diff --git a/eco-core/core-plugin/src/main/java/com/willfp/reforges/ReforgesPlugin.java b/eco-core/core-plugin/src/main/java/com/willfp/reforges/ReforgesPlugin.java index a778e5e..8352b75 100644 --- a/eco-core/core-plugin/src/main/java/com/willfp/reforges/ReforgesPlugin.java +++ b/eco-core/core-plugin/src/main/java/com/willfp/reforges/ReforgesPlugin.java @@ -5,7 +5,10 @@ import com.willfp.eco.core.command.impl.PluginCommand; import com.willfp.eco.core.display.DisplayModule; import com.willfp.reforges.commands.CommandReforge; import com.willfp.reforges.display.ReforgesDisplay; +import com.willfp.reforges.reforges.Reforge; +import com.willfp.reforges.reforges.Reforges; import lombok.Getter; +import org.bukkit.event.HandlerList; import org.bukkit.event.Listener; import org.jetbrains.annotations.Nullable; @@ -27,6 +30,18 @@ public class ReforgesPlugin extends EcoPlugin { instance = this; } + @Override + protected void handleReload() { + for (Reforge reforge : Reforges.values()) { + HandlerList.unregisterAll(reforge); + this.getScheduler().runLater(() -> { + if (reforge.isEnabled()) { + this.getEventManager().registerListener(reforge); + } + }, 1); + } + } + @Override protected List loadListeners() { return Arrays.asList( diff --git a/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/Reforge.java b/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/Reforge.java index 8cd0d50..7f62d39 100644 --- a/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/Reforge.java +++ b/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/Reforge.java @@ -5,13 +5,15 @@ import com.willfp.eco.core.Prerequisite; import com.willfp.reforges.ReforgesPlugin; import com.willfp.reforges.config.ReforgeConfig; import com.willfp.reforges.reforges.meta.ReforgeTarget; +import com.willfp.reforges.reforges.util.Watcher; import lombok.AccessLevel; import lombok.Getter; +import org.bukkit.event.Listener; import org.jetbrains.annotations.NotNull; import java.util.Objects; -public abstract class Reforge { +public abstract class Reforge implements Listener, Watcher { /** * Instance of Reforges for reforges to be able to access. */ @@ -36,6 +38,18 @@ public abstract class Reforge { @Getter private boolean enabled; + /** + * The display name. + */ + @Getter + private String name; + + /** + * The display name. + */ + @Getter + private String description; + /** * Create a new Reforge. * @@ -61,6 +75,8 @@ public abstract class Reforge { */ public void update() { enabled = config.getBool("enabled"); + name = config.getString("name"); + description = config.getString("description"); postUpdate(); } diff --git a/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/Reforges.java b/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/Reforges.java index 8655745..11d7291 100644 --- a/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/Reforges.java +++ b/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/Reforges.java @@ -4,6 +4,7 @@ import com.google.common.collect.BiMap; import com.google.common.collect.HashBiMap; import com.google.common.collect.ImmutableSet; import com.willfp.eco.core.config.updating.ConfigUpdater; +import com.willfp.reforges.reforges.reforges.ReforgeSharp; import lombok.experimental.UtilityClass; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -15,11 +16,11 @@ import java.util.Set; @SuppressWarnings({"unused", "checkstyle:JavadocVariable"}) public class Reforges { public static final String CONFIG_LOCATION = "config."; - public static final String OBTAINING_LOCATION = "obtaining."; - public static final String GENERAL_LOCATION = "general-config."; private static final BiMap BY_KEY = HashBiMap.create(); + public static final Reforge SHARP = new ReforgeSharp(); + /** * Get all registered {@link Reforge}s. * diff --git a/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/meta/ReforgeTarget.java b/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/meta/ReforgeTarget.java index 2ec7bcc..5c1fa7e 100644 --- a/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/meta/ReforgeTarget.java +++ b/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/meta/ReforgeTarget.java @@ -6,6 +6,7 @@ import com.willfp.reforges.ReforgesPlugin; import lombok.Getter; import org.bukkit.Material; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import java.util.HashSet; import java.util.Objects; @@ -110,6 +111,18 @@ public class ReforgeTarget { return matching.orElse(null); } + /** + * Get target from material. + * + * @param material The material. + * @return The target. + */ + @Nullable + public static ReforgeTarget getForMaterial(@NotNull final Material material) { + Optional matching = REGISTERED.stream().filter(rarity -> rarity.getMaterials().contains(material)).findFirst(); + return matching.orElse(null); + } + /** * Update all targets. * diff --git a/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/reforges/ReforgeSharp.java b/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/reforges/ReforgeSharp.java index b2d1f8e..dc3291e 100644 --- a/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/reforges/ReforgeSharp.java +++ b/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/reforges/ReforgeSharp.java @@ -1,7 +1,11 @@ package com.willfp.reforges.reforges.reforges; import com.willfp.reforges.reforges.Reforge; +import com.willfp.reforges.reforges.Reforges; import com.willfp.reforges.reforges.meta.ReforgeTarget; +import org.bukkit.entity.LivingEntity; +import org.bukkit.event.entity.EntityDamageByEntityEvent; +import org.jetbrains.annotations.NotNull; public class ReforgeSharp extends Reforge { public ReforgeSharp() { @@ -12,4 +16,11 @@ public class ReforgeSharp extends Reforge { public ReforgeTarget getTarget() { return ReforgeTarget.MELEE; } + + @Override + public void onMeleeAttack(@NotNull final LivingEntity attacker, + @NotNull final LivingEntity victim, + @NotNull final EntityDamageByEntityEvent event) { + event.setDamage(event.getDamage() * this.getConfig().getDouble(Reforges.CONFIG_LOCATION + "multiplier")); + } } diff --git a/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/ReforgeUtils.java b/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/ReforgeUtils.java index 70a2509..bff73ec 100644 --- a/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/ReforgeUtils.java +++ b/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/ReforgeUtils.java @@ -4,6 +4,7 @@ import com.willfp.eco.core.EcoPlugin; import com.willfp.reforges.ReforgesPlugin; import com.willfp.reforges.reforges.Reforge; import com.willfp.reforges.reforges.Reforges; +import com.willfp.reforges.reforges.meta.ReforgeTarget; import lombok.experimental.UtilityClass; import org.bukkit.NamespacedKey; import org.bukkit.inventory.ItemStack; @@ -13,6 +14,10 @@ import org.bukkit.persistence.PersistentDataType; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + @UtilityClass public class ReforgeUtils { /** @@ -25,6 +30,25 @@ public class ReforgeUtils { */ private static final NamespacedKey REFORGE_KEY = PLUGIN.getNamespacedKeyFactory().create("reforge"); + /** + * Get a random reforge for a target. + * + * @param target The target. + */ + public static Reforge getRandomReforge(@NotNull final ReforgeTarget target) { + List applicable = new ArrayList<>(); + + for (Reforge reforge : Reforges.values()) { + if (reforge.getTarget().equals(target)) { + applicable.add(reforge); + } + } + + Collections.shuffle(applicable); + + return applicable.get(0); + } + /** * Get reforge on an item. * diff --git a/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/Watcher.java b/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/Watcher.java new file mode 100644 index 0000000..19a0c8b --- /dev/null +++ b/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/Watcher.java @@ -0,0 +1,154 @@ +package com.willfp.reforges.reforges.util; + +import org.bukkit.entity.Arrow; +import org.bukkit.entity.LivingEntity; +import org.bukkit.entity.Player; +import org.bukkit.entity.Projectile; +import org.bukkit.entity.Trident; +import org.bukkit.event.entity.EntityDamageByEntityEvent; +import org.bukkit.event.entity.EntityDamageEvent; +import org.bukkit.event.entity.EntityShootBowEvent; +import org.bukkit.event.entity.ProjectileHitEvent; +import org.bukkit.event.entity.ProjectileLaunchEvent; +import org.bukkit.event.player.PlayerMoveEvent; +import org.jetbrains.annotations.NotNull; + +@SuppressWarnings("unused") +public interface Watcher { + /** + * Called when an entity shoots another entity with an arrow. + * + * @param attacker The shooter. + * @param victim The victim. + * @param arrow The arrow entity. + * @param event The event that called this watcher. + */ + default void onArrowDamage(@NotNull final LivingEntity attacker, + @NotNull final LivingEntity victim, + @NotNull final Arrow arrow, + @NotNull final EntityDamageByEntityEvent event) { + // Empty default as enchantments only override required watchers. + } + + /** + * Called when an entity damages another entity with a trident throw. + * + * @param attacker The shooter. + * @param victim The victim. + * @param trident The trident entity. + * @param event The event that called this watcher. + */ + default void onTridentDamage(@NotNull final LivingEntity attacker, + @NotNull final LivingEntity victim, + @NotNull final Trident trident, + @NotNull final EntityDamageByEntityEvent event) { + // Empty default as enchantments only override required watchers. + } + + /** + * Called when a player jumps. + * + * @param player The player. + * @param event The event that called this watcher. + */ + default void onJump(@NotNull final Player player, + @NotNull final PlayerMoveEvent event) { + // Empty default as enchantments only override required watchers. + } + + /** + * Called when an entity attacks another entity with a melee attack. + * + * @param attacker The attacker. + * @param victim The victim. + * @param event The event that called this watcher. + */ + default void onMeleeAttack(@NotNull final LivingEntity attacker, + @NotNull final LivingEntity victim, + @NotNull final EntityDamageByEntityEvent event) { + // Empty default as enchantments only override required watchers. + } + + /** + * Called when an entity shoots a bow. + * + * @param shooter The entity that shot the bow. + * @param arrow The arrow that was shot. + * @param event The event that called this watcher. + */ + default void onBowShoot(@NotNull final LivingEntity shooter, + @NotNull final Arrow arrow, + @NotNull final EntityShootBowEvent event) { + // Empty default as enchantments only override required watchers. + } + + /** + * Called when an entity shoots a projectile. + * + * @param shooter The entity that shot the bow. + * @param projectile The projectile that was shot. + * @param event The event that called this watcher. + */ + default void onProjectileLaunch(@NotNull final LivingEntity shooter, + @NotNull final Projectile projectile, + @NotNull final ProjectileLaunchEvent event) { + // Empty default as enchantments only override required watchers. + } + + /** + * Called when an entity takes fall damage. + * + * @param faller The entity that took the fall damage. + * @param event The event that called this watcher. + */ + default void onFallDamage(@NotNull final LivingEntity faller, + @NotNull final EntityDamageEvent event) { + // Empty default as enchantments only override required watchers. + } + + /** + * Called when an arrow hits a block or entity. + * + * @param shooter The entity that shot the arrow. + * @param event The event that called this watcher. + */ + default void onArrowHit(@NotNull final LivingEntity shooter, + @NotNull final ProjectileHitEvent event) { + // Empty default as enchantments only override required watchers. + } + + /** + * Called when a trident hits a block or entity. + * + * @param shooter The entity that threw the trident. + * @param event The event that called this watcher. + */ + default void onTridentHit(@NotNull final LivingEntity shooter, + @NotNull final ProjectileHitEvent event) { + // Empty default as enchantments only override required watchers. + } + + /** + * Called when an entity takes damage wearing armor. + * + * @param victim The entity that took damage. + * @param event The event that called this watcher. + */ + default void onDamageWearingArmor(@NotNull final LivingEntity victim, + @NotNull final EntityDamageEvent event) { + // Empty default as enchantments only override required watchers. + } + + /** + * Called when an entity throws a trident. + * + * @param shooter The entity that threw the trident. + * @param trident The trident that was thrown. + * @param event The event that called this watcher. + */ + default void onTridentLaunch(@NotNull final LivingEntity shooter, + @NotNull final Trident trident, + @NotNull final ProjectileLaunchEvent event) { + // Empty default as enchantments only override required watchers. + } +} diff --git a/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/WatcherTriggers.java b/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/WatcherTriggers.java new file mode 100644 index 0000000..6abf985 --- /dev/null +++ b/eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/WatcherTriggers.java @@ -0,0 +1,465 @@ +package com.willfp.reforges.reforges.util; + +import com.willfp.eco.core.EcoPlugin; +import com.willfp.eco.core.PluginDependent; +import com.willfp.eco.core.events.PlayerJumpEvent; +import com.willfp.eco.core.integrations.antigrief.AntigriefManager; +import com.willfp.eco.core.integrations.mcmmo.McmmoManager; +import com.willfp.eco.util.ArrowUtils; +import com.willfp.reforges.reforges.Reforge; +import org.bukkit.entity.AbstractArrow; +import org.bukkit.entity.Arrow; +import org.bukkit.entity.EntityType; +import org.bukkit.entity.LivingEntity; +import org.bukkit.entity.Player; +import org.bukkit.entity.Projectile; +import org.bukkit.entity.Trident; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.EntityDamageByEntityEvent; +import org.bukkit.event.entity.EntityDamageEvent; +import org.bukkit.event.entity.EntityShootBowEvent; +import org.bukkit.event.entity.ProjectileHitEvent; +import org.bukkit.event.entity.ProjectileLaunchEvent; +import org.bukkit.inventory.EntityEquipment; +import org.bukkit.inventory.ItemStack; +import org.jetbrains.annotations.NotNull; + +public class WatcherTriggers extends PluginDependent implements Listener { + /** + * Create new listener for watcher events. + * + * @param plugin The plugin to link the events to. + */ + public WatcherTriggers(@NotNull final EcoPlugin plugin) { + super(plugin); + } + + /** + * Called when an entity shoots another entity with an arrow. + * + * @param event The event to listen for. + */ + @EventHandler(ignoreCancelled = true) + public void onArrowDamage(@NotNull final EntityDamageByEntityEvent event) { + if (McmmoManager.isFake(event)) { + return; + } + + if (!(event.getDamager() instanceof Arrow arrow)) { + return; + } + + if (!(event.getEntity() instanceof LivingEntity victim)) { + return; + } + + if (arrow.getShooter() == null) { + return; + } + + if (!(arrow.getShooter() instanceof LivingEntity attacker)) { + return; + } + + if (attacker instanceof Player && !AntigriefManager.canInjure((Player) attacker, victim)) { + return; + } + + if (event.isCancelled()) { + return; + } + + ItemStack bow = ArrowUtils.getBow(arrow); + + if (bow == null) { + return; + } + + Reforge reforge = ReforgeUtils.getReforge(bow); + + if (reforge == null) { + return; + } + + reforge.onArrowDamage(attacker, victim, arrow, event); + } + + /** + * Called when an entity damages another entity with a trident throw. + * + * @param event The event to listen for. + */ + @EventHandler(ignoreCancelled = true) + public void onTridentDamage(@NotNull final EntityDamageByEntityEvent event) { + if (McmmoManager.isFake(event)) { + return; + } + + if (!(event.getDamager() instanceof Trident trident)) { + return; + } + + if (!(((Trident) event.getDamager()).getShooter() instanceof LivingEntity attacker)) { + return; + } + + if (((Trident) event.getDamager()).getShooter() == null) { + return; + } + + if (!(event.getEntity() instanceof LivingEntity victim)) { + return; + } + + if (event.isCancelled()) { + return; + } + + ItemStack item = trident.getItem(); + + if (attacker instanceof Player && !AntigriefManager.canInjure((Player) attacker, victim)) { + return; + } + + Reforge reforge = ReforgeUtils.getReforge(item); + + if (reforge == null) { + return; + } + + reforge.onTridentDamage(attacker, victim, trident, event); + } + + /** + * Called when a player jumps. + * + * @param event The event to listen for. + */ + @EventHandler(ignoreCancelled = true) + public void onJump(@NotNull final PlayerJumpEvent event) { + if (McmmoManager.isFake(event)) { + return; + } + + Player player = event.getPlayer(); + + for (ItemStack itemStack : player.getInventory().getArmorContents()) { + if (itemStack == null) { + continue; + } + + Reforge reforge = ReforgeUtils.getReforge(itemStack); + + if (reforge == null) { + continue; + } + + reforge.onJump(player, event); + } + } + + /** + * Called when an entity attacks another entity with a melee attack. + * + * @param event The event to listen for. + */ + @EventHandler(ignoreCancelled = true) + public void onMeleeAttack(@NotNull final EntityDamageByEntityEvent event) { + if (McmmoManager.isFake(event)) { + return; + } + + if (!(event.getDamager() instanceof LivingEntity attacker)) { + return; + } + + if (!(event.getEntity() instanceof LivingEntity victim)) { + return; + } + + if (event.isCancelled()) { + return; + } + + if (event.getCause() == EntityDamageEvent.DamageCause.THORNS) { + return; + } + + if (attacker instanceof Player && !AntigriefManager.canInjure((Player) attacker, victim)) { + return; + } + + EntityEquipment entityEquipment = attacker.getEquipment(); + + if (entityEquipment == null) { + return; + } + + Reforge reforge = ReforgeUtils.getReforge(entityEquipment.getItemInMainHand()); + + if (reforge == null) { + return; + } + + reforge.onMeleeAttack(attacker, victim, event); + } + + /** + * Called when an entity shoots a bow. + * + * @param event The event to listen for. + */ + @EventHandler(ignoreCancelled = true) + public void onBowShoot(@NotNull final EntityShootBowEvent event) { + if (McmmoManager.isFake(event)) { + return; + } + + if (event.getProjectile().getType() != EntityType.ARROW) { + return; + } + + LivingEntity shooter = event.getEntity(); + Arrow arrow = (Arrow) event.getProjectile(); + + ItemStack bow = ArrowUtils.getBow(arrow); + + if (bow == null) { + return; + } + + Reforge reforge = ReforgeUtils.getReforge(bow); + + if (reforge == null) { + return; + } + + reforge.onBowShoot(shooter, arrow, event); + } + + /** + * Called when an entity launches a projectile. + * + * @param event The event to listen for. + */ + @EventHandler(ignoreCancelled = true) + public void onProjectileLaunch(@NotNull final ProjectileLaunchEvent event) { + if (McmmoManager.isFake(event)) { + return; + } + + if (!(event.getEntity() instanceof AbstractArrow)) { + return; + } + + if (!(event.getEntity().getShooter() instanceof Player)) { + return; + } + + LivingEntity shooter = (LivingEntity) event.getEntity().getShooter(); + + Projectile projectile = event.getEntity(); + + if (shooter.getEquipment() == null) { + return; + } + + ItemStack item = shooter.getEquipment().getItemInMainHand(); + + if (projectile instanceof Trident trident) { + item = trident.getItem(); + } + + Reforge reforge = ReforgeUtils.getReforge(item); + + if (reforge == null) { + return; + } + + reforge.onProjectileLaunch(shooter, projectile, event); + } + + /** + * Called when an entity takes fall damage. + * + * @param event The event to listen for. + */ + @EventHandler(ignoreCancelled = true) + public void onFallDamage(@NotNull final EntityDamageEvent event) { + if (McmmoManager.isFake(event)) { + return; + } + + if (!event.getCause().equals(EntityDamageEvent.DamageCause.FALL)) { + return; + } + + if (!(event.getEntity() instanceof LivingEntity victim)) { + return; + } + + EntityEquipment entityEquipment = victim.getEquipment(); + + if (entityEquipment == null) { + return; + } + + for (ItemStack itemStack : entityEquipment.getArmorContents()) { + if (itemStack == null) { + continue; + } + + Reforge reforge = ReforgeUtils.getReforge(itemStack); + + if (reforge == null) { + continue; + } + + reforge.onFallDamage(victim, event); + } + } + + /** + * Called when an arrow hits a block or entity. + * + * @param event The event to listen for. + */ + @EventHandler(ignoreCancelled = true) + public void onArrowHit(@NotNull final ProjectileHitEvent event) { + if (McmmoManager.isFake(event)) { + return; + } + + if (!(event.getEntity().getShooter() instanceof LivingEntity shooter)) { + return; + } + + if (!(event.getEntity() instanceof Arrow arrow)) { + return; + } + + if (event.getEntity().getShooter() == null) { + return; + } + + ItemStack bow = ArrowUtils.getBow(arrow); + + if (bow == null) { + return; + } + + Reforge reforge = ReforgeUtils.getReforge(bow); + + if (reforge == null) { + return; + } + + reforge.onArrowHit(shooter, event); + } + + /** + * Called when a trident hits a block or entity. + * + * @param event The event to listen for. + */ + @EventHandler(ignoreCancelled = true) + public void onTridentHit(@NotNull final ProjectileHitEvent event) { + if (McmmoManager.isFake(event)) { + return; + } + + if (!(event.getEntity().getShooter() instanceof LivingEntity shooter)) { + return; + } + + if (event.getEntity().getShooter() == null) { + return; + } + + if (!(event.getEntity() instanceof Trident trident)) { + return; + } + + ItemStack item = trident.getItem(); + + Reforge reforge = ReforgeUtils.getReforge(item); + + if (reforge == null) { + return; + } + + reforge.onTridentHit(shooter, event); + } + + /** + * Called when an entity takes damage wearing armor. + * + * @param event The event to listen for. + */ + @EventHandler(ignoreCancelled = true) + public void onDamageWearingArmor(@NotNull final EntityDamageEvent event) { + if (McmmoManager.isFake(event)) { + return; + } + + if (!(event.getEntity() instanceof LivingEntity victim)) { + return; + } + + EntityEquipment entityEquipment = victim.getEquipment(); + + if (entityEquipment == null) { + return; + } + + for (ItemStack itemStack : entityEquipment.getArmorContents()) { + if (itemStack == null) { + continue; + } + + Reforge reforge = ReforgeUtils.getReforge(itemStack); + + if (reforge == null) { + continue; + } + + reforge.onDamageWearingArmor(victim, event); + } + } + + /** + * Called when an entity throws a trident. + * + * @param event The event to listen for. + */ + @EventHandler(ignoreCancelled = true) + public void onTridentLaunch(@NotNull final ProjectileLaunchEvent event) { + if (McmmoManager.isFake(event)) { + return; + } + + if (!(event.getEntity() instanceof Trident trident)) { + return; + } + + if (!(event.getEntity().getShooter() instanceof LivingEntity)) { + return; + } + + LivingEntity shooter = (LivingEntity) trident.getShooter(); + ItemStack item = trident.getItem(); + + if (shooter == null) { + return; + } + + Reforge reforge = ReforgeUtils.getReforge(item); + + if (reforge == null) { + return; + } + + reforge.onTridentLaunch(shooter, trident, event); + } +} diff --git a/eco-core/core-plugin/src/main/resources/config.yml b/eco-core/core-plugin/src/main/resources/config.yml index 27b291f..8fbc104 100644 --- a/eco-core/core-plugin/src/main/resources/config.yml +++ b/eco-core/core-plugin/src/main/resources/config.yml @@ -26,6 +26,14 @@ gui: reforge: cost: 5000 + display-in-item-name: true + display-in-lore: true + + lore-suffix: + - "" + - "&fReforge: %name%" + - "&8&o%description" + targets: melee: - wooden_axe diff --git a/eco-core/core-plugin/src/main/resources/lang.yml b/eco-core/core-plugin/src/main/resources/lang.yml index 47296ef..56dc0aa 100644 --- a/eco-core/core-plugin/src/main/resources/lang.yml +++ b/eco-core/core-plugin/src/main/resources/lang.yml @@ -3,9 +3,4 @@ messages: no-permission: "&cYou don't have permission to do this!" not-player: "&cThis command must be run by a player" invalid-command: "&cUnknown subcommand!" - reloaded: "Reloaded! (Restart if you're removed weapons!)" - needs-player: "&cYou must specify a player" - invalid-player: "&cInvalid player!" - needs-item: "&cYou must specify an item!" - invalid-item: "&cInvalid item!" - give-success: "Gave &a%item%&r to &a%recipient%" + reloaded: "Reloaded! (Restart if you're removed weapons!)" \ No newline at end of file diff --git a/eco-core/core-plugin/src/main/resources/reforges/sharp.yml b/eco-core/core-plugin/src/main/resources/reforges/sharp.yml index 0902765..0d83533 100644 --- a/eco-core/core-plugin/src/main/resources/reforges/sharp.yml +++ b/eco-core/core-plugin/src/main/resources/reforges/sharp.yml @@ -4,7 +4,7 @@ name: "&6Sharp" enabled: true -description: "Deal &a3%&r more damage" +description: "Deal &a3%&8&o more damage" config: multiplier: 1.03 # Damage multiplier \ No newline at end of file