def test_read_file():
WIDTH = 600
stone = Stone(WIDTH)
gc = GameController(WIDTH, stone)
assert gc.score_list == []
# The default when scores.txt is blank
gc.read_file('test_scores.txt')
assert gc.score_list == [['Khai4', 22], ['Khai3', 20]]
def test_constructor():
my_gc = GameController(800, 800)
my_board = Board(800, 800, 100, 20, my_gc, 0, 1)
assert my_board.WIDTH == 800
assert my_board.HEIGHT == 800
assert my_board.CELL_WIDTH == 100
assert my_board.EDGE == 20
assert my_board.gc is my_gc
assert my_board.human_color == 0
assert my_board.ai_color == 1
def main(stdscr):
model = Model()
agent = A2CAgent(model)
learning_environment = LearningEnvironment()
agent.initialize_model(learning_environment)
agent.load_pretrained_model()
game_controller = GameController(stdscr)
game_controller.play(agent, learning_environment)
def test_check_if_half_ends(self):
gc = GameController(600)
tiles = Tiles(100, 8, 255, 0)
b = Board(600, 100, 8, gc, tiles, 255, 0)
b.check_if_half_ends()
self.assertFalse(gc.black_wins)
b.tiles.tiles[3][3].set_color(b.BLACK)
b.tiles.tiles[4][4].set_color(b.BLACK)
b.check_if_half_ends()
self.assertTrue(gc.black_wins)
def test_initial_four():
my_gc = GameController(800, 800)
my_board = Board(800, 800, 100, 20, my_gc, 0, 1)
assert my_board.disks.matrix[3][3].color == 1
assert my_board.disks.matrix[3][4].color == 0
assert my_board.disks.matrix[4][3].color == 0
assert my_board.disks.matrix[4][4].color == 1
assert my_board.disks.total_disks == 4
assert my_board.disks.white_count == 2
assert my_board.disks.black_count == 2
def init(debug=True):
app = web.Application()
app['controller'] = GameController(debug=debug)
app.router.add_get('/', handle)
app.router.add_get('/style.css', handle)
app.router.add_get('/index.js', handle)
app.router.add_get('/connect', wshandler)
app.router.add_static('/static/', 'static/')
return app
def test_eat_dots():
g = GameController(600, 400)
m = Maze(600, 400, 150, 450, 100, 300, g)
m.eat_dots(100, 100)
assert len(m.dots.top_row) == 8
m.eat_dots(150, 200)
assert len(m.dots.left_col) == 5
m.eat_dots(150, 100)
assert len(m.dots.top_row) == 7
assert len(m.dots.left_col) == 4
def test_ranked_flipped_space():
"""Test ranked flipped space method"""
gc = GameController(800, 100)
assert (gc.ranked_flipped_space({
(3, 2): {(3, 3)},
(5, 4): {(4, 4), (4, 5)},
(4, 5): {(4, 4)},
(2, 3): {(3, 3)}
})) == [((5, 4), {(4, 5), (4, 4)}), ((3, 2), {(3, 3)}), ((4, 5), {(4, 4)}),
((2, 3), {(3, 3)})]
def test_game_can_proceed():
"""Test the game_can_proceed method."""
tiles = Tiles(800, 100)
board = Board(800, 100, tiles)
player = Player('Alfred', board, 'black')
ai = AI(board, player)
game_controller = GameController(player, ai, board)
assert game_controller.game_can_proceed() is True
for pair in board.on_board:
board.tiles_list[pair[0]][pair[1]].color = 'white'
assert game_controller.ai_has_move() is False
def test_can_go():
WIDTH = 600
stone = Stone(WIDTH)
gc = GameController(WIDTH, stone)
gc.counter = 2
gc.stone.total_row[3][3].color = 0 # 4 starting stones
gc.stone.total_row[4][4].color = 0
gc.stone.total_row[3][4].color = 1
gc.stone.total_row[4][3].color = 1
gc.can_go()
assert len(gc.moves_list) == 4 # First move: 4 valids moves for player
def test_legalMoves():
"""Test the Board legalMoves() function"""
gc = GameController(WIDTH, HEIGHT)
board = Board(GRID_COL_ROW_COUNT, CELL_W_H, WIDTH, HEIGHT, gc)
assert len(board.legalMoves(HUMAN)) == 4
assert (3, 4) in board.legalMoves(HUMAN)
assert (5, 6) in board.legalMoves(HUMAN)
assert (4, 4) not in board.legalMoves(HUMAN)
assert (6, 6) not in board.legalMoves(HUMAN)
assert (-1, -1) not in board.legalMoves(HUMAN)
def test_constructor():
gc = GameController(800, 800)
b = Board(800, 800, gc)
assert b.WIDTH == 800
assert b.HEIGHT == 800
assert b.SPACING == 100
assert b.COLS == 8
assert b.ROWS == 8
assert b.squares.tile_counts["white"] == 2
assert b.squares.tile_counts["black"] == 2
assert b.gc is gc
def test_minimax():
gc = GameController(SPACE, filename)
board = [[-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1],
[-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, 0, -1, -1, -1],
[-1, -1, -1, 1, 0, -1, -1], [-1, -1, 0, 1, 1, -1, 1]]
depth = 3
alpha = -sys.maxsize
beta = sys.maxsize
maximizing = True
best_col = gc.minimax(board, depth, alpha, beta, maximizing)[0]
assert best_col == 5
def test_constructor(self):
gc = GameController(600)
tiles = Tiles(100, 8, 255, 0)
b = Board(600, 100, 8, gc, tiles, 255, 0)
self.assertEqual(b.board_size, 600)
self.assertEqual(b.space, 100)
self.assertEqual(b.num, 8)
self.assertEqual(b.gc, gc)
self.assertEqual(b.tiles, tiles)
self.assertEqual(b.WHITE, 255)
self.assertEqual(b.BLACK, 0)
def test_valid_helper():
WIDTH = 600
piece = Piece(WIDTH)
gc = GameController(WIDTH, piece)
gc.counter = 2
gc.piece.total_row[3][3].color = 0 # 4 starting pieces
gc.piece.total_row[4][4].color = 0
gc.piece.total_row[3][4].color = 1
gc.piece.total_row[4][3].color = 1
gc.valid_helper()
assert len(gc.valid_list) == 4 # First move: 4 valids moves for player
def test_get_open_row():
gc = GameController(SPACE, filename)
board = [[-1, -1, 1, 1, -1, -1, -1], [-1, -1, 0, 0, -1, -1, -1],
[-1, 1, 0, 1, -1, -1, -1], [-1, 0, 0, 0, -1, -1, -1],
[-1, 1, 1, 1, -1, -1, -1], [-1, 0, 1, 0, 1, -1, -1]]
col0 = 0
col1 = 1
col4 = 4
assert gc.get_open_row(board, col0) == 5
assert gc.get_open_row(board, col1) == 1
assert gc.get_open_row(board, col4) == 4
def test_constructor(self):
gc = GameController(600)
self.assertEqual(gc.size, 600)
self.assertFalse(gc.black_wins)
self.assertFalse(gc.white_wins)
self.assertFalse(gc.tie)
self.assertFalse(gc.stop)
self.assertEqual(gc.black_num, 0)
self.assertEqual(gc.white_num, 0)
self.assertFalse(gc.FINISH)
self.assertFalse(gc.ai_turn)
def playGame():
game_controller = GameController()
game_controller.start_browser()
game_controller.startup_game()
game_handler = GameHandler(game_controller)
# game_handler.play_game()
parser = argparse.ArgumentParser(description='Description of your program')
parser.add_argument('-m', '--mode', help='Train / Run', required=True)
args = vars(parser.parse_args())
game = Model(game_handler)
game.playGame(args)
def test_constructor():
gc = GameController(800, 800)
assert gc.WIDTH == 800
assert gc.HEIGHT == 800
assert gc.player1_turn
assert not gc.game_over
assert gc.player1_score == 2
assert gc.player2_score == 2
assert gc.delay_counter == 100
assert not gc.is_saved
assert gc.delay_counter2 == 120
def _train_game(self, player1, player2):
controller = GameController(player1, player2)
winner = None
while winner is None:
winner, _ = controller.make_move()
run_if_learner(player1, lambda: player1.store_state())
run_if_learner(player2, lambda: player2.store_state())
run_if_learner(player1, lambda: player1.set_reward(winner))
run_if_learner(player2, lambda: player2.set_reward(winner))
return winner
def test_human_make_move():
my_gc = GameController(800, 800)
my_board = Board(800, 800, 100, 20, my_gc, 0, 1)
human_player = Player(my_board)
ai_player = Player(my_board)
gm = GameManager(human_player, ai_player, my_board, my_gc)
gm.human_make_move(250, 350)
assert gm.board.disks.white_count == 1
assert gm.board.disks.black_count == 4
assert gm.board.disks.total_disks == 5
assert gm.human_turn is False
def test_constructor():
my_gc = GameController(800, 800)
my_board = Board(800, 800, 100, 20, my_gc, 0, 1)
human_player = Player(my_board)
ai_player = Player(my_board)
gm = GameManager(human_player, ai_player, my_board, my_gc)
assert gm.human_player is human_player
assert gm.ai_player is ai_player
assert gm.human_turn is True
assert gm.board is my_board
assert gm.gc is my_gc
def main():
print("--------------------------------\n\
Welcome to street craps!\n")
print("Rules:")
print("If you roll 7 or 11 on your first roll, you win.\n\
If you roll 2, 3, or 12 on your first roll, you lose.\n\
If you roll anything else, that's your 'point', and\n\
you keep rolling until you either roll your point\n\
again (win) or roll a 7 (lose)\n")
gc = GameController()
gc.start_play()
def test_constructor():
g = GameController(600, 400)
m = Maze(600, 400, 150, 450, 100, 300, g)
assert m.LEFT_VERT == 150
assert m.RIGHT_VERT == 450
assert m.TOP_HORIZ == 100
assert m.BOTTOM_HORIZ == 300
assert m.WIDTH == 600
assert m.HEIGHT == 400
assert m.gc is g
assert m.dots.dots_left() == ((m.dots.WIDTH // m.dots.SPACING + 1) * 2 +
(m.dots.HEIGHT // m.dots.SPACING + 1) * 2)
def test_constructor():
gc = GameController(800, 800)
assert gc.WIDTH == 800
assert gc.HEIGHT == 800
assert gc.game_over is False
assert gc.black_wins is False
assert gc.white_wins is False
assert gc.a_tie is False
assert gc.black_count == 0
assert gc.white_count == 0
assert gc.ai_thinking is False
assert gc.waiting == 0
def test_constructor():
gc = GameController(200, 100)
assert gc.WIDTH == 200
assert gc.HEIGHT == 100
assert gc.FILE_NAME == "scores.txt"
assert gc.black_wins is False
assert gc.white_wins is False
assert gc.game_ends is False
assert gc.tie is False
assert gc.player_name is False
assert gc.num == 0
assert gc.black == 0
def __init__(self, size_x: int = None, size_y: int = None):
if size_x is None:
size_x = 10
if size_y is None:
size_y = size_x * 8 // 10
self.maze = Maze(np.array([size_x, size_y]))
self.build = self.maze.build()
self.game_controller = GameController(maze=self.maze, caption="Maze 3D")
start_view = self.game_controller.add_view(PlanView)
self.game_controller.add_view(TunnelView)
self.game_controller.add_view(TunnelView2)
self.game_controller.current_view_index = start_view
def test_eat_dots():
""" Test eat_dots method """
g = GameController(600, 600)
m = Maze(600, 600, 150, 450,
150, 450, g)
for x_coordinate in range(150, 451, 150):
for y_coordinate in range(600):
m.eat_dots(x_coordinate, y_coordinate)
for y_coordinate in range(150, 451, 150):
for x_coordinate in range(600):
m.eat_dots(x_coordinate, y_coordinate)
assert m.dots.dots_left() == 0
def main():
game = GameController()
print("--------------------------------")
print("Welcome to street craps!\n")
print("Rules:\nIf you roll 7 or 11 on your first roll, you win.\n"
"If you roll 2, 3, or 6 on your first role, you lose.\n"
"If you roll anything else, that's your 'point', and\n"
"you keep rolling until you either roll your point\n"
"again (win) or roll a 7 (lose)\n")
game.start_play()
def test_reset_all():
SPACE = {'width': 500, 'height': 700}
gc = GameController(SPACE, 2, 2)
gc.create_new_disk([300, 200], 1, 1)
gc.drop_disk()
gc.reset_all()
assert gc.current_disk is None
assert gc.falling is False
assert gc.final_row is None
assert gc.final_col is None
assert gc.current_score == 0
assert gc.playable is True
