def test_valid_number():
gb = Gameboard()
assert gb.valid_number(-3) == False
assert gb.valid_number(72) == False
assert gb.valid_number(1) == True
assert gb.valid_number(0) == True
def test_valid_choice():
gb = Gameboard()
assert gb.valid_choice("y") == True
assert gb.valid_choice("Y") == True
assert gb.valid_choice("n") == True
assert gb.valid_choice("N") == True
assert gb.valid_choice("U") == False
def __init__(self):
# GAME: MAIN VARIABLES
self.initial_time = time()
self.level = 0
self.start = False
self.game_over = [False, ""]
# GAMEBOARD
self.Gameboard = Gameboard()
self.constants = self.Gameboard.Constants
self.width = self.constants.width
self.height = self.constants.height
self.cell_size = self.constants.cell_size
self.grid = self.Gameboard.grid
# SCOREBOARD
self.scoreboard = Scoreboard()
# PLATFORMS AND GATES
self.platforms = self.Gameboard.platforms
self.entry_gate = self.Gameboard.generate_gate(self.platforms)
self.exit_gate = self.Gameboard.generate_gate(
self.platforms, self.entry_gate.row_index, exit_gate=True)
# TOOLS
self.user_x = 0
self.user_y = self.scoreboard.height
self.cursor_displacement = self.cell_size
self.tools = {
"umbrella": [],
"blocker": [],
"right_s": [],
"left_s": []
}
# LEMMING
self.alive = []
self.saved = []
self.dead = []
self.Lemming = Lemming(self.entry_gate.x, self.entry_gate.y,
self.platforms)
self.lemmings_num = self.Lemming.lemmings_num
# DRAW
self.Draw = Draw(self.platforms, self.entry_gate, self.exit_gate)
# PYXEL
self.pyxel_window_title = "Lemmings"
pyxel.init(self.width, self.height, caption=self.pyxel_window_title)
pyxel.load("./assets/resources.pyxres")
pyxel.run(self.interaction, self.update)
def generateMoves(snapshot, isPlayer):
"""
Crear tableros con nuevos movimientos para evaluar nuevos escenarios
"""
output = []
for x in range(3):
for y in range(3):
if (snapshot.board[x][y] == "\t"):
game = Gameboard(snapshot.width, snapshot.height,
snapshot.player, snapshot.opponent)
game.board = deepcopy(snapshot.board)
game.addChip(isPlayer, x, y)
output.append(game)
return output
def execAction(self, gameboard: Gameboard, actionIndex):
if actionIndex == 0:
gameboard.moveUp()
elif actionIndex == 1:
gameboard.moveDown()
elif actionIndex == 2:
gameboard.moveLeft()
else:
gameboard.moveRight()
def getReward(self, gameboard: Gameboard):
status = gameboard.getGameStatus()
if status == 0:
return -1
if status == -1:
return -100
else:
return 0
def test_gameboard_init():
gb = Gameboard()
assert len(gb.board) == 2
assert len(gb.deck.cards) == 50
# Ensure that the cards displayed are different
suit_check = gb.board[0].suit != gb.board[1].suit
rank_check = gb.board[0].rank != gb.board[1].rank
assert suit_check or rank_check
def execPolicy(self, gameboard: Gameboard, greedy=False):
epsilon = 0.1
position = gameboard.getPosition()
if greedy:
return self.q_valueTable[position].argmax()
else:
if np.random.random() < epsilon:
return np.random.choice(4)
else:
return self.q_valueTable[position].argmax()
def test_print_board(self):
global letters
gb = Gameboard()
for row in range(gb.length):
curr_row = ""
for col in range(gb.length):
curr_row = curr_row + " " + str(gb.visibleGameboard[row][col])
if row == 0:
self.assertEqual(curr_row, " 1 2 3 4 5 6 7 8 9 10")
else:
self.assertEqual(
curr_row,
" {} . . . . . . . . . .".format(letters[row - 1]))
def test_gameboard(self):
global letters
gb = Gameboard()
self.assertEqual(gb.length, 11)
self.assertEqual(gb.visibleGameboard[0][0], " ")
self.assertEqual(gb.invisibleGameboard[0][0], " ")
for y in range(1, gb.length):
for x in range(1, gb.length):
self.assertEqual(gb.visibleGameboard[y][x], ".")
self.assertEqual(gb.invisibleGameboard[y][x], " ")
for y in range(1, gb.length):
self.assertEqual(gb.visibleGameboard[y][0], letters[y - 1])
self.assertEqual(gb.invisibleGameboard[y][0], letters[y - 1])
for x in range(1, gb.length):
self.assertEqual(gb.visibleGameboard[0][x], x)
self.assertEqual(gb.invisibleGameboard[0][x], x)
def initGameboards(mode, players):
keyDicts = []
keyDict0 = {'1': 0, '2': 1, '3': 2, '4': 3, '5': 4}
keyDict1 = {'6': 0, '7': 1, '8': 2, '9': 3, '0': 4}
keyDict2 = {'z': 0, 'x': 1, 'c': 2, 'v': 3, 'b': 4}
keyDict3 = {'n': 0, 'm': 1, ',': 2, '.': 3, '/': 4}
keyDicts.extend([keyDict0, keyDict1, keyDict2, keyDict3])
mode.gameboards = []
for i in range(mode.players):
if not mode.presetGameboard:
newBoard = Gameboard(mode.players)
else:
newBoard = PresetGameboard(mode.players)
newBoard.initBoardDimensions(i, mode.width / mode.players,
mode.height)
newBoard.setKeysDict(keyDicts[i])
mode.gameboards.append(newBoard)
def __init__(self, platforms, entry_gate, exit_gate):
self.gameboard = Gameboard()
self.constants = self.gameboard.Constants
# DIMENSIONS
self.width = self.constants.width
self.height = self.constants.height
self.cell_size = self.constants.cell_size
self.grid_columns = self.constants.grid_columns
# COLORS
self.BLACK = 0
self.DARK_BLUE = 1
self.BROWN = 4
self.WHITE = 7
self.GREEN = 11
self.BLUE = 12
# MAIN OBJECTS
self.platforms = platforms
self.entry_gate = entry_gate
self.exit_gate = exit_gate
4. If the player cannot make a move as described in rule 2, they can continue to reveal cards until this is possible.
5. If all the cards have been revealed and there are no more moves avaialble, the game is over.
6. The goal is to have the least amount of piles once the board reaches such a state as described in rule 5.
*************************************************
EXAMPLE CARD:
[ (SUIT, RANK) ]
C ===> CLUB
S ===> SPADE
H ===> HEART
D ===> DIAMOND
*************************************************
*************************************************
To Exit Game Early: CTRL + C + Enter
*************************************************
\n''')
gb = Gameboard()
while True:
# Display inital state
gb.display_state()
# Let player choose next move
gb.prompt_for_move()
# Remove one of the stepping stones, and return true
ffNode.items.remove(gs.TILE_STEPPING_STONE)
return True
# All other cases:
else:
return False
# -------------------------------
# main
# -------------------------------
# Construct scenario
# Gameboard is a list of lists
gameboard = Gameboard()
gameboard.gamemap = []
map_row0 = [' ', '~', '~', '~']
map_row1 = [' ', '*', 'g', '*']
map_row2 = [' ', '*', '*', '*']
map_row3 = [' ', ' ', ' ', ' ']
gameboard.gamemap.append(map_row0)
gameboard.gamemap.append(map_row1)
gameboard.gamemap.append(map_row2)
gameboard.gamemap.append(map_row3)
# Set current position
gameboard.curr_position = { 'x': 0, 'y': 3 }
# Set direction
gameboard.direction = Gameboard.DIRECTION_LEFT
from World import World from Display import Display from Point import Point from Gameboard import Gameboard from RectangleFieldGameboardDisplay import RectangleFieldGameboardDisplay from WorldDisplay import WorldDisplay WIDTH = 300 HEIGTH = 300 g = Gameboard(10, 10) p = RectangleFieldGameboardDisplay(Point(100, 500), HEIGTH, WIDTH) wd = WorldDisplay(p) w = World(b) Display.create_window(600, 600) Display.set_background() # p.display(g) w.display(g) # world = World(30, 30) # world1 = World() # pygame.init() # x = 500 # y = 100 # handle = pygame.display.set_mode((x, y)) # handle.fill((255, 255, 255)) # pygame.draw.line(handle, (0, 0, 0), (100, 100), (200, 200)) # pygame.draw.line(handle, (0, 255, 0), (100, 100), (100, 200)) # pygame.draw.line(handle, (0, 0, 255), (100, 100), (200, 100)) # pygame.draw.rect(handle, (0, 0, 0), (100, 100, 100, -50), 1)
from Gameboard import Gameboard
from Agent import Agent
import numpy as np
import matplotlib.pyplot as plt
agent = Agent()
game_record = []
print('Training agent for {} games'.format(100))
for i in range(100):
game = Gameboard()
while game.getGameStatus() == 0:
firstPosition = game.getPosition()
actionIndex = agent.execPolicy(game)
agent.execAction(game, actionIndex)
newPosition = game.getPosition()
reward = agent.getReward(game)
agent.updateTable(firstPosition, newPosition, actionIndex, reward)
game_record.append(game.getGameStatus())
plt.plot(game_record)
plt.ylabel('Game results')
plt.title('Game record over {} games'.format(100))
plt.show()
print('Testing trained agent for one game')
if level == 1:
level = EASY
elif level == 2:
level = MEDIUM
else:
level = HARD
except KeyboardInterrupt:
print("Fin abrupto del programa")
quit()
except:
print("Hubo un error, creo que no tecleaste un número")
# === Ver quien INICIA ===
print("Voy a lanzar una moneda para ver quien inicia...")
turn = random.choice(["X", "O"])
print("Obtuve {}".format(turn))
game = Gameboard(3, 3, machine, user)
game.print()
if turn == machine:
game.addChip(True, random.randint(0, 2), random.randint(0, 2))
turn = user
game.print()
# === Ciclo del juego entre jugador vs máquina ===
winner = 0
while canMove(game.board) and winner == 0:
if turn == user:
print("Es TU turno")
valid = False
while not valid:
try:
print(
"¿Qué FILA seleccionas? [0 (Hasta arriba), 2(Hasta abajo)]"
return [maxScore, bestMove]
else:
minScore = float('inf')
children = getChildren(snapshot, False)
for child in children:
result = minimax(child, depth - 1, True, checkScore, getChildren)
minScore = min(result[0], minScore)
if minScore == result[0]:
bestMove = child.lastMove
if len(children) == 0:
if snapshot is not None:
return [checkScore(snapshot.board, snapshot.getPlayerFormat(), snapshot.getOpponentFormat()), snapshot.lastMove]
return [checkScore(snapshot, snapshot, snapshot), snapshot]
return [minScore, bestMove]
if __name__ == "__main__":
print("==== Tablero 3x3 ====")
g = Gameboard(3, 3, "X", "O")
g.addChip(True, 0, 0)
g.addChip(False, 1, 1)
g.addChip(False, 2, 2)
g.addChip(True, 0, 2)
g.print()
print("==== MOVIMIENTO ====")
res = minimax(g, 3, True, evaluate, generateMoves)
print("Mover la pieza a {1} (Score: {0})".format(res[0], res[1]))
g.addChip(False, res[1][0], res[1][1])
g.print()
print("==== MOVIMIENTO ====")
def run():
players = []
game_boards = []
print("""
Willkommen zu Niko Lehbrink's Schiffe Versenken!
Nachdem du deinen Spielern Namen gegeben hast,
kannst du auswählen, ob dieser Computergeneriert wird,
oder ob eine reale Person dahinter steckt...
Die Regeln:
Es gibt 5 Boote, die zu verteilen sind oder automatisch verteilt werden.
Pro Runde darf man einmal schiessen; sobald ein gegnerisches
Schiff getroffen wurde, ist der angreifende Spieler nochmal am Zug.
Ein Treffer wird als rotes """ + Fore.RED + "X" + Style.RESET_ALL +
""" angezeigt.
Ein missglückter Schuss ins Wasser wird als blaues """ + Fore.CYAN + "»" +
Style.RESET_ALL + """ angezeigt.
Viel Erfolg!
| | |
)_) )_) )_)
)___))___))___)
)____)____)_____)
_____|____|____|____\___
---------\ /---------
^^^^^ ^^^^^^^^^^^^^^^^^^^^^
^^^^ ^^^^ ^^^ ^^
^^^^ ^^^
""")
# 1 bis 3, weil Spielernummer so einfacher ausgegeben wird - statt Spieler 0, wird dadurch Spieler 1 ausgegeben
for i in range(1, 3):
while (True):
name = input("Spieler %s: Bitte Namen eingeben: " % i)
# Wenn Vor und Nachname eingegeben wird und der zusammengefügte String nicht nur Buchstaben enthält
if not "".join(name.split()).isalpha():
announce("invalid_name")
continue
break
while (True):
print("Welcher Spielertyp soll %s sein?" % name)
player_type = input(
"'C' für Computergeneriert, 'M' für Mensch: ").lower()
if player_type == 'c':
player = Player(name, get_random_ai_shot)
gameboard = Gameboard(10, 10, create_random_battleships())
players.append(player)
game_boards.append(gameboard)
break
elif player_type == 'm':
# Beim Auswählen eines menschlichen Spielers, ist es möglich die Schiffe automatisch zu platzieren, oder dies händisch zu tun
player = Player(name, get_human_shot)
# Bei einmaligen Ausgaben und input-Methoden wurde auf die Benutzung der announce-Methode verzichtet
print("Möchtest du deine Schiffe selbst platzieren?")
while (True):
create_ships = input(
"'J' für selbst generieren, 'N' für Computergeneriert: "
).lower()
if create_ships == 'j':
gameboard = Gameboard(10, 10, create_own_battleships())
break
elif create_ships == 'n':
gameboard = Gameboard(10, 10,
create_random_battleships())
time.sleep(3)
break
else:
announce("no_valid_input")
continue
players.append(player)
game_boards.append(gameboard)
break
else:
print("Gib einen validen Spielertypen ein!")
continue
offensive_index = 0
time_in_between_turns = 4
while (True):
print(
Fore.LIGHTYELLOW_EX +
"Wie viele Sekunden sollen zwischen den einzelnen Spielzügen gewartet werden?"
+ Style.RESET_ALL)
try:
time_in_between_turns = float(
input("Eingabe erfolgt als Zahl (Empf.: 4): "))
except ValueError:
announce("no_valid_input")
continue
break
while (True):
# Clear Terminal
os.system('cls')
# Immer die Zahl, die der Gegenpart nicht ist
defensive_index = (offensive_index + 1) % 2
defensive_board = game_boards[defensive_index]
offensive_player = players[offensive_index]
defensive_player = players[defensive_index]
# Zur eindeutigen Benennung, wessen Feld ab der nächsten Line gezeigt wird
print("%s's Feld:" % defensive_player.name)
# Wenn auf True gesetzt, dann sieht man alle Schiffe auf dem Spielfeld
render(defensive_board, False)
print("")
announce("new_turn", {"player": offensive_player.name})
# Welche Koordinaten als nächstes beschossen werden sollen
shot_location = offensive_player.shot_function(defensive_board)
# Clear, damit nun das aktualisierte Board mit kommendem Schuss an gleicher Stelle im Terminal angezeigt wird.
os.system('cls')
# Schuss auf die vorher ausgewählten Koordinaten
hit_battleship = defensive_board.take_shot(shot_location)
print("%s's Feld:" % defensive_player.name)
# Wenn auf True gesetzt, dann sieht man alle Schiffe auf dem Spielfeld
render(defensive_board, False)
print("")
# Um die Anzeige etwas nutzerfreundlicher zu machen
if (offensive_player.shot_function.__name__ != "get_human_shot"):
announce("new_turn", {"player": offensive_player.name})
print("")
announce("shot_location", {"coordinates": shot_location})
if defensive_board.is_game_over():
announce("win", {"player": offensive_player.name})
time.sleep(5)
break
if hit_battleship is None:
# Wenn nicht getroffen, switche die Spieler und der nächste Spieler darf jetzt spielen
announce("miss", {"player": offensive_player.name})
offensive_index = defensive_index
else:
if hit_battleship.is_destroyed():
announce(
"destroyed", {
"player": offensive_player.name,
"ship_name": hit_battleship.name
})
else:
# Wenn ein Hit, aber nicht zerstört
announce(
"hit", {
"player": offensive_player.name,
"ship_name": hit_battleship.name
})
announce("next_try")
# Zeit zwischen den einzelnen Spielzügen
time.sleep(time_in_between_turns)
def test_hit_and_get_result(self):
gb1 = Gameboard()
gb1.invisibleGameboard[1][1] = "X"
gb1.invisibleGameboard[1][2] = "X"
gb1.invisibleGameboard[1][3] = "X"
self.assertEqual(gb1.hit_and_get_result("A1"), "Hit")
self.assertEqual(gb1.visibleGameboard[1][1], "X")
self.assertEqual(gb1.hit_and_get_result("A2"), "Hit")
self.assertEqual(gb1.visibleGameboard[1][2], "X")
self.assertEqual(gb1.hit_and_get_result("A3"), "Hit")
self.assertEqual(gb1.visibleGameboard[1][3], "X")
self.assertEqual(gb1.hit_and_get_result("A4"), "Miss")
self.assertEqual(gb1.visibleGameboard[1][4], "-")
self.assertEqual(gb1.hit_and_get_result("F4"), "Miss")
self.assertEqual(gb1.visibleGameboard[6][4], "-")
self.assertEqual(gb1.visibleGameboard[1][5], ".")
self.assertEqual(gb1.visibleGameboard[6][6], ".")
self.assertEqual(gb1.hit_and_get_result("A11"), "Error")
self.assertEqual(gb1.hit_and_get_result(""), "Error")
self.assertEqual(gb1.hit_and_get_result("asdf"), "Error")
self.assertEqual(gb1.hit_and_get_result("11"), "Error")
self.assertEqual(gb1.hit_and_get_result("99999999999999999999999999"),
"Error")
self.assertEqual(gb1.hit_and_get_result("A99999999999999999999999999"),
"Error")
def test_valid_move():
gb = Gameboard()
board_state_1 = [Card("S", "A"), Card("S", "2")]
board_state_2 = [Card("S", "A"), Card("C", "A")]
board_state_3 = [
Card("S", "A"),
Card("C", "2"),
Card("D", "3"),
Card("H", "3")
]
board_state_4 = [
Card("S", "A"),
Card("C", "2"),
Card("D", "3"),
Card("S", "4")
]
board_state_5 = [
Card("S", "A"),
Card("C", "2"),
Card("D", "3"),
Card("H", "A")
]
gb.board = board_state_1
assert gb.valid_move(1, 101) == False
# Test 1 to the right suit move
assert gb.valid_move(0, 1) == True
assert gb.valid_move(0, 3) == False # Out of bounds check
gb.board = board_state_2
# Test 1 to the right rank move
assert gb.valid_move(0, 1) == True
assert gb.valid_move(0, 3) == False # Out of bounds check
gb.board = board_state_3
# Test with more options and valid 3 to the right
assert gb.valid_move(0, 1) == False
assert gb.valid_move(0, 3) == False
assert gb.valid_move(1, 2) == False
assert gb.valid_move(2, 3) == True
gb.board = board_state_4
# Test valid 3 to the right suit match
assert gb.valid_move(0, 1) == False
assert gb.valid_move(1, 3) == False
assert gb.valid_move(2, 1) == False
assert gb.valid_move(0, 3) == True
gb.board = board_state_4
# Test valid 3 to the right rank match
assert gb.valid_move(0, 1) == False
assert gb.valid_move(1, 3) == False
assert gb.valid_move(2, 3) == False
assert gb.valid_move(0, 3) == True
def __init__(self):
self.__game_board = Gameboard(5, 5)
self.__command = Command()
self.__ship_list = [] #list of ship objects
class Game():
CIEL = 0, 200, 255
BLUE = 0, 102, 255
WHITE = 255, 255, 255
GREEN = 0, 255, 0
RED = 255, 0, 0
YELLOW = 255, 255, 100
PURPLE = 204, 0, 153
GRAY = 150, 150, 150
WIDTH = 1080
HEIGHT = 720
WINDOW_WIDTH = WIDTH / 4
WINDOW_HEIGHT = HEIGHT / 2
WIDTH_BUTTON = 100
def __init__(self):
pygame.init()
def setLeonardo(self, player, fenetre):
leonardo = "Leonardo : " + player
myfont = pygame.font.SysFont("monospace", 12)
label = myfont.render(leonardo, 1, (0, 0, 0))
fenetre.blit(label, (540, 375))
def getMyInventors(self, colour):
myparse = parse.Parse()
myteam = myparse.getTeam()
for team in myteam:
if (team.color == colour):
return team.inventors
def drawButtonNbPlayer(self, fenetre, offset):
return pygame.draw.rect(fenetre, Game.WHITE,
[Game.WIDTH / 5 * offset - Game.WIDTH_BUTTON / 2,
Game.HEIGHT / 3, Game.WIDTH_BUTTON, 50])
def selectIALevel(self):
fenetre = pygame.display.set_mode((self.WIDTH, self.HEIGHT))
fond = pygame.image.load("background.jpg").convert()
background = pygame.transform.scale(fond, (int(Game.WIDTH), int(Game.HEIGHT)))
fenetre.blit(background, (0, 0))
myfont = pygame.font.SysFont("monospace", 52)
label = myfont.render("Select the difficulty", 1, (0, 0, 0))
fenetre.blit(label, (Game.WIDTH / 2 - label.get_width() / 2, Game.HEIGHT / 4 - label.get_height()))
button_IABasic = pygame.draw.rect(fenetre, Game.WHITE,
[Game.WIDTH / 5, Game.HEIGHT / 3, Game.WIDTH_BUTTON, 50])
button_IAAdvanced = pygame.draw.rect(fenetre, Game.WHITE,
[Game.WIDTH / 5 * 4, Game.HEIGHT / 3, Game.WIDTH_BUTTON, 50])
myfont = pygame.font.SysFont("monospace", 12)
labelAI1 = myfont.render(str("AI Basic"), 1, (0, 0, 0))
labelAI2 = myfont.render(str("AI Advanced"), 1, (0, 0, 0))
fenetre.blit(labelAI1, (Game.WIDTH / 5 + 10, Game.HEIGHT / 3 + 20))
fenetre.blit(labelAI2, (Game.WIDTH / 5 * 4 + 10, Game.HEIGHT / 3 + 20))
pygame.display.flip()
loop = True
while loop:
for i in range(1, 5):
myfont = pygame.font.SysFont("monospace", 14)
# label = myfont.render(str(i + 1), 1, (0, 0, 0))
fenetre.blit(label, (Game.WIDTH / 2 - label.get_width() / 2, Game.HEIGHT / 4 - label.get_height()))
for event in pygame.event.get():
if event.type == pygame.QUIT:
continue
if event.type == pygame.MOUSEBUTTONDOWN and Game.WIDTH / 5 < event.pos[
0] < Game.WIDTH / 5 + Game.WIDTH_BUTTON and Game.HEIGHT / 3 < event.pos[
1] < Game.HEIGHT / 3 + 50:
print("AI Basic")
self.loadSettingMenu()
loop = False
if event.type == pygame.MOUSEBUTTONDOWN and Game.WIDTH / 5 * 4 < event.pos[
0] < Game.WIDTH / 5 * 4 + Game.WIDTH_BUTTON and Game.HEIGHT / 3 < event.pos[
1] < Game.HEIGHT / 3 + 50:
print("AI Advanced")
self.loadSettingMenu()
loop = False
pygame.display.flip()
def selectIANumber(self, playerColor):
fenetre = pygame.display.set_mode((self.WIDTH, self.HEIGHT))
fond = pygame.image.load("background.jpg").convert()
background = pygame.transform.scale(fond, (int(Game.WIDTH), int(Game.HEIGHT)))
fenetre.blit(background, (0, 0))
myfont = pygame.font.SysFont("monospace", 52)
label = myfont.render("Select max numbers of players ", 1, (0, 0, 0))
fenetre.blit(label, (Game.WIDTH / 2 - label.get_width() / 2, Game.HEIGHT / 4 - label.get_height()))
loop = True
while loop:
button_2 = self.drawButtonNbPlayer(fenetre, 1)
button_3 = self.drawButtonNbPlayer(fenetre, 2)
button_4 = self.drawButtonNbPlayer(fenetre, 3)
button_5 = self.drawButtonNbPlayer(fenetre, 4)
for i in range(1, 5):
myfont = pygame.font.SysFont("monospace", 14)
label = myfont.render(str(i + 1), 1, (0, 0, 0))
fenetre.blit(label, (Game.WIDTH / 5 * i + label.get_width() / 2, Game.HEIGHT / 3))
nbPlayer = 0
for event in pygame.event.get():
if event.type == pygame.QUIT:
loop = False
if event.type == pygame.MOUSEBUTTONDOWN and 166 < event.pos[0] < 266 and 240 < event.pos[1] < 290:
print("Players :2")
self.showGameScreen(playerColor, 2)
loop = False
if event.type == pygame.MOUSEBUTTONDOWN and 382 < event.pos[0] < 482 and 240 < event.pos[1] < 290:
print("Players :3")
self.showGameScreen(playerColor, 3)
loop = False
if event.type == pygame.MOUSEBUTTONDOWN and 598 < event.pos[0] < 698 and 240 < event.pos[1] < 290:
print("Players :4")
self.showGameScreen(playerColor, 4)
loop = False
if event.type == pygame.MOUSEBUTTONDOWN and 814 < event.pos[0] < 914 and 240 < event.pos[1] < 290:
print("Players :5")
self.showGameScreen(playerColor, 5)
loop = False
pygame.display.flip()
def showGameScreen(self, playerColor, IAnumber):
clock = pygame.time.Clock()
fenetre = pygame.display.set_mode((self.WIDTH, self.HEIGHT))
fond = pygame.image.load("background.jpg").convert()
background = pygame.transform.scale(fond, (int(Game.WINDOW_WIDTH * 3), int(Game.WINDOW_HEIGHT)))
fenetre.blit(background, (0, Game.WINDOW_HEIGHT))
fondCard = pygame.image.load("backgroundCard.png").convert()
self.setLeonardo("null", fenetre)
self.loadPlayersBackgrounds(fenetre, fondCard, playerColor, IAnumber)
# exchanges 2 items of a list
def exchangeList(self, list, pos1, pos2):
tmp = list[pos1]
list[pos1] = list[pos2]
list[pos2] = tmp
return list
# Places the player in the bottom right corner and randomizes other players position
def placeColors(self, strPlayerColor, IANumber):
if strPlayerColor == "green":
playerColor = Game.GREEN
elif strPlayerColor == "purple":
playerColor = Game.PURPLE
elif strPlayerColor == "red":
playerColor = Game.RED
elif strPlayerColor == "yellow":
playerColor = Game.YELLOW
elif strPlayerColor == "blue":
playerColor = Game.BLUE
colorList = [Game.PURPLE, Game.YELLOW, Game.GREEN, Game.BLUE, Game.RED]
# exchanges 2 positions 60 times => randomizes the list
for x in range(0, 50):
pos1 = 0
pos2 = 0
while pos1 == pos2:
pos1 = random.randrange(0, 5, 1)
pos2 = random.randrange(0, 5, 1)
colorList = self.exchangeList(colorList, pos1, pos2)
pos = 0
for x in range(0, 5):
if colorList[x] == playerColor:
pos = x
if pos != 4:
colorList = self.exchangeList(colorList, pos, 4)
for i in range(0, 5 - IANumber):
colorList.pop(0)
return colorList
def fromRGBtoSTRINGList(self, list, size):
returnList = []
for i in range(0, size):
if list[i] == Game.GREEN:
returnList.append("green")
elif list[i] == Game.RED:
returnList.append("red")
elif list[i] == Game.YELLOW:
returnList.append("yellow")
elif list[i] == Game.PURPLE:
returnList.append("purple")
elif list[i] == Game.BLUE:
returnList.append("blue")
return returnList
def displayKnowledge(self, myfont, knowledge, fenetre, pos1, pos2):
label = myfont.render(knowledge, 1, (0, 0, 0))
fenetre.blit(label, (pos1, pos2))
def displayInventors(self, intPlayer, colorListString, originPosition, fenetre):
oneLine = 12
fonting_space = 40
knowledge_space = 90
inventors = self.getMyInventors(colorListString[intPlayer])
namePos = [originPosition[0] + fonting_space, originPosition[1] + 30]
myfont = pygame.font.SysFont("bitstreamverasans", 10)
label1 = myfont.render(str("Age1"), 1, (0, 0, 0))
label2 = myfont.render(str("Age2"), 1, (0, 0, 0))
label3 = myfont.render(str("Age3"), 1, (0, 0, 0))
fenetre.blit(label1, (830, 550))
fenetre.blit(label2, (870, 550))
fenetre.blit(label3, (910, 550))
myfont = pygame.font.SysFont("bitstreamverasans", 12)
knowledgeLegend = ["Ph :", "Ch :", "Me :", "Ma :", "Vpt :"]
toAddToI = 5
for i in range(0, 5): # display the legend
label = myfont.render(knowledgeLegend[i], 1, (0, 0, 0))
if i == 4:
toAddToI = 6
fenetre.blit(label, (namePos[0] - 30, namePos[1] + (toAddToI + i) * oneLine))
myfont = pygame.font.SysFont("bitstreamverasans", 9)
ownedcard = [["Age1", [namePos[0], -150 + namePos[1] * oneLine]],
["Age2", [namePos[0] + 30, -150 + namePos[1] * oneLine]],
["Age3", [namePos[0] + 60, -150 + namePos[1] * oneLine]]]
for card in ownedcard:
label = myfont.render(card[0], 1, (0, 0, 0))
fenetre.blit(label, card[1])
for inventor in inventors:
namePos = [originPosition[0] + fonting_space, originPosition[1] + 30]
# separates fist and last name into a list
name = inventor.name.split()
vPoints = inventor.points
myfont = pygame.font.SysFont("bitstreamverasans", 9)
label1 = myfont.render(name[0], 1, (0, 0, 0))
if len(name) > 1:
label2 = myfont.render(name[1], 1, (0, 0, 0))
if len(name) > 2:
label3 = myfont.render(name[2], 1, (0, 0, 0))
if len(name) > 0:
fenetre.blit(label1, (namePos[0], namePos[1]))
if len(name) > 1:
fenetre.blit(label2, (namePos[0], namePos[1] + oneLine))
if len(name) > 2:
fenetre.blit(label3, (namePos[0], namePos[1] + oneLine * 2))
fonting_space += 61
myfont = pygame.font.SysFont("bitstreamverasans", 9)
startTargetLegend = [["CP", [namePos[0], namePos[1] + 4 * oneLine]],
["TP", [namePos[0] + 20, namePos[1] + 4 * oneLine]]]
for legend in startTargetLegend:
label = myfont.render(legend[0], 1, (0, 0, 0))
fenetre.blit(label, legend[1])
for i in range(0, 4):
self.displayKnowledge(myfont, str(inventor.currentKnowledge[i]),
fenetre, namePos[0], namePos[1] + (5 + i) * 12)
self.displayKnowledge(myfont, str(inventor.targetKnowledge[i]),
fenetre, namePos[0] + 20, namePos[1] + (5 + i) * 12)
label = myfont.render(vPoints, 1, (0, 0, 0))
fenetre.blit(label, (namePos[0], namePos[1] + (7 + i) * oneLine))
def displayToken(self, fenetre):
line = 2
height = int(self.HEIGHT / 4) # 1/4 of the screen height
tokenOnBoard = self.gameboard.emplacementOnBoard
myfonttoken = pygame.font.SysFont("bitstreamverasans", 10)
i = 0
for token in tokenOnBoard:
print(token[1].type)
if i > 3:
line = 3
if token[1].type == "pointReward":
token1 = myfonttoken.render(str("PT" + str(token[1].level)), 1, (0, 0, 0))
fenetre.blit(token1, (30 + int((i % 4) * (self.WIDTH / 8)), line * height + 130))
if token[2].type == "pointReward":
token2 = myfonttoken.render(str("PT" + str(token[2].level)), 1, (0, 0, 0))
fenetre.blit(token2, (80 + int((i % 4) * (self.WIDTH / 8)), line * height + 130))
if token[1].type == "progressReward":
token1 = myfonttoken.render(str("P" + str(token[1].level)), 1, (0, 0, 0))
fenetre.blit(token1, (30 + int((i % 4) * (self.WIDTH / 8)), line * height + 130))
if token[2].type == "progressReward":
token2 = myfonttoken.render(str("P" + str(token[2].level)), 1, (0, 0, 0))
fenetre.blit(token2, (80 + int((i % 4) * (self.WIDTH / 8)), line * height + 130))
if token[1].type == "availabilityReward":
token1 = myfonttoken.render("CF", 1, (0, 0, 0))
fenetre.blit(token1, (30 + int((i % 4) * (self.WIDTH / 8)), line * height + 130))
if token[2].type == "availabilityReward":
token2 = myfonttoken.render("CF", 1, (0, 0, 0))
fenetre.blit(token2, (80 + int((i % 4) * (self.WIDTH / 8)), line * height + 130))
if token[1].type == "additonalKnowledgeReward":
token1 = myfonttoken.render("DG", 1, (0, 0, 0))
fenetre.blit(token1, (30 + int((i % 4) * (self.WIDTH / 8)), line * height + 130))
if token[2].type == "additonalKnowledgeReward":
token2 = myfonttoken.render("DG", 1, (0, 0, 0))
fenetre.blit(token2, (80 + int((i % 4) * (self.WIDTH / 8)), line * height + 130))
if token[1].type == "classificationReward":
token1 = myfonttoken.render("ST", 1, (0, 0, 0))
fenetre.blit(token1, (30 + int((i % 4) * (self.WIDTH / 8)), line * height + 130))
if token[2].type == "classificationReward":
token2 = myfonttoken.render("ST", 1, (0, 0, 0))
fenetre.blit(token2, (80 + int((i % 4) * (self.WIDTH / 8)), line * height + 130))
i += 1
def displayCards(self, cards, fenetre):
rectSize = 16
positions = []
myfont = pygame.font.SysFont("bitstreamverasans", 10)
line = 2
height = int(self.HEIGHT / 4) # 1/4 of the screen height
height = int(self.HEIGHT / 4) # 1/4 of the screen height
for i in range(0, len(cards)):
if i > 3:
line = 3
positions.append([int(30 + int(i % 4) * (self.WIDTH / 8)), line * height + 30])
label = myfont.render(cards[i].name, 1, (0, 0, 0))
classicationlabel = myfont.render(str(cards[i].classification), 1, (0, 0, 0))
fenetre.blit(label, (30 + int((i % 4) * (self.WIDTH / 8)), line * height + 30))
fenetre.blit(classicationlabel, (15 + int((i % 4) * (self.WIDTH / 8)), line * height + 130))
myfont = pygame.font.SysFont("bitstreamverasans", 14)
knowledgeLegend = ["Ph :", "Ch :", "Me :", "Ma :"]
for i in range(0, len(cards)):
heightoffest = 20
heightknow = 5
for kn in cards[i].knowledge:
widthoffset = 0
for j in range(0, kn):
pygame.draw.rect(fenetre, Game.WHITE,
[positions[i][0] + widthoffset, positions[i][1] + heightoffest,
rectSize, rectSize])
widthoffset += (rectSize + 2)
heightoffest += (rectSize + 2)
if i > 4:
for i in range(0, 4):
heightknow = 20
for j in range(0, 4):
myfont = pygame.font.SysFont("monospace", 12)
label = myfont.render(knowledgeLegend[j], 1, (0, 0, 0))
fenetre.blit(label, (positions[i][0] - 25, positions[i][1] + heightknow))
heightknow += 19
else:
for i in range(i, len(cards) - 4):
heightknow = 20
for j in range(0, 4):
myfont = pygame.font.SysFont("monospace", 12)
label = myfont.render(knowledgeLegend[j], 1, (0, 0, 0))
fenetre.blit(label, (positions[i][0] - 25, positions[i][1] + heightknow + 178))
heightknow += 19
# print(cards[0].knowledge)
def displayButton(self, fenetre, text, posX, posY, sizeX, sizeY, fontSize, color):
buttonSettings = [posX, posY, sizeX, sizeY]
pygame.draw.rect(fenetre, color, [posX, posY, sizeX, sizeY])
myfont = pygame.font.SysFont("bitstreamverasans", fontSize)
label = myfont.render(text, 1, (0, 0, 0))
fenetre.blit(label, (posX + 5, int(posY + sizeY / 2 - fontSize / 2)))
return buttonSettings
def overButton(self, eventPos, buttonSettings):
return buttonSettings[0] < eventPos[0] < buttonSettings[0] + buttonSettings[2] and \
buttonSettings[1] < eventPos[1] < buttonSettings[1] + buttonSettings[3]
def displayDropList(self, fenetre, buttonSettings, inventors):
offsetX = buttonSettings[2] + 1
offsetY = buttonSettings[3]
oneLine = 0
boutons = []
color = Game.WHITE
for inventor in inventors:
if inventor.sleep:
color = Game.GRAY
else:
color = Game.WHITE
self.displayButton(fenetre, inventor.name, buttonSettings[0] + offsetX,
buttonSettings[1] + oneLine,
110, 15, 10, color)
boutons.append([buttonSettings[0] + offsetX, buttonSettings[1] + oneLine, 100, 15])
oneLine += 16
return boutons
def displayInventionPossible(self, fenetre, buttonSettings, inventions):
offsetX = buttonSettings[2] + 1
offsetY = buttonSettings[3]
oneLine = 0
boutons = []
color = Game.WHITE
for invention in inventions:
color = Game.WHITE
self.displayButton(fenetre, invention[2].name, buttonSettings[0] + offsetX,
buttonSettings[1] + oneLine,
110, 15, 10, color)
boutons.append([buttonSettings[0] + offsetX, buttonSettings[1] + oneLine, 100, 15])
oneLine += 16
return boutons
def loadPlayersBackgrounds(self, fenetre, fondCard, playerColor, IANumber):
dropListDisplayed = False
dropListActionDisplayed = False
myInventors = self.getMyInventors(playerColor)
inventorName = ""
ActionChoosen = []
InventorChoosen = []
hasChoosenAction = False
CubePosed = False
# Display Backgrounds for players emplacements
backgroundCard = pygame.transform.scale(fondCard, (int(Game.WINDOW_WIDTH), int(Game.WINDOW_HEIGHT)))
fenetre.blit(backgroundCard, (0, 0))
fenetre.blit(backgroundCard, (int(Game.WINDOW_WIDTH), 0))
fenetre.blit(backgroundCard, (int(Game.WINDOW_WIDTH * 2), 0))
fenetre.blit(backgroundCard, (int(Game.WINDOW_WIDTH * 3), 0))
fenetre.blit(backgroundCard, (int(Game.WINDOW_WIDTH * 3), Game.WINDOW_HEIGHT))
playerPositions = [[0, 0]]
if IANumber > 2:
playerPositions.append([int(Game.WINDOW_WIDTH), 0])
if IANumber > 3:
playerPositions.append([int(Game.WINDOW_WIDTH * 2), 0])
if IANumber > 4:
playerPositions.append([int(Game.WINDOW_WIDTH * 3), 0])
playerPositions.append([int(Game.WINDOW_WIDTH * 3), int(Game.WINDOW_HEIGHT)])
loop = True
colorList = self.placeColors(playerColor, IANumber) # Place the player in the bottom right corner and
# randomize other players position
white_color = Game.WHITE
colorListString = self.fromRGBtoSTRINGList(colorList, len(colorList))
listPlayer = []
for color in colorListString:
player = Player.Player("Player", False)
player.chooseTeam(color)
listPlayer.append(player)
# Display the inventors infos
self.gameboard = Gameboard(1, listPlayer)
cards = self.gameboard.distribute()
self.gameboard.newTurn()
for player in range(0, IANumber):
self.displayInventors(player, colorListString, playerPositions[player], fenetre)
self.displayToken(fenetre)
self.displayCards(cards, fenetre)
# Top Button
button1Settings = self.displayButton(fenetre, "PlaceCube",
Game.WIDTH / 2, Game.HEIGHT / 2 + 30, 100, 50, 14, Game.WHITE)
buttonAddKnowledge = self.displayButton(fenetre, "Add knowledge",
Game.WIDTH / 2, Game.HEIGHT / 10 * 7 + 30, 100, 50, 14, Game.WHITE)
# Bottom Buttons
buttonCoffee = self.displayButton(fenetre, "Coffee",
Game.WIDTH / 2, Game.HEIGHT / 10 * 9 + 30, 60, 20, 14, Game.WHITE)
buttonRecycle = self.displayButton(fenetre, "Recycle",
Game.WINDOW_WIDTH * 2 + Game.WINDOW_WIDTH / 3, Game.HEIGHT / 10 * 9 + 30, 60,
20, 14, Game.WHITE)
while loop:
pygame.display.flip()
# Draw a rectangle outline for each player area
mouse_xy = pygame.mouse.get_pos()
player1 = pygame.draw.rect(fenetre, colorList[0], [0, 0, Game.WINDOW_WIDTH - 3, Game.WINDOW_HEIGHT],
5)
if IANumber > 2:
player2 = pygame.draw.rect(fenetre, colorList[1],
[Game.WINDOW_WIDTH, 0, Game.WINDOW_WIDTH - 3, Game.WINDOW_HEIGHT],
5)
if IANumber > 3:
player3 = pygame.draw.rect(fenetre, colorList[2],
[Game.WINDOW_WIDTH * 2, 0, Game.WINDOW_WIDTH - 3, Game.WINDOW_HEIGHT],
5)
if IANumber > 4:
player4 = pygame.draw.rect(fenetre, colorList[3],
[Game.WINDOW_WIDTH * 3, 0, Game.WINDOW_WIDTH - 3, Game.WINDOW_HEIGHT],
5)
myplayer = pygame.draw.rect(fenetre, colorList[IANumber - 1],
[Game.WINDOW_WIDTH * 3, Game.WINDOW_HEIGHT + 3, Game.WINDOW_WIDTH,
Game.WINDOW_HEIGHT - 5],
5)
# Draw a rectangle outline representing the gameboard with inventions cards
board = pygame.draw.rect(fenetre, white_color,
[0, Game.WINDOW_HEIGHT + 5, Game.WINDOW_WIDTH * 3 - 5, Game.WINDOW_HEIGHT - 6],
5)
for event in pygame.event.get():
if event.type == pygame.QUIT:
loop = False
elif event.type == pygame.MOUSEBUTTONDOWN and dropListActionDisplayed:
droplistaction = self.displayInventionPossible(fenetre, button1Settings, inventionListPosssible)
for button in droplistaction:
if self.overButton(event.pos, button):
self.displayInventionPossible(fenetre, button1Settings, inventionListPosssible)
clickedAction = inventionListPosssible[int((button[1] - 390) / 16)]
ActionChoosen.append(clickedAction[2])
print(clickedAction[2].name)
print(clickedInventor.name)
hasChoosenAction = True
dropListActionDisplayed == False
CubePosed = True
self.Next(clickedAction[2],InventorChoosen)
elif event.type == pygame.MOUSEBUTTONDOWN:
if self.overButton(event.pos, button1Settings):
if dropListDisplayed:
print("hide droplist") # TODO
else:
dropList = self.displayDropList(fenetre, button1Settings, myInventors)
dropListDisplayed = not dropListDisplayed
inventionListPosssible = []
if dropListDisplayed:
for button in dropList:
if self.overButton(event.pos, button):
clickedInventor = self.gameboard.playersOnBoard[len(self.gameboard.playersOnBoard)-1].myTeam.inventors[int((button[1] - 390) / 16)]
clickedInventor.sleep = True
dropList = self.displayDropList(fenetre, button1Settings, myInventors)
print(clickedInventor.name)
InventorChoosen.append(clickedInventor)
dropListDisplayed = not dropListDisplayed
for action in self.gameboard.possibleactions:
dropListDisplayed = False
if (action[1].name == clickedInventor.name):
inventionListPosssible.append(action)
dropListActionDisplayed = not dropListActionDisplayed
print(inventionListPosssible)
dropListActionDisplayed = True
if event.type == pygame.MOUSEBUTTONDOWN and hasChoosenAction and Game.WIDTH / 2 + 180 < event.pos[
0] < Game.WIDTH / 2 + 250 and Game.HEIGHT / 10 * 9 + 30 < event.pos[
1] < Game.HEIGHT / 10 * 9 + 50:
print(ActionChoosen)
# Click on Coffee button
if event.type == pygame.MOUSEBUTTONDOWN and Game.WIDTH / 2 < event.pos[
0] < Game.WIDTH / 2 + 60 and Game.HEIGHT / 10 * 9 + 30 < event.pos[
1] < Game.HEIGHT / 10 * 9 + 50:
loopToken = True
while loopToken:
print(self.gameboard.playersOnBoard[self.gameboard.currentPlayer].myTeam.listTokens)
for token in self.gameboard.playersOnBoard[self.gameboard.currentPlayer].myTeam.listTokens:
# If the tokenList contain an availabilityReward then it remove this one, and call the awake function on all inventors
# Then, it leave the loop
if token.type == "availabilityReward":
self.gameboard.playersOnBoard[self.gameboard.currentPlayer].myTeam.listTokens.remove(token)
self.gameboard.awakeCurrentPlayer()
break
loopToken = False
# Recycle button
if event.type == pygame.MOUSEBUTTONDOWN and Game.WINDOW_WIDTH * 2 + Game.WINDOW_WIDTH / 3 < event.pos[
0] < Game.WINDOW_WIDTH * 2 + Game.WINDOW_WIDTH / 3 + 60 and Game.HEIGHT / 10 * 9 + 30 < event.pos[
1] < Game.HEIGHT / 10 * 9 + 50:
self.gameboard.awakeCurrentPlayer()
self.gameboard.newTurn()
print("Recycle button yata ! ")
pygame.display.flip()
# 10 fps
def loadSettingMenu(self):
clock = pygame.time.Clock()
fenetre = pygame.display.set_mode((self.WIDTH, self.HEIGHT))
fond = pygame.image.load("background.jpg").convert()
background = pygame.transform.scale(fond, (int(Game.WIDTH), int(Game.HEIGHT)))
fenetre.blit(background, (0, 0))
button_green = pygame.draw.rect(fenetre, Game.GREEN,
[Game.WIDTH / 6 - Game.WIDTH_BUTTON / 2, Game.HEIGHT / 4, Game.WIDTH_BUTTON,
50])
button_red = pygame.draw.rect(fenetre, Game.RED,
[Game.WIDTH / 6 * 4 - Game.WIDTH_BUTTON / 2, Game.HEIGHT / 4, Game.WIDTH_BUTTON,
50])
button_blue = pygame.draw.rect(fenetre, Game.BLUE,
[Game.WIDTH / 6 * 2 - Game.WIDTH_BUTTON / 2, Game.HEIGHT / 4, Game.WIDTH_BUTTON,
50])
button_yellow = pygame.draw.rect(fenetre, Game.YELLOW,
[Game.WIDTH / 6 * 3 - Game.WIDTH_BUTTON / 2, Game.HEIGHT / 4,
Game.WIDTH_BUTTON, 50])
button_purple = pygame.draw.rect(fenetre, Game.PURPLE,
[Game.WIDTH / 6 * 5 - Game.WIDTH_BUTTON / 2, Game.HEIGHT / 4,
Game.WIDTH_BUTTON, 50])
myParse = parse.Parse()
myColor = parse.Parse.getColor(myParse)
fontcompt = 1
for item in myColor:
myfont = pygame.font.SysFont("monospace", 14)
label = myfont.render(item, 1, (0, 0, 0))
fenetre.blit(label, (
(Game.WIDTH / 6 * fontcompt - Game.WIDTH_BUTTON / 2 + label.get_width() / 2, Game.HEIGHT / 4)))
fontcompt += 1
myfont = pygame.font.SysFont("monospace", 52)
# render text
label = myfont.render("Select a player!", 1, (0, 0, 0))
fenetre.blit(label, ((Game.WIDTH - label.get_width()) / 2, Game.HEIGHT / 5 - label.get_height()))
loop = True
while loop:
pygame.display.flip()
mouse_xy = pygame.mouse.get_pos()
for event in pygame.event.get():
if event.type == pygame.QUIT:
loop = False
if event.type == pygame.MOUSEBUTTONDOWN and 0 < event.pos[0] < 200 and 150 < event.pos[1] < 250:
print("Green team")
self.getMyTeam("green")
self.selectIANumber("green")
loop = False
if event.type == pygame.MOUSEBUTTONDOWN and 200 < event.pos[0] < 400 and 150 < event.pos[1] < 250:
print("Blue team")
self.getMyTeam("blue")
self.selectIANumber("blue")
loop = False
if event.type == pygame.MOUSEBUTTONDOWN and 400 < event.pos[0] < 600 and 150 < event.pos[1] < 250:
print("Yellow team")
self.getMyTeam("yellow")
self.selectIANumber("yellow")
loop = False
if event.type == pygame.MOUSEBUTTONDOWN and 600 < event.pos[0] < 800 and 150 < event.pos[1] < 250:
print("Red team")
self.getMyTeam("red")
self.selectIANumber("red")
loop = False
if event.type == pygame.MOUSEBUTTONDOWN and 800 < event.pos[0] < 1000 and 150 < event.pos[1] < 250:
print("Purple team")
self.getMyTeam("purple")
self.selectIANumber("purple")
loop = False
pygame.display.flip()
# 10 fps
def getMyTeam(self, colour):
myparse = parse.Parse()
myteams = myparse.getTeam()
for team in myteams:
if team.color == colour:
for inv in team.inventors:
print("Inventor added :" + inv.name)
return team
def Next(self, Invention, Inventor):
knowledgeposed = []
for i in range (0,3):
if Inventor[0].currentKnowledge[i] !=0:
knowledgeposed.append(Inventor[0].name)
knowledgeposed.append(Inventor[0].currentKnowledge[i])
Invention.knowledgeposed = knowledgeposed
from Gameboard import Gameboard
gameboard = Gameboard()
for i in range(10000):
print("# GAME {} #".format(i))
gameboard.play_game()
gameboard.get_stats()
print("LETTER BOXED SOLVER")
# Gets gameboard from user input and checks validity
while (True):
board = input("ENTER THE CHARACTERS IN THE GAMEBOARD: ")
if len(board) != 12:
print("Gameboard needs to be 12 letters long")
continue
for c in board:
if not c.isalpha():
print("Gameboard has to consist of letters")
continue
break
mainBoard = Gameboard(board)
if input("Type 1 for the smaller dictionary, 2 for the bigger one: ") == 1:
words = open("words.txt", "r")
else:
words = open("words_alpha.txt", "r")
# Builds dictionary object and calls recursive algorithm
dict = Dictionary(words, mainBoard)
results = findGameboards(mainBoard)
# Prints solutions which are stored as a dictionary of solutions
# with solution word count as keys
# {"1": [["word1"], ["word2"]], }
solutions = {}
for res in results:
solWords = res.getWords()
def test_fields_correct_creation(self):
gameboard = Gameboard(5, 5)
assert len(gameboard.fields.values()) == 25
for coordinates, field in gameboard.fields.items():
assert self.__field_have_correct_position(field, coordinates)
def loadPlayersBackgrounds(self, fenetre, fondCard, playerColor, IANumber):
dropListDisplayed = False
dropListActionDisplayed = False
myInventors = self.getMyInventors(playerColor)
inventorName = ""
ActionChoosen = []
InventorChoosen = []
hasChoosenAction = False
CubePosed = False
# Display Backgrounds for players emplacements
backgroundCard = pygame.transform.scale(fondCard, (int(Game.WINDOW_WIDTH), int(Game.WINDOW_HEIGHT)))
fenetre.blit(backgroundCard, (0, 0))
fenetre.blit(backgroundCard, (int(Game.WINDOW_WIDTH), 0))
fenetre.blit(backgroundCard, (int(Game.WINDOW_WIDTH * 2), 0))
fenetre.blit(backgroundCard, (int(Game.WINDOW_WIDTH * 3), 0))
fenetre.blit(backgroundCard, (int(Game.WINDOW_WIDTH * 3), Game.WINDOW_HEIGHT))
playerPositions = [[0, 0]]
if IANumber > 2:
playerPositions.append([int(Game.WINDOW_WIDTH), 0])
if IANumber > 3:
playerPositions.append([int(Game.WINDOW_WIDTH * 2), 0])
if IANumber > 4:
playerPositions.append([int(Game.WINDOW_WIDTH * 3), 0])
playerPositions.append([int(Game.WINDOW_WIDTH * 3), int(Game.WINDOW_HEIGHT)])
loop = True
colorList = self.placeColors(playerColor, IANumber) # Place the player in the bottom right corner and
# randomize other players position
white_color = Game.WHITE
colorListString = self.fromRGBtoSTRINGList(colorList, len(colorList))
listPlayer = []
for color in colorListString:
player = Player.Player("Player", False)
player.chooseTeam(color)
listPlayer.append(player)
# Display the inventors infos
self.gameboard = Gameboard(1, listPlayer)
cards = self.gameboard.distribute()
self.gameboard.newTurn()
for player in range(0, IANumber):
self.displayInventors(player, colorListString, playerPositions[player], fenetre)
self.displayToken(fenetre)
self.displayCards(cards, fenetre)
# Top Button
button1Settings = self.displayButton(fenetre, "PlaceCube",
Game.WIDTH / 2, Game.HEIGHT / 2 + 30, 100, 50, 14, Game.WHITE)
buttonAddKnowledge = self.displayButton(fenetre, "Add knowledge",
Game.WIDTH / 2, Game.HEIGHT / 10 * 7 + 30, 100, 50, 14, Game.WHITE)
# Bottom Buttons
buttonCoffee = self.displayButton(fenetre, "Coffee",
Game.WIDTH / 2, Game.HEIGHT / 10 * 9 + 30, 60, 20, 14, Game.WHITE)
buttonRecycle = self.displayButton(fenetre, "Recycle",
Game.WINDOW_WIDTH * 2 + Game.WINDOW_WIDTH / 3, Game.HEIGHT / 10 * 9 + 30, 60,
20, 14, Game.WHITE)
while loop:
pygame.display.flip()
# Draw a rectangle outline for each player area
mouse_xy = pygame.mouse.get_pos()
player1 = pygame.draw.rect(fenetre, colorList[0], [0, 0, Game.WINDOW_WIDTH - 3, Game.WINDOW_HEIGHT],
5)
if IANumber > 2:
player2 = pygame.draw.rect(fenetre, colorList[1],
[Game.WINDOW_WIDTH, 0, Game.WINDOW_WIDTH - 3, Game.WINDOW_HEIGHT],
5)
if IANumber > 3:
player3 = pygame.draw.rect(fenetre, colorList[2],
[Game.WINDOW_WIDTH * 2, 0, Game.WINDOW_WIDTH - 3, Game.WINDOW_HEIGHT],
5)
if IANumber > 4:
player4 = pygame.draw.rect(fenetre, colorList[3],
[Game.WINDOW_WIDTH * 3, 0, Game.WINDOW_WIDTH - 3, Game.WINDOW_HEIGHT],
5)
myplayer = pygame.draw.rect(fenetre, colorList[IANumber - 1],
[Game.WINDOW_WIDTH * 3, Game.WINDOW_HEIGHT + 3, Game.WINDOW_WIDTH,
Game.WINDOW_HEIGHT - 5],
5)
# Draw a rectangle outline representing the gameboard with inventions cards
board = pygame.draw.rect(fenetre, white_color,
[0, Game.WINDOW_HEIGHT + 5, Game.WINDOW_WIDTH * 3 - 5, Game.WINDOW_HEIGHT - 6],
5)
for event in pygame.event.get():
if event.type == pygame.QUIT:
loop = False
elif event.type == pygame.MOUSEBUTTONDOWN and dropListActionDisplayed:
droplistaction = self.displayInventionPossible(fenetre, button1Settings, inventionListPosssible)
for button in droplistaction:
if self.overButton(event.pos, button):
self.displayInventionPossible(fenetre, button1Settings, inventionListPosssible)
clickedAction = inventionListPosssible[int((button[1] - 390) / 16)]
ActionChoosen.append(clickedAction[2])
print(clickedAction[2].name)
print(clickedInventor.name)
hasChoosenAction = True
dropListActionDisplayed == False
CubePosed = True
self.Next(clickedAction[2],InventorChoosen)
elif event.type == pygame.MOUSEBUTTONDOWN:
if self.overButton(event.pos, button1Settings):
if dropListDisplayed:
print("hide droplist") # TODO
else:
dropList = self.displayDropList(fenetre, button1Settings, myInventors)
dropListDisplayed = not dropListDisplayed
inventionListPosssible = []
if dropListDisplayed:
for button in dropList:
if self.overButton(event.pos, button):
clickedInventor = self.gameboard.playersOnBoard[len(self.gameboard.playersOnBoard)-1].myTeam.inventors[int((button[1] - 390) / 16)]
clickedInventor.sleep = True
dropList = self.displayDropList(fenetre, button1Settings, myInventors)
print(clickedInventor.name)
InventorChoosen.append(clickedInventor)
dropListDisplayed = not dropListDisplayed
for action in self.gameboard.possibleactions:
dropListDisplayed = False
if (action[1].name == clickedInventor.name):
inventionListPosssible.append(action)
dropListActionDisplayed = not dropListActionDisplayed
print(inventionListPosssible)
dropListActionDisplayed = True
if event.type == pygame.MOUSEBUTTONDOWN and hasChoosenAction and Game.WIDTH / 2 + 180 < event.pos[
0] < Game.WIDTH / 2 + 250 and Game.HEIGHT / 10 * 9 + 30 < event.pos[
1] < Game.HEIGHT / 10 * 9 + 50:
print(ActionChoosen)
# Click on Coffee button
if event.type == pygame.MOUSEBUTTONDOWN and Game.WIDTH / 2 < event.pos[
0] < Game.WIDTH / 2 + 60 and Game.HEIGHT / 10 * 9 + 30 < event.pos[
1] < Game.HEIGHT / 10 * 9 + 50:
loopToken = True
while loopToken:
print(self.gameboard.playersOnBoard[self.gameboard.currentPlayer].myTeam.listTokens)
for token in self.gameboard.playersOnBoard[self.gameboard.currentPlayer].myTeam.listTokens:
# If the tokenList contain an availabilityReward then it remove this one, and call the awake function on all inventors
# Then, it leave the loop
if token.type == "availabilityReward":
self.gameboard.playersOnBoard[self.gameboard.currentPlayer].myTeam.listTokens.remove(token)
self.gameboard.awakeCurrentPlayer()
break
loopToken = False
# Recycle button
if event.type == pygame.MOUSEBUTTONDOWN and Game.WINDOW_WIDTH * 2 + Game.WINDOW_WIDTH / 3 < event.pos[
0] < Game.WINDOW_WIDTH * 2 + Game.WINDOW_WIDTH / 3 + 60 and Game.HEIGHT / 10 * 9 + 30 < event.pos[
1] < Game.HEIGHT / 10 * 9 + 50:
self.gameboard.awakeCurrentPlayer()
self.gameboard.newTurn()
print("Recycle button yata ! ")
pygame.display.flip()
class App:
def __init__(self):
# GAME: MAIN VARIABLES
self.initial_time = time()
self.level = 0
self.start = False
self.game_over = [False, ""]
# GAMEBOARD
self.Gameboard = Gameboard()
self.constants = self.Gameboard.Constants
self.width = self.constants.width
self.height = self.constants.height
self.cell_size = self.constants.cell_size
self.grid = self.Gameboard.grid
# SCOREBOARD
self.scoreboard = Scoreboard()
# PLATFORMS AND GATES
self.platforms = self.Gameboard.platforms
self.entry_gate = self.Gameboard.generate_gate(self.platforms)
self.exit_gate = self.Gameboard.generate_gate(
self.platforms, self.entry_gate.row_index, exit_gate=True)
# TOOLS
self.user_x = 0
self.user_y = self.scoreboard.height
self.cursor_displacement = self.cell_size
self.tools = {
"umbrella": [],
"blocker": [],
"right_s": [],
"left_s": []
}
# LEMMING
self.alive = []
self.saved = []
self.dead = []
self.Lemming = Lemming(self.entry_gate.x, self.entry_gate.y,
self.platforms)
self.lemmings_num = self.Lemming.lemmings_num
# DRAW
self.Draw = Draw(self.platforms, self.entry_gate, self.exit_gate)
# PYXEL
self.pyxel_window_title = "Lemmings"
pyxel.init(self.width, self.height, caption=self.pyxel_window_title)
pyxel.load("./assets/resources.pyxres")
pyxel.run(self.interaction, self.update)
def interaction(self):
"""Allows the user to interact with the grid to place tools in the map.
This function also add the option to quit the program by pressing Q.
"""
if pyxel.btnp(pyxel.KEY_SPACE):
# Start the game
self.start = True
elif pyxel.btnp(pyxel.KEY_LEFT) and self.user_x > 0:
# Move to the left
self.user_x -= self.cursor_displacement
elif pyxel.btnp(pyxel.KEY_RIGHT) and self.user_x < self.width - 16:
# Move to the right
self.user_x += self.cursor_displacement
elif pyxel.btnp(pyxel.KEY_UP) and self.user_y > 32:
# Move up
self.user_y -= self.cursor_displacement
elif pyxel.btnp(pyxel.KEY_DOWN) and self.user_y < self.height - 16:
# Move down
self.user_y += self.cursor_displacement
elif pyxel.btnp(pyxel.KEY_U):
# Place an umbrella
tools = Tools(self.user_x, self.user_y, "umbrella")
umbrella_x, umbrella_y, umbrella_img = tools.umbrella()
idx, is_tool = self.same_tool_there(umbrella_x, umbrella_y,
self.tools["umbrella"])
if is_tool:
# check if there's the same umbrella already there
self.tools["umbrella"].pop(idx)
elif not self.tool_in_tools(umbrella_x, umbrella_y):
self.tools["umbrella"].append(
[umbrella_x, umbrella_y, umbrella_img])
elif pyxel.btnp(pyxel.KEY_B):
# Place a blocker
tools = Tools(self.user_x, self.user_y, "blocker")
blocker_x, blocker_y, blocker_img = tools.blocker()
idx, is_tool = self.same_tool_there(blocker_x, blocker_y,
self.tools["blocker"])
if is_tool:
# check if there's the same blocker already there
self.tools["blocker"].pop(idx)
elif not self.tool_in_tools(blocker_x, blocker_y):
self.tools["blocker"].append(
[blocker_x, blocker_y, blocker_img])
elif pyxel.btnp(pyxel.KEY_R):
# Place a right stair
tools = Tools(self.user_x, self.user_y, "right_stair")
right_s_x, right_s_y, right_s_right, right_s_img = tools.right_stair(
)
if not self.tool_in_tools(right_s_x, right_s_y):
self.tools["right_s"].append(
[right_s_x, right_s_y, right_s_right, right_s_img])
elif pyxel.btnp(pyxel.KEY_L):
# Place a left stair
tools = Tools(self.user_x, self.user_y, "left_stair")
left_s_x, left_s_y, left_s_left, left_s_img = tools.left_stair()
if not self.tool_in_tools(left_s_x, left_s_y):
self.tools["left_s"].append(
[left_s_x, left_s_y, left_s_left, left_s_img])
elif pyxel.btnp(pyxel.KEY_Q):
# Quit the program
pyxel.quit()
def tool_in_tools(self, tool_x, tool_y):
"""Check if the coordinates x and y of the tools coincide
with some existing ones of any tool"""
for umbrella in self.tools["umbrella"]:
# Check if it coincides with an umbrella
if umbrella[0] == tool_x and umbrella[1] == tool_y:
return True
for blocker in self.tools["blocker"]:
# Check if it coincides with a blocker
if blocker[0] == tool_x and blocker[1] == tool_y:
return True
for right_s in self.tools["right_s"]:
# Check if it coincides with a right stair
if right_s[0] == tool_x and right_s[1] == tool_y:
return True
for left_s in self.tools["left_s"]:
# Check if it coincides with a left stair
if left_s[0] == tool_x and left_s[1] == tool_y:
return True
return False
def same_tool_there(self, tool_x, tool_y, tool_list):
"""The same tool is there"""
is_tool = False
idx = 0
for i in range(len(tool_list)):
if tool_x == tool_list[i][0] and tool_y == tool_list[i][1]:
is_tool = True
idx = i
return idx, is_tool
def update(self):
"""Updates the players and draw the game."""
# LEMMINGS
if self.start and not self.game_over[0]:
lemmings = self.Lemming.update_player(self.tools)
for i in range(len(lemmings)):
if (lemmings[i].x == self.exit_gate.x
and lemmings[i].y == self.exit_gate.y
and i not in self.saved):
# Lemming saved
self.saved.append(i)
if i in self.alive:
self.alive.remove(i)
elif lemmings[i].alive and i not in self.alive:
# Lemming alive
self.alive.append(i)
elif lemmings[i].alive == False and i not in self.dead:
# Lemming dead
self.dead.append(i)
if i in self.alive:
self.alive.remove(i)
if len(self.saved) == self.lemmings_num:
self.game_over[0] = True
self.game_over[1] = "win"
elif len(self.dead) == self.lemmings_num:
self.game_over[0] = True
self.game_over[1] = "lose"
# SCOREBOARD
total_alive = len(self.alive)
total_saved = len(self.saved)
total_dead = len(self.dead)
total_stairs = len(self.tools["right_s"]) + len(self.tools["left_s"])
total_umbrellas = len(self.tools["umbrella"])
total_blockers = len(self.tools["blocker"])
self.scoreboard = Scoreboard(self.level, total_alive, total_saved,
total_dead, total_stairs, total_umbrellas,
total_blockers)
# DRAW
if self.start and self.game_over[0]:
self.Draw.draw_game(self.scoreboard, self.Lemming.before_start(),
self.user_x, self.user_y, self.tools,
self.start, self.game_over[1])
elif self.start:
self.Draw.draw_game(self.scoreboard, lemmings, self.user_x,
self.user_y, self.tools, self.start)
else:
self.Draw.draw_game(self.scoreboard, self.Lemming.before_start(),
self.user_x, self.user_y, self.tools,
self.start)
from Gameboard import Gameboard
from Ship import Ship, Battleship, Destroyer
if __name__ == "__main__":
gb = Gameboard()
ships = [Battleship, Destroyer, Destroyer]
for ship in ships:
ship(gb).place_ship_on_gameboard()
resultFromHit = ""
gb.print_board(1)
while True:
inp = input("Enter coordinates (row, col), e.g. A5 = ")
if inp.lower() == "show":
gb.refresh_screen()
print(" \n")
gb.print_board(2)
else:
resultFromHit = gb.hit_and_get_result(inp)
if Ship.is_any_dead(gb):
resultFromHit = "Sunk"
gb.refresh_screen()
if resultFromHit != "":
print("*** {} *** \n".format(resultFromHit))
gb.print_board(1)
if Ship.AliveShips <= 0:
print("Well done! You completed the game in {} shots".format(
gb.hits))
