def move(self, player_name, direction):
player = self.players[player_name]
old_player_pos = list(player[1])
is_move_correct, new_player_pos = self._check_move_possible(
old_player_pos, direction)
self.players[player_name][1] = new_player_pos
if is_move_correct:
old_row = old_player_pos[1]
old_col = old_player_pos[0]
self.map_grid[old_row][old_col] = '.'
del self.occupied_cells[tuple(old_player_pos)]
new_row = new_player_pos[1]
new_col = new_player_pos[0]
if self.map_grid[new_row][new_col] != '.':
attacker = player[0]
defender = self.occupied_cells[tuple(new_player_pos)]
fight = Fight(attacker, defender)
fight.simulate_fight()
if not fight.attacker.is_alive():
self._update_map()
return True
self.occupied_cells[tuple(new_player_pos)] = player[0]
self.map_grid[new_row][new_col] = Dungeon._get_entity_symbol(
player[0])
self._update_map()
return is_move_correct
class FightTest(unittest.TestCase):
def setUp(self):
self.hero = Hero("Arthas", 660, "Lich King")
self.orc = Orc("Thrall", 700, 1.7)
self.heroWeapon = Weapon("Frostmourne", 35, 0.7)
self.orcWeapon = Weapon("Doomhammer", 40, 0.6)
self.hero.weapon = self.heroWeapon
self.orc.weapon = self.orcWeapon
self.fight = Fight(self.hero, self.orc)
def test_init(self):
self.assertEqual(self.fight.hero, self.hero)
self.assertEqual(self.fight.orc, self.orc)
def test_coin_toss_for_first_attacker(self):
self.assertIn(self.fight.coin_toss(),
[(self.orc, self.hero), (self.hero, self.orc)])
def test_simulate_fight_with_no_weapons(self):
self.fight.hero.weapon = None
self.fight.orc.weapon = None
result = self.fight.simulate_fight()
self.assertEqual(result, "No winner")
def test_simulate_fight_with_only_one_weapon(self):
self.fight.hero.weapon = None
result = self.fight.simulate_fight()
self.assertEqual(result, self.fight.orc)
def test_simulate_fight_with_both_armed_chars(self):
result = self.fight.simulate_fight()
self.assertIn(result, [self.fight.orc, self.hero])
def move(self, player_name, direction):
player = self.players[player_name]
old_player_pos = list(player[1])
is_move_correct, new_player_pos = self._check_move_possible(
old_player_pos, direction)
self.players[player_name][1] = new_player_pos
if is_move_correct:
old_row = old_player_pos[1]
old_col = old_player_pos[0]
self.map_grid[old_row][old_col] = '.'
del self.occupied_cells[tuple(old_player_pos)]
new_row = new_player_pos[1]
new_col = new_player_pos[0]
if self.map_grid[new_row][new_col] != '.':
attacker = player[0]
defender = self.occupied_cells[tuple(new_player_pos)]
fight = Fight(attacker, defender)
fight.simulate_fight()
if not fight.attacker.is_alive():
self._update_map()
return True
self.occupied_cells[tuple(new_player_pos)] = player[0]
self.map_grid[new_row][new_col] = Dungeon._get_entity_symbol(
player[0])
self._update_map()
return is_move_correct
class TestFightingSkills(unittest.TestCase):
def setUp(self):
self.orc = Orc("Gerasim", 100, 1.7)
self.hero = Hero("Spiridon", 100, "Lich King")
self.bitka = Fight(self.orc, self.hero)
self.orc.weapon = Weapon("Wirt's Leg", 30, 0.9)
self.hero.weapon = Weapon("WarGlaive", 30, 0.5)
def test_init_fighters(self):
self.assertEqual(self.orc.name, "Gerasim")
self.assertEqual(self.orc.health, 100)
self.assertEqual(self.orc.berserk_factor, 1.7)
self.assertEqual(self.hero.name, "Spiridon")
self.assertEqual(self.hero.health, 100)
self.assertEqual(self.hero.nickname, "Lich King")
def test_simulate_fight(self):
result = self.bitka.simulate_fight()
self.assertIn(result, [self.orc, self.hero])
def test_simulate_fight_with_no_weapon(self):
self.orc.weapon = None
result = self.bitka.simulate_fight()
self.assertEqual(self.hero, result)
def test_simulate_fight_with_unarmed_characters(self):
self.orc.weapon = None
self.hero.weapon = None
result = self.bitka.simulate_fight()
self.assertEqual(result, "No winner")
def change_map_after_move(self, player_name, old_position, new_position):
if 0 <= new_position[0] < self.lines and 0 <= new_position[1] < self.line_leng:
self.players[player_name][1] = new_position
char_on_new_position = self.get_on_position(new_position)
if char_on_new_position in {"."}:
self.set_position(new_position, self.get_on_position(old_position))
elif char_on_new_position in {"O", "H"}:
entity_0 = self.players[player_name][0]
entity_1 = None
print (self.players)
for p in self.players.values():
a = p[1]
if a == new_position:
entity_1 = p[0]
fight = Fight(entity_0, entity_1)
fight.simulate_fight()
if entity_0.is_alive():
self.set_position(new_position, self.get_on_position(old_position))
elif char_on_new_position in {"W"}:
self.players[player_name][0].equip_weapon(self.weapons[(new_position[0],new_position[1])])
del self.weapons[(new_position[0],new_position[1])]
self.set_position(new_position, self.get_on_position(old_position))
self.set_position(old_position, ".")
self.players[player_name][1] = new_position
return True
else:
return False
def start_fight(self):
arena = Fight(self.hero_player, self.orc_player)
arena.simulate_fight(self.orc_player, self.hero_player)
if not arena.simulate_fight(self.orc_player, self.hero_player):
return False
elif self.orc_player.is_alive() and not self.hero_player.is_alive():
print(self.orc_player_name, "won!")
elif self.hero_player.is_alive() and not self.orc_player.is_alive():
print(self.hero_player_name, "won!")
def start_fight(self):
arena = Fight(self.hero_player, self.orc_player)
arena.simulate_fight(self.orc_player, self.hero_player)
if not arena.simulate_fight(self.orc_player, self.hero_player):
return False
elif self.orc_player.is_alive() and not self.hero_player.is_alive():
print(self.orc_player_name, "won!")
elif self.hero_player.is_alive() and not self.orc_player.is_alive():
print(self.hero_player_name, "won!")
class TestFight(unittest.TestCase):
def setUp(self):
self.orc = Orc("Berserk", 1000, 2)
self.hero = Hero("Bron", 1000, "DragonSlayer")
self.weapon = Weapon("Mighty Axe", 25, 0.3)
self.orc.equip_weapon(self.weapon)
self.hero.equip_weapon(self.weapon)
self.fight = Fight(self.hero, self.orc)
def test_simulate_fight(self):
self.fight.simulate_fight()
self.assertTrue(not self.orc.is_alive() or not self.hero.is_alive())
def test_fight(self):
hero = Hero("LevskiHooligan", 650, "ChupimSkuli")
orc = Orc("CskaSkinhead", 100, 3)
fight = Fight(hero, orc)
beer_bottle = Weapon("BeerBottle", 150, 0.8)
metal_pipe = Weapon("MetalPipe", 180, 0.9)
fight.hero.weapon = metal_pipe
fight.orc.weapon = beer_bottle
fight.simulate_fight()
self.assertEqual(fight.orc.fight_health, 0)
self.assertTrue(fight.hero.fight_health > 0)
class TestFight(unittest.TestCase):
def setUp(self):
self.orc = Orc("Berserk", 1000, 2)
self.hero = Hero("Bron", 1000, "DragonSlayer")
self.weapon = Weapon("Mighty Axe", 25, 0.3)
self.orc.equip_weapon(self.weapon)
self.hero.equip_weapon(self.weapon)
self.fight = Fight(self.hero, self.orc)
def test_simulate_fight(self):
self.fight.simulate_fight()
self.assertTrue(not self.orc.is_alive() or not self.hero.is_alive())
def move(self, player_name, direction):
if player_name in self.players:
player = self.players[player_name]
# go_to -> (coord_x1, coord_y1)
go_to = self.go_to_field(player[1], player[2], direction)
if go_to:
if self.dungeon[go_to[1]][go_to[0]] == '#':
print('Obstacle in that direction.')
return False
elif self.dungeon[go_to[1]][go_to[0]] == '.':
self.dungeon[go_to[1]][go_to[0]] = self.dungeon[
player[2]][player[1]]
self.dungeon[player[2]][player[1]] = '.'
self.players[player_name] = (player[0], go_to[0], go_to[1])
elif self.dungeon[go_to[1]][go_to[0]] == 'W':
weapon = self.get_weapon(go_to[0], go_to[1])
player[0].equip_weapon(weapon)
self.dungeon[go_to[1]][go_to[0]] = self.dungeon[
player[2]][player[1]]
self.dungeon[player[2]][player[1]] = '.'
self.players[player_name] = (player[0], go_to[0], go_to[1])
print('{} weapon equipped!'.format(weapon.type))
else: # in that case we meet enemy
# recognise hero and orc
if isinstance(player[0], Hero):
hero = (player_name, player[0])
orc = self.entity_at_field(go_to[0], go_to[1])
else:
hero = self.entity_at_field(go_to[0], go_to[1])
orc = (player_name, player[0])
# get the winner
fight = Fight(hero[1], orc[1])
fight.simulate_fight()
if fight.hero.health != 0:
print('{} wins!!!'.format(hero[0]))
self.dungeon[go_to[1]][go_to[0]] = 'H'
self.players.pop(orc[0])
self.players[hero[0]] = (hero[1], go_to[0], go_to[1])
else:
print('{} wins!!!'.format(orc[0]))
self.dungeon[go_to[1]][go_to[0]] = 'O'
self.players.pop(hero[0])
self.players[orc[0]] = (orc[1], go_to[0], go_to[1])
self.dungeon[player[2]][player[1]] = '.'
else:
print('Movement out of bounds.')
return False
else:
message = 'There is no such player in the game.'
raise ValueError(message)
def move(self, player_name, direction):
if player_name in self.players:
player = self.players[player_name]
# go_to -> (coord_x1, coord_y1)
go_to = self.go_to_field(player[1], player[2], direction)
if go_to:
if self.dungeon[go_to[1]][go_to[0]] == '#':
print('Obstacle in that direction.')
return False
elif self.dungeon[go_to[1]][go_to[0]] == '.':
self.dungeon[go_to[1]][go_to[0]] = self.dungeon[player[2]][
player[1]]
self.dungeon[player[2]][player[1]] = '.'
self.players[player_name] = (player[0], go_to[0], go_to[1])
elif self.dungeon[go_to[1]][go_to[0]] == 'W':
weapon = self.get_weapon(go_to[0], go_to[1])
player[0].equip_weapon(weapon)
self.dungeon[go_to[1]][go_to[0]] = self.dungeon[player[2]][
player[1]]
self.dungeon[player[2]][player[1]] = '.'
self.players[player_name] = (player[0], go_to[0], go_to[1])
print('{} weapon equipped!'.format(weapon.type))
else: # in that case we meet enemy
# recognise hero and orc
if isinstance(player[0], Hero):
hero = (player_name, player[0])
orc = self.entity_at_field(go_to[0], go_to[1])
else:
hero = self.entity_at_field(go_to[0], go_to[1])
orc = (player_name, player[0])
# get the winner
fight = Fight(hero[1], orc[1])
fight.simulate_fight()
if fight.hero.health != 0:
print('{} wins!!!'.format(hero[0]))
self.dungeon[go_to[1]][go_to[0]] = 'H'
self.players.pop(orc[0])
self.players[hero[0]] = (hero[1], go_to[0], go_to[1])
else:
print('{} wins!!!'.format(orc[0]))
self.dungeon[go_to[1]][go_to[0]] = 'O'
self.players.pop(hero[0])
self.players[orc[0]] = (orc[1], go_to[0], go_to[1])
self.dungeon[player[2]][player[1]] = '.'
else:
print('Movement out of bounds.')
return False
else:
message = 'There is no such player in the game.'
raise ValueError(message)
def compleate_fight(self, player_name, enemy_pos):
enemy_name = self.get_entity_name(enemy_pos)
#get player from dict
player_one = Hero("Bron", 10, "DragonSlayer")
player_two = Orc("Bron", 10, 1.3)
for keys in self.heroes_dict:
if self.heroes_dict[keys] == "%s" % (enemy_name) or self.heroes_dict[keys] == "%s" % (player_name):
if self.heroes_dict[keys] == "%s" % (player_name):
player_one = keys
if self.heroes_dict[keys] == "%s" % (enemy_name):
player_two = keys
fight = Fight(player_one, player_two)
fight.simulate_fight()
return player_one.is_alive()
def move(self, player_name, direction):
pyrva = self.players[player_name].i_coord
vtora = self.players[player_name].j_coord
self.direction = direction
i = 0
j = 0
if direction == "right":
i = 0
j = 1
elif direction == "left":
i = 0
j = -1
elif direction == "down":
i = 1
j = 0
elif direction == "up":
i = -1
j = 0
if type(self.players[player_name]) == Hero and self.map_array[
pyrva + i][vtora + j] == 'O':
fight = Fight(self.players[player_name],
self.that_enemy(pyrva + i, vtora + j))
fight.simulate_fight()
elif type(self.players[player_name]) == Orc and self.map_array[
pyrva + i][vtora + j] == 'H':
fight = Fight(self.players[player_name],
self.that_enemy(pyrva + i, vtora + j))
fight.simulate_fight()
if self.map_array[pyrva + i][vtora + j] == '.':
if type(self.players[player_name]) == Hero:
self.map_array[pyrva + i][vtora + j] = 'H'
self.map_array[pyrva][vtora] = '.'
if direction == "left" or direction == "right":
self.players[player_name].j_coord += j
else:
self.players[player_name].i_coord += i
elif type(self.players[player_name]) == Orc:
self.map_array[pyrva + i][vtora + j] = 'O'
self.map_array[pyrva][vtora] = '.'
if direction == "left" or direction == "right":
self.players[player_name].j_coord += j
else:
self.players[player_name].i_coord += i
else:
return False
class FightTest(unittest.TestCase):
def setUp(self):
self.orc = Orc("PeshoOrc", 100, 1.2)
self.hero = Hero("PeshoHero", 100, "peshooo")
self.weapon1 = Weapon("axe", 50, 0.5)
self.weapon2 = Weapon("axe2", 70, 0.3)
self.fighting = Fight(self.hero, self.orc)
self.orc.weapon = self.weapon1
def test_init(self):
self.assertEqual(self.fighting.Orc,self.orc)
self.assertEqual(self.fighting.Hero,self.hero)
def test_coin(self):
arr = []
flag = [False, False]
for i in range(1, 100):
arr.append(self.fighting.coin())
for i in arr:
if i:
flag[0] = True
else:
flag[1] = True
self.assertEqual(flag, [True, True])
def test_simulate_fight(self):
self.assertEqual("PeshoOrc", self.fighting.simulate_fight())
def fight_for_territory(self, position, new_position):
initial_enemy_health = 100
if self.map[new_position.x][new_position.y] == 'P':
enemy = Python(initial_enemy_health)
elif self.map[new_position.x][new_position.y] == 'A':
enemy = Anaconda(initial_enemy_health)
if not enemy:
return False
fight_to_the_death = Fight(self.hero, enemy)
fight_to_the_death.simulate_fight()
if self.hero.is_alive():
self.change_position(position, new_position)
if isinstance(enemy, Anaconda):
self.hero.add_boss_benefits()
return True
def test_simulate_fight_orc_win(self):
orc_w = Orc("Winner", 300, 2)
hero_l = Hero("Loser", 300, "TheLoser")
wep = Weapon("Ubiec", 15, 0.5)
orc_w.equip_weapon(wep)
orc_fight = Fight(hero_l, orc_w)
self.assertEqual(orc_fight.simulate_fight(), orc_fight._ORC_WINNER)
def test_simulate_fight(self):
proba1 = Weapon("axe", 1, 0.1)
proba2 = Weapon("sword", 40, 0.9)
self.my_hero.equip_weapon(proba1)
self.my_orc.equip_weapon(proba2)
the_fight = Fight(self.my_hero, self.my_orc)
self.assertFalse(the_fight.simulate_fight())
def test_simulate_fight_hero_win(self):
orc_l = Orc("Loser", 300, 2)
hero_w = Hero("Winner", 300, "TheWinner")
wep = Weapon("Ubiec", 15, 0.5)
hero_w.equip_weapon(wep)
hero_fight = Fight(hero_w, orc_l)
self.assertEqual(hero_fight.simulate_fight(), hero_fight._HERO_WINNER)
def test_simulate_fight(self):
proba1 = Weapon("axe", 1, 0.1)
proba2 = Weapon("sword", 40, 0.9)
self.my_hero.equip_weapon(proba1)
self.my_orc.equip_weapon(proba2)
the_fight = Fight(self.my_hero, self.my_orc)
self.assertFalse(the_fight.simulate_fight())
def move(self, player_name, direction):
# If wrong direction is given, do nothing
directions = ["left", "right", "up", "down"]
if direction not in directions:
return "Wrong direction given."
# Read map from file
output = ""
f = open(self.filepath, "r+")
output += f.read()
f.close()
# converts output to list of lists of single-character strings (easier to work with)
getGPS = output = [list(x) for x in output.split("\n")]
# current coordinates
location = self.get_coordinates(getGPS, player_name)
# destination coordinates
destination = self.modify_indexes(self.get_coordinates(getGPS, player_name), direction)
# if coordinate tuple exceeds the map boundaries - terminate
if destination[0] < 0 or destination[1] < 0 or destination[0] > len(output) or destination[1] > len(output[0]):
return "Out of Bounds."
# What is the ASCI character in the given map location
target = output[destination[0]][destination[1]]
# Gets indicator of player who wants to execute a move on the board
indicator = self.get_player_indicator(self.spawnlist[player_name])
# enemy is opposite indicator
enemy = "OH".replace(indicator, "")
if target == "#":
return "You will hit the wall."
elif target == ".":
# swap the "." and current moving player indicator in map
output[location[0]][location[1]], output[destination[0]][destination[1]] = (
output[destination[0]][destination[1]],
output[location[0]][location[1]],
)
elif target == enemy:
# tokill is opposite object of currently-moving player
enemyElem = {i: self.spawnlist[i] for i in self.spawnlist if i != player_name}
ToKill = self.get_value_from_single_element_dict(enemyElem)
# creates fight and simulates it, leaving only winning player on map
# if winner attacked, its indicator overwrites the fallen enemy's one
# if winner was attacked, the fallen enemy one's is changed wiht "." on map
bitka = Fight(self.spawnlist[player_name], ToKill)
battle_result = bitka.simulate_fight()
output[location[0]][location[1]] = "."
output[destination[0]][destination[1]] = self.get_player_indicator(battle_result)
for item in self.spawnlist:
if self.spawnlist[item] == battle_result:
print("{} wins!".format(item))
# saves information to the dungeon map text file
f = open(self.filepath, "w+")
for i in range(0, len(output)):
if i != (len(output) - 1):
f.write("".join(output[i]) + "\n")
else:
f.write("".join(output[i]))
f.close()
def battle(self, name, dest, otpt, chr_loc):
"""Invoked when an Entity's destination map block
is occupied by the opposite entity type
Args:
name - Name of the Entity that walks over. Type(String)
dest - Coordinates of move direction. Type(Tuple)
otpt - Converted map. Type(List of Lists of Strings)
chr_loc - Current coordinates of entity. Type(Tuple)"""
to_fight = None
for each in self.ingame:
if self.ingame[each].location == dest:
to_fight = self.ingame[each]
battle = Fight(self.ingame[name], to_fight)
battle_result = battle.simulate_fight()
otpt[chr_loc[0]][chr_loc[1]] = "."
otpt[dest[0]][dest[1]] = self.get_entity_indicator(battle_result)
if self.ingame[name] == battle_result:
self.ingame[name].location = dest
else:
self.map = self.map.replace("H", ".")
for item in self.ingame:
if self.ingame[item] == battle_result:
self.map = self.revert_map_to_string_state(otpt)
return "{} wins!".format(item)
class FightTest(unittest.TestCase):
def setUp(self):
self.orc = Orc("PeshoOrc", 100, 1.2)
self.hero = Hero("PeshoHero", 100, "peshooo")
self.weapon1 = Weapon("axe", 50, 0.5)
self.weapon2 = Weapon("axe2", 70, 0.3)
self.fighting = Fight(self.hero, self.orc)
self.orc.weapon = self.weapon1
def test_init(self):
self.assertEqual(self.fighting.Orc, self.orc)
self.assertEqual(self.fighting.Hero, self.hero)
def test_coin(self):
arr = []
flag = [False, False]
for i in range(1, 100):
arr.append(self.fighting.coin())
for i in arr:
if i:
flag[0] = True
else:
flag[1] = True
self.assertEqual(flag, [True, True])
def test_simulate_fight(self):
self.assertEqual("PeshoOrc", self.fighting.simulate_fight())
def compleate_fight(self, player_name, enemy_pos):
enemy_name = self.get_entity_name(enemy_pos)
#get player from dict
player_one = Hero("Bron", 10, "DragonSlayer")
player_two = Orc("Bron", 10, 1.3)
for keys in self.heroes_dict:
if self.heroes_dict[keys] == "%s" % (
enemy_name) or self.heroes_dict[keys] == "%s" % (
player_name):
if self.heroes_dict[keys] == "%s" % (player_name):
player_one = keys
if self.heroes_dict[keys] == "%s" % (enemy_name):
player_two = keys
fight = Fight(player_one, player_two)
fight.simulate_fight()
return player_one.is_alive()
class TestFight(unittest.TestCase):
def setUp(self):
self.hero = Hero("Aiden", 500, "Daro Wonderer")
self.orc = Orc("Thrall", 400, 1.4)
weapon1 = Weapon("The Ash Bringer", 80, 0.5)
weapon2 = Weapon('DoomHammer', 80, 0.5)
self.hero.equip_weapon(weapon1)
self.orc.equip_weapon(weapon2)
self.fight = Fight(self.hero, self.orc)
def test_simulate_fight(self):
self.fight.simulate_fight()
self.assertTrue(self.hero.is_alive() or self.orc.is_alive())
self.assertFalse(self.orc.is_alive() and self.hero.is_alive())
def move(self, player_name, direction):
pyrva = self.players[player_name].i_coord
vtora = self.players[player_name].j_coord
self.direction = direction
i = 0
j = 0
if direction == "right":
i = 0
j = 1
elif direction == "left":
i = 0
j = -1
elif direction == "down":
i = 1
j = 0
elif direction == "up":
i = -1
j = 0
if type(self.players[player_name]) == Hero and self.map_array[pyrva + i][vtora + j] == 'O':
fight = Fight(
self.players[player_name], self.that_enemy(pyrva + i, vtora + j))
fight.simulate_fight()
elif type(self.players[player_name]) == Orc and self.map_array[pyrva + i][vtora + j] == 'H':
fight = Fight(
self.players[player_name], self.that_enemy(pyrva + i, vtora + j))
fight.simulate_fight()
if self.map_array[pyrva + i][vtora + j] == '.':
if type(self.players[player_name]) == Hero:
self.map_array[pyrva + i][vtora + j] = 'H'
self.map_array[pyrva][vtora] = '.'
if direction == "left" or direction == "right":
self.players[player_name].j_coord += j
else:
self.players[player_name].i_coord += i
elif type(self.players[player_name]) == Orc:
self.map_array[pyrva + i][vtora + j] = 'O'
self.map_array[pyrva][vtora] = '.'
if direction == "left" or direction == "right":
self.players[player_name].j_coord += j
else:
self.players[player_name].i_coord += i
else:
return False
def start_fight(self, player1, player2):
print("Characters are fighting...")
pl1_inst = self._give_me_player_instance(player1)
pl2_inst = self._give_me_player_instance(player2)
fight = Fight(pl1_inst, pl2_inst)
fight.simulate_fight()
if pl1_inst.is_alive() is True and pl2_inst.is_alive() is True:
print("Players don`t have weapons!")
return
elif pl1_inst.is_alive() is True:
winner = player1
loser = player2
else:
winner = player2
loser = player1
print("The winner is {}".format(winner))
self._make_changes_after_fight(winner, loser)
class Test_Fight(unittest.TestCase):
def setUp(self):
self.orc = Orc("orc", 90, 1.4)
self.hero = Hero("hero", 100, "DragonSlayer")
self.hero.equip_weapon(Weapon("Mighty Axe", 25, 0.2))
self.orc.equip_weapon(Weapon("basher", 16, 0.75))
self.fight = Fight(self.hero, self.orc)
def test_fight_init(self):
self.assertEqual(self.fight.orc, self.orc)
self.assertEqual(self.fight.hero, self.hero)
def test_simulate_fight(self):
self.fight.simulate_fight()
self.assertTrue(self.orc.health == 0 or self.hero.health == 0)
def test_flip_coin(self):
results = set()
for i in range(100):
results.add(self.fight._flip_coin())
self.assertEqual(len(results), 2)
class TestFight(unittest.TestCase):
def setUp(self):
self.sten = Hero("Bron", 100, "DragonSlayer")
self.sho = Orc("Vilasteros", 100, 1.34)
self.bow = Weapon("Mighty Bow", 13, 0.17)
self.axe = Weapon("Thunder Axe", 19, 0.25)
self.sho.equip_weapon(self.bow)
self.sten.equip_weapon(self.axe)
self.battle = Fight(self.sten, self.sho)
def test_init(self):
self.assertEqual(self.battle.hero, self.sten)
self.assertEqual(self.battle.orc, self.sho)
def test_player_order(self):
pass
def test_simulate_fight(self):
self.battle.simulate_fight()
self.assertTrue(self.sten.is_alive() ^ self.sho.is_alive())
def test_fight_with_no_weapons_orc(self):
self.sho.equipped_weapon = None
self.battle.simulate_fight()
self.assertTrue(self.sten.is_alive())
def test_fight_with_no_weapons_hero(self):
self.sten.equipped_weapon = None
self.battle.simulate_fight()
self.assertTrue(self.sho.is_alive())
def move(self, player_name, direction):
if player_name in self.players:
position = self.players[player_name][1] # (i. j)
new_position = () # ((i,j), (i, j),...)
if direction == 'up' and position[0] - 1 >= 0:
new_position = (position[0] - 1, position[1])
elif direction == 'down' and position[0] + 1 < len(self.map):
new_position = (position[0] + 1, position[1])
elif direction == 'left' and position[1] - 1 >= 0:
new_position = (position[0], position[1] - 1)
elif direction == 'right' and position[1] + 1 < len(
self.map[position[0]]):
new_position = (position[0], position[1] + 1)
else:
return False
oponent = 'O' if type(
self.players[player_name][0]) is Hero else 'H'
if self.map[new_position[0]][new_position[1]] == '.':
self.map[new_position[0]][new_position[1]] = self.map[
position[0]][position[1]]
self.map[position[0]][position[1]] = '.'
self.players[player_name][1] = new_position
return True
elif self.map[new_position[0]][new_position[1]] == oponent:
for oponent_name in self.players:
if self.players[oponent_name][1] == new_position:
fight = Fight(self.players[player_name][0],
self.players[oponent_name][0])
if not fight is None:
fight_outcome = fight.simulate_fight()
print(fight_outcome[0])
if fight_outcome[1] == 'H':
self.players.pop(oponent_name)
self.players[player_name][1] = new_position
self.map[new_position[0]][new_position[
1]] = self.map[position[0]][position[1]]
self.map[position[0]][position[1]] = '.'
elif fight_outcome[1] == 'O':
self.players.pop(player_name)
self.map[position[0]][position[1]] = '.'
return fight_outcome[1]
else:
return False
def move(self, player_name, direction):
if direction == "left":
move_by = -1
elif direction == "right":
move_by = 1
elif direction == "up":
move_by = -11
else:
move_by = 11
dungeon = open(self.file_path, "r")
dungeon_map = dungeon.read()
dungeon.close()
dungeon_map = list(dungeon_map)
new_place = self.spawned[player_name][1] + move_by
out_of_map = new_place < 0 or new_place > len(dungeon_map) - 1
if out_of_map or dungeon_map[new_place] in ["H", "O", "#", "\n"]:
return False
else:
a = dungeon_map[new_place]
dungeon_map[new_place] = dungeon_map[self.spawned[player_name][1]]
dungeon_map[self.spawned[player_name][1]] = a
self.spawned[player_name][1] += move_by
dungeon_map = "".join(dungeon_map)
dungeon = open(self.file_path, "w")
dungeon.write(dungeon_map)
dungeon.close()
for player, info in self.spawned.items():
into_right = self.spawned[player_name][1] == info[1] + 1
into_left = self.spawned[player_name][1] == info[1] - 1
into_up = self.spawned[player_name][1] == info[1] - 11
into_down = self.spawned[player_name][1] == info[1] + 11
into_enemy = into_right or into_left or into_up or into_down
enemies = type(info[0]) != type(self.spawned[player_name][0])
if into_enemy and enemies:
fight = Fight(info[0], self.spawned[player_name][0])
fight.simulate_fight()
return True
class fightTest(unittest.TestCase):
def setUp(self):
self.sniper = Weaphon("Gun", 85, 0.10)
self.hammer = Weaphon("One-Hand", 30, 0)
self.bron_orc = Orc("Pesho", 100, 1.50)
self.bron_hero = Hero("Ivan", 100, "Magician")
def test_fight(self):
self.bron_orc.equip_weapon(self.hammer)
self.bron_hero.equip_weapon(self.sniper)
self.fight1 = Fight(self.bron_hero, self.bron_orc)
print
self.assertEqual(1, self.fight1.simulate_fight())
print("__________________________________________________________")
def test_fight2(self):
self.bron_orc.equip_weapon(self.sniper)
self.bron_hero.equip_weapon(self.hammer)
self.fight1 = Fight(self.bron_hero, self.bron_orc)
self.assertEqual(2, self.fight1.simulate_fight())
def move(self, player_name, direction):
if direction == "left":
move_by = -1
elif direction == "right":
move_by = 1
elif direction == "up":
move_by = -11
else:
move_by = 11
dungeon = open(self.file_path, "r")
dungeon_map = dungeon.read()
dungeon.close()
dungeon_map = list(dungeon_map)
new_place = self.spawned[player_name][1] + move_by
out_of_map = new_place < 0 or new_place > len(dungeon_map) - 1
if out_of_map or dungeon_map[new_place] in ["H", "O", "#", "\n"]:
return False
else:
a = dungeon_map[new_place]
dungeon_map[new_place] = dungeon_map[self.spawned[player_name][1]]
dungeon_map[self.spawned[player_name][1]] = a
self.spawned[player_name][1] += move_by
dungeon_map = "".join(dungeon_map)
dungeon = open(self.file_path, "w")
dungeon.write(dungeon_map)
dungeon.close()
for player, info in self.spawned.items():
into_right = self.spawned[player_name][1] == info[1] + 1
into_left = self.spawned[player_name][1] == info[1] - 1
into_up = self.spawned[player_name][1] == info[1] - 11
into_down = self.spawned[player_name][1] == info[1] + 11
into_enemy = into_right or into_left or into_up or into_down
enemies = type(info[0]) != type(self.spawned[player_name][0])
if into_enemy and enemies:
fight = Fight(info[0], self.spawned[player_name][0])
fight.simulate_fight()
return True
def move(self, player_id, direction):
if player_id in self.players:
pos = self.players[player_id][1]
new_pos = ()
oponent = 'O' if type(self.players[player_id][0]) is Hero else 'H'
if direction == 'right' and pos[1] + 1 < len(self.map[pos[0]]):
new_pos = (pos[0], pos[1] + 1)
elif direction == 'left' and pos[1] - 1 >= 0:
new_pos = (pos[0], pos[1] - 1)
elif direction == 'up' and pos[0] - 1 >= 0:
new_pos = (pos[0] - 1, pos[1])
elif direction == 'down' and pos[0] + 1 < len(self.map):
new_pos = (pos[0] + 1, pos[1])
else:
return False
if self.map[new_pos[0]][new_pos[1]] == '.':
self.map[new_pos[0]][new_pos[1]] = self.map[pos[0]][pos[1]]
self.map[pos[0]][pos[1]] = '.'
self.players[player_id][1] = new_pos
return True
elif self.map[new_pos[0]][new_pos[1]] == oponent:
for oponent_name in self.players:
if self.players[oponent_name][1] == new_pos:
fight = Fight(self.players[player_id][0], self.players[oponent_name][0])
if not fight is None:
fight_outcome = fight.simulate_fight()
print(fight_outcome[0])
if fight_outcome[1] == 'H':
self.players.pop(oponent_name)
self.players[player_id][1] = new_pos
self.map[new_pos[0]][new_pos[1]] = self.map[pos[0]][pos[1]]
self.map[pos[0]][pos[1]] = '.'
elif fight_outcome[1] == 'O':
self.players.pop(player_id)
self.map[pos[0]][pos[1]] = '.'
return fight_outcome[1]
else:
return False
class TestFight(unittest.TestCase):
def setUp(self):
self.varyan = Hero("Varyan Wrynn", 100, "King")
self.garrosh = Orc("Garrosh Hellscream", 100, 7)
self.weak_weapon = Weapon("Noob Weapon", 10, 0.1)
self.strong_weapon = Weapon("Woo Weapon", 20, 0.7)
self.fight = Fight(self.varyan, self.garrosh)
def test_simulate_fight_win(self):
self.varyan.equip_weapon(self.strong_weapon)
self.garrosh.equip_weapon(self.weak_weapon)
self.assertIsNotNone(self.fight.simulate_fight())
def enemy_case(self, p_next, player_name):
if type(self.return_self(player_name)) == Hero:
second = self.return_self(player_name)
first = self.return_enemy(p_next)
else:
second = self.return_enemy(p_next)
first = self.return_self(player_name)
print('Wild {} appeared!'.format(self.return_enemy(p_next)))
print('FIGHT!')
fight = Fight(first, second)
winner = fight.simulate_fight()
print('{} WINS!'.format(winner))
return winner
class TestFight(unittest.TestCase):
def setUp(self):
self.varyan = Hero("Varyan Wrynn", 100, "King")
self.garrosh = Orc("Garrosh Hellscream", 100, 7)
self.weak_weapon = Weapon("Noob Weapon", 10, 0.1)
self.strong_weapon = Weapon("Woo Weapon", 20, 0.7)
self.fight = Fight(self.varyan, self.garrosh)
def test_simulate_fight_win(self):
self.varyan.equip_weapon(self.strong_weapon)
self.garrosh.equip_weapon(self.weak_weapon)
self.assertIsNotNone(self.fight.simulate_fight())
def initiate_fight(self, player_name, position):
player_obj = self.__players[player_name]["object"]
for enemy_player in self.__players:
if self.__players[enemy_player]["position"] == position:
new_fight = Fight(player_obj, self.__players[enemy_player]["object"])
winner = new_fight.simulate_fight()
if winner == player_obj:
loser = enemy_player
else:
loser = player_name
player_name = enemy_player
break
if loser:
del self.__players[loser]
return player_name
class TestFight(unittest.TestCase):
def setUp(self):
self.hero = Hero('Stoyan', 200, 'DeathBringer')
self.hero.equip_weapon(Weapon('Sword', 20, 0.5))
self.orc = Orc('Beginner Orc', 100, 1.5)
self.orc.equip_weapon(Weapon('Stick', 10, 0.1))
self.legendary_orc = Orc('Broksiguar', 200, 2)
self.legendary_orc.equip_weapon(Weapon('Frostmourne', 80, 0.9))
self.fight_hero_vs_orc = Fight(self.hero, self.orc)
self.fight_hero_vs_legendary_orc = Fight(self.hero, self.legendary_orc)
def test_fight_init(self):
self.assertEqual(self.fight_hero_vs_orc.hero, self.hero)
self.assertEqual(self.fight_hero_vs_orc.orc, self.orc)
def test_simulate_hero_win(self):
self.fight_hero_vs_orc.simulate_fight()
self.assertEqual(self.fight_hero_vs_orc.orc.current_health, 0)
def test_simulate_orc_win(self):
self.fight_hero_vs_legendary_orc.simulate_fight()
self.assertEqual(
self.fight_hero_vs_legendary_orc.hero.current_health, 0)
class FightTests(unittest.TestCase):
def setUp(self):
self.orc_goshe = Orc("Georgi", 100, 1.2)
self.hero_slayer = Hero("DragonSlayer", 100, "Killer")
self.axe = Weapon("Axe", 10, 0.2)
self.sword = Weapon("Sword", 12, 0.5)
self.orc_goshe.weapon = self.axe
self.hero_slayer.weapon = self.sword
self.battle_one = Fight(self.orc_goshe, self.hero_slayer)
def test_fight_init(self):
self.assertEqual(self.battle_one.orc, self.orc_goshe)
self.assertEqual(self.battle_one.hero, self.hero_slayer)
#как да тествам кой е attacker???!!!!
def test_who_is_attacked_and_attacker(self):
result_array = []
attacker, attacked = self.battle_one._set_turn()
result_array.append(attacked)
result_array.append(attacker)
self.assertIn(self.orc_goshe, result_array)
self.assertIn(self.hero_slayer, result_array)
def test_simulate_battle_fight_without_weapon(self):
self.orc_goshe.weapon = None
self.battle_one.simulate_fight()
self.assertFalse(self.orc_goshe.is_alive())
def test_simulate_battle_fight(self):
self.battle_one.simulate_fight()
result_array = []
result_array.append(self.orc_goshe.is_alive())
result_array.append(self.hero_slayer.is_alive())
self.assertIn(False, result_array)
class FightTests(unittest.TestCase):
def setUp(self):
self.hero = Hero("Don Quixote", 9.99, "The Common Sense")
self.orc = Orc("Oplik", 10, 0.3)
self.fight = Fight(self.hero, self.orc)
self.spoon = Weapon("Rounded Spoon", 2, 0.7)
self.knife = Weapon("Rusty Knife", 6, 0.3)
self.orc.weapon = self.knife
self.hero.weapon = self.spoon
def test_fight_init(self):
self.assertEqual(self.hero, self.fight.hero)
self.assertEqual(self.orc, self.fight.orc)
def test_set_hero_value_error(self):
with self.assertRaises(ValueError):
Fight("pancake", self.orc)
def test_set_orc_value_erroe(self):
with self.assertRaises(ValueError):
Fight(self.hero, "pancake")
def test_get_player_sequence(self):
h = False
o = False
for i in range(0, 1000):
h = h or (self.fight.get_player_sequence()
== (self.hero, self.orc))
o = o or (self.fight.get_player_sequence()
== (self.orc, self.hero))
self.assertTrue(h)
self.assertTrue(o)
def test_simulate_fight(self):
self.fight.simulate_fight()
self.assertFalse(self.fight.orc.is_alive()
and self.fight.hero.is_alive())
def test_simulate_fight_no_weapon_orc(self):
self.fight.orc.weapon = None
self.fight.simulate_fight()
self.assertFalse(self.fight.orc.is_alive())
def test_simulate_fight_no_weapon_hero(self):
self.fight.hero.weapon = None
self.fight.simulate_fight()
self.assertFalse(self.fight.hero.is_alive())
class FightTests(unittest.TestCase):
def setUp(self):
self.hero = Hero("Don Quixote", 9.99, "The Common Sense")
self.orc = Orc("Oplik", 10, 0.3)
self.fight = Fight(self.hero, self.orc)
self.spoon = Weapon("Rounded Spoon", 2, 0.7)
self.knife = Weapon("Rusty Knife", 6, 0.3)
self.orc.weapon = self.knife
self.hero.weapon = self.spoon
def test_fight_init(self):
self.assertEqual(self.hero, self.fight.hero)
self.assertEqual(self.orc, self.fight.orc)
def test_set_hero_value_error(self):
with self.assertRaises(ValueError):
Fight("pancake", self.orc)
def test_set_orc_value_erroe(self):
with self.assertRaises(ValueError):
Fight(self.hero, "pancake")
def test_get_player_sequence(self):
h = False
o = False
for i in range(0, 1000):
h = h or (self.fight.get_player_sequence()
== (self.hero, self.orc))
o = o or (self.fight.get_player_sequence()
== (self.orc, self.hero))
self.assertTrue(h)
self.assertTrue(o)
def test_simulate_fight(self):
self.fight.simulate_fight()
self.assertFalse(self.fight.orc.is_alive()
and self.fight.hero.is_alive())
def test_simulate_fight_no_weapon_orc(self):
self.fight.orc.weapon = None
self.fight.simulate_fight()
self.assertFalse(self.fight.orc.is_alive())
def test_simulate_fight_no_weapon_hero(self):
self.fight.hero.weapon = None
self.fight.simulate_fight()
self.assertFalse(self.fight.hero.is_alive())
class TestFight(unittest.TestCase):
def setUp(self):
self.hero = Hero("Bron", 100, "DragonSlayer")
self.orc = Orc("Shapeshifter", 100, 1.5)
sword = Weapon("Sword", 10, 0.2)
axe = Weapon("Axe", 10, 0.2)
self.hero.equip_weapon(sword)
self.orc.equip_weapon(axe)
self.battle = Fight(self.hero, self.orc)
def test_fight_init(self):
self.assertEqual(self.battle.hero.name, "Bron")
self.assertEqual(self.battle.hero.health, 100)
self.assertEqual(self.battle.hero.nickname, "DragonSlayer")
self.assertEqual(self.battle.orc.name, "Shapeshifter")
self.assertEqual(self.battle.orc.health, 100)
self.assertEqual(self.battle.orc.berserk, 1.5)
def test_flip_coin(self):
flip_chances = set()
for i in range(1000):
flip_chances.add(self.battle.flip_coin())
self.assertIn(True, flip_chances)
self.assertIn(False, flip_chances)
def test_simulate_fight_hero_first(self):
entity_wins = set()
for i in range(1000):
self.battle.hero.health = 100
self.battle.orc.health = 100
entity_wins.add(self.battle.simulate_fight())
self.assertIn("Hero wins.", entity_wins)
self.assertIn("Orc wins.", entity_wins)
class TestFight(unittest.TestCase):
def setUp(self):
self.bron_hero = Hero("Bron", 100, "DragonSlayer")
self.axe = Weapon("Mighty Axe", 25, 0.2)
self.sword = Weapon("Mighty Sword", 12, 0.7)
self.bron_orc = Orc("Bron", 100, 1.3)
self.my_fight = Fight(self.bron_hero, self.bron_orc)
self.bron_hero.weapon = self.sword
self.bron_orc.weapon = self.axe
def test_fight_init(self):
self.assertEqual(self.my_fight.hero, self.bron_hero)
self.assertEqual(self.my_fight.orc, self.bron_orc)
def test_who_is_first(self):
flag_hero = False
flag_orc = False
for i in range(0, 10):
self.my_fight.who_is_first()
if self.my_fight.who_is_first() == self.bron_hero:
flag_hero = True
else:
flag_orc = True
self.assertTrue(flag_hero and flag_orc)
def test_simulate_fight(self):
self.my_fight.simulate_fight()
self.assertFalse(self.bron_orc.is_alive()
and self.bron_hero.is_alive())
def test_simulate_fight_hero_wtih_wep_vs_hero_without_wep(self):
self.hero_without_wep = Hero("Toni", 100, "Monster")
self.fight = Fight(self.bron_hero, self.hero_without_wep)
self.fight.simulate_fight()
self.assertFalse(self.hero_without_wep.is_alive())
def test_simulate_fight_hero_vs_equal_orc(self):
self.equal_orc = Orc("Toni", 100, 1.5)
self.equal_orc.weapon = self.sword
self.fight = Fight(self.bron_hero, self.equal_orc)
self.fight.simulate_fight()
self.assertFalse(self.bron_hero.is_alive())
class TestFight(unittest.TestCase):
def setUp(self):
self.bron_hero = Hero("Bron", 100, "DragonSlayer")
self.axe = Weapon("Mighty Axe", 25, 0.2)
self.sword = Weapon("Mighty Sword", 12, 0.7)
self.bron_orc = Orc("Bron", 100, 1.3)
self.my_fight = Fight(self.bron_hero, self.bron_orc)
self.bron_hero.weapon = self.sword
self.bron_orc.weapon = self.axe
def test_fight_init(self):
self.assertEqual(self.my_fight.hero, self.bron_hero)
self.assertEqual(self.my_fight.orc, self.bron_orc)
def test_who_is_first(self):
flag_hero = False
flag_orc = False
for i in range(0, 10):
self.my_fight.who_is_first()
if self.my_fight.who_is_first() == self.bron_hero:
flag_hero = True
else:
flag_orc = True
self.assertTrue(flag_hero and flag_orc)
def test_simulate_fight(self):
self.my_fight.simulate_fight()
self.assertFalse(self.bron_orc.is_alive() and self.bron_hero.is_alive())
def test_simulate_fight_hero_wtih_wep_vs_hero_without_wep(self):
self.hero_without_wep = Hero("Toni", 100, "Monster")
self.fight = Fight(self.bron_hero, self.hero_without_wep)
self.fight.simulate_fight()
self.assertFalse(self.hero_without_wep.is_alive())
def test_simulate_fight_hero_vs_equal_orc(self):
self.equal_orc = Orc("Toni", 100, 1.5)
self.equal_orc.weapon = self.sword
self.fight = Fight(self.bron_hero, self.equal_orc)
self.fight.simulate_fight()
self.assertFalse(self.bron_hero.is_alive())
class Dungeon():
def __init__(self, path):
file = open(path, "r")
self.map = file.read()
self.heroes = []
self._ROW_LENGTH = math.sqrt(len(self.map))
file.close()
def print_map(self):
print (self.map)
def spawn(self, name, entity):
self.map = [x for x in self.map]
for i in range(len(self.map)):
if self.map[i] == 'S':
self.heroes.insert(i, [name, entity])
if isinstance(entity, Hero):
self.map[i] = "H"
else:
self.map[i] = "O"
break
else:
self.map = "".join(self.map)
return False
self.map = "".join(self.map)
return True
def move(self, name, direction):
self.map = [x for x in self.map]
if direction == "right":
step = 1
elif direction == "left":
step = - 1
elif direction == "down":
step = self._ROW_LENGTH
elif direction == "up":
step = - self._ROW_LENGTH
for i in range(len(self.heroes)):
if self.heroes[i][0] == name:
if self.map[i + step] == '.':
self.map[i + step] = "H" if isinstance(self.heroes[i][1], Hero) else "O"
self.map[i] = '.'
self.heroes.insert(i + step, self.heroes[i])
self.heroes.pop(i)
self.map = "".join(self.map)
return True
elif self.map[i + step] == "H" or self.map[i + step] == "O":
self.fight = Fight(self.heroes[i][1], self.heroes[i + step][1])
self.fight.simulate_fight()
if self.heroes[i][1].is_alive():
self.map[i + step] = "H" if isinstance(self.heroes[i][1], Hero) else "O"
self.map[i] = '.'
self.heroes.insert(i + step, self.heroes[i])
self.heroes.pop(i)
else:
self.map[i] = '.'
self.heroes.pop(i)
self.map = "".join(self.map)
return True
elif self.map[i + step] == '\n':
if self.map[i + step + 1] == '.':
self.map[i + step + 1] = "H" if isinstance(self.heroes[i][1], Hero) else "O"
self.map[i] = '.'
self.heroes.insert(i + step + 1, self.heroes[i])
self.heroes.pop(i)
self.map = "".join(self.map)
return True
elif self.map[i + step + 1] == "H" or self.map[i + step + 1] == "O":
self.fight = Fight(self.heroes[i][1], self.heroes[i + step + 1][1])
self.fight.simulate_fight()
if self.heroes[i][1].is_alive():
self.map[i + step + 1] = "H" if isinstance(self.heroes[i][1], Hero) else "O"
self.map[i] = '.'
self.heroes.insert(i + step + 1, self.heroes[i])
self.heroes.pop(i)
else:
self.map[i] = '.'
self.heroes.pop(i)
self.map = "".join(self.map)
return True
self.map = "".join(self.map)
return False
class Dungeon(object):
def __init__(self, path):
self.path = path
self.dct = {}
def print_map(self):
a = ''
f1 = open('/home/biser/TDD/simple_dungeon.txt', 'r')
for line in f1:
a += line
f1.close()
#print(a)
return a
def spown(self, player_name, entity):
a = ""
if isinstance(entity, Hero) or isinstance(entity, Orc):
f1 = open('/home/biser/TDD/simple_dungeon.txt', 'r')
for line in f1:
a += line
for i in range(len(a)):
if a[i] == 'S' and isinstance(entity, Hero):
#spawn Hero
a = a[:i] + "H" + a[i + 1:]
f2 = open('/home/biser/TDD/simple_dungeon.txt', 'w')
f2.write(a)
self.dct[entity] = entity.name
f2.close()
f1.close()
break
elif a[i] == 'S' and isinstance(entity, Orc):
#spown Orc
a = a[:i] + "O" + a[i + 1:]
f2 = open('/home/biser/TDD/simple_dungeon.txt', 'w')
f2.write(a)
self.dct[entity] = entity.name
f2.close()
f1.close()
break
elif i == len(a) - 1:
f1.close()
return ("currently there is no free spowning point")
else:
return ("wrong instance given")
def move(self, player_name, direction):
exceptFlag = False
for player in self.dct:
print(player.name)
if player.name == player_name:
if isinstance(player, Hero):
a = ''
f1 = open('/home/biser/TDD/simple_dungeon.txt', 'r+')
a = f1.read()
f1.close()
for i in range(len(a)):
if a[i] == "H":
if direction == "left":
try:
if a[i - 1] == ".":
a = a[:i - 1] + "H" + "." + a[i + 1:]
elif a[i - 1] == "O":
self.fight1 = Fight(
self.dct[0], self.dct[1])
if self.fight1.simulate_fight() == 1:
a = a[:i - 1] + "H" + "." + a[i +
1:]
else:
a = a[:i - 1] + "O" + "." + a[i +
1:]
except:
exceptFlag = True #!!! if excep....
f1 = open('/home/biser/TDD/simple_dungeon.txt',
'w+')
f1.write(a)
f1.close()
print(a)
break
elif direction == "right":
try:
if a[i + 1] == ".":
a = a[:i] + "." + "H" + a[i + 2:]
elif a[i + 1] == "O":
self.fight1 = Fight(
self.dct[0], self.dct[1])
if self.fight1.simulate_fight() == 1:
a = a[:i] + "." + "H" + a[i + 2:]
else:
a = a[:i] + "." + "O" + a[i + 2:]
except:
pass
f1 = open('/home/biser/TDD/simple_dungeon.txt',
'w+')
f1.write(a)
f1.close()
print(a)
break
elif direction == "up":
try:
if a[i - 11] == ".":
a = a[:i -
11] + "H" + a[i -
10:i] + "." + a[i +
1:]
except:
pass
f1 = open('/home/biser/TDD/simple_dungeon.txt',
'w+')
f1.write(a)
f1.close()
print(a)
break
elif direction == "down":
try:
if a[i + 11] == ".":
a = a[:i] + "." + a[i + 1:i +
11] + "H" + a[i +
12:]
elif a[i + 11] == "O":
aaa = self.dct.keys()
self.fight1 = Fight(aaa[0], aaa[1])
if self.fight1.simulate_fight() == 1:
a = a[:i] + "." + a[
i + 1:i + 11] + "H" + a[i +
12:]
else:
a = a[:i] + "." + a[
i + 1:i + 11] + "" + a[i + 12:]
except:
pass
f1 = open('/home/biser/TDD/simple_dungeon.txt',
'w+')
f1.write(a)
f1.close()
print(a)
break
class Dungeon():
def __init__(self, path):
file = open(path, "r")
self.map = file.read()
self.heroes = []
self._ROW_LENGTH = math.sqrt(len(self.map))
file.close()
def print_map(self):
print(self.map)
def spawn(self, name, entity):
self.map = [x for x in self.map]
for i in range(len(self.map)):
if self.map[i] == 'S':
self.heroes.insert(i, [name, entity])
if isinstance(entity, Hero):
self.map[i] = "H"
else:
self.map[i] = "O"
break
else:
self.map = "".join(self.map)
return False
self.map = "".join(self.map)
return True
def move(self, name, direction):
self.map = [x for x in self.map]
if direction == "right":
step = 1
elif direction == "left":
step = -1
elif direction == "down":
step = self._ROW_LENGTH
elif direction == "up":
step = -self._ROW_LENGTH
for i in range(len(self.heroes)):
if self.heroes[i][0] == name:
if self.map[i + step] == '.':
self.map[i + step] = "H" if isinstance(
self.heroes[i][1], Hero) else "O"
self.map[i] = '.'
self.heroes.insert(i + step, self.heroes[i])
self.heroes.pop(i)
self.map = "".join(self.map)
return True
elif self.map[i + step] == "H" or self.map[i + step] == "O":
self.fight = Fight(self.heroes[i][1],
self.heroes[i + step][1])
self.fight.simulate_fight()
if self.heroes[i][1].is_alive():
self.map[i + step] = "H" if isinstance(
self.heroes[i][1], Hero) else "O"
self.map[i] = '.'
self.heroes.insert(i + step, self.heroes[i])
self.heroes.pop(i)
else:
self.map[i] = '.'
self.heroes.pop(i)
self.map = "".join(self.map)
return True
elif self.map[i + step] == '\n':
if self.map[i + step + 1] == '.':
self.map[i + step + 1] = "H" if isinstance(
self.heroes[i][1], Hero) else "O"
self.map[i] = '.'
self.heroes.insert(i + step + 1, self.heroes[i])
self.heroes.pop(i)
self.map = "".join(self.map)
return True
elif self.map[i + step + 1] == "H" or self.map[i + step +
1] == "O":
self.fight = Fight(self.heroes[i][1],
self.heroes[i + step + 1][1])
self.fight.simulate_fight()
if self.heroes[i][1].is_alive():
self.map[i + step + 1] = "H" if isinstance(
self.heroes[i][1], Hero) else "O"
self.map[i] = '.'
self.heroes.insert(i + step + 1, self.heroes[i])
self.heroes.pop(i)
else:
self.map[i] = '.'
self.heroes.pop(i)
self.map = "".join(self.map)
return True
self.map = "".join(self.map)
return False
class EntityTest(unittest.TestCase):
def setUp(self):
self.hero = Hero("Bron", 100, "DragonSlayer")
self.orc = Ork("BronOrk", 100, 1.1)
self.axe = Weapon("Axe", 12.45, 0.2)
self.sword = Weapon("Sword of Arthur", 13, 0.5)
self.battle = Fight(self.hero, self.orc)
self.dungeon = Dungeon("dungeon.txt")
def test_hero_init(self):
self.assertEqual("Bron", self.hero.name)
self.assertEqual(100, self.hero.health)
self.assertEqual("DragonSlayer", self.hero.nickname)
def test_known_as(self):
self.assertEqual(self.hero.known_as(), "Bron the DragonSlayer")
def test_get_health(self):
self.assertEqual(100, self.hero.get_health())
self.assertEqual(100, self.orc.get_health())
def test_is_alive(self):
self.assertTrue(self.hero.is_alive())
self.hero.health = 0
self.orc.health = -1
self.assertFalse(self.orc.is_alive())
self.assertFalse(self.hero.is_alive())
def test_take_damage(self):
self.assertTrue(self.hero.take_damage(30.0))
result = self.hero.get_health()
self.assertEqual(70.0, result)
self.assertFalse(self.hero.take_damage(70))
def test_take_more_damage_that_he_can(self):
self.assertFalse(self.hero.take_damage(101))
def test_take_healing(self):
self.assertTrue(self.hero.take_healing(10))
self.hero.health = 10
self.assertTrue(self.hero.take_healing(10.0))
self.hero.health = 0
self.assertFalse(self.hero.take_healing(10.0))
def test_orc_init(self):
self.assertEqual("BronOrk", self.orc.name)
self.assertEqual(100, self.orc.health)
def test_ork_berseker(self):
self.orc._Ork__set_berserk_factor(3)
self.assertEqual(2, self.orc.berserk_factor)
self.orc._Ork__set_berserk_factor(0.5)
self.assertEqual(1, self.orc.berserk_factor)
def test_has_weapon(self):
self.assertFalse(self.orc.has_weapon())
self.orc.equip_weapon(self.axe)
self.assertTrue(self.orc.has_weapon())
def test_equip_weapon(self):
new_weapon = Weapon("Bazuka", 15, 3)
self.orc.equip_weapon(new_weapon)
self.assertEqual(new_weapon, self.orc.weapon)
def test_attack(self):
self.assertFalse(self.orc.has_weapon())
self.assertEqual(0, self.orc.attack())
self.orc.equip_weapon(self.axe)
self.assertEqual(self.axe.damage, self.orc.attack())
def test_fight_init(self):
self.assertEqual(self.battle.hero, self.hero)
self.assertEqual(self.battle.orc, self.orc)
def test_simulate_fight(self):
self.orc.weapon = self.axe
self.hero.weapon = self.sword
self.battle.simulate_fight()
def test_spawn(self):
self.assertTrue(self.dungeon.spawn('Bron', self.hero))
self.assertTrue(self.dungeon.spawn('BronOrk', self.orc))
# self.dungeon.print_map()
def test_move(self):
self.dungeon.spawn('Bron', self.hero)
self.dungeon.spawn('Undead', self.orc)
self.assertFalse(self.dungeon.move('Bron', 'left'))
self.assertFalse(self.dungeon.move('Bron', 'up'))
self.assertTrue(self.dungeon.move('Bron', 'right'))
self.assertFalse(self.dungeon.move('Undead', 'down'))
self.assertTrue(self.dungeon.move('Undead', 'up'))
self.dungeon.print_map()
