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.
562 lines
18 KiB
562 lines
18 KiB
// • ▌ ▄ ·. ▄▄▄· ▄▄ • ▪ ▄▄· ▄▄▄▄· ▄▄▄· ▐▄▄▄ ▄▄▄ . |
|
// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌· |
|
// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀ |
|
// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌ |
|
// ▀▀ █▪▀▀▀ ▀ ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀ ▀ ▀ ▀▀ █▪ ▀▀▀ |
|
// Magicbane Emulator Project © 2013 - 2022 |
|
// www.magicbane.com |
|
|
|
|
|
package engine.objects; |
|
|
|
import engine.Enum; |
|
import engine.Enum.DamageType; |
|
import engine.Enum.ModType; |
|
import engine.Enum.SourceType; |
|
import engine.gameManager.ChatManager; |
|
import engine.gameManager.DbManager; |
|
import engine.powers.EffectsBase; |
|
import engine.server.MBServerStatics; |
|
import org.pmw.tinylog.Logger; |
|
|
|
import java.sql.ResultSet; |
|
import java.sql.SQLException; |
|
import java.util.HashSet; |
|
import java.util.Iterator; |
|
import java.util.concurrent.ConcurrentHashMap; |
|
|
|
public class Resists { |
|
|
|
private ConcurrentHashMap<DamageType, Float> resists = new ConcurrentHashMap<>(MBServerStatics.CHM_INIT_CAP, MBServerStatics.CHM_LOAD, MBServerStatics.CHM_THREAD_LOW); |
|
private ConcurrentHashMap<DamageType, Boolean> immuneTo = new ConcurrentHashMap<>(MBServerStatics.CHM_INIT_CAP, MBServerStatics.CHM_LOAD, MBServerStatics.CHM_THREAD_LOW); |
|
private DamageType protection; |
|
private int protectionTrains=0; |
|
private boolean immuneToAll; |
|
private static ConcurrentHashMap<Integer, Resists> mobResists = new ConcurrentHashMap<>(MBServerStatics.CHM_INIT_CAP, MBServerStatics.CHM_LOAD, MBServerStatics.CHM_THREAD_LOW); |
|
|
|
/** |
|
* Generic Constructor |
|
*/ |
|
|
|
public Resists(String type) { |
|
switch (type) { |
|
case "Building": |
|
setBuildingResists(); |
|
break; |
|
case "Mine": |
|
setMineResists(); |
|
break; |
|
default: |
|
setGenericResists(); |
|
break; |
|
} |
|
} |
|
|
|
public Resists(Resists r) { |
|
for (DamageType dt : r.resists.keySet()) |
|
this.resists.put(dt, r.resists.get(dt)); |
|
for (DamageType dt : r.immuneTo.keySet()) |
|
this.immuneTo.put(dt, r.immuneTo.get(dt)); |
|
this.protection = r.protection; |
|
this.protectionTrains = r.protectionTrains; |
|
this.immuneToAll = r.immuneToAll; |
|
} |
|
|
|
/** |
|
* Generic Constructor for player |
|
*/ |
|
public Resists(PlayerCharacter pc) { |
|
setGenericResists(); |
|
} |
|
|
|
public Resists(Mob mob) { |
|
setGenericResists(); |
|
} |
|
|
|
/** |
|
* Called for mobBase when getting from the db fails |
|
*/ |
|
public Resists(MobBase mobBase) { |
|
setGenericResists(); |
|
} |
|
/** |
|
* Database Constructor |
|
*/ |
|
public Resists(ResultSet rs) throws SQLException { |
|
this.immuneToAll = false; |
|
this.resists.put(DamageType.Slash, rs.getFloat("slash")); |
|
this.resists.put(DamageType.Crush, rs.getFloat("crush")); |
|
this.resists.put(DamageType.Pierce, rs.getFloat("pierce")); |
|
this.resists.put(DamageType.Magic, rs.getFloat("magic")); |
|
this.resists.put(DamageType.Bleed, rs.getFloat("bleed")); |
|
this.resists.put(DamageType.Poison, rs.getFloat("poison")); |
|
this.resists.put(DamageType.Mental, rs.getFloat("mental")); |
|
this.resists.put(DamageType.Holy, rs.getFloat("holy")); |
|
this.resists.put(DamageType.Unholy, rs.getFloat("unholy")); |
|
this.resists.put(DamageType.Lightning, rs.getFloat("lightning")); |
|
this.resists.put(DamageType.Fire, rs.getFloat("fire")); |
|
this.resists.put(DamageType.Cold, rs.getFloat("cold")); |
|
this.resists.put(DamageType.Healing, 0f); |
|
} |
|
|
|
/** |
|
* Create generic resists for buildings |
|
*/ |
|
public final void setBuildingResists() { |
|
this.immuneToAll = false; |
|
this.resists.put(DamageType.Slash, 85f); |
|
this.resists.put(DamageType.Crush, 85f); |
|
this.resists.put(DamageType.Siege, 0f); |
|
this.immuneTo.put(DamageType.Pierce, true); |
|
this.immuneTo.put(DamageType.Magic, true); |
|
this.immuneTo.put(DamageType.Bleed, true); |
|
this.immuneTo.put(DamageType.Poison, true); |
|
this.immuneTo.put(DamageType.Mental, true); |
|
this.immuneTo.put(DamageType.Holy, true); |
|
this.immuneTo.put(DamageType.Unholy, true); |
|
this.immuneTo.put(DamageType.Lightning, true); |
|
this.immuneTo.put(DamageType.Fire, true); |
|
this.immuneTo.put(DamageType.Cold, true); |
|
|
|
} |
|
|
|
/** |
|
* Create generic resists for mines |
|
*/ |
|
public final void setMineResists() { |
|
this.immuneToAll = false; |
|
this.immuneTo.put(DamageType.Slash, true); |
|
this.immuneTo.put(DamageType.Crush, true); |
|
this.immuneTo.put(DamageType.Pierce, true); |
|
this.immuneTo.put(DamageType.Magic, true); |
|
this.immuneTo.put(DamageType.Bleed, true); |
|
this.immuneTo.put(DamageType.Poison, true); |
|
this.immuneTo.put(DamageType.Mental, true); |
|
this.immuneTo.put(DamageType.Holy, true); |
|
this.immuneTo.put(DamageType.Unholy, true); |
|
this.immuneTo.put(DamageType.Lightning, true); |
|
this.immuneTo.put(DamageType.Fire, true); |
|
this.immuneTo.put(DamageType.Cold, true); |
|
this.resists.put(DamageType.Siege, 0f); |
|
} |
|
|
|
/** |
|
* Create generic resists |
|
*/ |
|
public final void setGenericResists() { |
|
this.immuneToAll = false; |
|
this.resists.put(DamageType.Slash, 0f); |
|
this.resists.put(DamageType.Crush, 0f); |
|
this.resists.put(DamageType.Pierce, 0f); |
|
this.resists.put(DamageType.Magic, 0f); |
|
this.resists.put(DamageType.Bleed, 0f); |
|
this.resists.put(DamageType.Poison, 0f); |
|
this.resists.put(DamageType.Mental, 0f); |
|
this.resists.put(DamageType.Holy, 0f); |
|
this.resists.put(DamageType.Unholy, 0f); |
|
this.resists.put(DamageType.Lightning, 0f); |
|
this.resists.put(DamageType.Fire, 0f); |
|
this.resists.put(DamageType.Cold, 0f); |
|
this.resists.put(DamageType.Healing, 0f); |
|
this.immuneTo.put(DamageType.Siege, true); |
|
|
|
} |
|
|
|
/** |
|
* Get a resist |
|
*/ |
|
public float getResist(DamageType type, int trains) { |
|
//get resisted amount |
|
Float amount = 0f; |
|
if (this.resists.containsKey(type)) |
|
amount = this.resists.get(type); |
|
|
|
//add protection |
|
if (trains > 0 && protection != null && type.equals(this.protection)) { |
|
float prot = 50 + this.protectionTrains - trains; |
|
amount += (prot >= 0) ? prot : 0; |
|
} |
|
|
|
if (amount == null) |
|
return 0f; |
|
if (amount > 75f) |
|
return 75f; |
|
return amount; |
|
} |
|
|
|
/** |
|
* get immuneTo |
|
*/ |
|
public boolean immuneTo(DamageType type) { |
|
if (this.immuneTo.containsKey(type)) |
|
return this.immuneTo.get(type); |
|
else |
|
return false; |
|
} |
|
|
|
/** |
|
* get immuneToAll |
|
*/ |
|
public boolean immuneToAll() { |
|
return this.immuneToAll; |
|
} |
|
|
|
public boolean immuneToPowers() { |
|
return immuneTo(DamageType.Powers); |
|
} |
|
|
|
public boolean immuneToAttacks() { |
|
return immuneTo(DamageType.Attack); |
|
} |
|
|
|
public boolean immuneToSpires() { |
|
return immuneTo(DamageType.Spires); |
|
} |
|
|
|
/** |
|
* gets immuneTo(type) and immuneToAll |
|
*/ |
|
public boolean isImmune(DamageType type) { |
|
if (this.immuneToAll) |
|
return true; |
|
return this.immuneTo(type); |
|
} |
|
|
|
/** |
|
* Set a resist |
|
*/ |
|
public void setResist(DamageType type, float value) { |
|
this.resists.put(type, value); |
|
} |
|
|
|
/** |
|
* add to a resist |
|
*/ |
|
public void incResist(DamageType type, float value) { |
|
Float amount = this.resists.get(type); |
|
if (amount == null) |
|
this.resists.put(type, value); |
|
else |
|
this.resists.put(type, amount + value); |
|
} |
|
|
|
/** |
|
* subtract from a resist |
|
*/ |
|
public void decResist(DamageType type, float value) { |
|
Float amount = this.resists.get(type); |
|
if (amount == null) |
|
this.resists.put(type, (0 - value)); |
|
else |
|
this.resists.put(type, amount - value); |
|
} |
|
|
|
/** |
|
* set immunities from mobbase |
|
*/ |
|
public void setImmuneTo(int immune) { |
|
setImmuneTo(DamageType.Stun, ((immune & 1) != 0)); |
|
setImmuneTo(DamageType.PowerBlock, ((immune & 2) != 0)); |
|
setImmuneTo(DamageType.Drain, ((immune & 4) != 0)); |
|
setImmuneTo(DamageType.Snare, ((immune & 8) != 0)); |
|
setImmuneTo(DamageType.Siege, ((immune & 16) != 0)); |
|
setImmuneTo(DamageType.Slash, ((immune & 32) != 0)); |
|
setImmuneTo(DamageType.Crush, ((immune & 64) != 0)); |
|
setImmuneTo(DamageType.Pierce, ((immune & 128) != 0)); |
|
setImmuneTo(DamageType.Magic, ((immune & 256) != 0)); |
|
setImmuneTo(DamageType.Bleed, ((immune & 512) != 0)); |
|
setImmuneTo(DamageType.Poison, ((immune & 1024) != 0)); |
|
setImmuneTo(DamageType.Mental, ((immune & 2048) != 0)); |
|
setImmuneTo(DamageType.Holy, ((immune & 4096) != 0)); |
|
setImmuneTo(DamageType.Unholy, ((immune & 8192) != 0)); |
|
setImmuneTo(DamageType.Lightning, ((immune & 16384) != 0)); |
|
setImmuneTo(DamageType.Fire, ((immune & 32768) != 0)); |
|
setImmuneTo(DamageType.Cold, ((immune & 65536) != 0)); |
|
setImmuneTo(DamageType.Steel, ((immune & 131072) != 0)); |
|
} |
|
|
|
/** |
|
* set/unset immuneTo |
|
*/ |
|
public void setImmuneTo(DamageType type, boolean value) { |
|
this.immuneTo.put(type, value); |
|
} |
|
|
|
/** |
|
* set immuneToAll |
|
*/ |
|
public void setImmuneToAll(boolean value) { |
|
this.immuneToAll = value; |
|
} |
|
|
|
|
|
/** |
|
* set resists from mobbase |
|
*/ |
|
public void setMobResists(int resistID) { |
|
//TODO add this in later |
|
//calls `static_npc_mob_resists` table WHERE `ID`='resistID' |
|
} |
|
|
|
/** |
|
* get Damage after resist |
|
* Expects heals as negative damage and damage as positive damage for fortitudes. |
|
*/ |
|
public float getResistedDamage(AbstractCharacter source, AbstractCharacter target, DamageType type, float damage, int trains) { |
|
//handle fortitudes |
|
damage = handleFortitude(target, type, damage); |
|
|
|
//check to see if any damage absorbers should cancel |
|
float damageAfterResists = damage * (1 - (this.getResist(type, trains) / 100)); |
|
if (target != null) { |
|
//debug damage shields if any found |
|
if (source.getDebug(2) && source.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)) { |
|
Effect da = target.getDamageAbsorber(); |
|
if (da != null && da.getEffectsBase() != null) { |
|
EffectsBase eb = da.getEffectsBase(); |
|
String text = "Damage: " + damage + '\n'; |
|
text += "Damage after resists: " + damageAfterResists + '\n'; |
|
text += "Attack damage type: " + type.name() + '\n'; |
|
text += "Fortitude damage types; " + eb.getDamageTypes() + '\n'; |
|
text += "Fortitude damage before attack: " + da.getDamageAmount() + '\n'; |
|
text += "Fortitude total health: " + eb.getDamageAmount(da.getTrains()) + '\n'; |
|
text += "Fortitude trains: " + da.getTrains(); |
|
ChatManager.chatSystemInfo((PlayerCharacter) source, text); |
|
} |
|
} |
|
target.cancelOnTakeDamage(type, (damageAfterResists)); |
|
} |
|
return damageAfterResists; |
|
} |
|
|
|
//Handle Fortitudes |
|
private static float handleFortitude(AbstractCharacter target, DamageType type, float damage) { |
|
if (target == null || !(target.getObjectType().equals(Enum.GameObjectType.PlayerCharacter))) |
|
return damage; |
|
PlayerBonuses bonus = target.getBonuses(); |
|
|
|
//see if there is a fortitude |
|
float damageCap = bonus.getFloatPercentAll(ModType.DamageCap, SourceType.None); |
|
if (damageCap == 0f || type == DamageType.Healing) |
|
return damage; |
|
|
|
//is fortitude, Are we under the cap? |
|
float maxHealth = target.getHealthMax(); |
|
float capFire = maxHealth * (damageCap); |
|
if (damage < capFire) |
|
return damage; |
|
|
|
//let's see if valid damagetype to apply it |
|
boolean exclusive; |
|
HashSet<SourceType> forts = bonus.getList(ModType.IgnoreDamageCap); |
|
if (forts == null) { |
|
exclusive = true; |
|
forts = bonus.getList(ModType.ExclusiveDamageCap); |
|
} else |
|
exclusive = false; |
|
if (forts == null || !isValidDamageCapType(forts, type, exclusive)) |
|
return damage; |
|
|
|
float adjustedDamage = bonus.getFloatPercentAll(ModType.AdjustAboveDmgCap, SourceType.None); |
|
//Adjust damage down and return new amount |
|
float aadc = 1 +adjustedDamage; |
|
return capFire * aadc; |
|
} |
|
|
|
//Test if Damagetype is valid for foritude |
|
private static boolean isValidDamageCapType(HashSet<SourceType> forts, DamageType damageType, boolean exclusive) { |
|
for (SourceType fort: forts) { |
|
DamageType dt = DamageType.valueOf(fort.name()); |
|
|
|
if (dt == DamageType.None) |
|
continue; |
|
|
|
if (dt == damageType) { |
|
return exclusive; |
|
} |
|
} |
|
return !exclusive; |
|
} |
|
|
|
|
|
/** |
|
* Calculate Current Resists for Player |
|
*/ |
|
public static void calculateResists(AbstractCharacter ac) { |
|
if (ac.getResists() != null) |
|
ac.getResists().calculateResists(ac, true); |
|
else |
|
Logger.error("Unable to find resists for character " + ac.getObjectUUID()); |
|
} |
|
|
|
public void calculateResists(AbstractCharacter ac, boolean val) { |
|
this.immuneTo.clear(); |
|
|
|
// get resists for runes |
|
PlayerBonuses rb = ac.getBonuses(); |
|
float slash = 0f, crush = 0f, pierce = 0f, magic = 0f, bleed = 0f, mental = 0f, holy = 0f, unholy = 0f, poison = 0f, lightning = 0f, fire = 0f, cold = 0f, healing = 0f; |
|
|
|
if (rb != null) { |
|
// Handle immunities |
|
if (rb.getBool(ModType.ImmuneTo, SourceType.Stun)) |
|
this.immuneTo.put(DamageType.Stun, true); |
|
if (rb.getBool(ModType.ImmuneTo, SourceType.Blind)) |
|
this.immuneTo.put(DamageType.Blind, true); |
|
if (rb.getBool(ModType.ImmuneToAttack, SourceType.None)) |
|
this.immuneTo.put(DamageType.Attack, true); |
|
if (rb.getBool(ModType.ImmuneToPowers, SourceType.None)) |
|
this.immuneTo.put(DamageType.Powers, true); |
|
if (rb.getBool(ModType.ImmuneTo, SourceType.Powerblock)) |
|
this.immuneTo.put(DamageType.Powerblock, true); |
|
if (rb.getBool(ModType.ImmuneTo, SourceType.DeBuff)) |
|
this.immuneTo.put(DamageType.DeBuff, true); |
|
if (rb.getBool(ModType.ImmuneTo, SourceType.Fear)) |
|
this.immuneTo.put(DamageType.Fear, true); |
|
if (rb.getBool(ModType.ImmuneTo, SourceType.Charm)) |
|
this.immuneTo.put(DamageType.Charm, true); |
|
if (rb.getBool(ModType.ImmuneTo, SourceType.Root)) |
|
this.immuneTo.put(DamageType.Root, true); |
|
if (rb.getBool(ModType.ImmuneTo, SourceType.Snare)) |
|
this.immuneTo.put(DamageType.Snare, true); |
|
|
|
// Handle resists |
|
slash += rb.getFloat(ModType.Resistance, SourceType.Slash); |
|
crush += rb.getFloat(ModType.Resistance, SourceType.Crush); |
|
pierce += rb.getFloat(ModType.Resistance, SourceType.Pierce); |
|
magic += rb.getFloat(ModType.Resistance, SourceType.Magic); |
|
bleed += rb.getFloat(ModType.Resistance, SourceType.Bleed); |
|
poison += rb.getFloat(ModType.Resistance, SourceType.Poison); |
|
mental += rb.getFloat(ModType.Resistance, SourceType.Mental); |
|
holy += rb.getFloat(ModType.Resistance, SourceType.Holy); |
|
unholy += rb.getFloat(ModType.Resistance, SourceType.Unholy); |
|
lightning += rb.getFloat(ModType.Resistance, SourceType.Lightning); |
|
fire += rb.getFloat(ModType.Resistance, SourceType.Fire); |
|
cold += rb.getFloat(ModType.Resistance, SourceType.Cold); |
|
healing += rb.getFloat(ModType.Resistance, SourceType.Healing); // DamageType.Healing.name()); |
|
|
|
//HHO |
|
|
|
// String protectionString = rb.getString("protection"); |
|
// |
|
// if (protectionString.isEmpty()) |
|
// this.protection = null; |
|
// else try { |
|
// this.protection = DamageType.valueOf(rb.getString("protection")); |
|
// } catch (IllegalArgumentException e) { |
|
// Logger.error( "No enum for: " + protectionString); |
|
// this.protection = null; |
|
// } |
|
// this.protectionTrains = rb.getFloat("protection"); |
|
} |
|
|
|
// get resists from equipment |
|
if (ac.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)) { |
|
if (ac.getCharItemManager() != null && ac.getCharItemManager().getEquipped() != null) { |
|
float[] phys = { 0f, 0f, 0f }; |
|
ConcurrentHashMap<Integer, Item> equip = ac.getCharItemManager().getEquipped(); |
|
|
|
// get base physical resists |
|
phys = Resists.getArmorResists(equip.get(MBServerStatics.SLOT_HELMET), phys); |
|
phys = Resists.getArmorResists(equip.get(MBServerStatics.SLOT_CHEST), phys); |
|
phys = Resists.getArmorResists(equip.get(MBServerStatics.SLOT_ARMS), phys); |
|
phys = Resists.getArmorResists(equip.get(MBServerStatics.SLOT_GLOVES), phys); |
|
phys = Resists.getArmorResists(equip.get(MBServerStatics.SLOT_LEGGINGS), phys); |
|
phys = Resists.getArmorResists(equip.get(MBServerStatics.SLOT_FEET), phys); |
|
slash += phys[0]; |
|
crush += phys[1]; |
|
pierce += phys[2]; |
|
|
|
} |
|
} |
|
|
|
this.resists.put(DamageType.Slash, slash); |
|
this.resists.put(DamageType.Crush, crush); |
|
this.resists.put(DamageType.Pierce, pierce); |
|
this.resists.put(DamageType.Magic, magic); |
|
this.resists.put(DamageType.Bleed, bleed); |
|
this.resists.put(DamageType.Poison, poison); |
|
this.resists.put(DamageType.Mental, mental); |
|
this.resists.put(DamageType.Holy, holy); |
|
this.resists.put(DamageType.Unholy, unholy); |
|
this.resists.put(DamageType.Lightning, lightning); |
|
this.resists.put(DamageType.Fire, fire); |
|
this.resists.put(DamageType.Cold, cold); |
|
this.resists.put(DamageType.Healing, healing); |
|
|
|
this.immuneTo.put(DamageType.Siege, true); |
|
|
|
// debug printing of resists |
|
// printResists(pc); |
|
} |
|
|
|
private static float[] getArmorResists(Item armor, float[] phys) { |
|
if (armor == null) |
|
return phys; |
|
ItemBase ab = armor.getItemBase(); |
|
if (ab == null) |
|
return phys; |
|
phys[0] += ab.getSlashResist(); |
|
phys[1] += ab.getCrushResist(); |
|
phys[2] += ab.getPierceResist(); |
|
return phys; |
|
} |
|
|
|
public void printResistsToClient(PlayerCharacter pc) { |
|
for (DamageType dt : resists.keySet()) |
|
ChatManager.chatSystemInfo(pc, " resist." + dt.name() + ": " + resists.get(dt)); |
|
for (DamageType dt : immuneTo.keySet()) |
|
ChatManager.chatSystemInfo(pc, " immuneTo." + dt.name() + ": " + immuneTo.get(dt)); |
|
ChatManager.chatSystemInfo(pc, " immuneToAll: " + this.immuneToAll); |
|
if (protection != null) |
|
ChatManager.chatSystemInfo(pc, " Protection: " + protection.name() + ", Trains: " + protectionTrains); |
|
else |
|
ChatManager.chatSystemInfo(pc, " Protection: None"); |
|
} |
|
|
|
public String getResists(PlayerCharacter pc) { |
|
String out = pc.getName(); |
|
|
|
out += "Resists: "; |
|
Iterator<DamageType> it = this.resists.keySet().iterator(); |
|
while (it.hasNext()) { |
|
DamageType damType = it.next(); |
|
String dtName = damType.name(); |
|
out += dtName + '=' + this.resists.get(dtName) + ", "; |
|
} |
|
|
|
out += "ImmuneTo: "; |
|
it = this.immuneTo.keySet().iterator(); |
|
while (it.hasNext()) { |
|
DamageType damType = it.next(); |
|
|
|
String dtName = damType.name(); |
|
out += dtName + '=' + this.resists.get(dtName) + ", "; |
|
} |
|
|
|
if (protection != null) |
|
out += "Protection: " + protection.name() + ", Trains: " + protectionTrains; |
|
else |
|
out += "Protection: none"; |
|
|
|
return out; |
|
} |
|
|
|
/** |
|
* Get mob resists from db if there, otherwise set defaults |
|
*/ |
|
public static Resists getResists(int resistID) { |
|
//check cache first |
|
if (mobResists.containsKey(resistID)) |
|
return new Resists(mobResists.get(resistID)); |
|
|
|
//get from database |
|
Resists resists = DbManager.ResistQueries.GET_RESISTS_FOR_MOB(resistID); |
|
if (resists != null) { |
|
mobResists.put(resistID, resists); |
|
return new Resists(resists); |
|
} |
|
|
|
//failed, may want to debug this |
|
return null; |
|
} |
|
}
|
|
|