def test_add_existing_player_should_raise_error(self):
repo = PlayerRepository()
player = Advanced("Peter")
repo.players.append(player)
with self.assertRaises(ValueError) as cm:
repo.add(player)
self.assertEqual(str(cm.exception), "Player Peter already exists!")
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
def add_player(self, player_type: str, username: str):
player = Advanced(username) if player_type == 'Advance' else Beginner(
username)
self.player_repository.add(player)
return f'Successfully add player of type{player_type} with username {username}'
def add_card(self, card_type: str, name: str):
card = MagicCards(name) if card_type == "Magic" else TrapCard(name)
self.card_repository.add(card)
return f"Successfully added cart of type {card_type}Card with name {name}"
def add_player_card(self, username: str, card_name: str):
player = self.player_repository.find(username)
card = self.card_repository.find(card_name)
player.card_repository.add(card)
return f"Successfully added card: {card_name} to user {username}"
def fight(self, attacker_name: str, enemy_name: str):
attacker = self.player_repository.find(attacker_name)
enemy = self.player_repository.find(enemy_name)
BattleField.fight(attacker, enemy)
return f"Attack user health {attacker.health} - Enemy user health {enemy.health}"
def report(self):
result = ''
for player in self.player_repository.players:
result += f"Username: {player.username} - Health {player.health} - Cards {player.card_repository.count}\n"
for card in player.card_repository.cards:
result += f"### Carde: {card.name} - Damage: {card.damage_points}\n"
return result
def test_add_method_raise_ex_when_card_already_exist(self):
with self.assertRaises(Exception) as ex:
player_repository = PlayerRepository()
beginner = Beginner('test')
player_repository.add(beginner)
player_repository.add(beginner)
self.assertIsNotNone(ex.exception)
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
@staticmethod
def check_player_type(type_):
if type_ == 'Beginner':
return Beginner
return Advanced
@staticmethod
def check_card_type(type_):
if type_ == 'MagicCard':
return MagicCard
return TrapCard
def add_player(self, type_: str, username: str):
player = self.check_player_type(type_)(username)
self.player_repository.add_player(player)
return f"Successfully added player of type {type_} with username: {username}"
def add_card(self, type_, name):
card = self.check_card_type(type_)(name)
self.card_repository.add_card(card)
return f"Successfully added card of type {type_}Card with name: {name}"
def add_player_card(self, username: str, card_name: str):
player = self.player_repository.find_player(username)
card = self.card_repository.find_card(card_name)
player.card_repository.add_card(card)
return f"Successfully added card: {card_name} to user: {username}"
def fight(self, attack_name, enemy_name):
attacker = self.player_repository.find_player(attack_name)
enemy = self.player_repository.find_player(enemy_name)
BattleField.fight(attacker, enemy)
return f"Attack user health {attacker.health} - Enemy user health {enemy.health}"
def report(self):
result = ''
for player in self.player_repository.players:
result += f'Username: {player.username} - Health: {player.health} - Cards {player.card_repository.count}\n'
for card in player.card_repository.cards:
result += f'### Card: {card.name} - Damage: {card.damage_points}\n'
return result
# controller = Controller()
# controller.add_player('Beginner', 'b')
# controller.add_card('MagicCard', 'm')
# controller.add_player_card('b', 'm')
# print(controller.report())
# controller.add_player('Advanced', 'BogDan')
# controller.add_card('TrapCard', 'Sila')
# controller.add_player_card('BogDan', 'Sila')
# print(controller.report())
# print(controller.fight('BogDan', 'b'))
# print(controller.report())
def setUp(self) -> None:
# self.card1 = Advanced("Test")
# self.card2 = MagicCard("Test2")
# self.card3 = MagicCard("Test")
self.player1 = Advanced("Test")
self.player2 = Advanced("Test2")
self.player3 = Advanced("Test")
self.repository = PlayerRepository()
def test_add_count_valid_data_should_work_correctly(self):
repository = PlayerRepository()
player = Beginner("Dave")
repository.add(player)
self.assertEqual(repository.count, 1)
def test_add_player(self):
r = PlayerRepository()
self.assertEqual(len(r.players), 0)
self.assertEqual(r.count, 0)
player = Advanced("Test")
r.add(player)
self.assertEqual(len(r.players), 1)
self.assertEqual(r.count, 1)
def test_add(self):
repo = PlayerRepository()
p = Advanced('test')
self.assertEqual(0, len(repo.players))
self.assertEqual(0, repo.count)
repo.add(p)
self.assertEqual(1, len(repo.players))
self.assertEqual(1, repo.count)
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
def add_player(self, type: str, username: str):
player = None
if type == "Beginner":
player = Beginner(username)
else:
player = Advanced(username)
self.player_repository.add(player)
return f"Successfully added player of type {type} with username: {username}"
def add_card(self, type: str, name: str):
card = None
if type == "Magic":
card = MagicCard(name)
else:
card = TrapCard(name)
self.card_repository.add(card)
return f"Successfully added card of type {type}Card with name: {name}"
def add_player_card(self, username: str, card_name: str):
player = self.player_repository.find(username)
card = self.card_repository.find(card_name)
player.card_repository.add(card)
return f"Successfully added card: {card_name} to user: {username}"
def fight(self, attack_name: str, enemy_name: str):
battlefield = BattleField()
attacker = self.player_repository.find(attack_name)
enemy = self.player_repository.find(enemy_name)
battlefield.fight(attacker, enemy)
return f"Attack user health {attacker.health} - Enemy user health {enemy.health}"
def report(self):
result = ''
for player in self.player_repository.players:
result += f'Username: {player.username} - Health: {player.health} - Cards {len(player.card_repository.cards)}\n'
for card in player.card_repository.cards:
result += f'### Card: {card.name} - Damage: {card.damage_points}\n'
return result
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
def add_player(self, type, username):
if type == 'Beginner':
new = Beginner(username)
else:
new = Advanced(username)
self.player_repository.add(new)
return f'Successfully added player of type {type} with username: {username}'
def add_card(self, type, name):
if type == 'Magic':
new = MagicCard(name)
else:
new = TrapCard(name)
self.card_repository.add(new)
return f'Successfully added card of type {type}Card with name: {name}'
def add_player_card(self, username, card_name):
card = self.card_repository.find(card_name)
player = self.player_repository.find(username)
if not card or not player: return
player.card_repository.add(card)
return f'Successfully added card: {card.name} to user: {username}'
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 report(self):
result = f''
for player in self.player_repository.players:
result += f'Username: {player.username} - Health: {player.health} - ' \
f'Cards {player.card_repository.count}\n'
result += "".join(f'### Card: {card.name} - Damage: {card.damage_points}\n'
for card in player.card_repository.cards)
return result
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
@staticmethod
def check_player_type(type):
if type == Beginner:
return Beginner
else:
return Advanced
def add_player(self, type: str, username: str):
p_type = self.check_player_type(type)
player = p_type(username)
self.player_repository.add_player(player)
return f"Successfully added player of type {type} with username: {username}"
@staticmethod
def check_card_type(type):
if type == MagicCard:
return MagicCard
else:
return TrapCard
def add_card(self, type: str, name: str):
c_type = self.check_card_type(type)
card = c_type(name)
self.card_repository.cards.append(card)
return "Successfully added card of type {type}Card with name: {name}"
def find_player(self, name):
for player in self.player_repository.players:
if player.username == name:
return player
def find_card(self, name):
for card in self.card_repository.cards:
if card.name == name:
return card
def add_player_card(self, username: str, card_name: str):
player = self.find_player(username)
card = self.find_card(card_name)
player.card_repository.cards.append(card)
return "Successfully added card of type {type}Card with name: {name}"
def fight(self, player_one, player_two):
BattleField.fight(player_one, player_two)
return f"Attack user health {player_one.health} - Enemy user health {player_two.health}"
def test_find(self):
r = PlayerRepository()
self.assertEqual(len(r.players), 0)
self.assertEqual(r.count, 0)
player = Advanced("Test")
r.add(player)
self.assertEqual(len(r.players), 1)
self.assertEqual(r.count, 1)
founded = r.find("Test")
self.assertEqual(founded.username, player.username)
self.assertEqual(founded.health, player.health)
self.assertEqual(founded, player)
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
def add_player(self, type, username):
# global player_to_add
if type == "Beginner":
player_to_add = Beginner(username)
elif type == "Advanced":
player_to_add = Advanced(username)
self.player_repository.add(player_to_add)
return f"Successfully added player of type {type} with username: {username}"
def add_card(self, type, name):
# global card_to_add
if type == "Magic":
card_to_add = MagicCard(name)
elif type == "Trap":
card_to_add = TrapCard(name)
self.card_repository.add(card_to_add)
return f"Successfully added card of type {type}Card with name: {name}"
def add_player_card(self, username, card_name):
player = self.player_repository.find(username)
card = self.card_repository.find(card_name)
player.card_repository.add(card)
return f"Successfully added card: {card_name} to user: {username}"
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 report(self):
result = ''
for player in self.player_repository.players:
result += f"Username: {player.username} - Health: {player.health} - Cards {player.card_repository.count}\n"
for card in player.card_repository.cards:
result += f"### Card: {card.name} - Damage: {card.damage_points}\n"
return result
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
@staticmethod
def create_player(player_type, username):
if player_type == "Beginner":
return Beginner(username)
if player_type == "Advanced":
return Advanced(username)
@staticmethod
def create_card(card_type, name):
if card_type == "Magic":
return MagicCard(name)
if card_type == "Trap":
return TrapCard(name)
def add_player(self, type: str, username: str):
player = self.create_player(type, username)
self.player_repository.add(player)
return f"Successfully added player of type {type} with username: {username}"
def add_card(self, type: str, name: str):
card = self.create_card(type, name)
self.card_repository.add(card)
return f"Successfully added card of type {type}Card with name: {name}"
def add_player_card(self, username: str, card_name: str):
player = self.player_repository.find(username)
card = self.card_repository.find(card_name)
player.card_repository.add(card)
return f"Successfully added card: {card_name} to user: {username}"
def fight(self, attack_name: str, enemy_name: str):
attacker = self.player_repository.find(attack_name)
enemy = self.player_repository.find(enemy_name)
battlefield = BattleField()
battlefield.fight(attacker, enemy)
return f"Attack user health {attacker.health} - Enemy user health {enemy.health}"
def report(self):
result = []
for player in self.player_repository.players:
pl_result = f"Username: {player.username} - Health: {player.health} - Cards {player.card_repository.count}"
for card in player.card_repository.cards:
pl_result += f"\n### Card: {card.name} - Damage: {card.damage_points}"
result.append(pl_result)
return '\n'.join(result)
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])
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
def add_player(self, type: str, username: str):
if type == 'Beginner':
player = Beginner(username)
self.player_repository.players.append(player)
else:
player = Advanced(username)
self.player_repository.players.append(player)
return f"Successfully added player of type {type} with username: {username}"
def add_card(self, type: str, name: str):
if type == 'Magic':
card = MagicCard(name)
self.card_repository.cards.append(card)
else:
card = TrapCard(name)
self.card_repository.cards.append(card)
return f"Successfully added card of type {type} with name: {name}"
def add_player_card(self, username: str, card_name: str):
user = self.player_repository.find(username)
card = self.card_repository.find(card_name)
user.card_repository.add(card)
return f"Successfully added card: {card_name} to user: {username}"
def fight(self, attack_name: str, enemy_name: str):
a = self.player_repository.find(attack_name)
e = self.player_repository.find(enemy_name)
BattleField.fight(a, e)
return f"Attack user health {a.health} - Enemy user health {e.health}"
def report(self):
result = ""
for user in self.player_repository.players:
result += f"Username: {user.username} - Health: {user.health} - Cards {user.card_repository.count}\n"
for card in user.card_repository.cards:
result += f"### Card: {card.name} - Damage: {card.damage_points}\n"
return result
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
def add_player(self, type: str, username: str):
player = Beginner(username) if type == "Beginner" else Advanced(
username)
self.player_repository.add(player)
return f"Successfully added player of type {type} with username: {username}"
def add_card(self, type: str, name: str):
card = MagicCard(name) if type == 'Magic' else TrapCard(name)
self.card_repository.add(card)
return f"Successfully added card of type {type}Card with name: {name}"
def add_player_card(self, username: str, card_name: str):
player = self.player_repository.find(username)
card = self.card_repository.find(card_name)
player.card_repository.add(card)
return f"Successfully added card: {card_name} to user: {username}"
def fight(self, attack_name: str, enemy_name: str):
attacker = self.player_repository.find(attack_name)
enemy = self.player_repository.find(enemy_name)
battlefield = BattleField()
battlefield.fight(attacker, enemy)
return f"Attack user health {attacker.health} - Enemy user health {enemy.health}"
def report(self):
# result = []
# for player in self.player_repository.players:
# result.append(str(player))
# for card in player.card_repository.cards:
# result.append(f"### {str(card)}")
# return '\n'.join(result)
result = ""
for player in self.player_repository.players:
result += f"Username: {player.username} - Health: {player.health} - Cards {len(player.card_repository.cards)}\n"
for card in player.card_repository.cards:
result += f"### Card: {card.name} - Damage: {card.damage_points}\n"
return result
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
def add_player(self, type_p: str, username: str):
if type_p == 'Beginner':
player = Beginner(username)
else:
player = Advanced(username)
self.player_repository.add(player)
return f"Successfully added player of type {type_p} with username: {username}"
def add_card(self, type_c: str, name: str):
if type_c == "Magic":
card = MagicCard(name)
else:
card = TrapCard(name)
self.card_repository.add(card)
return f"Successfully added card of type {type_c}Card with name: {name}"
def add_player_card(self, username: str, card_name: str):
player = self.player_repository.find(username)
card = self.card_repository.find(card_name)
player.card_repository.add(card)
return f"Successfully added card: {card_name} to user: {username}"
def fight(self, attack_name: str, enemy_name: str):
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 report(self):
result = ""
for p in self.player_repository.players:
result += f"Username: {p.username} - Health: {p.health} - Cards {p.card_repository.count}\n"
for c in p.card_repository.cards:
result += f"### Card: {c.name} - Damage: {c.damage_points}\n"
return result
class TestPlayerRepository(unittest.TestCase):
def setUp(self):
self.repository = PlayerRepository()
self.beginner = Beginner('John')
def test_if_init_is_set_properly(self):
expected_count = 0
expected_players = []
self.assertEqual(expected_count, self.repository.count)
self.assertEqual(expected_players, self.repository.players)
def test_if_add_function_raises_value_error_if_player_is_already_in_list(self):
self.repository.players = [self.beginner]
with self.assertRaises(ValueError) as context_manager:
self.repository.add(self.beginner)
expected_message = f"Player John already exists!"
self.assertEqual(expected_message, str(context_manager.exception))
def test_if_add_function_appends_and_increases_count(self):
self.repository.add(self.beginner)
expected_result_for_players_list = [self.beginner]
expected_result_for_count = 1
self.assertEqual(expected_result_for_count, self.repository.count)
self.assertEqual(expected_result_for_players_list, self.repository.players)
def test_if_remove_function_raises_value_error(self):
expected_result = "Player cannot be an empty string!"
with self.assertRaises(ValueError) as context_manager:
self.repository.remove('')
self.assertEqual(expected_result, str(context_manager.exception))
def test_if_remove_function_removes_player_and_decreases_count(self):
self.repository.players = [self.beginner]
self.repository.count = 1
self.repository.remove('John')
expected_count = 0
expected_list = []
self.assertEqual(expected_count, self.repository.count)
self.assertEqual(expected_list, self.repository.players)
def test_if_find_function_works(self):
self.repository.players = [self.beginner]
result = self.repository.find('John')
expected_result = self.beginner
self.assertEqual(expected_result, result)
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.cards_repository = CardRepository()
def add_player(self, type, username):
if type == 'Beginner':
p = Beginner(username)
elif type == 'Advanced':
p = Advanced(username)
self.player_repository.add(p)
return f"Successfully added player of type {type} with username: {username}"
def add_card(self, type, name):
if type == 'Magic':
c = MagicCard(name)
elif type == 'Trap':
c = TrapCard(name)
self.cards_repository.add(c)
return f"Successfully added card of type {type}Card with name: {name}"
def add_player_card(self, username: str, card_name: str):
card = self.cards_repository.find(card_name)
user = self.player_repository.find(username)
user.card_repositoy.add(card)
return f"Successfully added card: {card_name} to user: {username}"
def fight(self, attack_name: str, enemy_name: str):
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 report(self):
text = ''
for p in self.player_repository.players:
text += f'Username: {p.username} - Health: {p.health} - Cards {p.card_repository.count}\n'
for c in p.card_repository:
text += f'Card: {c.name} - Damage: {c.damage_points}'
return text
def test_add_raises(self):
repo = PlayerRepository()
p = Advanced('test')
repo.add(p)
with self.assertRaises(ValueError) as ex:
repo.add(p)
self.assertEqual(str(ex.exception), "Player test already exists!")
def test_add_method_add_card_when_unique(self):
player_repo = PlayerRepository()
beginner = Beginner('test')
beginner2 = Beginner('test2')
player_repo.add(beginner)
player_repo.add(beginner2)
self.assertEqual(2, player_repo.count)
def test_remove_non_existing_should_raise_error(self):
repository = PlayerRepository()
player = Beginner("Dave")
repository.add(player)
repository.remove("Gosho")
def test_remove_valid_data_second_time_should_raise_error(self):
repository = PlayerRepository()
player = Beginner("Dave")
repository.add(player)
with self.assertRaises(ValueError):
repository.remove("")
class Controller:
def __init__(self) -> None:
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
def add_player(self, type, username):
if type == 'Beginner':
p = Beginner(username)
self.player_repository.add(p)
return f'Successfully added player of type {type} with username: {username}'
p = Advanced(username)
self.player_repository.add(p)
return f'Successfully added player of type {type} with username: {username}'
def add_card(self, type, name):
if type == 'Magic':
magic_c = MagicCard(name)
self.card_repository.add(magic_c)
return f'Successfully added card of type {type}Card with name: {name}'
trap_c = TrapCard(name)
self.card_repository.add(trap_c)
return f'Successfully added card of type {type}Card with name: {name}'
def add_player_card(self, username, card_name):
card = [c for c in self.card_repository.cards if c.name == card_name][0]
for pl in self.player_repository.players:
if pl.username == username:
pl.card_repository.add(card)
return f'Successfully added card: {card_name} to user: {username}'
def fight(self, attack_name, enemy_name):
enemy = self.player_repository.find(attack_name)
attacker = 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 report(self):
message = f''
for pl in self.player_repository.players:
message += f'Username: {pl.username} - Health: {pl.health} - Cards {pl.card_repository.count}\n'
for card in pl.card_repository.cards:
message += f'### Card: {card.name} - Damage: {card.damage_points}\n'
return message
def test_remove_valid_data_should_work_correctly(self):
repository = PlayerRepository()
player = Advanced("Dave")
repository.add(player)
self.assertEqual(repository.count, 1)
repository.remove("Dave")
self.assertEqual(repository.count, 0)
self.assertEqual(len(repository.players), 0)
def test_remove_player(self):
r = PlayerRepository()
self.assertEqual(len(r.players), 0)
self.assertEqual(r.count, 0)
player = Advanced("Test")
r.add(player)
self.assertEqual(len(r.players), 1)
self.assertEqual(r.count, 1)
r.remove(player.username)
self.assertEqual(len(r.players), 0)
self.assertEqual(r.count, 0)
def test_add_existing_player_raises(self):
r = PlayerRepository()
self.assertEqual(len(r.players), 0)
self.assertEqual(r.count, 0)
player = Advanced("Test")
r.add(player)
self.assertEqual(len(r.players), 1)
self.assertEqual(r.count, 1)
with self.assertRaises(ValueError):
r.add(player)
self.assertEqual(len(r.players), 1)
self.assertEqual(r.count, 1)
def test_remove_empty_player_name_raises(self):
r = PlayerRepository()
self.assertEqual(len(r.players), 0)
self.assertEqual(r.count, 0)
player = Advanced("Test")
r.add(player)
self.assertEqual(len(r.players), 1)
self.assertEqual(r.count, 1)
with self.assertRaises(ValueError):
r.remove("")
self.assertEqual(len(r.players), 1)
self.assertEqual(r.count, 1)
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
def add_player(self, type: str, username: str):
result = ""
if type == "Beginner":
new_player = Beginner(username)
self.player_repository.add(new_player)
result = f"Successfully added player of type {type} with username: {username}"
if type == "Advanced":
new_player = Advanced(username)
self.player_repository.add(new_player)
result = f"Successfully added player of type {type} with username: {username}"
return result
def add_card(self, type: str, name: str):
result = ""
if type == "Magic":
new_card = MagicCard(name)
self.card_repository.add(new_card)
result = f"Successfully added card of type {type}Card with name: {name}"
if type == "Trap":
new_card = TrapCard(name)
self.card_repository.add(new_card)
result = f"Successfully added card of type {type}Card with name: {name}"
return result
def add_player_card(self, username: str, card_name: str):
for player in self.player_repository.players:
if player.username == username:
for card in self.card_repository.cards:
if card.name == card_name:
player.card_repository.add(card)
return f"Successfully added card: {card_name} to user: {username}"
def fight(self, attack_name: str, enemy_name: str):
attacker = self.player_repository.find(attack_name)
enemy = self.player_repository.find(enemy_name)
BattleField.fight(attacker=attacker, enemy=enemy)
return f"Attack user health {attacker.health} - Enemy user health {enemy.health}"
def report(self):
report_msg = ""
for player in self.player_repository.players:
report_msg += f"Username: {player.username} - Health: {player.health} - Cards {player.card_repository.count}\n"
for card in player.card_repository.cards:
report_msg += f"### Card: {card.name} - Damage: {card.damage_points}\n"
return report_msg
