minesweeper in python with curses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 

391 lines
12 KiB

import random
# 8x8_10
# 16x16_40
# 16x30_99
# under variables
UNDER_DEFAULT = 0
UNDER_BOMB = -1
# over variables
OVER_DEFAULT = '_'
OVER_FLAGGED = 'x'
OVER_UNCOVERED = 'u'
OVER_MOVES = [OVER_FLAGGED, OVER_UNCOVERED]
# board variables
BOARD_COVERED = '_'
BOARD_FLAGGED = '!'
BOARD_BOMB_UNCOVERED = 'x'
BOARD_BOMB_COVERED = '-'
BOARD_BOMB_FLAGGED = '+'
DELIMITER = '|'
# get a random seed value
def get_seed():
return random.randint(1,1000000)
class MinesweeperLogic:
# field is the bombs and the values
# board is uncovered/flagged
UNDER = []
OVER = []
# other variables
WIDTH = 0
HEIGHT = 0
BOMBS = 0
SEED = 0
MOVES = []
def do_all_moves(self):
for move in self.MOVES:
self.do_move(int(move[0]), int(move[1]), move[2])
def load(self, filename):
# get a handle to the global variables
#global WIDTH, HEIGHT, BOMBS, SEED, MOVES
# grab the lines from the file
with open(filename, 'r') as fil:
istr = fil.readline().strip()
moves = fil.readlines()
# the first line must have 4 numeric values
try:
ilist = [int(i) for i in istr.split('|')]
except ValueError as e:
return False
if len(ilist) == 4:
# set up global variables
self.WIDTH = ilist[0]
self.HEIGHT = ilist[1]
self.BOMBS = ilist[2]
self.SEED = ilist[3]
self.setup()
# validate moves
for m in moves:
vm = self.validate_move(m.strip())
if not vm:
return False
#self.MOVES.append(vm)
self.do_move(vm[0], vm[1], vm[2])
# if all the moves are valid, do them
#self.do_all_moves()
#for move in self.MOVES:
#self.do_move(int(move[0]), int(move[1]), move[2])
return True
return False
def save(self, filename=None):
# set a filename, if missing
if filename is None:
filename = "{}.sweepy".format(str(self.SEED))
with open(filename, "w") as fn:
# write the header information
fn.write("{}|{}|{}|{}\n".format(str(self.WIDTH),
str(self.HEIGHT),
str(self.BOMBS),
str(self.SEED)))
# write the moves
for move in self.MOVES:
fn.write("{}\n".format(str(move)))
def new_game(self, width=8, height=8, bombs=10):
self.WIDTH = width
self.HEIGHT = height
self.BOMBS = bombs
self.setup()
self.do_first_move()
# handle interactive highlighting
def get_first_cell(self):
for y, col in enumerate(self.OVER):
for x, cell in enumerate(col):
if cell == OVER_DEFAULT:
return y, x
def get_covered_cells(self):
out = []
for y, col in enumerate(self.OVER):
for x, cell in enumerate(col):
if cell == OVER_DEFAULT:
out.append([y,x])
return out
def closest(self, y, x):
covered_cells = self.get_covered_cells()
for point in covered_cells:
if point[0] == y and point[1] > x:
return point[0], point[1]
elif point[0] > y:
return point[0], point[1]
return covered_cells[0][0], covered_cells[0][1]
def get_closest_cell(self, y, x):
# set some defaults that will be overwritten
min_off = self.WIDTH + self.HEIGHT
ny = -1
nx = -1
# go through the directions
ry, rx, ro = self.get_right(y, x)
if 0 < ro < min_off:
min_off = ro
ny = ry
nx = rx
dy, dx, do = self.get_down(y, x)
if 0 < do < min_off:
min_off = do
ny = dy
nx = dx
ly, lx, lo = self.get_left(y, x)
if 0 < lo < min_off:
min_off = lo
ny = ly
nx = lx
uy, ux, uo = self.get_up(y, x)
if 0 < uo < min_off:
min_off = uo
ny = uy
nx = ux
# if we found something, return it
if min_off < self.WIDTH + self.HEIGHT:
return ny, nx
else:
return self.get_first_cell()
def get_left(self, y, x):
col = self.OVER[y]
for ix in range(1,x+1):
adj_x = x - ix
if col[adj_x] in (OVER_DEFAULT, OVER_FLAGGED):
return y, adj_x, abs(adj_x - x)
return y, x, 0
def get_right(self, y, x):
col = self.OVER[y]
for ix in range(x+1,len(col)):
if col[ix] in (OVER_DEFAULT, OVER_FLAGGED):
return y, ix, abs(ix - x)
return y, x, 0
def get_up(self, y, x):
row = [self.OVER[i][x] for i in range(len(self.OVER))]
for iy in range(1,y+1):
adj_y = y - iy
if row[adj_y] in (OVER_DEFAULT, OVER_FLAGGED):
return adj_y, x, abs(adj_y - y)
return y, x, 0
def get_down(self, y, x):
row = [self.OVER[i][x] for i in range(len(self.OVER))]
for iy in range(y+1, len(row)):
if row[iy] in (OVER_DEFAULT, OVER_FLAGGED):
return iy, x, abs(iy - y)
return y, x, 0
def do_first_move(self):
for y, col in enumerate(self.UNDER):
for x, cell in enumerate(self.UNDER[y]):
if cell == UNDER_DEFAULT:
self.do_move(y, x, OVER_UNCOVERED)
return
def validate_move(self, move):
if type(move) is list:
mlist = move
else:
mlist = move.split(DELIMITER)
try:
if not 0 <= int(mlist[0]) < self.WIDTH:
return None
mlist[0] = int(mlist[0])
if not 0 <= int(mlist[1]) < self.HEIGHT:
return None
mlist[1] = int(mlist[1])
if mlist[2] in OVER_MOVES:
return mlist
except ValueError as e:
return None
# returns true if move is successful/valid
# returns false otherwise
def do_move(self, col, row, move, propagated=False):
# if the cell hasn't been uncovered, try to uncover it
if self.OVER[col][row] == OVER_DEFAULT:
if move == OVER_FLAGGED:
if not propagated:
self.MOVES.append("{}|{}|{}".format(str(col), str(row), move))
self.OVER[col][row] = move
elif move == OVER_UNCOVERED:
# uncover the targeted cell
if not propagated:
self.MOVES.append("{}|{}|{}".format(str(col), str(row), move))
self.OVER[col][row] = move
# if the uncovered cell is the default,
# uncover neighboring cells
if self.UNDER[col][row] == UNDER_DEFAULT:
neighbors = self.get_valid_neighbors(col, row)
for n in neighbors:
n.extend(move) # add the move to the neighbor
vm = self.validate_move(n)
if vm and self.UNDER[vm[0]][vm[1]] != UNDER_BOMB:
self.do_move(vm[0], vm[1], vm[2], True)
elif self.OVER[col][row] == OVER_FLAGGED and move == OVER_FLAGGED:
if not propagated:
self.MOVES.append("{}|{}|{}".format(str(col), str(row), move))
self.OVER[col][row] = OVER_DEFAULT
else:
return False
def setup(self):
# grab a handle to the global variables
if self.SEED == 0:
self.SEED = get_seed()
# initialize with the width
# use None objects, as these will be ultimately be lists
self.UNDER = [None] * self.WIDTH
self.OVER = [None] * self.WIDTH
# add the height rows (use the defaults)
for i in range(self.WIDTH):
under_row = [UNDER_DEFAULT] * self.HEIGHT
self.UNDER[i] = under_row
over_row = [OVER_DEFAULT] * self.HEIGHT
self.OVER[i] = over_row
# generate and place the bombs
random.seed(self.SEED)
for i in range(self.BOMBS):
while True:
w = random.randint(0, self.WIDTH - 1)
h = random.randint(0, self.HEIGHT - 1)
if self.UNDER[w][h] == UNDER_DEFAULT:
self.UNDER[w][h] = UNDER_BOMB
break
# calculate the values next to the bombs
for w in range(self.WIDTH):
for h in range(self.HEIGHT):
if self.UNDER[w][h] == UNDER_BOMB:
neighbors = self.get_valid_neighbors(w, h)
for n in neighbors:
if self.UNDER[n[0]][n[1]] != UNDER_BOMB:
self.UNDER[n[0]][n[1]] += 1
def get_valid_neighbors(self, col, row):
# calculate the values
col_left = col - 1
col_right = col + 1
row_up = row - 1
row_down = row + 1
# calculate which directions we can go
left = True if col_left >= 0 else False
right = True if col_right < self.WIDTH else False
up = True if row_up >= 0 else False
down = True if row_down < self.HEIGHT else False
# valid neighbors
vns = []
if left and up:
vns.append([col_left, row_up])
if left:
vns.append([col_left, row])
if left and down:
vns.append([col_left, row_down])
if right and up:
vns.append([col_right, row_up])
if right:
vns.append([col_right, row])
if right and down:
vns.append([col_right, row_down])
if up:
vns.append([col, row_up])
if down:
vns.append([col, row_down])
return vns
def has_won(self):
# win condition: all non-bombs are uncovered
for w in range(0,self.WIDTH):
for h in range(0,self.HEIGHT):
if self.UNDER[w][h] != UNDER_BOMB and self.OVER[w][h] != OVER_UNCOVERED:
return False
return True
def has_lost(self):
# lose condition: at least one bomb is uncovered
for w in range(0,self.WIDTH):
for h in range(0,self.HEIGHT):
if self.UNDER[w][h] == UNDER_BOMB and self.OVER[w][h] == OVER_UNCOVERED:
return True
return False
def get_board(self):
# this will be what the user sees
lost = self.has_lost()
out = []
for c in range(self.WIDTH):
col = self.OVER[c]
inner = []
for r in range(self.HEIGHT):
row = col[r]
under_cell = self.UNDER[c][r]
if row == OVER_UNCOVERED and under_cell >= 0:
inner.append(str(under_cell))
elif row == OVER_UNCOVERED:
inner.append(BOARD_BOMB_UNCOVERED)
elif row == OVER_FLAGGED:
if lost and under_cell == UNDER_BOMB:
inner.append(BOARD_BOMB_FLAGGED)
else:
inner.append(BOARD_FLAGGED)
else:
if lost and under_cell == UNDER_BOMB:
inner.append(BOARD_BOMB_COVERED)
else:
inner.append(BOARD_COVERED)
out.append(inner)
return out
def get_flag_count(self):
total = 0
for col in self.OVER:
for cell in col:
if cell == OVER_FLAGGED:
total += 1
return total