def draw_domino(self, player: Player): """ Draw a domino for the specified player. :param player: the player to add the domino to. :return: the domino that was drawn and given to the player. """ if len(self.dominoes) == 0: return False domino = self.dominoes.pop() player.give_domino(domino) return domino
def draw_domino_and_check_for_start(self, player: Player, starting_domino: Domino) -> bool: """ Helper function when determine the first player. Draws a domino for tha player, then checks to see if it is the required domino for going first. :param player: the player to add the domino to. :param starting_domino: the required starting Domino :return: True if the starting_domino was drawn. """ if len(self.dominoes) == 0: raise RuntimeError( 'Ran out of dominoes while trying to find the starting player. Did we miss the starting tile? ' + str(starting_domino)) d = self.dominoes.pop() if d == starting_domino: if len(self.dominoes) > 0: player.give_domino(self.dominoes.pop()) return True player.dominoes.append(d) return False
class testPlayer(TestCase): def setUp(self): self.player = Player("Alice") def testThatThePlayerHasAName(self): self.assertEqual("Alice", self.player.name) def testThatAPlayerCanOwnZones(self): graveyard = Mock() self.player.addZone(graveyard) self.assertIn(graveyard, self.player.zones) def testThatAddingAZoneAlsoGivesOwnership(self): zone = Mock() self.player.addZone(zone) zone.addOwner.assert_called_with(self.player, addRecursively=False) def testThatAZoneIsAddedNonRecursively(self): zone = Mock() self.player.addZone(zone, addRecursively=False) assert not zone.addOwner.called, "addOwner should not be called when creating the bidirectional relation"
def load_player(el, from_save): name = el.find("name").text.strip() level = el.find('level') if level is None: # If level is not specified, default value is 1 level = 1 else: level = int(level.text.strip()) p_class = el.find("class").text.strip() race = el.find("race").text.strip() gold = int(el.find("gold").text.strip()) exp = int(el.find("exp").text.strip()) if from_save else 0 hp = int(el.find("hp").text.strip()) strength = int(el.find("strength").text.strip()) defense = int(el.find("defense").text.strip()) res = int(el.find("resistance").text.strip()) current_hp = int(el.find("current_hp").text.strip()) if from_save else hp inv = [] for it in el.findall("inventory/item"): it_name = it.text.strip() item = parse_item_file(it_name) inv.append(item) equipments = [] for eq in el.findall("equipment/*"): eq_name = eq.text.strip() eq = parse_item_file(eq_name) equipments.append(eq) if from_save: skills = [(load_skill(skill.text.strip()) if skill.text.strip() not in skills_infos else skills_infos[skill.text.strip()]) for skill in el.findall('skills/skill/name')] tree = etree.parse("data/characters.xml").getroot() player_t = tree.xpath(name)[0] else: skills = Character.classes_data[p_class][ 'skills'] + Character.races_data[race]['skills'] player_t = el # -- Reading of the XML file for default character's values (i.e. sprites) sprite = 'imgs/' + player_t.find('sprite').text.strip() compl_sprite = player_t.find('complement_sprite') if compl_sprite is not None: compl_sprite = 'imgs/' + compl_sprite.text.strip() p = Player(name, sprite, hp, defense, res, strength, [p_class], equipments, race, gold, level, skills, compl_sprite=compl_sprite) p.earn_xp(exp) p.items = inv p.hp = current_hp if from_save: pos = (int(el.find("position/x").text.strip()) * TILE_SIZE, int(el.find("position/y").text.strip()) * TILE_SIZE) p.pos = pos state = el.find("turnFinished").text.strip() if state == "True": p.end_turn() else: # Up stats according to current lvl p.stats_up(level - 1) # Restore hp due to lvl up p.healed() return p
def __init__(self, player_name): self.character_universe = CharacterUniverse() self.player1 = Player(player_name) self.player2 = Player('Bot')
def loop(self): clock = pygame.time.Clock() positions_free, positions, pos_m = lists() #Creacion y ubicacion de jugadores y meta posP = pos_m[0] player_1 = Player(self.display, posP, positions_free) # Se puede añadir mas jugadores en players players = list() players.append(player_1) posW = pos_m[1] pointWin = PointWin(self.display, posW) # Una copia del tiempo transcurrido segundo_ant = -2 while True: # Segundos transcurriendo de haber iniciado pygame segundo_act = int(pygame.time.get_ticks()) // 1000 # Si la copia y los segundos actuales son diferentes if segundo_act != segundo_ant: segundo_ant = segundo_act self.segundo += 1 #El contador global de segundos llega a 30 y reinicia la partida if self.segundo == 45: self.segundo = 0 self.loop() for event in pygame.event.get(): # Si se sale del programa if event.type == pygame.QUIT: self.delete_user() self.send_record() exit() # Si se presiona una tecla if event.type == pygame.KEYDOWN: if event.key == pygame.K_LEFT: pos_player_pos = players[0].get_pos_xy() pos_player_pos[0] += -self.square_size players[0].verify_pos(pos_player_pos) elif event.key == pygame.K_RIGHT: pos_player_pos = players[0].get_pos_xy() pos_player_pos[0] += self.square_size players[0].verify_pos(pos_player_pos) elif event.key == pygame.K_UP: pos_player_pos = players[0].get_pos_xy() pos_player_pos[1] += -self.square_size players[0].verify_pos(pos_player_pos) elif event.key == pygame.K_DOWN: pos_player_pos = players[0].get_pos_xy() pos_player_pos[1] += self.square_size players[0].verify_pos(pos_player_pos) # Fondos e imagenes ------------------------------------------------------------- picture_fondo = pygame.transform.scale( pygame.image.load('src/degradado_dark2.jpeg'), (self.width_total, self.height_total)) self.display.blit(picture_fondo, (0, 0)) picture_fondo_play = pygame.transform.scale( pygame.image.load('src/degradado.png'), (self.width_able, self.height_able)) self.display.blit(picture_fondo_play, (self.square_size, self.square_size)) picture = pygame.transform.scale( pygame.image.load('src/block_red.png'), (self.square_size, self.square_size)) for x in positions: self.display.blit(picture, (x[0], x[1])) # ------------------------------------------------------------------------------- # range tiene 1 porque solo hay 1 jugador en players for playerN in range(1): if players[playerN].get_pos_xy() == posW: self.score += 1 self.segundo = 0 self.loop() players[playerN].draw() pointWin.draw() # Initialize font and draw title and score text pygame.font.init() font = pygame.font.SysFont(pygame.font.get_default_font(), 30) title = font.render('LABERINTO', False, Config['colors']['white']) title_rect = title.get_rect( center=(self.width_able + (self.width_total - self.width_able) / 2, 100)) score_text = 'Score: {}'.format(self.score) score = font.render(score_text, False, Config['colors']['white']) score_rect = score.get_rect( center=(self.width_able + (self.width_total - self.width_able) / 2, 200)) self.display.blit(score, score_rect) self.display.blit(title, title_rect) pygame.display.update() clock.tick(Config['game']['fps'])
class Player_Test(unittest.TestCase): ## Default step for every function def setUp(self): self.activePlayer = Player("Active") self.opponentPlayer = Player("Opponent") def testName(self): log = logging.getLogger("testName") log.debug("Testing names...") ##Testing if the names are correct self.assertEqual(self.activePlayer.name, 'Active') self.assertEqual(self.opponentPlayer.name, 'Opponent') def testHealth(self): log = logging.getLogger("testHealth") log.debug("Testing healths...") ##Testing if health equal to 30 for starting self.assertEqual(self.activePlayer.health, 30) self.assertEqual(self.opponentPlayer.health, 30) def testMana(self): log = logging.getLogger("testMana") log.debug("Testing players' mana...") ##Testing if mana equal to 0 for starting self.assertEqual(self.activePlayer.mana, 0) self.assertEqual(self.opponentPlayer.mana, 0) def testDeck(self): log = logging.getLogger("testDeck") log.debug("Testing decks...") ##Testing if deck is full for starting self.assertEqual(self.activePlayer.deck, deck) self.assertEqual(self.opponentPlayer.deck, deck) def testHand(self): log = logging.getLogger("testHand") log.debug("Testing hands...") ##Testing if hand is empty for starting self.assertEqual(self.activePlayer.hand, []) self.assertEqual(self.opponentPlayer.hand, []) def testManaSlots(self): log = logging.getLogger("testManaSlots") log.debug("Testing manaSlots...") ##Testing if manaSlots equal to 0 for starting self.assertEqual(self.activePlayer.manaSlots, 0) self.assertEqual(self.opponentPlayer.manaSlots, 0) def testDraw(self): log = logging.getLogger("testDraw") log.debug("Testing getCard function...") ##Testing if it gets a card or not self.activePlayer.getCard() self.assertEqual(len(self.activePlayer.deck), 19) self.assertEqual(len(self.activePlayer.hand), 1) ##Overload log.debug("Testing Overload") self.activePlayer.deck = [9] self.activePlayer.hand = [1, 2, 3, 4, 5] self.activePlayer.getCard() ##Testing if it gets more than 5 card or not self.assertEqual(len(self.activePlayer.hand), 5) ##Testing if 6th card is discarded self.assertEqual(self.activePlayer.hand, [1, 2, 3, 4, 5]) ##Bleeding Out log.debug("Testing Bleeding Out...") self.activePlayer.deck = [] self.activePlayer.getCard() ##Testing if it receives 1 damage when deck is empty self.assertEqual(self.activePlayer.health, 29) def testPlay(self): log = logging.getLogger("testMana") log.debug("Testing PlayCard function...") self.activePlayer.hand = [4, 5, 6] self.activePlayer.mana = 10 self.activePlayer.playCard(4, self.opponentPlayer) ##Testing if opponent received damage self.assertEqual(self.opponentPlayer.health, 26) ##Testing if played card is removed self.assertEqual(len(self.activePlayer.hand), 2) ##Testing if played card reduced mana self.assertEqual(self.activePlayer.mana, 6) def testHandCards(self): log = logging.getLogger("testHandCards") log.debug("Testing printing hand function...") ## Testing hand with cards log.debug("Testing hand with cards") self.activePlayer.hand = [4, 5] self.assertEqual( self.activePlayer.handCards(), "\n##### ##### \n# # # # \n# 4 # # 5 # \n# # # # \n##### ##### " ) ## Testing hand without card log.debug("Testing hand without card") self.activePlayer.hand = [] self.assertEqual(self.activePlayer.handCards(), "\n")
def createPlayer(self, name): player = Player(name) deck = self.createDeck() player.deck = deck return player
def __init__(self): self.piece = '' self.player = Player()
block.rect.y = temp_y if temp_x < screen_width - 80: temp_x += 40 else: temp_x = 40 temp_y += 40 block_list.add(block) all_sprites_list.add(block) # variables score = 0 running = True clock = pygame.time.Clock() player = Player((screen_width / 2) - 40, screen_height - 40, player_image, screen) all_sprites_list.add(player) # set the timers pygame.time.set_timer(move_down_event, MOVE_DOWN) # setting win label win_label = win_font.render("YOU WIN!", 1, WHITE) while running: # setting up labels, have to do in loop to update the variables score_label = font.render("Score: " + str(score), 1, WHITE) # lock the framerate clock.tick(60)
def test_give_domino(self): p = Player(1, TestBot()) d = Domino(2, 3) p.give_domino(d) self.assertTrue(p.dominoes.__contains__(d))
np.array(self.history[self.winner]['states'])) np.save(f'{filename}_moves.npy', np.array(self.history[self.winner]['moves'])) def uniform_board(self): new_board = [] for j in self.board.board: row = [] for i in j: row.append(int(1 / (0.5 * i) if i else i)) new_board.append(row) return new_board def export_final_results(self): if self.winner is not None: moves = np.array(self.history[self.winner]['moves']) states = np.array(self.history[self.winner]['states']) return moves, states, 'ok' return None, None, None if __name__ == '__main__': b = Board() model = load_model('my_first_model.h5') p1 = Player(1, b, model, 0.1) p2 = Player(2, b, model, 0.1) g = RecordedAIGame(b, p1, p2) g.initialize() g.play_a_game() print(g.export_final_results())
def setUp(self): self.TestGame = Game(Player("p1"), Player("p2"))
levelRow[j] = Level("maps\\" + files[j], i, j) # Add the row of levels to the level list levels.append(levelRow) # Tick i = i + 1 # Close the map file map_file.close() # Initialize coordinates for the current level currentLevelX = 2 currentLevelY = 1 # Initialize a variable to represent the level currently being drawn currentLevel = levels[1][2] # Initialize the player player = Player(100, 100) currentLevel.resetPlayer(player) # Start the clock clock = pygame.time.Clock() ''' Main loop ''' gameExit = False while not gameExit: # If the game is on the main menu if game_state == 0: # Get the current mouse position mouse_pos = pygame.mouse.get_pos() # Draw the menu
np.save(f'{filename}_states.npy', np.array(self.history[self.winner]['states'])) np.save(f'{filename}_moves.npy', np.array(self.history[self.winner]['moves'])) def uniform_board(self): new_board = [] for j in self.board.board: row = [] for i in j: row.append(int(1 / (0.5 * i) if i else i)) new_board.append(row) return new_board def export_final_results(self): if self.winner is not None: moves = np.array(self.history[self.winner]['moves']) states = np.array(self.history[self.winner]['states']) return moves, states, 'ok' return None, None, None if __name__ == '__main__': b = Board() p1 = Player(1, b) p2 = Player(2, b) g = RecordedGame(b, p1, p2) g.initialize() g.play_a_game() print(g.export_final_results())
inspector is player 0, it must be represented by the first socket. fantom is player 1, it must be representer by the second socket. """ def init_connexion(): while len(clients) != 2: link.listen(2) (clientsocket, addr) = link.accept() logger.info("Received client !") clients.append(clientsocket) clientsocket.settimeout(500) if __name__ == '__main__': players = [Player(0), Player(1)] scores = [] logger.info("no client yet") init_connexion() logger.info("received all clients") # profiling pr = cProfile.Profile() pr.enable() game = Game(players) game.lancer() link.close()
def load_game(self): try: save = open("saves/main_save.xml", "r") # Test if there is a current saved game if save: tree_root = etree.parse("saves/main_save.xml").getroot() index = tree_root.find("level/index").text.strip() level_name = 'maps/level_' + index + '/' game_status = tree_root.find("level/phase").text.strip() turn_nb = 0 if game_status != 'I': turn_nb = int(tree_root.find("level/turn").text.strip()) team = [] for player in tree_root.findall("team/player"): name = player.find("name").text.strip() level = int(player.find("level").text.strip()) p_class = player.find("class").text.strip() race = player.find("race").text.strip() gold = int(player.find("gold").text.strip()) exp = int(player.find("exp").text.strip()) hp = int(player.find("hp").text.strip()) strength = int(player.find("strength").text.strip()) defense = int(player.find("def").text.strip()) res = int(player.find("res").text.strip()) move = int(player.find("move").text.strip()) current_hp = int(player.find("currentHp").text.strip()) pos = (int(player.find("position/x").text.strip()) * TILE_SIZE, int(player.find("position/y").text.strip()) * TILE_SIZE) state = player.find("turnFinished").text.strip() inv = [] for it in player.findall("inventory/item"): it_name = it.find("name").text.strip() item = LoadFromXMLManager.parse_item_file(it_name) inv.append(item) equipments = [] for eq in player.findall("equipments/equipment"): eq_name = eq.find("name").text.strip() eq = LoadFromXMLManager.parse_item_file(eq_name) equipments.append(eq) # -- Reading of the XML file for default character's values (i.e. sprites) tree = etree.parse("data/characters.xml").getroot() player_t = tree.xpath(name)[0] sprite = 'imgs/dungeon_crawl/player/' + player_t.find('sprite').text.strip() compl_sprite = player_t.find('complementSprite') if compl_sprite is not None: compl_sprite = 'imgs/dungeon_crawl/player/' + compl_sprite.text.strip() p = Player(name, sprite, hp, defense, res, move, strength, [p_class], equipments, race, gold, level, compl_sprite=compl_sprite) p.earn_xp(exp) p.items = inv p.set_current_hp(current_hp) p.pos = pos if state == "True": p.turn_finished() team.append(p) # Load level with current game status, foes states, and team self.level_id = int(index) level = Level(level_name, team, self.level_id, game_status, turn_nb, tree_root.find("level/entities")) self.play(level) save.close() return except FileNotFoundError: # No saved game self.background_menus.append([self.active_menu, True]) name = "Load Game" entries = [[{'type': 'text', 'text': "No saved game.", 'font': fonts['MENU_SUB_TITLE_FONT']}]] width = self.screen.get_width() // 2 self.active_menu = InfoBox(name, "", "imgs/interface/PopUpMenu.png", entries, width, close_button=1)
def test_choose_with_no_pre_choice(self): test_player = Player() test_plate = [['A', 'B', 'A'], ['C', 'D', 'A'], ['A', 'X', 'X']] self.assertEqual('A', test_player.choose(plate=test_plate))
class GUI: """ This class handle the simulation interface of the system """ def __init__(self): self.piece = '' self.player = Player() def drawBoard(self, player): """ This function draws the board of the game which includes adding the river and chess pieces :param player: This object is used to get the current chess piece list to draw the pieces on the board """ self.player = player self.currentPlayer = self.player.getCurrentPlayer() self.pieceList= self.player.getCurrentPieceList() print("-----------------------------------------------------------------------") for col in range(1,10): print("\t{}\t".format(col), end=('\n' if col == 9 else '')) for row in range(1,11): print("\n{}".format(row), end='') for col in range (1,10): self.findPiece(row,col) print("\t{}\t".format(self.piece),end=('\n' if col == 9 else '')) if row == 5: self.drawRiver() print("-----------------------------------------------------------------------") def drawRiver(self): """ This function draw the river on the board with symbol (~~) """ for row in range(2): for col in range (1,10): print("\t~~\t",end=('\n' if col == 9 else '')) def findPiece(self, row, col): """ This function draw the chess piece using symbol in the chess piece list or draw (*) if the position is empty. This function will be called for each location on the chess board. :param row, col: Board position variable which will be compared with the position of the chess piece in the chess piece list. """ self.piece='' pos =(row, col) for i in range(len(self.pieceList)): if self.pieceList[i]['Pos'] == pos: self.piece = self.pieceList[i]['Symbol'] else: pass if self.piece == '': self.piece = "*"
def test_choose_with_pre_choice(self): test_player = Player() test_plate = [['A', 'B', 'A'], ['C', 'D', 'A'], ['A', 'X', 'X']] test_player.set_cur_choice(test_plate[0][0]) self.assertEqual('B', test_player.choose(plate=test_plate))
def setUp(self): self.snakes = {14: 7} self.board = Board(self.snakes) self.dice = RegularDice() self.player = Player("Test Player", self.dice) self.game = SnakesAndLadders(self.player, self.board, 1)
else: temp_x = (screen_width/2) + 40 temp_y += 40 elite_list.add(block) enemy_list.add(block) all_sprites_list.add(block) spawn_elites(ENEMIES) spawn_grunts(ENEMIES) # variables score = 0 running = True clock = pygame.time.Clock() player = Player((screen_width / 2) - 40, screen_height - 40, player_image, screen) all_sprites_list.add(player) # set the timers pygame.time.set_timer(move_grunts_down_event, MOVE_GRUNTS_DOWN) pygame.time.set_timer(move_elites_down_event, MOVE_ELITES_DOWN) pygame.time.set_timer(respawn_event, RESPAWN_SPEED) # setting lose label lose_label = large_font.render("YOU LOSE!", 1, WHITE) while running: # setting up labels, have to do in loop to update the variables score_label = font.render("Score: " + str(score), 1, WHITE) # lock the framerate
def setUp(self): self.player = Player("Alice")
def test_get_initial_default_location(self): initial_default_location = (0, 0) player = Player() self.assertEqual(initial_default_location, player.GetLocation())
pygame.display.set_caption("Dice game") myfont = pygame.font.SysFont("Monospace", 15) # creating constants LEFT_BUTTON = 1 WHITE = (255, 255, 255) BLACK = (0, 0, 0) FOREST_GREEN = (34, 139, 34) window.fill(FOREST_GREEN) # creating bool var and player objects running = True clicked = False show_hidden = False player = Player(150) computer = Player(240) # creating buttons reroll_msg = myfont.render("Reroll", 1, WHITE) button_reroll = reroll_msg.get_rect() button_reroll.x = 150 button_reroll.y = 350 show_msg = myfont.render("Show", 1, WHITE) button_show = show_msg.get_rect() button_show.x = 300 button_show.y = 350 result_msg = myfont.render("Results", 1, WHITE) button_result = result_msg.get_rect()
def setUp(self): self.activePlayer = Player("Active") self.opponentPlayer = Player("Opponent")
block.rect.y = temp_y if temp_x < screen_width - 80: temp_x += 40 else: temp_x = 40 temp_y += 40 block_list.add(block) all_sprites_list.add(block) # variables score = 0 running = True clock = pygame.time.Clock() player = Player((screen_width / 2) - 40, screen_height - 40, player_image, screen) all_sprites_list.add(player) # set the timers pygame.time.set_timer(move_down_event, MOVE_DOWN) pygame.time.set_timer(respawn_event, RESPAWN_SPEED) # setting lose label lose_label = large_font.render("YOU LOSE!", 1, WHITE) while running: # setting up labels, have to do in loop to update the variables score_label = font.render("Score: " + str(score), 1, WHITE) # lock the framerate clock.tick(60)
def test_get_initial_defined_location(self): location = (7, 19) player = Player(location) self.assertEqual(location, player.GetLocation())