Python BuildPokemonBattleWrapper.setCurrHP方法代码示例

# 需要导入模块: from Test.test_helper import BuildPokemonBattleWrapper [as 别名]
# 或者: from Test.test_helper.BuildPokemonBattleWrapper import setCurrHP [as 别名]
class damage(unittest.TestCase):
    """ Test cases of damage """
    
    def  setUp(self):
        """ Build the Pkmn and Delegate for the test """
        self.user = BuildPokemonBattleWrapper()
        self.target = BuildPokemonBattleWrapper()
        attack = AttackFactory.getAttackAsNew("TACKLE")
        
        self.hp = 100
        self.target.setCurrHP(self.hp)
        
        self.delegate = OneHitDelegate(attack, 1)
        
    def oneHitKO(self):
        """ Test that the attack is a one-hit KO """
        self.target.setCurrHP(self.hp)
        self.target.pkmn.battleDelegate.types = ["NORMAL"]
        
        damage, messages = self.delegate.damage(self.user, self.target)
        assert damage == self.hp, "The damage should be the targets health"
        assert len(messages) == 1, "Should only get one message"
        assert messages[0] == OneHitDelegate.message, "Should get the One Hit KO message"
        
    def noDamage(self):
        """ Test that the attack does no damage when the effectiveness is 0 """
        self.target.pkmn.battleDelegate.types = ["GHOST"]
        
        damage, messages = self.delegate.damage(self.user, self.target)
        assert damage == 0, "The damage should be zero"

# 需要导入模块: from Test.test_helper import BuildPokemonBattleWrapper [as 别名]
# 或者: from Test.test_helper.BuildPokemonBattleWrapper import setCurrHP [as 别名]
class calcDamage(unittest.TestCase):
    """ Test cases of calcDamage """
    
    def  setUp(self):
        """ Build the Pkmn and Delegate for the test """
        self.user = BuildPokemonBattleWrapper()
        self.target = BuildPokemonBattleWrapper()
        
        self.delegate = HalfHealthDelegate(None, 1)
        
    def halfHealth(self):
        """ Test that the damage is Half the Health of the target """
        hp = 100
        self.target.setCurrHP(hp)
        
        damage = self.delegate.calcDamage(self.user, self.target)
        assert damage == hp/2, "Damage should be half the targets health"
        
    def halfHealthNotFloored(self):
        """ Test that the damage is Half the Health of the target """
        hp = 101
        self.target.setCurrHP(hp)
        
        damage = self.delegate.calcDamage(self.user, self.target)
        assert damage == hp/2.0, "Damage should be half the targets health, not floored"

# 需要导入模块: from Test.test_helper import BuildPokemonBattleWrapper [as 别名]
# 或者: from Test.test_helper.BuildPokemonBattleWrapper import setCurrHP [as 别名]
class heal(unittest.TestCase):
    """ Test cases of heal """
    
    def  setUp(self):
        """ Build the Pkmn and Delegate for the test """
        self.pkmn = BuildPokemonBattleWrapper()
        
        self.ratio = 2
        self.damage = 10
        self.delegate = HealByDamageRatioDelegate(self.ratio)
        
    def heal(self):
        """ Test that it heals by the ratio of the damage done """
        self.pkmn.setCurrHP(0)
        self.delegate.damage = self.damage
        self.delegate.heal(self.pkmn)
        
        hp = self.pkmn.getCurrHP()
        heal = self.damage/self.ratio
        assert hp == heal, "Should be healed by the ratio of the damage"

# 需要导入模块: from Test.test_helper import BuildPokemonBattleWrapper [as 别名]
# 或者: from Test.test_helper.BuildPokemonBattleWrapper import setCurrHP [as 别名]
class afterTurn(unittest.TestCase):
    """ Test that afterTurn works correctly """

    def setUp(self):
        """ Builds the Paralysis status"""
        self.status = Burn()
        self.pkmn = BuildPokemonBattleWrapper()

    def damage(self):
        """ Test that the damage is done correctly """
        self.pkmn.setStat("HP", 32)
        self.pkmn.setCurrHP(32)
        self.status.afterTurn(self.pkmn)
        damage = self.pkmn.getStat("HP") - self.pkmn.getCurrHP()
        assert damage == self.pkmn.getRatioOfHealth(Burn.ratio), "Damage should be Burn Ratio of Health"

    def message(self):
        """ Test that the message is returned correctly """
        messages = self.status.afterTurn(self.pkmn)
        message = self.pkmn.getHeader() + Burn.intermittent
        assert len(messages) == 1, "Should get one message"
        assert messages[0] == message, "Message should be that the Pkmn was damaged by the Burn"

# 需要导入模块: from Test.test_helper import BuildPokemonBattleWrapper [as 别名]
# 或者: from Test.test_helper.BuildPokemonBattleWrapper import setCurrHP [as 别名]
class afterTurn(unittest.TestCase):
    """ Test that afterTurn returns correctly """

    def setUp(self):
        """ Builds the Pkmn and the Leech Effect """
        self.pkmn = BuildPokemonBattleWrapper()

        self.message = " hurt."
        self.pkmn2 = BuildPokemonBattleWrapper()
        self.leech = Leech(self.pkmn2, self.message)

    def message(self):
        """ Test the message is correct """
        message = self.leech.afterTurn(self.pkmn)
        assert message == [
            self.pkmn.getHeader() + self.message
        ], "Message should be the pokemon's name and the message given to the Leech."

    def faint(self):
        """ Test that the messsages returned when the target faints """
        self.pkmn.setCurrHP(self.leech.getAmount(self.pkmn))
        messages = self.leech.afterTurn(self.pkmn)
        assert len(messages) == 2, "Should have 2 messages"
        assert messages[1] == self.pkmn.getHeader() + Faint.start, "Should have a faint message."

# 需要导入模块: from Test.test_helper import BuildPokemonBattleWrapper [as 别名]
# 或者: from Test.test_helper.BuildPokemonBattleWrapper import setCurrHP [as 别名]
class effectOnMiss(unittest.TestCase):
    """ Test cases of effectOnMiss """
    
    def  setUp(self):
        """ Build the Pkmn and Delegate for the test """
        self.pkmn = BuildPokemonBattleWrapper()
        self.attack = BuildAttack()
        
        self.damage, messages = self.attack.damageDelegate.damage(self.pkmn, self.pkmn)
        
        self.ratio = 2
        self.delegate = CrashDelegate(self.attack, self.ratio)
        
    def recoil(self):
        """ Test that recoil damage is done """
        self.pkmn.setCurrHP(self.damage*2)
        self.delegate.effectOnMiss(self.pkmn, self.pkmn, None)
        
        damageDone = self.damage*2 - self.pkmn.getCurrHP()
        damage = self.damage/self.ratio
        assert damageDone == damage or damageDone == 2*damage, "Should do damage over ratio as damage"
        
    def message(self):
        """ Test that the message returned is correct """
        self.pkmn.setCurrHP(self.damage)
        self.delegate.damage = self.damage
        messages = self.delegate.effectOnMiss(self.pkmn, self.pkmn, None)

        message = CrashDelegate.message % self.pkmn.getHeader()
        assert len(messages) == 1, "Should get one message"
        assert messages[0] == message, "Message should be Pkmn's header and the Delegate's message"
        
    def faints(self):
        """ Test that the message is correct when the Pkmn faints """
        self.pkmn.setCurrHP(1)
        self.delegate.damage = self.damage
        messages = self.delegate.effectOnMiss(self.pkmn, self.pkmn, None)

        faintMessage = self.pkmn.getHeader() + Faint.start
        assert len(messages) == 2, "Should get 2 messages"
        assert messages[1] == faintMessage, "Message should be that the Pkmn Fainted"

# 需要导入模块: from Test.test_helper import BuildPokemonBattleWrapper [as 别名]
# 或者: from Test.test_helper.BuildPokemonBattleWrapper import setCurrHP [as 别名]
class afterTurn(unittest.TestCase):
    """ Test that afterTurn returns correctly """
    
    def setUp(self):
        """ Builds the side and trap """
        self.source = BuildPokemonBattleWrapper()
        self.pkmn = BuildPokemonBattleWrapper()
        
        self.message = " hurt."
        self.doneMessage = " done."
        self.trap = Trap(None, self.message, self.doneMessage)
    
    def turnDecreases(self):
        """ Test the turn counter decreases """
        self.trap.turns = 5
        turns = self.trap.turns
        self.trap.afterTurn(self.pkmn)
        assert self.trap.turns == turns - 1, "Turns should decrement"
        
    def effectIsRemoved(self):
        """ Test that the effect is removed when the turn count is reduced to zero """
        self.trap.turns = 1
        self.pkmn.secondaryEffects.append(self.trap)
        self.trap.afterTurn(self.pkmn)
        
        assert self.trap.turns == 0, "Turns should be zero"
        assert not self.trap in self.pkmn.secondaryEffects
        
    def message(self):
        """ Test the message is correct """
        message = self.trap.afterTurn(self.pkmn)
        assert message == [self.pkmn.getHeader() + self.message], "Message should be the pokemon's name and the message given to the Trap."
        
    def doneMessage(self):
        """ Test the done message is correct """
        self.trap.turns = 1
        self.pkmn.secondaryEffects.append(self.trap)
        messages = self.trap.afterTurn(self.pkmn)
        
        assert len(messages) == 2, "Should have two messages"
        assert messages[1] == self.pkmn.getHeader() + self.doneMessage, "Done message should be returned."
        
    def faintMessage(self):
        """ Test the faint message appears if the Pkmn faints """
        self.trap.turns = 3
        self.pkmn.setCurrHP(self.trap.getDamage(self.pkmn))
        
        self.pkmn.secondaryEffects.append(self.trap)
        messages = self.trap.afterTurn(self.pkmn)
        
        assert len(messages) == 2, "Should have two messages"
        assert messages[1] == self.pkmn.getHeader() + Faint.start, "Pkmn should have fainted."
    
    def faintAndDoneMessage(self):
        """ Test the done message is correct """
        self.trap.turns = 1
        self.pkmn.setCurrHP(self.trap.getDamage(self.pkmn))
        
        self.pkmn.secondaryEffects.append(self.trap)
        messages = self.trap.afterTurn(self.pkmn)
        
        assert len(messages) == 2, "Should have two messages"
        assert messages[1] == self.pkmn.getHeader() + Faint.start, "Pkmn should have fainted."