class coreDamage(unittest.TestCase):
""" Test that core damage is calculated correctly """
def setUp(self):
""" Setup the attack and Pokemon to use the attack """
self.battlePkmn = BuildPokemonBattleWrapper()
self.pkmn = self.battlePkmn.pkmn
self.delegate = DamageDelegate(None, 50, 1)
self.pkmn.battleDelegate.stats["ATK"] = 10
self.pkmn.battleDelegate.stats["DEF"] = 10
self.pkmn.battleDelegate.level = 5
self.core = self.delegate.coreDamage(self.battlePkmn, self.battlePkmn) - 2
def testAtkEffect(self):
""" Test that altering ATK has the correct effect """
self.pkmn.battleDelegate.stats["ATK"] = self.pkmn.battleDelegate.stats["ATK"]*2
damage = self.delegate.coreDamage(self.battlePkmn, self.battlePkmn) - 2
assert damage == 2*self.core, "Damage should double when Attack is doubled"
def testDefEffect(self):
""" Test that altering DEF has the correct effect """
self.pkmn.battleDelegate.stats["DEF"] = self.pkmn.battleDelegate.stats["DEF"]*2
damage = self.delegate.coreDamage(self.battlePkmn, self.battlePkmn) - 2
assert damage == self.core/2.0, "Damage should half when Defense is doubled"
def testPowerEffect(self):
""" Test that altering Power has the correct effect """
self.delegate.power = 100
damage = self.delegate.coreDamage(self.battlePkmn, self.battlePkmn) - 2
assert damage == self.core*2.0, "Damage should double when Power is doubled"
class coreDamage(unittest.TestCase):
""" Test that core damage is calculated correctly """
def setUp(self):
""" Build the Pkmn and Delegates for use in the tests """
power = 50
isPhysical = 1
self.delegate = DamageScaleDelegate(None, power, isPhysical, 2, 5)
self.standardDelegate = DamageDelegate(None, power, isPhysical)
self.user = BuildPokemonBattleWrapper()
self.target = BuildPokemonBattleWrapper()
def damageIsSameOnFirstTurn(self):
""" Test that damage is equivalent before the scale kicks in """
self.delegate.turnsToGo = 0
standardDamage = self.standardDelegate.coreDamage(
self.user, self.target)
damage = self.delegate.coreDamage(self.user, self.target)
assert standardDamage == damage, "Should be no difference in damage on first turn"
def damageIsScaled(self):
""" Test that the damage is scaled when there is a scale """
self.delegate.turnsToGo = 2
scale = self.delegate.getScale()
standardDamage = self.standardDelegate.coreDamage(
self.user, self.target)
damage = self.delegate.coreDamage(self.user, self.target)
assert (
standardDamage - 2
) * scale + 2 == damage, "Damage should be scaled by the scale factor"
class coreDamage(unittest.TestCase):
""" Test that core damage is calculated correctly """
def setUp(self):
""" Build the Pkmn and Delegates for use in the tests """
power = 50
isPhysical = 1
self.delegate = DamageScaleDelegate(None, power, isPhysical, 2, 5)
self.standardDelegate = DamageDelegate(None, power, isPhysical)
self.user = BuildPokemonBattleWrapper()
self.target = BuildPokemonBattleWrapper()
def damageIsSameOnFirstTurn(self):
""" Test that damage is equivalent before the scale kicks in """
self.delegate.turnsToGo = 0
standardDamage = self.standardDelegate.coreDamage(self.user, self.target)
damage = self.delegate.coreDamage(self.user, self.target)
assert standardDamage == damage, "Should be no difference in damage on first turn"
def damageIsScaled(self):
""" Test that the damage is scaled when there is a scale """
self.delegate.turnsToGo = 2
scale = self.delegate.getScale()
standardDamage = self.standardDelegate.coreDamage(self.user, self.target)
damage = self.delegate.coreDamage(self.user, self.target)
assert (standardDamage-2)*scale+2 == damage, "Damage should be scaled by the scale factor"
class coreDamage(unittest.TestCase):
""" Test cases of coreDamage """
def setUp(self):
""" Build the Pkmn and Delegate for the test """
self.user = BuildPokemonBattleWrapper()
self.target = BuildPokemonBattleWrapper()
self.dodge = "DIG"
self.delegate = PierceDodge2XDelegate(None, 20, 1, self.dodge)
self.standard = DamageDelegate(None, 20, 1)
def pierce(self):
""" Test that the damage is doubled on pierce """
self.target.dodge = self.dodge
standard = self.standard.coreDamage(self.user, self.target)
damage = self.delegate.coreDamage(self.user, self.target)
assert damage == standard*2 , "The damage should be double on pierce"
def noPierce(self):
""" Test that the damage is standard when there is no pierce """
self.target.dodge = None
standard = self.standard.coreDamage(self.user, self.target)
damage = self.delegate.coreDamage(self.user, self.target)
assert damage == standard , "The damage should be standard on no pierce"
def setUp(self):
""" Build the Pkmn and Delegate for the test """
self.user = BuildPokemonBattleWrapper()
self.target = BuildPokemonBattleWrapper()
self.dodge = "DIG"
self.delegate = PierceDodge2XDelegate(None, 20, 1, self.dodge)
self.standard = DamageDelegate(None, 20, 1)
def setUp(self):
""" Build the Pkmn and Delegates for use in the tests """
power = 50
isPhysical = 1
self.delegate = DamageScaleDelegate(None, power, isPhysical, 2, 5)
self.standardDelegate = DamageDelegate(None, power, isPhysical)
self.user = BuildPokemonBattleWrapper()
self.target = BuildPokemonBattleWrapper()
def setUp(self):
""" Setup the attack and Pokemon to use the attack """
self.user = BuildPokemonBattleWrapper()
self.target = BuildPokemonBattleWrapper()
regDelegate = DamageDelegate(None, 50, 1)
self.core = regDelegate.coreDamage(self.user, self.target)
self.delegate = BoostDamageOnStatusDelegate(None, 50, 1)
def setUp(self):
""" Setup the attack and Pokemon to use the attack """
self.user = BuildPokemonBattleWrapper()
self.target = BuildPokemonBattleWrapper()
regDelegate = DamageDelegate(None, 50, 1)
self.core = regDelegate.coreDamage(self.user, self.target)
self.delegate = BoostDamageOnStatusDelegate(None, 50, 1)
def setUp(self):
""" Setup the attack and Pokemon to use the attack """
self.battlePkmn = BuildPokemonBattleWrapper()
self.pkmn = self.battlePkmn.pkmn
self.delegate = DamageDelegate(None, 50, 1)
self.pkmn.battleDelegate.stats["ATK"] = 10
self.pkmn.battleDelegate.stats["DEF"] = 10
self.pkmn.battleDelegate.level = 5
self.core = self.delegate.coreDamage(self.battlePkmn, self.battlePkmn) - 2
def setUp(self):
""" Build the Pkmn and Delegates for use in the tests """
power = 50
isPhysical = 1
self.delegate = DamageScaleDelegate(None, power, isPhysical, 2, 5)
self.standardDelegate = DamageDelegate(None, power, isPhysical)
self.user = BuildPokemonBattleWrapper()
self.target = BuildPokemonBattleWrapper()
class getStab(unittest.TestCase):
""" Tests that STAB returns the appropriate modifier """
def setUp(self):
""" Build the Attack and Damage Delegate """
attack = Attack()
attack.type ="FIRE"
self.delegate = DamageDelegate(attack, 0, 1)
def hasStab(self):
""" Test that it correctly returns STAB modifier """
pkmn = BuildPokemonBattleWrapper("CHARMANDER")
stab = self.delegate.getStab(pkmn)
assert stab == 1.5, "Should return with STAB modifier"
def noStab(self):
""" Test that it correctly returns STAB modifier """
pkmn = BuildPokemonBattleWrapper("BULBASAUR")
stab = self.delegate.getStab(pkmn)
assert stab == 1, "Should return with modifier of 1"
class normalize(unittest.TestCase):
""" Tests that Normalize normalizes correctly """
def setUp(self):
""" Build the Damage Delegate """
self.target = BuildPokemonBattleWrapper()
self.delegate = DamageDelegate(None, 0, 1)
def zero(self):
""" Test that 0 is normalized correctly """
damage = 0
newDamage = self.delegate.normalize(damage, self.target)
assert newDamage == 0, "Should return zero"
def lessThanOne(self):
""" Test that < 1 is normalized correctly """
damage = 0.1
newDamage = self.delegate.normalize(damage, self.target)
assert newDamage == 1, "Should return one if between 0 and 1"
def normalizeInt(self):
""" Test that normalizing an int returns the int """
damage = 3
newDamage = self.delegate.normalize(damage, self.target)
assert newDamage == damage, "Should return the number if its an int"
def normalizeFloat(self):
""" Test that normalizing a float returns the int """
damage = 3.3
newDamage = self.delegate.normalize(damage, self.target)
assert newDamage == int(damage), "Should return the floored number if its an int"
def greaterThanTargetHP(self):
""" Test that damage is normalized correctly when greater than the target's HP """
damage = self.target.getCurrHP()+1
newDamage = self.delegate.normalize(damage, self.target)
assert newDamage == int(self.target.getCurrHP()), "Should return the target's HP as damage"
def setUp(self):
""" Build the Attack and Damage Delegate for the test """
self.attack = Attack()
self.nullDamageDelegate = NullDamageDelegate()
self.normalDamageDelegate = DamageDelegate(None, None, None)
def setUp(self):
""" Build the Damage Delegate """
self.target = BuildPokemonBattleWrapper()
self.delegate = DamageDelegate(None, 0, 1)
def __init__(self, parent, power, isPhysical, factor, turns):
""" """
self.factor = factor
DamageDelegate.__init__(self, parent, power, isPhysical)
FixedMultiTurnDelegate.__init__(self, turns, [])
def loadFromDB(cursor, parent):
""" Loads an attack Damage Delegate from a Database """
type, id = DamageDelegateFactory.GetTypeAndID(cursor, parent.name)
if type == "BOOST ON STATUS":
power = int(element.find(Tags.powerTag).text)
isPhysical = int(element.find(Tags.physicalTag).text)
return BoostDamageOnStatusDelegate(parent, power, isPhysical)
elif type == "CORE":
parameters = ["power", "physical"]
power, physical = GetParameters(cursor, parameters,
"CoreDamageDelegate", id)
return DamageDelegate(parent, power, physical)
elif type == "EFFECT ON DAMAGE":
power = int(element.find(Tags.powerTag).text)
isPhysical = int(element.find(Tags.physicalTag).text)
return EffectOnDamageDelegate(parent, power, isPhysical)
elif type == "FIXED":
isPhysical = int(element.find(Tags.physicalTag).text)
damage = int(element.find(Tags.damageTag).text)
return FixedDelegate(parent, damage, isPhysical)
elif type == "HALF HEALTH":
isPhysical = int(element.find(Tags.physicalTag).text)
return HalfHealthDelegate(parent, isPhysical)
elif type == "LEVEL":
isPhysical = int(element.find(Tags.physicalTag).text)
return LevelDelegate(parent, isPhysical)
elif type == "NO FAINT":
parameters = ["power", "physical"]
power, physical = GetParameters(cursor, parameters,
"NoFaintDamage", id)
return NoFaintDelegate(parent, power, physical)
elif type == "ONE HIT KO":
isPhysical = int(element.find(Tags.physicalTag).text)
return OneHitDelegate(parent, isPhysical)
elif type == "PIERCE DODGE 2X":
power = int(element.find(Tags.powerTag).text)
isPhysical = int(element.find(Tags.physicalTag).text)
pierce = element.find(Tags.pierceTag).text
return PierceDodge2XDelegate(parent, power, isPhysical, pierce)
elif type == "SCALE":
power = int(element.find(Tags.powerTag).text)
isPhysical = int(element.find(Tags.physicalTag).text)
factor = int(element.find(Tags.factorTag).text)
turns = int(element.find(Tags.turnsTag).text)
return DamageScaleDelegate(parent, power, isPhysical, factor,
turns)
elif type == "STAT RATIO FIXED":
isPhysical = int(element.find(Tags.physicalTag).text)
stat = element.find(Tags.statTag).text
return StatRatioFixedDelegate(parent, isPhysical, stat)
elif type == "STAT RATIO RANGE":
isPhysical = int(element.find(Tags.physicalTag).text)
stat = element.find(Tags.statTag).text
return StatRatioRangeDelegate(parent, isPhysical, stat)
cursor.close()
def loadFromXML(element, parent):
""" Builds a DamageDelegate from XML """
delegateType = element.find(Tags.typeTag).text
if delegateType == "BOOST ON STATUS":
power = int(element.find(Tags.powerTag).text)
isPhysical = int(element.find(Tags.physicalTag).text)
return BoostDamageOnStatusDelegate(parent, power, isPhysical)
elif delegateType == "CORE":
power = int(element.find(Tags.powerTag).text)
isPhysical = int(element.find(Tags.physicalTag).text)
return DamageDelegate(parent, power, isPhysical)
elif delegateType == "EFFECT ON DAMAGE":
power = int(element.find(Tags.powerTag).text)
isPhysical = int(element.find(Tags.physicalTag).text)
return EffectOnDamageDelegate(parent, power, isPhysical)
elif delegateType == "FIXED":
isPhysical = int(element.find(Tags.physicalTag).text)
damage = int(element.find(Tags.damageTag).text)
return FixedDelegate(parent, damage, isPhysical)
elif delegateType == "HALF HEALTH":
isPhysical = int(element.find(Tags.physicalTag).text)
return HalfHealthDelegate(parent, isPhysical)
elif delegateType == "LEVEL":
isPhysical = int(element.find(Tags.physicalTag).text)
return LevelDelegate(parent, isPhysical)
elif delegateType == "NO FAINT":
power = int(element.find(Tags.powerTag).text)
isPhysical = int(element.find(Tags.physicalTag).text)
return NoFaintDelegate(parent, power, isPhysical)
elif delegateType == "ONE HIT KO":
isPhysical = int(element.find(Tags.physicalTag).text)
return OneHitDelegate(parent, isPhysical)
elif delegateType == "PIERCE DODGE 2X":
power = int(element.find(Tags.powerTag).text)
isPhysical = int(element.find(Tags.physicalTag).text)
pierce = element.find(Tags.pierceTag).text
return PierceDodge2XDelegate(parent, power, isPhysical, pierce)
elif delegateType == "SCALE":
power = int(element.find(Tags.powerTag).text)
isPhysical = int(element.find(Tags.physicalTag).text)
factor = int(element.find(Tags.factorTag).text)
turns = int(element.find(Tags.turnsTag).text)
return DamageScaleDelegate(parent, power, isPhysical, factor,
turns)
elif delegateType == "STAT RATIO FIXED":
isPhysical = int(element.find(Tags.physicalTag).text)
stat = element.find(Tags.statTag).text
return StatRatioFixedDelegate(parent, isPhysical, stat)
elif delegateType == "STAT RATIO RANGE":
isPhysical = int(element.find(Tags.physicalTag).text)
stat = element.find(Tags.statTag).text
return StatRatioRangeDelegate(parent, isPhysical, stat)
def getConfusionAttack():
""" Builds and returns the DamageDelegate used for Confusion """
attack = Attack()
attack.type = ""
return DamageDelegate(attack, 40, 1)
def __init__(self, parent, power, isPhysical, factor, turns):
""" """
self.factor = factor
DamageDelegate.__init__(self, parent, power, isPhysical)
FixedMultiTurnDelegate.__init__(self, turns, [])
def setUp(self):
""" Build the Attack and Damage Delegate """
attack = Attack()
attack.type ="FIRE"
self.delegate = DamageDelegate(attack, 0, 1)
def special(self):
""" Test that it returns correctly for physical attacks """
delegate = DamageDelegate(None, None, 0)
atkStat, defStat = delegate.getAtkAndDefType()
assert atkStat == "SATK", "Attack stat should be special"
assert defStat == "SDEF", "Defense stat should be special"
def buildDamageDelegate(self):
""" Returns a Damage Delegate """
return DamageDelegate(None, 50, 1)
