MagicBotandClaude Opus 5.5
b21ccdbb4c
Unarmed mobs now add their rune natural attack range in processAttack and use it in getRange. Most melee runes have 0, so they are unchanged; ranged plant mobs (Gasser, Spitter, Needler, ...) get 150, Shuggra 50. Natural range is not subject to the unverified 80 clamp. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
789 lines
33 KiB
Java
789 lines
33 KiB
Java
// • ▌ ▄ ·. ▄▄▄· ▄▄ • ▪ ▄▄· ▄▄▄▄· ▄▄▄· ▐▄▄▄ ▄▄▄ .
|
|
// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
|
|
// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
|
|
// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
|
|
// ▀▀ █▪▀▀▀ ▀ ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀ ▀ ▀ ▀▀ █▪ ▀▀▀
|
|
// Magicbane Emulator Project © 2013 - 2026
|
|
// https://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.PowerProjectileMsg;
|
|
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.powers.effectmodifiers.WeaponProcEffectModifier;
|
|
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;
|
|
|
|
import static java.lang.Math.pow;
|
|
|
|
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 final int COMBAT_BLOCK_ANIMATION = 298;
|
|
public static final int COMBAT_PARRY_ANIMATION = 299;
|
|
public static final int COMBAT_DODGE_ANIMATION = 300;
|
|
|
|
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_used.equals("Block")) {
|
|
//swing left hand only
|
|
processAttack(attacker, target, mbEnums.EquipSlotType.LHELD);
|
|
return;
|
|
}
|
|
|
|
if (mainWeapon == null && offWeapon != null && offWeapon.template.item_skill_used.equals("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_used.equals("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_used.equals("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;
|
|
|
|
//check if this slot is on attack timer, if timer has passed clear it, else early exit
|
|
if (attacker.getTimers() != null && attacker.getTimers().containsKey("Attack" + slot.name()))
|
|
if (attacker.getTimers().get("Attack" + slot.name()).timeToExecutionLeft() <= 0)
|
|
attacker.getTimers().remove("Attack" + slot.name());
|
|
else
|
|
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;
|
|
} else if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob)) {
|
|
|
|
//unarmed mob, add the natural attack range from its rune (0 for most melee mobs)
|
|
|
|
if (bonus != null)
|
|
rangeMod += bonus.getFloatPercentAll(mbEnums.ModType.WeaponRange, mbEnums.SourceType.None);
|
|
|
|
attackRange += getNaturalAttackRange(attacker, slot) * rangeMod;
|
|
}
|
|
|
|
if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob))
|
|
if (((Mob) attacker).isSiege())
|
|
attackRange = getSiegeRange((Mob) attacker);
|
|
|
|
float distanceSquared = attacker.loc.distanceSquared(target.loc);
|
|
|
|
boolean inRange = false;
|
|
if (AbstractCharacter.IsAbstractCharacter(target)) {
|
|
attackRange += ((AbstractCharacter) target).calcHitBox();
|
|
} else {
|
|
|
|
}
|
|
|
|
if (attackRange > 15 && attacker.isMoving()) {
|
|
//cannot shoot bow while moving;
|
|
return;
|
|
}
|
|
|
|
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:
|
|
if (attackRange > 15) {
|
|
float rangeSquared = (attackRange + target.getBounds().getHalfExtents().x) * (attackRange + target.getBounds().getHalfExtents().x);
|
|
//float distanceSquared = attacker.loc.distanceSquared(target.loc);
|
|
if (distanceSquared < rangeSquared) {
|
|
inRange = true;
|
|
break;
|
|
}
|
|
} else {
|
|
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) {
|
|
|
|
float 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 = (long)wepSpeed * 100L;
|
|
} else {
|
|
|
|
//unarmed, use the natural attack speed from the mob or race rune
|
|
|
|
float naturalSpeed = getNaturalAttackSpeed(attacker, slot);
|
|
|
|
if (naturalSpeed > 0) {
|
|
|
|
if (attacker.getBonuses() != null && attacker.getBonuses().getFloatPercentAll(mbEnums.ModType.AttackDelay, mbEnums.SourceType.None) != 0f) //add effects speed bonus
|
|
naturalSpeed *= (1 + attacker.getBonuses().getFloatPercentAll(mbEnums.ModType.AttackDelay, mbEnums.SourceType.None));
|
|
|
|
if (naturalSpeed < 10)
|
|
naturalSpeed = 10;
|
|
|
|
delay = (long) naturalSpeed * 100L;
|
|
}
|
|
}
|
|
|
|
if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob))
|
|
((Mob) attacker).nextAttackTime = System.currentTimeMillis() + delay;
|
|
|
|
if (inRange) {
|
|
|
|
if(attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)){
|
|
if(!attacker.getTimestamps().contains(slot.name()+"Attack")){
|
|
attacker.getTimestamps().put(slot.name()+"Attack", System.currentTimeMillis() - 1000);
|
|
} else if(System.currentTimeMillis() < attacker.getTimestamps().get(slot.name()+"Attack") + delay){
|
|
setAutoAttackJob(attacker,slot,delay);
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
//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);
|
|
}
|
|
}
|
|
|
|
// take stamina away from attacker if its not a mob
|
|
if (weapon != null && !attacker.getObjectType().equals(mbEnums.GameObjectType.Mob)) {
|
|
//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;
|
|
}
|
|
}
|
|
float stam = weapon.template.item_wt / 3f;
|
|
stam = (stam < 1) ? 1 : stam;
|
|
attacker.modifyStamina(-(stam), attacker, true);
|
|
} else
|
|
attacker.modifyStamina(1, 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;
|
|
}
|
|
|
|
//apply weapon powers before early exit for miss or passives
|
|
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);
|
|
}
|
|
}
|
|
|
|
|
|
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 = getPassiveAnimation(mbEnums.PassiveType.None); // checking for a miss due to ATR vs Def
|
|
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);
|
|
|
|
//we need to send the animation even if the attacker misses
|
|
TargetedActionMsg cmm = new TargetedActionMsg(attacker, target, (float) 0, getSwingAnimation(weapon == null ? null : weapon.template, null, slot));
|
|
DispatchManager.sendToAllInRange(target, cmm);
|
|
|
|
//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)) {
|
|
passiveAnim = getPassiveAnimation(passiveType);
|
|
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);
|
|
|
|
//we need to send the animation even if the attacker misses
|
|
TargetedActionMsg cmm = new TargetedActionMsg(attacker, target, (float) 0, getSwingAnimation(weapon == null ? null : weapon.template, null, slot));
|
|
DispatchManager.sendToAllInRange(target, cmm);
|
|
//set auto attack job
|
|
setAutoAttackJob(attacker, slot, delay);
|
|
return;
|
|
}
|
|
}
|
|
|
|
//check for proccing
|
|
checkForProc(attacker,target,weapon);
|
|
|
|
//calculate the base damage
|
|
int damage = ThreadLocalRandom.current().nextInt(min, max + 1);
|
|
if (damage == 0) {
|
|
//set auto attack job
|
|
setAutoAttackJob(attacker, slot, delay);
|
|
return;
|
|
}
|
|
if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob) && ((Mob) attacker).isPet())
|
|
calculatePetDamage(attacker);
|
|
|
|
//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<AbstractEffectModifier, DamageShield> 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
|
|
//we need to send the animation even if the attacker misses
|
|
TargetedActionMsg cmm = new TargetedActionMsg(attacker, target, (float) 0, getSwingAnimation(weapon == null ? null : weapon.template, null, slot));
|
|
DispatchManager.sendToAllInRange(target, cmm);
|
|
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);
|
|
((AbstractCharacter) target).cancelOnTakeDamage();
|
|
}else {
|
|
((Building) target).modifyHealth(-damage, attacker);
|
|
}
|
|
int attackAnim = getSwingAnimation(null, null, slot);
|
|
if (attacker.charItemManager.getEquipped().get(slot) != null) {
|
|
if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) {
|
|
DeferredPowerJob weaponPower = ((PlayerCharacter) attacker).getWeaponPower();
|
|
attackAnim = getSwingAnimation(weapon.template, weaponPower, slot);
|
|
} else {
|
|
attackAnim = getSwingAnimation(weapon.template, null, slot);
|
|
}
|
|
}
|
|
TargetedActionMsg cmm = new TargetedActionMsg(attacker, target, (float) damage, attackAnim);
|
|
DispatchManager.sendToAllInRange(target, cmm);
|
|
|
|
//siege projectile is sent once per hit, not per AI pulse
|
|
|
|
if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob) && ((Mob) attacker).isSiege()
|
|
&& target.getObjectType().equals(mbEnums.GameObjectType.Building)) {
|
|
PowerProjectileMsg ppm = new PowerProjectileMsg(attacker, target);
|
|
ppm.setRange(50);
|
|
DispatchManager.dispatchMsgToInterestArea(attacker, ppm, mbEnums.DispatchChannel.SECONDARY, MBServerStatics.CHARACTER_LOAD_RANGE, false, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
//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, mbEnums.EquipSlotType slot) {
|
|
|
|
//No weapon, return default animation
|
|
if (wb == null)
|
|
return 75;
|
|
|
|
int token;
|
|
|
|
if (dpj != null) {
|
|
|
|
token = (dpj.getPower() != null) ? dpj.getPower().getToken() : 0;
|
|
|
|
if (token == 563721004) //kick animation
|
|
return 79;
|
|
}
|
|
|
|
//Item has no equipment slots and should not try to return an animation, return default instead
|
|
if (wb.item_eq_slots_or == null || wb.item_eq_slots_or.isEmpty()) {
|
|
return 75;
|
|
}
|
|
|
|
//declare variables
|
|
int anim;
|
|
int random;
|
|
|
|
//Item can only be equipped in one slot, return animation for that slot
|
|
if (wb.item_eq_slots_or.size() == 1) {
|
|
if (wb.item_eq_slots_or.iterator().next().equals(mbEnums.EquipSlotType.RHELD)) {
|
|
anim = wb.weapon_attack_anim_right.get(0)[0];
|
|
if (dpj != null) {
|
|
random = ThreadLocalRandom.current().nextInt(wb.weapon_attack_anim_right.size());
|
|
anim = wb.weapon_attack_anim_right.get(random)[0];
|
|
}
|
|
} else {
|
|
anim = wb.weapon_attack_anim_left.get(0)[0];
|
|
if (dpj != null) {
|
|
random = ThreadLocalRandom.current().nextInt(wb.weapon_attack_anim_left.size());
|
|
anim = wb.weapon_attack_anim_left.get(random)[0];
|
|
}
|
|
}
|
|
return anim;
|
|
}
|
|
|
|
//Item can be equipped in either hand, and should have animation sets for each hand
|
|
if (slot.equals(mbEnums.EquipSlotType.RHELD)) {
|
|
anim = wb.weapon_attack_anim_right.get(0)[0];
|
|
if (dpj != null) {
|
|
random = ThreadLocalRandom.current().nextInt(wb.weapon_attack_anim_right.size());
|
|
anim = wb.weapon_attack_anim_right.get(random)[0];
|
|
}
|
|
} else {
|
|
anim = wb.weapon_attack_anim_left.get(0)[0];
|
|
if (dpj != null) {
|
|
random = ThreadLocalRandom.current().nextInt(wb.weapon_attack_anim_left.size());
|
|
anim = wb.weapon_attack_anim_left.get(random)[0];
|
|
}
|
|
}
|
|
return anim;
|
|
}
|
|
|
|
public static int getPassiveAnimation(mbEnums.PassiveType passiveType) {
|
|
switch (passiveType) {
|
|
case Block:
|
|
return COMBAT_BLOCK_ANIMATION;
|
|
case Parry:
|
|
return COMBAT_PARRY_ANIMATION;
|
|
case Dodge:
|
|
return COMBAT_DODGE_ANIMATION;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public static void setAutoAttackJob(AbstractCharacter attacker, mbEnums.EquipSlotType slot, long delay) {
|
|
//calculate next allowed attack and update the timestamp
|
|
|
|
if (attacker.getTimestamps().containsKey("Attack" + slot.name()) && attacker.getTimestamps().get("Attack" + slot.name()) > System.currentTimeMillis())
|
|
return;
|
|
|
|
attacker.getTimestamps().put("Attack" + slot.name(), System.currentTimeMillis() + delay);
|
|
|
|
//handle auto attack job creation
|
|
ConcurrentHashMap<String, JobContainer> 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.name(), job);
|
|
} else
|
|
Logger.error("Unable to find Timers for Character " + attacker.getObjectUUID());
|
|
|
|
}
|
|
|
|
public static float getNaturalAttackSpeed(AbstractCharacter attacker, mbEnums.EquipSlotType slot) {
|
|
|
|
// Returns the rune natural attack speed (x100 ms) for this hand, or 0 if the rune has none.
|
|
|
|
float[] attack = getNaturalAttack(attacker, slot);
|
|
|
|
if (attack == null || attack.length < 1)
|
|
return 0;
|
|
|
|
return attack[0];
|
|
}
|
|
|
|
public static float getNaturalAttackRange(AbstractCharacter attacker, mbEnums.EquipSlotType slot) {
|
|
|
|
// Returns the rune natural attack range for this hand, or 0 if the rune has none.
|
|
|
|
float[] attack = getNaturalAttack(attacker, slot);
|
|
|
|
if (attack == null || attack.length < 2)
|
|
return 0;
|
|
|
|
return attack[1];
|
|
}
|
|
|
|
public static float getSiegeRange(Mob siegeEngine) {
|
|
|
|
// Siege engines use the range from their rune natural attack (350 for all three), 300 if the rune has none.
|
|
|
|
float range = getNaturalAttackRange(siegeEngine, mbEnums.EquipSlotType.RHELD);
|
|
|
|
if (range <= 0)
|
|
return 300;
|
|
|
|
return range;
|
|
}
|
|
|
|
public static float[] getNaturalAttack(AbstractCharacter attacker, mbEnums.EquipSlotType slot) {
|
|
|
|
// Returns the rune natural attack entry for this hand, or null if the rune has none.
|
|
// Mobs use their mobbase rune, players use their race rune.
|
|
|
|
int runeID;
|
|
ItemTemplate rune;
|
|
int hand = slot.equals(mbEnums.EquipSlotType.LHELD) ? 2 : 1;
|
|
|
|
switch (attacker.getObjectType()) {
|
|
case Mob:
|
|
runeID = ((Mob) attacker).loadID;
|
|
break;
|
|
case PlayerCharacter:
|
|
runeID = ((PlayerCharacter) attacker).getRaceID();
|
|
break;
|
|
default:
|
|
return null;
|
|
}
|
|
|
|
rune = ItemTemplate.templates.get(runeID);
|
|
|
|
if (rune == null || rune.rune_natural_attacks.isEmpty())
|
|
return null;
|
|
|
|
for (float[] attack : rune.rune_natural_attacks)
|
|
if (attack.length > 3 && (int) attack[3] == hand)
|
|
return attack;
|
|
|
|
// No entry for this hand, fall back to the first natural attack
|
|
|
|
return rune.rune_natural_attacks.get(0);
|
|
}
|
|
|
|
public static int calculatePetDamage(AbstractCharacter agent) {
|
|
//damage calc for pet
|
|
float range;
|
|
float damage;
|
|
float min = 40;
|
|
float max = 60;
|
|
float dmgMultiplier = 1 + agent.getBonuses().getFloatPercentAll(mbEnums.ModType.MeleeDamageModifier, mbEnums.SourceType.None);
|
|
double minDmg = getMinDmg(min, agent);
|
|
double maxDmg = getMaxDmg(max, agent);
|
|
dmgMultiplier += agent.getLevel() * 0.1f;
|
|
range = (float) (maxDmg - minDmg);
|
|
damage = min + ((ThreadLocalRandom.current().nextFloat() * range) + (ThreadLocalRandom.current().nextFloat() * range)) / 2;
|
|
return (int) (damage * dmgMultiplier);
|
|
}
|
|
|
|
public static double getMinDmg(double min, AbstractCharacter agent) {
|
|
int primary = agent.getStatStrCurrent();
|
|
int secondary = agent.getStatDexCurrent();
|
|
int focusLevel = 0;
|
|
int masteryLevel = 0;
|
|
return min * (pow(0.0048 * primary + .049 * (primary - 0.75), 0.5) + pow(0.0066 * secondary + 0.064 * (secondary - 0.75), 0.5) + +0.01 * (focusLevel + masteryLevel));
|
|
}
|
|
|
|
public static double getMaxDmg(double max, AbstractCharacter agent) {
|
|
int primary = agent.getStatStrCurrent();
|
|
int secondary = agent.getStatDexCurrent();
|
|
int focusLevel = 0;
|
|
int masteryLevel = 0;
|
|
return max * (pow(0.0124 * primary + 0.118 * (primary - 0.75), 0.5) + pow(0.0022 * secondary + 0.028 * (secondary - 0.75), 0.5) + 0.0075 * (focusLevel + masteryLevel));
|
|
}
|
|
|
|
public static void checkForProc(AbstractCharacter attacker, AbstractWorldObject target, Item weapon){
|
|
|
|
if(weapon == null) // cant proc without a weapon
|
|
return;
|
|
|
|
for(Effect eff : weapon.effects.values()){
|
|
for(AbstractEffectModifier mod : eff.getEffectsBase().getModifiers()){
|
|
if(mod.modType.equals(mbEnums.ModType.WeaponProc))
|
|
if(ThreadLocalRandom.current().nextInt(0,101) < 6)
|
|
((WeaponProcEffectModifier)mod).applyProc(attacker,target);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
} |