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:
