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])
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!")
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)
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 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_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
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 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 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()