def test_select(self):
game = Game(GameConfig(3, 3, 2))
board = self.flip([[False, True, False], [False, False, False],
[False, False, True]])
self.reinit_game(game, board)
#expose only same square
result = game.select(1, 1)
self.assertFalse(result.explosion)
self.assertEqual(1, len(result.new_squares))
self.assertEqual(result.new_squares[0], Position(1, 1, 2))
#expose neighbors
result = game.select(0, 2)
self.assertFalse(result.explosion)
self.assertEqual(3, len(result.new_squares))
self.assertTrue(Position(0, 2, 0) in result.new_squares)
self.assertTrue(Position(0, 1, 1) in result.new_squares)
self.assertTrue(Position(1, 2, 1) in result.new_squares)
#select square already selected or exposed
self.assertIsNone(game.select(0, 2))
self.assertIsNone(game.select(1, 2))
#select outside the board
with self.assertRaises(ValueError):
game.select(2, 3)
#boom
result = game.select(1, 0)
self.assertTrue(result.explosion)
#select after game over
with self.assertRaises(ValueError):
game.select(2, 0)
def restart():
req = request.get_json()
col = req['col']
row = req['row']
mines = req['mines']
session['game'] = Game(row, col, mines)
game_obj = session['game']
return get_game_obj_response(game_obj)
def test_reveal_empty(self):
game = Game(self.mines, self.flags)
self.assertEqual(True, game.reveal(3, 3))
self.assertEqual(self.flags, Table.from_nested_list([
[Flags.Unknown, Flags.Unknown, Flags.Revealed, Flags.Revealed],
[Flags.Unknown, Flags.Unknown, Flags.Revealed, Flags.Revealed],
[Flags.Revealed, Flags.Revealed, Flags.Revealed, Flags.Revealed],
[Flags.Revealed, Flags.Revealed, Flags.Revealed, Flags.Revealed],
]))
def test_reveal_mine(self):
game = Game(self.mines, self.flags)
self.assertEqual(False, game.reveal(1, 1))
self.assertEqual(self.flags, Table.from_nested_list([
[Flags.Unknown, Flags.Unknown, Flags.Unknown, Flags.Unknown],
[Flags.Unknown, Flags.Revealed, Flags.Unknown, Flags.Unknown],
[Flags.Unknown, Flags.Unknown, Flags.Unknown, Flags.Unknown],
[Flags.Unknown, Flags.Unknown, Flags.Unknown, Flags.Unknown],
]))
def mark():
req = request.get_json()
col = req['col']
row = req['row']
if 'game' not in session:
session['game'] = Game(*default_game)
game_obj = session['game']
game_obj.mark(row, col)
session['game'] = game_obj
return get_game_obj_response(game_obj)
def test_init_counts(self):
game = Game(GameConfig(5, 4, 4))
board = self.flip([[True, False, False, False, False],
[False, False, False, True, False],
[False, False, False, True, False],
[False, False, True, False, False]])
counts = self.flip([[0, 1, 1, 1, 1], [1, 1, 2, 1, 2], [0, 1, 3, 2, 2],
[0, 1, 1, 2, 1]])
self.reinit_game(game, board)
self.assertEqual(counts, game.counts)
def test_get_state(self):
game = Game(GameConfig(3, 3, 3))
board = self.flip([[False, False, True], [False, False, False],
[True, False, True]])
self.reinit_game(game, board)
game.select(0, 0)
expected = self.flip([[0, 1, None], [1, 3, None], [None, None, None]])
state = game.get_state()
for x in [0, 1, 2]:
for y in [0, 1, 2]:
self.assertEqual(expected[x][y], state[x][y])
def test_reveal_revealed_hint(self):
self.flags = Table.from_nested_list([
[Flags.Revealed, Flags.Unknown, Flags.Unknown, Flags.Unknown],
[Flags.Unknown, Flags.Marked, Flags.Unknown, Flags.Unknown],
[Flags.Unknown, Flags.Unknown, Flags.Unknown, Flags.Unknown],
[Flags.Unknown, Flags.Unknown, Flags.Unknown, Flags.Unknown],
])
game = Game(self.mines, self.flags)
self.assertEqual(True, game.reveal(0, 0))
self.assertEqual(self.flags, Table.from_nested_list([
[Flags.Revealed, Flags.Revealed, Flags.Unknown, Flags.Unknown],
[Flags.Revealed, Flags.Marked, Flags.Unknown, Flags.Unknown],
[Flags.Unknown, Flags.Unknown, Flags.Unknown, Flags.Unknown],
[Flags.Unknown, Flags.Unknown, Flags.Unknown, Flags.Unknown],
]))
def test_is_game_over(self):
game = Game(GameConfig(3, 3, 1))
board = self.flip([[False, False, True], [False, False, False],
[False, False, False]])
self.reinit_game(game, board)
#not over before we start
self.assertFalse(game.is_game_over())
#over after explosion
result = game.select(2, 0)
self.assertTrue(result.explosion)
self.assertTrue(game.is_game_over())
#over when all the squares have been revealed
self.reinit_game(game, board)
result = game.select(0, 0)
self.assertFalse(result.explosion)
self.assertEqual(8, len(result.new_squares))
self.assertTrue(game.is_game_over())
from string import ascii_lowercase
from minesweeper import Game
if __name__ == '__main__':
size_x = 8
size_y = 8
mines = 10
letters = {letter: index for index, letter in enumerate(ascii_lowercase)}
game = Game(size_y, size_x, mines)
print('Minesweper ({},{}) with {} mines.'.format(size_y, size_x, mines))
print('Input your moves in row column format, e.g. a 4.')
print('If you want to add a flag, add f after the position, e.g. b 6 f.')
print('Flags are {} and unopened fields are {}.'.format(Game._FLAG, Game._UNOPENED))
while game.won() == 0:
game.show_field()
print()
move = input('Your input: ')
move = move.split()
try:
y = letters[move[0]]
x = int(move[1])
if len(move) == 2:
game.open(y, x)
else:
game.flag(y, x)
except Exception:
print('Invalid move. Please try again.')
# Make a path for our model to be saved in.
if not os.path.exists(path):
os.makedirs(path)
print("Start training.")
with tf.Session() as sess:
sess.run(init)
if load_model:
print('Loading Model...')
ckpt = tf.train.get_checkpoint_state(path)
saver.restore(sess, ckpt.model_checkpoint_path)
for i in range(num_episodes):
episodeBuffer = qnetwork.ExperienceBuffer()
# Reset environment and get first new observation
game = Game(field_size, field_size, mines)
s = game.state()
d = False
rAll = 0
j = 0
actions = []
# The Q-Network
while j < max_epLength: # If the network takes more moves than needed for the field, cancel episode
j += 1
# Choose an action by greedily (with e chance of random action) from the Q-network
if np.random.rand(1) < e or total_steps < pre_train_steps:
a = np.random.randint(0, num_actions)
else:
a = sess.run(mainQN.predict,
feed_dict={
mainQN.input:
def test_place_mines(self):
game = Game(GameConfig(100, 100, 800))
self.assertEqual(800, sum([row.count(True) for row in game.board]))
