def main():
# set up window display stuff
pygame.display.set_caption('Catan')
screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
game_board = GameBoard(300, 100, WINDOW_WIDTH / 2, 100)
running = True
time_between_frames = 1 / FRAMES_PER_SECOND
# ~~~~~ MAIN GAME LOOP ~~~~~
while running:
screen.fill((100, 100, 200))
start_time = time.time()
game_board.draw(screen)
game_board.hex_board.select(game_board.hex_board.roads)
pygame.display.flip()
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
sleep_time = (start_time + time_between_frames) - time.time()
if sleep_time > 0:
time.sleep(sleep_time)
def __init__(self, player_array):
'''
:param playerArray: Array of possible players
:param boardSize: Board will have size [boardSize x boardSize]
'''
# player_class = player_array['random']
players = list(player_array.values())
self.player1_color = 0
self.player2_color = 1
self.player1 = player_creator.create_player(players[0],
self.player1_color,
self.player2_color,
BOARD_SIZE)
self.player2 = player_creator.create_player(players[-1],
self.player2_color,
self.player1_color,
BOARD_SIZE)
self.board = GameBoard(board_size=BOARD_SIZE)
self.sleep_time_ms = 200
self.gui = ReversiView(players=player_array, boardSize=BOARD_SIZE)
self.gui.set_game(self)
self.gui.set_board(self.board)
self.clear_game()
self.paused = False
print('gui created')
def __init__(self):
super().__init__()
self.pieces = []
self.col = QColor(0, 0, 0)
locs = [10, 120, 230]
self.o_pix = QIcon('O.png')
self.x_pix = QIcon('X.png')
self.b_pix = QIcon('B.png')
for i, (y, x) in enumerate(itertools.product(locs, locs)):
game_piece = QPushButton(self)
game_piece.setGeometry(x, y, 100, 100)
game_piece.setIcon(self.b_pix)
game_piece.setIconSize(QSize(100,100))
game_piece.id = i
game_piece.clicked.connect(self.piece_pressed)
self.pieces.append(game_piece)
self.setGeometry(300, 300, 340, 380)
self.setFixedSize(self.size())
self.setWindowTitle('3T-RL')
self.show()
# Initialize the gameboard
self.pos_lookup = {i:(x,y) for i,(x,y) in enumerate(itertools.product(range(3), range(3)))}
self.board = GameBoard()
self.policy = MovementPolicy()
def __init__(self, game_number, file_name=None):
self.winner = 0 # The winner
self.board_size = 3 # The board size
self.game_number = game_number # The game number
self.game_board = GameBoard(self.board_size) # Board creation
self.file_name = file_name
# Computer Player move - easy bot
if game_number == 1:
self.computer_player = ComputerPlayer() # The Computer Player
# Computer Player move - strong bot
elif game_number == 2:
self.player_list = []
self.player_list.append(PlayerQRL(1, 0.1, 0.9, 0.7, game_number,
1)) # The QRL Computer Player
# Load saved players data:
load_players_stats(self.player_list, file_name)
elif game_number == 3:
self.player_list = []
# Add 1st Player:
self.player_list.append(ComputerPlayer())
# Add 2nd Player:
self.player_list.append(ComputerPlayer())
# Load saved players data:
load_players_stats(self.player_list, file_name)
elif game_number == 4:
self.player_list = []
# Add 1st Player:
# Parameters: mark, learning rate, discount, exploration rate
self.player_list.append(PlayerQRL(1, 0.1, 0.9, 0.7, game_number,
1))
# Add 2nd Player:
self.player_list.append(ComputerPlayer())
# Load saved players data:
load_players_stats(self.player_list, file_name)
elif game_number == 5:
self.player_list = []
# Add 1st Player:
# Parameters: mark, learning rate, discount, exploration rate
self.player_list.append(
PlayerQRL(-1, 0.1, 0.9, 0.7, game_number, 1))
# Add 2nd Player:
self.player_list.append(PlayerQRL(1, 0.1, 0.9, 0.7, game_number,
1))
# Load saved players data:
load_players_stats(self.player_list, file_name)
def test_initial_play_creates_3_x_3_board_with_piece_in_middle(self):
board = GameBoard()
piece = Piece()
board.play(piece)
self.assertEqual(3, len(board._board))
self.assertEqual(3, len(board._board[0]))
self.assertEqual(piece, board._board[1][1])
def __init__(self):
self.__running = False
self.screen = pygame.display.set_mode(
(Consts.WINDOW_WIDTH, Consts.WINDOW_HEIGHT))
self.__clock = pygame.time.Clock() # frame clock
self.__game_board = GameBoard()
self.player = Player()
self.control_panel = ControlPanel(self.player)
self.caretaker = Caretaker(self.player)
def test_scoring(self):
game_board = GameBoard()
game_board.board = [
[0, 0, 1, 3],
[0, 6, 0, 2],
[0, 12, 0, 0],
[24, 0, 0, 0],
]
self.assertEqual(game_board.calc_score(), 3*2+6+27+81)
def __init__(self):
self.board = GameBoard()
self.ai = Expectimax()
self.init_game()
print_board(self.board)
self.run_game()
self.over = False
def init(self):
self.screen = pygame.display.get_surface()
self.game_running = True
self.screen.fill(BLACK)
# initialize game components
self.game_board = GameBoard(self, self.game_grid)
self.highlighter.init()
self.initialize_buttons()
def __init__(self, master=None, height=0, width=0):
tk.Canvas.__init__(self, master, height=height, width=width)
self.draw_gameBoard()
self.gameBoard = GameBoard()
self.boardSearcher = BoardSearcher()
self.boardSearcher.board = self.gameBoard.board()
self.turn = 2
self.undo = False
self.depth = 2
self.prev_exist = False
self.prev_row = 0
self.prev_col = 0
def main(args):
try:
board = GameBoard(rows=args.rows, cols=args.cols, mines=args.mines)
except RuntimeError as error:
print(error)
sys.exit(1)
board.generate_board()
game_renderer = GameRenderer(board)
game_renderer.play_game()
print('\n\nThanks for playing :)')
def __init__(self, player1, player1_color, player2, player2_color, board_size=8):
'''
:param player1: Instance of first player
:param player1_color: color of player1
:param player2: Instance of second player
:param player1_color: color of player2
:param boardSize: Board will have size [boardSize x boardSize]
'''
self.board = GameBoard(board_size, player1_color, player2_color)
self.player1 = player1
self.player2 = player2
self.current_player = self.player1
self.current_player_color = player1_color
self.player1_color = player1_color
self.player2_color = player2_color
def __init__(self, *args, **kwargs):
tk.Tk.__init__(self, *args, **kwargs)
#Class variables for game window. frames holds each menu, game creates
#object from game_board, reveal, unlock, and score used for in game.
self.frames = {}
self.Game = GameBoard()
self.reveal = tk.IntVar()
self.unlock = False
self.score = {
"CURRENT": {
"RESULT": "",
"GOLD": 0,
"MOVES": 0
},
"BEST": {
"RESULT": "",
"GOLD": 0,
"MOVES": 0
}
}
#top-level frame
container = tk.Frame(self)
container.pack(side="top", fill="both", expand=True)
container.grid_rowconfigure(0, weight=1)
container.grid_columnconfigure(0, weight=1)
#Dictionary of frames for use in 'show_frame'
for i in (MainMenu, GameMenu, EndMenu):
frame = i(container, self)
self.frames[i] = frame
frame.grid(row=0, column=0, sticky="nsew")
self.show_frame(MainMenu)
def run_game():
logger = Logger()
gb = GameBoard()
p1 = Player('X')
game = Game(logger, gb, p1)
game.choose_player()
game.play()
def run(tree):
board = GameBoard(
position=DEFAULT_POS,
destination=GOAL_POS,
terminal=False,
hits=0,
# parent_position=(None, None),
)
step = 0
while True:
step += 1
# print("step", step, "distance", get_distance(board.position, board.destination))
# break the loop from pygame
for event in pygame.event.get():
if event.type == QUIT:
sys.exit(0)
elif event.type == KEYDOWN and event.key == K_ESCAPE:
sys.exit(0)
for _ in range(ROLLOUTS):
tree.do_rollout(board)
board = tree.do_choose(board)
sim.body_character.position = board.position
sim.render()
if board.terminal:
print("WIN STEP", step, "WIN POS", GOAL_POS, "DISTANCE",
get_distance(board.position, board.destination),
"Position", board.position)
return step
def play(self):
GameBoard(SCREEN_WIDTH)
snake = Snake(3)
snake.registerKeyListener(self.screen)
food = Food()
scoreBoard = ScoreBoard()
while self.gameRunns:
start = time.time()
if not self.gamePaused:
scoreBoard.update_scoreboard()
snake.show()
food.show()
snake.move()
if self.recognize_collision(snake, food, scoreBoard):
snake.hide()
food.hide()
scoreBoard.game_over()
self.gameRunns = False
else:
scoreBoard.pause()
snake.hide()
food.hide()
self.screen.update()
time.sleep(max(1.0 / snake.speed - (time.time() - start), 0))
self.screen.exitonclick()
def initGameBoardFrame(self, width=None, height=None):
if width is None or height is None:
width = self.board_width
height = self.board_height
else:
self.board_width = width
self.board_height = height
self.game_board_frame = GameBoard(self, self.mode)
self.game_board_frame.setMinimumSize(width, height)
self.game_board_frame.setMaximumSize(width, height)
self.game_board_frame.setObjectName("game_board_frame")
self.game_board_frame.show()
self.game_board_frame.game_over_tool_bar_signal.connect(
self.parent_widget.gameOver)
def __init__(self, player1, player1_color, player2, player2_color,
board_size):
'''
:param player1: instance of {Player} for first player
:param player1_color: {int} color of player1
:param player2: instance of {Player} for second player
:param player1_color: {int} color of player2
:param boardSize: {int}, board will have size [board_size x board_size]
'''
self.board = GameBoard(board_size, player1_color, player2_color)
self.player1 = player1
self.player2 = player2
self.current_player = self.player1
self.current_player_color = player1_color
self.player1_color = player1_color
self.player2_color = player2_color
def __init__(self, player_array):
"""
:param player_array: Array of possible players
"""
player_class = player_array['random']
self.player1_color = 0
self.player2_color = 1
self.player1 = player_class(self.player1_color, self.player2_color)
self.player2 = player_class(self.player2_color, self.player1_color)
self.board = GameBoard()
self.sleep_time_ms = 200
self.gui = ReversiView(player_array)
self.gui.set_game(self)
self.gui.set_board(self.board)
self.clear_game()
self.paused = False
print('gui created')
def main():
if len(sys.argv) == 2 and sys.argv[1] == "-d":
dev_logger()
else:
logger()
loop = asyncio.get_event_loop()
game_board = GameBoard()
start_server = game_board.create_server(IP, PORT)
try:
logging.info("Start")
loop.create_task(game_board.game_loop())
loop.run_until_complete(start_server)
loop.run_forever()
except KeyboardInterrupt:
loop.call_soon_threadsafe(loop.stop)
logging.warning("Caught keyboard interrupt. Stopping Server...")
def __init__(self, player_array):
'''
:param playerArray: Array of possible players
:param boardSize: Board will have size [boardSize x boardSize]
'''
player_class = player_array['random']
self.player1_color = 0
self.player2_color = 1
self.player1 = player_class(self.player1_color, self.player2_color)
self.player2 = player_class(self.player2_color, self.player1_color)
self.board = GameBoard()
self.sleep_time_ms = 0
self.gui = ReversiView(player_array)
self.gui.set_game(self)
self.gui.set_board(self.board)
self.clear_game()
self.paused = False
print('gui created')
def main():
pygame.init()
screen: pygame.Surface = pygame.display.set_mode(
((BLOCK_SIZE * NBLOCKS) * 2 + PADDING * 3,
BLOCK_SIZE * NBLOCKS + TOP_MARGIN + PADDING))
screen.fill(colors.screen_bkgd)
pygame.display.set_caption('USNA Battleship')
# size of the game board figure based on BLOCK SIZE pixels
board_dimension = (BLOCK_SIZE * NBLOCKS, BLOCK_SIZE * NBLOCKS)
# "my" game board displays my ships with their guesses
my_board: GameBoard = GameBoard(board_dimension, screen)
my_board.rect.top = TOP_MARGIN
my_board.rect.left = PADDING
# "their" game board displays my guesses with their *sunk* ships
their_board: GameBoard = GameBoard(board_dimension, screen)
their_board.rect.top = TOP_MARGIN
their_board.rect.left = PADDING * 2 + my_board.rect.width
# --------- BEGIN YOUR CODE ----------
# add titles above the game boards
# draw 'YOU' centered above my_board
# draw 'THEM' centered above their_board
# --------- END YOUR CODE ----------
my_board.initialize()
my_board.draw()
their_board.initialize()
their_board.draw()
pygame.display.update()
# wait until the user closes the game
while True:
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
def play():
game_board = GameBoard()
player = Player()
logging.basicConfig(
filename='dd_game.log',
format=
"%(asctime)s - %(name)s - %(levelname)s - %(message)s - [FUNCTION]: %(funcName)s - line %(lineno)d",
level=logging.DEBUG)
monster, door, player.location = game_board.get_locations()
logging.info("GAME_DIMENSIONS: {}".format(str(game_board.GAME_DIMENSIONS)))
logging.info("LOCATIONS: Monster - {}; Door - {}; Player - {}"\
.format(monster, door, player.location))
while True:
game_board.clear()
print("WELCOME TO THE DUNGEON!")
moves = game_board.get_moves(player.location)
game_board.draw_map(player)
current_plyr_loc = "\nYou're currently in room {}".\
format(player.location)
logging.info(current_plyr_loc)
print(current_plyr_loc)
print("\nYou can move {}".format(', '.join(moves)))
print("Enter QUIT to quit")
move = input("> ").upper()
if move in ['QUIT', 'Q']:
break
if move not in moves:
print("\n** Walls are hard! Stop running into them! **\n")
continue
player.move_player(move)
if player.location == door:
logging.info('Escaped at {}'.format(player.location))
print("\n** You escaped! **\n")
break
elif player.location == monster:
logging.info('Eaten at {}'.format(player.location))
print("\n** You got eaten! **\n")
break
def test_raises_placement_error_when_placing_invalid_tiles_adjacent_vertically(
self):
board = GameBoard()
red_circle = Piece(shape=SHAPES.CIRCLE, color=COLORS.RED)
board.play(red_circle)
green_circle = Piece(shape=SHAPES.CIRCLE, color=COLORS.GREEN)
board.play(green_circle, x=1, y=2)
green_triangle = Piece(shape=SHAPES.TRIANGLE, color=COLORS.GREEN)
with self.assertRaises(InvalidPlayException):
board.play(green_triangle, x=1, y=3)
def test_raises_placement_error_when_placing_on_edge_of_board(self):
board = GameBoard()
piece = Piece()
board.play(piece)
with self.assertRaises(InvalidPlayException):
board.play(piece, x=0, y=0)
def __init__(self):
self.game_over = False
self.turn = 0
self.last_move_row = 0
self.last_move_col = 0
self.game_board = GameBoard()
self.action = None
self.sq_size: int = 100
self.width: int = 7 * self.sq_size
self.height: int = 7 * self.sq_size
self.size: Tuple[int, int] = (self.width, self.height)
self.radius: int = int(self.sq_size / 2 - 5)
class GameBoardTests(unittest.TestCase):
def setUp(self):
self.gb1 = GameBoard(test_mode=True)
self.gb2 = GameBoard(test_mode=True, dim=(5, 5))
def test_creation(self):
self.assertEqual(self.gb1.GAME_DIMENSIONS, (3, 3))
def test_specify_game_dimensions(self):
self.assertEqual(self.gb2.GAME_DIMENSIONS, (5, 5))
def test_build_cells(self):
self.assertEqual(self.gb1.CELLS, [
(0, 0),
(1, 0),
(2, 0),
(0, 1),
(1, 1),
(2, 1),
(0, 2),
(1, 2),
(2, 2),
])
def test_get_locations_values(self):
monster, door, player = self.gb1.get_locations()
test_result = True
for cell in self.gb1.CELLS:
if cell[0] < self.gb1.GAME_DIMENSIONS[0]:
pass
else:
test_result = False
print(self.gb1.GAME_DIMENSIONS)
self.assertTrue(test_result)
if cell[1] < self.gb1.GAME_DIMENSIONS[1]:
pass
else:
test_result = False
print(self.gb1.GAME_DIMENSIONS)
self.assertTrue(test_result)
self.assertTrue(test_result)
def test_get_locations_type(self):
monster, door, player = self.gb1.get_locations()
self.assertIsInstance(monster, type((0, 0)))
self.assertIsInstance(door, type((0, 0)))
self.assertIsInstance(player, type((0, 0)))
def test_get_moves(self):
self.assertEquals(['RIGHT', 'UP', 'DOWN'], self.gb1.get_moves((0, 1)))
self.assertEquals(['LEFT', 'UP', 'DOWN'], self.gb1.get_moves(
(3 - 1, 1)))
self.assertEquals(['LEFT', 'RIGHT', 'DOWN'], self.gb1.get_moves(
(1, 0)))
self.assertEquals(['LEFT', 'RIGHT', 'UP'],
self.gb1.get_moves((1, 3 - 1)))
def run_game():
# create the game board
gameboard = GameBoard()
GameOver = False
# create game board
gameboard.create_board()
# set player piece type
player = GAME_PIECE_X
while GameOver == False:
# update weights for each possible path
path_weights = update_path_weights(gameboard.get_board(), player)
# tallies weights at each board position
position_weights = update_position_weights(path_weights,
gameboard.get_board())
# chooses best position based on weights
best_position, GameOver = choose_path(position_weights)
#print(f"Best Pos {best_position}")
# time.sleep(1)
# mark position on board
gameboard.put_piece(best_position, player)
# update game board
# gameboard.print_board()
# check if game is over
GameOver, isWinner = check_gameOver(gameboard.get_board(), player)
if (GameOver == False and isWinner == False):
# switch player
if player == GAME_PIECE_X:
player = GAME_PIECE_O
else:
player = GAME_PIECE_X
def main():
game_board = GameBoard()
keep_playing = True
while keep_playing:
print "Next Cards: {}".format(game_board.next_cards)
print game_board
in_keys = raw_input("Press awsd keys to move the board ulrd (or type quit): ")
if in_keys == 'quit':
print "Sorry to see you go!"
break
direc = key_map.get(in_keys, None)
if direc is None:
print "Invalid command! Try Again!"
else:
try:
game_board.move_board(direc)
except InvalidMoveException:
print "You cannot move that direction! Try another!"
if game_board.no_more_moves:
print "Sorry Charlie, no moves remain for you!"
print "Your score is: {:d}".format(game_board.calc_score())
def __init__(self, color_player1=red, color_player2=yellow):
self.game_over = False
self.turn = 0
self.last_move_row = []
self.last_move_col = []
self.game_board = GameBoard()
self.action = None
self.c1 = color_player1
self.c2 = color_player2
self.sq_size: int = 100
self.width: int = 7 * self.sq_size
self.height: int = 7 * self.sq_size
self.size: Tuple[int, int] = (self.width, self.height)
self.radius: int = int(self.sq_size / 2 - 5)
def __init__(self):
# MEASURES
self.total_moves_time = 0
self.total_moves = 0
self.fastest_move = -1
self.longest_move = 0
self.time_to_reach = []
# setup game & ai
self.board = GameBoard()
self.ai = Expectimax()
self.init_game()
# run ai on game
self.start = timer()
self.run_game()
end = timer()
# MEASURES
self.total_time = end - self.start # total time to run
self.avg_move_time = self.total_moves_time / self.total_moves # moves done
self.max_tile = self.board.get_max_tile() # max tile
self.states_visited = self.ai.states_visited # states visited
def test_game_board_interactions(self):
print("test_game_board_interactions")
# Create a gameboard with 4 players, 1 die of six sides, and card decks 4 card decks of 25 cards each
print(r"Creating gameboard. Players: 4, names: p1, p2, p3, p4")
test_game_board = GameBoard(num_players=4,
player_names=["p1", "p2", "p3", "p4"])
print("Testing that four players were created")
self.assertEqual(len(test_game_board.players.players), 4)
print("Testing that the dice has 6 sides")
self.assertEqual(test_game_board.die.num_sides, 6)
print("Testing that the card decks have 25 in each category")
self.assertEqual(len(test_game_board.card_decks.blue_deck.cards), 25)
self.assertEqual(len(test_game_board.card_decks.white_deck.cards), 25)
self.assertEqual(len(test_game_board.card_decks.red_deck.cards), 25)
self.assertEqual(len(test_game_board.card_decks.green_deck.cards), 25)
def __init__(self):
super(GUI, self).__init__()
logging.info('Initializing game gui.')
self.admin = Admin()
self.gui_state = self.SHOW_GAME_BOARD
# Set the stage background to grey.
self.set_color(config.stage_background_color)
# Connect callback listeners
logging.info('Setting up game stage signals.')
self.connect('destroy', clutter.main_quit)
self.connect('key-press-event', self.on_press)
self.connect('button-release-event', self.on_click)
self.connect('allocation-changed', self.on_allocation_changed)
self.board_box = clutter.Box(clutter.BoxLayout())
board_box_layout = self.board_box.get_layout_manager()
# Instantiate the game board which is the collection of squares to show
# on screen.
self.game_board = GameBoard()
board_box_layout.pack(self.game_board,
True, True, True,
clutter.BOX_ALIGNMENT_CENTER,
clutter.BOX_ALIGNMENT_CENTER)
# Determine whether or not to display player scores.
self.player_score_box = None
if config.display_player_scores:
self.player_score_box = PlayerScoreBox(game.get_players())
self.player_score_box.set_width(0.1 * self.get_width())
if config.player_scores_position == 'east':
layout = self.player_score_box.get_layout_manager()
layout.set_vertical(True)
board_box_layout.pack(self.player_score_box,
True, True, True,
clutter.BOX_ALIGNMENT_CENTER,
clutter.BOX_ALIGNMENT_CENTER)
if config.player_scores_position == 'south':
layout = self.player_score_box.get_layout_manager()
layout.set_vertical(False)
board_box_layout.pack(self.player_score_box,
True, True, True,
clutter.BOX_ALIGNMENT_CENTER,
clutter.BOX_ALIGNMENT_CENTER)
else:
self.board_box.add(self.player_score_box)
# Add the box with the board in it to the screen.
self.add(self.board_box)
# Overlay box for displaying clue information and answers
self.clue_overlay = ClueOverlay()
self.clue_overlay.set_size(self.get_width(), self.get_height())
self.add(self.clue_overlay)
self.clue_overlay.set_opacity(0)
# Overlay box for display category information.
self.category_overlay = CategoryOverlay()
self.category_overlay.set_size(self.get_width(),
self.get_height())
# Overlay box for displaying which player buzzed in.
self.player_buzz_overlay = PlayerBuzzOverlay()
self.player_buzz_overlay.set_size(self.get_width(),
self.get_height())
self.player_buzz_overlay.set_opacity(0)
self.add(self.player_buzz_overlay)
# Overlay box for displaying player score.
self.player_score_overlay = PlayerScoreOverlay()
self.player_score_overlay.set_size(self.get_width(),
self.get_height())
self.player_score_overlay.set_opacity(0)
self.add(self.player_score_overlay)
# Overlay box for daily double.
self.daily_double_overlay = DailyDoubleOverlay()
self.daily_double_overlay.set_size(self.get_width(),
self.get_height())
self.daily_double_overlay.set_opacity(0)
self.add(self.daily_double_overlay)
# Overlay box for final round.
self.final_round_overlay = FinalRoundOverlay()
self.final_round_overlay.set_size(self.get_width(),
self.get_height())
self.final_round_overlay.set_opacity(0)
self.add(self.final_round_overlay)
# Overlay box for displaying all player scores.
self.all_player_scores_overlay = AllPlayerScoresOverlay()
self.all_player_scores_overlay.set_size(self.get_width(),
self.get_height())
self.all_player_scores_overlay.set_opacity(0)
self.add(self.all_player_scores_overlay)
self.flashing_scores = False
# Set a default stage size.
self.set_fullscreen(False)
self.set_size(800, 600)
self.set_user_resizable(True)
self.show()
def assert_board_shifts(self, direc, start_board, exp_board):
game_board = GameBoard()
game_board.board = start_board
game_board.move_board(direc)
self.assert_board_equal(game_board.board, exp_board)
def update(self):
"""
Update the GUI based on the current state of the game.
"""
if game.check_update_game_board():
self.board_box.remove(self.game_board)
self.game_board = GameBoard()
self.board_box.add(self.game_board)
if config.display_player_scores:
self.game_board.set_size(0.9 * self.get_width(),
self.get_height())
else:
self.game_board.set_size(self.get_width,
self.get_height())
self.game_board.lower_bottom()
if game.check_timeout_beep():
logging.debug("****************** BZZZZZT! ******************")
tex = cluttergst.VideoTexture()
tex.set_filename(config.sound_timeout)
tex.set_playing(True)
if game.check_flash_player_name():
player_name = game.players[game.buzzed_player].name
self.player_buzz_overlay.set_opacity(255)
self.player_buzz_overlay.set_text(player_name)
self.player_buzz_overlay.animate(clutter.EASE_IN_CUBIC,
2000,
'opacity', 0)
if game.check_flash_player_score():
player = game.players[game.buzzed_player]
self.player_score_overlay.set_opacity(255)
self.player_score_overlay.set_content(player.name, player.last_score_change)
self.player_score_overlay.animate(clutter.EASE_IN_CUBIC,
1000,
'opacity', 0)
if game.check_flash_daily_double():
self.daily_double_overlay.set_opacity(255)
tex = cluttergst.VideoTexture()
tex.set_filename(config.sound_daily_double)
tex.set_playing(True)
if game.check_clear_daily_double():
self.daily_double_overlay.animate(clutter.EASE_IN_CUBIC,
1000,
'opacity', 0)
new_gui_state = self.gui_state
if game.state == game.IDLE:
new_gui_state = self.SHOW_GAME_BOARD
elif game.state == game.FINAL_ROUND:
new_gui_state = self.SHOW_FINAL_ROUND
elif game.state == game.FINAL_ROUND_WAGER:
new_gui_state = self.SHOW_FINAL_ROUND_CATEGORY
elif game.state == game.FINAL_ROUND_CLUE:
new_gui_state = self.SHOW_FINAL_ROUND_CLUE
elif game.state == game.FINAL_ROUND_QUESTION:
new_gui_state = self.SHOW_FINAL_ROUND_QUESTION
elif game.state in (game.DISPLAY_CLUE,
game.AWAIT_BUZZ,
game.AWAIT_ANSWER,
game.DAILY_DOUBLE_AWAIT_WAGER,
game.DAILY_DOUBLE_SHOW_CLUE):
new_gui_state = self.SHOW_CLUE
elif game.state == game.DISPLAY_QUESTION:
new_gui_state = self.SHOW_QUESTION
else:
logging.error('Invalid game state')
if self.gui_state != new_gui_state:
logging.debug("State %s to %s" % (self.gui_state, new_gui_state))
if new_gui_state == self.SHOW_CLUE:
# Reset the buttons.
game_buttons.reset_buttons()
# We're not displaying clue. Setup the users that are locked out.
if game.selected_clue.get_type() == 'audio':
self.clue_overlay.set_audio(game.selected_clue.answer['audio'])
elif game.selected_clue.get_type() == 'image':
self.clue_overlay.set_image(game.selected_clue.answer['image'])
elif game.selected_clue.get_type() == 'text':
self.clue_overlay.set_text(game.selected_clue.answer)
elif game.selected_clue.get_type() == 'video':
self.clue_overlay.set_video(game.selected_clue.answer['video'])
self.clue_overlay.set_opacity(255)
self.clue_overlay.set_scale(0.1, 0.1)
self.clue_overlay.animate(clutter.LINEAR,
500,
'scale-x', 1,
'scale-y', 1)
elif new_gui_state == self.SHOW_QUESTION:
self.clue_overlay.set_text(game.selected_clue.question)
self.clue_overlay.set_opacity(255)
self.clue_overlay.animate(clutter.LINEAR,
500,
'scale-x', 1,
'scale-y', 1)
elif new_gui_state == self.SHOW_GAME_BOARD:
logging.debug("Hiding clue overlay")
self.clue_overlay.set_opacity(0)
elif new_gui_state == self.SHOW_FINAL_ROUND:
self.final_round_overlay.set_opacity(255)
elif new_gui_state == self.SHOW_FINAL_ROUND_CATEGORY:
self.final_round_overlay.set_opacity(255)
self.final_round_overlay.set_text("Category:\n%s" % game.final_round.category)
elif new_gui_state == self.SHOW_FINAL_ROUND_CLUE:
self.final_round_overlay.set_opacity(255)
self.final_round_overlay.set_text(game.final_round.answer)
self.final_round_overlay.play_music()
elif new_gui_state == self.SHOW_FINAL_ROUND_QUESTION:
self.final_round_overlay.set_opacity(255)
self.final_round_overlay.set_text(game.final_round.question)
self.gui_state = new_gui_state
class GUI(clutter.Stage):
"""
"""
SHOW_GAME_BOARD = 'SHOW_GAME_BOARD'
SHOW_CLUE = 'SHOW_CLUE'
SHOW_QUESTION = 'SHOW_QUESTION'
SHOW_FINAL_ROUND = 'SHOW_FINAL_ROUND'
SHOW_FINAL_ROUND_CATEGORY = 'SHOW_FINAL_ROUND_CATEGORY'
SHOW_FINAL_ROUND_CLUE = 'SHOW_FINAL_ROUND_CLUE'
SHOW_FINAL_ROUND_QUESTION = 'SHOW_FINAL_ROUND_QUESTION'
def __init__(self):
super(GUI, self).__init__()
logging.info('Initializing game gui.')
self.admin = Admin()
self.gui_state = self.SHOW_GAME_BOARD
# Set the stage background to grey.
self.set_color(config.stage_background_color)
# Connect callback listeners
logging.info('Setting up game stage signals.')
self.connect('destroy', clutter.main_quit)
self.connect('key-press-event', self.on_press)
self.connect('button-release-event', self.on_click)
self.connect('allocation-changed', self.on_allocation_changed)
self.board_box = clutter.Box(clutter.BoxLayout())
board_box_layout = self.board_box.get_layout_manager()
# Instantiate the game board which is the collection of squares to show
# on screen.
self.game_board = GameBoard()
board_box_layout.pack(self.game_board,
True, True, True,
clutter.BOX_ALIGNMENT_CENTER,
clutter.BOX_ALIGNMENT_CENTER)
# Determine whether or not to display player scores.
self.player_score_box = None
if config.display_player_scores:
self.player_score_box = PlayerScoreBox(game.get_players())
self.player_score_box.set_width(0.1 * self.get_width())
if config.player_scores_position == 'east':
layout = self.player_score_box.get_layout_manager()
layout.set_vertical(True)
board_box_layout.pack(self.player_score_box,
True, True, True,
clutter.BOX_ALIGNMENT_CENTER,
clutter.BOX_ALIGNMENT_CENTER)
if config.player_scores_position == 'south':
layout = self.player_score_box.get_layout_manager()
layout.set_vertical(False)
board_box_layout.pack(self.player_score_box,
True, True, True,
clutter.BOX_ALIGNMENT_CENTER,
clutter.BOX_ALIGNMENT_CENTER)
else:
self.board_box.add(self.player_score_box)
# Add the box with the board in it to the screen.
self.add(self.board_box)
# Overlay box for displaying clue information and answers
self.clue_overlay = ClueOverlay()
self.clue_overlay.set_size(self.get_width(), self.get_height())
self.add(self.clue_overlay)
self.clue_overlay.set_opacity(0)
# Overlay box for display category information.
self.category_overlay = CategoryOverlay()
self.category_overlay.set_size(self.get_width(),
self.get_height())
# Overlay box for displaying which player buzzed in.
self.player_buzz_overlay = PlayerBuzzOverlay()
self.player_buzz_overlay.set_size(self.get_width(),
self.get_height())
self.player_buzz_overlay.set_opacity(0)
self.add(self.player_buzz_overlay)
# Overlay box for displaying player score.
self.player_score_overlay = PlayerScoreOverlay()
self.player_score_overlay.set_size(self.get_width(),
self.get_height())
self.player_score_overlay.set_opacity(0)
self.add(self.player_score_overlay)
# Overlay box for daily double.
self.daily_double_overlay = DailyDoubleOverlay()
self.daily_double_overlay.set_size(self.get_width(),
self.get_height())
self.daily_double_overlay.set_opacity(0)
self.add(self.daily_double_overlay)
# Overlay box for final round.
self.final_round_overlay = FinalRoundOverlay()
self.final_round_overlay.set_size(self.get_width(),
self.get_height())
self.final_round_overlay.set_opacity(0)
self.add(self.final_round_overlay)
# Overlay box for displaying all player scores.
self.all_player_scores_overlay = AllPlayerScoresOverlay()
self.all_player_scores_overlay.set_size(self.get_width(),
self.get_height())
self.all_player_scores_overlay.set_opacity(0)
self.add(self.all_player_scores_overlay)
self.flashing_scores = False
# Set a default stage size.
self.set_fullscreen(False)
self.set_size(800, 600)
self.set_user_resizable(True)
self.show()
def on_click(self, actor, event):
"""
"""
if type(event.source) == ClueSquare:
clue_square = event.source
logging.debug('Notify game clue selected')
game.select_clue(clue_square.clue)
def on_press(self, actor, event):
"""
"""
if event.keyval == clutter.keysyms.Escape:
clutter.main_quit()
elif event.keyval == clutter.keysyms.a:
# player A rings in.
game_buttons.player_set(0, True)
game.buzz(0)
self.update()
elif event.keyval == clutter.keysyms.b:
# player B rings in.
game_buttons.player_set(1, True)
game.buzz(1)
self.update()
elif event.keyval == clutter.keysyms.c:
# player C rings in.
game_buttons.player_set(2, True)
game.buzz(2)
self.update()
elif event.keyval == clutter.keysyms.space:
if not self.final_round_overlay.is_playing():
# We do not allow for incoming space button presses when final
# round overlay music is playing.
# multi-purpose bar press
game.bar()
self.update()
elif event.keyval == clutter.keysyms.x:
# cancel
game.cancel()
self.update()
elif event.keyval == clutter.keysyms.y:
# correct answer
game.correct_answer()
self.update()
elif event.keyval == clutter.keysyms.n:
# incorrect answer
game.incorrect_answer()
self.update()
elif event.keyval == clutter.keysyms.z:
logging.debug('resetting player lights')
game_buttons.reset_player_lights()
elif event.keyval == clutter.keysyms.l:
if self.category_overlay in self.get_children():
self.category_overlay.animate(clutter.LINEAR,
500,
'x', self.category_overlay.get_x() - self.get_width())
else:
self.category_overlay.set_size(self.get_width(),
self.get_height())
self.category_overlay.set_x(self.get_width())
self.add(self.category_overlay)
self.category_overlay.animate(clutter.LINEAR,
500,
'x', self.category_overlay.get_x() - self.get_width())
elif event.keyval == clutter.keysyms.p:
# DEBUG - for testing end of round condition without clicking everything.
# don't leave this active in production code!
for category in game.categories:
for clue in category.clues:
clue.state = 'selected'
game.categories[0].clues[0].state = 'unanswered'
elif event.keyval == clutter.keysyms.f:
# Fullscreen play area.
self.set_fullscreen(not self.get_fullscreen())
elif event.keyval == clutter.keysyms.s:
self.flash_scores()
def on_allocation_changed(self, stage, box, flags):
"""
"""
logging.debug("self size %d x %d and stage size %d x %d" % (self.get_width(),
self.get_height(),
stage.get_width(),
stage.get_height()))
self.clue_overlay.set_size(self.get_width(), self.get_height())
self.daily_double_overlay.set_size(self.get_width(), self.get_height())
self.board_box.set_size(self.get_width(), self.get_height())
if config.display_player_scores:
self.player_score_box.set_size(0.1 * self.get_width(),
self.get_height())
self.game_board.set_size(0.9 * self.get_width(),
self.get_height())
else:
self.game_board.set_size(self.get_width,
self.get_height())
self.board_box.set_size(self.get_width(), self.get_height())
self.category_overlay.set_size(self.get_width(), self.get_height())
self.player_buzz_overlay.set_size(self.get_width(), self.get_height())
self.player_score_overlay.set_size(self.get_width(), self.get_height())
self.daily_double_overlay.set_size(self.get_width(), self.get_height())
self.final_round_overlay.set_size(self.get_width(), self.get_height())
self.all_player_scores_overlay.set_size(self.get_width(), self.get_height())
def on_tick(self):
"""
Call back associated with each tick.
"""
game.on_tick()
self.admin.on_tick()
# Send update to player scores.
self.player_score_box.update()
# Read incoming game button presses if they exist.
player1, player2, player3 = game_buttons.read()
if player1:
game.buzz(0)
elif player2:
game.buzz(1)
elif player3:
game.buzz(2)
game_buttons.reset_buttons()
self.update()
return True
def update(self):
"""
Update the GUI based on the current state of the game.
"""
if game.check_update_game_board():
self.board_box.remove(self.game_board)
self.game_board = GameBoard()
self.board_box.add(self.game_board)
if config.display_player_scores:
self.game_board.set_size(0.9 * self.get_width(),
self.get_height())
else:
self.game_board.set_size(self.get_width,
self.get_height())
self.game_board.lower_bottom()
if game.check_timeout_beep():
logging.debug("****************** BZZZZZT! ******************")
tex = cluttergst.VideoTexture()
tex.set_filename(config.sound_timeout)
tex.set_playing(True)
if game.check_flash_player_name():
player_name = game.players[game.buzzed_player].name
self.player_buzz_overlay.set_opacity(255)
self.player_buzz_overlay.set_text(player_name)
self.player_buzz_overlay.animate(clutter.EASE_IN_CUBIC,
2000,
'opacity', 0)
if game.check_flash_player_score():
player = game.players[game.buzzed_player]
self.player_score_overlay.set_opacity(255)
self.player_score_overlay.set_content(player.name, player.last_score_change)
self.player_score_overlay.animate(clutter.EASE_IN_CUBIC,
1000,
'opacity', 0)
if game.check_flash_daily_double():
self.daily_double_overlay.set_opacity(255)
tex = cluttergst.VideoTexture()
tex.set_filename(config.sound_daily_double)
tex.set_playing(True)
if game.check_clear_daily_double():
self.daily_double_overlay.animate(clutter.EASE_IN_CUBIC,
1000,
'opacity', 0)
new_gui_state = self.gui_state
if game.state == game.IDLE:
new_gui_state = self.SHOW_GAME_BOARD
elif game.state == game.FINAL_ROUND:
new_gui_state = self.SHOW_FINAL_ROUND
elif game.state == game.FINAL_ROUND_WAGER:
new_gui_state = self.SHOW_FINAL_ROUND_CATEGORY
elif game.state == game.FINAL_ROUND_CLUE:
new_gui_state = self.SHOW_FINAL_ROUND_CLUE
elif game.state == game.FINAL_ROUND_QUESTION:
new_gui_state = self.SHOW_FINAL_ROUND_QUESTION
elif game.state in (game.DISPLAY_CLUE,
game.AWAIT_BUZZ,
game.AWAIT_ANSWER,
game.DAILY_DOUBLE_AWAIT_WAGER,
game.DAILY_DOUBLE_SHOW_CLUE):
new_gui_state = self.SHOW_CLUE
elif game.state == game.DISPLAY_QUESTION:
new_gui_state = self.SHOW_QUESTION
else:
logging.error('Invalid game state')
if self.gui_state != new_gui_state:
logging.debug("State %s to %s" % (self.gui_state, new_gui_state))
if new_gui_state == self.SHOW_CLUE:
# Reset the buttons.
game_buttons.reset_buttons()
# We're not displaying clue. Setup the users that are locked out.
if game.selected_clue.get_type() == 'audio':
self.clue_overlay.set_audio(game.selected_clue.answer['audio'])
elif game.selected_clue.get_type() == 'image':
self.clue_overlay.set_image(game.selected_clue.answer['image'])
elif game.selected_clue.get_type() == 'text':
self.clue_overlay.set_text(game.selected_clue.answer)
elif game.selected_clue.get_type() == 'video':
self.clue_overlay.set_video(game.selected_clue.answer['video'])
self.clue_overlay.set_opacity(255)
self.clue_overlay.set_scale(0.1, 0.1)
self.clue_overlay.animate(clutter.LINEAR,
500,
'scale-x', 1,
'scale-y', 1)
elif new_gui_state == self.SHOW_QUESTION:
self.clue_overlay.set_text(game.selected_clue.question)
self.clue_overlay.set_opacity(255)
self.clue_overlay.animate(clutter.LINEAR,
500,
'scale-x', 1,
'scale-y', 1)
elif new_gui_state == self.SHOW_GAME_BOARD:
logging.debug("Hiding clue overlay")
self.clue_overlay.set_opacity(0)
elif new_gui_state == self.SHOW_FINAL_ROUND:
self.final_round_overlay.set_opacity(255)
elif new_gui_state == self.SHOW_FINAL_ROUND_CATEGORY:
self.final_round_overlay.set_opacity(255)
self.final_round_overlay.set_text("Category:\n%s" % game.final_round.category)
elif new_gui_state == self.SHOW_FINAL_ROUND_CLUE:
self.final_round_overlay.set_opacity(255)
self.final_round_overlay.set_text(game.final_round.answer)
self.final_round_overlay.play_music()
elif new_gui_state == self.SHOW_FINAL_ROUND_QUESTION:
self.final_round_overlay.set_opacity(255)
self.final_round_overlay.set_text(game.final_round.question)
self.gui_state = new_gui_state
def flash_scores(self):
if self.flashing_scores == False:
sc = ""
for player in game.players:
sc += '%s\n$%d\n' % (player.name, player.score)
self.all_player_scores_overlay.set_text(sc)
self.all_player_scores_overlay.animate(clutter.EASE_IN_CUBIC,
500,
'opacity', 255)
self.flashing_scores = True
else:
self.all_player_scores_overlay.animate(clutter.EASE_IN_CUBIC,
500,
'opacity', 0)
self.flashing_scores = False
