CombatUtils.java 43 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095
  1. package com.gmail.nossr50.util.skills;
  2. import com.gmail.nossr50.config.experience.ExperienceConfig;
  3. import com.gmail.nossr50.datatypes.experience.XPGainReason;
  4. import com.gmail.nossr50.datatypes.interactions.NotificationType;
  5. import com.gmail.nossr50.datatypes.meta.OldName;
  6. import com.gmail.nossr50.datatypes.player.McMMOPlayer;
  7. import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
  8. import com.gmail.nossr50.datatypes.skills.SubSkillType;
  9. import com.gmail.nossr50.events.fake.FakeEntityDamageByEntityEvent;
  10. import com.gmail.nossr50.events.fake.FakeEntityDamageEvent;
  11. import com.gmail.nossr50.mcMMO;
  12. import com.gmail.nossr50.party.PartyManager;
  13. import com.gmail.nossr50.runnables.skills.AwardCombatXpTask;
  14. import com.gmail.nossr50.skills.acrobatics.AcrobaticsManager;
  15. import com.gmail.nossr50.skills.archery.ArcheryManager;
  16. import com.gmail.nossr50.skills.axes.AxesManager;
  17. import com.gmail.nossr50.skills.swords.SwordsManager;
  18. import com.gmail.nossr50.skills.taming.TamingManager;
  19. import com.gmail.nossr50.skills.unarmed.UnarmedManager;
  20. import com.gmail.nossr50.util.*;
  21. import com.gmail.nossr50.util.compat.layers.persistentdata.AbstractPersistentDataLayer;
  22. import com.gmail.nossr50.util.compat.layers.persistentdata.MobMetaFlagType;
  23. import com.gmail.nossr50.util.player.NotificationManager;
  24. import com.gmail.nossr50.util.player.UserManager;
  25. import com.google.common.collect.ImmutableMap;
  26. import org.bukkit.Bukkit;
  27. import org.bukkit.GameMode;
  28. import org.bukkit.Material;
  29. import org.bukkit.attribute.Attribute;
  30. import org.bukkit.attribute.AttributeInstance;
  31. import org.bukkit.entity.*;
  32. import org.bukkit.event.entity.EntityDamageByEntityEvent;
  33. import org.bukkit.event.entity.EntityDamageEvent;
  34. import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
  35. import org.bukkit.event.entity.EntityDamageEvent.DamageModifier;
  36. import org.bukkit.inventory.ItemStack;
  37. import org.bukkit.metadata.MetadataValue;
  38. import org.bukkit.potion.PotionEffectType;
  39. import org.bukkit.projectiles.ProjectileSource;
  40. import org.jetbrains.annotations.NotNull;
  41. import org.jetbrains.annotations.Nullable;
  42. import java.util.EnumMap;
  43. import java.util.HashMap;
  44. import java.util.List;
  45. import java.util.Map;
  46. public final class CombatUtils {
  47. private CombatUtils() {}
  48. private static @NotNull AbstractPersistentDataLayer getPersistentData() {
  49. return mcMMO.getCompatibilityManager().getPersistentDataLayer();
  50. }
  51. //Likely.. because who knows what plugins are throwing around
  52. public static boolean isDamageLikelyFromNormalCombat(@NotNull DamageCause damageCause) {
  53. switch (damageCause) {
  54. case ENTITY_ATTACK:
  55. case ENTITY_SWEEP_ATTACK:
  56. case PROJECTILE:
  57. return true;
  58. default:
  59. return false;
  60. }
  61. }
  62. public static boolean hasWeakenedDamage(@NotNull LivingEntity livingEntity) {
  63. return livingEntity.hasPotionEffect(PotionEffectType.WEAKNESS);
  64. }
  65. private static void processSwordCombat(@NotNull LivingEntity target, @NotNull Player player, @NotNull EntityDamageByEntityEvent event) {
  66. if (event.getCause() == DamageCause.THORNS) {
  67. return;
  68. }
  69. McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
  70. //Make sure the profiles been loaded
  71. if(mcMMOPlayer == null) {
  72. return;
  73. }
  74. SwordsManager swordsManager = mcMMOPlayer.getSwordsManager();
  75. double initialDamage = event.getDamage();
  76. double finalDamage = initialDamage;
  77. Map<DamageModifier, Double> modifiers = getModifiers(event);
  78. if (swordsManager.canActivateAbility()) {
  79. mcMMOPlayer.checkAbilityActivation(PrimarySkillType.SWORDS);
  80. }
  81. if(target.getHealth() - event.getFinalDamage() > 0) {
  82. if (swordsManager.canUseRupture()) {
  83. swordsManager.processRupture(target);
  84. }
  85. }
  86. //Add Stab Damage
  87. if(swordsManager.canUseStab())
  88. {
  89. finalDamage+=(swordsManager.getStabDamage() * mcMMOPlayer.getAttackStrength());
  90. }
  91. if (swordsManager.canUseSerratedStrike()) {
  92. swordsManager.serratedStrikes(target, initialDamage, modifiers);
  93. }
  94. if(canUseLimitBreak(player, target, SubSkillType.SWORDS_SWORDS_LIMIT_BREAK))
  95. {
  96. finalDamage+=(getLimitBreakDamage(player, target, SubSkillType.SWORDS_SWORDS_LIMIT_BREAK) * mcMMOPlayer.getAttackStrength());
  97. }
  98. applyScaledModifiers(initialDamage, finalDamage, event);
  99. processCombatXP(mcMMOPlayer, target, PrimarySkillType.SWORDS);
  100. printFinalDamageDebug(player, event, mcMMOPlayer);
  101. }
  102. private static void printFinalDamageDebug(@NotNull Player player, @NotNull EntityDamageByEntityEvent event, @NotNull McMMOPlayer mcMMOPlayer, @Nullable String @Nullable ... extraInfoLines) {
  103. if(mcMMOPlayer.isDebugMode()) {
  104. player.sendMessage("Final Damage value after mcMMO modifiers: "+ event.getFinalDamage());
  105. if(extraInfoLines != null) {
  106. for(String str : extraInfoLines) {
  107. if(str != null)
  108. player.sendMessage(str);
  109. }
  110. }
  111. }
  112. }
  113. private static void processAxeCombat(@NotNull LivingEntity target, @NotNull Player player, @NotNull EntityDamageByEntityEvent event) {
  114. if (event.getCause() == DamageCause.THORNS) {
  115. return;
  116. }
  117. double initialDamage = event.getDamage();
  118. double finalDamage = initialDamage;
  119. Map<DamageModifier, Double> modifiers = getModifiers(event);
  120. McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
  121. //Make sure the profiles been loaded
  122. if(mcMMOPlayer == null) {
  123. return;
  124. }
  125. AxesManager axesManager = mcMMOPlayer.getAxesManager();
  126. if (axesManager.canActivateAbility()) {
  127. mcMMOPlayer.checkAbilityActivation(PrimarySkillType.AXES);
  128. }
  129. if (axesManager.canUseAxeMastery()) {
  130. finalDamage+=axesManager.axeMastery();
  131. }
  132. if (axesManager.canImpact(target)) {
  133. axesManager.impactCheck(target);
  134. }
  135. else if (axesManager.canGreaterImpact(target)) {
  136. finalDamage+=axesManager.greaterImpact(target);
  137. }
  138. if (axesManager.canUseSkullSplitter(target)) {
  139. axesManager.skullSplitterCheck(target, initialDamage, modifiers);
  140. }
  141. if (axesManager.canCriticalHit(target)) {
  142. finalDamage+=(axesManager.criticalHit(target, finalDamage) * mcMMOPlayer.getAttackStrength());
  143. }
  144. if(canUseLimitBreak(player, target, SubSkillType.AXES_AXES_LIMIT_BREAK))
  145. {
  146. finalDamage+=(getLimitBreakDamage(player, target, SubSkillType.AXES_AXES_LIMIT_BREAK) * mcMMOPlayer.getAttackStrength());
  147. }
  148. applyScaledModifiers(initialDamage, finalDamage, event);
  149. processCombatXP(mcMMOPlayer, target, PrimarySkillType.AXES);
  150. printFinalDamageDebug(player, event, mcMMOPlayer);
  151. }
  152. private static void processUnarmedCombat(@NotNull LivingEntity target, @NotNull Player player, @NotNull EntityDamageByEntityEvent event) {
  153. if (event.getCause() == DamageCause.THORNS) {
  154. return;
  155. }
  156. double initialDamage = event.getDamage();
  157. double finalDamage = initialDamage;
  158. McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
  159. //Make sure the profiles been loaded
  160. if(mcMMOPlayer == null) {
  161. return;
  162. }
  163. UnarmedManager unarmedManager = mcMMOPlayer.getUnarmedManager();
  164. if (unarmedManager.canActivateAbility()) {
  165. mcMMOPlayer.checkAbilityActivation(PrimarySkillType.UNARMED);
  166. }
  167. if (unarmedManager.canUseSteelArm()) {
  168. finalDamage+=(unarmedManager.calculateSteelArmStyleDamage() * mcMMOPlayer.getAttackStrength());
  169. }
  170. if (unarmedManager.canUseBerserk()) {
  171. finalDamage+=(unarmedManager.berserkDamage(finalDamage) * mcMMOPlayer.getAttackStrength());
  172. }
  173. if (unarmedManager.canDisarm(target)) {
  174. unarmedManager.disarmCheck((Player) target);
  175. }
  176. if(canUseLimitBreak(player, target, SubSkillType.UNARMED_UNARMED_LIMIT_BREAK))
  177. {
  178. finalDamage+=(getLimitBreakDamage(player, target, SubSkillType.UNARMED_UNARMED_LIMIT_BREAK) * mcMMOPlayer.getAttackStrength());
  179. }
  180. applyScaledModifiers(initialDamage, finalDamage, event);
  181. processCombatXP(mcMMOPlayer, target, PrimarySkillType.UNARMED);
  182. printFinalDamageDebug(player, event, mcMMOPlayer);
  183. }
  184. private static void processTamingCombat(@NotNull LivingEntity target, @Nullable Player master, @NotNull Wolf wolf, @NotNull EntityDamageByEntityEvent event) {
  185. double initialDamage = event.getDamage();
  186. double finalDamage = initialDamage;
  187. if(master != null && master.isOnline() && master.isValid()) {
  188. McMMOPlayer mcMMOPlayer = UserManager.getPlayer(master);
  189. //Make sure the profiles been loaded
  190. if(mcMMOPlayer == null) {
  191. return;
  192. }
  193. TamingManager tamingManager = mcMMOPlayer.getTamingManager();
  194. if (tamingManager.canUseFastFoodService()) {
  195. tamingManager.fastFoodService(wolf, event.getDamage());
  196. }
  197. tamingManager.pummel(target, wolf);
  198. if (tamingManager.canUseSharpenedClaws()) {
  199. finalDamage+=tamingManager.sharpenedClaws();
  200. }
  201. if (tamingManager.canUseGore()) {
  202. finalDamage+=tamingManager.gore(target, initialDamage);
  203. }
  204. applyScaledModifiers(initialDamage, finalDamage, event);
  205. processCombatXP(mcMMOPlayer, target, PrimarySkillType.TAMING, 3);
  206. }
  207. }
  208. private static void processArcheryCombat(@NotNull LivingEntity target, @NotNull Player player, @NotNull EntityDamageByEntityEvent event, @NotNull Projectile arrow) {
  209. double initialDamage = event.getDamage();
  210. McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
  211. //Make sure the profiles been loaded
  212. if(mcMMOPlayer == null) {
  213. cleanupArrowMetadata(arrow);
  214. return;
  215. }
  216. ArcheryManager archeryManager = mcMMOPlayer.getArcheryManager();
  217. double finalDamage = event.getDamage();
  218. if (archeryManager.canSkillShot()) {
  219. //Not Additive
  220. finalDamage = archeryManager.skillShot(initialDamage);
  221. }
  222. if (archeryManager.canDaze(target)) {
  223. finalDamage+=archeryManager.daze((Player) target); //the cast is checked by the if condition
  224. }
  225. if (!arrow.hasMetadata(mcMMO.infiniteArrowKey) && archeryManager.canRetrieveArrows()) {
  226. archeryManager.retrieveArrows(target, arrow);
  227. }
  228. if(canUseLimitBreak(player, target, SubSkillType.ARCHERY_ARCHERY_LIMIT_BREAK))
  229. {
  230. finalDamage+=getLimitBreakDamage(player, target, SubSkillType.ARCHERY_ARCHERY_LIMIT_BREAK);
  231. }
  232. double distanceMultiplier = archeryManager.distanceXpBonusMultiplier(target, arrow);
  233. double forceMultiplier = 1.0; //Hacky Fix - some plugins spawn arrows and assign them to players after the ProjectileLaunchEvent fires
  234. if(arrow.hasMetadata(mcMMO.bowForceKey))
  235. forceMultiplier = arrow.getMetadata(mcMMO.bowForceKey).get(0).asDouble();
  236. applyScaledModifiers(initialDamage, finalDamage, event);
  237. processCombatXP(mcMMOPlayer, target, PrimarySkillType.ARCHERY, forceMultiplier * distanceMultiplier);
  238. printFinalDamageDebug(player, event, mcMMOPlayer,
  239. "Distance Multiplier: "+distanceMultiplier,
  240. "Force Multiplier: "+forceMultiplier,
  241. "Initial Damage: "+initialDamage,
  242. "Final Damage: "+finalDamage);
  243. //Clean data
  244. cleanupArrowMetadata(arrow);
  245. }
  246. /**
  247. * Apply combat modifiers and process and XP gain.
  248. *
  249. * @param event The event to run the combat checks on.
  250. */
  251. public static void processCombatAttack(@NotNull EntityDamageByEntityEvent event, @NotNull Entity painSourceRoot, @NotNull LivingEntity target) {
  252. Entity painSource = event.getDamager();
  253. EntityType entityType = painSource.getType();
  254. if (target instanceof Player) {
  255. if(ExperienceConfig.getInstance().isNPCInteractionPrevented()) {
  256. if (Misc.isNPCEntityExcludingVillagers(target)) {
  257. return;
  258. }
  259. }
  260. Player player = (Player) target;
  261. if (!UserManager.hasPlayerDataKey(player)) {
  262. return;
  263. }
  264. McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
  265. AcrobaticsManager acrobaticsManager = mcMMOPlayer.getAcrobaticsManager();
  266. if (acrobaticsManager.canDodge(target)) {
  267. event.setDamage(acrobaticsManager.dodgeCheck(painSourceRoot, event.getDamage()));
  268. }
  269. if (ItemUtils.isSword(player.getInventory().getItemInMainHand())) {
  270. if (!mcMMO.p.getSkillTools().canCombatSkillsTrigger(PrimarySkillType.SWORDS, target)) {
  271. return;
  272. }
  273. SwordsManager swordsManager = mcMMOPlayer.getSwordsManager();
  274. if (swordsManager.canUseCounterAttack(painSource)) {
  275. swordsManager.counterAttackChecks((LivingEntity) painSource, event.getDamage());
  276. }
  277. }
  278. }
  279. if (painSourceRoot instanceof Player && entityType == EntityType.PLAYER) {
  280. Player player = (Player) painSourceRoot;
  281. if (!UserManager.hasPlayerDataKey(player)) {
  282. return;
  283. }
  284. ItemStack heldItem = player.getInventory().getItemInMainHand();
  285. if (target instanceof Tameable) {
  286. if (heldItem.getType() == Material.BONE) {
  287. TamingManager tamingManager = UserManager.getPlayer(player).getTamingManager();
  288. if (tamingManager.canUseBeastLore()) {
  289. tamingManager.beastLore(target);
  290. event.setCancelled(true);
  291. return;
  292. }
  293. }
  294. if (isFriendlyPet(player, (Tameable) target)) {
  295. return;
  296. }
  297. }
  298. if (ItemUtils.isSword(heldItem)) {
  299. if (!mcMMO.p.getSkillTools().canCombatSkillsTrigger(PrimarySkillType.SWORDS, target)) {
  300. return;
  301. }
  302. if (Permissions.skillEnabled(player, PrimarySkillType.SWORDS)) {
  303. processSwordCombat(target, player, event);
  304. }
  305. }
  306. else if (ItemUtils.isAxe(heldItem)) {
  307. if (!mcMMO.p.getSkillTools().canCombatSkillsTrigger(PrimarySkillType.AXES, target)) {
  308. return;
  309. }
  310. if (Permissions.skillEnabled(player, PrimarySkillType.AXES)) {
  311. processAxeCombat(target, player, event);
  312. }
  313. }
  314. else if (ItemUtils.isUnarmed(heldItem)) {
  315. if (!mcMMO.p.getSkillTools().canCombatSkillsTrigger(PrimarySkillType.UNARMED, target)) {
  316. return;
  317. }
  318. if (Permissions.skillEnabled(player, PrimarySkillType.UNARMED)) {
  319. processUnarmedCombat(target, player, event);
  320. }
  321. }
  322. }
  323. else if (entityType == EntityType.WOLF) {
  324. Wolf wolf = (Wolf) painSource;
  325. AnimalTamer tamer = wolf.getOwner();
  326. if (tamer instanceof Player && mcMMO.p.getSkillTools().canCombatSkillsTrigger(PrimarySkillType.TAMING, target)) {
  327. Player master = (Player) tamer;
  328. if (!Misc.isNPCEntityExcludingVillagers(master) && Permissions.skillEnabled(master, PrimarySkillType.TAMING)) {
  329. processTamingCombat(target, master, wolf, event);
  330. }
  331. }
  332. }
  333. else if (entityType == EntityType.ARROW || entityType == EntityType.SPECTRAL_ARROW) {
  334. Projectile arrow = (Projectile) painSource;
  335. ProjectileSource projectileSource = arrow.getShooter();
  336. if (projectileSource instanceof Player && mcMMO.p.getSkillTools().canCombatSkillsTrigger(PrimarySkillType.ARCHERY, target)) {
  337. Player player = (Player) projectileSource;
  338. if (!Misc.isNPCEntityExcludingVillagers(player) && Permissions.skillEnabled(player, PrimarySkillType.ARCHERY)) {
  339. processArcheryCombat(target, player, event, arrow);
  340. } else {
  341. //Cleanup Arrow
  342. cleanupArrowMetadata(arrow);
  343. }
  344. if (target.getType() != EntityType.CREEPER && !Misc.isNPCEntityExcludingVillagers(player) && Permissions.skillEnabled(player, PrimarySkillType.TAMING)) {
  345. McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
  346. if(mcMMOPlayer == null)
  347. return;
  348. TamingManager tamingManager = mcMMOPlayer.getTamingManager();
  349. tamingManager.attackTarget(target);
  350. }
  351. }
  352. }
  353. }
  354. /**
  355. * This cleans up names from displaying in chat as hearts
  356. * @param entity target entity
  357. */
  358. public static void fixNames(@NotNull LivingEntity entity)
  359. {
  360. List<MetadataValue> metadataValue = entity.getMetadata(TransientMetadataTools.OLD_NAME_METAKEY);
  361. if(metadataValue.size() <= 0)
  362. return;
  363. OldName oldName = (OldName) metadataValue.get(0);
  364. entity.setCustomName(oldName.asString());
  365. entity.setCustomNameVisible(false);
  366. }
  367. /**
  368. * Calculate and return the RAW damage bonus from Limit Break before reductions
  369. * @param attacker attacking player
  370. * @param defender defending living entity
  371. * @param subSkillType the specific limit break skill for calculations
  372. * @return the RAW damage bonus from Limit Break which is applied before reductions
  373. */
  374. public static int getLimitBreakDamage(@NotNull Player attacker, @NotNull LivingEntity defender, @NotNull SubSkillType subSkillType) {
  375. if(defender instanceof Player) {
  376. Player playerDefender = (Player) defender;
  377. return getLimitBreakDamageAgainstQuality(attacker, subSkillType, getArmorQualityLevel(playerDefender));
  378. } else {
  379. return getLimitBreakDamageAgainstQuality(attacker, subSkillType, 1000);
  380. }
  381. }
  382. /**
  383. * Calculate the RAW daamge value of limit break based on the armor quality of the target
  384. * PVE mobs are passed in with a value of 1000 for armor quality, hacky... I'll change it later
  385. * @param attacker Living entity attacker
  386. * @param subSkillType Target limit break
  387. * @param armorQualityLevel Armor quality level
  388. * @return the RAW damage boost after its been mutated by armor quality
  389. */
  390. public static int getLimitBreakDamageAgainstQuality(@NotNull Player attacker, @NotNull SubSkillType subSkillType, int armorQualityLevel) {
  391. int rawDamageBoost = RankUtils.getRank(attacker, subSkillType);
  392. if(armorQualityLevel <= 4) {
  393. rawDamageBoost *= .25; //75% Nerf
  394. } else if(armorQualityLevel <= 8) {
  395. rawDamageBoost *= .50; //50% Nerf
  396. } else if(armorQualityLevel <= 12) {
  397. rawDamageBoost *= .75; //25% Nerf
  398. }
  399. return rawDamageBoost;
  400. }
  401. /**
  402. * Get the quality level of the armor of a player used for Limit Break calculations
  403. * @param defender target defending player
  404. * @return the armor quality of the defending player
  405. */
  406. public static int getArmorQualityLevel(@NotNull Player defender) {
  407. int armorQualityLevel = 0;
  408. for(ItemStack itemStack : defender.getInventory().getArmorContents()) {
  409. if(itemStack != null) {
  410. armorQualityLevel += getArmorQuality(itemStack);
  411. }
  412. }
  413. return armorQualityLevel;
  414. }
  415. /**
  416. * Get the armor quality for a specific item used for Limit Break calculations
  417. * @param itemStack target item stack
  418. * @return the armor quality of a specific Item Stack
  419. */
  420. private static int getArmorQuality(@NotNull ItemStack itemStack) {
  421. return mcMMO.getMaterialMapStore().getTier(itemStack.getType().getKey().getKey());
  422. }
  423. /**
  424. * Checks if player has access to their weapons limit break
  425. * @param player target entity
  426. * @return true if the player has access to the limit break
  427. */
  428. public static boolean canUseLimitBreak(@NotNull Player player, LivingEntity target, @NotNull SubSkillType subSkillType) {
  429. if(target instanceof Player || mcMMO.p.getAdvancedConfig().canApplyLimitBreakPVE()) {
  430. return RankUtils.hasUnlockedSubskill(player, subSkillType)
  431. && Permissions.isSubSkillEnabled(player, subSkillType);
  432. } else {
  433. return false;
  434. }
  435. }
  436. /**
  437. * Attempt to damage target for value dmg with reason CUSTOM
  438. *
  439. * @param target LivingEntity which to attempt to damage
  440. * @param damage Amount of damage to attempt to do
  441. */
  442. @Deprecated
  443. public static void dealDamage(@NotNull LivingEntity target, double damage) {
  444. dealDamage(target, damage, DamageCause.CUSTOM, null);
  445. }
  446. /**
  447. * Attempt to damage target for value dmg with reason ENTITY_ATTACK with damager attacker
  448. *
  449. * @param target LivingEntity which to attempt to damage
  450. * @param damage Amount of damage to attempt to do
  451. * @param attacker Player to pass to event as damager
  452. */
  453. @Deprecated
  454. public static void dealDamage(@NotNull LivingEntity target, double damage, @NotNull LivingEntity attacker) {
  455. dealDamage(target, damage, DamageCause.CUSTOM, attacker);
  456. }
  457. // /**
  458. // * Attempt to damage target for value dmg with reason ENTITY_ATTACK with damager attacker
  459. // *
  460. // * @param target LivingEntity which to attempt to damage
  461. // * @param damage Amount of damage to attempt to do
  462. // * @param attacker Player to pass to event as damager
  463. // */
  464. // public static void dealDamage(LivingEntity target, double damage, Map<DamageModifier, Double> modifiers, LivingEntity attacker) {
  465. // if (target.isDead()) {
  466. // return;
  467. // }
  468. //
  469. // // Aren't we applying the damage twice????
  470. // target.damage(getFakeDamageFinalResult(attacker, target, damage, modifiers));
  471. // }
  472. /**
  473. * Attempt to damage target for value dmg with reason ENTITY_ATTACK with damager attacker
  474. *
  475. * @param target LivingEntity which to attempt to damage
  476. * @param damage Amount of damage to attempt to do
  477. * @param attacker Player to pass to event as damager
  478. */
  479. @Deprecated
  480. public static void dealDamage(@NotNull LivingEntity target, double damage, @NotNull DamageCause cause, @Nullable Entity attacker) {
  481. if (target.isDead()) {
  482. return;
  483. }
  484. if(canDamage(attacker, target, cause, damage)) {
  485. applyIgnoreDamageMetadata(target);
  486. target.damage(damage);
  487. removeIgnoreDamageMetadata(target);
  488. }
  489. }
  490. private static boolean processingNoInvulnDamage;
  491. public static boolean isProcessingNoInvulnDamage() {
  492. return processingNoInvulnDamage;
  493. }
  494. public static void dealNoInvulnerabilityTickDamage(@NotNull LivingEntity target, double damage, @Nullable Entity attacker) {
  495. if (target.isDead()) {
  496. return;
  497. }
  498. // TODO: This is horrible, but there is no cleaner way to do this without potentially breaking existing code right now
  499. // calling damage here is a double edged sword: On one hand, without a call, plugins won't see this properly when the entity dies,
  500. // potentially mis-attributing the death cause; calling a fake event would partially fix this, but this and setting the last damage
  501. // cause do have issues around plugin observability. This is not a perfect solution, but it appears to be the best one here
  502. // We also set no damage ticks to 0, to ensure that damage is applied for this case, and reset it back to the original value
  503. // Snapshot current state so we can pop up properly
  504. boolean wasMetaSet = hasIgnoreDamageMetadata(target);
  505. boolean wasProcessing = processingNoInvulnDamage;
  506. // set markers
  507. processingNoInvulnDamage = true;
  508. applyIgnoreDamageMetadata(target);
  509. int noDamageTicks = target.getNoDamageTicks();
  510. target.setNoDamageTicks(0);
  511. target.damage(damage, attacker);
  512. target.setNoDamageTicks(noDamageTicks);
  513. if (!wasMetaSet)
  514. removeIgnoreDamageMetadata(target);
  515. if (!wasProcessing)
  516. processingNoInvulnDamage = false;
  517. }
  518. public static void removeIgnoreDamageMetadata(@NotNull LivingEntity target) {
  519. target.removeMetadata(mcMMO.CUSTOM_DAMAGE_METAKEY, mcMMO.p);
  520. }
  521. public static void applyIgnoreDamageMetadata(@NotNull LivingEntity target) {
  522. target.setMetadata(mcMMO.CUSTOM_DAMAGE_METAKEY, mcMMO.metadataValue);
  523. }
  524. public static boolean hasIgnoreDamageMetadata(@NotNull LivingEntity target) {
  525. return target.getMetadata(mcMMO.CUSTOM_DAMAGE_METAKEY).size() != 0;
  526. }
  527. public static void dealNoInvulnerabilityTickDamageRupture(@NotNull LivingEntity target, double damage, Entity attacker, int toolTier) {
  528. if (target.isDead()) {
  529. return;
  530. }
  531. dealNoInvulnerabilityTickDamage(target, damage, attacker);
  532. // //IFrame storage
  533. //// int noDamageTicks = target.getNoDamageTicks();
  534. //
  535. //// String debug = "BLEED DMG RESULT: INC DMG:"+damage+", HP-Before:"+target.getHealth()+", HP-After:";
  536. //
  537. //// double incDmg = getFakeDamageFinalResult(attacker, target, DamageCause.ENTITY_ATTACK, damage);
  538. //
  539. //// double newHealth = Math.max(0, target.getHealth() - incDmg);
  540. //
  541. // //Don't kill things with a stone or wooden weapon
  542. //// if(toolTier < 3 && newHealth == 0)
  543. //// return;
  544. //
  545. // target.setMetadata(mcMMO.CUSTOM_DAMAGE_METAKEY, mcMMO.metadataValue);
  546. //
  547. // if(newHealth == 0 && !(target instanceof Player))
  548. // {
  549. // target.damage(99999, attacker);
  550. // }
  551. // else
  552. // {
  553. //// Vector beforeRuptureVec = new Vector(target.getVelocity().getX(), target.getVelocity().getY(), target.getVelocity().getZ()); ;
  554. // target.damage(damage, attacker);
  555. //// debug+=target.getHealth();
  556. // Bukkit.broadcastMessage(debug);
  557. //// target.setNoDamageTicks(noDamageTicks); //Do not add additional IFrames
  558. //// target.setVelocity(beforeRuptureVec);
  559. // }
  560. }
  561. /**
  562. * Apply Area-of-Effect ability actions.
  563. *
  564. * @param attacker The attacking player
  565. * @param target The defending entity
  566. * @param damage The initial damage amount
  567. * @param type The type of skill being used
  568. */
  569. public static void applyAbilityAoE(@NotNull Player attacker, @NotNull LivingEntity target, double damage, Map<DamageModifier, Double> modifiers, @NotNull PrimarySkillType type) {
  570. int numberOfTargets = getTier(attacker.getInventory().getItemInMainHand()); // The higher the weapon tier, the more targets you hit
  571. double damageAmount = Math.max(damage, 1);
  572. for (Entity entity : target.getNearbyEntities(2.5, 2.5, 2.5)) {
  573. if (numberOfTargets <= 0) {
  574. break;
  575. }
  576. if ((ExperienceConfig.getInstance().isNPCInteractionPrevented() && Misc.isNPCEntityExcludingVillagers(entity)) || !(entity instanceof LivingEntity) || !shouldBeAffected(attacker, entity)) {
  577. continue;
  578. }
  579. LivingEntity livingEntity = (LivingEntity) entity;
  580. EventUtils.callFakeArmSwingEvent(attacker);
  581. switch (type) {
  582. case SWORDS:
  583. if (entity instanceof Player) {
  584. NotificationManager.sendPlayerInformation((Player)entity, NotificationType.SUBSKILL_MESSAGE, "Swords.Combat.SS.Struck");
  585. }
  586. UserManager.getPlayer(attacker).getSwordsManager().processRupture(target);
  587. break;
  588. case AXES:
  589. if (entity instanceof Player) {
  590. NotificationManager.sendPlayerInformation((Player)entity, NotificationType.SUBSKILL_MESSAGE, "Axes.Combat.SS.Struck");
  591. }
  592. break;
  593. default:
  594. break;
  595. }
  596. dealDamage(livingEntity, damageAmount, attacker);
  597. numberOfTargets--;
  598. }
  599. }
  600. /**
  601. * Start the task that gives combat XP.
  602. *
  603. * @param mcMMOPlayer The attacking player
  604. * @param target The defending entity
  605. * @param primarySkillType The skill being used
  606. */
  607. public static void processCombatXP(@NotNull McMMOPlayer mcMMOPlayer, LivingEntity target, PrimarySkillType primarySkillType) {
  608. processCombatXP(mcMMOPlayer, target, primarySkillType, 1.0);
  609. }
  610. /**
  611. * Start the task that gives combat XP.
  612. *
  613. * @param mcMMOPlayer The attacking player
  614. * @param target The defending entity
  615. * @param primarySkillType The skill being used
  616. * @param multiplier final XP result will be multiplied by this
  617. */
  618. public static void processCombatXP(@NotNull McMMOPlayer mcMMOPlayer, LivingEntity target, PrimarySkillType primarySkillType, double multiplier) {
  619. double baseXP = 0;
  620. XPGainReason xpGainReason;
  621. if (target instanceof Player) {
  622. if (!ExperienceConfig.getInstance().getExperienceGainsPlayerVersusPlayerEnabled() || PartyManager.inSameParty(mcMMOPlayer.getPlayer(), (Player) target)) {
  623. return;
  624. }
  625. xpGainReason = XPGainReason.PVP;
  626. Player defender = (Player) target;
  627. if (defender.isOnline() && SkillUtils.cooldownExpired(mcMMOPlayer.getRespawnATS(), Misc.PLAYER_RESPAWN_COOLDOWN_SECONDS)) {
  628. baseXP = 20 * ExperienceConfig.getInstance().getPlayerVersusPlayerXP();
  629. }
  630. }
  631. else {
  632. if (mcMMO.getModManager().isCustomEntity(target)) {
  633. baseXP = mcMMO.getModManager().getEntity(target).getXpMultiplier();
  634. }
  635. else if (target instanceof Animals) {
  636. EntityType type = target.getType();
  637. baseXP = ExperienceConfig.getInstance().getAnimalsXP(type);
  638. }
  639. else if (target instanceof Monster)
  640. {
  641. EntityType type = target.getType();
  642. baseXP = ExperienceConfig.getInstance().getCombatXP(type);
  643. }
  644. else {
  645. EntityType type = target.getType();
  646. if (ExperienceConfig.getInstance().hasCombatXP(type)) {
  647. if (type == EntityType.IRON_GOLEM)
  648. {
  649. if (!((IronGolem) target).isPlayerCreated()) {
  650. baseXP = ExperienceConfig.getInstance().getCombatXP(type);
  651. }
  652. }
  653. else
  654. {
  655. baseXP = ExperienceConfig.getInstance().getCombatXP(type);
  656. }
  657. }
  658. else
  659. {
  660. baseXP = 1.0;
  661. mcMMO.getModManager().addCustomEntity(target);
  662. }
  663. }
  664. if(getPersistentData().hasMobFlag(MobMetaFlagType.COTW_SUMMONED_MOB, target)) {
  665. baseXP = 0;
  666. } else if(getPersistentData().hasMobFlag(MobMetaFlagType.MOB_SPAWNER_MOB, target) || target.hasMetadata("ES")) {
  667. baseXP *= ExperienceConfig.getInstance().getSpawnedMobXpMultiplier();
  668. } else if(getPersistentData().hasMobFlag(MobMetaFlagType.NETHER_PORTAL_MOB, target)) {
  669. baseXP *= ExperienceConfig.getInstance().getNetherPortalXpMultiplier();
  670. } else if(getPersistentData().hasMobFlag(MobMetaFlagType.EGG_MOB, target)) {
  671. baseXP *= ExperienceConfig.getInstance().getEggXpMultiplier();
  672. } else if (getPersistentData().hasMobFlag(MobMetaFlagType.PLAYER_BRED_MOB, target)) {
  673. baseXP *= ExperienceConfig.getInstance().getBredMobXpMultiplier();
  674. } else if(getPersistentData().hasMobFlag(MobMetaFlagType.PLAYER_TAMED_MOB, target)) {
  675. baseXP *= ExperienceConfig.getInstance().getTamedMobXpMultiplier();
  676. }
  677. baseXP *= 10;
  678. xpGainReason = XPGainReason.PVE;
  679. }
  680. baseXP *= multiplier;
  681. if (baseXP != 0) {
  682. new AwardCombatXpTask(mcMMOPlayer, primarySkillType, baseXP, target, xpGainReason).runTaskLater(mcMMO.p, 0);
  683. }
  684. }
  685. /**
  686. * Check to see if the given LivingEntity should be affected by a combat ability.
  687. *
  688. * @param player The attacking Player
  689. * @param entity The defending Entity
  690. * @return true if the Entity should be damaged, false otherwise.
  691. */
  692. private static boolean shouldBeAffected(@NotNull Player player, @NotNull Entity entity) {
  693. if (entity instanceof Player) {
  694. Player defender = (Player) entity;
  695. //TODO: NPC Interaction?
  696. if(UserManager.getPlayer(defender) == null)
  697. return true;
  698. if (!defender.getWorld().getPVP() || defender == player || UserManager.getPlayer(defender).getGodMode()) {
  699. return false;
  700. }
  701. if ((PartyManager.inSameParty(player, defender) || PartyManager.areAllies(player, defender)) && !(Permissions.friendlyFire(player) && Permissions.friendlyFire(defender))) {
  702. return false;
  703. }
  704. // Vanished players should not be able to get hit by AoE effects
  705. if (!player.canSee(defender)) {
  706. return false;
  707. }
  708. // Spectators should not be affected
  709. if (defender.getGameMode() == GameMode.SPECTATOR) {
  710. return false;
  711. }
  712. // It may seem a bit redundant but we need a check here to prevent bleed from being applied in applyAbilityAoE()
  713. return getFakeDamageFinalResult(player, entity, 1.0) != 0;
  714. }
  715. else if (entity instanceof Tameable) {
  716. Tameable tameableEntity = (Tameable) entity;
  717. if (isFriendlyPet(player, tameableEntity)) {
  718. // isFriendlyPet ensures that the Tameable is: Tamed, owned by a player, and the owner is in the same party
  719. // So we can make some assumptions here, about our casting and our check
  720. Player owner = (Player) tameableEntity.getOwner();
  721. return Permissions.friendlyFire(player) && Permissions.friendlyFire(owner);
  722. }
  723. }
  724. return true;
  725. }
  726. /**
  727. * Checks to see if an entity is currently invincible.
  728. *
  729. * @param entity The {@link LivingEntity} to check
  730. * @param eventDamage The damage from the event the entity is involved in
  731. * @return true if the entity is invincible, false otherwise
  732. */
  733. public static boolean isInvincible(@NotNull LivingEntity entity, double eventDamage) {
  734. /*
  735. * So apparently if you do more damage to a LivingEntity than its last damage int you bypass the invincibility.
  736. * So yeah, this is for that.
  737. */
  738. return (entity.getNoDamageTicks() > entity.getMaximumNoDamageTicks() / 2.0F) && (eventDamage <= entity.getLastDamage());
  739. }
  740. /**
  741. * Checks to see if an entity is currently friendly toward a given player.
  742. *
  743. * @param attacker The player to check.
  744. * @param pet The entity to check.
  745. * @return true if the entity is friendly, false otherwise
  746. */
  747. public static boolean isFriendlyPet(@NotNull Player attacker, @NotNull Tameable pet) {
  748. if (pet.isTamed()) {
  749. AnimalTamer tamer = pet.getOwner();
  750. if (tamer instanceof Player) {
  751. Player owner = (Player) tamer;
  752. return (owner == attacker || PartyManager.inSameParty(attacker, owner) || PartyManager.areAllies(attacker, owner));
  753. }
  754. }
  755. return false;
  756. }
  757. @Deprecated
  758. public static double getFakeDamageFinalResult(@Nullable Entity attacker, @NotNull Entity target, double damage) {
  759. return getFakeDamageFinalResult(attacker, target, DamageCause.ENTITY_ATTACK, new EnumMap<>(ImmutableMap.of(DamageModifier.BASE, damage)));
  760. }
  761. @Deprecated
  762. public static double getFakeDamageFinalResult(@Nullable Entity attacker, @NotNull Entity target, @NotNull DamageCause damageCause, double damage) {
  763. EntityDamageEvent damageEvent = sendEntityDamageEvent(attacker, target, damageCause, damage);
  764. if (damageEvent.isCancelled()) {
  765. return 0;
  766. }
  767. return damageEvent.getFinalDamage();
  768. }
  769. public static boolean canDamage(@NotNull Entity attacker, @NotNull Entity target, @NotNull DamageCause damageCause, double damage) {
  770. EntityDamageEvent damageEvent = sendEntityDamageEvent(attacker, target, damageCause, damage);
  771. return !damageEvent.isCancelled();
  772. }
  773. public static @NotNull EntityDamageEvent sendEntityDamageEvent(@Nullable Entity attacker, @NotNull Entity target, @NotNull DamageCause damageCause, double damage) {
  774. EntityDamageEvent damageEvent = attacker == null ? new FakeEntityDamageEvent(target, damageCause, damage) : new FakeEntityDamageByEntityEvent(attacker, target, damageCause, damage);
  775. mcMMO.p.getServer().getPluginManager().callEvent(damageEvent);
  776. return damageEvent;
  777. }
  778. public static double getFakeDamageFinalResult(@Nullable Entity attacker, @NotNull Entity target, @NotNull Map<DamageModifier, Double> modifiers) {
  779. return getFakeDamageFinalResult(attacker, target, DamageCause.ENTITY_ATTACK, modifiers);
  780. }
  781. public static double getFakeDamageFinalResult(@Nullable Entity attacker, @NotNull Entity target, double damage, @NotNull Map<DamageModifier, Double> modifiers) {
  782. return getFakeDamageFinalResult(attacker, target, DamageCause.ENTITY_ATTACK, getScaledModifiers(damage, modifiers));
  783. }
  784. public static double getFakeDamageFinalResult(@Nullable Entity attacker, @NotNull Entity target, @NotNull DamageCause cause, @NotNull Map<DamageModifier, Double> modifiers) {
  785. EntityDamageEvent damageEvent = attacker == null ? new FakeEntityDamageEvent(target, cause, modifiers) : new FakeEntityDamageByEntityEvent(attacker, target, cause, modifiers);
  786. mcMMO.p.getServer().getPluginManager().callEvent(damageEvent);
  787. if (damageEvent.isCancelled()) {
  788. return 0;
  789. }
  790. return damageEvent.getFinalDamage();
  791. }
  792. private static @NotNull Map<DamageModifier, Double> getModifiers(@NotNull EntityDamageEvent event) {
  793. Map<DamageModifier, Double> modifiers = new HashMap<>();
  794. for (DamageModifier modifier : DamageModifier.values()) {
  795. modifiers.put(modifier, event.getDamage(modifier));
  796. }
  797. return modifiers;
  798. }
  799. private static @NotNull Map<DamageModifier, Double> getScaledModifiers(double damage, @NotNull Map<DamageModifier, Double> modifiers) {
  800. Map<DamageModifier, Double> scaledModifiers = new HashMap<>();
  801. for (DamageModifier modifier : modifiers.keySet()) {
  802. if (modifier == DamageModifier.BASE) {
  803. scaledModifiers.put(modifier, damage);
  804. continue;
  805. }
  806. scaledModifiers.put(modifier, damage * modifiers.get(modifier));
  807. }
  808. return scaledModifiers;
  809. }
  810. public static @NotNull EntityDamageByEntityEvent applyScaledModifiers(double initialDamage, double finalDamage, @NotNull EntityDamageByEntityEvent event) {
  811. // No additional damage
  812. if (initialDamage == finalDamage) {
  813. return event;
  814. }
  815. for (DamageModifier modifier : DamageModifier.values()) {
  816. if (!event.isApplicable(modifier)) {
  817. continue;
  818. }
  819. if (modifier == DamageModifier.BASE) {
  820. event.setDamage(modifier, finalDamage);
  821. continue;
  822. }
  823. event.setDamage(modifier, finalDamage / initialDamage * event.getDamage(modifier));
  824. }
  825. return event;
  826. }
  827. /**
  828. * Get the upgrade tier of the item in hand.
  829. *
  830. * @param inHand The item to check the tier of
  831. * @return the tier of the item
  832. */
  833. private static int getTier(@NotNull ItemStack inHand) {
  834. int tier = 0;
  835. if (ItemUtils.isWoodTool(inHand)) {
  836. tier = 1;
  837. }
  838. else if (ItemUtils.isStoneTool(inHand)) {
  839. tier = 2;
  840. }
  841. else if (ItemUtils.isIronTool(inHand)) {
  842. tier = 3;
  843. }
  844. else if (ItemUtils.isGoldTool(inHand)) {
  845. tier = 1;
  846. }
  847. else if (ItemUtils.isDiamondTool(inHand)) {
  848. tier = 4;
  849. } else if (ItemUtils.isNetheriteTool(inHand)) {
  850. tier = 5;
  851. }
  852. else if (mcMMO.getModManager().isCustomTool(inHand)) {
  853. tier = mcMMO.getModManager().getTool(inHand).getTier();
  854. }
  855. return tier;
  856. }
  857. public static void handleHealthbars(@NotNull Entity attacker, @NotNull LivingEntity target, double damage, @NotNull mcMMO plugin) {
  858. if (!(attacker instanceof Player)) {
  859. return;
  860. }
  861. Player player = (Player) attacker;
  862. if (Misc.isNPCEntityExcludingVillagers(player) || Misc.isNPCEntityExcludingVillagers(target)) {
  863. return;
  864. }
  865. if (!player.hasMetadata(mcMMO.playerDataKey)) {
  866. return;
  867. }
  868. MobHealthbarUtils.handleMobHealthbars(target, damage, plugin);
  869. }
  870. public static void modifyMoveSpeed(@NotNull LivingEntity livingEntity, double multiplier) {
  871. AttributeInstance attributeInstance = livingEntity.getAttribute(Attribute.GENERIC_MOVEMENT_SPEED);
  872. if(attributeInstance != null) {
  873. double normalSpeed = attributeInstance.getBaseValue();
  874. attributeInstance.setBaseValue(normalSpeed * multiplier);
  875. }
  876. }
  877. /**
  878. * Clean up metadata from a projectile
  879. *
  880. * @param entity projectile
  881. */
  882. public static void cleanupArrowMetadata(@NotNull Projectile entity) {
  883. if(entity.hasMetadata(mcMMO.infiniteArrowKey)) {
  884. entity.removeMetadata(mcMMO.infiniteArrowKey, mcMMO.p);
  885. }
  886. if(entity.hasMetadata(mcMMO.bowForceKey)) {
  887. entity.removeMetadata(mcMMO.bowForceKey, mcMMO.p);
  888. }
  889. if(entity.hasMetadata(mcMMO.arrowDistanceKey)) {
  890. entity.removeMetadata(mcMMO.arrowDistanceKey, mcMMO.p);
  891. }
  892. }
  893. /**
  894. * Clean up metadata from a projectile after a minute has passed
  895. *
  896. * @param entity the projectile
  897. */
  898. public static void delayArrowMetaCleanup(@NotNull Projectile entity) {
  899. Bukkit.getServer().getScheduler().runTaskLater(mcMMO.p, () -> { cleanupArrowMetadata(entity);}, 20*60);
  900. }
  901. }