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 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 __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 test_valid_plays(self):
board = GameBoard()
piece1 = Piece(color=COLORS.RED, shape=SHAPES.SPARKLE)
piece2 = Piece(color=COLORS.RED, shape=SHAPES.SQUARE)
piece3 = Piece(color=COLORS.RED, shape=SHAPES.CIRCLE)
piece4 = Piece(color=COLORS.GREEN, shape=SHAPES.SQUARE)
piece5 = Piece(color=COLORS.BLUE, shape=SHAPES.SQUARE)
piece6 = Piece(color=COLORS.CYAN, shape=SHAPES.SQUARE)
board.start_turn()
board.play(piece1)
board.play(piece2, x=1, y=2)
board.play(piece3, x=1, y=3)
board.end_turn()
board.start_turn()
board.play(piece4, x=2, y=2)
self.assertEqual([(2, 1), (0, 2), (3, 2), (2, 3)], board.valid_plays())
board.play(piece5, x=3, y=2)
self.assertEqual([(0, 2), (4, 2)], board.valid_plays())
board.play(piece6, x=4, y=2)
self.assertEqual([(0, 2), (5, 2)], board.valid_plays())
board.end_turn()
self.assertEqual([(1, 0), (0, 1), (2, 1), (3, 1), (4, 1), (0, 2),
(5, 2), (0, 3), (2, 3), (3, 3), (4, 3), (1, 4)],
board.valid_plays())
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 __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 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, *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 __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 __init__(self):
self.board = GameBoard()
self.ai = Expectimax()
self.init_game()
print_board(self.board)
self.run_game()
self.over = False
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 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 test_playing_piece_adds_piece_to_board_at_correct_position_and_expands_board_down(
self):
board = GameBoard()
piece1 = Piece(color=COLORS.RED, shape=SHAPES.SPARKLE)
piece2 = Piece(color=COLORS.GREEN, shape=SHAPES.SPARKLE)
board.play(piece1)
board.play(piece2, x=1, y=2)
self.assertEqual(4, len(board._board))
self.assertEqual(3, len(board._board[0]))
self.assertEqual(piece2, board._board[2][1])
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 __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)
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 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 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 playTreasureHunt():
print('Welcome to Treasure Hunt!\n')
while True:
instructions = input('Would you like to view the instructions? (Y/N): ')
if instructions not in ['y', 'n', 'Y', 'N']:
print('***ERROR: Invalid response. Please enter Y or N.')
elif instructions.lower == 'y':
showInstructions()
else:
break
while True:
# Game setup
detectors = 20
board = GameBoard()
width = board.width
height = board.height
chests = getChests(3, width, height)
board.displayBoard()
previous_moves = []
while detectors > 0:
# show status
print(f'You have {detectors:d} detectors left and {len(chests)} chests remaining.')
x, y = getMove(previous_moves, width, height)
previous_moves.append([x, y])
result = makeMove(board, chests, x, y)
if result == False:
continue
else:
if result == 'Chest':
# Update previously placed detectors
for x, y in previous_moves:
makeMove(board, chests, x, y)
board.displayBoard()
if len(chests) == 0:
print('Congratulations! You found all the chests!')
break
detectors -= 1
if detectors == 0:
print('Darn! You ran out of detectors :(')
print('I guess that treasure will stay hidden!')
print('The remaining chests were here:')
for x, y in chests:
print(f' {x}, {y}')
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, 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 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 test_score_straight_line(self):
board = GameBoard()
piece1 = Piece(color=COLORS.RED, shape=SHAPES.SPARKLE)
piece2 = Piece(color=COLORS.RED, shape=SHAPES.SQUARE)
piece3 = Piece(color=COLORS.RED, shape=SHAPES.CIRCLE)
board.start_turn()
board.play(piece1)
board.play(piece2, x=1, y=2)
board.play(piece3, x=1, y=3)
self.assertEqual(3, board.score())
board.end_turn()
self.assertEqual(0, board.score())
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 test_board(self):
gb = GameBoard()
assert gb.is_valid(5) == True
gb.position[0] = 'X'
gb.position[1] = 'X'
gb.position[2] = 'X'
assert gb.check_win() == True
assert gb.is_valid(1) == False
assert gb.check_tie() == False
gb.position[3] = 'X'
gb.position[4] = 'X'
gb.position[5] = 'X'
gb.position[6] = 'X'
gb.position[7] = 'X'
gb.position[8] = 'X'
assert gb.check_tie() == True
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 test_complex_score(self):
board = GameBoard()
piece1 = Piece(color=COLORS.RED, shape=SHAPES.SPARKLE)
piece2 = Piece(color=COLORS.RED, shape=SHAPES.SQUARE)
piece3 = Piece(color=COLORS.RED, shape=SHAPES.CIRCLE)
piece4 = Piece(color=COLORS.GREEN, shape=SHAPES.SQUARE)
piece5 = Piece(color=COLORS.BLUE, shape=SHAPES.SQUARE)
piece6 = Piece(color=COLORS.CYAN, shape=SHAPES.SQUARE)
piece7 = Piece(color=COLORS.GREEN, shape=SHAPES.CIRCLE)
piece8 = Piece(color=COLORS.BLUE, shape=SHAPES.CIRCLE)
piece9 = Piece(color=COLORS.CYAN, shape=SHAPES.CIRCLE)
piece10 = Piece(color=COLORS.GREEN, shape=SHAPES.SPARKLE)
piece11 = Piece(color=COLORS.GREEN, shape=SHAPES.TRIANGLE)
piece12 = Piece(color=COLORS.GREEN, shape=SHAPES.DIAMOND)
piece13 = Piece(color=COLORS.GREEN, shape=SHAPES.STAR)
board.start_turn()
board.play(piece1)
board.play(piece2, x=1, y=2)
board.play(piece3, x=1, y=3)
self.assertEqual(3, board.score())
board.end_turn()
board.start_turn()
board.play(piece4, x=2, y=2)
board.play(piece5, x=3, y=2)
board.play(piece6, x=4, y=2)
self.assertEqual(4, board.score())
board.end_turn()
board.start_turn()
board.play(piece7, x=2, y=3)
board.play(piece8, x=3, y=3)
board.play(piece9, x=4, y=3)
self.assertEqual(10, board.score())
board.end_turn()
board.start_turn()
board.play(piece10, x=2, y=1)
board.play(piece11, x=2, y=4)
board.play(piece12, x=2, y=5)
board.play(piece13, x=2, y=6)
self.assertEqual(14, board.score())
board.end_turn()
board.print_board()
