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 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())
class FightTest(unittest.TestCase): def setUp(self): self.bron_hero = Hero("Bron", 100, "DragonSlayer") self.torug_orc = Orc("Torug", 100, 1.2) self.new_fight = Fight(self.bron_hero, self.torug_orc) self.axe = Weapon("Axe", 20, 0.2) self.sword = Weapon("Sword", 12, 0.7) self.bron_hero.equip_weapon(self.sword) self.torug_orc.equip_weapon(self.axe) def test_init(self): self.assertEqual(self.new_fight.orc, self.torug_orc) self.assertEqual(self.new_fight.hero, self.bron_hero) def test_who_is_first(self): first_entity = self.new_fight.who_is_first() self.assertIn(first_entity, [self.bron_hero, self.torug_orc]) def test_fight(self): self.new_fight.simulate_battle() self.assertFalse(self.torug_orc.is_alive() and self.bron_hero.is_alive()) def test_fight_with_no_weapons(self): self.torug_orc.weapon = None self.new_fight.simulate_battle() self.assertFalse(self.torug_orc.is_alive())
def hero_attack(self, by=""): if by == 'weapon' and self.hero.weapon is None: raise Exception("Hero cannot attack by weapon") if by == 'spell' and self.hero.spell is None: raise Exception("Hero cannot attack by spell") if by == 'spell' and self.hero.spell is not None: for i in range(self.__coords[1]+1, self.__coords[1]+1+self.hero.spell.cast_range**2): try: print(self.map[self.__coords[0]][i], self.__coords[1], self.__coords[1]+1+self.hero.spell.cast_range**2) if self.map[self.__coords[0]][i] == Dungeon.WALKABLE_PATH: continue elif self.map[self.__coords[0]][i] == Dungeon.ENEMY: print("A fight is started between our {} and {}".format(repr(self.hero), repr(self.enemy))) f = Fight(self.hero, self.enemy) f.fight(self.hero.weapon_to_fight()) break print("Nothing in casting range {}".format(self.hero.spell.cast_range)) return False except IndexError: break if by == 'weapon' and self.hero.weapon is not None: print("A fight is started between our {} and {}".format(repr(self.hero), repr(self.enemy))) Fight(self.hero, self.enemy).fight(self.hero.weapon_to_fight()) return True
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): 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
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 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 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")
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 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 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
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 duel_accept(self, other): if other["duel_invite"] == None or len([x for x in other["duel_invite"] if x[0] == self.id]) == 0: raise MyException(u"Игрок отменил свой вызов") if other["zone"] != self["zone"]: raise MyException(u"Игрок находится в другой локации") if other["loc"] != "default": raise MyException(u"Игрок пока не может начать дуэль") other["duel_invite"] = [di for di in other["duel_invite"] if di[0] != self.id] Fight.create([other], [self], _type="training")
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_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
def attack(self, req, replysock): # assume we're attacking the first enemy loc = self.places[req.location] user = self.users[req.user] if len(loc.enemies) == 0: replysock.send('/attack No enemies to attack') else: enemy = loc.enemies[0] fight = Fight(user, enemy, self.event_pub, ['player-' + user.name]) winner = fight.fight() if winner != enemy: loc.enemies.remove(enemy) loc.dead.append(enemy) replysock.send('/attack {0} wins'.format(winner.name))
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 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 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
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 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 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_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 fight_time(self): if self.cords[self.spawned[0]] == self.cords[self.spawned[1]]: print('') print("Its time for fight. Lets Bet!") print('') self.its_show_time = Fight(self.player1, self.player2) self.its_show_time.simulate_fight()
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())
class TestFight(unittest.TestCase): def setUp(self): self.my_hero = Hero("Hero", 100, "Hero") self.my_orc = Orc("Orc", 100, 1.5) self.the_fight = Fight(self.my_hero, self.my_orc) def test_init(self): self.assertEqual(self.my_hero.name, "Hero") self.assertEqual(self.my_hero.health, 100) self.assertEqual(self.my_hero.nickname, "Hero") self.assertEqual(self.my_orc.name, "Orc") self.assertEqual(self.my_orc.health, 100) self.assertEqual(self.my_orc.berserk_factor, 1.5) def test_attacks_first(self): my_arr = [] for i in range(0, 100): if self.the_fight.attacks_first() == True: my_arr.append(1) my_arr.append(0) self.assertIn(1, my_arr) self.assertIn(0, my_arr) 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_enemy_with_same_x_as_hero_and_y_in_range_to_attack_choose_normal_attack_reduces_hero_health_5( self): # test with weapon and spell and enemy dmg > spell dmg > weapon dmg h = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) enemy = Enemy(health=100, mana=40, damage=60) enemy.x = 3 enemy.y = 2 weapon = Weapon(name='Pruchka', damage=50) s = Spell('fireball', damage=45, mana_cost=15, cast_range=3) enemy.learn(s) enemy.equip(weapon) fight = Fight(enemy) h.x = 3 h.y = 3 fight.enemy_move(h) self.assertEqual(h.health, 40)
def test_enemy_with_bigger_weapon_dmg_and_not_enough_range_should_change_x_to_hero_2( self): # hero is on the left side of enemy and in the same y level h = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) enemy = Enemy(health=100, mana=40, damage=20) enemy.x = 5 enemy.y = 3 weapon = Weapon(name='Pruchka', damage=50) s = Spell('fireball', damage=45, mana_cost=15, cast_range=1) enemy.learn(s) enemy.equip(weapon) fight = Fight(enemy) h.x = 3 h.y = 3 fight.enemy_move(h) self.assertEqual(enemy.x, 4)
def enter_tile(self, tile): #TODO: Add Method for Player Entry tile.show_tile_prompt() player_input = input("Your Choice:").lower() if player_input == "f": if Fight.fight(self.player, tile.enemy): self.show_world_prompt(tile) else: return False if player_input == "c": self.enter_city()
def handle_encounters(self, row, col): for respawn_tuple in self.save_respawn_points: self.dungeon[respawn_tuple[0]][respawn_tuple[1]] = 'S' if self.dungeon[row][col] == 'E': self.set_enemy(Enemy(health=100, mana=100, damage=20)) if self.hero is not None and self.enemy is not None: f = Fight(self.hero, self.enemy) f.fight() if not self.hero.is_alive(): self.spawn(self.hero) elif self.dungeon[row][col] == 'T': self.get_treasure() elif self.dungeon[row][col] == 'G': print('Level complete!') exit() elif self.dungeon[row][col] == 'S': self.save_respawn_points.append((row, col)) elif self.dungeon[row][col] == '.': pass else: print('WTF have you encountered?')
def test_with_weapon_should_attack_by_weapon(self): h = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) h.equip(Weapon(name="The Axe of Destiny", damage=20)) e = Enemy() Fight(h, e) self.assertEqual(h.attacking, PLAYER_ATTACK_BY_WEAPON_STRING)
def _move_into(self, x, y): symbol = self.map[x][y] if symbol == 'T': self.collector.treasures[(x, y)].apply_on_hero(self.hero) elif symbol == 'E': Fight(self.hero, self.collector.enemies[(x, y)]).start_fight() if self._is_game_over(): print("Game over!") sys.exit(0) elif symbol == 'G': self._go_on_next_level()
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 test_init_fiht(self): h = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) e = Enemy() f = Fight(h, e) self.assertIsNotNone(f) self.assertIsNotNone(f.hero) self.assertIsNotNone(f.enemy)
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 test_with_weapon_and_spell_should_attack_by_higher_damage(self): h = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) h.learn(Spell(name="Fireball", damage=20, mana_cost=50, cast_range=2)) h.equip(Weapon(name="The Axe of Destiny", damage=30)) e = Enemy() Fight(h, e) self.assertEqual(h.attacking, PLAYER_ATTACK_BY_WEAPON_STRING)
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 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 test_with_spell_and_weapon_with_distance_and_no_mana_should_move(self): h = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) h.learn(Spell(name="Fireball", damage=30, mana_cost=50, cast_range=2)) h.equip(Weapon(name="The Axe of Destiny", damage=40)) e = Enemy() h.mana = 0 f = Fight(h, e, distance=2) self.assertEqual(f.distance, 0)
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())
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 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())
def Monastery(): window.clear() window.print_double_line() window.smooth_print("\n".join(dialogs["monastery"]["intro"])) window.print_double_line() window.user_input(dialogs["pause"]) window.print_double_line() window.smooth_print("\n".join(dialogs["monastery"]["first_battle"])) window.print_double_line() for i in range(5): window.smooth_print( f"\n Paintings remaining before next event: \033[1;33;40m{player.next_event - player.room}\033[1;37;40m\n") window.user_input(dialogs["pause"]) enemy = choose_opponent() fight = Fight(window, player, enemy) fight.fight() player.room += 1 if i != 4: window.print_double_line() window.smooth_print("\n".join(dialogs["monastery"]["interlude1"])) window.print_double_line() EncounterAcolyte() player.room += 1 player.next_event = 11 for i in range(5): window.smooth_print( f"\n Paintings remaining before meeting the Master: \033[1;33;40m{player.next_event - player.room}\033[1;37;40m\n") window.user_input(dialogs["pause"]) enemy = choose_opponent() fight = Fight(window, player, enemy) fight.fight() player.room += 1 if i != 4: window.print_double_line() window.smooth_print("\n".join(dialogs["monastery"]["interlude2"])) window.print_double_line() Bossfight() ending()
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 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 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)
def simulate_fight(): # Two users login, one of them fails and retries print print("############################################") print("############## SIMULATE FIGHT ##############") print("############################################") # Login both users username_one = "user1" password_one = "user1" username_two = "user2" password_two = "user2" user_one = User(username_one, password_one) if not user_one.valid: print("User1 did not authenticate!!") exit() else: print("User1 authenticated!") user_two = User(username_two, password_two) if not user_two.valid: print("User2 did not authenticate!!") exit() else: print("User2 authenticated!") # Get their squads squad_one = create_squad( user_one.username, "7911ceb9f0f546c2b49bff6a8bd7044d") squad_two = create_squad( user_two.username, "b3f175ec05564cdbbb8545bf6f26b469") print("User1 will use Squad <" + str(squad_one.uid)+">") print("User2 will use Squad <" + str(squad_two.uid)+">") # Create Fight test_fight = Fight(squad_one, squad_two) # Attack b_hpt_prev_health = squad_two.hierophant.get_stat_health() a_cpt_dmg = squad_one.captain.get_stat_fight() print("Squad B Hierophant health pre-fight: " + str(b_hpt_prev_health)) print("Squad A Captain attacks with " + str(a_cpt_dmg) + " damage") test_fight.a_attack(squad_one.captain.uid, squad_two.hierophant.uid) # End fight and save squads test_fight.end_game() # Get Squad b again an check Hierophant health del squad_two squad_two = create_squad( user_two.username, "b3f175ec05564cdbbb8545bf6f26b469") b_hpt_post_health = squad_two.hierophant.get_stat_health() print("Squad B Hierophant health post-fight: " + str(b_hpt_post_health))
def can_move(self, x, y, player_name): if x >= 0 and \ x < len(self.current_map) and \ y >= 0 and \ y < len(self.current_map[0]): if self.current_map[x][y] != "#" and self.current_map[x][y] == ".": return True elif self.current_map[x][y] != self.players[player_name]['sign']: print('Battle begins! Someone will DIE now') for player in self.players: if self.players[player]['type'] == 'Hero': hero = self.players[player]['class'] elif self.players[player]['type'] == 'Orc': orc = self.players[player]['class'] # print(players[0], players[1]) Fight(hero, orc).simulate_fight() return False return False
def attack_from_distance(self, direction): direction = self.directions[direction] land_hit_pos_x = self._hero_pos[ 0] + direction[0] * self._hero.spell.cast_range land_hit_pos_y = self._hero_pos[ 1] + direction[1] * self._hero.spell.cast_range start_pos_x = self._hero_pos[0] start_pos_y = self._hero_pos[1] range_ = max(abs(land_hit_pos_x - start_pos_x), abs(land_hit_pos_y - start_pos_y)) for i in range(range_): start_pos_x, start_pos_y = (start_pos_x + direction[0], start_pos_y + direction[1]) if start_pos_x < 0 or\ start_pos_y < 0 or\ start_pos_x >= len(self._map) or\ start_pos_y >= len(self._map[start_pos_x]): break # while(abs(start_pos_x) <= abs(land_hit_pos_x) and # abs(start_pos_y) <= abs(land_hit_pos_y) and # start_pos_x >= 0 and # start_pos_y >= 0 and # start_pos_x < len(self._map) and # start_pos_y < len(self._map[start_pos_x])): elif type(self._map[start_pos_x][start_pos_y]) is str and\ self._map[start_pos_x][start_pos_y] == '#': raise Exception("Hero cant attack through walls") elif isinstance(self._map[start_pos_x][start_pos_y], Enemy): if self._hero.can_cast(): Fight(dungeon=self, enemy_pos=(start_pos_x, start_pos_y)).fight() self._map[self._hero_pos[0]][self._hero_pos[1]] = 'H' else: raise Exception( 'Hero doesnt have enough mana to attack from distance') return True print('There is no enemy in this direction') return False
def unpause(self): if self.next_was == 0: #previous state was Move-menu self.next_was = None self.cur_troops = self.next.troops elif self.next_was == 1: #prev state was Fight self.next_was = None if self.next.hq_conquered: self.to_winlose(win=True) return self.map.redraw() elif self.next_was == 3: #win/lose screen State.unpause(self) self.to_start_menu() return elif self.next_was == 4: #prev state was AirstrikeMenu self.next_was = None self.airstriking = True self.cur_troops = self.next.troops State.unpause(self) if self.player.ai: return self.map.changed = 1 self.conti.update() if self.airstriking and self.cur_troops: #airstrike self.pause() self.next = Fight(self) self.quit() elif self.airstriking and not self.cur_troops: self.airstriking = False elif self.cur_troops: self.move_troops() else: if self.from_reg: self.map.select(self.from_reg.id) self.from_reg = None self.dest_reg = None self.msgline.set_msg("") self.msgline.draw(self.bg)
class TestFight(unittest.TestCase): def setUp(self): self.orc = Orc("Bron", 300, 1.3) self.hero = Hero("Brom", 300, "DragonSlayer") self.fight_sim = Fight(self.hero, self.orc) def test_hero_in_fight(self): self.assertEqual("Brom", self.fight_sim.hero.name) self.assertEqual(300, self.fight_sim.hero.health) self.assertEqual("DragonSlayer", self.fight_sim.hero.nickname) def test_orc_in_fight(self): self.assertEqual("Bron", self.fight_sim.orc.name) self.assertEqual(300, self.fight_sim.orc.health) self.assertEqual(1.3, self.fight_sim.orc.berserk_factor) def test_flip_coin(self): coins = [] for i in range(100): coins.append(self.fight_sim._flip_coin()) self.assertIn(self.fight_sim._HERO_TURN, coins) self.assertIn(self.fight_sim._ORC_TURN, coins) 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_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 update_screen(self, starter=''): if self.state == 0: self.screen.blit(self.images['white_bg'], (0, 0)) pygame.display.flip() textSurface = self.myfont.render("Choisissez un starter !", False, (0, 0, 255), (255, 255, 255)) self.screen.blit(textSurface, (400, 114)) starter_1 = pygame.transform.scale(self.images['Salamèche'], (112, 112)) starter_1_rect = starter_1.get_rect() starter_1_rect.left = 469 starter_1_rect.top = 214 self.screen.blit(starter_1, (469, 214)) starter_2 = pygame.transform.scale(self.images['Bulbizarre'], (112, 112)) starter_2_rect = starter_2.get_rect() starter_2_rect.left = 669 starter_2_rect.top = 214 self.screen.blit(starter_2, (669, 214)) starter_3 = pygame.transform.scale(self.images['Carapuce'], (112, 112)) starter_3_rect = starter_3.get_rect() starter_3_rect.left = 269 starter_3_rect.top = 214 self.screen.blit(starter_3, (269, 214)) pygame.display.flip() self.state = 1 return { 'Salamèche': starter_1_rect, 'Bulbizarre': starter_2_rect, 'Carapuce': starter_3_rect } elif self.state == 1: self.screen.blit(self.images['white_bg'], (0, 0)) pygame.display.flip() self.screen.blit(self.images['fight_bg'], (0, 0)) pygame.display.flip() self.fight = Fight(starter, Rattata(), self) return
def fight(self): # list of Fight objects fights = [] # only fight if there's a unit here if not self.unit_in_loc: return fights # dictionary of PlayerColor to list of locations fighting_locations = {} fighting_locations = self.add_fighting_neighbor( fighting_locations, Direction.EAST) fighting_locations = self.add_fighting_neighbor( fighting_locations, Direction.WEST) fighting_locations = self.add_fighting_neighbor( fighting_locations, Direction.SOUTH) fighting_locations = self.add_fighting_neighbor( fighting_locations, Direction.NORTH) if self.unit_in_loc: fighting_locations = util.add_loc_to_fight_queue( fighting_locations, self.unit_in_loc.owner, self) while len(fighting_locations.keys()) > 1: # Dictionary of PlayerColor to Location round_fighters = {} for color in fighting_locations.keys(): round_fighters[color] = fighting_locations[color].pop() while len(round_fighters) > 1: fight_results = unit.resolve_fight_round(round_fighters) for color in fight_results: if fight_results[color]: round_fighters[color].unit_in_loc = None dead_loc = round_fighters.pop(color) fights.append(Fight((dead_loc.x, dead_loc.y))) if len(fighting_locations[color]) == 0: # If this was the last unit for this player, remove that player from the fight. fighting_locations.pop(color) else: fighting_locations[color].append(round_fighters[color]) return fights
all_players = [] for x in range(0, num_players / 3): red_clan_member = ClanMember("player_red_" + str(x), clan_red) green_clan_member = ClanMember("player_green_" + str(x), clan_green) blue_clan_member = ClanMember("player_blue_" + str(x), clan_blue) all_players.append(red_clan_member) all_players.append(green_clan_member) all_players.append(blue_clan_member) print clan_red print clan_green print clan_blue f = Fight() df = DominationFight() print "round,red_count,green_count,blue_count" for round_count in range(0, 10000): for x in range(0, num_players): player_a = random.choice(all_players) player_b = random.choice(all_players) #if round_count % 300: f.fight(player_a, player_b) #else: # df.fight(player_a, player_b) if round_count % 300 == 0: print str(round_count) + "," + str(clan_red.size()) + "," + str(
class Dungeon: def __init__(self, file_path): self.get_map(file_path) def set_enemies(self): self.enemies = [] self.enemies.append(Enemy(health=100, mana=100, damage=20)) self.enemies.append(Enemy(health=80, mana=80, damage=10)) self.enemies.append(Enemy(health=150, mana=150, damage=25)) self.enemies.append(Enemy(health=120, mana=120, damage=15)) self.enemies.append(Enemy(health=50, mana=70, damage=45)) def set_treasure(self): self.treasure = [] spell = [] spell.append(Spell(name="djsn", damage=20, mana_cost=20, cast_range=1)) spell.append(Spell(name="dksm", damage=10, mana_cost=10, cast_range=3)) spell.append(Spell(name="sajj", damage=25, mana_cost=25, cast_range=1)) spell.append(Spell(name="sajk", damage=15, mana_cost=15, cast_range=2)) spell.append(Spell(name="sakm", damage=45, mana_cost=45, cast_range=1)) weapon = [] weapon.append(Weapon(name="snsankansn", damage=20)) weapon.append(Weapon(name="nsknaknska", damage=10)) weapon.append(Weapon(name="sanjnkjsna", damage=25)) weapon.append(Weapon(name="lakklaksla", damage=15)) weapon.append(Weapon(name="klaskamkml", damage=45)) self.treasure.append(spell) self.treasure.append(weapon) def get_map(self, file_path): self.dungeon = [] f = open(file_path, "r") for line in f: temp = [] for el in line: temp.append(el) self.dungeon.append(temp) def print_map(self): for row in self.dungeon: for el in row: print(el, end="") def spawn(self, hero): self.hero = hero for y in range(len(self.dungeon)): for x in range(len(self.dungeon[y])): if self.dungeon[y][x] == "S": self.dungeon[y][x] = "H" return True return False def get_hero_location(self): for y in range(len(self.dungeon)): for x in range(len(self.dungeon[y])): if self.dungeon[y][x] == "H": return (x, y) return False def move_up(self): location = self.get_hero_location() if location[1] < 0: return False elif self.dungeon[location[0]][location[1] + 1] == "#": return False elif self.dungeon[location[0]][location[1] + 1] == "T": self.pick_treasure() elif self.dungeon[location[0]][location[1] + 1] == ".": self.dungeon[location[0]][location[1]] = "." self.dungeon[location[0]][location[1] + 1] = "H" elif self.dungeon[location[0]][location[1] + 1] == "E": self.fight = Fight(self.hero, self.enemies[randint(0, 4)]) self.fight.start(self) if self.fight.start(self): self.dungeon[location[0]][location[1] + 1] = "H" else: self.spawn(hero) def move_down(self): location = self.get_hero_location() if location[1] >= len(self.dungeon): return False elif self.dungeon[location[0]][location[1] - 1] == "#": return False elif self.dungeon[location[0]][location[1] - 1] == "T": self.pick_treasure() elif self.dungeon[location[0]][location[1] - 1] == ".": self.dungeon[location[0]][location[1]] = "." self.dungeon[location[0]][location[1] - 1] = "H" elif self.dungeon[location[0]][location[1] - 1] == "E": self.fight = Fight(self.hero, self.enemies[randint(0, 4)]) if self.fight.start(self): self.dungeon[location[0]][location[1] - 1] = "H" else: self.spawn(hero) def move_left(self): location = self.get_hero_location() if location[0] < 0: return False elif self.dungeon[location[0] - 1][location[1]] == "#": return False elif self.dungeon[location[0] - 1][location[1]] == "T": self.pick_treasure() elif self.dungeon[location[0] - 1][location[1]] == ".": self.dungeon[location[0]][location[1]] = "." self.dungeon[location[0] - 1][location[1]] = "H" elif self.dungeon[location[0] - 1][location[1]] == "E": self.fight = Fight(self.hero, self.enemies[randint(0, 4)]) self.fight.start(self) if self.fight.start(self): self.dungeon[location[0] - 1][location[1]] = "H" else: self.spawn(hero) def move_right(self): location = self.get_hero_location() if location[0] >= len(self.dungeon[0]) - 1: return False elif self.dungeon[location[0] + 1][location[1]] == "#": return False elif self.dungeon[location[0] + 1][location[1]] == "T": self.pick_treasure() elif self.dungeon[location[0] + 1][location[1]] == ".": self.dungeon[location[0]][location[1]] = "." self.dungeon[location[0] + 1][location[1]] = "H" elif self.dungeon[location[0] + 1][location[1]] == "E": self.fight = Fight(self.hero, self.enemies[randint(0, 4)]) if self.fight.start(self): self.dungeon[location[0] + 1][location[1]] = "H" else: self.spawn(hero) def move_hero(self, direction): if direction == "up": self.move_up() elif direction == "down": self.move_down() elif direction == "left": self.move_left() elif direction == "right": self.move_right() def pick_treasure(self): index = randint(0, 1) if index: self.hero.equip(self.pick_treasures[1][randint(0, 4)]) else: self.hero.learn(self.pick_treasures[0][randint(0, 4)])
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()