def __init__(self): pygame.init() game = tetris.Game() win = pygame.display.set_mode( (game.gameData.width, game.gameData.height)) running = True clock = pygame.time.Clock() while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False if event.type == pygame.KEYDOWN: if event.key == pygame.K_LEFT: game.moveShapeLeft() if event.key == pygame.K_RIGHT: game.moveShapeRight() if event.key == pygame.K_UP: game.rotate() if event.key == pygame.K_DOWN: game.moveShapeDown() game.update() if game.checkGameOver(game.gameData.numY - 1): running = False game.gameData.displayGrid(win) pygame.display.update() time = clock.tick(4) pygame.quit()
def populate_memory(self, n): # Ensure replay memory has sufficient samples in it before training begins i = 0 while i < n: game = tetris.Game(self.rows, self.columns, self.tetriminos, self.end_at) while not game.game_over: # Interact state = game.state() mask = validity_mask(game.next_tetrimino, self.columns) action = np.random.choice( [i for i in range(self.output_size) if mask[i] == 1]) rotation, column = action_to_rc(action, self.columns) reward = game.place_tetrimino(rotation, column) state_new = game.state() mask_new = validity_mask(game.next_tetrimino, self.columns) # Save if self.use_priority: self.replay_memory.save( state, action, reward, game.game_over, state_new, mask, mask_new, np.max(self.replay_memory.priorities)) else: self.replay_memory.save(state, action, reward, game.game_over, state_new, mask, mask_new) i += 1
def eval_genome_board(genome, config): net = neat.nn.FeedForwardNetwork.create(genome, config) game = tet.Game() while (game.tetris.state == 0): if not HEADLESS: game.tetris.print_board() # pooled = skimage.measure.block_reduce(game.tetris.get_projection(), \ # (POOL_X, POOL_Y), np.max) # print(pooled) # piece_vector = one_hot(game.tetris.tet.type, 7) # rotation_vector = one_hot(game.tetris.tet.rotation, 4) # print(piece_vector) # feature_vector = np.concatenate((np.ndarray.flatten(pooled), piece_vector, rotation_vector)) feature_vector = np.ndarray.flatten(game.tetris.get_projection()) output = net.activate(feature_vector) mv = np.argmax(output) prev_board = np.copy(game.tetris.board) game.move(mv) if not HEADLESS: time.sleep(.5) return game.tetris.turns + game.tetris.score
def load_and_gif(self): with tf.Session() as sess: sess.run(self.init) self.saver.restore(sess, self.save_directory) frames = [] def add_frame(s): frame = np.reshape(s[:self.rows * self.columns], (self.rows, self.columns)) # Upscale so GIF is larger than 20x10 pixels frame = np.kron(frame, np.ones((20, 20)))[::-1] # Convert to RGB array frame = np.stack((frame, frame, frame)) * 100 frames.append(frame) game = tetris.Game(self.rows, self.columns, self.tetriminos, self.end_at) while not game.game_over: state = game.state() add_frame(state) q_values = sess.run(self.net.q_out, feed_dict={self.net.inputs: [state]}) mask = validity_mask(game.next_tetrimino, self.columns) q_masked = np.where(mask, q_values, -1000) action = np.argmax(q_masked, 1)[0] rotation, column = action_to_rc(action, self.columns) game.place_tetrimino(rotation, column) add_frame(game.state()) write_gif(frames, 'gif/game.gif', fps=2) print('GIF saved')
def test_pause_and_resume(self): app = tetris.Game(title="Tetris") app.second_screen() self.assertNotEqual(app._job, None) app.pause() self.assertEqual(app._job, None) app.resume() self.assertNotEqual(app._job, None)
def test_gravity(self): app = tetris.Game(title="Tetris") app.second_screen() app.gravity() f = app.current_figure next_f = app.next_figure app.create_figure() self.assertEqual(next_f, app.current_figure) self.assertNotEqual(f, app.current_figure)
def test(self, n): total_score = 0 for _ in tqdm(range(n)): game = tetris.Game(self.rows, self.columns, self.tetriminos, self.end_at) while not game.game_over: rotation, column = self.select_move(game.grid, game.next_tetrimino) total_score += game.place_tetrimino(rotation, column) return total_score / n
def test_game_over(self): app = tetris.Game(title="Tetris") app.second_screen() self.assertNotEqual(app._job, None) for i in range(app.control.canvas.rows): for j in range(app.control.canvas.columns): app.control.canvas.matrix[j][i] = "red" app.gravity() self.assertEqual(app._job, None)
def eval_fitness(genome): net = nn.create_feed_forward_phenotype(genome) score = 0 for i in range(10): #do 10 games tetris_session = tetris.Game() tetris_session.start(continous_evaluation, net, False) score += tetris_session.score if score > 30000: return 1 else: return (score / (score + 30000))
def play(self): score = 0 game = tetris.Game(self.rows, self.columns, self.tetriminos, self.end_at) while not game.game_over: for i in tetrimino_dict[game.next_tetrimino]: print(i[:][::-1], '\n--------') tetris.print_game(game.grid) rotation = int(input("Enter a rotation: ")) column = int(input("Enter a column: ")) score += game.place_tetrimino(rotation, column) tetris.print_game(game.grid) print(score)
def test(self, session, num_tests): """ Test performance of agent, returning mean score and standard deviation from given number of test games. """ score_list = np.zeros(num_tests) for n in range(num_tests): game = tetris.Game(self.rows, self.columns, self.tetriminos, self.end_at) while not game.game_over: # Pass state to network - perform best action and add reward to log state = [game.state()] q_values = session.run(self.net.q_out, feed_dict={self.net.inputs: state}) mask = validity_mask(game.next_tetrimino, self.columns) q_masked = np.where(mask, q_values, -1000) action = np.argmax(q_masked, 1)[0] rotation, column = action_to_rc(action, self.columns) score_list[n] += game.place_tetrimino(rotation, column) return np.mean(score_list), np.std(score_list)
def play(genome, config): net = neat.nn.FeedForwardNetwork.create(genome, config) game = tet.Game() black = pygame.Color("#000000") white = pygame.Color("#FFFFFF") gray = pygame.Color("#ABABAB") pygame.init() zoom = 20 board_size = (200, 800) screen = pygame.display.set_mode(board_size) while (game.tetris.state == 0): pygame.event.get() screen.fill(white) piece_vector = dominator.one_hot(game.tetris.tet.type, 7) rotation_vector = dominator.one_hot(game.tetris.tet.rotation, 4) board, row = game.tetris.get_top_four() x_vector = np.array([game.tetris.tet.x]) y_vector = np.array([row - game.tetris.tet.y]) board_vector = np.ndarray.flatten(board) feature_vector = np.concatenate( (piece_vector, rotation_vector, x_vector, y_vector, board_vector)) output = net.activate(feature_vector) mv = np.argmax(output) prev_board = np.copy(game.tetris.board) game.move(mv) proj = game.tetris.get_projection() for i in range(tet.HEIGHT): for j in range(tet.WIDTH): pygame.draw.rect(screen, gray, [zoom * j, zoom * i, zoom, zoom], 1) if proj[i][j] > 0: pygame.draw.rect( screen, black, [zoom * j + 1, zoom * i + 1, zoom - 2, zoom - 1]) pygame.display.update() time.sleep(.05)
def play(genome, config): net = neat.nn.FeedForwardNetwork.create(genome, config) game = tet.Game() while (game.tetris.state == 0): game.tetris.print_board() piece_vector = dominator.one_hot(game.tetris.tet.type, 7) rotation_vector = dominator.one_hot(game.tetris.tet.rotation, 4) board, row = game.tetris.get_top_four() x_vector = dominator.one_hot(game.tetris.tet.x, 10) y_vector = dominator.one_hot(row - game.tetris.tet.y, 40) board_vector = np.ndarray.flatten(board) feature_vector = np.concatenate( (piece_vector, rotation_vector, x_vector, y_vector, board_vector)) output = net.activate(feature_vector) mv = np.argmax(output) prev_board = np.copy(game.tetris.board) game.move(mv) time.sleep(.05)
def eval_genome_top_four(genome, config): net = neat.nn.FeedForwardNetwork.create(genome, config) # scores = [] # for i in range(10): game = tet.Game() while (game.tetris.state == 0): if not HEADLESS: game.tetris.print_board() piece_vector = one_hot(game.tetris.tet.type, 7) rotation_vector = one_hot(game.tetris.tet.rotation, 4) board, row = game.tetris.get_top_four() #x_vector = np.array([game.tetris.tet.x]) x_vector = one_hot(game.tetris.tet.x, 10) #y_vector = np.array([row - game.tetris.tet.y]) y_vector = one_hot(row - game.tetris.tet.y, 40) board_vector = np.ndarray.flatten(board) feature_vector = np.concatenate( (piece_vector, rotation_vector, x_vector, y_vector, board_vector)) # print(feature_vector) output = net.activate(feature_vector) mv = np.argmax(output) prev_board = np.copy(game.tetris.board) game.move(mv) if not HEADLESS: time.sleep(.05) # scores.append(game.tetris.turns + game.tetris.score) # return np.average(scores) return game.tetris.turns + game.tetris.score
def learning_curve(self, training_intervals, interval_interactions): # Extra element for performance after 0 training scores_list = np.zeros(training_intervals + 1) devs_list = np.zeros(training_intervals + 1) ep_list = np.arange(training_intervals + 1) * interval_interactions with tf.Session() as sess: sess.run(self.init) # Ensure target network is initialised to same values as Q network perform_updates(self.initial_targets, sess) if self.use_summaries: self.writer = tf.summary.FileWriter('./graphs', sess.graph) for episode in tqdm(range(training_intervals)): current_interaction = 0 while current_interaction < interval_interactions: game = tetris.Game(self.rows, self.columns, self.tetriminos, self.end_at) while not game.game_over and current_interaction < interval_interactions: current_interaction += 1 # --------- Interact --------- # Get current state and perform feed forward pass state = game.state() q_values = sess.run( self.net.q_out, feed_dict={self.net.inputs: [state]}) # Validity mask for the current tetrimino, then select best action mask = validity_mask(game.next_tetrimino, self.columns) q_masked = np.where(mask, q_values, -np.inf) action = np.argmax(q_masked, 1)[0] # Epsilon greedy action - ensuring that action is valid if np.random.rand() < self.e: valid_act_args = [ i for i in range(self.output_size) if mask[i] == 1 ] action = np.random.choice(valid_act_args) # Decay e self.e = max(self.e_min, self.e - self.e_step) # convert action to a rotation and column which can be used to update the game rotation, column = action_to_rc(action, self.columns) reward = game.place_tetrimino(rotation, column) # State: s' state_new = game.state() mask_new = validity_mask(game.next_tetrimino, self.columns) # Save this experience if self.use_priority: self.replay_memory.save( state, action, reward, game.game_over, state_new, mask, mask_new, np.max(self.replay_memory.priorities)) else: self.replay_memory.save(state, action, reward, game.game_over, state_new, mask, mask_new) # --------- Train --------- # If not using experience replay, perform single update for this experience if not self.use_replay: # Q values for s' according to target network q_new = sess.run( self.target.q_out, feed_dict={self.target.inputs: [state_new]}) q_new_masked = np.where(mask_new, q_new, -1000) if self.use_double: # 1) Q network to select best action q = sess.run( self.net.q_out, feed_dict={self.net.inputs: [state_new]}) q = np.where(mask_new, q, -1000) a_max = np.argmax(q, 1) # 2) Use target network to determine value of action q_max = q_new[0, a_max] else: # Use target net to select the action and its value q_max = np.max(q_new_masked) # Set target values q_target = q_values if game.game_over: q_target[0, action] = reward else: q_target[0, action] = reward + self.y * q_max # Train network _ = sess.run(self.net.update_model, feed_dict={ self.net.inputs: [state], self.net.target_q: q_target }) perform_updates(self.updater, sess) else: if self.use_priority: self.priority_replay_train(sess) else: self.replay_train(sess) # Test current performance of agent and store so that learning curve can be plotted av_score, dev = self.test(sess, 100) scores_list[episode + 1] = av_score devs_list[episode + 1] = dev if self.save_model: self.saver.save(sess, self.save_directory) print('Saved!') return ep_list, scores_list, devs_list
def test_terminate(self): app = tetris.Game(title="Tetris") app.second_screen() control = app.control app.terminate() self.assertNotEqual(control, app.control)
def __init__(self, number_of_games=1): self.game = tetris.Game() self.number_of_games = number_of_games self.game_iterator = 0 self.game_cleared_lines = 0 self.game_score = 0
def reset_game(self): self.game = tetris.Game() self.game_iterator += 1 self.game_cleared_lines = 0 self.game_score = 0
def setUp(self): self.game = tetris.Game(width=10, height=10) self.shapes = self.game.shape_generator.shapes
def key_press_handler(event): if event.name == 'left': game.move_piece_horizontally(-1) elif event.name == 'right': game.move_piece_horizontally(1) elif event.name == 'up': game.rotate_piece(1) elif event.name == 'down': game.move_piece_down() elif event.name == 'space': game.move_piece_down_until_not_allowed() keyboard.on_press(key_press_handler) game = tetris.Game() start_time = time.time() i = 0 while not game.is_game_over(): if time.time() > start_time + i: i += 1 game.tick() game.print() game.print() print('\nGame over, your final score was', game.get_score()) input("Press enter key to continue")
# Constants # colors BLACK = (0, 0, 0) BLUE = (0, 0, 255) WHITE = (255, 255, 255) GRAY = (128, 128, 128) pygame.init() pygame.display.set_caption("Tetris") SQUARE_SIZE = 50 BOARD_WIDTH = 10 BOARD_HEIGHT = 15 game = tetris.Game(BOARD_WIDTH, BOARD_HEIGHT) DISPLAY_HEIGHT = SQUARE_SIZE * BOARD_HEIGHT DISPLAY_WIDTH = SQUARE_SIZE * BOARD_WIDTH display_size = [DISPLAY_WIDTH, DISPLAY_HEIGHT] # Set up the drawing window screen = pygame.display.set_mode(display_size) line_clear_scores = {0: 0, 1: 100, 2: 300, 3: 500, 4: 800} score = 0 start_time = time.time() i = 0 should_quit = False while not game.is_game_over() and not should_quit: