From 5bf8c990bd931d017fe36625de02f695d27cfaf2 Mon Sep 17 00:00:00 2001 From: Chin-Hung Lee Date: Mon, 19 Apr 2021 22:25:15 +0800 Subject: [PATCH] init update to git --- .classpath | 24 + .project | 23 + .settings/org.eclipse.core.resources.prefs | 3 + .settings/org.eclipse.jdt.core.prefs | 16 + .../org.eclipse.ltk.core.refactoring.prefs | 2 + .settings/org.eclipse.m2e.core.prefs | 4 + blocked.yml | 66 ++ config.yml | 38 + forge.yml | 13 + mobs.yml | 7 + plugin.yml | 37 + pom.xml | 38 + races.yml | 44 + skills.yml | 9 + .../armorequip/AfterArmorEquipEvent.java | 28 + .../armorequip/ArmorEquipEvent.java | 141 +++ .../armorequip/ArmorListener.java | 291 ++++++ .../armorequip/ArmorType.java | 38 + .../armorequip/DispenserArmorListener.java | 43 + src/main/java/nashi/NRPG/API/SkillAPI.java | 346 +++++++ src/main/java/nashi/NRPG/API/Utils.java | 370 +++++++ .../nashi/NRPG/Commands/AbandonCommand.java | 69 ++ .../java/nashi/NRPG/Commands/CastCommand.java | 39 + .../java/nashi/NRPG/Commands/Commands.java | 407 ++++++++ .../java/nashi/NRPG/Commands/RaceCommand.java | 105 ++ .../nashi/NRPG/Commands/ResetCommand.java | 49 + .../nashi/NRPG/Commands/ScaleCommand.java | 36 + .../nashi/NRPG/Commands/SkillEditCommand.java | 46 + .../nashi/NRPG/Commands/SkillSlotCommand.java | 64 ++ .../java/nashi/NRPG/Commands/StatCommand.java | 57 ++ .../nashi/NRPG/CustomEvents/CastEvent.java | 49 + .../NRPG/CustomEvents/CastStartEvent.java | 68 ++ .../NRPG/CustomEvents/PreSkillUseEvent.java | 56 + .../NRPG/CustomEvents/RaceChangeEvent.java | 41 + .../CustomEvents/SkillItemGenerateEvent.java | 40 + .../NRPG/CustomEvents/SkillLearnEvent.java | 33 + .../NRPG/CustomEvents/SkillUsedEvent.java | 39 + .../java/nashi/NRPG/Items/CreateItem.java | 303 ++++++ src/main/java/nashi/NRPG/Main.java | 297 ++++++ .../java/nashi/NRPG/Players/Leveling.java | 64 ++ src/main/java/nashi/NRPG/Players/Players.java | 528 ++++++++++ src/main/java/nashi/NRPG/Players/Races.java | 355 +++++++ src/main/java/nashi/NRPG/Skills/Cast.java | 80 ++ src/main/java/nashi/NRPG/Skills/GUI.java | 162 +++ src/main/java/nashi/NRPG/Skills/Magic.java | 219 ++++ src/main/java/nashi/NRPG/Skills/NewSkill.java | 72 ++ src/main/java/nashi/NRPG/Skills/Skill.java | 104 ++ .../java/nashi/NRPG/Skills/SkillItem.java | 123 +++ .../java/nashi/NRPG/Skills/SkillName.java | 20 + .../nashi/NRPG/listeners/AllAboutDamage.java | 174 ++++ .../nashi/NRPG/listeners/EventListener.java | 962 ++++++++++++++++++ .../nashi/NRPG/listeners/ForgeListener.java | 597 +++++++++++ .../java/nashi/NRPG/listeners/ModifyItem.java | 680 +++++++++++++ .../NRPG/listeners/MythicMobsListener.java | 112 ++ .../NRPG/listeners/ProtocolLibEvent.java | 41 + .../NRPG/listeners/SkillItemListener.java | 141 +++ target/classes/.gitignore | 2 + target/test-classes/nashi/NRPG/AppTest.class | Bin 0 -> 1290 bytes 58 files changed, 7815 insertions(+) create mode 100644 .classpath create mode 100644 .project create mode 100644 .settings/org.eclipse.core.resources.prefs create mode 100644 .settings/org.eclipse.jdt.core.prefs create mode 100644 .settings/org.eclipse.ltk.core.refactoring.prefs create mode 100644 .settings/org.eclipse.m2e.core.prefs create mode 100644 blocked.yml create mode 100644 config.yml create mode 100644 forge.yml create mode 100644 mobs.yml create mode 100644 plugin.yml create mode 100644 pom.xml create mode 100644 races.yml create mode 100644 skills.yml create mode 100644 src/main/java/edited/com/codingforcookies/armorequip/AfterArmorEquipEvent.java create mode 100644 src/main/java/edited/com/codingforcookies/armorequip/ArmorEquipEvent.java create mode 100644 src/main/java/edited/com/codingforcookies/armorequip/ArmorListener.java create mode 100644 src/main/java/edited/com/codingforcookies/armorequip/ArmorType.java create mode 100644 src/main/java/edited/com/codingforcookies/armorequip/DispenserArmorListener.java create mode 100644 src/main/java/nashi/NRPG/API/SkillAPI.java create mode 100644 src/main/java/nashi/NRPG/API/Utils.java create mode 100644 src/main/java/nashi/NRPG/Commands/AbandonCommand.java create mode 100644 src/main/java/nashi/NRPG/Commands/CastCommand.java create mode 100644 src/main/java/nashi/NRPG/Commands/Commands.java create mode 100644 src/main/java/nashi/NRPG/Commands/RaceCommand.java create mode 100644 src/main/java/nashi/NRPG/Commands/ResetCommand.java create mode 100644 src/main/java/nashi/NRPG/Commands/ScaleCommand.java create mode 100644 src/main/java/nashi/NRPG/Commands/SkillEditCommand.java create mode 100644 src/main/java/nashi/NRPG/Commands/SkillSlotCommand.java create mode 100644 src/main/java/nashi/NRPG/Commands/StatCommand.java create mode 100644 src/main/java/nashi/NRPG/CustomEvents/CastEvent.java create mode 100644 src/main/java/nashi/NRPG/CustomEvents/CastStartEvent.java create mode 100644 src/main/java/nashi/NRPG/CustomEvents/PreSkillUseEvent.java create mode 100644 src/main/java/nashi/NRPG/CustomEvents/RaceChangeEvent.java create mode 100644 src/main/java/nashi/NRPG/CustomEvents/SkillItemGenerateEvent.java create mode 100644 src/main/java/nashi/NRPG/CustomEvents/SkillLearnEvent.java create mode 100644 src/main/java/nashi/NRPG/CustomEvents/SkillUsedEvent.java create mode 100644 src/main/java/nashi/NRPG/Items/CreateItem.java create mode 100644 src/main/java/nashi/NRPG/Main.java create mode 100644 src/main/java/nashi/NRPG/Players/Leveling.java create mode 100644 src/main/java/nashi/NRPG/Players/Players.java create mode 100644 src/main/java/nashi/NRPG/Players/Races.java create mode 100644 src/main/java/nashi/NRPG/Skills/Cast.java create mode 100644 src/main/java/nashi/NRPG/Skills/GUI.java create mode 100644 src/main/java/nashi/NRPG/Skills/Magic.java create mode 100644 src/main/java/nashi/NRPG/Skills/NewSkill.java create mode 100644 src/main/java/nashi/NRPG/Skills/Skill.java create mode 100644 src/main/java/nashi/NRPG/Skills/SkillItem.java create mode 100644 src/main/java/nashi/NRPG/Skills/SkillName.java create mode 100644 src/main/java/nashi/NRPG/listeners/AllAboutDamage.java create mode 100644 src/main/java/nashi/NRPG/listeners/EventListener.java create mode 100644 src/main/java/nashi/NRPG/listeners/ForgeListener.java create mode 100644 src/main/java/nashi/NRPG/listeners/ModifyItem.java create mode 100644 src/main/java/nashi/NRPG/listeners/MythicMobsListener.java create mode 100644 src/main/java/nashi/NRPG/listeners/ProtocolLibEvent.java create mode 100644 src/main/java/nashi/NRPG/listeners/SkillItemListener.java create mode 100644 target/classes/.gitignore create mode 100644 target/test-classes/nashi/NRPG/AppTest.class diff --git a/.classpath b/.classpath new file mode 100644 index 0000000..50ec34d --- /dev/null +++ b/.classpath @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/.project b/.project new file mode 100644 index 0000000..acce0b5 --- /dev/null +++ b/.project @@ -0,0 +1,23 @@ + + + ModRPG-git + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.m2e.core.maven2Builder + + + + + + org.eclipse.jdt.core.javanature + org.eclipse.m2e.core.maven2Nature + + diff --git a/.settings/org.eclipse.core.resources.prefs b/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 0000000..e9441bb --- /dev/null +++ b/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,3 @@ +eclipse.preferences.version=1 +encoding//src/main/java=UTF-8 +encoding/=UTF-8 diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..fbf1aac --- /dev/null +++ b/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,16 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate +org.eclipse.jdt.core.compiler.codegen.targetPlatform=11 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=11 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning +org.eclipse.jdt.core.compiler.release=enabled +org.eclipse.jdt.core.compiler.source=11 diff --git a/.settings/org.eclipse.ltk.core.refactoring.prefs b/.settings/org.eclipse.ltk.core.refactoring.prefs new file mode 100644 index 0000000..b196c64 --- /dev/null +++ b/.settings/org.eclipse.ltk.core.refactoring.prefs @@ -0,0 +1,2 @@ +eclipse.preferences.version=1 +org.eclipse.ltk.core.refactoring.enable.project.refactoring.history=false diff --git a/.settings/org.eclipse.m2e.core.prefs b/.settings/org.eclipse.m2e.core.prefs new file mode 100644 index 0000000..f897a7f --- /dev/null +++ b/.settings/org.eclipse.m2e.core.prefs @@ -0,0 +1,4 @@ +activeProfiles= +eclipse.preferences.version=1 +resolveWorkspaceProjects=true +version=1 diff --git a/blocked.yml b/blocked.yml new file mode 100644 index 0000000..bfcdba3 --- /dev/null +++ b/blocked.yml @@ -0,0 +1,66 @@ +# All blocks with an inventory or any blocks that when right clicked shouldn't equip armor. +blocked: + - FURNACE + - CHEST + - TRAPPED_CHEST + - BEACON + - DISPENSER + - DROPPER + - HOPPER + - WORKBENCH + - ENCHANTMENT_TABLE + - ENDER_CHEST + - ANVIL + - BED_BLOCK + - FENCE_GATE + - SPRUCE_FENCE_GATE + - BIRCH_FENCE_GATE + - ACACIA_FENCE_GATE + - JUNGLE_FENCE_GATE + - DARK_OAK_FENCE_GATE + - IRON_DOOR_BLOCK + - WOODEN_DOOR + - SPRUCE_DOOR + - BIRCH_DOOR + - JUNGLE_DOOR + - ACACIA_DOOR + - DARK_OAK_DOOR + - WOOD_BUTTON + - STONE_BUTTON + - TRAP_DOOR + - IRON_TRAPDOOR + - DIODE_BLOCK_OFF + - DIODE_BLOCK_ON + - REDSTONE_COMPARATOR_OFF + - REDSTONE_COMPARATOR_ON + - FENCE + - SPRUCE_FENCE + - BIRCH_FENCE + - JUNGLE_FENCE + - DARK_OAK_FENCE + - ACACIA_FENCE + - NETHER_FENCE + - BREWING_STAND + - CAULDRON + - SIGN_POST + - WALL_SIGN + - SIGN + - LEVER + - BLACK_SHULKER_BOX + - BLUE_SHULKER_BOX + - BROWN_SHULKER_BOX + - CYAN_SHULKER_BOX + - GRAY_SHULKER_BOX + - GREEN_SHULKER_BOX + - LIGHT_BLUE_SHULKER_BOX + - LIME_SHULKER_BOX + - MAGENTA_SHULKER_BOX + - ORANGE_SHULKER_BOX + - PINK_SHULKER_BOX + - PURPLE_SHULKER_BOX + - RED_SHULKER_BOX + - SILVER_SHULKER_BOX + - WHITE_SHULKER_BOX + - YELLOW_SHULKER_BOX + - DAYLIGHT_DETECTOR_INVERTED + - DAYLIGHT_DETECTOR diff --git a/config.yml b/config.yml new file mode 100644 index 0000000..06a6f33 --- /dev/null +++ b/config.yml @@ -0,0 +1,38 @@ +ManaDamage: 10 +TimeLimit: 60000 +SpeedMod: 0.015 +HPMod: 1 +MPMod: 1 +LUKAVD: 5 +LUKCRIT: 10 +BaseHP: 100 +BaseMP: 50 +BaseSpeed: 0.2 +ATKMod: 1 +SlotExpandRate: 0 +MaxSlot: 4 +MaxForge: 30 +RateOfNote: 20 +ManaRecover: 15 +HPRecover: 10 +DefaultAttackRange: 2 +HungerDamage: 15 +enableLeftAttack: true +NoTick: true +Worlds: + - test1 + - lottery +LeakArmorMod: 0.1 +ArrowEnchMod: 0.1 +StatusRandomMax: 3 +RequiredDamageDueToMobs: 0.3 +DeathPenaltyWorlds: + - world +Penalty: + LevelLose: true + ClearRace: false + ResetStatus: true + MakeUp: true +MakeUpSkills: + - ReturnsByDeath +MakeUpMod: 0.3 \ No newline at end of file diff --git a/forge.yml b/forge.yml new file mode 100644 index 0000000..ec4e546 --- /dev/null +++ b/forge.yml @@ -0,0 +1,13 @@ +max: + slot: +Random: + tier: + 0: + ... + 5: +technique: + slot: + tier: + 0: + ... + 24: \ No newline at end of file diff --git a/mobs.yml b/mobs.yml new file mode 100644 index 0000000..91da9a6 --- /dev/null +++ b/mobs.yml @@ -0,0 +1,7 @@ +level: + Method1: + MobType: Amount + MobType: Amount + Method2: + MobType: Amount + MobType: Amount diff --git a/plugin.yml b/plugin.yml new file mode 100644 index 0000000..a0cb67c --- /dev/null +++ b/plugin.yml @@ -0,0 +1,37 @@ +main: nashi.NRPG.Main +api-version: 1.14 +name: NRPG +version: '2.0' +description: RPG plugin with potion, races and skills +softdepend: +- MythicMobs +- ProtocolLib +author: Nashi +commands: + nrpg: + description: base command + usage: /nrpg + stat: + description: stat command + usage: /stat + skilledit: + description: edit skill command + usage: /skilledit + cast: + description: change cast time command + usage: /cast ticks + slot: + description: modify skillslot command + usage: /slot + scale: + description: modify heal scale command + usage: /scale + abandon: + description: abandon skill command + usage: /abandon + reset: + description: reset command + usage: /reset + race: + description: race command + usage: /race \ No newline at end of file diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..8a6d081 --- /dev/null +++ b/pom.xml @@ -0,0 +1,38 @@ + + 4.0.0 + + nashi + NRPG + 0.0.1-SNAPSHOT + jar + + NRPG + http://maven.apache.org + + + UTF-8 + + + + spigotmc-repo + https://hub.spigotmc.org/nexus/content/repositories/snapshots/ + + + + dmulloy2-repo + http://repo.dmulloy2.net/nexus/repository/public/ + + + + + + + junit + junit + 3.8.1 + test + + + diff --git a/races.yml b/races.yml new file mode 100644 index 0000000..f1b2f97 --- /dev/null +++ b/races.yml @@ -0,0 +1,44 @@ +RaceName: + default: true + DisplayName: + Info: + SkillList: + - skillname + Mod: + Slot: + ATK: + LUK: + Speed: + MP: + HP: + Items: + Helmet: + enable: true + DisplayName: + Material: + Color: r,g,b + damage: + Chestplate: + enable: true + DisplayName: + Material: + Color: r,g,b + damage: + Leggings: + enable: true + DisplayName: + Material: + Color: r,g,b + damage: + Boots: + enable: true + DisplayName: + Material: + Color: r,g,b + damage: + OffHand: + enable: true + DisplayName: + Material: + Color: r,g,b + damage: \ No newline at end of file diff --git a/skills.yml b/skills.yml new file mode 100644 index 0000000..695b5cb --- /dev/null +++ b/skills.yml @@ -0,0 +1,9 @@ +Skillname: + Info: + var: double + CostMP: double + Description: String + Difficulty: int + Times: int + general: boolean + \ No newline at end of file diff --git a/src/main/java/edited/com/codingforcookies/armorequip/AfterArmorEquipEvent.java b/src/main/java/edited/com/codingforcookies/armorequip/AfterArmorEquipEvent.java new file mode 100644 index 0000000..4563c2a --- /dev/null +++ b/src/main/java/edited/com/codingforcookies/armorequip/AfterArmorEquipEvent.java @@ -0,0 +1,28 @@ +package edited.com.codingforcookies.armorequip; + +import org.bukkit.entity.Player; +import org.bukkit.event.HandlerList; +import org.bukkit.event.player.PlayerEvent; + +public final class AfterArmorEquipEvent extends PlayerEvent { + private static final HandlerList handlers = new HandlerList(); + private static ArmorEquipEvent event; + + public AfterArmorEquipEvent(Player player, ArmorEquipEvent event) { + super(player); + AfterArmorEquipEvent.event = event; + } + + public static ArmorEquipEvent getEquipEvent() { + return event; + } + + public static final HandlerList getHandlerList() { + return handlers; + } + + public final HandlerList getHandlers() { + return handlers; + } + +} diff --git a/src/main/java/edited/com/codingforcookies/armorequip/ArmorEquipEvent.java b/src/main/java/edited/com/codingforcookies/armorequip/ArmorEquipEvent.java new file mode 100644 index 0000000..e403b10 --- /dev/null +++ b/src/main/java/edited/com/codingforcookies/armorequip/ArmorEquipEvent.java @@ -0,0 +1,141 @@ +package edited.com.codingforcookies.armorequip; + +import org.bukkit.entity.Player; +import org.bukkit.event.Cancellable; +import org.bukkit.event.HandlerList; +import org.bukkit.event.player.PlayerEvent; +import org.bukkit.inventory.ItemStack; + +/** + * @author Arnah + * @since Jul 30, 2015 + */ +public final class ArmorEquipEvent extends PlayerEvent implements Cancellable{ + + private static final HandlerList handlers = new HandlerList(); + private boolean cancel = false; + private final EquipMethod equipType; + private final ArmorType type; + private ItemStack oldArmorPiece, newArmorPiece; + + /** + * @param player The player who put on / removed the armor. + * @param type The ArmorType of the armor added + * @param oldArmorPiece The ItemStack of the armor removed. + * @param newArmorPiece The ItemStack of the armor added. + */ + public ArmorEquipEvent(final Player player, final EquipMethod equipType, final ArmorType type, final ItemStack oldArmorPiece, final ItemStack newArmorPiece){ + super(player); + this.equipType = equipType; + this.type = type; + this.oldArmorPiece = oldArmorPiece; + this.newArmorPiece = newArmorPiece; + } + + /** + * Gets a list of handlers handling this event. + * + * @return A list of handlers handling this event. + */ + public static HandlerList getHandlerList(){ + return handlers; + } + + /** + * Gets a list of handlers handling this event. + * + * @return A list of handlers handling this event. + */ + @Override + public final HandlerList getHandlers(){ + return handlers; + } + + /** + * Sets if this event should be cancelled. + * + * @param cancel If this event should be cancelled. + */ + public final void setCancelled(final boolean cancel){ + this.cancel = cancel; + } + + /** + * Gets if this event is cancelled. + * + * @return If this event is cancelled + */ + public final boolean isCancelled(){ + return cancel; + } + + public final ArmorType getType(){ + return type; + } + + /** + * Returns the last equipped armor piece, could be a piece of armor, or null + */ + public final ItemStack getOldArmorPiece(){ + return oldArmorPiece; + } + + public final void setOldArmorPiece(final ItemStack oldArmorPiece){ + this.oldArmorPiece = oldArmorPiece; + } + + /** + * Returns the newly equipped armor, could be a piece of armor, or null + */ + public final ItemStack getNewArmorPiece(){ + return newArmorPiece; + } + + public final void setNewArmorPiece(final ItemStack newArmorPiece){ + this.newArmorPiece = newArmorPiece; + } + + /** + * Gets the method used to either equip or unequip an armor piece. + */ + public EquipMethod getMethod(){ + return equipType; + } + + public enum EquipMethod{// These have got to be the worst documentations ever. + /** + * When you shift click an armor piece to equip or unequip + */ + SHIFT_CLICK, + /** + * When you drag and drop the item to equip or unequip + */ + DRAG, + /** + * When you manually equip or unequip the item. Use to be DRAG + */ + PICK_DROP, + /** + * When you right click an armor piece in the hotbar without the inventory open to equip. + */ + HOTBAR, + /** + * When you press the hotbar slot number while hovering over the armor slot to equip or unequip + */ + HOTBAR_SWAP, + /** + * When in range of a dispenser that shoots an armor piece to equip.
+ * Requires the spigot version to have {@link org.bukkit.event.block.BlockDispenseArmorEvent} implemented. + */ + DISPENSER, + /** + * When an armor piece is removed due to it losing all durability. + */ + BROKE, + /** + * When you die causing all armor to unequip + */ + DEATH, + ; + } +} \ No newline at end of file diff --git a/src/main/java/edited/com/codingforcookies/armorequip/ArmorListener.java b/src/main/java/edited/com/codingforcookies/armorequip/ArmorListener.java new file mode 100644 index 0000000..1fc53e9 --- /dev/null +++ b/src/main/java/edited/com/codingforcookies/armorequip/ArmorListener.java @@ -0,0 +1,291 @@ +package edited.com.codingforcookies.armorequip; + +import java.util.List; +import org.bukkit.Bukkit; +import org.bukkit.Material; +import org.bukkit.Sound; +import org.bukkit.entity.Player; +import org.bukkit.event.Event.Result; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.Action; +import org.bukkit.event.entity.PlayerDeathEvent; +import org.bukkit.event.inventory.ClickType; +import org.bukkit.event.inventory.InventoryAction; +import org.bukkit.event.inventory.InventoryClickEvent; +import org.bukkit.event.inventory.InventoryDragEvent; +import org.bukkit.event.inventory.InventoryType; +import org.bukkit.event.player.PlayerInteractEvent; +import org.bukkit.event.player.PlayerItemBreakEvent; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.Damageable; +import org.bukkit.inventory.meta.ItemMeta; + +import nashi.NRPG.Main; +import nashi.NRPG.API.Utils; + +public class ArmorListener implements Listener { + private final List blockedMaterials; + + public ArmorListener(List blockedMaterials) { + this.blockedMaterials = blockedMaterials; + } + + @EventHandler + public final void inventoryClick(InventoryClickEvent e) { + boolean shift = false; + boolean numberkey = false; + if (e.isCancelled()) { + return; + } + if (e.getAction() == InventoryAction.NOTHING) { + return; + } + if ((e.getClick().equals(ClickType.SHIFT_LEFT)) || (e.getClick().equals(ClickType.SHIFT_RIGHT))) { + shift = true; + } + if (e.getClick().equals(ClickType.NUMBER_KEY)) { + numberkey = true; + } + if ((e.getSlotType() != InventoryType.SlotType.ARMOR) && (e.getSlotType() != InventoryType.SlotType.QUICKBAR) + && (e.getSlotType() != InventoryType.SlotType.CONTAINER)) { + return; + } + if ((e.getClickedInventory() != null) && (!e.getClickedInventory().getType().equals(InventoryType.PLAYER))) { + return; + } + if ((!e.getInventory().getType().equals(InventoryType.CRAFTING)) + && (!e.getInventory().getType().equals(InventoryType.PLAYER))) { + return; + } + if (!(e.getWhoClicked() instanceof Player)) { + return; + } + ArmorType newArmorType = ArmorType.matchType(shift ? e.getCurrentItem() : e.getCursor()); + if ((!shift) && (newArmorType != null) && (e.getRawSlot() != newArmorType.getSlot())) { + return; + } + if (shift) { + newArmorType = ArmorType.matchType(e.getCurrentItem()); + if (newArmorType != null) { + boolean equipping = true; + if (e.getRawSlot() == newArmorType.getSlot()) { + equipping = false; + } + if ((!newArmorType.equals(ArmorType.HELMET)) + || (equipping ? !isAirOrNull(e.getWhoClicked().getInventory().getHelmet()) + : isAirOrNull(e.getWhoClicked().getInventory().getHelmet()))) { + if ((!newArmorType.equals(ArmorType.CHESTPLATE)) + || (equipping ? !isAirOrNull(e.getWhoClicked().getInventory().getChestplate()) + : isAirOrNull(e.getWhoClicked().getInventory().getChestplate()))) { + if ((!newArmorType.equals(ArmorType.LEGGINGS)) + || (equipping ? !isAirOrNull(e.getWhoClicked().getInventory().getLeggings()) + : isAirOrNull(e.getWhoClicked().getInventory().getLeggings()))) { + if ((!newArmorType.equals(ArmorType.BOOTS)) + || (equipping ? !isAirOrNull(e.getWhoClicked().getInventory().getBoots()) + : isAirOrNull(e.getWhoClicked().getInventory().getBoots()))) { + return; + } + } + } + } + ArmorEquipEvent armorEquipEvent = new ArmorEquipEvent((Player) e.getWhoClicked(), + ArmorEquipEvent.EquipMethod.SHIFT_CLICK, newArmorType, equipping ? null : e.getCurrentItem(), + equipping ? e.getCurrentItem() : null); + Bukkit.getServer().getPluginManager().callEvent(armorEquipEvent); + if (armorEquipEvent.isCancelled()) { + e.setCancelled(true); + } + Bukkit.getScheduler().scheduleSyncDelayedTask(Main.getPlugin(), new Runnable() { + @Override + public void run() { + AfterArmorEquipEvent ae = new AfterArmorEquipEvent((Player) e.getWhoClicked(), armorEquipEvent); + Bukkit.getServer().getPluginManager().callEvent(ae); + } + }, 5L); + } + } else { + ItemStack newArmorPiece = e.getCursor(); + ItemStack oldArmorPiece = e.getCurrentItem(); + if (numberkey) { + if (e.getClickedInventory().getType().equals(InventoryType.PLAYER)) { + ItemStack hotbarItem = e.getClickedInventory().getItem(e.getHotbarButton()); + if (!isAirOrNull(hotbarItem)) { + newArmorType = ArmorType.matchType(hotbarItem); + newArmorPiece = hotbarItem; + oldArmorPiece = e.getClickedInventory().getItem(e.getSlot()); + } else { + newArmorType = ArmorType + .matchType(!isAirOrNull(e.getCurrentItem()) ? e.getCurrentItem() : e.getCursor()); + } + } + } else if ((isAirOrNull(e.getCursor())) && (!isAirOrNull(e.getCurrentItem()))) { + newArmorType = ArmorType.matchType(e.getCurrentItem()); + } + if ((newArmorType != null) && (e.getRawSlot() == newArmorType.getSlot())) { + ArmorEquipEvent.EquipMethod method = ArmorEquipEvent.EquipMethod.PICK_DROP; + if ((e.getAction().equals(InventoryAction.HOTBAR_SWAP)) || (numberkey)) { + method = ArmorEquipEvent.EquipMethod.HOTBAR_SWAP; + } + ArmorEquipEvent armorEquipEvent = new ArmorEquipEvent((Player) e.getWhoClicked(), method, newArmorType, + oldArmorPiece, newArmorPiece); + Bukkit.getServer().getPluginManager().callEvent(armorEquipEvent); + if (armorEquipEvent.isCancelled()) { + e.setCancelled(true); + } + Bukkit.getScheduler().scheduleSyncDelayedTask(Main.getPlugin(), new Runnable() { + @Override + public void run() { + AfterArmorEquipEvent ae = new AfterArmorEquipEvent((Player) e.getWhoClicked(), armorEquipEvent); + Bukkit.getServer().getPluginManager().callEvent(ae); + } + }, 5L); + } + } + } + + @EventHandler + public void playerInteractEvent(PlayerInteractEvent e) { + if (e.getAction() == Action.PHYSICAL) { + return; + } + if ((e.getAction() == Action.RIGHT_CLICK_AIR) || (e.getAction() == Action.RIGHT_CLICK_BLOCK)) { + Player player = e.getPlayer(); + Material mat; + if ((e.getClickedBlock() != null) && (e.getAction() == Action.RIGHT_CLICK_BLOCK)) { + mat = e.getClickedBlock().getType(); + for (String s : this.blockedMaterials) { + if (mat.name().equalsIgnoreCase(s)) { + return; + } + } + } + ArmorType newArmorType = ArmorType.matchType(e.getItem()); + if ((newArmorType != null) && (((newArmorType.equals(ArmorType.HELMET)) + && (isAirOrNull(e.getPlayer().getInventory().getHelmet()))) + || ((newArmorType.equals(ArmorType.CHESTPLATE)) + && (isAirOrNull(e.getPlayer().getInventory().getChestplate()))) + || ((newArmorType.equals(ArmorType.LEGGINGS)) + && (isAirOrNull(e.getPlayer().getInventory().getLeggings()))) + || ((newArmorType.equals(ArmorType.BOOTS)) + && (isAirOrNull(e.getPlayer().getInventory().getBoots()))))) { + ArmorEquipEvent armorEquipEvent = new ArmorEquipEvent(e.getPlayer(), ArmorEquipEvent.EquipMethod.HOTBAR, + ArmorType.matchType(e.getItem()), null, e.getItem()); + Bukkit.getServer().getPluginManager().callEvent(armorEquipEvent); + if (armorEquipEvent.isCancelled()) { + e.setCancelled(true); + player.updateInventory(); + } else { + switch (newArmorType) { + case CHESTPLATE: + player.getInventory().setChestplate(e.getItem().clone()); + break; + case BOOTS: + player.getInventory().setBoots(e.getItem().clone()); + break; + case HELMET: + player.getInventory().setHelmet(e.getItem().clone()); + break; + case LEGGINGS: + player.getInventory().setLeggings(e.getItem().clone()); + break; + } + e.getItem().setAmount(0); + Bukkit.getScheduler().scheduleSyncDelayedTask(Main.getPlugin(), new Runnable() { + @Override + public void run() { + AfterArmorEquipEvent ae = new AfterArmorEquipEvent(player, armorEquipEvent); + Bukkit.getServer().getPluginManager().callEvent(ae); + } + }, 5L); + } + } + } + } + + @EventHandler + public void inventoryDrag(InventoryDragEvent event) { + ArmorType type = ArmorType.matchType(event.getOldCursor()); + if (event.getRawSlots().isEmpty()) { + return; + } + if ((type != null) + && (type.getSlot() == ((Integer) event.getRawSlots().stream().findFirst().orElse(Integer.valueOf(0))) + .intValue())) { + ArmorEquipEvent armorEquipEvent = new ArmorEquipEvent((Player) event.getWhoClicked(), + ArmorEquipEvent.EquipMethod.DRAG, type, null, event.getOldCursor()); + Bukkit.getServer().getPluginManager().callEvent(armorEquipEvent); + if (armorEquipEvent.isCancelled()) { + event.setResult(Result.DENY); + event.setCancelled(true); + } + } + } + + @EventHandler + public void itemBreakEvent(PlayerItemBreakEvent e) { + ArmorType type = ArmorType.matchType(e.getBrokenItem()); + if (type != null) { + Player p = e.getPlayer(); + ArmorEquipEvent armorEquipEvent = new ArmorEquipEvent(p, ArmorEquipEvent.EquipMethod.BROKE, type, + e.getBrokenItem(), null); + Bukkit.getServer().getPluginManager().callEvent(armorEquipEvent); + if (armorEquipEvent.isCancelled()) { + ItemStack i = e.getBrokenItem().clone(); + i.setAmount(1); + + ItemMeta im = i.getItemMeta(); + ((Damageable) im).setDamage(((Damageable) im).getDamage() - 1); + i.setItemMeta(im); + + if (type.equals(ArmorType.HELMET)) { + p.getInventory().setHelmet(i); + } else if (type.equals(ArmorType.CHESTPLATE)) { + p.getInventory().setChestplate(i); + } else if (type.equals(ArmorType.LEGGINGS)) { + p.getInventory().setLeggings(i); + } else if (type.equals(ArmorType.BOOTS)) { + p.getInventory().setBoots(i); + } + } else { + switch (type) { + case CHESTPLATE: + p.getInventory().setChestplate(null); + break; + case BOOTS: + p.getInventory().setBoots(null); + break; + case HELMET: + p.getInventory().setHelmet(null); + break; + case LEGGINGS: + p.getInventory().setLeggings(null); + break; + } + p.getWorld().playSound(p.getLocation(), Sound.ENTITY_ITEM_BREAK, 2, 2); + Bukkit.getScheduler().scheduleSyncDelayedTask(Main.getPlugin(), new Runnable() { + @Override + public void run() { + AfterArmorEquipEvent ae = new AfterArmorEquipEvent(p, armorEquipEvent); + Bukkit.getServer().getPluginManager().callEvent(ae); + } + }, 5L); + } + } + } + + @EventHandler + public void playerDeathEvent(PlayerDeathEvent e) { + Player p = e.getEntity(); + for (ItemStack i : p.getInventory().getArmorContents()) { + if (!isAirOrNull(i)) { + Bukkit.getServer().getPluginManager().callEvent( + new ArmorEquipEvent(p, ArmorEquipEvent.EquipMethod.DEATH, ArmorType.matchType(i), i, null)); + } + } + } + + private boolean isAirOrNull(ItemStack item) { + return (item == null) || (item.getType().equals(Material.AIR) || Utils.isNotDrop(item)); + } +} diff --git a/src/main/java/edited/com/codingforcookies/armorequip/ArmorType.java b/src/main/java/edited/com/codingforcookies/armorequip/ArmorType.java new file mode 100644 index 0000000..6fc877c --- /dev/null +++ b/src/main/java/edited/com/codingforcookies/armorequip/ArmorType.java @@ -0,0 +1,38 @@ +package edited.com.codingforcookies.armorequip; + +import org.bukkit.Material; +import org.bukkit.inventory.ItemStack; + +public enum ArmorType { + HELMET(5), CHESTPLATE(6), LEGGINGS(7), BOOTS(8); + + private final int slot; + + private ArmorType(int slot) { + this.slot = slot; + } + + public static final ArmorType matchType(ItemStack itemStack) { + if ((itemStack == null) || (itemStack.getType().equals(Material.AIR))) { + return null; + } + String type = itemStack.getType().name(); + if ((type.endsWith("_HELMET")) || (type.endsWith("_SKULL"))) { + return HELMET; + } + if (type.endsWith("_CHESTPLATE")) { + return CHESTPLATE; + } + if (type.endsWith("_LEGGINGS")) { + return LEGGINGS; + } + if (type.endsWith("_BOOTS")) { + return BOOTS; + } + return null; + } + + public int getSlot() { + return this.slot; + } +} diff --git a/src/main/java/edited/com/codingforcookies/armorequip/DispenserArmorListener.java b/src/main/java/edited/com/codingforcookies/armorequip/DispenserArmorListener.java new file mode 100644 index 0000000..5da73b1 --- /dev/null +++ b/src/main/java/edited/com/codingforcookies/armorequip/DispenserArmorListener.java @@ -0,0 +1,43 @@ +package edited.com.codingforcookies.armorequip; + +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.BlockDispenseArmorEvent; +import org.bukkit.inventory.ItemStack; + +public class DispenserArmorListener implements Listener { + @EventHandler + public void dispenseArmorEvent(BlockDispenseArmorEvent event) { + ArmorType type = ArmorType.matchType(event.getItem()); + if ((type != null) && ((event.getTargetEntity() instanceof Player))) { + Player p = (Player) event.getTargetEntity(); + ArmorEquipEvent armorEquipEvent = new ArmorEquipEvent(p, ArmorEquipEvent.EquipMethod.DISPENSER, type, null, + event.getItem()); + Bukkit.getServer().getPluginManager().callEvent(armorEquipEvent); + if (armorEquipEvent.isCancelled()) { + event.setCancelled(true); + } else { + event.setCancelled(true); + ItemStack item = event.getItem().clone(); + switch (type) { + case CHESTPLATE: + p.getInventory().setChestplate(item); + break; + case BOOTS: + p.getInventory().setBoots(item); + break; + case HELMET: + p.getInventory().setHelmet(item); + break; + case LEGGINGS: + p.getInventory().setLeggings(item); + break; + } + AfterArmorEquipEvent ae = new AfterArmorEquipEvent(p, armorEquipEvent); + Bukkit.getServer().getPluginManager().callEvent(ae); + } + } + } +} diff --git a/src/main/java/nashi/NRPG/API/SkillAPI.java b/src/main/java/nashi/NRPG/API/SkillAPI.java new file mode 100644 index 0000000..4e14bf0 --- /dev/null +++ b/src/main/java/nashi/NRPG/API/SkillAPI.java @@ -0,0 +1,346 @@ +package nashi.NRPG.API; + +import java.util.ArrayList; +import java.util.EnumSet; +import java.util.HashMap; +import java.util.List; +import java.util.Set; +import java.util.UUID; + +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.World; +import org.bukkit.attribute.Attribute; +import org.bukkit.block.Block; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.ArmorStand; +import org.bukkit.entity.Entity; +import org.bukkit.entity.LivingEntity; +import org.bukkit.entity.Player; +import org.bukkit.plugin.Plugin; +import org.bukkit.scheduler.BukkitRunnable; +import org.bukkit.util.Vector; + +import nashi.NRPG.Main; +import nashi.NRPG.Players.Players; +import nashi.NRPG.Players.Players.PlayerData; +import nashi.NRPG.Skills.Skill; +import nashi.NRPG.listeners.EventListener; +import nashi.NRPG.listeners.ModifyItem; +import nashi.NRPG.listeners.EventListener.Casting; + +public class SkillAPI { + public static HashMap Silence = new HashMap(); + + public static void setSilenceTime(Player player, long ms) { + Silence.put(player.getUniqueId(), System.currentTimeMillis() + ms); + } + + public static PlayerData getPlayerData(Player player) { + return Players.Data.get(player); + } + + public static boolean inSkillMode(Player player) { + return EventListener.skillmode.get(player); + } + + public static Casting getCast(Player player) { + if (EventListener.cast.containsKey(player)) { + return EventListener.cast.get(player); + } + return null; + } + + public static void setPlayerMaxAttackRange(Player player, double range) { + ModifyItem.edit.put(player, range); + } + + public static void resetPlayerMaxAttackRange(Player player, double range) { + if (ModifyItem.edit.containsKey(player)) { + ModifyItem.edit.remove(player); + } + } + + public static void damage(LivingEntity e, Player player, double amount) { + ModifyItem.edit.put(player, Double.MAX_VALUE); + e.damage(amount + player.getAttribute(Attribute.GENERIC_ATTACK_DAMAGE).getValue(), player); + ModifyItem.edit.remove(player); + } + + public static long getRemainingSilenceTime(Player player) { + return Silence.get(player.getUniqueId()) - System.currentTimeMillis(); + } + + public static boolean costMP(Player player, double MP) { + return Players.Data.get(player).costMP(MP); + } + + private static final Set containerTypes = EnumSet.of(Material.CHEST, Material.DROPPER, Material.HOPPER, + Material.DISPENSER, Material.TRAPPED_CHEST, Material.BREWING_STAND, Material.FURNACE, + Material.BLAST_FURNACE, Material.CHEST_MINECART, Material.BLACK_SHULKER_BOX, Material.BLUE_SHULKER_BOX, + Material.BROWN_SHULKER_BOX, Material.CYAN_SHULKER_BOX, Material.GRAY_SHULKER_BOX, + Material.GREEN_SHULKER_BOX, Material.ENDER_CHEST, Material.BARREL, Material.BEACON, Material.JUKEBOX, + Material.NOTE_BLOCK, Material.COMMAND_BLOCK, Material.COMMAND_BLOCK_MINECART, Material.CHAIN_COMMAND_BLOCK, + Material.ITEM_FRAME); + + public static boolean isContainer(Material mat) { + return containerTypes.contains(mat); + } + + public static List getEntityFromLoc(Location loc, int range) { + List near = loc.getWorld().getLivingEntities(); + ArrayList l = new ArrayList(); + for (LivingEntity target : near) { + if ((target.getLocation().distance(loc) <= range) && (!(target instanceof ArmorStand))) { + l.add(target); + } + } + return l; + } + + public static List blocksFromTwoPoints(Location loc1, Location loc2, World w) { + List blocks = new ArrayList(); + + int minx = Math.min(loc1.getBlockX(), loc2.getBlockX()), miny = Math.min(loc1.getBlockY(), loc2.getBlockY()), + minz = Math.min(loc1.getBlockZ(), loc2.getBlockZ()), + maxx = Math.max(loc1.getBlockX(), loc2.getBlockX()), + maxy = Math.max(loc1.getBlockY(), loc2.getBlockY()), + maxz = Math.max(loc1.getBlockZ(), loc2.getBlockZ()); + for (int x = minx; x <= maxx; x++) { + for (int y = miny; y <= maxy; y++) { + for (int z = minz; z <= maxz; z++) { + Block b = w.getBlockAt(x, y, z); + if (b.getType() != Material.AIR) { + blocks.add(b); + } + } + } + } + + return blocks; + } + + /** + * 用於計算拋物線的重力加速度，必須為負數。 + */ + private static final double G = -9.8; + /** + * 拋物線運動時的速度加快倍數，數字越大，速度越快。 + */ + private static final double SPEED = 1; + /** + * 變更運動方向的週期。 + */ + private static final long PERIOD = 1; + + /** + * 將目標推離玩家。 + * + * @param player 玩家 + * @param target 要推離的目標 + * @param distance 離地到落地的距離 + * @param rad 起飛角度 + */ + public static void push(Player player, Entity target, double distance, double rad) { + Location playerLocation = player.getLocation(); + Location targetLocation = target.getLocation(); + + Vector vector = getDirection(playerLocation, targetLocation); + + move(target, vector, distance, rad); + } + + public static void push(Location loc, Entity target, double distance, double rad) { + Location targetLocation = target.getLocation(); + + Vector vector = getDirection(loc, targetLocation); + + move(target, vector, distance, rad); + } + + /** + * 將目標拉進玩家。 + * + * @param player 玩家 + * @param target 要拉進的目標 + * @param distance 離地到落地的距離 + * @param rad 起飛角度 + */ + public static void pull(Player player, Entity target, double distance, double rad) { + Location playerLocation = player.getLocation(); + Location targetLocation = target.getLocation(); + + Vector vector = getDirection(targetLocation, playerLocation); + + move(target, vector, distance, rad); + } + + public static void pull(Location loc, Entity target, double distance, double rad) { + Location targetLocation = target.getLocation(); + + Vector vector = getDirection(targetLocation, loc); + + move(target, vector, distance, rad); + } + + /** + * 取得某個點朝向另一個點的方向。 + */ + private static Vector getDirection(Location from, Location to) { + return new Vector(to.getX() - from.getX(), to.getY() - from.getY(), to.getZ() - from.getZ()); + } + + /** + * 將目標朝向指定方向以指定弧度拋出。 + * + * @param target 目標 + * @param vector 方向 + * @param distance 起飛到落地的距離 + * @param rad 弧度（單位是 rad） + */ + private static void move(Entity target, Vector vector, double distance, double rad) { + + double v = Math.sqrt((G / (-Math.tan(rad) * Math.cos(rad) * Math.cos(rad))) * distance / 2); + double vx = v * Math.cos(rad); + + double coefficient1 = (G / (2 * v * v * Math.cos(rad) * Math.cos(rad))); + double coefficient2 = Math.tan(rad); + + vector.normalize().setY(0); + + new BukkitRunnable() { + + private Location last = new Location(target.getWorld(), 0, 0, 0); + double now = 0; + + @Override + public void run() { + double x = vx / 20 * now; + if (x > distance) { + this.cancel(); + return; + } + double y = coefficient1 * x * x + coefficient2 * x; + + Location end = vector.clone().multiply(x).setY(y).toLocation(target.getWorld()); + Vector move = getDirection(last, end); + try { + target.setVelocity(move); + } catch (Exception e) { + this.cancel(); + } + last = end; + + now += PERIOD * SPEED; + + } + + }.runTaskTimer(Main.getPlugin(), 0, PERIOD); + + } + + public static Vector getRightDirection(Location l) { + Vector direction = l.getDirection().normalize(); + return new Vector(-direction.getZ(), 0.0, direction.getX()).normalize(); + } + + public static Vector getLeftDirection(Location l) { + Vector direction = l.getDirection().normalize(); + return new Vector(direction.getZ(), 0.0, -direction.getX()).normalize(); + } + + public static LivingEntity getEntityInLineOfSight(Player player, double range) { + ArrayList entities = (ArrayList) player.getNearbyEntities(range, range, range); + ArrayList sightBlock = (ArrayList) player.getLineOfSight((Set) null, (int) range); + ArrayList sight = new ArrayList(); + for (int i = 0; i < sightBlock.size(); i++) { + Block b = sightBlock.get(i); + if (!Utils.transparentBlocks.contains(b.getType())) { + break; + } + sight.add(sightBlock.get(i).getLocation()); + } + for (int i = 0; i < sight.size(); i++) { + for (int k = 0; k < entities.size(); k++) { + if (Math.abs(entities.get(k).getLocation().getX() - sight.get(i).getX()) < 1.3) { + if (Math.abs(entities.get(k).getLocation().getY() - sight.get(i).getY()) < 1.5) { + if (Math.abs(entities.get(k).getLocation().getZ() - sight.get(i).getZ()) < 1.3) { + if (entities.get(k) instanceof LivingEntity && (!(entities.get(k) instanceof ArmorStand))) { + return (LivingEntity) entities.get(k); + } + } + } + } + } + } + return null; + } + + public static List getNearEntity(Player player, int range) { + List near = player.getLocation().getWorld().getLivingEntities(); + ArrayList l = new ArrayList(); + for (LivingEntity target : near) { + if (target.getLocation().distance(player.getLocation()) <= range && target != player + && (!(target instanceof ArmorStand))) { + l.add(target); + } + } + return l; + } + + public static List getNumbersTargetsFromList(List List, int maxtargets) { + if (List.size() <= maxtargets) { + return List; + } else { + int i; + List l = new ArrayList(); + for (i = 0; i <= maxtargets; i++) { + LivingEntity le = List.get(i); + l.add(le); + } + return l; + } + } + + public static double getSkillInfo(Player player, String skillname, String Info) { + YamlConfiguration pf = Players.getYaml(player); + return pf.getDouble("Skills." + skillname + ".Custom." + Info); + } + + public static double getPublicSkillInfo(String skillname, String Info) { + YamlConfiguration f = Players.skillsetting; + return f.getDouble(skillname + "." + Info); + } + + public static boolean getSkillPublicBoolean(String skillname, String Info) { + YamlConfiguration f = Players.skillsetting; + return f.getBoolean(skillname + "." + Info); + } + + public static Location BlockLocPlayerLook(Player player, int maxdistance) { + Block block = player.getTargetBlock((Set) null, maxdistance); + Location bl = block.getLocation(); + return bl; + } + + public static long getRemainingCooldown(Player player, String skillname) { + if (Skill.cooldowns.containsKey(player.getUniqueId() + "." + skillname)) { + return Skill.cooldowns.get(player.getUniqueId() + "." + skillname) - System.currentTimeMillis(); + } else { + return 0; + } + } + + public static Vector getPlayerLookDir(Player player) { + return player.getLocation().getDirection(); + } + + public static void setCooldown(Player player, String skillname, long CD) { + Skill.cooldowns.put(player.getUniqueId() + "." + skillname, System.currentTimeMillis() + CD); + } + + public static Plugin plugin() { + return Main.getPlugin(); + } + +} \ No newline at end of file diff --git a/src/main/java/nashi/NRPG/API/Utils.java b/src/main/java/nashi/NRPG/API/Utils.java new file mode 100644 index 0000000..0255c02 --- /dev/null +++ b/src/main/java/nashi/NRPG/API/Utils.java @@ -0,0 +1,370 @@ +package nashi.NRPG.API; + +import java.io.File; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Random; + +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.Material; +import org.bukkit.NamespacedKey; +import org.bukkit.World; +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; +import org.bukkit.persistence.PersistentDataContainer; +import org.bukkit.persistence.PersistentDataType; +import org.bukkit.scheduler.BukkitRunnable; + +import nashi.NRPG.Main; +import nashi.NRPG.Items.CreateItem; +import nashi.NRPG.Players.Leveling; +import nashi.NRPG.Players.Players; +import nashi.NRPG.Players.Races; +import nashi.NRPG.Skills.Cast; +import nashi.NRPG.Skills.Skill; +import nashi.NRPG.Skills.SkillName; +import nashi.NRPG.Skills.Skill.Skills; +import nashi.NRPG.listeners.AllAboutDamage; + +public class Utils { + public static boolean Penalty_MakeUp; + private static HashMap playerstatus = new HashMap(); + public static Random rand = new Random(); + public static double manaDMG; + public static float SPDSpeed; + public static double HPHealth; + public static double ManaMP; + public static double LUKAVD; + public static double LUKCRIT; + public static double basehp; + public static double basemp; + public static float basespd; + public static List transparentBlocks = new ArrayList(); + public static int MaxSlot; + public static int RMP; + public static int RHP; + public static NamespacedKey key = new NamespacedKey(Main.getPlugin(), "NRPG_Consumables"); + public static double defaultattackrange; + public static double hunger; + public static double exarmor; + public static double arrowdamagemod; + public static int STATRAND; + public static double PercentDamageLVL; + public static List deathpenworld = new ArrayList(); + public static boolean Penalty_LVL; + public static boolean Penalty_Race; + public static boolean Penalty_Status; + public static List MakeUpSkills = new ArrayList(); + public static double MakeUpMod; + + public static void additem(Player player, ItemStack item) { + if (item == null) { + return; + } + if (player.getInventory().firstEmpty() != -1) { + player.getInventory().addItem(item); + } else { + player.getWorld().dropItem(player.getLocation(), item); + } + } + + public static void util() { + transparentBlocks.clear(); + transparentBlocks.add(Material.CAVE_AIR); + transparentBlocks.add(Material.AIR); + transparentBlocks.add(Material.BLACK_CARPET); + transparentBlocks.add(Material.BLUE_CARPET); + transparentBlocks.add(Material.BROWN_CARPET); + transparentBlocks.add(Material.CYAN_CARPET); + transparentBlocks.add(Material.MAGENTA_CARPET); + transparentBlocks.add(Material.ORANGE_CARPET); + transparentBlocks.add(Material.PINK_CARPET); + transparentBlocks.add(Material.PURPLE_CARPET); + transparentBlocks.add(Material.RED_CARPET); + transparentBlocks.add(Material.WHITE_CARPET); + transparentBlocks.add(Material.YELLOW_CARPET); + transparentBlocks.add(Material.CARROT); + transparentBlocks.add(Material.WHEAT); + transparentBlocks.add(Material.DEAD_BUSH); + transparentBlocks.add(Material.DETECTOR_RAIL); + transparentBlocks.add(Material.ACACIA_FENCE_GATE); + transparentBlocks.add(Material.BIRCH_FENCE_GATE); + transparentBlocks.add(Material.DARK_OAK_FENCE_GATE); + transparentBlocks.add(Material.JUNGLE_FENCE_GATE); + transparentBlocks.add(Material.OAK_FENCE_GATE); + transparentBlocks.add(Material.SPRUCE_FENCE_GATE); + transparentBlocks.add(Material.FLOWER_POT); + transparentBlocks.add(Material.LADDER); + transparentBlocks.add(Material.LEVER); + transparentBlocks.add(Material.GRASS); + transparentBlocks.add(Material.POWERED_RAIL); + transparentBlocks.add(Material.REDSTONE_TORCH); + transparentBlocks.add(Material.REDSTONE_WIRE); + transparentBlocks.add(Material.ACACIA_SIGN); + transparentBlocks.add(Material.BIRCH_SIGN); + transparentBlocks.add(Material.DARK_OAK_SIGN); + transparentBlocks.add(Material.JUNGLE_SIGN); + transparentBlocks.add(Material.OAK_SIGN); + transparentBlocks.add(Material.SPRUCE_SIGN); + transparentBlocks.add(Material.SNOW); + transparentBlocks.add(Material.STONE_BUTTON); + transparentBlocks.add(Material.SUGAR_CANE); + transparentBlocks.add(Material.TORCH); + transparentBlocks.add(Material.TRIPWIRE); + transparentBlocks.add(Material.VINE); + transparentBlocks.add(Material.ACACIA_WALL_SIGN); + transparentBlocks.add(Material.BIRCH_WALL_SIGN); + transparentBlocks.add(Material.DARK_OAK_WALL_SIGN); + transparentBlocks.add(Material.JUNGLE_WALL_SIGN); + transparentBlocks.add(Material.OAK_WALL_SIGN); + transparentBlocks.add(Material.SPRUCE_WALL_SIGN); + transparentBlocks.add(Material.WATER); + transparentBlocks.add(Material.LAVA); + transparentBlocks.add(Material.LARGE_FERN); + transparentBlocks.add(Material.FERN); + transparentBlocks.add(Material.TALL_GRASS); + transparentBlocks.add(Material.SEAGRASS); + transparentBlocks.add(Material.TALL_SEAGRASS); + + } + + public static long time = System.currentTimeMillis(); + + public static String getRandomMakeUpSkills() { + return MakeUpSkills.get(rand.nextInt(MakeUpSkills.size())); + } + + public static Status getStatusFromInt(int i, int lvl) { + Random rand = new Random(time + i); + return new Status(rand.nextInt(Utils.STATRAND) + 1, rand.nextInt(Utils.STATRAND) + 1, + rand.nextInt(Utils.STATRAND) + 1, rand.nextInt(Utils.STATRAND) + 1, rand.nextInt(Utils.STATRAND) + 1, + rand.nextInt(Utils.STATRAND) + 1, rand.nextInt(Utils.STATRAND) + 1, rand.nextInt(Utils.STATRAND) + 1, + lvl); + } + + public static Status getStatusFromInt(int i) { + Random rand = new Random(time + i); + return new Status(rand.nextInt(Utils.STATRAND) + 1, rand.nextInt(Utils.STATRAND) + 1, + rand.nextInt(Utils.STATRAND) + 1, rand.nextInt(Utils.STATRAND) + 1, rand.nextInt(Utils.STATRAND) + 1, + rand.nextInt(Utils.STATRAND) + 1, rand.nextInt(Utils.STATRAND) + 1, rand.nextInt(Utils.STATRAND) + 1, + 1); + } + + public static void init() { + Races.init(); + Leveling.init(); + util(); + CreateItem.init(); + FileConfiguration yml = Main.getPlugin().getConfig(); + RMP = yml.getInt("ManaRecover"); + RHP = yml.getInt("HPRecover"); + manaDMG = yml.getDouble("ManaDamage"); + Cast.timelimit = yml.getLong("TimeLimit"); + MaxSlot = yml.getInt("MaxSlot"); + basespd = (float) yml.getDouble("BaseSpeed"); + basehp = yml.getDouble("BaseHP"); + basemp = yml.getDouble("BaseMP"); + LUKAVD = yml.getDouble("LUKAVD"); + LUKCRIT = yml.getDouble("LUKCRIT"); + HPHealth = yml.getDouble("HPMod"); + ManaMP = yml.getDouble("MPMod"); + SPDSpeed = (float) yml.getDouble("SpeedMod"); + defaultattackrange = yml.getDouble("DefaultAttackRange"); + hunger = yml.getDouble("HungerDamage"); + exarmor = yml.getDouble("LeakArmorMod"); + arrowdamagemod = yml.getDouble("ArrowEnchMod"); + STATRAND = yml.getInt("StatusRandomMax"); + PercentDamageLVL = yml.getDouble("RequiredDamageDueToMobs"); + Penalty_LVL = yml.getBoolean("Penalty.LevelLose"); + Penalty_Race = yml.getBoolean("Penalty.ResetRace"); + Penalty_Status = yml.getBoolean("Penalty.ResetStatus"); + Penalty_Status = yml.getBoolean("Penalty.MakeUp"); + MakeUpMod = yml.getDouble("MakeUpMod"); + Main.worlds.clear(); + deathpenworld.clear(); + MakeUpSkills.clear(); + try { + for (String str : yml.getStringList("MakeUpSkills")) { + MakeUpSkills.add(str); + } + } catch (Exception e) { + } + try { + for (String str : yml.getStringList("DeathPenaltyWorlds")) { + deathpenworld.add(Bukkit.getWorld(str)); + } + } catch (Exception e) { + } + try { + for (String str : yml.getStringList("Worlds")) { + Main.worlds.add(Bukkit.getWorld(str)); + } + } catch (Exception e) { + } + Players.skillsetting = YamlConfiguration + .loadConfiguration(new File(Main.getPlugin().getDataFolder() + File.separator + "skills.yml")); + + new BukkitRunnable() { + @Override + public void run() { + Utils.time = System.currentTimeMillis(); + } + }.runTaskTimerAsynchronously(Main.getPlugin(), 1728000, 1728000); + } + + public static class Status { + private int ATK; + private int HP; + private int SPD; + private int LUK; + private int MP; + private int AR; + private int AT; + private int LVL; + private int SKL; + + public Status() { + this.ATK = 0; + this.SPD = 0; + this.HP = 0; + this.MP = 0; + this.LUK = 0; + this.LVL = 1; + this.AR = 0; + this.AT = 0; + } + + public Status(int SKL, int AR, int AT, int atk, int spd, int hp, int mp, int luk, int lvl) { + this.SKL = SKL; + this.AR = AR; + this.AT = AT; + this.ATK = atk; + this.SPD = spd; + this.HP = hp; + this.MP = mp; + this.LUK = luk; + this.LVL = lvl; + } + + public int getArmor() { + return this.AR; + } + + public int getArmorToughness() { + return AT; + } + + public int getLvL() { + return this.LVL; + } + + public void setLvL(int lvl) { + this.LVL = lvl; + } + + public int getATK() { + return this.ATK; + } + + public int getHP() { + return this.HP; + } + + public int getMP() { + return this.MP; + } + + public int getSpeed() { + return this.SPD; + } + + public int getLucky() { + return this.LUK; + } + + public int getSKL() { + return this.SKL; + } + } + + public static Status getPlayerStatus(Player player) { + return playerstatus.get(player); + } + + public static void setPlayerStatus(Player player, Status status) { + playerstatus.put(player, status); + } + + public static boolean isSuccess(double rate) { + return rand.nextInt(100) < rate; + } + + public static ItemStack getSkillItem(String skillname, Player player) { + ItemStack item = new ItemStack(Material.ENCHANTED_BOOK); + ItemMeta im = item.getItemMeta(); + skillname = SkillName.get(skillname); + im.setDisplayName(ChatColor.LIGHT_PURPLE + skillname); + List lore = new ArrayList(); + lore.add(ChatColor.YELLOW + Players.skillsetting.getString(skillname + ".Description")); + int cost; + + try { + Skills sk = Skill.skills.get(skillname); + Class clazz = sk.skill; + Object s = clazz.getDeclaredConstructor().newInstance(); + Method skill = clazz.getMethod("getManaCost", Player.class); + cost = (int) skill.invoke(s, player); + } catch (Exception e) { + cost = (int) Players.skillsetting.getDouble(skillname + ".CostMP"); + } + lore.add(ChatColor.YELLOW + "消耗魔力: " + cost); + lore.add(ChatColor.YELLOW + "需要詠唱次數: " + Players.skillsetting.getString(skillname + ".Times")); + lore.add(ChatColor.YELLOW + "冷卻時間: " + Players.skillsetting.getString(skillname + ".Cooldown")); + im.setLore(lore); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(AllAboutDamage.key, PersistentDataType.STRING, "ItemsNotDrop"); + item.setItemMeta(im); + + return item; + } + + public static ItemStack getSkillItem(String skillname, String Cost) { + ItemStack item = new ItemStack(Material.ENCHANTED_BOOK); + ItemMeta im = item.getItemMeta(); + skillname = SkillName.get(skillname); + im.setDisplayName(ChatColor.LIGHT_PURPLE + skillname); + List lore = new ArrayList(); + lore.add(ChatColor.YELLOW + Players.skillsetting.getString(skillname + ".Description")); + lore.add(Cost); + lore.add(ChatColor.YELLOW + "需要詠唱次數: " + Players.skillsetting.getString(skillname + ".Times")); + lore.add(ChatColor.YELLOW + "冷卻時間: " + Players.skillsetting.getString(skillname + ".Cooldown")); + im.setLore(lore); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(AllAboutDamage.key, PersistentDataType.STRING, "ItemsNotDrop"); + item.setItemMeta(im); + return item; + } + + public static void setNotDrop(ItemStack item) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(AllAboutDamage.key, PersistentDataType.STRING, "ItemsNotDrop"); + item.setItemMeta(im); + } + + public static boolean isNotDrop(ItemStack item) { + try { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + return pdc.has(AllAboutDamage.key, PersistentDataType.STRING); + } catch (NullPointerException e) { + return false; + } + } +} diff --git a/src/main/java/nashi/NRPG/Commands/AbandonCommand.java b/src/main/java/nashi/NRPG/Commands/AbandonCommand.java new file mode 100644 index 0000000..31f256a --- /dev/null +++ b/src/main/java/nashi/NRPG/Commands/AbandonCommand.java @@ -0,0 +1,69 @@ +package nashi.NRPG.Commands; + +import java.util.List; + +import org.bukkit.ChatColor; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; + +import nashi.NRPG.Players.Players; +import nashi.NRPG.Skills.Skill; +import nashi.NRPG.Skills.SkillName; + +public class AbandonCommand implements CommandExecutor { + @Override + public boolean onCommand(CommandSender sender, Command cmd, String cmdlable, String[] args) { + if (args.length == 0) { + Commands.sendHelp(sender); + return true; + } else { + if (args[0] != null) { + if (sender instanceof Player) { + Player player = (Player) sender; + if (!player.hasPermission("nrpg.abandon")) { + player.sendMessage(ChatColor.RED + "你沒有權限使用此指令"); + return true; + } + String sk = args[0]; + String skillname = SkillName.get(sk); + if (Skill.GeneralSkills.contains(skillname)) { + player.sendMessage(ChatColor.RED + "你無法放棄通用技能"); + return true; + } + if (Players.Data.get(player).getRace().getSkillList().contains(skillname)) { + player.sendMessage(ChatColor.RED + "你無法放棄種族技能"); + return true; + } + YamlConfiguration y = Players.getYaml(player); + boolean have = false; + List skl = y.getStringList("UniqeSkills"); + if (skl.contains(skillname)) { + have = true; + } + if (have) { + skl.remove(skillname); + y.set("UniqeSkills", skl); + y.set("UsedSlots", y.getInt("UsedSlots") - 1); + for(int i = 1;i<=9;i++) { + try { + if(y.getString("Slot." + i).equals(skillname)) { + y.set("Slot."+i, null); + } + }catch(Exception e) {} + } + player.sendMessage(ChatColor.GREEN + "你已放棄技能- " + skillname); + } else { + player.sendMessage(ChatColor.RED + "技能不存在,請確認是否擁有此技能或名稱是否正確"); + } + + return true; + } + } + } + return false; + } + +} diff --git a/src/main/java/nashi/NRPG/Commands/CastCommand.java b/src/main/java/nashi/NRPG/Commands/CastCommand.java new file mode 100644 index 0000000..66f2ec3 --- /dev/null +++ b/src/main/java/nashi/NRPG/Commands/CastCommand.java @@ -0,0 +1,39 @@ +package nashi.NRPG.Commands; + +import org.bukkit.ChatColor; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; + +import nashi.NRPG.Players.Players; +import nashi.NRPG.Skills.Cast; + +public class CastCommand implements CommandExecutor { + @Override + public boolean onCommand(CommandSender sender, Command cmd, String cmdlable, String[] args) { + if (args.length == 0) { + Commands.sendHelp(sender); + return true; + } else { + if (args[0] != null) { + if (sender instanceof Player) { + Player player = (Player) sender; + int speed = Integer.parseInt(args[0]); + YamlConfiguration y = Players.getYaml(player); + if (speed > 0 && speed <= 20) { + y.set("CastSpeed", speed); + Cast.castspeed.put(player, speed); + player.sendMessage(ChatColor.GREEN +"你已將詠唱間隔設定為 " + speed + " ticks"); + } else { + player.sendMessage(ChatColor.RED +"請輸入1~20的數字"); + } + } + return true; + } + } + return false; + } + +} diff --git a/src/main/java/nashi/NRPG/Commands/Commands.java b/src/main/java/nashi/NRPG/Commands/Commands.java new file mode 100644 index 0000000..7aacb3a --- /dev/null +++ b/src/main/java/nashi/NRPG/Commands/Commands.java @@ -0,0 +1,407 @@ +package nashi.NRPG.Commands; + +import java.io.File; +import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.ArrayList; +import java.util.List; + +import org.bukkit.ChatColor; +import org.bukkit.Material; +import org.bukkit.NamespacedKey; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; +import org.bukkit.inventory.ItemFlag; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; +import org.bukkit.persistence.PersistentDataContainer; +import org.bukkit.persistence.PersistentDataType; + +import nashi.NRPG.Main; +import nashi.NRPG.API.SkillAPI; +import nashi.NRPG.API.Utils; +import nashi.NRPG.Items.CreateItem; +import nashi.NRPG.Players.Players; +import nashi.NRPG.Skills.Cast; +import nashi.NRPG.Skills.Skill; +import nashi.NRPG.Skills.SkillItem; +import nashi.NRPG.Skills.SkillName; +import nashi.NRPG.listeners.ModifyItem; + +public class Commands implements CommandExecutor { + @Override + public boolean onCommand(CommandSender sender, Command cmd, String cmdlable, String[] args) { + if (args.length == 0) { + sendHelp(sender); + return true; + } else { + if (args[0].equalsIgnoreCase("key") && args.length >= 4) { + if (!sender.hasPermission("nrpg.op")) { + sender.sendMessage("No permission"); + return true; + } + if (sender instanceof Player) { + Player player = (Player) sender; + String key = args[1]; + String type = args[2]; + type = type.toUpperCase(); + String data = args[3]; + ItemStack item = player.getInventory().getItemInMainHand(); + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + int c = 0; + String[] sp = data.split(","); + switch (type) { + case "INTEGER": + pdc.set(new NamespacedKey(Main.getPlugin(), key), PersistentDataType.INTEGER, + Integer.parseInt(data)); + break; + case "INTEGER_ARRAY": + int[] ia = new int[data.length()]; + for (String str : sp) { + ia[c] = Integer.parseInt(str); + c++; + } + pdc.set(new NamespacedKey(Main.getPlugin(), key), PersistentDataType.INTEGER_ARRAY, ia); + break; + case "BYTE": + pdc.set(new NamespacedKey(Main.getPlugin(), key), PersistentDataType.BYTE, + Byte.parseByte(data)); + break; + case "BYTE_ARRAY": + byte[] ba = new byte[data.length()]; + for (String str : sp) { + ba[c] = Byte.parseByte(str); + c++; + } + pdc.set(new NamespacedKey(Main.getPlugin(), key), PersistentDataType.BYTE_ARRAY, ba); + break; + case "DOUBLE": + pdc.set(new NamespacedKey(Main.getPlugin(), key), PersistentDataType.DOUBLE, + Double.parseDouble(data)); + break; + case "FLOAT": + pdc.set(new NamespacedKey(Main.getPlugin(), key), PersistentDataType.FLOAT, + Float.parseFloat(data)); + break; + case "LONG": + pdc.set(new NamespacedKey(Main.getPlugin(), key), PersistentDataType.LONG, + Long.parseLong(data)); + break; + case "LONG_ARRAY": + long[] la = new long[data.length()]; + for (String str : sp) { + la[c] = Long.parseLong(str); + c++; + } + pdc.set(new NamespacedKey(Main.getPlugin(), key), PersistentDataType.LONG_ARRAY, la); + break; + case "SHORT": + pdc.set(new NamespacedKey(Main.getPlugin(), key), PersistentDataType.SHORT, + Short.parseShort(data)); + break; + default: + pdc.set(new NamespacedKey(Main.getPlugin(), key), PersistentDataType.STRING, data); + break; + } + item.setItemMeta(im); + return true; + } + + } + if (args[0].equalsIgnoreCase("potion")) { + if (!sender.hasPermission("nrpg.op")) { + sender.sendMessage("No permission"); + return true; + } + if (sender instanceof Player) { + Player player = (Player) sender; + ItemStack i = player.getInventory().getItemInMainHand(); + if (i != null && i.getType() != Material.AIR) { + ItemMeta im = i.getItemMeta(); + im.setUnbreakable(true); + im.addItemFlags(ItemFlag.HIDE_UNBREAKABLE); + im.getPersistentDataContainer().set(Utils.key, PersistentDataType.STRING, "Consumables"); + i.setItemMeta(im); + player.sendMessage("已修改道具"); + } + } + return true; + } + if (args[0].equalsIgnoreCase("skillitem")) { + if (!sender.hasPermission("nrpg.op")) { + sender.sendMessage("No permission"); + return true; + } + if (sender instanceof Player) { + Player player = (Player) sender; + ItemStack i = player.getInventory().getItemInMainHand(); + if (i != null && i.getType() != Material.AIR) { + SkillItem.setSkillItem(i, SkillName.get(args[1]), Integer.parseInt(args[2]), + Integer.parseInt(args[3]), Integer.parseInt(args[4]), Integer.parseInt(args[5])); + player.sendMessage("已修改道具"); + } + } + return true; + } + if (args[0].equalsIgnoreCase("modcast") && args[1] != null) { + if (!sender.hasPermission("nrpg.op")) { + sender.sendMessage("No permission"); + return true; + } + if (sender instanceof Player) { + Player player = (Player) sender; + ItemStack item = player.getInventory().getItemInMainHand(); + if (item == null) { + player.sendMessage("請手持想要修改的物品"); + } + int mod = Integer.parseInt(args[1]); + ModifyItem.setItemCastMod(item, mod); + player.sendMessage("已將此道具的額外詠唱速度設為" + mod); + } + return true; + } + if (args[0].equalsIgnoreCase("mana") && args[1] != null) { + if (!sender.hasPermission("nrpg.op")) { + sender.sendMessage("No permission"); + return true; + } + if (sender instanceof Player) { + Player player = (Player) sender; + ItemStack item = player.getInventory().getItemInMainHand(); + if (item == null) { + player.sendMessage("請手持想要修改的物品"); + } + int mod = Integer.parseInt(args[1]); + ModifyItem.setItemMP(item, mod); + player.sendMessage("裝備此道具時獲得的魔力修改為" + mod); + } + return true; + } + + if (args[0].equalsIgnoreCase("mp") && args[1] != null) { + if (!sender.hasPermission("nrpg.op")) { + sender.sendMessage("No permission"); + return true; + } + if (sender instanceof Player) { + Player player = (Player) sender; + ItemStack item = player.getInventory().getItemInMainHand(); + if (item == null) { + player.sendMessage("請手持想要修改的物品"); + } + int mod = Integer.parseInt(args[1]); + ModifyItem.setPotionMP(item, mod); + player.sendMessage("消耗此道具時獲得的魔力修改為" + mod); + } + return true; + } + if (args[0].equalsIgnoreCase("hp") && args[1] != null) { + if (!sender.hasPermission("nrpg.op")) { + sender.sendMessage("No permission"); + return true; + } + if (sender instanceof Player) { + Player player = (Player) sender; + ItemStack item = player.getInventory().getItemInMainHand(); + if (item == null) { + player.sendMessage("請手持想要修改的物品"); + } + int mod = Integer.parseInt(args[1]); + ModifyItem.setPotionHP(item, mod); + player.sendMessage("消耗此道具時獲得的血量修改為" + mod); + } + return true; + } + + if (args[0].equalsIgnoreCase("book") && args[1] != null) { + if (!sender.hasPermission("nrpg.op")) { + sender.sendMessage("No permission"); + return true; + } + if (sender instanceof Player) { + Player player = (Player) sender; + String sk = args[1]; + if (SkillName.get(sk) != null) { + String skillname = SkillName.get(sk); + ItemStack i = player.getInventory().getItemInMainHand(); + if (i != null && i.getType() != Material.AIR) { + ItemMeta im = i.getItemMeta(); + im.setDisplayName(ChatColor.GOLD + "技能書" + ChatColor.AQUA + skillname); + List lore = new ArrayList(); + lore.add(ChatColor.GREEN + "使用此書即可學習技能-" + ChatColor.LIGHT_PURPLE + skillname); + lore.add(ChatColor.GREEN + "技能說明: "); + lore.add(ChatColor.YELLOW + Players.skillsetting.getString(skillname + ".Description")); + im.setLore(lore); + im.setUnbreakable(true); + im.addItemFlags(ItemFlag.HIDE_UNBREAKABLE); + i.setItemMeta(im); + ModifyItem.setSkillBookSkill(i, skillname); + } else { + ItemStack a = new ItemStack(Material.ENCHANTED_BOOK); + ItemMeta im = a.getItemMeta(); + im.setDisplayName(ChatColor.GOLD + "技能書" + ChatColor.AQUA + skillname); + List lore = new ArrayList(); + lore.add(ChatColor.GREEN + "使用此書即可學習技能-" + ChatColor.LIGHT_PURPLE + skillname); + lore.add(ChatColor.GREEN + "技能說明: "); + lore.add(ChatColor.YELLOW + Players.skillsetting.getString(skillname + ".Description")); + im.setLore(lore); + im.setUnbreakable(true); + im.addItemFlags(ItemFlag.HIDE_UNBREAKABLE); + a.setItemMeta(im); + ModifyItem.setSkillBookSkill(a, skillname); + player.getInventory().setItemInMainHand(a); + } + } + } + return true; + } + if (args[0].equalsIgnoreCase("reload")) { + if (!sender.hasPermission("nrpg.op")) { + sender.sendMessage("No permission"); + return true; + } + SkillAPI.plugin().reloadConfig(); + Utils.init(); + return true; + } + if (args[0].equalsIgnoreCase("range") && args[1] != null) { + if (!sender.hasPermission("nrpg.op")) { + sender.sendMessage("No permission"); + return true; + } + if (sender instanceof Player) { + Player player = (Player) sender; + ItemStack item = player.getInventory().getItemInMainHand(); + if (item == null) { + player.sendMessage("請手持想要修改的物品"); + } + double mod = Double.parseDouble(args[1]); + ModifyItem.setItemRangeMod(item, mod); + player.sendMessage("已將此道具的額外攻擊距離設為" + mod); + } + return true; + } + + if (args[0].equalsIgnoreCase("forge") && args[1] != null) { + if (!sender.hasPermission("nrpg.op")) { + sender.sendMessage("No permission"); + return true; + } + if (sender instanceof Player) { + Player player = (Player) sender; + ItemStack item = player.getInventory().getItemInMainHand(); + if (item == null) { + player.sendMessage("請手持想要修改的物品"); + } + CreateItem.setItemForgeSlot(item, Integer.parseInt(args[1])); + CreateItem.setItemForgeTime(item, 0); + + player.sendMessage( + "已將此道具設定為可鍛造物品, 欄位:" + CreateItem.getEquipmentSlotFromInt(Integer.parseInt(args[1]))); + } + return true; + } + + if (args[0].equalsIgnoreCase("material") && args[1] != null) { + if (!sender.hasPermission("nrpg.op")) { + sender.sendMessage("No permission"); + return true; + } + if (sender instanceof Player) { + Player player = (Player) sender; + ItemStack item = player.getInventory().getItemInMainHand(); + if (item == null) { + player.sendMessage("請手持想要修改的物品"); + } + String tier = args[1]; + CreateItem.setItemForgeMaterialTier(item, tier); + player.sendMessage("已將此道具設定為" + tier + "等級素材"); + } + return true; + } + if (args[0].equalsIgnoreCase("unloadskill") && args[1] != null) { + if (!sender.hasPermission("nrpg.op")) { + sender.sendMessage("No permission"); + return true; + } + try { + String sk = args[1]; + Class clazz = Skill.skills.get(sk).skill; + Object s = clazz.getDeclaredConstructor().newInstance(); + Method skill = clazz.getMethod("unload"); + skill.invoke(s); + } catch (Exception e) { + + } + } + if (args[0].equalsIgnoreCase("loadskill") && args[1] != null) { + if (!sender.hasPermission("nrpg.op")) { + sender.sendMessage("No permission"); + return true; + } + + String sk = args[1]; + if (SkillName.get(sk) != null) { + Class clz = Skill.skills.get(SkillName.get(sk)).skill; + try { + Method set = clz.getMethod("unload"); + Object s = clz.getDeclaredConstructor().newInstance(); + set.invoke(s); + } catch (Exception e) { + } + } + File fileEntry = new File( + SkillAPI.plugin().getDataFolder() + File.separator + "skills" + File.separator + sk + ".jar"); + try { + File f = fileEntry; + URL u = f.toURI().toURL(); + URLClassLoader child = new URLClassLoader(new URL[] { u }, Main.class.getClassLoader()); + Class clazz = Class.forName(sk + "." + sk, true, child); + Object s = clazz.getDeclaredConstructor().newInstance(); + try { + Method set = clazz.getMethod("load"); + set.invoke(s); + } catch (Exception e) { + } + try { + if (SkillAPI.getSkillPublicBoolean(sk, "general")) { + Skill.GeneralSkills.add(sk); + } + Method skill = clazz.getMethod("skill", Player.class); + Skill.skills.put(sk, new Skill.Skills(skill, s, clazz)); + SkillName.put(sk); + } catch (Exception e) { + } + } catch (Exception e) { + e.printStackTrace(); + } + return true; + } + } + return false; + } + + public static void sendHelp(CommandSender sender) { + sender.sendMessage(ChatColor.GOLD + "NRPG指令幫助"); + sender.sendMessage(ChatColor.YELLOW + "/stat " + ChatColor.GREEN + "能力值"); + sender.sendMessage(ChatColor.YELLOW + "/skilledit " + ChatColor.GREEN + "調整技能參數"); + sender.sendMessage(ChatColor.YELLOW + "/cast 間隔 " + ChatColor.GREEN + "修改詠唱速度,越低越快"); + sender.sendMessage(ChatColor.YELLOW + "/slot " + ChatColor.GREEN + "將技能綁定至欄位上"); + sender.sendMessage(ChatColor.YELLOW + "/scale 格數 " + ChatColor.GREEN + "調整血量的最高格數顯示"); + sender.sendMessage(ChatColor.YELLOW + "/abandon 技能名稱 " + ChatColor.GREEN + "捨棄技能"); + sender.sendMessage(ChatColor.YELLOW + "/race " + ChatColor.GREEN + "種族相關指令"); + sender.sendMessage(ChatColor.YELLOW + "/reset " + ChatColor.GREEN + "重設玩家資料"); + sender.sendMessage(ChatColor.GOLD + "技能運作說明"); + sender.sendMessage(ChatColor.YELLOW + "切換雙手物品位置(快捷鍵F): " + ChatColor.GREEN + "施法模式"); + sender.sendMessage(ChatColor.YELLOW + "施法方式: " + ChatColor.GREEN + "Actionbar會顯示詠唱進度條,在跑到" + Cast.right + + Cast.logo + ChatColor.GREEN + "的時候點右鍵進行詠唱"); + sender.sendMessage(ChatColor.RED + "每個技能需要的成功次數不同"); + sender.sendMessage(ChatColor.RED + "詠唱時間為" + ChatColor.LIGHT_PURPLE + (Cast.timelimit / 1000) + ChatColor.RED + + "秒,時間過後則會判定失敗"); + sender.sendMessage(ChatColor.RED + "施法失敗會導致爆炸"); + } +} diff --git a/src/main/java/nashi/NRPG/Commands/RaceCommand.java b/src/main/java/nashi/NRPG/Commands/RaceCommand.java new file mode 100644 index 0000000..ca2c266 --- /dev/null +++ b/src/main/java/nashi/NRPG/Commands/RaceCommand.java @@ -0,0 +1,105 @@ +package nashi.NRPG.Commands; + +import java.util.HashSet; +import java.util.Set; + +import org.bukkit.ChatColor; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; + +import nashi.NRPG.Players.Players; +import nashi.NRPG.Players.Races; +import nashi.NRPG.Players.Players.PlayerData; +import nashi.NRPG.Players.Races.Race; + +public class RaceCommand implements CommandExecutor { + public static Set enable = new HashSet(); + + @Override + public boolean onCommand(CommandSender sender, Command cmd, String cmdlable, String[] args) { + if (!(sender instanceof Player)) { + return true; + } + Player player = (Player) sender; + if (args.length == 0) { + sendRaceHelp(player); + return true; + } else { + if (args[0].equalsIgnoreCase("choose") && args[1] != null) { + PlayerData pd = Players.Data.get(player); + if (!pd.getRace().getName().equals(Races.defaultRace.getName())) { + player.sendMessage(ChatColor.RED + "你已經選擇過種族了"); + return true; + } + String racename = args[1]; + Race race = Races.getRace(racename); + if (race == null) { + player.sendMessage(ChatColor.RED + "種族不存在,請確認名稱是否正確"); + return true; + } + YamlConfiguration y = Players.getYaml(player); + pd.setRace(player, race); + y.set("Race", race.getName()); + player.sendMessage(ChatColor.GREEN + "你已成為" + race.getDisplayName()); + + return true; + } + if (args[0].equalsIgnoreCase("exterior")) { + if (enable.contains(player)) { + disable(player); + player.sendMessage(ChatColor.RED + "種族外觀特徵已停用"); + } else { + enable(player); + player.sendMessage(ChatColor.GREEN + "種族外觀特徵已啟用"); + } + return true; + } + } + return false; + } + + private static void sendRaceHelp(Player sender) { + /*String able; + if (enable.contains(sender)) { + able = ChatColor.GREEN + "啟用"; + } else { + able = ChatColor.RED + "停用"; + } + sender.sendMessage(ChatColor.YELLOW + "種族外觀: " + able); + sender.sendMessage( + ChatColor.GREEN + "輸入" + ChatColor.YELLOW + "/race exterior " + ChatColor.GREEN + "即可啟用或停用種族外觀特徵"); +*/ + sender.sendMessage( + ChatColor.GREEN + "輸入" + ChatColor.YELLOW + "/race choose 種族英文名 " + ChatColor.GREEN + "即可選擇種族"); + sender.sendMessage(ChatColor.RED + "選擇種族後將無法更改"); + + /* + sender.sendMessage(ChatColor.GREEN + "種族列表:"); + Set keys = Races.races.keySet(); + for (String key : keys) { + Race race = Races.getRace(key); + sender.sendMessage(ChatColor.GOLD + key + ChatColor.GRAY + ": " + ChatColor.YELLOW + race.getDisplayName() + + " " + ChatColor.LIGHT_PURPLE + race.getDescription()); + } + */ + } + + public static void disable(Player player) { + YamlConfiguration y = Players.getYaml(player); + y.set("Exterior", false); + enable.remove(player); + } + + public static void enable(Player player) { + YamlConfiguration y = Players.getYaml(player); + y.set("Exterior", true); + enable.add(player); + } + + public static boolean isEnable(Player player) { + return enable.contains(player); + } +} diff --git a/src/main/java/nashi/NRPG/Commands/ResetCommand.java b/src/main/java/nashi/NRPG/Commands/ResetCommand.java new file mode 100644 index 0000000..e71a11d --- /dev/null +++ b/src/main/java/nashi/NRPG/Commands/ResetCommand.java @@ -0,0 +1,49 @@ +package nashi.NRPG.Commands; + +import java.util.HashSet; +import java.util.Set; + +import org.bukkit.ChatColor; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; +import org.bukkit.scheduler.BukkitRunnable; + +import nashi.NRPG.API.SkillAPI; +import nashi.NRPG.Players.Players; + +public class ResetCommand implements CommandExecutor { + private static Set reset = new HashSet(); + + @Override + public boolean onCommand(CommandSender sender, Command cmd, String cmdlable, String[] args) { + if (sender instanceof Player) { + Player player = (Player) sender; + if (args.length == 0) { + player.sendMessage(ChatColor.RED + "如果確定要重設資料請在30秒內輸入/reset confirm"); + reset.add(player); + sec(player); + } else if (args[0].equalsIgnoreCase("confirm")) { + if (reset.contains(player)) { + reset.remove(player); + Players.delete(player); + Players.delete(player);// bug 需要reset兩次來生效.. + player.sendMessage(ChatColor.GOLD + "你已重設你的資料"); + } + } + + return true; + } + return false; + } + + private void sec(Player player) { + new BukkitRunnable() { + @Override + public void run() { + reset.remove(player); + } + }.runTaskLater(SkillAPI.plugin(), 600); + } +} diff --git a/src/main/java/nashi/NRPG/Commands/ScaleCommand.java b/src/main/java/nashi/NRPG/Commands/ScaleCommand.java new file mode 100644 index 0000000..927ca16 --- /dev/null +++ b/src/main/java/nashi/NRPG/Commands/ScaleCommand.java @@ -0,0 +1,36 @@ +package nashi.NRPG.Commands; + +import org.bukkit.ChatColor; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; + +import nashi.NRPG.Players.Players; + +public class ScaleCommand implements CommandExecutor { + @Override + public boolean onCommand(CommandSender sender, Command cmd, String cmdlable, String[] args) { + if (args.length == 0) { + Commands.sendHelp(sender); + return true; + } else { + if (args[0] != null) { + if (sender instanceof Player) { + Player player = (Player) sender; + int i = Integer.parseInt(args[0]); + YamlConfiguration y = Players.getYaml(player); + y.set("Scale", i); + if (i < 1) { + sender.sendMessage(ChatColor.RED + "請輸入大於1的數字"); + return true; + } + player.setHealthScale(i); + return true; + } + } + } + return false; + } +} diff --git a/src/main/java/nashi/NRPG/Commands/SkillEditCommand.java b/src/main/java/nashi/NRPG/Commands/SkillEditCommand.java new file mode 100644 index 0000000..763fb3e --- /dev/null +++ b/src/main/java/nashi/NRPG/Commands/SkillEditCommand.java @@ -0,0 +1,46 @@ +package nashi.NRPG.Commands; + +import org.bukkit.ChatColor; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; + +import nashi.NRPG.Players.Players; +import nashi.NRPG.Skills.GUI; +import nashi.NRPG.Skills.SkillName; + +public class SkillEditCommand implements CommandExecutor { + @Override + public boolean onCommand(CommandSender sender, Command cmd, String cmdlable, String[] args) { + if (args.length == 0) { + if (sender instanceof Player) { + Player player = (Player) sender; + GUI.EditGUI(player, 0); + } + return true; + } else { + if (sender instanceof Player) { + Player player = (Player) sender; + String skname = SkillName.get(args[0]); + YamlConfiguration y = Players.getYaml(player); + if (y.getStringList("UniqeSkills").contains(skname)) { + try { + if (y.getConfigurationSection(("Skills." + skname + ".Custom")).getKeys(false).size() > 0) { + GUI.openSkillEditGUI(player, skname); + } else { + player.sendMessage(ChatColor.RED + "請確認技能是否有可自定的數值"); + } + } catch (Exception e) { + player.sendMessage(ChatColor.RED + "請確認技能是否有可自定的數值"); + } + } else { + player.sendMessage(ChatColor.RED + "技能不存在,請確認是否擁有此技能或名稱是否正確"); + } + } + return true; + + } + } +} diff --git a/src/main/java/nashi/NRPG/Commands/SkillSlotCommand.java b/src/main/java/nashi/NRPG/Commands/SkillSlotCommand.java new file mode 100644 index 0000000..85877f2 --- /dev/null +++ b/src/main/java/nashi/NRPG/Commands/SkillSlotCommand.java @@ -0,0 +1,64 @@ +package nashi.NRPG.Commands; + +import nashi.NRPG.Players.Players; +import nashi.NRPG.Skills.GUI; +import nashi.NRPG.Skills.SkillName; +import nashi.NRPG.listeners.EventListener; + +import org.bukkit.ChatColor; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; + +public class SkillSlotCommand implements CommandExecutor { + public boolean onCommand(CommandSender sender, Command cmd, String cmdlable, String[] args) { + Player player; + if (args.length == 0) { + if (sender instanceof Player) { + player = (Player) sender; + if (!EventListener.skillmode.get(player)) { + GUI.SlotGUI(player, 0); + } else { + player.sendMessage(ChatColor.RED + "請先離開施法模式"); + } + } + + return true; + } else if (args[0] == null) { + return false; + } else { + if (sender instanceof Player) { + player = (Player) sender; + int slot = Integer.parseInt(args[0]) - 1; + if (slot < 0 || slot > 8) { + player.sendMessage(ChatColor.RED + "請輸入1~9的數字"); + return true; + } + + YamlConfiguration y = Players.getYaml(player); + + try { + String skname = SkillName.get(args[1]); + boolean have = false; + if (y.getStringList("UniqeSkills").contains(skname)) { + have = true; + } + + if (have) { + y.set("Slot." + slot, skname); + player.sendMessage(ChatColor.GREEN + "你已將" + skname + "綁定至欄位" + (slot + 1)); + } else { + player.sendMessage(ChatColor.RED + "技能不存在,請確認是否擁有此技能或名稱是否正確"); + } + } catch (ArrayIndexOutOfBoundsException var10) { + y.set("Slot." + slot, (Object) null); + player.sendMessage(ChatColor.GREEN + "你已將欄位" + (slot + 1) + "清空"); + } + } + + return true; + } + } +} \ No newline at end of file diff --git a/src/main/java/nashi/NRPG/Commands/StatCommand.java b/src/main/java/nashi/NRPG/Commands/StatCommand.java new file mode 100644 index 0000000..9c01851 --- /dev/null +++ b/src/main/java/nashi/NRPG/Commands/StatCommand.java @@ -0,0 +1,57 @@ +package nashi.NRPG.Commands; + +import java.text.DecimalFormat; + +import org.bukkit.ChatColor; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; + +import nashi.NRPG.API.Utils; +import nashi.NRPG.Players.Players; +import nashi.NRPG.Players.Players.PlayerData; +import nashi.NRPG.Skills.SkillName; + +public class StatCommand implements CommandExecutor { + public static DecimalFormat df = new DecimalFormat("#.##"); + + @Override + public boolean onCommand(CommandSender sender, Command cmd, String cmdlable, String[] args) { + + if (sender instanceof Player) { + Player player = (Player) sender; + YamlConfiguration y = Players.getYaml(player); + PlayerData pdata = Players.Data.get(player); + player.sendMessage(ChatColor.GREEN + "詠唱間隔: " + y.getInt("CastSpeed")); + + player.sendMessage(ChatColor.GREEN + "種族: " + ChatColor.GOLD + pdata.getRace().getDisplayName()); + int slot = y.getInt("UniqueSkillSlots"); + if (slot < 0) { + slot = 0; + } + player.sendMessage(ChatColor.GREEN + "等級: " + ChatColor.GOLD + pdata.getStatus().getLvL()); + player.sendMessage(ChatColor.GOLD + "能力值"); + player.sendMessage(ChatColor.GREEN + "血量倍率: " + ChatColor.GOLD + df.format(pdata.getTotalStatusHP()*pdata.getStatus().getLvL())); + player.sendMessage(ChatColor.GREEN + "魔力倍率: " + ChatColor.GOLD + df.format(pdata.getTotalStatusMP()*pdata.getStatus().getLvL())); + player.sendMessage(ChatColor.GREEN + "攻擊倍率: " + ChatColor.GOLD + df.format(pdata.getDamage())); + player.sendMessage(ChatColor.GREEN + "遠程倍率: " + ChatColor.GOLD + df.format(pdata.getRangeDamage())); + player.sendMessage(ChatColor.GREEN + "技能倍率: " + ChatColor.GOLD + df.format(pdata.getSkillDamage())); + player.sendMessage(ChatColor.GREEN + "迴避率/爆擊率: " + ChatColor.GOLD + df.format(pdata.getTotalStatusLUK()*Utils.LUKAVD)+"% / "+df.format(pdata.getTotalStatusLUK()*Utils.LUKCRIT)+"%"); + player.sendMessage(ChatColor.GREEN + "速度: " + ChatColor.GOLD + df.format(pdata.getTotalStatusSpeed()*Utils.SPDSpeed+Utils.basespd)); + player.sendMessage(ChatColor.GREEN + "裝甲倍率: " + ChatColor.GOLD + df.format(pdata.getTotalStatusArmor())); + player.sendMessage( + ChatColor.GREEN + "抗性倍率: " + ChatColor.GOLD + df.format(pdata.getTotalStatusArmorToughness())); + player.sendMessage(ChatColor.GREEN + "額外技能槽數量: " + ChatColor.GOLD + slot); + player.sendMessage(ChatColor.GREEN + "技能列表: "); + for (String str : y.getStringList("UniqeSkills")) { + player.sendMessage(ChatColor.YELLOW + "- " + ChatColor.LIGHT_PURPLE + SkillName.get(str) + + ChatColor.GREEN + " " + Players.skillsetting.getString(SkillName.get(str) + ".Description")); + } + return true; + } + return false; + } + +} diff --git a/src/main/java/nashi/NRPG/CustomEvents/CastEvent.java b/src/main/java/nashi/NRPG/CustomEvents/CastEvent.java new file mode 100644 index 0000000..a1c0080 --- /dev/null +++ b/src/main/java/nashi/NRPG/CustomEvents/CastEvent.java @@ -0,0 +1,49 @@ +package nashi.NRPG.CustomEvents; + +import org.bukkit.entity.Player; +import org.bukkit.event.Cancellable; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; + +import nashi.NRPG.listeners.EventListener.Casting; + +public class CastEvent extends Event implements Cancellable { + private static final HandlerList handlers = new HandlerList(); + private Casting cast; + private Player player; + private boolean b; + + public CastEvent(Player player, Casting cast) { + this.cast = cast; + this.player = player; + } + + public Casting getCast() { + return cast; + } + + public Player getPlayer() { + return player; + } + + @Override + public HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } + + @Override + public boolean isCancelled() { + // TODO Auto-generated method stub + return b; + } + + @Override + public void setCancelled(boolean arg0) { + b = arg0; + + } +} diff --git a/src/main/java/nashi/NRPG/CustomEvents/CastStartEvent.java b/src/main/java/nashi/NRPG/CustomEvents/CastStartEvent.java new file mode 100644 index 0000000..f38d152 --- /dev/null +++ b/src/main/java/nashi/NRPG/CustomEvents/CastStartEvent.java @@ -0,0 +1,68 @@ +package nashi.NRPG.CustomEvents; + +import org.bukkit.ChatColor; +import org.bukkit.Material; +import org.bukkit.entity.Player; +import org.bukkit.event.Cancellable; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; +import org.bukkit.persistence.PersistentDataContainer; +import org.bukkit.persistence.PersistentDataType; + +import nashi.NRPG.listeners.ModifyItem; +import nashi.NRPG.listeners.EventListener.Casting; + +public class CastStartEvent extends Event implements Cancellable { + private static final HandlerList handlers = new HandlerList(); + private Casting cast; + private Player player; + + public CastStartEvent(Player player, Casting cast) { + this.cast = cast; + this.player = player; + ItemStack item = player.getInventory().getItemInOffHand(); + if (item == null || item.getType() == Material.AIR) { + ItemStack n = new ItemStack(Material.STICK); + ItemMeta m = n.getItemMeta(); + m.setDisplayName(ChatColor.GOLD + "施法判定用道具"); + PersistentDataContainer pdc = m.getPersistentDataContainer(); + byte a = 100; + pdc.set(ModifyItem.CastHelp, PersistentDataType.BYTE, a); + n.setItemMeta(m); + player.getInventory().setItemInOffHand(n); + } + } + + public Casting getCast() { + return cast; + } + + public Player getPlayer() { + return player; + } + + @Override + public boolean isCancelled() { + // TODO Auto-generated method stub + return b; + } + + private boolean b; + + @Override + public void setCancelled(boolean arg0) { + b = arg0; + + } + + @Override + public HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } +} diff --git a/src/main/java/nashi/NRPG/CustomEvents/PreSkillUseEvent.java b/src/main/java/nashi/NRPG/CustomEvents/PreSkillUseEvent.java new file mode 100644 index 0000000..a2156d2 --- /dev/null +++ b/src/main/java/nashi/NRPG/CustomEvents/PreSkillUseEvent.java @@ -0,0 +1,56 @@ +package nashi.NRPG.CustomEvents; + +import org.bukkit.entity.Player; +import org.bukkit.event.Cancellable; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; + +public class PreSkillUseEvent extends Event implements Cancellable { + private static final HandlerList handlers = new HandlerList(); + private Player player; + private String SkillName; + private boolean cd; + private boolean isCancelled; + private boolean isitem; + + public PreSkillUseEvent(Player player, String skillname, boolean isSkillItem) { + this.player = player; + this.SkillName = skillname; + this.isitem = isSkillItem; + } + + public boolean isCastByItem() { + return this.isitem; + } + + public boolean toCooldown() { + return this.cd; + } + + public String getSkillName() { + return this.SkillName; + } + + public Player getPlayer() { + return player; + } + + @Override + public HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } + + @Override + public boolean isCancelled() { + return isCancelled; + } + + @Override + public void setCancelled(boolean cancelled) { + this.isCancelled = cancelled; + } +} diff --git a/src/main/java/nashi/NRPG/CustomEvents/RaceChangeEvent.java b/src/main/java/nashi/NRPG/CustomEvents/RaceChangeEvent.java new file mode 100644 index 0000000..b659e16 --- /dev/null +++ b/src/main/java/nashi/NRPG/CustomEvents/RaceChangeEvent.java @@ -0,0 +1,41 @@ +package nashi.NRPG.CustomEvents; + +import org.bukkit.entity.Player; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; + +import nashi.NRPG.Players.Races.Race; + +public class RaceChangeEvent extends Event { + private static final HandlerList handlers = new HandlerList(); + private Player player; + private Race race; + private Race old; + + public RaceChangeEvent(Player player, Race old, Race race) { + this.player = player; + this.race = race; + this.old = old; + } + + public Race getOldRace() { + return old; + } + + public Race getRace() { + return this.race; + } + + public Player getPlayer() { + return player; + } + + @Override + public HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } +} diff --git a/src/main/java/nashi/NRPG/CustomEvents/SkillItemGenerateEvent.java b/src/main/java/nashi/NRPG/CustomEvents/SkillItemGenerateEvent.java new file mode 100644 index 0000000..040b3e7 --- /dev/null +++ b/src/main/java/nashi/NRPG/CustomEvents/SkillItemGenerateEvent.java @@ -0,0 +1,40 @@ +package nashi.NRPG.CustomEvents; + +import org.bukkit.entity.Player; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +import org.bukkit.inventory.ItemStack; + +public class SkillItemGenerateEvent extends Event { + private static final HandlerList handlers = new HandlerList(); + private Player player; + private ItemStack item; + private String skillname; + + public SkillItemGenerateEvent(Player player, ItemStack item, String skillname) { + this.player = player; + this.item = item; + this.skillname = skillname; + } + + public String getSkillName() { + return skillname; + } + + public ItemStack getItem() { + return this.item; + } + + public Player getPlayer() { + return player; + } + + @Override + public HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } +} diff --git a/src/main/java/nashi/NRPG/CustomEvents/SkillLearnEvent.java b/src/main/java/nashi/NRPG/CustomEvents/SkillLearnEvent.java new file mode 100644 index 0000000..92e25bc --- /dev/null +++ b/src/main/java/nashi/NRPG/CustomEvents/SkillLearnEvent.java @@ -0,0 +1,33 @@ +package nashi.NRPG.CustomEvents; + +import org.bukkit.entity.Player; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; + +public class SkillLearnEvent extends Event { + private static final HandlerList handlers = new HandlerList(); + private String skillname; + private Player player; + + public SkillLearnEvent(Player player, String skillname) { + this.player = player; + this.skillname = skillname; + } + + public String getSkillName() { + return this.skillname; + } + + public Player getPlayer() { + return player; + } + + @Override + public HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } +} diff --git a/src/main/java/nashi/NRPG/CustomEvents/SkillUsedEvent.java b/src/main/java/nashi/NRPG/CustomEvents/SkillUsedEvent.java new file mode 100644 index 0000000..b9cb41e --- /dev/null +++ b/src/main/java/nashi/NRPG/CustomEvents/SkillUsedEvent.java @@ -0,0 +1,39 @@ +package nashi.NRPG.CustomEvents; + +import org.bukkit.entity.Player; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; + +public class SkillUsedEvent extends Event { + private static final HandlerList handlers = new HandlerList(); + private Player player; + private String SkillName; + private boolean success; + + public SkillUsedEvent(Player player, String skillname, boolean isSuccess) { + this.player = player; + this.SkillName = skillname; + this.success = isSuccess; + } + + public boolean isSuccess() { + return this.success; + } + + public String getSkillName() { + return this.SkillName; + } + + public Player getPlayer() { + return player; + } + + @Override + public HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } +} diff --git a/src/main/java/nashi/NRPG/Items/CreateItem.java b/src/main/java/nashi/NRPG/Items/CreateItem.java new file mode 100644 index 0000000..6cbcdf4 --- /dev/null +++ b/src/main/java/nashi/NRPG/Items/CreateItem.java @@ -0,0 +1,303 @@ +package nashi.NRPG.Items; + +import java.io.File; +import java.lang.reflect.Field; +import java.util.HashMap; +import java.util.Set; +import java.util.UUID; + +import org.bukkit.ChatColor; +import org.bukkit.Material; +import org.bukkit.NamespacedKey; +import org.bukkit.Note; +import org.bukkit.Note.Tone; +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.inventory.EquipmentSlot; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; +import org.bukkit.inventory.meta.SkullMeta; +import org.bukkit.persistence.PersistentDataContainer; +import org.bukkit.persistence.PersistentDataType; +import com.mojang.authlib.GameProfile; +import com.mojang.authlib.properties.Property; + +import nashi.NRPG.Main; + +public class CreateItem { + public static Note notes[] = new Note[25]; + public static final char blank = ' '; + public static final int size = 25; + public static int max; + public static long rate; + private static NamespacedKey key_item_forge = new NamespacedKey(Main.getPlugin(), "NRPG_Forge_Item_Forge"); + private static NamespacedKey key_item_time = new NamespacedKey(Main.getPlugin(), "NRPG_Forge_Item_Time"); + private static NamespacedKey key_item_type = new NamespacedKey(Main.getPlugin(), "NRPG_Forge_Item_Type"); + public static NamespacedKey key_material = new NamespacedKey(Main.getPlugin(), "NRPG_Forge_Material"); + public static NamespacedKey key_click = new NamespacedKey(Main.getPlugin(), "NRPG_Forge_Click"); + public static ItemStack click; + public static HashMap limits = new HashMap(); + public static HashMap technique = new HashMap(); + public static HashMap rand_technique = new HashMap(); + + public static void init() { + notes[0] = new Note(0, Tone.A, false); + notes[1] = new Note(0, Tone.A, true); + notes[2] = new Note(0, Tone.B, false); + notes[3] = new Note(0, Tone.C, false); + notes[4] = new Note(0, Tone.C, true); + notes[5] = new Note(0, Tone.D, false); + notes[6] = new Note(0, Tone.D, true); + notes[7] = new Note(0, Tone.E, false); + notes[8] = new Note(0, Tone.F, false); + notes[9] = new Note(0, Tone.F, true); + notes[10] = new Note(0, Tone.G, false); + notes[11] = new Note(0, Tone.G, true); + + notes[12] = new Note(1, Tone.A, false); + notes[13] = new Note(1, Tone.A, true); + notes[14] = new Note(1, Tone.B, false); + notes[15] = new Note(1, Tone.C, false); + notes[16] = new Note(1, Tone.C, true); + notes[17] = new Note(1, Tone.D, false); + notes[18] = new Note(1, Tone.D, true); + notes[19] = new Note(1, Tone.E, false); + notes[20] = new Note(1, Tone.F, false); + notes[21] = new Note(1, Tone.F, true); + notes[22] = new Note(1, Tone.G, false); + notes[23] = new Note(1, Tone.G, true); + + notes[24] = new Note(2, Tone.F, true); + FileConfiguration yml = Main.getPlugin().getConfig(); + YamlConfiguration forge = YamlConfiguration + .loadConfiguration(new File(Main.getPlugin().getDataFolder() + File.separator + "forge.yml")); + Set slot = forge.getConfigurationSection("technique").getKeys(false); + technique.clear(); + rand_technique.clear(); + for (String slotkey : slot) { + Set tier = forge.getConfigurationSection("technique." + slotkey).getKeys(false); + for (String tierkey : tier) { + Technique[] tech = new Technique[25]; + for (int i = 0; i < 25; i++) { + String str = forge.getString("technique." + slotkey + "." + tierkey + "." + i); + tech[i] = new Technique(str, Integer.parseInt(slotkey)); + } + technique.put(slotkey + "." + tierkey, tech); + } + } + Set slots = forge.getConfigurationSection("max").getKeys(false); + limits.clear(); + for (String slotkey : slots) { + String str = forge.getString("max." + slotkey); + limits.put(slotkey, new Technique(str, Integer.parseInt(slotkey))); + } + // Random + Set RandomLevel = forge.getConfigurationSection("Random").getKeys(false); + for (String slotkey : RandomLevel) { + Technique[] tech = new Technique[6]; + for (int s = 0; s <= 5; s++) { + String str = forge.getString("Random." + slotkey + "." + s); + tech[s] = new Technique(str); + } + rand_technique.put("r" + slotkey, tech); + } + // Random Ended + max = yml.getInt("MaxForge"); + rate = yml.getLong("RateOfNote"); + ItemStack item = getCustomTextureHead( + "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNDNkMDRkYmE1MWY4OTI0OTU4MzRmZjcxYTQyOWE4YTkxMDE1YTVhNzg2Yjg1NmZmZTljMDI0Y2RiNTJmYmM4ZiJ9fX0="); + ItemMeta im = item.getItemMeta(); + im.setDisplayName(ChatColor.GOLD + "" + ChatColor.BOLD + "鍛造"); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(key_click, PersistentDataType.INTEGER, 1); + item.setItemMeta(im); + click = item; + } + + public static ItemStack getCustomTextureHead(String value) { + ItemStack head = new ItemStack(Material.PLAYER_HEAD); + SkullMeta meta = (SkullMeta) head.getItemMeta(); + GameProfile profile = new GameProfile(UUID.randomUUID(), ""); + profile.getProperties().put("textures", new Property("textures", value)); + Field profileField = null; + try { + profileField = meta.getClass().getDeclaredField("profile"); + profileField.setAccessible(true); + profileField.set(meta, profile); + } catch (IllegalArgumentException | IllegalAccessException | NoSuchFieldException | SecurityException e) { + e.printStackTrace(); + } + head.setItemMeta(meta); + return head; + } + + public static class Technique { + public boolean isRandom = false; + public double Rand_Max; + public double Rand_Min; + + public double MAX_MANA; + public double MAX_HEALTH; + public double ARMOR_TOUGHNESS; + public double ARMOR; + public double ATTACK_DAMAGE; + public double ATTACK_SPEED; + public double ATTACK_RANGE; + public double KNOCKBACK_RESISTANCE; + public double MOVEMENT_SPEED; + public double CAST_MOD; + + public EquipmentSlot slot; + + public Technique(String raw, int slot) { + String[] str = raw.split(","); + this.MAX_MANA = Double.parseDouble(str[0]); + this.MAX_HEALTH = Double.parseDouble(str[1]); + this.ARMOR_TOUGHNESS = Double.parseDouble(str[2]); + this.ARMOR = Double.parseDouble(str[3]); + this.ATTACK_DAMAGE = Double.parseDouble(str[4]); + this.ATTACK_SPEED = Double.parseDouble(str[5]); + this.ATTACK_RANGE = Double.parseDouble(str[6]); + this.KNOCKBACK_RESISTANCE = Double.parseDouble(str[7]); + this.MOVEMENT_SPEED = Double.parseDouble(str[8]); + this.CAST_MOD = Double.parseDouble(str[9]); + this.slot = getEquipmentSlotFromInt(slot); + this.isRandom = false; + } + + public Technique(double arr[], int slot) { + this.MAX_MANA = arr[0]; + this.MAX_HEALTH = arr[1]; + this.ARMOR_TOUGHNESS = arr[2]; + this.ARMOR = arr[3]; + this.ATTACK_DAMAGE = arr[4]; + this.ATTACK_SPEED = arr[5]; + this.ATTACK_RANGE = arr[6]; + this.KNOCKBACK_RESISTANCE = arr[7]; + this.MOVEMENT_SPEED = arr[8]; + this.CAST_MOD = arr[9]; + this.slot = getEquipmentSlotFromInt(slot); + this.isRandom = false; + } + + public Technique(double arr[]) {// for Random + this.Rand_Min = arr[0]; + this.Rand_Max = arr[1]; + this.MAX_MANA = arr[2]; + this.MAX_HEALTH = arr[3]; + this.ARMOR_TOUGHNESS = arr[4]; + this.ARMOR = arr[5]; + this.ATTACK_DAMAGE = arr[6]; + this.ATTACK_SPEED = arr[7]; + this.ATTACK_RANGE = arr[8]; + this.KNOCKBACK_RESISTANCE = arr[9]; + this.MOVEMENT_SPEED = arr[10]; + this.CAST_MOD = arr[11]; + this.isRandom = true; + } + + public Technique(String raw) {// for Random + String[] str = raw.split(","); + this.Rand_Min = Double.parseDouble(str[0]); + this.Rand_Max = Double.parseDouble(str[1]); + this.MAX_MANA = Double.parseDouble(str[2]); + this.MAX_HEALTH = Double.parseDouble(str[3]); + this.ARMOR_TOUGHNESS = Double.parseDouble(str[4]); + this.ARMOR = Double.parseDouble(str[5]); + this.ATTACK_DAMAGE = Double.parseDouble(str[6]); + this.ATTACK_SPEED = Double.parseDouble(str[7]); + this.ATTACK_RANGE = Double.parseDouble(str[8]); + this.KNOCKBACK_RESISTANCE = Double.parseDouble(str[9]); + this.MOVEMENT_SPEED = Double.parseDouble(str[10]); + this.CAST_MOD = Double.parseDouble(str[11]); + this.isRandom = true; + } + + public boolean isRandom() { + return this.isRandom; + } + } + + public static EquipmentSlot getEquipmentSlotFromInt(int i) { + switch (i) { + case 0: + return EquipmentSlot.HAND; + case 1: + return EquipmentSlot.FEET; + case 2: + return EquipmentSlot.LEGS; + case 3: + return EquipmentSlot.CHEST; + case 4: + return EquipmentSlot.HEAD; + default: + return EquipmentSlot.OFF_HAND; + + } + } + + public static void setItemForgeMaterialTier(ItemStack item, String tier) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(key_material, PersistentDataType.STRING, tier); + item.setItemMeta(im); + } + + public static void setItemForgeKey(ItemStack item, int i) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(key_item_forge, PersistentDataType.INTEGER, i); + item.setItemMeta(im); + } + + public static void setItemForgeSlot(ItemStack item, int i) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(key_item_type, PersistentDataType.INTEGER, i); + item.setItemMeta(im); + } + + public static int getItemForgeKey(ItemStack item) { + if (item == null || item.getType() == Material.AIR) { + return -1; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(key_item_forge, PersistentDataType.INTEGER)) { + return pdc.get(key_item_forge, PersistentDataType.INTEGER); + } + return -1; + } + + public static int getItemForgeSlot(ItemStack item) { + if (item == null || item.getType() == Material.AIR) { + return -1; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(key_item_type, PersistentDataType.INTEGER)) { + return pdc.get(key_item_type, PersistentDataType.INTEGER); + } + return -1; + } + + public static int getItemForgeTime(ItemStack item) { + if (item == null || item.getType() == Material.AIR) { + return -1; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(key_item_time, PersistentDataType.INTEGER)) { + return pdc.get(key_item_time, PersistentDataType.INTEGER); + } + return -1; + } + + public static void setItemForgeTime(ItemStack item, int i) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(key_item_time, PersistentDataType.INTEGER, i); + item.setItemMeta(im); + } + +} diff --git a/src/main/java/nashi/NRPG/Main.java b/src/main/java/nashi/NRPG/Main.java new file mode 100644 index 0000000..99807ad --- /dev/null +++ b/src/main/java/nashi/NRPG/Main.java @@ -0,0 +1,297 @@ +package nashi.NRPG; + +import java.io.File; +import java.text.DecimalFormat; +import java.util.HashSet; +import java.util.Set; + +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.World; +import org.bukkit.attribute.Attribute; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; +import org.bukkit.inventory.EquipmentSlot; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.PlayerInventory; +import org.bukkit.plugin.Plugin; +import org.bukkit.plugin.java.JavaPlugin; +import org.bukkit.scheduler.BukkitRunnable; +import org.bukkit.scoreboard.DisplaySlot; +import org.bukkit.scoreboard.Objective; +import org.bukkit.scoreboard.Scoreboard; +import org.bukkit.scoreboard.Team; + +import edited.com.codingforcookies.armorequip.ArmorListener; +import edited.com.codingforcookies.armorequip.DispenserArmorListener; +import nashi.NRPG.API.Utils; +import nashi.NRPG.Commands.AbandonCommand; +import nashi.NRPG.Commands.CastCommand; +import nashi.NRPG.Commands.Commands; +import nashi.NRPG.Commands.RaceCommand; +import nashi.NRPG.Commands.ResetCommand; +import nashi.NRPG.Commands.ScaleCommand; +import nashi.NRPG.Commands.SkillEditCommand; +import nashi.NRPG.Commands.SkillSlotCommand; +import nashi.NRPG.Commands.StatCommand; +import nashi.NRPG.Players.Players; +import nashi.NRPG.Players.Players.PlayerData; +import nashi.NRPG.Skills.Magic; +import nashi.NRPG.Skills.NewSkill; +import nashi.NRPG.Skills.SkillName; +import nashi.NRPG.listeners.AllAboutDamage; +import nashi.NRPG.listeners.EventListener; +import nashi.NRPG.listeners.ForgeListener; +import nashi.NRPG.listeners.ModifyItem; +import nashi.NRPG.listeners.MythicMobsListener; +import nashi.NRPG.listeners.ProtocolLibEvent; +import nashi.NRPG.listeners.SkillItemListener; + +public class Main extends JavaPlugin { + private static Plugin plugin; + private static boolean loaded; + public static boolean cancel; + public static Set worlds = new HashSet(); + + public void onEnable() { + plugin = this; + if (!new File(getDataFolder(), "config.yml").exists()) { + saveDefaultConfig(); + } + if (!new File(getDataFolder(), "skills.yml").exists()) { + getPlugin().saveResource("skills.yml", false); + } + if (!new File(getDataFolder(), "mobs.yml").exists()) { + getPlugin().saveResource("mobs.yml", false); + } + if (!new File(getDataFolder(), "blocked.yml").exists()) { + getPlugin().saveResource("blocked.yml", false); + } + if (!new File(getDataFolder(), "races.yml").exists()) { + getPlugin().saveResource("races.yml", false); + } + reloadConfig(); + Bukkit.getLogger().info("Loading Settings..."); + Utils.init(); + + getCommand("nrpg").setExecutor(new Commands()); + + getCommand("stat").setExecutor(new StatCommand()); + getCommand("skilledit").setExecutor(new SkillEditCommand()); + getCommand("cast").setExecutor(new CastCommand()); + getCommand("slot").setExecutor(new SkillSlotCommand()); + getCommand("scale").setExecutor(new ScaleCommand()); + getCommand("abandon").setExecutor(new AbandonCommand()); + getCommand("race").setExecutor(new RaceCommand()); + getCommand("reset").setExecutor(new ResetCommand()); + + Bukkit.getLogger().info("Loading Skills.."); + NewSkill.loadskill(); + Bukkit.getLogger().info(SkillName.skillname.size() + " skill(s) loaded"); + + getServer().getPluginManager().registerEvents(new EventListener(), this); + getServer().getPluginManager().registerEvents(new AllAboutDamage(), this); + getServer().getPluginManager().registerEvents(new ModifyItem(), this); + getServer().getPluginManager().registerEvents(new ForgeListener(), this); + getServer().getPluginManager().registerEvents(new SkillItemListener(), this); + + if (Bukkit.getServer().getPluginManager().isPluginEnabled("MythicMobs")) { + Bukkit.getLogger().info("MythicMobs Detected"); + getServer().getPluginManager().registerEvents(new MythicMobsListener(), this); + } + + YamlConfiguration block = YamlConfiguration.loadConfiguration(new File(getDataFolder(), "blocked.yml")); + getServer().getPluginManager().registerEvents(new ArmorListener(block.getStringList("blocked")), this); + if (Bukkit.getServer().getPluginManager().isPluginEnabled("ProtocolLib")) { + Bukkit.getLogger().info("ProtocolLib Detected"); + cancel = true; + ProtocolLibEvent.run(); + } else { + cancel = false; + } + try { + Class.forName("org.bukkit.event.block.BlockDispenseArmorEvent"); + getServer().getPluginManager().registerEvents(new DispenserArmorListener(), this); + } catch (Exception localException) { + } + if (Bukkit.getOnlinePlayers().size() > 0) { + Bukkit.getLogger().warning("/reload command is not recommended"); + Bukkit.getLogger().warning("Might causes problems"); + Bukkit.getLogger().info("Loading All Online Players.."); + for (Player player : Bukkit.getServer().getOnlinePlayers()) { + Players.loadYaml(player); + EventListener.skillmode.put(player, false); + Magic.check(player); + Main.setPlayerScoreboard(player); + YamlConfiguration py = Players.getYaml(player); + int a = py.getInt("Scale"); + if (a > 0) { + player.setHealthScale(a); + } + PlayerData pd = Players.Data.get(player); + + float speed = 0.0f; + double hp = 0.0; + double mp = 0.0; + double ar = 0.0; + double at = 0.0; + ItemStack helmet = player.getInventory().getHelmet(); + ModifyItem.updateItem(helmet, EquipmentSlot.HEAD); + mp += ModifyItem.getItemMP(helmet); + hp += ModifyItem.getItemHP(helmet); + speed += ModifyItem.getItemSD(helmet); + ar += ModifyItem.getItemAR(helmet); + at += ModifyItem.getItemAT(helmet); + + ItemStack chest = player.getInventory().getChestplate(); + ModifyItem.updateItem(chest, EquipmentSlot.CHEST); + mp += ModifyItem.getItemMP(chest); + hp += ModifyItem.getItemHP(chest); + speed += ModifyItem.getItemSD(chest); + ar += ModifyItem.getItemAR(chest); + at += ModifyItem.getItemAT(chest); + + ItemStack leg = player.getInventory().getLeggings(); + ModifyItem.updateItem(leg, EquipmentSlot.LEGS); + mp += ModifyItem.getItemMP(leg); + hp += ModifyItem.getItemHP(leg); + speed += ModifyItem.getItemSD(leg); + ar += ModifyItem.getItemAR(leg); + at += ModifyItem.getItemAT(leg); + + ItemStack boot = player.getInventory().getBoots(); + ModifyItem.updateItem(boot, EquipmentSlot.FEET); + mp += ModifyItem.getItemMP(boot); + hp += ModifyItem.getItemHP(boot); + speed += ModifyItem.getItemSD(boot); + ar += ModifyItem.getItemAR(boot); + at += ModifyItem.getItemAT(boot); + + ItemStack off = player.getInventory().getItemInOffHand(); + ModifyItem.updateItem(off, EquipmentSlot.OFF_HAND); + mp += ModifyItem.getItemMP(off); + hp += ModifyItem.getItemHP(off); + speed += ModifyItem.getItemSD(off); + ar += ModifyItem.getItemAR(off); + at += ModifyItem.getItemAT(off); + pd.calc(player, mp, hp, speed, ar, at); + EventListener.setData(player, pd); + } + } + + loaded = true; + a(); + b(); + Bukkit.getLogger().info("NRPG is loaded"); + } + + private static void a() { + new BukkitRunnable() { + @Override + public void run() { + if (!loaded) { + this.cancel(); + } + for (Player player : Bukkit.getServer().getOnlinePlayers()) { + if (!player.isDead()) { + PlayerData pd = Players.Data.get(player); + pd.addCurrentMP(Utils.RMP); + double hp = player.getHealth(); + double max = player.getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue(); + if (hp + Utils.RHP < max) { + player.setHealth(hp + Utils.RHP); + } else if (hp < max) { + player.setHealth(max); + } + } + } + + } + }.runTaskTimerAsynchronously(Main.getPlugin(), 200, 200); + } + + private static void b() { + new BukkitRunnable() { + @Override + public void run() { + if (!loaded) { + this.cancel(); + } + for (Player player : Bukkit.getServer().getOnlinePlayers()) { + Main.updateScoreBoard(player); + } + + } + }.runTaskTimerAsynchronously(Main.getPlugin(), 5, 5); + } + + private static Scoreboard board; + private static Objective o; + + public static void setPlayerScoreboard(Player p) { + PlayerData pd = Players.Data.get(p); + board = Bukkit.getServer().getScoreboardManager().getNewScoreboard(); + o = board.registerNewObjective("NRPG", "dummy", "狀態欄"); + o.setDisplayName(ChatColor.GOLD + "狀態欄"); + o.setDisplaySlot(DisplaySlot.SIDEBAR); + Team HP = board.registerNewTeam("HP"); + Team MP = board.registerNewTeam("MP"); + HP.addEntry("" + ChatColor.RED + ChatColor.RED); + MP.addEntry("" + ChatColor.LIGHT_PURPLE + ChatColor.LIGHT_PURPLE); + DecimalFormat dff = new DecimalFormat("#"); + HP.setPrefix(ChatColor.RED + "HP:" + dff.format(p.getHealth()) + "/" + + dff.format(p.getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue())); + o.getScore("" + ChatColor.RED + ChatColor.RED).setScore(14); + MP.setPrefix(ChatColor.LIGHT_PURPLE + "MP:" + dff.format(pd.getCurrentMP()) + "/" + dff.format(pd.getMaxMana())); + o.getScore("" + ChatColor.LIGHT_PURPLE + ChatColor.LIGHT_PURPLE).setScore(13); + p.setScoreboard(board); + } + + public static void updateScoreBoard(Player player) { + PlayerData pd = Players.Data.get(player); + DecimalFormat dff = new DecimalFormat("#"); + Scoreboard board = player.getScoreboard(); + board.getTeam("HP").setPrefix(ChatColor.RED + "HP:" + dff.format(player.getHealth()) + "/" + + dff.format(player.getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue())); + board.getTeam("MP") + .setPrefix(ChatColor.LIGHT_PURPLE + "MP:" + dff.format(pd.getCurrentMP()) + "/" + dff.format(pd.getMaxMana())); + } + + public void onDisable() { + Bukkit.getLogger().info("Disabling NRPG"); + loaded = false; + + NewSkill.unloadAllSkills(); + for (Player player : Bukkit.getServer().getOnlinePlayers()) { + player.closeInventory(); + if (EventListener.backup.containsKey(player)) { + PlayerInventory inv = player.getInventory(); + ItemStack[] back = EventListener.backup.get(player); + int i = 0; + for (ItemStack item : back) { + inv.setItem(i, item); + i++; + } + double d; + if (EventListener.extra.containsKey(player)) { + d = EventListener.extra.get(player); + } else { + d = 0; + } + EventListener.skillmode.put(player, false); + player.getAttribute(Attribute.GENERIC_ATTACK_DAMAGE) + .setBaseValue(player.getAttribute(Attribute.GENERIC_ATTACK_DAMAGE).getBaseValue() - d); + EventListener.extra.remove(player); + EventListener.castmod.remove(player); + } + Players.unload(player); + player.kickPlayer("伺服器重新載入中"); + } + Bukkit.getLogger().info("NRPG Disabled"); + } + + public static Plugin getPlugin() { + return plugin; + } + +} diff --git a/src/main/java/nashi/NRPG/Players/Leveling.java b/src/main/java/nashi/NRPG/Players/Leveling.java new file mode 100644 index 0000000..58f0c60 --- /dev/null +++ b/src/main/java/nashi/NRPG/Players/Leveling.java @@ -0,0 +1,64 @@ +package nashi.NRPG.Players; + +import java.io.File; +import java.util.HashMap; + +import org.bukkit.Bukkit; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; +import org.bukkit.scheduler.BukkitRunnable; + +import nashi.NRPG.Main; +import nashi.NRPG.API.SkillAPI; +import nashi.NRPG.API.Utils.Status; +import nashi.NRPG.listeners.MythicMobsListener; + +public class Leveling { + public static YamlConfiguration setting; + + public static void init() { + setting = YamlConfiguration + .loadConfiguration(new File(Main.getPlugin().getDataFolder() + File.separator + "mobs.yml")); + + } + + public static void check(Player player) { + try { + new BukkitRunnable() { + @Override + public void run() { + HashMap map = MythicMobsListener.MobsKilled.get(player); + Players.PlayerData pd = Players.Data.get(player); + Status s = pd.getStatus(); + int level = s.getLvL(); + for (String key : Leveling.setting.getConfigurationSection("" + level).getKeys(false)) { + boolean b = true; + for (String type : Leveling.setting.getConfigurationSection("" + level + "." + key) + .getKeys(false)) { + int a = Leveling.setting.getInt("" + level + "." + key + "." + type); + if (!map.containsKey(type)) { + b = false; + break; + } + if (map.get(type) < a) { + b = false; + break; + } + } + if (b) { + s.setLvL(level + 1); + map.clear(); + MythicMobsListener.MobsKilled.put(player, map); + Bukkit.getScheduler().scheduleSyncDelayedTask(SkillAPI.plugin(), new Runnable() { + public void run() { + Players.recalcData(player, pd); + } + }, 0); + } + } + } + }.runTaskLaterAsynchronously(Main.getPlugin(), 0); + } catch (Exception e) { + } + } +} diff --git a/src/main/java/nashi/NRPG/Players/Players.java b/src/main/java/nashi/NRPG/Players/Players.java new file mode 100644 index 0000000..c8a47dd --- /dev/null +++ b/src/main/java/nashi/NRPG/Players/Players.java @@ -0,0 +1,528 @@ +package nashi.NRPG.Players; + +import java.io.File; +import java.io.IOException; +import java.util.HashMap; + +import org.bukkit.Bukkit; +import org.bukkit.attribute.Attribute; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; +import org.bukkit.inventory.EquipmentSlot; +import org.bukkit.inventory.ItemStack; + +import nashi.NRPG.Skills.Cast; +import nashi.NRPG.Skills.Magic; +import nashi.NRPG.listeners.EventListener; +import nashi.NRPG.listeners.ModifyItem; +import nashi.NRPG.listeners.MythicMobsListener; +import nashi.NRPG.Main; +import nashi.NRPG.API.SkillAPI; +import nashi.NRPG.API.Utils; +import nashi.NRPG.API.Utils.Status; +import nashi.NRPG.Commands.RaceCommand; +import nashi.NRPG.CustomEvents.RaceChangeEvent; +import nashi.NRPG.Items.CreateItem; +import nashi.NRPG.Players.Races.Race; + +public class Players { + public static HashMap file = new HashMap(); + public static YamlConfiguration skillsetting; + public static YamlConfiguration mobsetting; + public static HashMap Data = new HashMap(); + + public static YamlConfiguration getYaml(Player player) { + return file.get(player); + } + + public static void loadYaml(Player player) { + // File p = new File( + // Main.getPlugin().getDataFolder() + File.separator + "players" + + // File.separator + "players.yml"); + + File f = new File(Main.getPlugin().getDataFolder() + File.separator + "players" + File.separator + + player.getUniqueId().toString() + ".yml"); + HashMap map = new HashMap(); + if (!f.exists()) { + try { + f.createNewFile(); + YamlConfiguration y = YamlConfiguration.loadConfiguration(f); + y.set("ID", player.getName()); + y.set("CastSpeed", 10); + y.set("Race", Races.defaultRace.getName()); + Status stat = Utils.getStatusFromInt(player.getUniqueId().hashCode()); + Utils.setPlayerStatus(player, stat); + y.set("Status.ATK", stat.getATK()); + y.set("Status.SKL", stat.getSKL()); + y.set("Status.AR", stat.getArmor()); + y.set("Status.AT", stat.getArmorToughness()); + y.set("Status.Speed", stat.getSpeed()); + y.set("Status.HP", stat.getHP()); + y.set("Status.MP", stat.getMP()); + y.set("Status.LUK", stat.getLucky()); + y.set("Status.LVL", stat.getLvL()); + y.set("UniqueSkillSlots", + Utils.MaxSlot + - (stat.getSKL() + stat.getATK() + stat.getHP() + stat.getLucky() + stat.getSpeed() + + stat.getMP() + stat.getArmor() + stat.getArmorToughness()) / Utils.STATRAND); + y.set("UsedSlots", 0); + y.set("Exterior", false); + file.put(player, y); + Cast.castspeed.put(player, 10); + RaceCommand.disable(player); + y.save(f); + Data.put(player, new PlayerData(player, stat)); + y.set("MP", Data.get(player).getCurrentMP()); + if ((stat.getATK() + stat.getSKL() + stat.getHP() + stat.getLucky() + stat.getSpeed() + stat.getMP() + + stat.getArmor() + stat.getArmorToughness()) < ((Utils.STATRAND) + 1) * 8 * Utils.MakeUpMod) { + Magic.learnSkill(player, Utils.getRandomMakeUpSkills(), true); + } + /* + * if (!p.exists()) { try { p.createNewFile(); YamlConfiguration py = + * YamlConfiguration.loadConfiguration(p); if + * (!py.contains(player.getUniqueId().toString())) { + * py.set(player.getUniqueId().toString(), true); py.save(p); if ((stat.getATK() + * + stat.getHP() + stat.getLucky() + stat.getSpeed() + stat.getMP() + + * stat.getArmor() + stat.getArmorToughness()) < ((Utils.STATRAND) + 1) * 7 + * Utils.MakeUpMod) { Magic.learnSkill(player, Utils.getRandomMakeUpSkills(), + * true); } } } catch (IOException e) { e.printStackTrace(); } } else { + * YamlConfiguration py = YamlConfiguration.loadConfiguration(p); if + * (!py.contains(player.getUniqueId().toString())) { + * py.set(player.getUniqueId().toString(), true); py.save(p); if ((stat.getATK() + * + stat.getHP() + stat.getLucky() + stat.getSpeed() + stat.getMP() + + * stat.getArmor() + stat.getArmorToughness()) < ((Utils.STATRAND) + 1) * 7 + * Utils.MakeUpMod) { Magic.learnSkill(player, Utils.getRandomMakeUpSkills()); } + * } } + */ + } catch (IOException e) { + e.printStackTrace(); + } + } else { + YamlConfiguration y = YamlConfiguration.loadConfiguration(f); + file.put(player, y); + Cast.castspeed.put(player, y.getInt("CastSpeed")); + int lvl = y.getInt("Status.LVL"); + if (lvl <= 0) { + lvl = 1; + } + Status stat = new Status(y.getInt("Status.SKL"), y.getInt("Status.AR"), y.getInt("Status.AT"), + y.getInt("Status.ATK"), y.getInt("Status.Speed"), y.getInt("Status.HP"), y.getInt("Status.MP"), + y.getInt("Status.LUK"), lvl); + Utils.setPlayerStatus(player, stat); + try { + Data.put(player, new PlayerData(player, Races.getRace(y.getString("Race")), stat, y.getDouble("MP"))); + } catch (Exception e) { + Data.put(player, + new PlayerData(player, Races.getRace(Races.defaultRace.getName()), stat, y.getDouble("MP"))); + } + if (y.getBoolean("Exterior")) { + RaceCommand.enable(player); + } else { + RaceCommand.disable(player); + } + try { + for (String key : y.getConfigurationSection("MobsKilled").getKeys(false)) { + map.put(key, y.getInt("MobsKilled." + key)); + } + } catch (Exception e) { + } + } + MythicMobsListener.MobsKilled.put(player, map); + } + + public static void save(Player player) { + File f = new File(Main.getPlugin().getDataFolder() + File.separator + "players", + player.getUniqueId().toString() + ".yml"); + PlayerData pd = Data.get(player); + YamlConfiguration y = file.get(player); + y.set("Race", pd.getRace().getName()); + y.set("MP", Data.get(player).getCurrentMP()); + y.set("CastSpeed", Cast.castspeed.get(player)); + y.set("Status.SKL", pd.getStatus().getSKL()); + y.set("Status.AR", pd.getStatus().getArmor()); + y.set("Status.AT", pd.getStatus().getArmorToughness()); + y.set("Status.ATK", pd.getStatus().getATK()); + y.set("Status.MP", pd.getStatus().getMP()); + y.set("Status.LUK", pd.getStatus().getLucky()); + y.set("Status.HP", pd.getStatus().getHP()); + y.set("Status.Speed", pd.getStatus().getSpeed()); + y.set("Status.LVL", pd.getStatus().getLvL()); + HashMap map = MythicMobsListener.MobsKilled.get(player); + try { + for (String key : map.keySet()) { + y.set("MobsKilled." + key, map.get(key)); + } + } catch (Exception e) { + } + map.clear(); + MythicMobsListener.MobsKilled.remove(player); + try { + y.save(f); + } catch (IOException e) { + e.printStackTrace(); + } + } + + public static void delete(Player player) { + unload(player); + File f = new File(Main.getPlugin().getDataFolder() + File.separator + "players", + player.getUniqueId().toString() + ".yml"); + f.delete(); + loadYaml(player); + } + + public static void unload(Player player) { + RaceCommand.disable(player); + save(player); + file.remove(player); + } + + public static void recalcData(Player player, PlayerData pd) { + + float speed = 0.0f; + double hp = 0.0; + double mp = 0.0; + double ar = 0.0; + double at = 0.0; + ItemStack helmet = player.getInventory().getHelmet(); + if (CreateItem.getItemForgeSlot(helmet) == 4) { + ModifyItem.updateItem(helmet, EquipmentSlot.HEAD); + mp += ModifyItem.getItemMP(helmet); + hp += ModifyItem.getItemHP(helmet); + speed += ModifyItem.getItemSD(helmet); + ar += ModifyItem.getItemAR(helmet); + at += ModifyItem.getItemAT(helmet); + } + + ItemStack chest = player.getInventory().getChestplate(); + if (CreateItem.getItemForgeSlot(chest) == 3) { + ModifyItem.updateItem(chest, EquipmentSlot.CHEST); + mp += ModifyItem.getItemMP(chest); + hp += ModifyItem.getItemHP(chest); + speed += ModifyItem.getItemSD(chest); + ar += ModifyItem.getItemAR(chest); + at += ModifyItem.getItemAT(chest); + } + + ItemStack leg = player.getInventory().getLeggings(); + if (CreateItem.getItemForgeSlot(leg) == 2) { + ModifyItem.updateItem(leg, EquipmentSlot.LEGS); + mp += ModifyItem.getItemMP(leg); + hp += ModifyItem.getItemHP(leg); + speed += ModifyItem.getItemSD(leg); + ar += ModifyItem.getItemAR(leg); + at += ModifyItem.getItemAT(leg); + } + + ItemStack boot = player.getInventory().getBoots(); + if (CreateItem.getItemForgeSlot(boot) == 1) { + ModifyItem.updateItem(boot, EquipmentSlot.FEET); + mp += ModifyItem.getItemMP(boot); + hp += ModifyItem.getItemHP(boot); + speed += ModifyItem.getItemSD(boot); + ar += ModifyItem.getItemAR(boot); + at += ModifyItem.getItemAT(boot); + } + + ItemStack off = player.getInventory().getItemInOffHand(); + if (CreateItem.getItemForgeSlot(off) == 5) { + ModifyItem.updateItem(off, EquipmentSlot.OFF_HAND); + mp += ModifyItem.getItemMP(off); + hp += ModifyItem.getItemHP(off); + speed += ModifyItem.getItemSD(off); + ar += ModifyItem.getItemAR(off); + at += ModifyItem.getItemAT(off); + } + + pd.calc(player, mp, hp, speed, ar, at); + EventListener.setData(player, pd); + + } + + public static class PlayerData { + private double hp; + private double mp; + private double dmg; + private double dmg_skill; + private double dmg_range; + private float spd; + private double avd; + private double crit; + private Status stat; + private double CurrentMP; + private Race race; + public double armor; + public double armor_toughness; + + private double STSKL; + private double STATK; + private double STHP; + private double STSPD; + private double STLUK; + private double STMP; + private double STAR; + private double START; + + public PlayerData(Player player, Race race, Status stat, double currentMP) { + this.race = race; + this.stat = stat; + + this.STAR = stat.getArmor() * race.getArmorMod(); + this.START = stat.getArmorToughness() * race.getArmorToughnessMod(); + this.STSKL = stat.getSKL() * race.getSkillModify(); + this.STATK = stat.getATK() * race.getAttackModify(); + this.STHP = stat.getHP() * race.getHealthModify(); + this.STSPD = stat.getSpeed() * race.getSpeedModify(); + this.STMP = stat.getMP() * race.getManaModify(); + this.STLUK = stat.getLucky() * race.getLuckyModify(); + double temp = this.STHP * Utils.HPHealth * Utils.basehp * stat.getLvL(); + if (temp < 1) { + temp = 1; + } + this.hp = temp; + this.mp = (this.STMP) * Utils.ManaMP * Utils.basemp * stat.getLvL(); + if (this.STSPD * Utils.SPDSpeed + Utils.basespd > 1) { + this.spd = 1; + } else { + this.spd = (float) (this.STSPD * Utils.SPDSpeed + Utils.basespd); + } + this.avd = this.STLUK * Utils.LUKAVD; + this.crit = this.STLUK * Utils.LUKCRIT; + this.dmg_skill = (this.STSKL); + this.dmg = (this.STATK); + this.dmg_range = (stat.getATK() * race.getRangeModify()); + player.getAttribute(Attribute.GENERIC_ATTACK_DAMAGE).setBaseValue(1); + this.CurrentMP = currentMP; + } + + public void setRace(Player player, Race race) { + Race old = this.race; + this.race = race; + YamlConfiguration yml = getYaml(player); + int slot = yml.getInt("UniqueSkillSlots") + race.getSlotModify() - old.getSlotModify(); + yml.set("UniqueSkillSlots", slot); + for (String skillname : yml.getStringList("UniqeSkills")) { + try { + for (String str : yml.getConfigurationSection("Skills." + skillname + ".Max").getKeys(false)) { + double ori = yml.getDouble("Skills." + skillname + ".Max." + str); + PlayerData st = Players.Data.get(player); + double mod; + int i = (int) SkillAPI.getPublicSkillInfo(skillname, "ModType"); + switch (i) { + case 1: + mod = st.getTotalStatusATK(); + break; + case 2: + mod = st.getTotalStatusHP(); + break; + case 3: + mod = st.getTotalStatusMP(); + break; + case 4: + mod = st.getTotalStatusSpeed(); + break; + case 5: + mod = st.getTotalStatusLUK(); + break; + case 6: + mod = st.getTotalStatusSKL(); + break; + default: + mod = 1; + break; + } + yml.set("Skills." + skillname + ".Max." + str, + ori * yml.getDouble("Skills." + skillname + ".Mod." + str) * mod); + } + } catch (Exception e1) { + } + } + this.STAR = stat.getArmor() * race.getArmorMod(); + this.START = stat.getArmorToughness() * race.getArmorToughnessMod(); + this.STATK = stat.getATK() * race.getAttackModify(); + this.STHP = stat.getHP() * race.getHealthModify(); + this.STSPD = stat.getSpeed() * race.getSpeedModify(); + this.STMP = stat.getMP() * race.getManaModify(); + this.STLUK = stat.getLucky() * race.getLuckyModify(); + this.STSKL = stat.getSKL() * race.getSkillModify(); + double temp = (this.STHP) * Utils.HPHealth * stat.getLvL() * Utils.basehp; + if (temp < 1) { + temp = 1; + } + this.hp = temp; + this.mp = (this.STMP) * Utils.ManaMP * stat.getLvL() * Utils.basemp; + if ((this.STSPD) * Utils.SPDSpeed + Utils.basespd > 1) { + this.spd = 1; + } else { + this.spd = (float) ((this.STSPD) * Utils.SPDSpeed + Utils.basespd); + } + this.avd = this.STLUK * Utils.LUKAVD; + this.crit = this.STLUK * Utils.LUKCRIT; + this.dmg = (this.STATK); + this.dmg_skill = (this.STSKL); + this.dmg_range = (stat.getATK() * race.getRangeModify()); + player.getAttribute(Attribute.GENERIC_ATTACK_DAMAGE).setBaseValue(1); + Magic.check(player); + RaceChangeEvent le = new RaceChangeEvent(player, old, race); + Bukkit.getServer().getPluginManager().callEvent(le); + } + + public double getTotalStatusArmor() { + return this.STAR; + } + + public double getTotalStatusArmorToughness() { + return this.START; + } + + public double getTotalStatusATK() { + return this.STATK; + } + + public double getTotalStatusHP() { + return this.STHP; + } + + public double getTotalStatusMP() { + return this.STMP; + } + + public double getTotalStatusLUK() { + return this.STLUK; + } + + public double getTotalStatusSpeed() { + return this.STSPD; + } + + public PlayerData(Player player, Status stat) { + this.race = new Race(null, null, null, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, null, null); + this.stat = stat; + setRace(player, Races.defaultRace); + this.STAR = stat.getArmor() * race.getArmorMod(); + this.START = stat.getArmorToughness() * race.getArmorToughnessMod(); + this.STATK = stat.getATK() * race.getAttackModify(); + this.STHP = stat.getHP() * race.getHealthModify(); + this.STSPD = stat.getSpeed() * race.getSpeedModify(); + this.STMP = stat.getMP() * race.getManaModify(); + this.STLUK = stat.getLucky() * race.getLuckyModify(); + double temp = this.STHP * Utils.HPHealth * Utils.basehp * stat.getLvL(); + if (temp < 1) { + temp = 1; + } + this.hp = temp; + this.mp = this.STMP * Utils.ManaMP * Utils.basemp * stat.getLvL(); + if (this.STSPD * Utils.SPDSpeed + Utils.basespd > 1) { + this.spd = 1; + } else { + this.spd = (float) (this.STSPD * Utils.SPDSpeed + Utils.basespd); + } + this.avd = (stat.getLucky() + race.getLuckyModify()) * Utils.LUKAVD; + this.crit = (stat.getLucky() + race.getLuckyModify()) * Utils.LUKCRIT; + this.dmg = (this.STATK); + this.dmg_skill = (this.STSKL); + this.dmg_range = (stat.getATK() * race.getRangeModify()); + player.getAttribute(Attribute.GENERIC_ATTACK_DAMAGE).setBaseValue(1); + this.CurrentMP = this.mp; + } + + public Race getRace() { + return this.race; + } + + public double getCurrentMP() { + return this.CurrentMP; + } + + public void setCurrentMP(double mp) { + this.CurrentMP = mp; + } + + public void addCurrentMP(double amp) { + if (this.CurrentMP + amp < 0) { + this.CurrentMP = 0; + } else if (this.CurrentMP + amp >= this.mp) { + this.CurrentMP = this.mp; + } else { + this.CurrentMP += amp; + } + } + + public double getMaxHealth() { + return this.hp; + } + + public double getMaxMana() { + return this.mp; + } + + public float getSpeed() { + return this.spd; + } + + public double getCrit() { + return this.crit; + } + + public double getAvoid() { + return this.avd; + } + + public Status getStatus() { + return this.stat; + } + + public double getDamage() { + return this.dmg * this.stat.getLvL(); + } + + public double getSkillDamage() { + return this.dmg_skill * this.stat.getLvL(); + } + + public double getRangeDamage() { + return this.dmg_range * this.stat.getLvL(); + } + + public void calc(Player player, double mana, double health, float speed, double ar, double at) { + double temp = (this.STHP) * Utils.HPHealth * (Utils.basehp + health) * stat.getLvL(); + if (temp < 1) { + temp = 1; + } + this.hp = temp; + this.mp = this.STMP * Utils.ManaMP * (mana + Utils.basemp) * stat.getLvL(); + float tempspeed = (float) (this.STSPD * Utils.SPDSpeed * speed + Utils.basespd); + if (tempspeed > 1) { + this.spd = 1; + } else { + this.spd = tempspeed; + } + this.avd = (stat.getLucky() * race.getLuckyModify()) * Utils.LUKAVD; + this.crit = (stat.getLucky() * race.getLuckyModify()) * Utils.LUKCRIT; + this.dmg = (stat.getATK() * race.getAttackModify()); + this.dmg_skill = (stat.getSKL() * race.getSkillModify()); + this.dmg_range = (stat.getATK() * race.getRangeModify()); + player.getAttribute(Attribute.GENERIC_ATTACK_DAMAGE).setBaseValue(1); + armor = (ar) * this.STAR; + player.getAttribute(Attribute.GENERIC_ARMOR).setBaseValue(armor); + armor_toughness = (at) * this.START; + // player.getAttribute(Attribute.GENERIC_ARMOR_TOUGHNESS).setBaseValue(armor_toughness); + } + + public boolean costMP(double mp) { + if (mp <= 0) { + return true; + } + if (this.CurrentMP - mp >= 0) { + this.CurrentMP -= mp; + return true; + } + return false; + + } + + public double getTotalStatusSKL() { + return this.STSKL; + } + } +} diff --git a/src/main/java/nashi/NRPG/Players/Races.java b/src/main/java/nashi/NRPG/Players/Races.java new file mode 100644 index 0000000..415289b --- /dev/null +++ b/src/main/java/nashi/NRPG/Players/Races.java @@ -0,0 +1,355 @@ +package nashi.NRPG.Players; + +import java.io.File; +import java.util.HashMap; +import java.util.List; +import java.util.Set; +import java.util.UUID; + +import org.bukkit.ChatColor; +import org.bukkit.Color; +import org.bukkit.Material; +import org.bukkit.attribute.Attribute; +import org.bukkit.attribute.AttributeModifier; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.inventory.EquipmentSlot; +import org.bukkit.inventory.ItemFlag; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.Damageable; +import org.bukkit.inventory.meta.ItemMeta; +import org.bukkit.inventory.meta.LeatherArmorMeta; + +import nashi.NRPG.Main; +import nashi.NRPG.API.Utils; + +public class Races { + public static HashMap races = new HashMap(); + public static Race defaultRace; + + public static Race getRace(String name) { + if (races.containsKey(name.toLowerCase())) { + return races.get(name.toLowerCase()); + } + return null; + } + + public static class Race { + private String name; + private String displayname; + private String des; + private int slotmod; + private double strmod; + private double spdmod; + private double hpmod; + private double mpmod; + private double lukmod; + private double rangemod; + private List skilllist; + ItemStack[] items; + private double armod; + private double atmod; + private double skmod; + + public Race(String name, String display, String des, int slot, double str, double spd, double hp, double mp, + double luk, double ar, double at, double rangemod, double skmod, List skills, + ItemStack[] armor) { + this.des = des; + this.name = name; + this.displayname = display; + this.slotmod = slot; + this.strmod = str; + this.spdmod = spd; + this.hpmod = hp; + this.mpmod = mp; + this.lukmod = luk; + this.skilllist = skills; + this.items = armor; + this.armod = ar; + this.atmod = at; + this.rangemod = rangemod; + this.skmod = skmod; + } + + public String getDescription() { + return this.des; + } + + public ItemStack[] getArmor() { + return this.items.clone(); + } + + public String getName() { + return this.name; + } + + public String getDisplayName() { + return this.displayname; + } + + public List getSkillList() { + return this.skilllist; + } + + public int getSlotModify() { + return this.slotmod; + } + + public double getRangeModify() { + return this.rangemod; + } + + public double getAttackModify() { + return this.strmod; + } + + public double getHealthModify() { + return this.hpmod; + } + + public double getManaModify() { + return this.mpmod; + } + + public double getSkillModify() { + return this.skmod; + } + + public double getLuckyModify() { + return this.lukmod; + } + + public double getSpeedModify() { + return this.spdmod; + } + + public double getArmorMod() { + return this.armod; + } + + public double getArmorToughnessMod() { + return this.atmod; + } + + } + + public static void init() { + races.clear(); + defaultRace = null; + YamlConfiguration yml = YamlConfiguration + .loadConfiguration(new File(Main.getPlugin().getDataFolder() + File.separator + "races.yml")); + Set key = yml.getKeys(false); + for (String name : key) { + String display = yml.getString(name + ".DisplayName"); + String des = yml.getString(name + ".Info"); + List skills = yml.getStringList(name + ".SkillList"); + int slot = yml.getInt(name + ".Mod.Slot"); + double atk = yml.getDouble(name + ".Mod.ATK"); + double luk = yml.getDouble(name + ".Mod.LUK"); + double spd = yml.getDouble(name + ".Mod.Speed"); + double mp = yml.getDouble(name + ".Mod.MP"); + double hp = yml.getDouble(name + ".Mod.HP"); + double at = yml.getDouble(name + ".Mod.AT"); + double sk = yml.getDouble(name + ".Mod.SKL"); + double ar = yml.getDouble(name + ".Mod.AR"); + double range = yml.getDouble(name + ".Mod.RG"); + String[] color; + int red; + int green; + int blue; + + ItemStack[] items = new ItemStack[5]; + ItemStack helmet = null; + if (yml.getBoolean(name + ".Items.Helmet.enable")) { + String helmat = yml.getString(name + ".Items.Helmet.Material"); + helmet = new ItemStack(Material.valueOf(helmat)); + Utils.setNotDrop(helmet); + if (helmat.toLowerCase().contains("leather")) { + LeatherArmorMeta lam = (LeatherArmorMeta) helmet.getItemMeta(); + lam.addAttributeModifier(Attribute.GENERIC_ARMOR, new AttributeModifier(UUID.randomUUID(), + "NRPGMOD", 0, AttributeModifier.Operation.ADD_NUMBER, EquipmentSlot.HEAD)); + color = yml.getString(name + ".Items.Helmet.Color").replaceAll(" ", "").split(","); + red = Integer.parseInt(color[0]); + green = Integer.parseInt(color[1]); + blue = Integer.parseInt(color[2]); + lam.setColor(Color.fromRGB(red, green, blue)); + ((Damageable) lam).setDamage(yml.getInt(name + ".Items.Helmet.damage")); + String itemname = yml.getString(name + ".Items.Helmet.DisplayName"); + if (itemname != null) { + lam.setDisplayName(ChatColor.translateAlternateColorCodes('&', itemname)); + } + lam.addItemFlags(ItemFlag.HIDE_UNBREAKABLE); + lam.setUnbreakable(true); + helmet.setItemMeta(lam); + } else { + ItemMeta lam = helmet.getItemMeta(); + lam.addAttributeModifier(Attribute.GENERIC_ARMOR, new AttributeModifier(UUID.randomUUID(), + "NRPGMOD", 0, AttributeModifier.Operation.ADD_NUMBER, EquipmentSlot.HEAD)); + ((Damageable) lam).setDamage(yml.getInt(name + ".Items.Helmet.damage")); + lam.addItemFlags(ItemFlag.HIDE_UNBREAKABLE); + lam.setUnbreakable(true); + String itemname = yml.getString(name + ".Items.Helmet.DisplayName"); + if (itemname != null) { + lam.setDisplayName(ChatColor.translateAlternateColorCodes('&', itemname)); + } + helmet.setItemMeta(lam); + } + } + + ItemStack chestplate = null; + if (yml.getBoolean(name + ".Items.Chestplate.enable")) { + String mat = yml.getString(name + ".Items.Chestplate.Material"); + chestplate = new ItemStack(Material.valueOf(mat)); + Utils.setNotDrop(chestplate); + if (mat.toLowerCase().contains("leather")) { + LeatherArmorMeta lam = (LeatherArmorMeta) chestplate.getItemMeta(); + lam.addAttributeModifier(Attribute.GENERIC_ARMOR, new AttributeModifier(UUID.randomUUID(), + "NRPGMOD", 0, AttributeModifier.Operation.ADD_NUMBER, EquipmentSlot.CHEST)); + color = yml.getString(name + ".Items.Chestplate.Color").replaceAll(" ", "").split(","); + red = Integer.parseInt(color[0]); + green = Integer.parseInt(color[1]); + blue = Integer.parseInt(color[2]); + lam.setColor(Color.fromRGB(red, green, blue)); + ((Damageable) lam).setDamage(yml.getInt(name + ".Items.Chestplate.damage")); + lam.addItemFlags(ItemFlag.HIDE_UNBREAKABLE); + lam.setUnbreakable(true); + String itemname = yml.getString(name + ".Items.Chestplate.DisplayName"); + if (itemname != null) { + lam.setDisplayName(ChatColor.translateAlternateColorCodes('&', itemname)); + } + chestplate.setItemMeta(lam); + } else { + ItemMeta lam = chestplate.getItemMeta(); + lam.addAttributeModifier(Attribute.GENERIC_ARMOR, new AttributeModifier(UUID.randomUUID(), + "NRPGMOD", 0, AttributeModifier.Operation.ADD_NUMBER, EquipmentSlot.CHEST)); + ((Damageable) lam).setDamage(yml.getInt(name + ".Items.Chestplate.damage")); + lam.addItemFlags(ItemFlag.HIDE_UNBREAKABLE); + lam.setUnbreakable(true); + String itemname = yml.getString(name + ".Items.Chestplate.DisplayName"); + if (itemname != null) { + lam.setDisplayName(ChatColor.translateAlternateColorCodes('&', itemname)); + } + chestplate.setItemMeta(lam); + } + } + + ItemStack leggings = null; + if (yml.getBoolean(name + ".Items.Leggings.enable")) { + String mat = yml.getString(name + ".Items.Leggings.Material"); + leggings = new ItemStack(Material.valueOf(mat)); + Utils.setNotDrop(leggings); + if (mat.toLowerCase().contains("leather")) { + LeatherArmorMeta lam = (LeatherArmorMeta) leggings.getItemMeta(); + lam.addAttributeModifier(Attribute.GENERIC_ARMOR, new AttributeModifier(UUID.randomUUID(), + "NRPGMOD", 0, AttributeModifier.Operation.ADD_NUMBER, EquipmentSlot.LEGS)); + color = yml.getString(name + ".Items.Leggings.Color").replaceAll(" ", "").split(","); + red = Integer.parseInt(color[0]); + green = Integer.parseInt(color[1]); + blue = Integer.parseInt(color[2]); + lam.setColor(Color.fromRGB(red, green, blue)); + ((Damageable) lam).setDamage(yml.getInt(name + ".Items.Leggings.damage")); + lam.addItemFlags(ItemFlag.HIDE_UNBREAKABLE); + lam.setUnbreakable(true); + String itemname = yml.getString(name + ".Items.Leggings.DisplayName"); + if (itemname != null) { + lam.setDisplayName(ChatColor.translateAlternateColorCodes('&', itemname)); + } + leggings.setItemMeta(lam); + } else { + ItemMeta lam = leggings.getItemMeta(); + lam.addAttributeModifier(Attribute.GENERIC_ARMOR, new AttributeModifier(UUID.randomUUID(), + "NRPGMOD", 0, AttributeModifier.Operation.ADD_NUMBER, EquipmentSlot.LEGS)); + ((Damageable) lam).setDamage(yml.getInt(name + ".Items.Leggings.damage")); + lam.addItemFlags(ItemFlag.HIDE_UNBREAKABLE); + lam.setUnbreakable(true); + String itemname = yml.getString(name + ".Items.Leggings.DisplayName"); + if (itemname != null) { + lam.setDisplayName(ChatColor.translateAlternateColorCodes('&', itemname)); + } + leggings.setItemMeta(lam); + } + } + ItemStack boots = null; + if (yml.getBoolean(name + ".Items.Boots.enable")) { + String mat = yml.getString(name + ".Items.Boots.Material"); + boots = new ItemStack(Material.valueOf(mat)); + Utils.setNotDrop(boots); + if (mat.toLowerCase().contains("leather")) { + LeatherArmorMeta lam = (LeatherArmorMeta) boots.getItemMeta(); + lam.addAttributeModifier(Attribute.GENERIC_ARMOR, new AttributeModifier(UUID.randomUUID(), + "NRPGMOD", 0, AttributeModifier.Operation.ADD_NUMBER, EquipmentSlot.FEET)); + color = yml.getString(name + ".Items.Boots.Color").replaceAll(" ", "").split(","); + red = Integer.parseInt(color[0]); + green = Integer.parseInt(color[1]); + blue = Integer.parseInt(color[2]); + lam.setColor(Color.fromRGB(red, green, blue)); + ((Damageable) lam).setDamage(yml.getInt(name + ".Items.Boots.damage")); + lam.addItemFlags(ItemFlag.HIDE_UNBREAKABLE); + lam.setUnbreakable(true); + String itemname = yml.getString(name + ".Items.Boots.DisplayName"); + if (itemname != null) { + lam.setDisplayName(ChatColor.translateAlternateColorCodes('&', itemname)); + } + boots.setItemMeta(lam); + } else { + ItemMeta lam = boots.getItemMeta(); + lam.addAttributeModifier(Attribute.GENERIC_ARMOR, new AttributeModifier(UUID.randomUUID(), + "NRPGMOD", 0, AttributeModifier.Operation.ADD_NUMBER, EquipmentSlot.FEET)); + ((Damageable) lam).setDamage(yml.getInt(name + ".Items.Boots.damage")); + lam.addItemFlags(ItemFlag.HIDE_UNBREAKABLE); + lam.setUnbreakable(true); + String itemname = yml.getString(name + ".Items.Boots.DisplayName"); + if (itemname != null) { + lam.setDisplayName(ChatColor.translateAlternateColorCodes('&', itemname)); + } + boots.setItemMeta(lam); + } + } + ItemStack off = null; + if (yml.getBoolean(name + ".Items.OffHand.enable")) { + String mat = yml.getString(name + ".Items.OffHand.Material"); + off = new ItemStack(Material.valueOf(mat)); + Utils.setNotDrop(off); + if (mat.toLowerCase().contains("leather")) { + LeatherArmorMeta lam = (LeatherArmorMeta) off.getItemMeta(); + lam.addAttributeModifier(Attribute.GENERIC_ARMOR, new AttributeModifier(UUID.randomUUID(), + "NRPGMOD", 0, AttributeModifier.Operation.ADD_NUMBER, EquipmentSlot.FEET)); + color = yml.getString(name + ".Items.OffHand.Color").replaceAll(" ", "").split(","); + red = Integer.parseInt(color[0]); + green = Integer.parseInt(color[1]); + blue = Integer.parseInt(color[2]); + lam.setColor(Color.fromRGB(red, green, blue)); + ((Damageable) lam).setDamage(yml.getInt(name + ".Items.OffHand.damage")); + lam.addItemFlags(ItemFlag.HIDE_UNBREAKABLE); + lam.setUnbreakable(true); + String itemname = yml.getString(name + ".Items.OffHand.DisplayName"); + if (itemname != null) { + lam.setDisplayName(ChatColor.translateAlternateColorCodes('&', itemname)); + } + off.setItemMeta(lam); + } else { + ItemMeta lam = off.getItemMeta(); + lam.addAttributeModifier(Attribute.GENERIC_ARMOR, new AttributeModifier(UUID.randomUUID(), + "NRPGMOD", 0, AttributeModifier.Operation.ADD_NUMBER, EquipmentSlot.FEET)); + ((Damageable) lam).setDamage(yml.getInt(name + ".Items.OffHand.damage")); + lam.addItemFlags(ItemFlag.HIDE_UNBREAKABLE); + lam.setUnbreakable(true); + String itemname = yml.getString(name + ".Items.OffHand.DisplayName"); + if (itemname != null) { + lam.setDisplayName(ChatColor.translateAlternateColorCodes('&', itemname)); + } + off.setItemMeta(lam); + } + } + items[0] = helmet; + items[1] = chestplate; + items[2] = leggings; + items[3] = boots; + items[4] = off; + Race race = new Race(name, display, des, slot, atk, spd, hp, mp, luk, ar, at, range, sk, skills, items); + if (yml.getBoolean(name + ".default")) { + Races.defaultRace = race; + } + races.put(name.toLowerCase(), race); + } + } +} diff --git a/src/main/java/nashi/NRPG/Skills/Cast.java b/src/main/java/nashi/NRPG/Skills/Cast.java new file mode 100644 index 0000000..4f90f6b --- /dev/null +++ b/src/main/java/nashi/NRPG/Skills/Cast.java @@ -0,0 +1,80 @@ +package nashi.NRPG.Skills; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.Random; +import java.util.Set; + +import org.bukkit.ChatColor; +import org.bukkit.entity.Player; + +public class Cast { + public static long timelimit; + public static final int length = 20; + public static final String logo = "✡"; + private static final String normal = "-"; + public static final ChatColor wrong = ChatColor.YELLOW; + public static final ChatColor right = ChatColor.AQUA; + public static final ChatColor current = ChatColor.LIGHT_PURPLE; + + public static HashMap castspeed = new HashMap(); + + public static class Abracadabra { + private String str; + private Set pos; + + public Abracadabra(String str, Set set) { + this.str = str; + this.pos = set; + } + + public String getString() { + return this.str; + } + + public Set getPos() { + return this.pos; + } + } + + public static Abracadabra getabracadabra(int num) { + StringBuilder sb = new StringBuilder(); + Random rand = new Random(); + int l = 0; + Set pos = new HashSet(); + while (l < length) { + l++; + sb.append(normal); + } + l = 0; + while (l < num) { + int s = rand.nextInt(length); + if (!pos.contains(s)) { + pos.add(s); + l++; + } else { + while (pos.contains(s)) { + s = (s + 1) % length; + } + pos.add(s); + l++; + } + } + for (int i : pos) { + sb.replace(i, i + 1, logo); + } + Abracadabra a = new Abracadabra(sb.toString(), pos); + return a; + } + + public static String getDisplay(String str, int pos) { + str = str.replaceAll(logo, right + logo).replaceAll(normal, wrong + normal); + String s = str.substring(0, pos * 3) + current; + try { + s += str.substring(pos * 3 + 2, str.length()); + } catch (Exception e) { + + } + return s; + } +} diff --git a/src/main/java/nashi/NRPG/Skills/GUI.java b/src/main/java/nashi/NRPG/Skills/GUI.java new file mode 100644 index 0000000..bb4bcd8 --- /dev/null +++ b/src/main/java/nashi/NRPG/Skills/GUI.java @@ -0,0 +1,162 @@ +package nashi.NRPG.Skills; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Set; + +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.Material; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; +import org.bukkit.inventory.Inventory; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; + +import nashi.NRPG.API.Utils; +import nashi.NRPG.CustomEvents.SkillItemGenerateEvent; +import nashi.NRPG.Players.Players; + +public class GUI { + public static HashMap editpage = new HashMap(); + + public static void EditGUI(Player player, int page) { + editpage.put(player, page); + Inventory inv = Bukkit.createInventory(player, 54, "技能調整介面"); + YamlConfiguration yml = Players.getYaml(player); + // All Skill + List skilllist = yml.getStringList("UniqeSkills"); + int i = 0; + int skip = (page - 1) * 53 - 1; + for (String skillname : skilllist) { + if (i >= 53) { + break; + } + if (skip > 0) { + skip--; + continue; + } + try { + if (yml.getConfigurationSection(("Skills." + skillname + ".Custom")).getKeys(false).size() > 0) { + ItemStack item = Utils.getSkillItem(skillname,player); + SkillItemGenerateEvent event = new SkillItemGenerateEvent(player, item, skillname); + Bukkit.getPluginManager().callEvent(event); + inv.setItem(i, item); + i++; + } + } catch (Exception e) { + } + } + if (i >= 53) { + ItemStack item = new ItemStack(Material.ARROW); + ItemMeta im = item.getItemMeta(); + im.setDisplayName(ChatColor.GREEN + "下一頁"); + item.setItemMeta(im); + Utils.setNotDrop(item); + inv.setItem(53, item); + } + player.openInventory(inv); + } + + public static void SlotGUI(Player player, int page) { + Inventory inv = Bukkit.createInventory(player, 54, "技能欄位設定"); + YamlConfiguration yml = Players.getYaml(player); + // Current Setting + for (int s = 0; s < 9; s++) { + String skillname = yml.getString("Slot." + s); + if (skillname != null) { + ItemStack item = Utils.getSkillItem(skillname,player); + inv.setItem(s, item); + } + } + // All Skill + List skilllist = yml.getStringList("UniqeSkills"); + ItemStack b = new ItemStack(Material.BARRIER); + Utils.setNotDrop(b); + for (int i = 9; i < 18; i++) { + inv.setItem(i, b); + } + int i = 0; + int skip = (page - 1) * 35 - 1; + for (String skillname : skilllist) { + if (i >= 35) { + break; + } + if (skip > 0) { + skip--; + continue; + } + ItemStack item = Utils.getSkillItem(skillname,player); + inv.setItem(i + 18, item); + i++; + } + if (i >= 35) { + ItemStack item = new ItemStack(Material.ARROW); + ItemMeta im = item.getItemMeta(); + im.setDisplayName(ChatColor.GREEN + "下一頁"); + item.setItemMeta(im); + Utils.setNotDrop(item); + inv.setItem(53, item); + } + player.openInventory(inv); + } + + public static void openSkillEditGUI(Player player, String skillname) { + YamlConfiguration yml = Players.getYaml(player); + Inventory inv = Bukkit.createInventory(player, 27, "技能設定-" + skillname); + ItemStack skill = new ItemStack(Material.ENCHANTED_BOOK); + ItemMeta skillmeta = skill.getItemMeta(); + skillmeta.setDisplayName(ChatColor.LIGHT_PURPLE + skillname); + skill.setItemMeta(skillmeta); + inv.setItem(9, skill); + Set key = yml.getConfigurationSection("Skills." + skillname + ".Custom").getKeys(false); + int t = 1; + int m = 10; + int b = 19; + if (key.size() <= 0) { + player.sendMessage(ChatColor.RED + "此技能沒有可調整的數值"); + return; + } + for (String str : key) { + if (t >= 8) { + break; + } + ItemStack top = new ItemStack(Material.GREEN_WOOL); + ItemStack mid = new ItemStack(Material.ACACIA_SIGN); + ItemStack bot = new ItemStack(Material.RED_WOOL); + ItemMeta tm = top.getItemMeta(); + ItemMeta mm = mid.getItemMeta(); + ItemMeta bm = bot.getItemMeta(); + tm.setDisplayName(ChatColor.GREEN + "提升:" + str); + mm.setDisplayName(ChatColor.GOLD + str + "數值"); + bm.setDisplayName(ChatColor.RED + "降低:" + str); + List tl = new ArrayList();// L 0.01 R 0.1 SL 0.05 SR 0.5 + tl.add(ChatColor.YELLOW + "點此左鍵來提升0.01"); + tl.add(ChatColor.YELLOW + "點此Shift+左鍵來提升0.1"); + tl.add(ChatColor.YELLOW + "點此右鍵來提升1"); + tl.add(ChatColor.YELLOW + "點此Shift+右鍵來提升10"); + List bl = new ArrayList();// L 0.01 R 0.1 SL 0.05 SR 0.5 + bl.add(ChatColor.YELLOW + "點此左鍵來降低0.01"); + bl.add(ChatColor.YELLOW + "點此Shift+左鍵來降低0.1"); + bl.add(ChatColor.YELLOW + "點此右鍵來降低1"); + bl.add(ChatColor.YELLOW + "點此Shift+右鍵來降低10"); + List ml = new ArrayList(); + ml.add(ChatColor.YELLOW + "當前: " + yml.getString("Skills." + skillname + ".Custom." + str)); + ml.add(ChatColor.YELLOW + "最大: " + yml.getString("Skills." + skillname + ".Max." + str)); + tm.setLore(tl); + mm.setLore(ml); + bm.setLore(bl); + top.setItemMeta(tm); + mid.setItemMeta(mm); + bot.setItemMeta(bm); + inv.setItem(t, top); + inv.setItem(m, mid); + inv.setItem(b, bot); + t++; + m++; + b++; + } + player.openInventory(inv); + } +} diff --git a/src/main/java/nashi/NRPG/Skills/Magic.java b/src/main/java/nashi/NRPG/Skills/Magic.java new file mode 100644 index 0000000..74f95d8 --- /dev/null +++ b/src/main/java/nashi/NRPG/Skills/Magic.java @@ -0,0 +1,219 @@ +package nashi.NRPG.Skills; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import org.bukkit.Bukkit; +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; + +import nashi.NRPG.API.SkillAPI; +import nashi.NRPG.CustomEvents.SkillLearnEvent; +import nashi.NRPG.Players.Players; +import nashi.NRPG.Players.Players.PlayerData; + +public class Magic { + public static boolean learnSkill(Player player, String skillname, boolean isMakeUp) { + YamlConfiguration yml = Players.getYaml(player); + ConfigurationSection sec = Players.skillsetting.getConfigurationSection(skillname); + yml.set("Skills." + skillname, sec); + if (isMakeUp) { + yml.set("Skills." + skillname + ".isMakeUp", true); + } + try { + for (String str : yml.getConfigurationSection("Skills." + skillname + ".Max").getKeys(false)) { + double ori = yml.getDouble("Skills." + skillname + ".Max." + str); + PlayerData st = Players.Data.get(player); + double mod; + int i = (int) SkillAPI.getPublicSkillInfo(skillname, "ModType"); + switch (i) { + case 1: + mod = st.getTotalStatusATK(); + break; + case 2: + mod = st.getTotalStatusHP(); + break; + case 3: + mod = st.getTotalStatusMP(); + break; + case 4: + mod = st.getTotalStatusSpeed(); + break; + case 5: + mod = st.getTotalStatusLUK(); + break; + default: + mod = 1; + break; + } + yml.set("Skills." + skillname + ".Max." + str, + ori * yml.getDouble("Skills." + skillname + ".Mod." + str) * mod); + } + } catch (Exception e) { + } + + List list; + try { + list = yml.getStringList("UniqeSkills"); + } catch (Exception e) { + list = new ArrayList(); + } + if (!list.contains(skillname)) { + list.add(skillname); + yml.set("UniqeSkills", list); + yml.set("UsedSlots", yml.getInt("UsedSlots") + 1); + SkillLearnEvent se = new SkillLearnEvent(player, skillname); + Bukkit.getServer().getPluginManager().callEvent(se); + return true; + } else { + return false; + } + } + + public static boolean learnSkill(Player player, String skillname) { + YamlConfiguration yml = Players.getYaml(player); + ConfigurationSection sec = Players.skillsetting.getConfigurationSection(skillname); + yml.set("Skills." + skillname, sec); + try { + for (String str : yml.getConfigurationSection("Skills." + skillname + ".Max").getKeys(false)) { + double ori = yml.getDouble("Skills." + skillname + ".Max." + str); + PlayerData st = Players.Data.get(player); + double mod; + int i = (int) SkillAPI.getPublicSkillInfo(skillname, "ModType"); + switch (i) { + case 1: + mod = st.getTotalStatusATK(); + break; + case 2: + mod = st.getTotalStatusHP(); + break; + case 3: + mod = st.getTotalStatusMP(); + break; + case 4: + mod = st.getTotalStatusSpeed(); + break; + case 5: + mod = st.getTotalStatusLUK(); + break; + default: + mod = 1; + break; + } + yml.set("Skills." + skillname + ".Max." + str, + ori * yml.getDouble("Skills." + skillname + ".Mod." + str) * mod); + } + } catch (Exception e) { + } + + List list; + try { + list = yml.getStringList("UniqeSkills"); + } catch (Exception e) { + list = new ArrayList(); + } + if (!list.contains(skillname)) { + list.add(skillname); + yml.set("UniqeSkills", list); + yml.set("UsedSlots", yml.getInt("UsedSlots") + 1); + SkillLearnEvent se = new SkillLearnEvent(player, skillname); + Bukkit.getServer().getPluginManager().callEvent(se); + return true; + } else { + return false; + } + } + + public static void learnGenSkill(Player player, String skillname) { + YamlConfiguration yml = Players.getYaml(player); + ConfigurationSection sec = Players.skillsetting.getConfigurationSection(skillname); + yml.set("Skills." + skillname, sec); + List list; + try { + list = yml.getStringList("UniqeSkills"); + } catch (Exception e) { + list = new ArrayList(); + } + list.add(skillname); + yml.set("UniqeSkills", list); + try { + for (String str : yml.getConfigurationSection("Skills." + skillname + ".Max").getKeys(false)) { + double ori = yml.getDouble("Skills." + skillname + ".Max." + str); + PlayerData st = Players.Data.get(player); + double mod; + int i = (int) SkillAPI.getPublicSkillInfo(skillname, "ModType"); + switch (i) { + case 1: + mod = st.getTotalStatusATK(); + break; + case 2: + mod = st.getTotalStatusHP(); + break; + case 3: + mod = st.getTotalStatusMP(); + break; + case 4: + mod = st.getTotalStatusSpeed(); + break; + case 5: + mod = st.getTotalStatusLUK(); + break; + default: + mod = 1; + break; + } + yml.set("Skills." + skillname + ".Max." + str, + ori * yml.getDouble("Skills." + skillname + ".Mod." + str) * mod); + } + } catch (Exception e) { + } + SkillLearnEvent se = new SkillLearnEvent(player, skillname); + Bukkit.getServer().getPluginManager().callEvent(se); + } + + public static void check(Player player) { + Set add = new HashSet(); + YamlConfiguration y = Players.getYaml(player); + List set; + try { + set = y.getStringList("UniqeSkills"); + } catch (NullPointerException e) { + set = new ArrayList(); + } + try { + for (String str : Skill.GeneralSkills) { + if (!set.contains(str)) { + add.add(str); + } + } + } catch (NullPointerException e) { + } + + for (int i = 0; i <= 9; i++) { + try { + if (!set.contains(y.getString("Slot." + i))) { + y.set("Slot." + i, null); + } + } catch (NullPointerException e) { + } + } + + try { + for (String str : Players.Data.get(player).getRace().getSkillList()) { + if (!set.contains(str)) { + add.add(str); + } + } + } catch (NullPointerException e) { + } + try { + for (String str : add) { + learnGenSkill(player, str); + } + } catch (NullPointerException e) { + } + } +} diff --git a/src/main/java/nashi/NRPG/Skills/NewSkill.java b/src/main/java/nashi/NRPG/Skills/NewSkill.java new file mode 100644 index 0000000..999899b --- /dev/null +++ b/src/main/java/nashi/NRPG/Skills/NewSkill.java @@ -0,0 +1,72 @@ +package nashi.NRPG.Skills; + +import java.io.File; +import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; + +import org.bukkit.entity.Player; + +import nashi.NRPG.Main; +import nashi.NRPG.API.SkillAPI; +import nashi.NRPG.Skills.Skill.Skills; + +public abstract class NewSkill { + + private static void load(File fileEntry) { + try { + File f = fileEntry; + URL u = f.toURI().toURL(); + URLClassLoader child = new URLClassLoader(new URL[] { u }, Main.class.getClassLoader()); + Class clazz = Class.forName( + fileEntry.getName().replaceAll(".jar", "") + "." + fileEntry.getName().replaceAll(".jar", ""), true, + child); + Object s = clazz.getDeclaredConstructor().newInstance(); + try { + Method set = clazz.getMethod("load"); + set.invoke(s); + } catch (Exception e) { + } + try { + String name = fileEntry.getName().replaceAll(".jar", ""); + if (SkillAPI.getSkillPublicBoolean(name, "general")) { + Skill.GeneralSkills.add(name); + } + Method skill = clazz.getMethod("skill", Player.class); + Skill.skills.put(name, new Skill.Skills(skill, s, clazz)); + SkillName.put(name); + } catch (Exception e) { + } + } catch (Exception e) { + e.printStackTrace(); + } + } + + public static void unloadAllSkills() { + for (String key : Skill.skills.keySet()) { + Skills skill = Skill.skills.get(key); + Class clazz = skill.skill; + try { + Object s = clazz.getDeclaredConstructor().newInstance(); + Method set = clazz.getMethod("unload"); + set.invoke(s); + } catch (Exception e) { + } + } + } + + private static void listFilesForFolder(final File folder) { + for (final File fileEntry : folder.listFiles()) { + if (fileEntry.isDirectory()) { + listFilesForFolder(fileEntry); + } else { + load(fileEntry); + } + } + } + + public static void loadskill() { + final File folder = new File(Main.getPlugin().getDataFolder() + File.separator + "skills"); + listFilesForFolder(folder); + } +} diff --git a/src/main/java/nashi/NRPG/Skills/Skill.java b/src/main/java/nashi/NRPG/Skills/Skill.java new file mode 100644 index 0000000..83e7e10 --- /dev/null +++ b/src/main/java/nashi/NRPG/Skills/Skill.java @@ -0,0 +1,104 @@ +package nashi.NRPG.Skills; + +import java.lang.reflect.Method; +import java.text.DecimalFormat; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Set; + +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.World; +import org.bukkit.entity.Player; + +import nashi.NRPG.Main; +import nashi.NRPG.API.SkillAPI; +import nashi.NRPG.CustomEvents.PreSkillUseEvent; +import nashi.NRPG.CustomEvents.SkillUsedEvent; +import nashi.NRPG.Players.Players; +import nashi.NRPG.Players.Players.PlayerData; + +public abstract class Skill { + public static HashMap cooldowns = new HashMap(); + public static HashMap skills = new HashMap(); + public static Set GeneralSkills = new HashSet(); + public static DecimalFormat formatter = new DecimalFormat("#.##"); + + public static void cast(String skillname, Player player, boolean isSkillItem) { + World world = player.getWorld(); + try { + if (Main.worlds.contains(world)) { + player.sendMessage(ChatColor.RED + "你無法在這個世界使用技能"); + return; + } + } catch (Exception e) { + } + if (SkillAPI.Silence.containsKey(player.getUniqueId())) { + double secondsLeft = SkillAPI.Silence.get(player.getUniqueId()) - System.currentTimeMillis(); + if (secondsLeft > 0) { + player.sendMessage(ChatColor.RED + "你已被沉默 " + Skill.formatter.format((secondsLeft / 1000)) + " 秒"); + return; + } + } + int cooldownTime = (int) SkillAPI.getPublicSkillInfo(skillname, "Cooldown"); + if (cooldowns.containsKey(player.getUniqueId() + "." + skillname)) { + double secondsLeft = cooldowns.get(player.getUniqueId() + "." + skillname) - System.currentTimeMillis(); + if (secondsLeft > 0) { + player.sendMessage(ChatColor.RED + "技能冷卻時間剩餘:" + Skill.formatter.format((secondsLeft / 1000)) + " 秒"); + return; + } + } + PlayerData p = Players.Data.get(player); + double cost = SkillAPI.getPublicSkillInfo(skillname, "CostMP"); + if (p.getCurrentMP() - cost < 0) { + player.sendMessage(ChatColor.RED + "魔力不足"); + return; + } + + PreSkillUseEvent psue = new PreSkillUseEvent(player, skillname, isSkillItem); + Bukkit.getPluginManager().callEvent(psue); + if (psue.isCancelled()) { + if (psue.toCooldown()) { + cooldowns.put(player.getUniqueId() + "." + skillname, System.currentTimeMillis() + cooldownTime); + } + return; + } + + try { + + cooldowns.put(player.getUniqueId() + "." + skillname, System.currentTimeMillis() + cooldownTime); + Skills sk = skills.get(skillname); + Class clazz = sk.skill; + Object s = clazz.getDeclaredConstructor().newInstance(); + Method skill = clazz.getMethod("skill", Player.class); + boolean b = (boolean) skill.invoke(s, player); + if (!b) { + cooldowns.put(player.getUniqueId() + "." + skillname, (long) (-cooldownTime)); + } + + SkillUsedEvent sue = new SkillUsedEvent(player, skillname, b); + Bukkit.getPluginManager().callEvent(sue); + + } catch (Exception e) { + if (e instanceof NoSuchMethodException) { + return; + } + e.printStackTrace(); + } + return; + } + + public static class Skills { + public Method method; + public Object object; + public Class skill; + + public Skills(Method l, Object v, Class c) { + method = l; + object = v; + skill = c; + } + + } + +} diff --git a/src/main/java/nashi/NRPG/Skills/SkillItem.java b/src/main/java/nashi/NRPG/Skills/SkillItem.java new file mode 100644 index 0000000..d7d41e2 --- /dev/null +++ b/src/main/java/nashi/NRPG/Skills/SkillItem.java @@ -0,0 +1,123 @@ +package nashi.NRPG.Skills; + +import org.bukkit.Material; +import org.bukkit.NamespacedKey; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; +import org.bukkit.persistence.PersistentDataContainer; +import org.bukkit.persistence.PersistentDataType; + +import nashi.NRPG.Main; + +public class SkillItem { + public static NamespacedKey Item_Skillname = new NamespacedKey(Main.getPlugin(), "NRPG_SkillItem_SkillName"); + public static NamespacedKey Item_SkillDifficulty = new NamespacedKey(Main.getPlugin(), "NRPG_SkillItem_Difficulty"); + public static NamespacedKey Item_SkillTime = new NamespacedKey(Main.getPlugin(), "NRPG_SkillItem_Times"); + public static NamespacedKey Item_SkillLimitTimeUse = new NamespacedKey(Main.getPlugin(), + "NRPG_SkillItem_LimitTimeUse"); + public static NamespacedKey Item_SkillUseDamage = new NamespacedKey(Main.getPlugin(), "NRPG_SkillItem_UseDamage"); + + + public static void setSkillItem(ItemStack item, String skillname, int damage, int time, int limit, int difficulty) { + setSkill(item, skillname); + setUseDamage(item, damage); + setSkillTime(item, time); + setSkillLimitTimeUse(item, limit); + setSkillDifficulty(item, difficulty); + } + + public static void setSkill(ItemStack item, String skillname) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(SkillItem.Item_Skillname, PersistentDataType.STRING, skillname); + item.setItemMeta(im); + } + + public static String getSkill(ItemStack item) { + if (item == null || item.getType() == Material.AIR) { + return null; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(SkillItem.Item_Skillname, PersistentDataType.STRING)) { + return pdc.get(SkillItem.Item_Skillname, PersistentDataType.STRING); + } + return null; + } + + public static void setUseDamage(ItemStack item, int damage) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(SkillItem.Item_SkillUseDamage, PersistentDataType.INTEGER, damage); + item.setItemMeta(im); + } + + public static int getUseDamage(ItemStack item) { + if (item == null || item.getType() == Material.AIR) { + return -1; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(SkillItem.Item_SkillUseDamage, PersistentDataType.INTEGER)) { + return pdc.get(SkillItem.Item_SkillUseDamage, PersistentDataType.INTEGER); + } + return -1; + } + + public static void setSkillTime(ItemStack item, int time) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(SkillItem.Item_SkillTime, PersistentDataType.INTEGER, time); + item.setItemMeta(im); + } + + public static int getSkillTime(ItemStack item) { + if (item == null || item.getType() == Material.AIR) { + return -1; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(SkillItem.Item_SkillTime, PersistentDataType.INTEGER)) { + return pdc.get(SkillItem.Item_SkillTime, PersistentDataType.INTEGER); + } + return -1; + } + + public static void setSkillLimitTimeUse(ItemStack item, int limit) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(SkillItem.Item_SkillLimitTimeUse, PersistentDataType.INTEGER, limit); + item.setItemMeta(im); + } + + public static int getSkillLimitTimeUse(ItemStack item) { + if (item == null || item.getType() == Material.AIR) { + return -1; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(SkillItem.Item_SkillLimitTimeUse, PersistentDataType.INTEGER)) { + return pdc.get(SkillItem.Item_SkillLimitTimeUse, PersistentDataType.INTEGER); + } + return -1; + } + + public static void setSkillDifficulty(ItemStack item, int difficulty) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(SkillItem.Item_SkillDifficulty, PersistentDataType.INTEGER, difficulty); + item.setItemMeta(im); + } + + public static int getSkillDifficulty(ItemStack item) { + if (item == null || item.getType() == Material.AIR) { + return -1; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(SkillItem.Item_SkillDifficulty, PersistentDataType.INTEGER)) { + return pdc.get(SkillItem.Item_SkillDifficulty, PersistentDataType.INTEGER); + } + return -1; + } +} diff --git a/src/main/java/nashi/NRPG/Skills/SkillName.java b/src/main/java/nashi/NRPG/Skills/SkillName.java new file mode 100644 index 0000000..17b7c77 --- /dev/null +++ b/src/main/java/nashi/NRPG/Skills/SkillName.java @@ -0,0 +1,20 @@ +package nashi.NRPG.Skills; + +import java.util.HashMap; +import java.util.HashSet; + +public class SkillName { + public static HashMap skillname = new HashMap(); + public static HashSet SkillList = new HashSet(); + + public static void put(String Skillname) { + skillname.put(Skillname.toLowerCase(), Skillname); + if (!SkillList.contains(Skillname)) { + SkillList.add(Skillname); + } + } + + public static String get(String Skillname) { + return skillname.get(Skillname.toLowerCase()); + } +} diff --git a/src/main/java/nashi/NRPG/listeners/AllAboutDamage.java b/src/main/java/nashi/NRPG/listeners/AllAboutDamage.java new file mode 100644 index 0000000..f90245e --- /dev/null +++ b/src/main/java/nashi/NRPG/listeners/AllAboutDamage.java @@ -0,0 +1,174 @@ +package nashi.NRPG.listeners; + +import org.bukkit.Location; +import org.bukkit.NamespacedKey; +import org.bukkit.Sound; +import org.bukkit.attribute.Attribute; +import org.bukkit.entity.Entity; +import org.bukkit.entity.LivingEntity; +import org.bukkit.entity.Player; +import org.bukkit.entity.Projectile; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.EntityDamageByEntityEvent; +import org.bukkit.event.entity.EntityDamageEvent; +import org.bukkit.event.entity.EntityDamageEvent.DamageCause; +import org.bukkit.event.entity.EntityDamageEvent.DamageModifier; +import org.bukkit.event.entity.EntityShootBowEvent; + +import nashi.NRPG.Main; +import nashi.NRPG.API.Utils; +import nashi.NRPG.Players.Players; +import nashi.NRPG.Players.Players.PlayerData; + +@SuppressWarnings("deprecation") +public class AllAboutDamage implements Listener { + public static NamespacedKey key = new NamespacedKey(Main.getPlugin(), "NRPG_ItemsNotDrop"); + + @EventHandler + public void hunger(EntityDamageEvent e) { + if (e.getCause() == DamageCause.STARVATION) { + e.setDamage(Utils.hunger); + } + } + + public static double damagecalc(double damage, double defense, double toughness) { + double max = Math.max(defense / 5, defense - damage / (toughness / 4 + 2)); + double damageTaken = damage * (1 - Math.min(20, max) / 25); + if (max > 20) { + damageTaken -= (max - 20) * Utils.exarmor; + } + if (damageTaken > 1) { + return damageTaken; + } + return 1; + } + + @EventHandler(priority = EventPriority.LOWEST) + public void arrow(EntityShootBowEvent e) { + Projectile p = (Projectile) e.getProjectile(); + p.setShooter(e.getEntity()); + } + + @EventHandler//(priority = EventPriority.LOW) + public void attack(EntityDamageByEntityEvent e) { + Entity enty = e.getEntity(); + Entity damer = e.getDamager(); + if(!(enty instanceof LivingEntity)) { + return; + } + LivingEntity ent = (LivingEntity) enty; + if(ent.getNoDamageTicks()>0) { + return; + } + if(e.getDamage()==0) { + return; + } + if (ent instanceof Player) { + Player player = (Player) ent; + PlayerData pdata = Players.Data.get(player); + try { + if (Utils.isSuccess(pdata.getAvoid())) { + e.setCancelled(true); + return; + } + } catch (Exception e1) { + + } + } + if (damer instanceof Projectile) { + Projectile p = (Projectile) damer; + if (p.getShooter() instanceof Player) { + Player atker = (Player) p.getShooter(); + Players.PlayerData adata = Players.Data.get(atker); + double dmg = e.getDamage(); + double extra = atker.getAttribute(Attribute.GENERIC_ATTACK_DAMAGE).getValue(); + double damage = dmg + adata.getDamage(); + if (damage < 1.0) { + damage = 1.0; + } + + if (Utils.isSuccess((double) adata.getCrit())) { + damage = (damage + extra) * 2.0 * adata.getRangeDamage(); + } else { + damage = (damage + extra) * adata.getRangeDamage(); + } + if (ent instanceof Player) { + Player player = (Player) ent; + PlayerData pdata = Players.Data.get(player); + e.setDamage(DamageModifier.ARMOR, 0); + e.setDamage(damagecalc(damage, pdata.armor, pdata.armor_toughness)); + } else { + e.setDamage(damage); + } + return; + } + } + if (e.getCause() != DamageCause.ENTITY_ATTACK) { + return; + } + if (damer instanceof Player) { + double damage; + Player atker = (Player) damer; + PlayerData adata = Players.Data.get(atker); + double range = ModifyItem.getPlayerAttackRange(atker); + if (ent.getLocation().distance(atker.getLocation()) > range) { + e.setCancelled(true); + return; + } + double dmg = e.getDamage(); + double mod = 1.0; + boolean skill = true; + if (range != Double.MAX_VALUE) { + skill = false; + double base = atker.getAttribute(Attribute.GENERIC_ATTACK_DAMAGE).getValue() + * ModifyItem.AtkModBasedCD(atker); + if (ent instanceof LivingEntity) { + base += ModifyItem.extraATKBasedEnch(atker, (LivingEntity) ent); + } + mod = base / dmg; + } + damage = dmg; + if (damage < 1.0) { + damage = 1.0; + } + if (Utils.isSuccess(adata.getCrit())) { + damage = (mod * damage * 2.0); + if (Main.cancel) { + Location loc = atker.getLocation(); + Sound sound = Sound.ENTITY_PLAYER_ATTACK_CRIT; + ProtocolLibEvent.setWhitelist(sound); + loc.getWorld().playSound(loc, sound, 1.0f, 2.0f); + } + } else { + damage = (mod * damage); + if (Main.cancel) { + Location loc = atker.getLocation(); + Sound sound = Sound.ENTITY_PLAYER_ATTACK_WEAK; + ProtocolLibEvent.setWhitelist(sound); + loc.getWorld().playSound(loc, sound, 1.0f, 2.0f); + } + } + if (ent instanceof Player) { + Player player = (Player) ent; + PlayerData pdata = Players.Data.get(player); + e.setDamage(DamageModifier.ARMOR, 0); + if (skill) { + e.setDamage(damagecalc(damage * adata.getSkillDamage(), pdata.armor, pdata.armor_toughness)); + } else { + e.setDamage(damagecalc(damage * adata.getDamage(), pdata.armor, pdata.armor_toughness)); + } + } else { + if (skill) { + e.setDamage(damage * adata.getSkillDamage()); + } else { + e.setDamage(damage * adata.getDamage()); + } + } + ModifyItem.atktime.put(atker, System.currentTimeMillis()); + + return; + } + } +} diff --git a/src/main/java/nashi/NRPG/listeners/EventListener.java b/src/main/java/nashi/NRPG/listeners/EventListener.java new file mode 100644 index 0000000..ba5c969 --- /dev/null +++ b/src/main/java/nashi/NRPG/listeners/EventListener.java @@ -0,0 +1,962 @@ +package nashi.NRPG.listeners; + +import edited.com.codingforcookies.armorequip.AfterArmorEquipEvent; +import edited.com.codingforcookies.armorequip.ArmorType; +import java.text.DecimalFormat; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Set; +import java.util.UUID; + +import nashi.NRPG.Main; +import nashi.NRPG.API.SkillAPI; +import nashi.NRPG.API.Utils; +import nashi.NRPG.API.Utils.Status; +import nashi.NRPG.CustomEvents.CastEvent; +import nashi.NRPG.CustomEvents.CastStartEvent; +import nashi.NRPG.CustomEvents.SkillItemGenerateEvent; +import nashi.NRPG.Players.Players; +import nashi.NRPG.Players.Players.PlayerData; +import nashi.NRPG.Players.Races.Race; +import nashi.NRPG.Skills.Cast; +import nashi.NRPG.Skills.GUI; +import nashi.NRPG.Skills.Magic; +import nashi.NRPG.Skills.Skill; +import nashi.NRPG.Skills.SkillName; +import nashi.NRPG.Skills.Cast.Abracadabra; +import net.minecraft.server.v1_16_R3.IChatBaseComponent; +import net.minecraft.server.v1_16_R3.IChatBaseComponent.ChatSerializer; +import net.minecraft.server.v1_16_R3.PacketPlayOutTitle; +import net.minecraft.server.v1_16_R3.PacketPlayOutTitle.EnumTitleAction; + +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.Particle; +import org.bukkit.Sound; +import org.bukkit.attribute.Attribute; +import org.bukkit.attribute.AttributeModifier; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.craftbukkit.v1_16_R3.entity.CraftPlayer; +import org.bukkit.entity.Entity; +import org.bukkit.entity.ItemFrame; +import org.bukkit.entity.LivingEntity; +import org.bukkit.entity.Player; +import org.bukkit.event.Event; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import org.bukkit.event.block.Action; +import org.bukkit.event.block.BlockPlaceEvent; +import org.bukkit.event.entity.PlayerDeathEvent; +import org.bukkit.event.inventory.ClickType; +import org.bukkit.event.inventory.InventoryClickEvent; +import org.bukkit.event.inventory.InventoryCloseEvent; +import org.bukkit.event.inventory.InventoryType; +import org.bukkit.event.player.PlayerDropItemEvent; +import org.bukkit.event.player.PlayerInteractEntityEvent; +import org.bukkit.event.player.PlayerInteractEvent; +import org.bukkit.event.player.PlayerJoinEvent; +import org.bukkit.event.player.PlayerLoginEvent; +import org.bukkit.event.player.PlayerMoveEvent; +import org.bukkit.event.player.PlayerQuitEvent; +import org.bukkit.event.player.PlayerRespawnEvent; +import org.bukkit.event.player.PlayerSwapHandItemsEvent; +import org.bukkit.inventory.Inventory; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.PlayerInventory; +import org.bukkit.inventory.meta.ItemMeta; +import org.bukkit.persistence.PersistentDataContainer; +import org.bukkit.persistence.PersistentDataType; +import org.bukkit.scheduler.BukkitRunnable; + +public class EventListener implements Listener { + public static HashMap scooldowns = new HashMap(); + public static HashMap skillmode = new HashMap(); + private static DecimalFormat df = new DecimalFormat("#.##"); + public static HashMap backup = new HashMap(); + public static HashMap castCD = new HashMap(); + public static HashMap cast = new HashMap(); + public static long CD = 500L; + public static HashMap refresh = new HashMap(); + + @EventHandler + public void move(PlayerMoveEvent event) { + Player player = event.getPlayer(); + if (!refresh.containsKey(player)) { + PlayerData pd = Players.Data.get(player); + Players.recalcData(player, pd); + refresh.put(player, System.currentTimeMillis() + 10000); + return; + } + if (refresh.get(player) < System.currentTimeMillis()) { + PlayerData pd = Players.Data.get(player); + Players.recalcData(player, pd); + } + } + + @EventHandler + public void caststart(CastEvent e) { + if (e.isCancelled()) { + return; + } + Player player = e.getPlayer(); + PlayerInventory inv = player.getInventory(); + ItemStack item = inv.getItemInMainHand(); + Casting cast = e.getCast(); + Abracadabra a = cast.getAbracadabra(); + Set s = a.getPos(); + if (!cast.validPos()) { + return; + } + if (cast.getSuccessTime() < 1) { + cast.setWand(item); + int i = ModifyItem.getItemCastMod(item); + if (castmod.containsKey(player)) { + i += castmod.get(player); + } + cast.setModSuccess(i); + } + if (!cast.getWand().equals(item)) { + cast.setModSuccess(0); + } + if (s.contains(cast.getPos())) { + cast.success(); + player.playSound(player.getLocation(), Sound.ENTITY_EXPERIENCE_ORB_PICKUP, 3.0f, 3.0f); + if (cast.getSuccessTime() + cast.getSuccessMod() >= cast.getNeededTimes()) { + castCD.put(player, System.currentTimeMillis() + CD); + ItemStack n = inv.getItemInOffHand(); + ItemMeta m = n.getItemMeta(); + PersistentDataContainer pdc = m.getPersistentDataContainer(); + if (pdc.has(ModifyItem.CastHelp, PersistentDataType.BYTE)) { + inv.setItemInOffHand(null); + } + EventListener.cast.remove(player); + Skill.cast(cast.getSkillName(), player, false); + } + } else { + int t = cast.getSuccessTime(); + String skname = cast.getSkillName(); + Location loc = player.getLocation(); + loc.getWorld().playSound(loc, Sound.ENTITY_GENERIC_EXPLODE, (float) t, 3.0f); + loc.getWorld().spawnParticle(Particle.EXPLOSION_HUGE, loc, 2); + double cost = SkillAPI.getPublicSkillInfo(skname, "CostMP"); + SkillAPI.costMP(player, cost); + double damage = cost * Utils.manaDMG * ((0.0 + t) / cast.getNeededTimes()); + SkillAPI.damage((LivingEntity) player, (Player) player, damage); + for (LivingEntity ent : SkillAPI.getNearEntity((Player) player, (int) ((int) Math.pow(cost, 0.5)))) { + SkillAPI.damage((LivingEntity) ent, (Player) player, damage); + } + ItemStack n = inv.getItemInOffHand(); + ItemMeta m = n.getItemMeta(); + try { + PersistentDataContainer pdc = m.getPersistentDataContainer(); + if (pdc.has(ModifyItem.CastHelp, PersistentDataType.BYTE)) { + inv.setItemInOffHand(null); + } + } catch (Exception pdc) { + // empty catch block + } + castCD.put(player, System.currentTimeMillis() + CD); + EventListener.cast.remove(player); + return; + } + } + + @EventHandler + public void close(InventoryCloseEvent e) { + Player player = (Player) e.getPlayer(); + PlayerData pd = Players.Data.get(player); + Players.recalcData(player, pd); + + } + + @EventHandler + public void equip(AfterArmorEquipEvent e) { + Player player = e.getPlayer(); + PlayerData pd = Players.Data.get(player); + Players.recalcData(player, pd); + } + + @EventHandler + public void logout(PlayerQuitEvent e) { + Player player = e.getPlayer(); + Players.unload((Player) player); + if (backup.containsKey(player)) { + PlayerInventory inv = player.getInventory(); + ItemStack[] back = backup.get(player).clone(); + int n = back.length; + for (int n2 = 0; n2 < n; n2++) { + ItemStack item = back[n2]; + inv.setItem(n2, item); + } + backup.remove(player); + } + if (ModifyItem.edit.containsKey(player)) { + ModifyItem.edit.remove(player); + } + } + + @EventHandler + public void login(PlayerLoginEvent e) { + Player player = e.getPlayer(); + Players.loadYaml(player); + skillmode.put(player, false); + Magic.check(player); + } + + @EventHandler + public void Join(PlayerJoinEvent e) { + Player player = e.getPlayer(); + Main.setPlayerScoreboard(player); + YamlConfiguration y = Players.getYaml(player); + y.set("ID", player.getName()); + int a = y.getInt("Scale"); + if (a > 0) { + player.setHealthScale(a); + } else { + player.setHealthScale(20.0); + } + PlayerData pd = Players.Data.get(player); + Players.recalcData(player, pd); + if (ModifyItem.edit.containsKey(player)) { + ModifyItem.edit.remove(player); + } + } + + @EventHandler + public void respawn(PlayerRespawnEvent e) { + Player player = e.getPlayer(); + if (backup.containsKey(player)) { + PlayerInventory inv = player.getInventory(); + ItemStack[] back = backup.get(player).clone(); + int n = back.length; + for (int n2 = 0; n2 < n; n2++) { + ItemStack item = back[n2]; + inv.setItem(n2, item); + } + backup.remove(player); + skillmode.put(player, false); + } + Players.PlayerData pdata = Players.Data.get(player); + Players.recalcData(player, pdata); + } + + public static void setData(Player player, Players.PlayerData pdata) { + if (skillmode.get(player)) { + double d; + if (extra.containsKey(player)) { + d = extra.get(player); + } else { + d = 0; + } + player.getAttribute(Attribute.GENERIC_ATTACK_DAMAGE) + .setBaseValue(player.getAttribute(Attribute.GENERIC_ATTACK_DAMAGE).getBaseValue() + d); + player.getAttribute(Attribute.GENERIC_MAX_HEALTH).setBaseValue(pdata.getMaxHealth()); + player.setWalkSpeed(pdata.getSpeed()); + if (pdata.getCurrentMP() > pdata.getMaxMana()) { + pdata.setCurrentMP(pdata.getMaxMana()); + } + } else { + if (player.getAttribute(Attribute.GENERIC_MAX_HEALTH).getBaseValue() != pdata.getMaxHealth()) { + player.getAttribute(Attribute.GENERIC_MAX_HEALTH).setBaseValue(pdata.getMaxHealth()); + } + player.setWalkSpeed(pdata.getSpeed()); + if (pdata.getCurrentMP() > pdata.getMaxMana()) { + pdata.setCurrentMP(pdata.getMaxMana()); + } + } + } + + @EventHandler + public void check(InventoryClickEvent e) { + if (e.isCancelled()) { + return; + } + try { + if (e.getClickedInventory().getType() == InventoryType.PLAYER) { + ItemStack i = e.getCurrentItem(); + if (i == null) { + return; + } + ItemStack c = e.getCursor(); + if (e.getSlotType() == InventoryType.SlotType.ARMOR && Utils.isNotDrop(i)) { + if (c == null || c.getType() == Material.AIR) { + e.setCancelled(true); + return; + } + int slot = e.getSlot(); + ArmorType at = ArmorType.matchType(c); + if (at == null) { + return; + } + if (at.equals(ArmorType.BOOTS) && slot != 36) { + e.setCancelled(true); + return; + } + if (at.equals(ArmorType.LEGGINGS) && slot != 37) { + e.setCancelled(true); + return; + } + if (at.equals(ArmorType.CHESTPLATE) && slot != 38) { + e.setCancelled(true); + return; + } + if (at.equals(ArmorType.HELMET) && slot != 39) { + e.setCancelled(true); + return; + } + e.setCurrentItem(null); + } + } + } catch (Exception i) { + // empty catch block + } + } + + @EventHandler + public void SkillEditPageGUI(InventoryClickEvent e) { + if (!e.getView().getTitle().contains("技能調整")) { + return; + } + e.setCancelled(true); + Player player = (Player) e.getWhoClicked(); + if (e.getClick() == ClickType.valueOf("SWAP_OFFHAND")) { + player.closeInventory(); + ItemStack item = player.getInventory().getItemInOffHand().clone(); + new BukkitRunnable() { + public void run() { + player.getInventory().setItemInOffHand(item); + } + }.runTaskLater(SkillAPI.plugin(), 1L); + return; + } + if (e.getClick() != ClickType.LEFT && e.getClick() != ClickType.RIGHT) { + return; + } + ItemStack item = e.getCurrentItem(); + if (item == null) { + return; + } + if (!item.hasItemMeta()) { + return; + } + ItemMeta im = item.getItemMeta(); + if (!im.hasDisplayName()) { + return; + } + if (ChatColor.stripColor(im.getDisplayName()).equals("下一頁")) { + + GUI.EditGUI(player, (GUI.editpage.get(player) + 1)); + } else { + String skillname = SkillName.get(ChatColor.stripColor(im.getDisplayName())); + if (skillname == null) { + return; + } + GUI.openSkillEditGUI(player, skillname); + } + } + + @EventHandler + public void SlotEditClose(InventoryCloseEvent e) { + if (!e.getView().getTitle().contains("技能欄位設定")) { + return; + } + e.getView().setCursor(null); + Player player = (Player) e.getPlayer(); + Inventory inv = e.getInventory(); + String[] skills = new String[9]; + int i = 0; + while (i < 9) { + ItemStack item = inv.getItem(i); + if (item != null && item.hasItemMeta()) { + ItemMeta im = item.getItemMeta(); + skills[i] = SkillName.get(ChatColor.stripColor(im.getDisplayName())); + } + ++i; + } + YamlConfiguration y = Players.getYaml(player); + int slot = 0; + while (slot < 9) { + String skname = skills[slot]; + y.set("Slot." + slot, skname); + ++slot; + } + PlayerInventory pi = player.getInventory(); + int i2 = 0; + while (i2 < pi.getSize()) { + ItemStack item = pi.getItem(i2); + if (Utils.isNotDrop(item)) { + pi.setItem(i2, null); + } + ++i2; + } + } + + @EventHandler + public void SlotPageGUI(InventoryClickEvent e) { + if (!e.getView().getTitle().contains("技能欄位設定")) { + return; + } + Player player = (Player) e.getWhoClicked(); + if (e.getClick() == ClickType.valueOf("SWAP_OFFHAND")) { + e.setCancelled(true); + player.closeInventory(); + ItemStack item = player.getInventory().getItemInOffHand().clone(); + new BukkitRunnable() { + public void run() { + player.getInventory().setItemInOffHand(item); + } + }.runTaskLater(SkillAPI.plugin(), 1L); + return; + } + if (e.getClick() != ClickType.LEFT && e.getClick() != ClickType.RIGHT) { + e.setCancelled(true); + return; + } + if (e.getRawSlot() < 0 || e.getRawSlot() > 53) { + e.setCancelled(true); + return; + } + try { + if (e.getClickedInventory().equals(player.getInventory())) { + e.setCancelled(true); + return; + } + ItemStack item = e.getCurrentItem(); + if (item == null) { + return; + } + if (!item.hasItemMeta()) { + e.setCancelled(true); + return; + } + ItemMeta im = item.getItemMeta(); + if (!im.hasDisplayName()) { + e.setCancelled(true); + return; + } + if (ChatColor.stripColor(im.getDisplayName()).equals("下一頁")) { + e.setCancelled(true); + GUI.SlotGUI((Player) player, (GUI.editpage.get(player) + 1)); + return; + } + if (SkillName.get(ChatColor.stripColor(im.getDisplayName())) == null) { + e.setCancelled(true); + } + } catch (Exception e1) { + e.setCancelled(true); + } + } + + @EventHandler + public void SkillEditGUI(InventoryClickEvent e) { + Player player = (Player) e.getWhoClicked(); + if ((skillmode.get(player) || cast.containsKey(player)) && !e.getView().getTitle().contains("技能設定") + && !e.getView().getTitle().contains("技能調整")) { + e.setCancelled(true); + return; + } + if (!e.getView().getTitle().contains("技能設定")) { + return; + } + if (e.getClick() == ClickType.valueOf("SWAP_OFFHAND")) { + e.setCancelled(true); + player.closeInventory(); + ItemStack item = player.getInventory().getItemInOffHand().clone(); + new BukkitRunnable() { + public void run() { + player.getInventory().setItemInOffHand(item); + } + }.runTaskLater(SkillAPI.plugin(), 1L); + return; + } + if (e.getClick() != ClickType.LEFT && e.getClick() != ClickType.RIGHT && e.getClick() != ClickType.SHIFT_LEFT + && e.getClick() != ClickType.SHIFT_RIGHT) { + e.setCancelled(true); + return; + } + e.setCancelled(true); + String skillName = e.getView().getTitle().split("-")[1]; + ItemStack item = e.getCurrentItem(); + if (item == null) { + return; + } + YamlConfiguration yml = Players.getYaml((Player) player); + ItemMeta im = item.getItemMeta(); + boolean increase = im.getDisplayName().contains("提升"); + String var = ChatColor.stripColor(im.getDisplayName()).split(":")[1]; + double max = yml.getDouble("Skills." + skillName + ".Max." + var); + if (e.isShiftClick()) { + if (increase) { + if (e.isLeftClick()) { + double mod = Double + .parseDouble(df.format(yml.getDouble("Skills." + skillName + ".Custom." + var) + 0.1)); + if (mod > max) { + mod = max; + } + yml.set("Skills." + skillName + ".Custom." + var, mod); + } else { + double mod = Double + .parseDouble(df.format(yml.getDouble("Skills." + skillName + ".Custom." + var) + 10)); + if (mod > max) { + mod = max; + } + yml.set("Skills." + skillName + ".Custom." + var, mod); + } + } else if (e.isLeftClick()) { + double mod = Double + .parseDouble(df.format(yml.getDouble("Skills." + skillName + ".Custom." + var) - 0.1)); + if (mod < 0.0) { + mod = 0.0; + } + yml.set("Skills." + skillName + ".Custom." + var, mod); + } else { + double mod = Double + .parseDouble(df.format(yml.getDouble("Skills." + skillName + ".Custom." + var) - 10)); + if (mod < 0.0) { + mod = 0.0; + } + yml.set("Skills." + skillName + ".Custom." + var, mod); + } + } else if (increase) { + if (e.isLeftClick()) { + double mod = Double + .parseDouble(df.format(yml.getDouble("Skills." + skillName + ".Custom." + var) + 0.01)); + if (mod > max) { + mod = max; + } + yml.set("Skills." + skillName + ".Custom." + var, mod); + } else { + double mod = Double.parseDouble(df.format(yml.getDouble("Skills." + skillName + ".Custom." + var) + 1)); + if (mod > max) { + mod = max; + } + yml.set("Skills." + skillName + ".Custom." + var, mod); + } + } else if (e.isLeftClick()) { + double mod = Double.parseDouble(df.format(yml.getDouble("Skills." + skillName + ".Custom." + var) - 0.01)); + if (mod < 0.0) { + mod = 0.0; + } + yml.set("Skills." + skillName + ".Custom." + var, mod); + } else { + double mod = Double.parseDouble(df.format(yml.getDouble("Skills." + skillName + ".Custom." + var) - 1)); + if (mod < 0.0) { + mod = 0.0; + } + yml.set("Skills." + skillName + ".Custom." + var, mod); + } + GUI.openSkillEditGUI((Player) player, skillName); + } + + @EventHandler + public void die(PlayerDeathEvent e) { + List drops = e.getDrops(); + List items = new ArrayList(); + for (ItemStack item : drops) { + if (!Utils.isNotDrop(item)) { + items.add(item); + } + } + drops.clear(); + drops.addAll(items); + Player player = e.getEntity(); + if (Utils.deathpenworld.contains(player.getWorld())) { + PlayerData pd = Players.Data.get(player); + Status status = pd.getStatus(); + if (Utils.Penalty_MakeUp) { + YamlConfiguration yml = Players.getYaml(player); + try { + for (String skill : yml.getConfigurationSection("Skills").getKeys(false)) { + if (yml.getBoolean("Skills." + skill + ".isMakeUp")) { + yml.set("Skills." + skill, null); + } + } + } catch (Exception e1) { + + } + } + if (Utils.Penalty_LVL) { + status.setLvL(1); + } + if (Utils.Penalty_Status) { + Status stat = Utils.getStatusFromInt(player.getUniqueId().hashCode(), status.getLvL()); + status = stat; + Utils.setPlayerStatus(player, stat); + Race race = pd.getRace(); + Players.Data.put(player, pd); + if (!Utils.Penalty_Race) { + pd = new PlayerData(player, race, stat, pd.getCurrentMP()); + } else { + pd = new PlayerData(player, stat); + } + } else if (Utils.Penalty_Race) { + Utils.setPlayerStatus(player, status); + pd = new PlayerData(player, status); + Players.Data.put(player, pd); + } + } + } + + @EventHandler + public void drop(PlayerDropItemEvent e) { + Player player = e.getPlayer(); + if (cast.containsKey(player) || skillmode.get(player).booleanValue()) { + e.setCancelled(true); + } + if (Utils.isNotDrop(e.getItemDrop().getItemStack())) { + e.setCancelled(true); + } + } + + public static HashMap extra = new HashMap(); + public static HashMap castmod = new HashMap(); + + @EventHandler(priority = EventPriority.HIGHEST) + public void SkillMode(PlayerSwapHandItemsEvent e) { + if (e.isCancelled()) { + return; + } + Player player = e.getPlayer(); + e.setCancelled(true); + YamlConfiguration y = Players.getYaml(player); + if (skillmode.get(player)) {// from skill mode + PlayerInventory inv = player.getInventory(); + ItemStack[] back = backup.get(player).clone(); + int n = back.length; + for (int n2 = 0; n2 < n; n2++) { + ItemStack item = back[n2]; + inv.setItem(n2, item); + } + double d; + if (extra.containsKey(player)) { + d = extra.get(player); + } else { + d = 0; + } + backup.remove(player); + skillmode.put(player, false); + player.getAttribute(Attribute.GENERIC_ATTACK_DAMAGE) + .setBaseValue(player.getAttribute(Attribute.GENERIC_ATTACK_DAMAGE).getBaseValue() - d); + extra.remove(player); + castmod.remove(player); + } else {// to skillmode + PlayerInventory inv = player.getInventory(); + ItemStack[] back = new ItemStack[9]; + for (int i = 0; i < 9; i++) { + back[i] = inv.getItem(i); + } + backup.put(player, back); + double d = 0; + int c = ModifyItem.getItemCastMod(inv.getItemInMainHand()); + try { + for (AttributeModifier a : inv.getItemInMainHand().getItemMeta() + .getAttributeModifiers(Attribute.GENERIC_ATTACK_DAMAGE)) { + d += a.getAmount(); + } + } catch (Exception e1) { + } + extra.put(player, d); + castmod.put(player, c); + player.getAttribute(Attribute.GENERIC_ATTACK_DAMAGE) + .setBaseValue(player.getAttribute(Attribute.GENERIC_ATTACK_DAMAGE).getBaseValue() + d); + int i = 0; + while (i < 9) { + try { + String sk = y.getString("Slot." + i); + ItemStack item = Utils.getSkillItem(sk, player); + SkillItemGenerateEvent event = new SkillItemGenerateEvent(player, item, sk); + Bukkit.getPluginManager().callEvent(event); + inv.setItem(i, item); + } catch (NullPointerException e1) { + ItemStack item = new ItemStack(Material.BARRIER); + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(AllAboutDamage.key, PersistentDataType.STRING, "ItemsNotDrop"); + item.setItemMeta(im); + inv.setItem(i, item); + } + ++i; + } + skillmode.put(player, true); + } + } + + public static void sendTitle(Player player, String title, int time1, int time2, int time3) { + IChatBaseComponent chatTitle = ChatSerializer.a("{\"text\": \"" + title + "\"}"); + PacketPlayOutTitle titleT = new PacketPlayOutTitle(EnumTitleAction.ACTIONBAR, chatTitle); + PacketPlayOutTitle length = new PacketPlayOutTitle(time1, time2, time3); + ((CraftPlayer) player).getHandle().playerConnection.sendPacket(titleT); + ((CraftPlayer) player).getHandle().playerConnection.sendPacket(length); + } + + public static void playercast(final Player player, final Casting cast, long speed, long limit) { + CastStartEvent ce = new CastStartEvent(player, cast); + Bukkit.getPluginManager().callEvent(ce); + if (ce.isCancelled()) { + return; + } + EventListener.cast.put(player, cast); + final String a = cast.getAbracadabra().getString(); + sendTitle(player, Cast.getDisplay(a, cast.getPos()), 5, 5, 5); + /* + * player.spigot().sendMessage(ChatMessageType.ACTION_BAR, + * TextComponent.fromLegacyText(Cast.getDisplay(a, cast.getPos()))); + */ + final long breaktime = System.currentTimeMillis() + limit; + new BukkitRunnable() { + + public void run() { + if (!EventListener.cast.containsKey(player)) { + this.cancel(); + return; + } + if (System.currentTimeMillis() > breaktime) { + int t = cast.getSuccessTime(); + String skname = cast.getSkillName(); + double cost = SkillAPI.getPublicSkillInfo(skname, "CostMP"); + SkillAPI.costMP((Player) player, cost); + double damage = cost * Utils.manaDMG * ((0.0 + t) / cast.getNeededTimes()); + Location loc = player.getLocation(); + loc.getWorld().playSound(loc, Sound.ENTITY_GENERIC_EXPLODE, (float) t, 3.0f); + loc.getWorld().spawnParticle(Particle.EXPLOSION_HUGE, loc, 2); + SkillAPI.damage(player, player, damage); + for (LivingEntity ent : SkillAPI.getNearEntity(player, ((int) Math.pow(cost, 0.5)))) { + SkillAPI.damage(ent, player, damage); + } + EventListener.cast.remove(player); + EventListener.castCD.put(player, System.currentTimeMillis() + EventListener.CD); + this.cancel(); + return; + } + cast.nextPos(); + sendTitle(player, Cast.getDisplay(a, cast.getPos()), 5, 5, 5); + /* + * player.spigot().sendMessage(ChatMessageType.ACTION_BAR, + * TextComponent.fromLegacyText(Cast.getDisplay(a, cast.getPos()))); + */ + } + }.runTaskTimer(Main.getPlugin(), speed, speed); + } + + @EventHandler + public void place(BlockPlaceEvent e) { + Player player = e.getPlayer(); + if (cast.containsKey(player) || skillmode.get(player).booleanValue()) { + e.setCancelled(true); + } + } + + @EventHandler + public void itemframe(PlayerInteractEntityEvent event) { + + Player player = event.getPlayer(); + + Entity e = event.getRightClicked(); + + if (e instanceof ItemFrame) { + + if (Utils.isNotDrop(player.getInventory().getItemInMainHand())) { + event.setCancelled(true); + } + + } + + } + + @EventHandler(priority = EventPriority.LOWEST) + public void interact(PlayerInteractEvent event) { + ItemStack item; + Player player = event.getPlayer(); + if ((item = event.getItem()) != null) { + if (!item.hasItemMeta()) { + return; + } + ItemMeta im = item.getItemMeta(); + if (im.isUnbreakable()) { + String skillname = ModifyItem.getSkillBookSkill(item); + if (skillname != null) { + event.setCancelled(true); + YamlConfiguration y = Players.getYaml((Player) player); + int slot = y.getInt("UniqueSkillSlots"); + if (slot > y.getInt("UsedSlots")) { + if (!Magic.learnSkill((Player) player, skillname)) { + player.sendMessage(ChatColor.RED + "你已經擁有此技能"); + return; + } + ItemStack book = player.getInventory().getItemInMainHand(); + book.setAmount(book.getAmount() - 1); + player.sendMessage(ChatColor.GREEN + "你已學習了" + skillname); + } else { + player.sendMessage(ChatColor.RED + "請確認你是否擁有足夠的欄位"); + } + return; + } + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(Utils.key, PersistentDataType.STRING)) { + event.setCancelled(true); + double hp = 0.0; + double mp = 0.0; + Players.PlayerData pd = Players.Data.get(player); + pd.addCurrentMP(mp += ModifyItem.getPotionMP(item)); + double chp = player.getHealth(); + double max = player.getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue(); + if (chp + (hp += ModifyItem.getPotionHP(item)) < 0.0) { + player.setHealth(0.0); + } else if (chp + hp < max) { + player.setHealth(chp + hp); + } else { + player.setHealth(max); + } + int amount = item.getAmount(); + item.setAmount(amount - 1); + return; + } + } + } + if (cast.containsKey(player)) { + if (event.getAction().equals(Action.LEFT_CLICK_AIR) || event.getAction().equals(Action.LEFT_CLICK_BLOCK)) { + return; + } + event.setCancelled(true); + Casting c = cast.get(player); + CastEvent ce = new CastEvent(player, c); + Bukkit.getPluginManager().callEvent((Event) ce); + return; + } + if (!event.getAction().equals(Action.RIGHT_CLICK_AIR) && !event.getAction().equals(Action.RIGHT_CLICK_BLOCK)) { + return; + } + long cooldowntime = 100L; + if (scooldowns.containsKey(player.getUniqueId()) + && System.currentTimeMillis() - scooldowns.get(player.getUniqueId()) <= cooldowntime) { + return; + } + if (skillmode.get(player)) { + if (castCD.containsKey(player) && castCD.get(player) > System.currentTimeMillis()) { + return; + } + if (skillmode.get(player)) { + event.setCancelled(true); + scooldowns.put(player.getUniqueId(), System.currentTimeMillis()); + int slot = player.getInventory().getHeldItemSlot(); + YamlConfiguration y = Players.getYaml(player); + try { + String sk = y.getString("Slot." + slot); + if (sk.length() < 1) { + return; + } + double cost = SkillAPI.getPublicSkillInfo(sk, "CostMP"); + Players.PlayerData pd = Players.Data.get(player); + if (pd.getCurrentMP() - cost < 0.0) { + player.sendMessage(ChatColor.RED + "魔力不足"); + return; + } + if (SkillAPI.getPublicSkillInfo(sk, "Times") < 1.0) { + Skill.cast(sk, player, false); + } else { + long time = SkillAPI.getRemainingCooldown((Player) player, sk); + if (time > 0L) { + player.sendMessage(ChatColor.RED + "技能冷卻時間剩餘:" + time + " 毫秒"); + return; + } + Cast.Abracadabra abra = Cast + .getabracadabra(((int) SkillAPI.getPublicSkillInfo(sk, "Difficulty"))); + EventListener.playercast(player, + new Casting(sk, abra, (int) SkillAPI.getPublicSkillInfo(sk, "Times")), + (Cast.castspeed.get(player)), Cast.timelimit); + } + } catch (NullPointerException sk) { + // empty catch block + } + } + } + + } + + public static class Casting { + private int success = 0; + private String skillname; + private Cast.Abracadabra abracadabra; + private int pos; + private boolean d; + private int needed; + private boolean s; + private int add = 0; + private ItemStack item = null; + + public Casting(String skillname, Cast.Abracadabra abracadabra, int needed) { + this.skillname = skillname; + this.abracadabra = abracadabra; + this.pos = 1; + this.d = true; + this.needed = needed; + this.s = true; + } + + public int getSuccessMod() { + return this.add; + } + + public int getNeededTimes() { + return this.needed; + } + + public void setModSuccess(int mod) { + this.add = mod; + } + + public ItemStack getWand() { + return this.item; + } + + public void setWand(ItemStack wand) { + this.item = wand; + } + + public boolean validPos() { + return !this.s; + } + + public void nextPos() { + this.s = false; + if (this.pos < 20 && this.d) { + ++this.pos; + } else if (this.pos == 20 || this.pos == 1) { + d = !d; + this.pos = this.d ? ++this.pos : --this.pos; + } else { + --this.pos; + } + } + + public int getPos() { + return this.pos - 1; + } + + public Cast.Abracadabra getAbracadabra() { + return this.abracadabra; + } + + public int getSuccessTime() { + return this.success; + } + + public String getSkillName() { + return this.skillname; + } + + public void success() { + this.s = true; + ++this.success; + } + + public void addSuccessTime(int i) { + this.success += i; + } + } + +} \ No newline at end of file diff --git a/src/main/java/nashi/NRPG/listeners/ForgeListener.java b/src/main/java/nashi/NRPG/listeners/ForgeListener.java new file mode 100644 index 0000000..e4c5c66 --- /dev/null +++ b/src/main/java/nashi/NRPG/listeners/ForgeListener.java @@ -0,0 +1,597 @@ +package nashi.NRPG.listeners; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.UUID; + +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.Instrument; +import org.bukkit.Material; +import org.bukkit.Note; +import org.bukkit.Sound; +import org.bukkit.attribute.Attribute; +import org.bukkit.attribute.AttributeModifier; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.Action; +import org.bukkit.event.inventory.InventoryClickEvent; +import org.bukkit.event.inventory.InventoryCloseEvent; +import org.bukkit.event.inventory.InventoryType; +import org.bukkit.event.player.PlayerInteractEvent; +import org.bukkit.event.player.PlayerQuitEvent; +import org.bukkit.inventory.EquipmentSlot; +import org.bukkit.inventory.Inventory; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; +import org.bukkit.persistence.PersistentDataContainer; +import org.bukkit.persistence.PersistentDataType; +import org.bukkit.scheduler.BukkitRunnable; + +import com.google.common.collect.Multimap; + +import nashi.NRPG.Main; +import nashi.NRPG.API.Utils; +import nashi.NRPG.Items.CreateItem; +import nashi.NRPG.Items.CreateItem.Technique; + +public class ForgeListener implements Listener { + + @EventHandler + public void openGUI(PlayerInteractEvent event) { + Player player = event.getPlayer(); + if (!(player.isSneaking() && event.getAction() == Action.RIGHT_CLICK_BLOCK + && (event.getClickedBlock().getType() == Material.ANVIL + || event.getClickedBlock().getType() == Material.CHIPPED_ANVIL + || event.getClickedBlock().getType() == Material.DAMAGED_ANVIL))) { + return; + } + event.setCancelled(true); + Inventory inv = Bukkit.createInventory(player, InventoryType.FURNACE, "裝備/武器鍛造"); + player.openInventory(inv); + } + + @EventHandler + public void ForgeGUI(InventoryClickEvent event) { + if (!event.getView().getTitle().equals("裝備/武器鍛造")) { + return; + } + event.setCancelled(true); + Inventory inv = event.getView().getTopInventory(); + if (event.getCurrentItem() == null) { + return; + } + ItemStack clicked = event.getCurrentItem().clone(); + if (!clicked.hasItemMeta()) { + return; + } + Player player = (Player) event.getWhoClicked(); + ItemStack item = inv.getItem(0); + ItemStack mat = inv.getItem(1); + if (clicked.getItemMeta().getPersistentDataContainer().has(CreateItem.key_click, PersistentDataType.INTEGER)) { + int time = CreateItem.getItemForgeTime(item); + if (CreateItem.max - time < 1) { + player.sendMessage(ChatColor.RED + "此道具已無法繼續鍛造"); + player.closeInventory(); + return; + } + int key = CreateItem.getItemForgeKey(item); + CreateItem.setItemForgeKey(item, -1); + if (key != -1) { + CreateItem.setItemForgeTime(item, time + 1); + int a = mat.getAmount(); + Technique tech = getTechnique(item, mat, key); + if (tech.isRandom()) { + int bond = (int) (tech.Rand_Max - tech.Rand_Min); + + double r = Utils.rand.nextInt(bond) + tech.Rand_Min; + + double[] raw = new double[10]; + raw[0] = r * tech.MAX_MANA; + r = Utils.rand.nextInt(bond) + tech.Rand_Min; + raw[1] = r * tech.MAX_HEALTH; + r = Utils.rand.nextInt(bond) + tech.Rand_Min; + raw[2] = r * tech.ARMOR_TOUGHNESS; + r = Utils.rand.nextInt(bond) + tech.Rand_Min; + raw[3] = r * tech.ARMOR; + r = Utils.rand.nextInt(bond) + tech.Rand_Min; + raw[4] = r * tech.ATTACK_DAMAGE; + r = Utils.rand.nextInt(bond) + tech.Rand_Min; + raw[5] = r * tech.ATTACK_SPEED; + r = Utils.rand.nextInt(bond) + tech.Rand_Min; + raw[6] = r * tech.ATTACK_RANGE; + r = Utils.rand.nextInt(bond) + tech.Rand_Min; + raw[7] = r * tech.KNOCKBACK_RESISTANCE; + r = Utils.rand.nextInt(bond) + tech.Rand_Min; + raw[8] = r * tech.MOVEMENT_SPEED; + r = Utils.rand.nextInt(bond) + tech.Rand_Min; + raw[9] = r * tech.CAST_MOD; + tech = new Technique(raw, CreateItem.getItemForgeSlot(item)); + } + Technique t = getLimitTechnique(item); + if (a > 1) { + mat.setAmount(a - 1); + inv.setItem(1, mat); + } else { + inv.setItem(1, null); + } + ItemMeta meta = item.getItemMeta(); + EquipmentSlot equip = tech.slot; + int castmod = 0; + double mp = 0, hp = 0, armor = 0, armor_toughness = 0, movement_speed = 0, attack_range = 0, + attack_speed = 0, knockback_resistance = 0, damage = 0; + if (meta.hasAttributeModifiers()) { + Multimap map = meta.getAttributeModifiers(equip); + Collection g_armor = map.get(Attribute.GENERIC_ARMOR); + double add_amount = 0; + double scalar_amount = 0; + double addmult_amount = 0; + for (AttributeModifier am : g_armor) { + switch (am.getOperation()) { + case ADD_NUMBER: + add_amount += am.getAmount(); + break; + case ADD_SCALAR: + scalar_amount += am.getAmount(); + break; + case MULTIPLY_SCALAR_1: + addmult_amount += am.getAmount(); + break; + default: + break; + } + } + g_armor.clear(); + if (add_amount + tech.ARMOR != 0) { + double amount = add_amount + tech.ARMOR; + armor = amount; + } + if (scalar_amount != 0) { + g_armor.add(new AttributeModifier(UUID.randomUUID(), "generic.armor", scalar_amount, + AttributeModifier.Operation.ADD_SCALAR, equip)); + } + if (addmult_amount != 0) { + g_armor.add(new AttributeModifier(UUID.randomUUID(), "generic.armor", addmult_amount, + AttributeModifier.Operation.MULTIPLY_SCALAR_1, equip)); + } + + Collection g_hp = map.get(Attribute.GENERIC_MAX_HEALTH); + add_amount = 0; + scalar_amount = 0; + addmult_amount = 0; + for (AttributeModifier am : g_hp) { + switch (am.getOperation()) { + case ADD_NUMBER: + add_amount += am.getAmount(); + break; + case ADD_SCALAR: + scalar_amount += am.getAmount(); + break; + case MULTIPLY_SCALAR_1: + addmult_amount += am.getAmount(); + break; + default: + break; + } + } + g_hp.clear(); + if (add_amount + tech.MAX_HEALTH != 0) { + double amount = add_amount + tech.MAX_HEALTH; + hp = amount; + } + if (scalar_amount != 0) { + g_hp.add(new AttributeModifier(UUID.randomUUID(), "generic.maxHealth", scalar_amount, + AttributeModifier.Operation.ADD_SCALAR, equip)); + } + if (addmult_amount != 0) { + g_hp.add(new AttributeModifier(UUID.randomUUID(), "generic.maxHealth", addmult_amount, + AttributeModifier.Operation.MULTIPLY_SCALAR_1, equip)); + } + + Collection at = map.get(Attribute.GENERIC_ARMOR_TOUGHNESS); + add_amount = 0; + scalar_amount = 0; + addmult_amount = 0; + for (AttributeModifier am : at) { + switch (am.getOperation()) { + case ADD_NUMBER: + add_amount += am.getAmount(); + break; + case ADD_SCALAR: + scalar_amount += am.getAmount(); + break; + case MULTIPLY_SCALAR_1: + addmult_amount += am.getAmount(); + break; + default: + break; + } + } + at.clear(); + if (add_amount + tech.ARMOR_TOUGHNESS != 0) { + double amount = add_amount + tech.ARMOR_TOUGHNESS; + armor_toughness = amount; + } + if (scalar_amount != 0) { + at.add(new AttributeModifier(UUID.randomUUID(), "generic.armorToughness", scalar_amount, + AttributeModifier.Operation.ADD_SCALAR, equip)); + } + if (addmult_amount != 0) { + at.add(new AttributeModifier(UUID.randomUUID(), "generic.armorToughness", addmult_amount, + AttributeModifier.Operation.MULTIPLY_SCALAR_1, equip)); + } + + Collection ad = map.get(Attribute.GENERIC_ATTACK_DAMAGE); + add_amount = 0; + scalar_amount = 0; + addmult_amount = 0; + for (AttributeModifier am : ad) { + switch (am.getOperation()) { + case ADD_NUMBER: + add_amount += am.getAmount(); + break; + case ADD_SCALAR: + scalar_amount += am.getAmount(); + break; + case MULTIPLY_SCALAR_1: + addmult_amount += am.getAmount(); + break; + default: + break; + } + } + ad.clear(); + if (add_amount + tech.ATTACK_DAMAGE != 0) { + double amount = add_amount + tech.ATTACK_DAMAGE; + if (amount > t.ATTACK_DAMAGE) { + amount = t.ATTACK_DAMAGE; + } + damage = amount; + ad.add(new AttributeModifier(UUID.randomUUID(), "generic.attackDamage", amount, + AttributeModifier.Operation.ADD_NUMBER, equip)); + } + if (scalar_amount != 0) { + ad.add(new AttributeModifier(UUID.randomUUID(), "generic.attackDamage", scalar_amount, + AttributeModifier.Operation.ADD_SCALAR, equip)); + } + if (addmult_amount != 0) { + ad.add(new AttributeModifier(UUID.randomUUID(), "generic.attackDamage", addmult_amount, + AttributeModifier.Operation.MULTIPLY_SCALAR_1, equip)); + } + + Collection as = map.get(Attribute.GENERIC_ATTACK_SPEED); + add_amount = 0; + scalar_amount = 0; + addmult_amount = 0; + for (AttributeModifier am : as) { + switch (am.getOperation()) { + case ADD_NUMBER: + add_amount += am.getAmount(); + break; + case ADD_SCALAR: + scalar_amount += am.getAmount(); + break; + case MULTIPLY_SCALAR_1: + addmult_amount += am.getAmount(); + break; + default: + break; + } + } + as.clear(); + if (add_amount + tech.ATTACK_SPEED != 0) { + double amount = add_amount + tech.ATTACK_SPEED; + if (amount > t.ATTACK_SPEED) { + amount = t.ATTACK_SPEED; + } + attack_speed = amount; + as.add(new AttributeModifier(UUID.randomUUID(), "generic.attackSpeed", amount, + AttributeModifier.Operation.ADD_NUMBER, equip)); + } + if (scalar_amount != 0) { + as.add(new AttributeModifier(UUID.randomUUID(), "generic.attackSpeed", scalar_amount, + AttributeModifier.Operation.ADD_SCALAR, equip)); + } + if (addmult_amount != 0) { + as.add(new AttributeModifier(UUID.randomUUID(), "generic.attackSpeed", addmult_amount, + AttributeModifier.Operation.MULTIPLY_SCALAR_1, equip)); + } + + Collection kr = map.get(Attribute.GENERIC_KNOCKBACK_RESISTANCE); + add_amount = 0; + scalar_amount = 0; + addmult_amount = 0; + for (AttributeModifier am : kr) { + switch (am.getOperation()) { + case ADD_NUMBER: + add_amount += am.getAmount(); + break; + case ADD_SCALAR: + scalar_amount += am.getAmount(); + break; + case MULTIPLY_SCALAR_1: + addmult_amount += am.getAmount(); + break; + default: + break; + } + } + kr.clear(); + if (add_amount + tech.KNOCKBACK_RESISTANCE != 0) { + double amount = add_amount + tech.KNOCKBACK_RESISTANCE; + if (amount > t.KNOCKBACK_RESISTANCE) { + amount = t.KNOCKBACK_RESISTANCE; + } + knockback_resistance = amount; + kr.add(new AttributeModifier(UUID.randomUUID(), "generic.knockbackResistance", amount, + AttributeModifier.Operation.ADD_NUMBER, equip)); + } + if (scalar_amount != 0) { + kr.add(new AttributeModifier(UUID.randomUUID(), "generic.knockbackResistance", scalar_amount, + AttributeModifier.Operation.ADD_SCALAR, equip)); + } + if (addmult_amount != 0) { + kr.add(new AttributeModifier(UUID.randomUUID(), "generic.knockbackResistance", addmult_amount, + AttributeModifier.Operation.MULTIPLY_SCALAR_1, equip)); + } + + Collection ms = map.get(Attribute.GENERIC_MOVEMENT_SPEED); + add_amount = 0; + scalar_amount = 0; + addmult_amount = 0; + for (AttributeModifier am : ms) { + switch (am.getOperation()) { + case ADD_NUMBER: + add_amount += am.getAmount(); + break; + case ADD_SCALAR: + scalar_amount += am.getAmount(); + break; + case MULTIPLY_SCALAR_1: + addmult_amount += am.getAmount(); + break; + default: + break; + } + } + ms.clear(); + if (add_amount + tech.MOVEMENT_SPEED != 0) { + double amount = add_amount + tech.MOVEMENT_SPEED; + if (amount > t.MOVEMENT_SPEED) { + amount = t.MOVEMENT_SPEED; + } + movement_speed = amount; + if (equip.equals(EquipmentSlot.HAND)) { + ms.add(new AttributeModifier(UUID.randomUUID(), "generic.movementSpeed", amount, + AttributeModifier.Operation.ADD_NUMBER, equip)); + } + } + if (scalar_amount != 0) { + ms.add(new AttributeModifier(UUID.randomUUID(), "generic.movementSpeed", scalar_amount, + AttributeModifier.Operation.ADD_SCALAR, equip)); + } + if (addmult_amount != 0) { + ms.add(new AttributeModifier(UUID.randomUUID(), "generic.movementSpeed", addmult_amount, + AttributeModifier.Operation.MULTIPLY_SCALAR_1, equip)); + } + meta.setAttributeModifiers(map); + // mod attribute + + } else {// if no attribute then add + meta.addAttributeModifier(Attribute.GENERIC_ATTACK_DAMAGE, new AttributeModifier(UUID.randomUUID(), + "generic.attackDamage", tech.ATTACK_DAMAGE, AttributeModifier.Operation.ADD_NUMBER, equip)); + meta.addAttributeModifier(Attribute.GENERIC_ATTACK_SPEED, new AttributeModifier(UUID.randomUUID(), + "generic.attackSpeed", tech.ATTACK_SPEED, AttributeModifier.Operation.ADD_NUMBER, equip)); + meta.addAttributeModifier(Attribute.GENERIC_KNOCKBACK_RESISTANCE, + new AttributeModifier(UUID.randomUUID(), "generic.knockbackResistance", + tech.KNOCKBACK_RESISTANCE, AttributeModifier.Operation.ADD_NUMBER, equip)); + if (equip.equals(EquipmentSlot.HAND)) { + meta.addAttributeModifier(Attribute.GENERIC_MOVEMENT_SPEED, + (new AttributeModifier(UUID.randomUUID(), "generic.movementSpeed", tech.MOVEMENT_SPEED, + AttributeModifier.Operation.ADD_NUMBER, equip))); + } + hp = tech.MAX_HEALTH; + armor = tech.ARMOR; + armor_toughness = tech.ARMOR_TOUGHNESS; + movement_speed = tech.MOVEMENT_SPEED; + attack_speed = tech.ATTACK_SPEED; + knockback_resistance = tech.KNOCKBACK_RESISTANCE; + damage = tech.ATTACK_DAMAGE; + } + + item.setItemMeta(meta); + double cast = ModifyItem.getItemCastMod(item) + tech.CAST_MOD; + double range = ModifyItem.getItemRangeMod(item) + tech.ATTACK_RANGE; + double mana = ModifyItem.getItemMP(item) + tech.MAX_MANA; + if (cast != 0) { + if (cast > t.CAST_MOD) { + cast = t.CAST_MOD; + } + ModifyItem.setItemCastMod(item, cast); + castmod = (int) cast; + } + if (range != 0) { + if (range > t.ATTACK_RANGE) { + range = t.ATTACK_RANGE; + } + ModifyItem.setItemRangeMod(item, range); + attack_range = range; + } + if (mana != 0) { + if (mana > t.MAX_MANA) { + mana = t.MAX_MANA; + } + ModifyItem.setItemMP(item, mana); + mp = mana; + } + // weapon mod + player.getLocation().getWorld().playSound(player.getLocation(), Sound.BLOCK_ANVIL_USE, 3, 1); + ItemMeta im = item.getItemMeta(); + List lore; + if (im.hasLore()) { + lore = im.getLore(); + } else { + lore = new ArrayList(); + } + hp += ModifyItem.getItemHP(item); + armor += ModifyItem.getItemAR(item); + armor_toughness += ModifyItem.getItemAT(item); + movement_speed += ModifyItem.getItemSD(item); + if (movement_speed > t.MOVEMENT_SPEED) { + movement_speed = t.MOVEMENT_SPEED; + } + if (hp > t.MAX_HEALTH) { + hp = t.MAX_HEALTH; + } + if (armor > t.ARMOR) { + armor = t.ARMOR; + } + if (armor_toughness > t.ARMOR_TOUGHNESS) { + armor_toughness = t.ARMOR_TOUGHNESS; + } + ModifyItem.setItemHP(item, hp); + ModifyItem.setItemAR(item, armor); + ModifyItem.setItemAT(item, armor_toughness); + if (!equip.equals(EquipmentSlot.HAND)) { + ModifyItem.setItemSD(item, movement_speed); + } + ModifyItem.LoreBuilder(item, tech.slot, hp, mp, armor, armor_toughness, movement_speed, attack_range, + attack_speed, knockback_resistance, castmod, damage, time + 1, lore); + } + return; + } + int clickSlot = event.getSlot(); + int type = CreateItem.getItemForgeSlot(clicked); + if (type != -1) { + int oldtype = CreateItem.getItemForgeSlot(inv.getItem(0)); + if (oldtype != -1) { + return; + } else { + ItemStack stack = clicked.clone(); + stack.setAmount(1); + inv.setItem(0, stack); + int amount = clicked.getAmount(); + if (amount > 1) { + clicked.setAmount(amount - 1); + player.getInventory().setItem(clickSlot, clicked); + } else { + player.getInventory().setItem(clickSlot, null); + } + } + } else { + String oldtier = getItemForgeMaterialTier(inv.getItem(1)); + if (oldtier == "-1") { + String tier = getItemForgeMaterialTier(clicked); + if (tier != "-1") { + inv.setItem(1, clicked); + player.getInventory().setItem(clickSlot, null); + } + } else { + return; + } + } + + item = inv.getItem(0); + mat = inv.getItem(1); + if (item != null && mat != null) { + inv.setItem(2, CreateItem.click.clone()); + PlayerForging(player, inv, item); + } else { + inv.setItem(2, null); + } + + } + + private static Technique getTechnique(ItemStack item, ItemStack material, int note) { + String tier = getItemForgeMaterialTier(material); + int slot = CreateItem.getItemForgeSlot(item); + String str = slot + "." + tier; + if (CreateItem.technique.containsKey(str)) { + return CreateItem.technique.get(str)[note]; + } else if (CreateItem.rand_technique.containsKey(tier)) { + return CreateItem.rand_technique.get(tier)[slot]; + } else { + System.out.println("Wrong Config? Error: \"" + tier + "\""); + return new Technique("0,0,0,0,0,0,0,0,0,0", slot); + } + } + + private static Technique getLimitTechnique(ItemStack item) { + int slot = CreateItem.getItemForgeSlot(item); + String str = "" + slot; + if (CreateItem.limits.containsKey(str)) { + return CreateItem.limits.get(str); + } else { + return new Technique("0,0,0,0,0,0,0,0,0,0", slot); + } + } + + private static String getItemForgeMaterialTier(ItemStack item) { + if (item == null || item.getType() == Material.AIR) { + return "-1"; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(CreateItem.key_material, PersistentDataType.STRING)) { + return pdc.get(CreateItem.key_material, PersistentDataType.STRING); + } + return "-1"; + } + + private static Note getNoteFromInt(int i) { + return CreateItem.notes[i]; + } + + private static int getRandomIntforNote() { + return Utils.rand.nextInt(CreateItem.size); + } + + private static void playNote(Note note, Player player) { + player.playNote(player.getLocation(), Instrument.BIT, note); + } + + private static void PlayerForging(Player player, Inventory inv, ItemStack item) { + int time = CreateItem.getItemForgeTime(item); + if (CreateItem.max - time < 1) { + player.sendMessage(ChatColor.RED + "此道具已無法繼續鍛造"); + player.closeInventory(); + return; + } + int i = getRandomIntforNote(); + Note note = getNoteFromInt(i); + CreateItem.setItemForgeKey(item, i); + playNote(note, player); + new BukkitRunnable() { + @Override + public void run() { + if (inv.getItem(0) != null && inv.getItem(1) != null) { + if (inv.getItem(0).equals(item)) { + PlayerForging(player, inv, item); + } + } + } + }.runTaskLater(Main.getPlugin(), CreateItem.rate); + } + + @EventHandler + public void leave(PlayerQuitEvent event) { + Player player = event.getPlayer(); + player.closeInventory(); + } + + @EventHandler + public void closeEvent(InventoryCloseEvent event) { + Player player = (Player) event.getPlayer(); + Inventory inv = event.getInventory(); + if (!event.getView().getTitle().equals("裝備/武器鍛造")) { + return; + } + Utils.additem(player, inv.getItem(0)); + Utils.additem(player, inv.getItem(1)); + inv.setItem(0, null); + inv.setItem(1, null); + inv.setItem(2, null); + } +} diff --git a/src/main/java/nashi/NRPG/listeners/ModifyItem.java b/src/main/java/nashi/NRPG/listeners/ModifyItem.java new file mode 100644 index 0000000..cc600b7 --- /dev/null +++ b/src/main/java/nashi/NRPG/listeners/ModifyItem.java @@ -0,0 +1,680 @@ +package nashi.NRPG.listeners; + +import java.text.DecimalFormat; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.List; +import java.util.UUID; + +import org.bukkit.ChatColor; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.NamespacedKey; +import org.bukkit.attribute.Attribute; +import org.bukkit.attribute.AttributeModifier; +import org.bukkit.enchantments.Enchantment; +import org.bukkit.entity.EntityType; +import org.bukkit.entity.LivingEntity; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.Action; +import org.bukkit.event.player.PlayerInteractEvent; +import org.bukkit.event.player.PlayerItemHeldEvent; +import org.bukkit.inventory.EquipmentSlot; +import org.bukkit.inventory.ItemFlag; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; +import org.bukkit.persistence.PersistentDataContainer; +import org.bukkit.persistence.PersistentDataType; + +import com.google.common.collect.Multimap; + +import nashi.NRPG.Main; +import nashi.NRPG.API.SkillAPI; +import nashi.NRPG.API.Utils; + +public class ModifyItem implements Listener { + public static NamespacedKey Item_Range = new NamespacedKey(Main.getPlugin(), "NRPG_AttackRange"); + public static NamespacedKey Castkey = new NamespacedKey(Main.getPlugin(), "NRPG_CastMod"); + public static HashMap edit = new HashMap(); + public static HashMap atktime = new HashMap(); + public static NamespacedKey CastHelp = new NamespacedKey(Main.getPlugin(), "NRPG_CastHelp"); + public static NamespacedKey Item_MP = new NamespacedKey(Main.getPlugin(), "NRPG_ItemMP");// mp + public static NamespacedKey Item_HP = new NamespacedKey(Main.getPlugin(), "NRPG_ItemHP");// hp + public static NamespacedKey Item_AR = new NamespacedKey(Main.getPlugin(), "NRPG_ItemAR");// armor + public static NamespacedKey Item_AT = new NamespacedKey(Main.getPlugin(), "NRPG_ItemAT");// armor toughness + public static NamespacedKey Item_SD = new NamespacedKey(Main.getPlugin(), "NRPG_ItemSD");// speed + + public static void updateItem(ItemStack item, EquipmentSlot equip) { + if (item == null || item.getType().equals(Material.AIR) || equip.equals(EquipmentSlot.HAND)) { + return; + } + double hp = 0, armor = 0, armor_toughness = 0, movement_speed = 0; + try { + ItemMeta meta = item.getItemMeta(); + if (meta.hasAttributeModifiers()) { + Multimap map = meta.getAttributeModifiers(equip); + Collection g_armor = map.get(Attribute.GENERIC_ARMOR); + double add_amount = 0; + double scalar_amount = 0; + double addmult_amount = 0; + for (AttributeModifier am : g_armor) { + switch (am.getOperation()) { + case ADD_NUMBER: + add_amount += am.getAmount(); + break; + default: + break; + } + } + g_armor.clear(); + armor = add_amount; + if (scalar_amount != 0) { + g_armor.add(new AttributeModifier(UUID.randomUUID(), "generic.armor", scalar_amount, + AttributeModifier.Operation.ADD_SCALAR, equip)); + } + if (addmult_amount != 0) { + g_armor.add(new AttributeModifier(UUID.randomUUID(), "generic.armor", addmult_amount, + AttributeModifier.Operation.MULTIPLY_SCALAR_1, equip)); + } + + Collection g_hp = map.get(Attribute.GENERIC_MAX_HEALTH); + add_amount = 0; + scalar_amount = 0; + addmult_amount = 0; + for (AttributeModifier am : g_hp) { + switch (am.getOperation()) { + case ADD_NUMBER: + add_amount += am.getAmount(); + break; + case ADD_SCALAR: + scalar_amount += am.getAmount(); + break; + case MULTIPLY_SCALAR_1: + addmult_amount += am.getAmount(); + break; + default: + break; + } + } + g_hp.clear(); + hp = add_amount; + if (scalar_amount != 0) { + g_hp.add(new AttributeModifier(UUID.randomUUID(), "generic.maxHealth", scalar_amount, + AttributeModifier.Operation.ADD_SCALAR, equip)); + } + if (addmult_amount != 0) { + g_hp.add(new AttributeModifier(UUID.randomUUID(), "generic.maxHealth", addmult_amount, + AttributeModifier.Operation.MULTIPLY_SCALAR_1, equip)); + } + + Collection at = map.get(Attribute.GENERIC_ARMOR_TOUGHNESS); + add_amount = 0; + scalar_amount = 0; + addmult_amount = 0; + for (AttributeModifier am : at) { + switch (am.getOperation()) { + case ADD_NUMBER: + add_amount += am.getAmount(); + break; + case ADD_SCALAR: + scalar_amount += am.getAmount(); + break; + case MULTIPLY_SCALAR_1: + addmult_amount += am.getAmount(); + break; + default: + break; + } + } + at.clear(); + + armor_toughness = add_amount; + if (scalar_amount != 0) { + at.add(new AttributeModifier(UUID.randomUUID(), "generic.armorToughness", scalar_amount, + AttributeModifier.Operation.ADD_SCALAR, equip)); + } + if (addmult_amount != 0) { + at.add(new AttributeModifier(UUID.randomUUID(), "generic.armorToughness", addmult_amount, + AttributeModifier.Operation.MULTIPLY_SCALAR_1, equip)); + } + + Collection ms = map.get(Attribute.GENERIC_MOVEMENT_SPEED); + add_amount = 0; + scalar_amount = 0; + addmult_amount = 0; + for (AttributeModifier am : ms) { + switch (am.getOperation()) { + case ADD_NUMBER: + add_amount += am.getAmount(); + break; + case ADD_SCALAR: + scalar_amount += am.getAmount(); + break; + case MULTIPLY_SCALAR_1: + addmult_amount += am.getAmount(); + break; + default: + break; + } + } + ms.clear(); + + movement_speed = add_amount; + if (scalar_amount != 0) { + ms.add(new AttributeModifier(UUID.randomUUID(), "generic.movementSpeed", scalar_amount, + AttributeModifier.Operation.ADD_SCALAR, equip)); + } + if (addmult_amount != 0) { + ms.add(new AttributeModifier(UUID.randomUUID(), "generic.movementSpeed", addmult_amount, + AttributeModifier.Operation.MULTIPLY_SCALAR_1, equip)); + } + meta.setAttributeModifiers(map); + // mod attribute + if (hp + armor + armor_toughness + movement_speed != 0) { + item.setItemMeta(meta); + setItemHP(item, getItemHP(item) + hp); + setItemAR(item, getItemAR(item) + armor); + setItemAT(item, getItemAT(item) + armor_toughness); + setItemSD(item, getItemSD(item) + movement_speed); + } + } + + } catch (Exception e) { + + } + } + + public static void setItemHP(ItemStack item, double amount) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(ModifyItem.Item_HP, PersistentDataType.DOUBLE, amount); + item.setItemMeta(im); + } + + public static double getItemHP(ItemStack item) { + double range = 0; + if (item == null || item.getType() == Material.AIR) { + return range; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(Item_HP, PersistentDataType.DOUBLE)) { + range += pdc.get(Item_HP, PersistentDataType.DOUBLE); + } + return range; + } + + public static void setItemAR(ItemStack item, double amount) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(ModifyItem.Item_AR, PersistentDataType.DOUBLE, amount); + item.setItemMeta(im); + } + + public static double getItemAR(ItemStack item) { + double range = 0; + if (item == null || item.getType() == Material.AIR) { + return range; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(Item_AR, PersistentDataType.DOUBLE)) { + range += pdc.get(Item_AR, PersistentDataType.DOUBLE); + } + return range; + } + + public static void setItemAT(ItemStack item, double amount) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(ModifyItem.Item_AT, PersistentDataType.DOUBLE, amount); + item.setItemMeta(im); + } + + public static double getItemAT(ItemStack item) { + double range = 0; + if (item == null || item.getType() == Material.AIR) { + return range; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(Item_AT, PersistentDataType.DOUBLE)) { + range += pdc.get(Item_AT, PersistentDataType.DOUBLE); + } + return range; + } + + public static void setItemSD(ItemStack item, double amount) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(ModifyItem.Item_SD, PersistentDataType.DOUBLE, amount); + item.setItemMeta(im); + } + + public static double getItemSD(ItemStack item) { + double range = 0; + if (item == null || item.getType() == Material.AIR) { + return range; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(Item_SD, PersistentDataType.DOUBLE)) { + range += pdc.get(Item_SD, PersistentDataType.DOUBLE); + } + return range; + } + + @EventHandler + public void click(PlayerInteractEvent event) { + Player player = event.getPlayer(); + if ((event.getAction().equals(Action.LEFT_CLICK_AIR))) { + double range = getPlayerAttackRange(player); + LivingEntity e = SkillAPI.getEntityInLineOfSight(player, range); + if (e == null) { + return; + } + Location loc = player.getEyeLocation(); + if (e.getLocation().distance(loc) > 4) { + double dmg = player.getAttribute(Attribute.GENERIC_ATTACK_DAMAGE).getValue() * AtkModBasedCD(player) + + extraATKBasedEnch(player, e); + e.damage(dmg, player); + } + atktime.put(player, System.currentTimeMillis()); + } + if (event.getAction().equals(Action.LEFT_CLICK_BLOCK)) { + atktime.put(player, System.currentTimeMillis()); + } + } + + @EventHandler + public void itemswitch(PlayerItemHeldEvent event) { + Player player = event.getPlayer(); + atktime.put(player, System.currentTimeMillis()); + } + + private static String LorePrefix = ChatColor.WHITE + "〕"; + private static DecimalFormat df = new DecimalFormat("#.##"); + private static String LoreLine = ChatColor.WHITE + "=============================="; + + public static void LoreBuilder(ItemStack item, EquipmentSlot slot, double hp, double mp, double armor, + double armor_toughness, double movement_speed, double attack_range, double attack_speed, + double knockback_resistance, int castmod, double damage, int forge_time, List oldLore) { + if (!item.hasItemMeta()) { + return; + } + ItemMeta meta = item.getItemMeta(); + meta.addItemFlags(ItemFlag.HIDE_ATTRIBUTES); + List lore = new ArrayList(); + String str = LorePrefix + "欄位: "; + switch (slot) { + case CHEST: + str += "胸甲"; + break; + case FEET: + str += "鞋子"; + break; + case LEGS: + str += "褲甲"; + break; + case HEAD: + str += "頭盔"; + break; + case OFF_HAND: + str += "副手"; + break; + case HAND: + str += "武器"; + break; + } + lore.add(str); + if (hp != 0) { + lore.add(ModifyItem.HPLoreBuilder(hp)); + } + if (mp != 0) { + lore.add(ModifyItem.MPLoreBuilder(mp)); + } + if ((int) (armor * 100) != 0) { + lore.add(ModifyItem.ArmorLoreBuilder(armor)); + } + if ((int) (armor_toughness * 100) != 0) { + lore.add(ModifyItem.ArmorToughnessLoreBuilder(armor_toughness)); + } + if ((int) (damage * 100) != 0) { + lore.add(ModifyItem.DamageLoreBuilder(damage)); + } + if ((int) (attack_range * 100) != 0) { + lore.add(ModifyItem.AttackRangeLoreBuilder(attack_range)); + } + if ((int) (attack_speed * 100) != 0) { + lore.add(ModifyItem.AttackSpeedLoreBuilder(attack_speed)); + } + if ((int) (movement_speed * 100) != 0) { + lore.add(ModifyItem.MovementSpeedLoreBuilder(movement_speed)); + } + if ((int) (knockback_resistance * 100) != 0) { + lore.add(ModifyItem.KnockbackResistanceLoreBuilder(knockback_resistance)); + } + if (castmod != 0) { + lore.add(ModifyItem.CastModLoreBuilder(castmod)); + } + if (forge_time != 0) { + lore.add(ForgeLoreBuilder(forge_time)); + } + if (oldLore.size() > 0) { + boolean t = true; + for (String l : oldLore) { + if (!l.startsWith(ModifyItem.LorePrefix) && !l.equals(ModifyItem.LoreLine)) { + if (t) { + lore.add(ModifyItem.LoreLine);// 分隔線 + t = false; + } + lore.add(l); + } + } + } + meta.setLore(lore); + item.setItemMeta(meta); + } + + public static String ForgeLoreBuilder(int amount) { + String str = LorePrefix + "已鍛造次數: "; + str += amount; + return str; + } + + public static String MPLoreBuilder(double amount) { + String str = LorePrefix + "魔力: "; + if (amount < 0) { + str += df.format(amount); + } else { + str += "+" + df.format(amount); + } + return str; + } + + public static String HPLoreBuilder(double amount) { + String str = LorePrefix + "血量: "; + if (amount < 0) { + str += df.format(amount); + } else { + str += "+" + df.format(amount); + } + return str; + } + + public static String ArmorLoreBuilder(double amount) { + String str = LorePrefix + "裝甲: "; + if (amount < 0) { + str += df.format(amount); + } else { + str += "+" + df.format(amount); + } + return str; + } + + public static String ArmorToughnessLoreBuilder(double amount) { + String str = LorePrefix + "抗性: "; + if (amount < 0) { + str += df.format(amount); + } else { + str += "+" + df.format(amount); + } + return str; + } + + public static String MovementSpeedLoreBuilder(double amount) { + String str = LorePrefix + "移動速度: "; + if (amount < 0) { + str += df.format(amount); + } else { + str += "+" + df.format(amount); + } + return str; + } + + public static String AttackRangeLoreBuilder(double amount) { + String str = LorePrefix + "攻擊距離: "; + if (amount < 0) { + str += df.format(amount); + } else { + str += "+" + df.format(amount); + } + return str; + } + + public static String AttackSpeedLoreBuilder(double amount) { + String str = LorePrefix + "攻擊速度: "; + if (amount < 0) { + str += df.format(amount); + } else { + str += "+" + df.format(amount); + } + return str; + } + + public static String KnockbackResistanceLoreBuilder(double amount) { + String str = LorePrefix + "抗擊退機率: "; + amount *= 100; + if (amount < 0) { + str += ((int) amount) + "%"; + } else { + str += "+" + ((int) amount) + "%"; + } + return str; + } + + public static String CastModLoreBuilder(int amount) { + String str = LorePrefix + "技能詠唱次數需求"; + if (amount < 0) { + str += "增加: " + df.format(Math.abs(amount)); + } else { + str += "減少: " + df.format(amount); + } + return str; + } + + public static String DamageLoreBuilder(double amount) { + String str = LorePrefix + "傷害: "; + if (amount < 0) { + str += df.format(amount); + } else { + str += "+" + df.format(amount); + } + return str; + } + + public static double getPlayerAttackRange(Player player) { + if (edit.containsKey(player)) { + return edit.get(player); + } + ItemStack item = player.getInventory().getItemInMainHand(); + double range = Utils.defaultattackrange; + if (item == null || item.getType() == Material.AIR) { + return range; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(Item_Range, PersistentDataType.DOUBLE)) { + range += pdc.get(Item_Range, PersistentDataType.DOUBLE); + } + return range; + } + + public static double getItemRangeMod(ItemStack item) { + double range = 0; + if (item == null || item.getType() == Material.AIR) { + return range; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(Item_Range, PersistentDataType.DOUBLE)) { + range += pdc.get(Item_Range, PersistentDataType.DOUBLE); + } + return range; + } + + public static double getItemMP(ItemStack item) { + double range = 0; + if (item == null || item.getType() == Material.AIR) { + return range; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(Item_MP, PersistentDataType.DOUBLE)) { + range += pdc.get(Item_MP, PersistentDataType.DOUBLE); + } + return range; + } + + public static void setItemRangeMod(ItemStack item, double range) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(ModifyItem.Item_Range, PersistentDataType.DOUBLE, range); + item.setItemMeta(im); + } + + public static void setItemMP(ItemStack item, double amount) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(ModifyItem.Item_MP, PersistentDataType.DOUBLE, amount); + item.setItemMeta(im); + } + + public static void setItemCastMod(ItemStack item, double time) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(ModifyItem.Castkey, PersistentDataType.DOUBLE, time); + item.setItemMeta(im); + } + + public static int getItemCastMod(ItemStack item) { + if (item == null || item.getType() == Material.AIR) { + return 0; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(ModifyItem.Castkey, PersistentDataType.DOUBLE)) { + return pdc.get(ModifyItem.Castkey, PersistentDataType.DOUBLE).intValue(); + } + return 0; + } + + public static double AtkModBasedCD(Player player) { + if (!atktime.containsKey(player)) { + return 1; + } + long o = atktime.get(player); + long n = System.currentTimeMillis(); + double t = (n - o) / 50.0; + double T = 1 / player.getAttribute(Attribute.GENERIC_ATTACK_SPEED).getValue() * 20; + double mult = 0.2 + ((t + 0.5) / T) * ((t + 0.5) / T) * 0.8; + if (mult > 1) { + mult = 1; + } + return mult; + } + + public static double extraATKBasedEnch(Player player, LivingEntity e) { + double dmg = 0; + ItemStack item = player.getInventory().getItemInMainHand(); + if (item.containsEnchantment(Enchantment.DAMAGE_ALL)) { + dmg += item.getEnchantmentLevel(Enchantment.DAMAGE_ALL) * 0.5; + } + EntityType type = e.getType(); + if (type == EntityType.SPIDER || type == EntityType.CAVE_SPIDER || type == EntityType.ENDERMITE + || type == EntityType.SILVERFISH) { + if (item.containsEnchantment(Enchantment.DAMAGE_ARTHROPODS)) { + dmg += item.getEnchantmentLevel(Enchantment.DAMAGE_ARTHROPODS) * 2.5; + } + } + if (type == EntityType.SKELETON || type == EntityType.SKELETON_HORSE || type == EntityType.STRAY + || type == EntityType.WITHER_SKELETON || type == EntityType.WITHER || type == EntityType.ZOMBIE + || type == EntityType.HUSK || type == EntityType.ZOMBIE_VILLAGER || type == EntityType.ZOMBIFIED_PIGLIN + || type == EntityType.DROWNED || type == EntityType.ZOMBIE_HORSE || type == EntityType.PHANTOM) { + if (item.containsEnchantment(Enchantment.DAMAGE_UNDEAD)) { + dmg += item.getEnchantmentLevel(Enchantment.DAMAGE_UNDEAD) * 2.5; + } + } + double mult; + if (!atktime.containsKey(player)) { + mult = 1; + } else { + long o = atktime.get(player); + long n = System.currentTimeMillis(); + long t = (n - o) / 50; + double T = 1 / player.getAttribute(Attribute.GENERIC_ATTACK_SPEED).getValue() * 20; + mult = 0.2 + ((t + 0.5) / T) * 0.8; + if (mult > 1) { + mult = 1; + } + } + return dmg * mult; + } + + public static NamespacedKey Potion_HP = new NamespacedKey(Main.getPlugin(), "NRPG_Potion_HP"); + public static NamespacedKey Potion_MP = new NamespacedKey(Main.getPlugin(), "NRPG_Potion_MP"); + + public static int getPotionMP(ItemStack item) { + int range = 0; + if (item == null || item.getType() == Material.AIR) { + return range; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(Potion_MP, PersistentDataType.INTEGER)) { + range += pdc.get(Potion_MP, PersistentDataType.INTEGER); + } + return range; + } + + public static double getPotionHP(ItemStack item) { + int range = 0; + if (item == null || item.getType() == Material.AIR) { + return range; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(Potion_HP, PersistentDataType.INTEGER)) { + range += pdc.get(Potion_HP, PersistentDataType.INTEGER); + } + return range; + } + + public static void setPotionHP(ItemStack item, int amount) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(Potion_HP, PersistentDataType.INTEGER, amount); + item.setItemMeta(im); + } + + public static void setPotionMP(ItemStack item, int amount) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(Potion_MP, PersistentDataType.INTEGER, amount); + item.setItemMeta(im); + } + + public static NamespacedKey SkillBook_key = new NamespacedKey(Main.getPlugin(), "NRPG_SkillBook_Skillname"); + + public static String getSkillBookSkill(ItemStack item) { + if (item == null || item.getType() == Material.AIR) { + return null; + } + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + if (pdc.has(SkillBook_key, PersistentDataType.STRING)) { + return pdc.get(SkillBook_key, PersistentDataType.STRING); + } + return null; + } + + public static void setSkillBookSkill(ItemStack item, String amount) { + ItemMeta im = item.getItemMeta(); + PersistentDataContainer pdc = im.getPersistentDataContainer(); + pdc.set(SkillBook_key, PersistentDataType.STRING, amount); + item.setItemMeta(im); + } +} diff --git a/src/main/java/nashi/NRPG/listeners/MythicMobsListener.java b/src/main/java/nashi/NRPG/listeners/MythicMobsListener.java new file mode 100644 index 0000000..bde2e6c --- /dev/null +++ b/src/main/java/nashi/NRPG/listeners/MythicMobsListener.java @@ -0,0 +1,112 @@ +package nashi.NRPG.listeners; + +import java.util.HashMap; +import java.util.UUID; + +import org.bukkit.Bukkit; +import org.bukkit.OfflinePlayer; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.EntityDamageByEntityEvent; +import org.bukkit.event.entity.EntityDamageEvent; +import io.lumine.xikage.mythicmobs.MythicMobs; +import io.lumine.xikage.mythicmobs.api.bukkit.events.MythicMobDeathEvent; +import io.lumine.xikage.mythicmobs.mobs.ActiveMob; +import io.lumine.xikage.mythicmobs.mobs.MobManager; +import nashi.NRPG.Players.Leveling; + +public class MythicMobsListener implements Listener { + public static HashMap> MobsKilled = new HashMap>(); + public static HashMap> DamageDelt = new HashMap>(); + public static MythicMobs mythicMobs = MythicMobs.inst(); + public static MobManager mobManager = mythicMobs.getMobManager(); + public static final String total = "total"; + public static final double amount = 0.3; + + @EventHandler + public void MyThicMobsDie(MythicMobDeathEvent event) { + String type = event.getMobType().getInternalName(); + HashMap map = DamageDelt.get(event.getMob()); + double delt = map.get(total); + for (String str : map.keySet()) { + if (str.equals(total)) { + continue; + } + if (map.get(str) / delt < amount) { + continue; + } + OfflinePlayer offp = Bukkit.getServer().getOfflinePlayer(UUID.fromString(str)); + if (offp.isOnline()) { + Player player = offp.getPlayer(); + HashMap mk; + if (MobsKilled.containsKey(player)) { + mk = MobsKilled.get(player); + } else { + mk = new HashMap(); + } + int n; + if (mk.containsKey(type)) { + n = mk.get(type); + } else { + n = 0; + } + mk.put(type, n + 1); + MobsKilled.put(player, mk); + Leveling.check(player); + } + + } + } + + @EventHandler(priority = EventPriority.MONITOR) + public void DmgDeltCalc(EntityDamageEvent event) { + ActiveMob mob = mobManager.getMythicMobInstance(event.getEntity()); + if (mob == null) { + return; + } + HashMap map; + if (!DamageDelt.containsKey(mob)) { + map = new HashMap(); + } else { + map = DamageDelt.get(mob); + } + double damage = event.getDamage(); + double c; + if (map.containsKey(total)) { + c = map.get(total); + } else { + c = 0; + } + map.put(total, c + damage); + DamageDelt.put(mob, map); + } + + @EventHandler(priority = EventPriority.MONITOR) + public void DmgDeltCalc(EntityDamageByEntityEvent event) { + ActiveMob mob = mobManager.getMythicMobInstance(event.getEntity()); + if (mob == null) { + return; + } + HashMap map; + if (!DamageDelt.containsKey(mob)) { + map = new HashMap(); + } else { + map = DamageDelt.get(mob); + } + double damage = event.getDamage(); + if (event.getDamager() instanceof Player) { + Player player = (Player) event.getDamager(); + double c; + if (map.containsKey(player.getUniqueId().toString())) { + c = map.get(player.getUniqueId().toString()); + } else { + c = 0; + } + map.put(player.getUniqueId().toString(), c + damage); + } + DamageDelt.put(mob, map); + } + +} diff --git a/src/main/java/nashi/NRPG/listeners/ProtocolLibEvent.java b/src/main/java/nashi/NRPG/listeners/ProtocolLibEvent.java new file mode 100644 index 0000000..7250350 --- /dev/null +++ b/src/main/java/nashi/NRPG/listeners/ProtocolLibEvent.java @@ -0,0 +1,41 @@ +package nashi.NRPG.listeners; + +import java.util.HashSet; +import java.util.LinkedHashSet; + +import org.bukkit.Sound; + +import com.comphenix.protocol.PacketType; +import com.comphenix.protocol.ProtocolLibrary; +import com.comphenix.protocol.events.ListenerPriority; +import com.comphenix.protocol.events.PacketAdapter; +import com.comphenix.protocol.events.PacketEvent; + +import nashi.NRPG.API.SkillAPI; + +public class ProtocolLibEvent { + public static HashSet sounds = new LinkedHashSet(500); + + public static void run() { + ProtocolLibrary.getProtocolManager().addPacketListener(new PacketAdapter(SkillAPI.plugin(), + ListenerPriority.NORMAL, PacketType.Play.Server.NAMED_SOUND_EFFECT) { + @Override + public void onPacketSending(PacketEvent event) { + if (event.getPacketType() == PacketType.Play.Server.NAMED_SOUND_EFFECT) { + Sound sound = event.getPacket().getSoundEffects().read(0); + if (!sound.name().contains("ENTITY_PLAYER_ATTACK")) { + return; + } + if (sounds.contains(sound)) { + return; + } + event.setCancelled(true); + } + } + }); + } + + public static void setWhitelist(Sound sound) { + ProtocolLibEvent.sounds.add(sound); + } +} diff --git a/src/main/java/nashi/NRPG/listeners/SkillItemListener.java b/src/main/java/nashi/NRPG/listeners/SkillItemListener.java new file mode 100644 index 0000000..0034ec7 --- /dev/null +++ b/src/main/java/nashi/NRPG/listeners/SkillItemListener.java @@ -0,0 +1,141 @@ +package nashi.NRPG.listeners; + +import java.util.ArrayList; +import java.util.List; + +import org.bukkit.ChatColor; +import org.bukkit.World; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.Action; +import org.bukkit.event.player.PlayerInteractEvent; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.Damageable; +import org.bukkit.inventory.meta.ItemMeta; + +import nashi.NRPG.Main; +import nashi.NRPG.API.SkillAPI; +import nashi.NRPG.Players.Players; +import nashi.NRPG.Skills.Cast; +import nashi.NRPG.Skills.Skill; +import nashi.NRPG.Skills.SkillItem; +import nashi.NRPG.listeners.EventListener.Casting; + +public class SkillItemListener implements Listener { + + @EventHandler + public void use(PlayerInteractEvent event) { + Player player = event.getPlayer(); + if (EventListener.cast.containsKey(player)) { + return; + } + if (event.getAction() != Action.RIGHT_CLICK_AIR && event.getAction() != Action.RIGHT_CLICK_BLOCK) { + return; + } + long cooldowntime = 100L; + if (EventListener.scooldowns.containsKey(player.getUniqueId()) + && System.currentTimeMillis() - EventListener.scooldowns.get(player.getUniqueId()) <= cooldowntime) { + return; + } + try { + ItemStack item = player.getInventory().getItemInMainHand(); + int limit = SkillItem.getSkillLimitTimeUse(item); + if (limit == 0) { + return; + } + EventListener.scooldowns.put(player.getUniqueId(), System.currentTimeMillis()); + String sk = SkillItem.getSkill(item); + if (sk == null) { + return; + } + event.setCancelled(true); + World world = player.getWorld(); + try { + if (Main.worlds.contains(world)) { + player.sendMessage(ChatColor.RED + "你無法在這個世界使用技能"); + return; + } + } catch (Exception e) { + } + if (SkillAPI.Silence.containsKey(player.getUniqueId())) { + double secondsLeft = SkillAPI.Silence.get(player.getUniqueId()) - System.currentTimeMillis(); + if (secondsLeft > 0) { + player.sendMessage(ChatColor.RED + "你已被沉默 " + Skill.formatter.format((secondsLeft / 1000)) + " 秒"); + return; + } + } + if (Skill.cooldowns.containsKey(player.getUniqueId() + "." + sk)) { + double secondsLeft = Skill.cooldowns.get(player.getUniqueId() + "." + sk) - System.currentTimeMillis(); + if (secondsLeft > 0) { + player.sendMessage( + ChatColor.RED + "技能冷卻時間剩餘:" + Skill.formatter.format((secondsLeft / 1000)) + " 秒"); + return; + } + } + double cost = SkillAPI.getPublicSkillInfo(sk, "CostMP"); + Players.PlayerData pd = Players.Data.get(player); + if (pd.getCurrentMP() - cost < 0.0) { + player.sendMessage(ChatColor.RED + "魔力不足"); + return; + } + int difficulty = SkillItem.getSkillDifficulty(item); + if (difficulty == -1) { + difficulty = (int) SkillAPI.getPublicSkillInfo(sk, "Difficulty"); + } + int req = SkillItem.getSkillTime(item); + if (req != -1) { + if (req == 0) { + Skill.cast(sk, player, true); + } else { + long time = SkillAPI.getRemainingCooldown(player, sk); + if (time > 0L) { + player.sendMessage(ChatColor.RED + "技能冷卻時間剩餘:" + Skill.formatter.format((time / 1000)) + " 秒"); + return; + } + Cast.Abracadabra abra = Cast.getabracadabra((difficulty)); + EventListener.playercast(player, new Casting(sk, abra, req), (Cast.castspeed.get(player)), + Cast.timelimit); + } + } else { + if (SkillAPI.getPublicSkillInfo(sk, "Times") < 1.0) { + Skill.cast(sk, player, true); + } else { + long time = SkillAPI.getRemainingCooldown(player, sk); + if (time > 0L) { + player.sendMessage(ChatColor.RED + "技能冷卻時間剩餘:" + Skill.formatter.format((time / 1000)) + " 秒"); + return; + } + Cast.Abracadabra abra = Cast.getabracadabra((difficulty)); + EventListener.playercast(player, + new Casting(sk, abra, (int) SkillAPI.getPublicSkillInfo(sk, "Times")), + (Cast.castspeed.get(player)), Cast.timelimit); + } + } + SkillItem.setSkillLimitTimeUse(item, limit - 1); + if (limit - 1 == 0) { + ItemMeta im = item.getItemMeta(); + List lore; + if (im.hasLore()) { + lore = im.getLore(); + } else { + lore = new ArrayList(); + } + lore.add(ChatColor.RED + "技能次數已耗盡"); + im.setLore(lore); + item.setItemMeta(im); + } + int damage = SkillItem.getUseDamage(item); + if (damage > 0) { + Damageable dmg = ((Damageable) item.getItemMeta()); + dmg.setDamage(dmg.getDamage() + damage); + item.setItemMeta((ItemMeta) dmg); + if (item.getType().getMaxDurability() < dmg.getDamage()) { + item.setAmount(0); + } + } + } catch (NullPointerException sk) { + // empty catch block + } + } +} diff --git a/target/classes/.gitignore b/target/classes/.gitignore new file mode 100644 index 0000000..4ed4006 --- /dev/null +++ b/target/classes/.gitignore @@ -0,0 +1,2 @@ +/edited/ +/nashi/ diff --git a/target/test-classes/nashi/NRPG/AppTest.class b/target/test-classes/nashi/NRPG/AppTest.class new file mode 100644 index 0000000000000000000000000000000000000000..60a5313deb74ace6199393034e1a5ff3f4278728 GIT binary patch literal 1290 zcmb_cO>Yx15PeSDBwYe6rG)|ojKm?~kX(?E2tq;?AC*EuBvj()>^hCZt{rS|QGOW` zNO0#rff#2KMLnm-gGwF#;cxrhz`es4EW1+S2yf672q{$CF zSB@*4C`%_yCzKjUD|Ji^18Xvh-{zD{cr#9gb9|su>6WtWPxJqqWT>PSHXcs68E`-E zZKiW^_Sk5roR``c=laKz->SpC;bN*~fg5kqkzbyADV=dkka~|&1JoBOe%$LgjRB$$br&9dZPHb*(gF4XKPqPne5S_eTRA0 zm$oNp_GH73iA8!OtP1h$&s9HEj$ym=t4G@mYc6!auv>3*MmagNHLxO+?~HxZ3Jtca z*kMTiY`VGUPNxn-#SYCif@-Z2kp*C|?Gu$4!rw4lB zuBUS=R&f1?>s>gAik}r@@6q*hxCv^7z7wF8v__fM3PpD)F3~&si0bRD=sjwmDJtO{ ztzi%7*`T#H{T*Qw=P6pp7B0*XZqINFgzY5=dsBqK!f+9nW_5u%;1_kfOX_YdVP3%% Tswv?r_UH}Vpr=gn3a)(zR#0$E literal 0 HcmV?d00001