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())
