def test_mark_cells_adjacents(self):
self.ms = MineSweeper(3, 3, 0)
self.ms.add_mine(0, 0)
self.ms.pick_cell(0, 1)
self.ms.pick_cell(1, 0)
# Can't mark yet, not enough info! (could be 0,0 or 1,1)
# B 1 ?
# 1 ? ?
# ? ? ?
self.ms.ai.mark_cells()
self.assertEqual(self.count_marked_cells(), 0)
self.ms.add_mine(1, 1)
# B 2 ?
# 2 B ?
# ? ? ?
self.ms.ai.mark_cells()
self.assertEqual(self.count_marked_cells(), 0)
# Reveal top right, Adjacency should give us top left
# B 2 1
# 2 B ?
# ? ? ?
self.ms.pick_cell(0, 2)
self.ms.ai.mark_cells()
self.ms.display_grid()
self.assertEqual(self.count_marked_cells(), 1)
self.assertEqual(self.ms.grid[0][0].marked, True)
def test_reveal_cell_basic(self):
self.ms = MineSweeper(4, 4, 0)
# ----------------------------------------
# 0| ?, ?, 1, 0,
# 1| ?, ?, 2, 1,
# 2| ?, ?, ?, ?,
# 3| ?, ?, ?, ?,
# ----------------------------------------
self.ms.add_mine(0, 1)
self.ms.add_mine(2, 3)
self.ms.pick_cell(0, 3)
self.ms.display_grid()
cell = self.ms.ai.reveal_cell()
self.assertEquals(cell, (2, 1))
def test_mark_cells_basic_one(self):
self.ms = MineSweeper(3, 3, 0)
self.ms.add_mine(0, 0)
for y in xrange(len(self.ms.grid)):
for x in xrange(len(self.ms.grid[0])):
if y != 0 and x != 0:
self.ms.pick_cell(y, x)
# B 1 0
# 1 1 0
# 0 0 0
self.ms.ai.mark_cells()
self.ms.display_grid()
self.assertEqual(self.count_marked_cells(), 1)
self.assertEqual(self.ms.grid[0][0].marked, True)
def test_mark_cells_adjacents_two(self):
# B ? B
# 1 2 1
# 0 0 0
self.ms = MineSweeper(3, 3, 0)
self.ms.add_mine(0, 0)
self.ms.add_mine(0, 2)
for y in xrange(1, len(self.ms.grid)):
for x in xrange(len(self.ms.grid[0])):
self.ms.pick_cell(y, x)
self.ms.ai.mark_cells()
self.assertEqual(self.count_marked_cells(), 2)
self.assertEqual(self.ms.grid[0][0].marked, True)
self.assertEqual(self.ms.grid[0][2].marked, True)
def test_mark_cells_basic_three(self):
self.ms = MineSweeper(3, 3, 0)
self.ms.add_mine(0, 0)
self.ms.add_mine(0, 1)
self.ms.add_mine(0, 2)
for y in xrange(1, len(self.ms.grid)):
for x in xrange(len(self.ms.grid[0])):
self.ms.pick_cell(y, x)
# B B B
# 2 3 2
# 0 0 0
self.ms.ai.mark_cells()
self.ms.display_grid()
self.assertEqual(self.count_marked_cells(), 3)
self.assertEqual(self.ms.grid[0][0].marked, True)
self.assertEqual(self.ms.grid[0][1].marked, True)
self.assertEqual(self.ms.grid[0][2].marked, True)
def test_reveal_cell_complex(self):
""" Present it a situation where it *must* use adjaceny rules"""
# ----------------------------------------
# 0| 1, M, B, ?,
# 1| 2, 3, 2, ?,
# 2| 1, M, ?, ?,
# ----------------------------------------
self.ms = MineSweeper(3, 4, 0)
self.ms.add_mine(0, 1)
self.ms.add_mine(2, 1)
self.ms.add_mine(0, 2)
self.ms.pick_cell(0, 0)
self.ms.pick_cell(1, 0)
self.ms.pick_cell(2, 0)
self.ms.pick_cell(1, 1)
self.ms.pick_cell(1, 2)
self.ms.mark_cell(0, 1)
self.ms.mark_cell(0, 2)
# ----
pick = self.ms.ai.reveal_cell()
self.assertIn(pick, {(0, 3), (1, 3), (2, 3)})
self.assertEqual(self.ms.ai.guessing, False)
def test_brute_force(self):
""" loop over a number of grids, making sure we only fail on random guesses"""
wins = 0
losses = 0
games = 1
for i in xrange(games):
self.ms = MineSweeper(16, 30, 99) # standard expert grid
while not self.ms.victory and not self.ms.game_over:
self.ms.ai.mark_cells()
pick = self.ms.ai.reveal_cell()
self.ms.pick_cell(*pick)
if self.ms.victory:
wins += 1
if self.ms.game_over:
if self.ms.ai.guessing:
losses += 1
else:
self.ms.display_grid()
print pick
assert 0, "Lost on a non guess"
print "Games:{}\n\tWins:{}\n\tLosses:{}".format(games, wins, losses)
def test_add_mine(self):
ms = MineSweeper(3, 3, 0)
ms.add_mine(0, 0)
# M 1 0
# 1 0 0
# 0 0 0
self.assertEqual(ms.grid[0][0].value, -1)
self.assertEqual(ms.grid[0][1].value, 1)
self.assertEqual(ms.grid[1][0].value, 1)
ms.add_mine(1, 1)
# M 2 1
# 2 M 1
# 1 1 1
self.assertEqual(ms.grid[0][0].value, -1)
self.assertEqual(ms.grid[1][1].value, -1)
self.assertEqual(ms.grid[0][1].value, 2)
self.assertEqual(ms.grid[1][0].value, 2)
self.assertEqual(ms.grid[0][2].value, 1)
self.assertEqual(ms.grid[2][0].value, 1)
self.assertEqual(ms.grid[1][2].value, 1)
self.assertEqual(ms.grid[2][1].value, 1)
self.assertEqual(ms.grid[2][2].value, 1)
def test_reveal_cell_guess(self):
""" Present it a situation where it *must* guess"""
# ----------------------------------------
# 0| 1, M, B, ?,
# 1| 2, 3, 3, ?,
# 2| 1, M, ?, B,
# ----------------------------------------
self.ms = MineSweeper(3, 4, 0)
self.ms.add_mine(0, 1)
self.ms.add_mine(2, 1)
self.ms.add_mine(0, 2)
self.ms.add_mine(2, 3)
self.ms.pick_cell(0, 0)
self.ms.pick_cell(1, 0)
self.ms.pick_cell(2, 0)
self.ms.pick_cell(1, 1)
self.ms.pick_cell(1, 2)
self.ms.mark_cell(0, 1)
self.ms.mark_cell(0, 2)
# ----
pick = self.ms.ai.reveal_cell()
self.assertIn(pick, {(0, 3), (1, 3), (2, 3)})
self.assertEqual(self.ms.ai.guessing, True)
def main_loop():
# Obtain the width and height of the screen.
width = field_width * tile_width + 10
height = field_height * tile_height + digit_height + 15
smiley_offset = (width // 2 - digit_height // 2, 5)
win = pygame.display.set_mode((width, height))
pygame.display.set_caption('Minesweeper')
clock = pygame.time.Clock()
minesweeper = MineSweeper(field_width, field_height, field_mines)
steps = solver(minesweeper)
run = True
while run:
for event in pygame.event.get():
if (event.type == pygame.QUIT
or (event.type == pygame.KEYDOWN
and event.key in [pygame.K_q, pygame.K_ESCAPE])):
run = False
# Handle mouse clicks.
if handle_clicks(event, minesweeper,
offset=(5, digit_height + 10)):
# On user input, just in case reset the solver.
steps = solver(minesweeper)
if handle_click_smiley(event, minesweeper, offset=smiley_offset):
# On reset, create a new solver.
steps = solver(minesweeper)
if event.type == pygame.KEYDOWN and event.key == pygame.K_r:
# Reset the minesweeper.
minesweeper.reset()
print('RESET')
steps = solver(minesweeper)
if event.type == pygame.KEYDOWN and event.key == pygame.K_n:
# Try twice if in case generator was exhausted in which case we use a newer one.
# If solver can't solve it in second try don't simply keep calling it.
tries = 0
while tries <= 1:
try:
# Obtain the step from the solver.
position, operation = next(steps)
if operation == MARK:
print(f'[AI] MARK {position[0]}, {position[1]}')
minesweeper.toggle(position, force_mark=True)
elif operation == UNCOVER:
print(f'[AI] UNCOVER {position[0]}, {position[1]}')
minesweeper.uncover(position)
break
except StopIteration:
# reset the solver in case previous one exhausted and check if it can solve
steps = solver(minesweeper)
tries += 1
win.fill((255, 255, 255))
# Render the time and number of mines.
count_surf = number_surface(minesweeper.pending_mines())
win.blit(count_surf, (5, 5))
time_surf = number_surface(minesweeper.time_progressed())
time_rect = time_surf.get_rect()
win.blit(time_surf, (width - time_rect.width - 5, 5))
# Render the smiley
draw_smiley(win, minesweeper, offset=smiley_offset)
# Render the minesweeper field
draw_minesweeper(win, minesweeper, offset=(5, digit_height + 10))
pygame.display.update()
clock.tick(60)
from minesweeper import MineSweeper
m = MineSweeper()
m.set_mines(1)
game_over = False
while not game_over:
m.print()
x = int(input("enter x:"))
y = int(input("enter y:"))
move_type = input(
"enter 'o' for open, 'f' for flag or a 'd' for discover:")
game_over = m.move(move_type, x, y)
def __init__(self, size: int):
super(QMineSweeper, self).__init__()
self.size = size
self.mineSweeper = MineSweeper(self.size, 0.10)
self.initUI()
self.show()
def test_dot_should_return_0(self):
ms = MineSweeper(".")
self.assertEquals("0", ms.solve())
def setUp(self):
self.minesweeper = MineSweeper()
def test_star_should_return_star(self):
self.assertEquals("*", MineSweeper("*").solve())
def test_star_dot_should_return_star_1(self):
self.assertEquals("*.", MineSweeper("*1").solve())
__default_state_shape__))
from ai import AI
from minesweeper import VisualizeAI
ai = AI(state_shape=__default_state_shape__,
action_dim=__default_action_dim__,
verbose=verbose)
if verbose:
print("Load AI model from file: [{0}] ...".format(__filename__),
end="")
ai.load_nnet(__filename__)
if verbose:
print("OK!")
vi = VisualizeAI(state_shape=__default_state_shape__,
ai=ai,
verbose=verbose)
vi.start()
if args.play:
print(
"Play game. Please close game in terminal after closing window (i.e, Press Ctrl+C)."
)
from minesweeper import MineSweeper
minesweeper = MineSweeper(state_shape=__default_state_shape__,
verbose=verbose)
minesweeper.start()
import sys
from minesweeper import MineSweeper
if __name__ == '__main__':
ms = MineSweeper(10, 10)
quit = False
while (not quit):
print('Enter position you want to reveal.')
pos = input().split()
import time
from minesweeper import MineSweeper
if __name__ == '__main__':
start = time.time()
for i in range(0, 300):
mine = MineSweeper(25, 25, 25)
mine.mine(5, 10)
print(time.time() - start)
sys.path.insert(
0,
os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))),
'src/game'))
from random import randint
from tkinter import *
from tkinter import messagebox
from minesweeper import MineSweeper
from cellstatus import CellStatus
from gamestatus import GameStatus
is_first_click = True
minesweeper = MineSweeper()
minesweeper.set_mines(randint(0, 100))
root = Tk()
root.title('Minesweeper')
def disable_cells():
for row in range(minesweeper.BOUNDS):
for col in range(minesweeper.BOUNDS):
button[row][col].config(state="disabled")
def handle_left_click(row, col):
minesweeper.expose_cell(row, col)
if minesweeper.get_game_status() == GameStatus.INPROGRESS:
async def new_game(source, user, msg_type, row: int, column: int, mines: int):
if user.id in in_gaming_list:
await send_msg(source, [Plain("你已经在游戏中了")], user, msg_type)
return
in_gaming_list[user.id] = MineSweeper(row, column, mines)
await send_panel(app, source, user, msg_type)
