// • ▌ ▄ ·. ▄▄▄· ▄▄ • ▪ ▄▄· ▄▄▄▄· ▄▄▄· ▐▄▄▄ ▄▄▄ . // ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌· // ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀ // ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌ // ▀▀ █▪▀▀▀ ▀ ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀ ▀ ▀ ▀▀ █▪ ▀▀▀ // Magicbane Emulator Project © 2013 - 2022 // www.magicbane.com package engine.gameManager; import engine.job.JobContainer; import engine.job.JobScheduler; import engine.jobs.AttackJob; import engine.jobs.DeferredPowerJob; import engine.mbEnums; import engine.net.client.ClientConnection; import engine.net.client.msg.TargetedActionMsg; import engine.net.client.msg.UpdateStateMsg; import engine.objects.*; import engine.powers.DamageShield; import engine.powers.effectmodifiers.AbstractEffectModifier; import engine.server.MBServerStatics; import org.pmw.tinylog.Logger; import java.awt.geom.Point2D; import java.awt.geom.Rectangle2D; import java.util.EnumSet; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ThreadLocalRandom; public enum CombatManager { // MB Dev notes: // Class implements all combat mechanics for Magicbane. // // Combat initiates in "combatCycle" to determine which hands will be swung, and attack is processed based on that. // Handles all combat for AbstractCharacter including player characters and mobiles. // Controls toggling of combat and sit/stand for all AbstractCharacters // // COMBAT_MANAGER; public static void combatCycle(AbstractCharacter attacker, AbstractWorldObject target) { //early exit checks if (attacker == null || target == null || !attacker.isAlive() || !target.isAlive()) return; if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob)) if (((Mob) attacker).nextAttackTime > System.currentTimeMillis()) return; switch (target.getObjectType()) { case Building: if (!((Building) target).isVulnerable()) return; break; case PlayerCharacter: case Mob: PlayerBonuses bonuses = ((AbstractCharacter) target).getBonuses(); if (bonuses != null && bonuses.getBool(mbEnums.ModType.ImmuneToAttack, mbEnums.SourceType.None)) return; break; case NPC: return; } Item mainWeapon = attacker.charItemManager.getEquipped().get(mbEnums.EquipSlotType.RHELD); Item offWeapon = attacker.charItemManager.getEquipped().get(mbEnums.EquipSlotType.LHELD); if (mainWeapon == null && offWeapon == null) { //no weapons equipped, punch with both fists processAttack(attacker, target, mbEnums.EquipSlotType.RHELD); if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) processAttack(attacker, target, mbEnums.EquipSlotType.LHELD); return; } if (mainWeapon != null && offWeapon == null) { //swing right hand only processAttack(attacker, target, mbEnums.EquipSlotType.RHELD); return; } if (mainWeapon == null && offWeapon != null && !offWeapon.template.item_skill_required.containsKey("Block")) { //swing left hand only processAttack(attacker, target, mbEnums.EquipSlotType.LHELD); return; } if (mainWeapon == null && offWeapon != null && offWeapon.template.item_skill_required.containsKey("Block")) { //no weapon equipped with a shield, punch with one hand processAttack(attacker, target, mbEnums.EquipSlotType.RHELD); return; } if (mainWeapon != null && offWeapon != null && offWeapon.template.item_skill_required.containsKey("Block")) { //one weapon equipped with a shield, swing with one hand processAttack(attacker, target, mbEnums.EquipSlotType.RHELD); return; } if (mainWeapon != null && offWeapon != null && !offWeapon.template.item_skill_required.containsKey("Block")) { //two weapons equipped, swing both hands processAttack(attacker, target, mbEnums.EquipSlotType.RHELD); if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) processAttack(attacker, target, mbEnums.EquipSlotType.LHELD); } } public static void processAttack(AbstractCharacter attacker, AbstractWorldObject target, mbEnums.EquipSlotType slot) { if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) { if (!attacker.isCombat()) return; if (attacker.getTimestamps().get("Attack" + slot.name()) != null && attacker.getTimestamps().get("Attack" + slot.name()) < System.currentTimeMillis()) { setAutoAttackJob(attacker, slot, 1000); return; } } // check if character is in range to attack target PlayerBonuses bonus = attacker.getBonuses(); float rangeMod = 1.0f; float attackRange = MBServerStatics.NO_WEAPON_RANGE; Item weapon = attacker.charItemManager.getEquipped(slot); if (weapon != null) { if (bonus != null) rangeMod += bonus.getFloatPercentAll(mbEnums.ModType.WeaponRange, mbEnums.SourceType.None); attackRange = weapon.template.item_weapon_max_range * rangeMod; } if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob)) if (((Mob) attacker).isSiege()) attackRange = 300; float distanceSquared = attacker.loc.distanceSquared(target.loc); boolean inRange = false; if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) { attackRange += ((PlayerCharacter) attacker).getCharacterHeight() * 0.5f; } else { attackRange += attacker.calcHitBox(); } switch (target.getObjectType()) { case PlayerCharacter: attackRange += ((PlayerCharacter) target).getCharacterHeight() * 0.5f; if (distanceSquared < attackRange * attackRange) inRange = true; break; case Mob: attackRange += ((AbstractCharacter) target).calcHitBox(); if (distanceSquared < attackRange * attackRange) inRange = true; break; case Building: float locX = target.loc.x - target.getBounds().getHalfExtents().x; float locZ = target.loc.z - target.getBounds().getHalfExtents().y; float sizeX = (target.getBounds().getHalfExtents().x + attackRange) * 2; float sizeZ = (target.getBounds().getHalfExtents().y + attackRange) * 2; Rectangle2D.Float rect = new Rectangle2D.Float(locX, locZ, sizeX, sizeZ); if (rect.contains(new Point2D.Float(attacker.loc.x, attacker.loc.z))) inRange = true; break; } //get delay for the auto attack job long delay = 5000; if (weapon != null) { int wepSpeed = (int) (weapon.template.item_weapon_wepspeed); if (weapon.getBonusPercent(mbEnums.ModType.WeaponSpeed, mbEnums.SourceType.None) != 0f) //add weapon speed bonus wepSpeed *= (1 + weapon.getBonus(mbEnums.ModType.WeaponSpeed, mbEnums.SourceType.None)); if (attacker.getBonuses() != null && attacker.getBonuses().getFloatPercentAll(mbEnums.ModType.AttackDelay, mbEnums.SourceType.None) != 0f) //add effects speed bonus wepSpeed *= (1 + attacker.getBonuses().getFloatPercentAll(mbEnums.ModType.AttackDelay, mbEnums.SourceType.None)); if (wepSpeed < 10) wepSpeed = 10; //Old was 10, but it can be reached lower with legit buffs,effects. delay = wepSpeed * 100L; } if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob)) ((Mob) attacker).nextAttackTime = System.currentTimeMillis() + delay; if (inRange) { //handle retaliate if (AbstractCharacter.IsAbstractCharacter(target)) { if (((AbstractCharacter) target).combatTarget == null || !((AbstractCharacter) target).combatTarget.isAlive()) { ((AbstractCharacter) target).combatTarget = attacker; if (target.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter) && ((AbstractCharacter) target).isCombat()) combatCycle((AbstractCharacter) target, attacker); } } //check if Out of Stamina if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) { if (attacker.getStamina() < (weapon.template.item_wt / 3f)) { //set auto attack job setAutoAttackJob(attacker, slot, delay); return; } } // take stamina away from attacker if (weapon != null) { float stam = weapon.template.item_wt / 3f; stam = (stam < 1) ? 1 : stam; attacker.modifyStamina(-(stam), attacker, true); } else attacker.modifyStamina(-0.5f, attacker, true); //cancel things that are cancelled by an attack attacker.cancelOnAttackSwing(); //declare relevant variables int min = attacker.minDamageHandOne; int max = attacker.maxDamageHandOne; int atr = attacker.atrHandOne; //get the proper stats based on which slot is attacking if (slot == mbEnums.EquipSlotType.LHELD) { min = attacker.minDamageHandTwo; max = attacker.maxDamageHandTwo; atr = attacker.atrHandTwo; } int def = 0; if (AbstractCharacter.IsAbstractCharacter(target)) def = ((AbstractCharacter) target).defenseRating; //calculate hit chance based off ATR and DEF int hitChance; if (def == 0) def = 1; float dif = atr * 1f / def; if (dif <= 0.8f) hitChance = 4; else hitChance = ((int) (450 * (dif - 0.8f)) + 4); if (target.getObjectType() == mbEnums.GameObjectType.Building) hitChance = 100; int passiveAnim = getSwingAnimation(null, null, slot.equals(mbEnums.EquipSlotType.RHELD)); if(attacker.getObjectType().equals(mbEnums.GameObjectType.Mob)){ if (weapon != null) { passiveAnim = getSwingAnimation(weapon.template, null, true); } }else { if (attacker.charItemManager.getEquipped().get(slot) != null) { passiveAnim = getSwingAnimation(attacker.charItemManager.getEquipped().get(slot).template, null, true); } } if (ThreadLocalRandom.current().nextInt(100) > hitChance) { TargetedActionMsg msg = new TargetedActionMsg(attacker, target, 0f, passiveAnim); if (target.getObjectType() == mbEnums.GameObjectType.PlayerCharacter) DispatchManager.dispatchMsgToInterestArea(target, msg, mbEnums.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false); else DispatchManager.sendToAllInRange(attacker, msg); //set auto attack job setAutoAttackJob(attacker, slot, delay); return; } //calculate passive chances only if target is AbstractCharacter if (EnumSet.of(mbEnums.GameObjectType.PlayerCharacter, mbEnums.GameObjectType.NPC, mbEnums.GameObjectType.Mob).contains(target.getObjectType())) { mbEnums.PassiveType passiveType = mbEnums.PassiveType.None; int hitRoll = ThreadLocalRandom.current().nextInt(100); float dodgeChance = ((AbstractCharacter) target).getPassiveChance("Dodge", attacker.getLevel(), true); float blockChance = ((AbstractCharacter) target).getPassiveChance("Block", attacker.getLevel(), true); float parryChance = ((AbstractCharacter) target).getPassiveChance("Parry", attacker.getLevel(), true); // Passive chance clamped at 75 dodgeChance = Math.max(0, Math.min(75, dodgeChance)); blockChance = Math.max(0, Math.min(75, blockChance)); parryChance = Math.max(0, Math.min(75, parryChance)); if (hitRoll < dodgeChance) passiveType = mbEnums.PassiveType.Dodge; else if (hitRoll < blockChance) passiveType = mbEnums.PassiveType.Block; else if (hitRoll < parryChance) passiveType = mbEnums.PassiveType.Parry; if (!passiveType.equals(mbEnums.PassiveType.None)) { TargetedActionMsg msg = new TargetedActionMsg(attacker, passiveAnim, target, passiveType.value); if (target.getObjectType() == mbEnums.GameObjectType.PlayerCharacter) DispatchManager.dispatchMsgToInterestArea(target, msg, mbEnums.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false); else DispatchManager.sendToAllInRange(attacker, msg); //set auto attack job setAutoAttackJob(attacker, slot, delay); return; } } //calculate the base damage int damage = ThreadLocalRandom.current().nextInt(min, max + 1); if (damage == 0) { //set auto attack job setAutoAttackJob(attacker, slot, delay); return; } //get the damage type mbEnums.DamageType damageType; if (attacker.charItemManager.getEquipped().get(slot) == null) { damageType = mbEnums.DamageType.CRUSHING; if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob)) if (((Mob) attacker).isSiege()) damageType = mbEnums.DamageType.SIEGE; } else { damageType = (mbEnums.DamageType) attacker.charItemManager.getEquipped().get(slot).template.item_weapon_damage.keySet().toArray()[0]; } //get resists Resists resists; if (!AbstractCharacter.IsAbstractCharacter(target)) resists = ((Building) target).getResists(); //this is a building else resists = ((AbstractCharacter) target).getResists(); //this is a character if (AbstractCharacter.IsAbstractCharacter(target)) { AbstractCharacter absTarget = (AbstractCharacter) target; //check damage shields PlayerBonuses bonuses = absTarget.getBonuses(); if (bonuses != null) { ConcurrentHashMap damageShields = bonuses.getDamageShields(); float total = 0; for (DamageShield ds : damageShields.values()) { //get amount to damage back float amount; if (ds.usePercent()) amount = damage * ds.getAmount() / 100; else amount = ds.getAmount(); //get resisted damage for damagetype if (resists != null) amount = resists.getResistedDamage(absTarget, attacker, ds.getDamageType(), amount, 0); total += amount; } if (total > 0) { //apply Damage back attacker.modifyHealth(-total, absTarget, true); TargetedActionMsg cmm = new TargetedActionMsg(attacker, attacker, total, 0); DispatchManager.sendToAllInRange(target, cmm); } } if (resists != null) { //check for damage type immunities if (resists.immuneTo(damageType)) { //set auto attack job setAutoAttackJob(attacker, slot, delay); return; } //calculate resisted damage including fortitude damage = (int) resists.getResistedDamage(attacker, (AbstractCharacter) target, damageType, damage, 0); } } //remove damage from target health if (damage > 0) { if (AbstractCharacter.IsAbstractCharacter(target)) ((AbstractCharacter) target).modifyHealth(-damage, attacker, true); else ((Building) target).setCurrentHitPoints(target.getCurrentHitpoints() - damage); int attackAnim = getSwingAnimation(null, null, slot.equals(mbEnums.EquipSlotType.RHELD)); if (attacker.charItemManager.getEquipped().get(slot) != null) { if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) { DeferredPowerJob weaponPower = ((PlayerCharacter) attacker).getWeaponPower(); attackAnim = getSwingAnimation(attacker.charItemManager.getEquipped().get(slot).template, weaponPower, slot.equals(mbEnums.EquipSlotType.RHELD)); } else { attackAnim = getSwingAnimation(attacker.charItemManager.getEquipped().get(slot).template, null, slot.equals(mbEnums.EquipSlotType.RHELD)); } } TargetedActionMsg cmm = new TargetedActionMsg(attacker, target, (float) damage, attackAnim); DispatchManager.sendToAllInRange(target, cmm); } } DeferredPowerJob dpj = null; if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) { dpj = ((PlayerCharacter) attacker).getWeaponPower(); if (dpj != null) { dpj.attack(target, attackRange); if (dpj.getPower() != null && (dpj.getPowerToken() == -1851459567 || dpj.getPowerToken() == -1851489518)) ((PlayerCharacter) attacker).setWeaponPower(dpj); } } //set auto attack job setAutoAttackJob(attacker, slot, delay); } public static void toggleCombat(boolean toggle, ClientConnection origin) { PlayerCharacter playerCharacter = SessionManager.getPlayerCharacter(origin); if (playerCharacter == null) return; playerCharacter.setCombat(toggle); if (!toggle) // toggle is move it to false so clear combat target playerCharacter.setCombatTarget(null); //clear last combat target UpdateStateMsg rwss = new UpdateStateMsg(); rwss.setPlayer(playerCharacter); DispatchManager.dispatchMsgToInterestArea(playerCharacter, rwss, mbEnums.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, false, false); } public static void toggleSit(boolean toggle, ClientConnection origin) { PlayerCharacter playerCharacter = SessionManager.getPlayerCharacter(origin); if (playerCharacter == null) return; playerCharacter.setSit(toggle); UpdateStateMsg rwss = new UpdateStateMsg(); rwss.setPlayer(playerCharacter); DispatchManager.dispatchMsgToInterestArea(playerCharacter, rwss, mbEnums.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false); } public static void handleRetaliate(AbstractCharacter target, AbstractCharacter attacker) { //Called when character takes damage. if (attacker == null || target == null) return; if (attacker.equals(target)) return; if (target.isMoving() && target.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) return; if (!target.isAlive() || !attacker.isAlive()) return; boolean isCombat = target.isCombat(); //If target in combat and has no target, then attack back if (isCombat && target.combatTarget == null) target.setCombatTarget(attacker); } public static int getSwingAnimation(ItemTemplate wb, DeferredPowerJob dpj, boolean mainHand) { int token; if (dpj != null) { token = (dpj.getPower() != null) ? dpj.getPower().getToken() : 0; if (token == 563721004) //kick animation return 79; if (wb != null) { if (mainHand) { int random = ThreadLocalRandom.current().nextInt(wb.weapon_attack_anim_right.size()); int anim = wb.weapon_attack_anim_right.get(random)[0]; return anim; } else { int random = ThreadLocalRandom.current().nextInt(wb.weapon_attack_anim_left.size()); return wb.weapon_attack_anim_left.get(random)[0]; } } } if (wb == null) return 75; if (mainHand) return wb.weapon_attack_anim_right.get(0)[0]; else return wb.weapon_attack_anim_left.get(0)[0]; } public static void setAutoAttackJob(AbstractCharacter attacker, mbEnums.EquipSlotType slot, long delay) { //calculate next allowed attack and update the timestamp attacker.getTimestamps().put("Attack" + slot.name(), System.currentTimeMillis() + delay); //handle auto attack job creation ConcurrentHashMap timers = attacker.getTimers(); if (timers != null) { AttackJob aj = new AttackJob(attacker, slot.ordinal(), true); JobContainer job; job = JobScheduler.getInstance().scheduleJob(aj, (System.currentTimeMillis() + delay)); // offset 1 millisecond so no overlap issue timers.put("Attack" + slot, job); } else Logger.error("Unable to find Timers for Character " + attacker.getObjectUUID()); } }