def test_damage_points_and_health_increased_without_cards(self):
advanced = Advanced("test")
beginner = Beginner("test2")
bf = BattleField()
bf.fight(advanced, beginner)
self.assertEqual(advanced.health, 250)
self.assertEqual(beginner.health, 90)
def test_fight_attacker_or_enemy_is_dead_zero_raises(self):
self.assertEqual(50, self.attacker.health)
self.assertEqual(50, self.enemy.health)
self.enemy.health = 0
with self.assertRaises(ValueError) as ex:
BattleField.fight(self.attacker, self.enemy)
self.assertEqual("Player is dead!", str(ex.exception))
def test_beginner_health_increase(self):
a = Advanced('attacker')
e = Beginner('enemy')
self.assertEqual(50, e.health)
bf = BattleField()
bf.fight(a, e)
self.assertEqual(90, e.health)
class BattleFieldTests(unittest.TestCase):
def setUp(self):
self.battlefield = BattleField()
def test_fight__when_at_least_one_player_is_dead_expect_value_error(self):
attacker = Advanced("aragorn")
enemy = Beginner("orc")
enemy.is_dead = True
with self.assertRaises(ValueError) as err:
self.battlefield.fight(attacker, enemy)
self.assertEqual("Player is dead!", str(err.exception))
def test_fight__expect_players_health_and_card_damage_points_to_change(
self):
attacker = Advanced("aragorn")
sword = TrapCard("sword")
attacker.card_repository.add(sword)
enemy = Beginner("orc")
axe = TrapCard("axe")
enemy.card_repository.add(axe)
self.battlefield.fight(attacker, enemy)
# before attack:
# enemy health = 50 + 40; enemy card damage points = 120 + 30 --> beginner
# enemy health = 90 + 5
# attacker health = 250 + 5
# after attack:
# enemy health = 95 - 120 --> value error
# attacker health = 255 - 150
self.assertEqual(95, enemy.health)
self.assertEqual(105, attacker.health)
self.assertEqual(150, axe.damage_points)
self.assertEqual(120, sword.damage_points)
def test_fight_attacker_is_beginner(self):
self.assertEqual(50, self.attacker.health)
self.assertEqual(50, self.enemy.health)
self.enemy.health += 110
BattleField.fight(self.attacker, self.enemy)
self.assertEqual(345, self.attacker.health)
self.assertEqual(0, self.enemy.health)
def fight(self, attack_name, enemy_name):
attacker = self.player_repository.find(attack_name)
enemy = self.player_repository.find(enemy_name)
battle_field = BattleField()
battle_field.fight(attacker, enemy)
return f"Attack user health {attacker.health} - Enemy user health {enemy.health}"
def test_dmg_and_hp_without_cards(self):
advanced = Advanced('test')
beginner = Beginner('test2')
battlefield = BattleField()
battlefield.fight(advanced, beginner)
self.assertEqual(advanced.health, 250)
self.assertEqual(beginner.health, 90)
def test_fight_attacker_is_dead(self):
attacker = Advanced("Test1")
enemy = Advanced("Test2")
attacker.health = 0
with self.assertRaises(ValueError):
BattleField.fight(attacker, enemy)
def setUp(self) -> None:
self.battle_field = BattleField()
self.player1 = Advanced('John')
self.player2 = Beginner('Mike')
self.player1.card_repository.add(MagicCard('MagicCard1'))
self.player1.card_repository.add(TrapCard('TrapCard1'))
self.player2.card_repository.add(MagicCard('MagicCard2'))
self.player2.card_repository.add(TrapCard('TrapCard2'))
def test_attacker_is_dead(self):
p1 = Advanced("test")
p1.health = 0
p2 = Advanced("test2")
bf = BattleField()
with self.assertRaises(ValueError) as ex:
bf.fight(p1, p2)
self.assertEqual(str(ex.exception), "Player is dead!")
def setUp(self):
self.attacker = Advanced('I am attacker')
mc = MagicCard('carte non-magique')
self.attacker.card_repository.add(mc)
self.enemy = Beginner('I am enemy')
mc1 = MagicCard('catre magique')
self.enemy.card_repository.add(mc1)
self.battlefield = BattleField()
def test_att_is_dead(self):
advanced = Advanced('test')
advanced.health = 0
advanced2 = Advanced('test2')
battlefield = BattleField()
with self.assertRaises(ValueError) as cm:
battlefield.fight(advanced, advanced2)
self.assertEqual('Player is dead!', str(cm.exception))
def test_enemy_is_dead(self):
advanced = Advanced("test")
advanced_2 = Advanced("test2")
advanced_2.health = 0
bf = BattleField()
with self.assertRaises(ValueError) as ex:
bf.fight(advanced, advanced_2)
self.assertEqual(str(ex.exception), "Player is dead!")
def test_fight_with_dead_player_should_raise_error(self):
bf = BattleField()
p1 = Beginner("Peter")
p2 = Beginner("George")
p1.health = 0
with self.assertRaises(ValueError) as cm:
bf.fight(p1, p2)
self.assertEqual(str(cm.exception), "Player is dead!")
def test_player_is_dead(self):
a = Advanced('attacker')
e = Beginner('enemy')
a.health = 0
bf = BattleField()
with self.assertRaises(ValueError) as ex:
bf.fight(a, e)
self.assertEqual(str(ex.exception), "Player is dead!")
def setUp(self):
self.battle_field = BattleField()
self.beginner_player = Beginner("KOZA_BEGINNER")
self.advanced_player = Advanced("KOZA_ADVANCED")
self.new_trap_card = TrapCard("KOZA_TRAP")
self.new_magic_card = MagicCard("KOZA_MAGIC")
self.beginner_player.card_repository.add(self.new_trap_card)
self.advanced_player.card_repository.add(self.new_magic_card)
def fight(self, attack_name, enemy_name):
attacker = self.player_repository.find(attack_name)
enemy = self.player_repository.find(enemy_name)
if not attacker or not enemy: return
BattleField.fight(attacker, enemy)
return f'Attack user health {attacker.health} - Enemy user health {enemy.health}'
def test_fight(self):
pl1 = Beginner('beg1')
pl2 = Beginner('beg2')
self.ctrl.player_repository.add(pl1)
self.ctrl.player_repository.add(pl2)
battlefield = BattleField()
battlefield.fight(pl1, pl2)
res = self.ctrl.fight('beg1', 'beg2')
self.assertEqual('Attack user health 130 - Enemy user health 130', res)
def fight(self, attack_name: str, enemy_name: str):
# The attacker and the enemy start a fight in a battlefield. The method should return the following message:
# "Attack user health {attacker_health_left} - Enemy user health {enemy_health_left}"
attacker = self.player_repository.find(attack_name)
enemy = self.player_repository.find(enemy_name)
battle_field = BattleField()
battle_field.fight(attacker, enemy)
return f'Attack user health {attacker.health} - Enemy user health {enemy.health}'
def test_bonus(self):
a = Advanced('attacker')
e = Beginner('enemy')
c = MagicCard('magic')
a.card_repository.add(c)
self.assertEqual(a.health, 250)
bf = BattleField()
bf.fight(a, e)
self.assertEqual(a.health, 330)
def test_enemy_beginner_should_increase_attributes(self):
bf = BattleField()
p1 = Beginner("Peter")
p2 = Beginner("George")
mg1 = MagicCard("Magic One")
mg2 = MagicCard("Magic Two")
p2.card_repository.add(mg1)
p2.card_repository.add(mg2)
bf.fight(p2, p1)
self.assertEqual(p2.health, 250)
def test_fight_logic_is_dead(self):
a = Advanced('attacker')
e = Beginner('enemy')
c = TrapCard('trap')
a.card_repository.add(c)
bf = BattleField()
with self.assertRaises(ValueError) as ex:
bf.fight(a, e)
self.assertEqual(str(ex.exception),
'Player\'s health bonus cannot be less than zero.')
def test_fight_increase_health(self):
attacker = Advanced("Bushido")
enemy = Advanced("Onyx")
card = TrapCard("Exodia")
attacker.card_repository.cards.append(card)
enemy.card_repository.cards.append(card)
BattleField.fight(attacker, enemy)
self.assertEqual(135, attacker.health)
self.assertEqual(135, enemy.health)
self.assertFalse(attacker.is_dead)
self.assertFalse(enemy.is_dead)
def test_health_increased_from_cards(self):
advanced = Advanced("test")
beginner = Beginner("test2")
bf = BattleField()
mc = MagicCard("testmagic")
advanced.card_repository.add(mc)
tc = TrapCard("testtrap")
beginner.card_repository.add(tc)
bf.fight(advanced, beginner)
self.assertEqual(advanced.health, 180)
self.assertEqual(beginner.health, 90)
def test_dmg_and_hp_with_cards(self):
advanced = Advanced('test')
beginner = Beginner('test2')
battlefield = BattleField()
magic_card = MagicCard('Light')
trap_card = TrapCard('TRAP')
advanced.card_repository.add(magic_card)
beginner.card_repository.add(trap_card)
battlefield.fight(advanced, beginner)
self.assertEqual(advanced.health, 180)
self.assertEqual(beginner.health, 90)
def test_dead_player_while_fighing(self):
advanced = Advanced("test")
beginner = Beginner("test2")
mc = MagicCard('testmagic')
tc = TrapCard("testtrap")
tc2 = TrapCard("testtrap1")
advanced.card_repository.add(tc)
advanced.card_repository.add(tc2)
bf = BattleField()
beginner.card_repository.add(mc)
with self.assertRaises(ValueError) as ex:
bf.fight(advanced, beginner)
self.assertEqual(str(ex.exception),
"Player's health bonus cannot be less than zero.")
def test_fight_one_player_dies_valid_data_should_work_correctly(self):
battlefield = BattleField()
attacker = Advanced("Dave")
enemy = Beginner("John")
common_card = MagicCard("Magic")
attacker.card_repository.cards.append(common_card)
enemy.card_repository.cards.append(common_card)
enemy.take_damage(50)
with self.assertRaises(ValueError):
battlefield.fight(attacker, enemy)
class TestBattleField(unittest.TestCase):
def setUp(self) -> None:
self.battle_field = BattleField()
self.player1 = Advanced('John')
self.player2 = Beginner('Mike')
self.player1.card_repository.add(MagicCard('MagicCard1'))
self.player1.card_repository.add(TrapCard('TrapCard1'))
self.player2.card_repository.add(MagicCard('MagicCard2'))
self.player2.card_repository.add(TrapCard('TrapCard2'))
def test_fight_method(self) -> None:
self.battle_field.fight(self.player1, self.player2)
self.assertEqual(self.player1.health, 150)
self.assertEqual(self.player2.health, 50)
def test_players_health_is_increased(self):
attacker = Advanced("Test1")
enemy = Advanced("Test2")
card = TrapCard("TrapTest")
attacker.card_repository.add(card)
enemy.card_repository.add(card)
self.assertEqual(attacker.health, 250)
self.assertEqual(enemy.health, 250)
BattleField.fight(attacker, enemy)
self.assertEqual(attacker.health, 135)
self.assertEqual(enemy.health, 135)
self.assertFalse(attacker.is_dead)
self.assertFalse(enemy.is_dead)
class Controller:
player_repository: PlayerRepository
card_repository: CardRepository
def __init__(self) -> None:
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
self.battle_field = BattleField()
def add_player(self, player_type: str, username: str) -> str:
player_types = {
'Beginner': Beginner,
'Advanced': Advanced
}
player = player_types[player_type](username)
self.player_repository.add(player)
return f'Successfully added player of type {player_type} with username: {username}'
def add_card(self, card_type: str, name: str) -> str:
card_types = {
'Magic': MagicCard,
'Trap': TrapCard,
}
card = card_types[card_type](name)
self.card_repository.add(card)
return f'Successfully added card of type {card_type}Card with name: {name}'
def add_player_card(self, username: str, card_name: str) -> Optional[str]:
player = self.player_repository.find(username)
card = self.card_repository.find(card_name)
if not (player and card):
return
player.card_repository.add(card)
return f'Successfully added card: {card_name} to user: {username}'
def fight(self, attack_name: str, enemy_name: str) -> Optional[str]:
attacker = self.player_repository.find(attack_name)
enemy = self.player_repository.find(enemy_name)
if not (attacker and enemy):
return
self.battle_field.fight(attacker, enemy)
return f'Attack user health {attacker.health} - Enemy user health {enemy.health}'
def report(self):
return '\n'.join([str(p) for p in self.player_repository.players])
