Public Repository for the Magicbane Shadowbane Emulator
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

518 lines
19 KiB

package engine.gameManager;
import engine.Enum;
import engine.job.JobContainer;
import engine.job.JobScheduler;
import engine.jobs.AttackJob;
import engine.jobs.DeferredPowerJob;
import engine.net.DispatchMessage;
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.util.EnumSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ThreadLocalRandom;
12 months ago
public enum CombatManager {
COMBAT_MANAGER;
public static void combatCycle(AbstractCharacter attacker, AbstractWorldObject target) {
//early exit checks
if (attacker == null || target == null || !attacker.isAlive() || !target.isAlive())
return;
switch (target.getObjectType()) {
case Building:
if (((Building) target).isVulnerable() == false)
return;
break;
case PlayerCharacter:
case Mob:
PlayerBonuses bonuses = ((AbstractCharacter) target).getBonuses();
if (bonuses != null && bonuses.getBool(Enum.ModType.ImmuneToAttack, Enum.SourceType.None))
return;
break;
case NPC:
return;
}
Item mainWeapon = attacker.charItemManager.getEquipped().get(Enum.EquipSlotType.RHELD);
Item offWeapon = attacker.charItemManager.getEquipped().get(Enum.EquipSlotType.LHELD);
if (mainWeapon == null && offWeapon == null) {
//no weapons equipped, punch with both fists
processAttack(attacker, target, Enum.EquipSlotType.RHELD);
processAttack(attacker, target, Enum.EquipSlotType.LHELD);
} else 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, Enum.EquipSlotType.RHELD);
} else 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, Enum.EquipSlotType.RHELD);
} else if (mainWeapon != null && offWeapon != null && offWeapon.template.item_skill_required.containsKey("Block") == false) {
//two weapons equipped, swing both hands
processAttack(attacker, target, Enum.EquipSlotType.RHELD);
processAttack(attacker, target, Enum.EquipSlotType.LHELD);
} else if (mainWeapon == null && offWeapon != null && offWeapon.template.item_skill_required.containsKey("Block") == false) {
//swing left hand only
processAttack(attacker, target, Enum.EquipSlotType.LHELD);
12 months ago
} else if (mainWeapon != null && offWeapon == null) {
//swing left hand only
processAttack(attacker, target, Enum.EquipSlotType.RHELD);
}
}
public static void processAttack(AbstractCharacter attacker, AbstractWorldObject target, Enum.EquipSlotType slot) {
// heck if character can even attack yet
if (attacker.getTimestamps().containsKey("Attack" + slot.name()))
if (System.currentTimeMillis() < attacker.getTimestamps().get("Attack" + slot.name()))
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(Enum.ModType.WeaponRange, Enum.SourceType.None);
attackRange = weapon.template.item_weapon_max_range * rangeMod;
}
if (attacker.getObjectType().equals(Enum.GameObjectType.Mob))
if (((Mob) attacker).isSiege())
attackRange = 300;
float distanceSquared = attacker.loc.distanceSquared(target.loc);
if (distanceSquared > attackRange * attackRange)
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 == Enum.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;
12 months ago
if (def == 0)
12 months ago
def = 1;
float dif = atr / def;
if (dif <= 0.8f)
hitChance = 4;
else
hitChance = ((int) (450 * (dif - 0.8f)) + 4);
if (target.getObjectType() == Enum.GameObjectType.Building)
hitChance = 100;
12 months ago
int passiveAnim = getSwingAnimation(null, null, slot.equals(Enum.EquipSlotType.RHELD));
12 months ago
if (attacker.charItemManager.getEquipped().get(slot) != null) {
12 months ago
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() == Enum.GameObjectType.PlayerCharacter)
DispatchMessage.dispatchMsgToInterestArea(target, msg, Enum.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
else
DispatchMessage.sendToAllInRange(attacker, msg);
return;
}
//calculate passive chances only if target is AbstractCharacter
if (EnumSet.of(Enum.GameObjectType.PlayerCharacter, Enum.GameObjectType.NPC, Enum.GameObjectType.Mob).contains(target.getObjectType())) {
Enum.PassiveType passiveType = Enum.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 = Enum.PassiveType.Dodge;
else if (hitRoll < blockChance)
passiveType = Enum.PassiveType.Block;
else if (hitRoll < parryChance)
passiveType = Enum.PassiveType.Parry;
if (passiveType.equals(Enum.PassiveType.None) == false) {
TargetedActionMsg msg = new TargetedActionMsg(attacker, passiveAnim, target, passiveType.value);
if (target.getObjectType() == Enum.GameObjectType.PlayerCharacter)
DispatchMessage.dispatchMsgToInterestArea(target, msg, Enum.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
else
DispatchMessage.sendToAllInRange(attacker, msg);
return;
}
}
//calculate the base damage
int damage = ThreadLocalRandom.current().nextInt(min, max + 1);
if (damage == 0)
return;
//get the damage type
Enum.DamageType damageType;
if (attacker.charItemManager.getEquipped().get(slot) == null) {
damageType = Enum.DamageType.CRUSHING;
if (attacker.getObjectType().equals(Enum.GameObjectType.Mob))
if (((Mob) attacker).isSiege())
damageType = Enum.DamageType.SIEGE;
} else {
damageType = (Enum.DamageType) attacker.charItemManager.getEquipped().get(slot).template.item_weapon_damage.keySet().toArray()[0];
}
//get resists
Resists resists;
if (AbstractCharacter.IsAbstractCharacter(target) == false)
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);
DispatchMessage.sendToAllInRange(target, cmm);
}
}
if (resists != null) {
//check for damage type immunities
if (resists.immuneTo(damageType))
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);
12 months ago
int attackAnim = getSwingAnimation(null, null, slot.equals(Enum.EquipSlotType.RHELD));
12 months ago
if (attacker.charItemManager.getEquipped().get(slot) != null) {
12 months ago
attackAnim = getSwingAnimation(attacker.charItemManager.getEquipped().get(slot).template, null, slot.equals(Enum.EquipSlotType.RHELD));
12 months ago
}
TargetedActionMsg cmm = new TargetedActionMsg(attacker, target, (float) damage, attackAnim);
DispatchMessage.sendToAllInRange(target, cmm);
}
DeferredPowerJob dpj = null;
if (attacker.getObjectType().equals(Enum.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);
}
}
//calculate next allowed attack and update the timestamp
long delay = 20 * 100;
if (weapon != null) {
int wepSpeed = (int) (weapon.template.item_weapon_wepspeed);
if (weapon.getBonusPercent(Enum.ModType.WeaponSpeed, Enum.SourceType.None) != 0f) //add weapon speed bonus
wepSpeed *= (1 + weapon.getBonus(Enum.ModType.WeaponSpeed, Enum.SourceType.None));
if (attacker.getBonuses() != null && attacker.getBonuses().getFloatPercentAll(Enum.ModType.AttackDelay, Enum.SourceType.None) != 0f) //add effects speed bonus
wepSpeed *= (1 + attacker.getBonuses().getFloatPercentAll(Enum.ModType.AttackDelay, Enum.SourceType.None));
if (wepSpeed < 10)
wepSpeed = 10; //Old was 10, but it can be reached lower with legit buffs,effects.
delay = wepSpeed * 100;
}
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, job);
} else
Logger.error("Unable to find Timers for Character " + attacker.getObjectUUID());
}
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);
DispatchMessage.dispatchMsgToInterestArea(playerCharacter, rwss, Enum.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);
DispatchMessage.dispatchMsgToInterestArea(playerCharacter, rwss, Enum.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(Enum.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 = 0;
if (dpj != null)
token = (dpj.getPower() != null) ? dpj.getPower().getToken() : 0;
if (token == 563721004) //kick animation
return 79;
if (wb == null)
return 75;
ItemTemplate template = wb;
if (mainHand) {
if (template.weapon_attack_anim_right.size() > 0) {
int animation;
int random = ThreadLocalRandom.current().nextInt(template.weapon_attack_anim_right.size());
try {
animation = template.weapon_attack_anim_right.get(random)[0];
return animation;
} catch (Exception e) {
Logger.error(e.getMessage());
return template.weapon_attack_anim_right.get(0)[0];
}
} else if (template.weapon_attack_anim_left.size() > 0) {
int animation;
int random = ThreadLocalRandom.current().nextInt(template.weapon_attack_anim_left.size());
try {
animation = template.weapon_attack_anim_left.get(random)[0];
return animation;
} catch (Exception e) {
Logger.error(e.getMessage());
return template.weapon_attack_anim_right.get(0)[0];
}
}
} else {
if (template.weapon_attack_anim_left.size() > 0) {
int animation;
int random = ThreadLocalRandom.current().nextInt(template.weapon_attack_anim_left.size());
try {
animation = template.weapon_attack_anim_left.get(random)[0];
return animation;
} catch (Exception e) {
Logger.error(e.getMessage());
return template.weapon_attack_anim_right.get(0)[0];
}
} else if (template.weapon_attack_anim_left.size() > 0) {
int animation;
int random = ThreadLocalRandom.current().nextInt(template.weapon_attack_anim_left.size());
try {
animation = template.weapon_attack_anim_left.get(random)[0];
return animation;
} catch (Exception e) {
Logger.error(e.getMessage());
return template.weapon_attack_anim_right.get(0)[0];
}
}
}
String required = template.item_skill_used;
String mastery = wb.item_skill_mastery_used;
if (required.equals("Unarmed Combat"))
return 75;
else if (required.equals("Sword")) {
if (ItemTemplate.isTwoHanded(template))
return 105;
else
return 98;
} else if (required.equals("Staff") || required.equals("Pole Arm")) {
return 85;
} else if (required.equals("Spear")) {
return 92;
} else if (required.equals("Hammer") || required.equals("Axe")) {
if (ItemTemplate.isTwoHanded(template)) {
return 105;
} else if (mastery.equals("Throwing")) {
return 115;
} else {
return 100;
}
} else if (required.equals("Dagger")) {
if (mastery.equals("Throwing")) {
return 117;
} else {
return 81;
}
} else if (required.equals("Crossbow")) {
return 110;
} else if (required.equals("Bow")) {
return 109;
} else if (ItemTemplate.isTwoHanded(template)) {
return 105;
} else {
return 100;
}
}
}