forked from IPKM/nmreval
778 lines
22 KiB
Python
778 lines
22 KiB
Python
import random
|
|
import time
|
|
|
|
import numpy as np
|
|
|
|
from ..Qt import QtWidgets, QtCore, QtGui
|
|
|
|
|
|
__all__ = ['Game']
|
|
|
|
|
|
class Game(QtWidgets.QDialog):
|
|
def __init__(self, mode, parent=None):
|
|
super().__init__(parent=parent)
|
|
|
|
layout = QtWidgets.QVBoxLayout()
|
|
layout.setContentsMargins(3, 3, 3, 3)
|
|
|
|
self.label = QtWidgets.QLabel(self)
|
|
layout.addWidget(self.label)
|
|
|
|
self.startbutton = QtWidgets.QPushButton('Start', self)
|
|
self.startbutton.clicked.connect(self.start)
|
|
layout.addWidget(self.startbutton)
|
|
|
|
if mode == 'tetris':
|
|
self._setup_tetris()
|
|
else:
|
|
self._setup_snake()
|
|
|
|
layout.addWidget(self.board)
|
|
self.setStyleSheet("""
|
|
Board {
|
|
border: 5px solid black;
|
|
}
|
|
QPushButton {
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
|
|
self.setLayout(layout)
|
|
|
|
self.board.new_status.connect(self.new_message)
|
|
|
|
def _setup_tetris(self):
|
|
self.board = TetrisBoard(self)
|
|
self.setGeometry(200, 100, 276, 546+self.startbutton.height()+self.label.height())
|
|
self.setWindowTitle('Totally not Tetris')
|
|
|
|
def _setup_snake(self):
|
|
self.board = SnakeBoard(self)
|
|
self.setGeometry(200, 100, 406, 406+self.startbutton.height()+self.label.height())
|
|
self.setWindowTitle('Snakey')
|
|
|
|
def start(self):
|
|
|
|
self.board.start()
|
|
|
|
@QtCore.pyqtSlot(str)
|
|
def new_message(self, msg: str):
|
|
self.label.setText(msg)
|
|
|
|
|
|
class Board(QtWidgets.QFrame):
|
|
new_status = QtCore.pyqtSignal(str)
|
|
|
|
SPEED = 1000
|
|
WIDTH = 10
|
|
HEIGHT = 10
|
|
|
|
def __init__(self, parent=None):
|
|
super().__init__(parent=parent)
|
|
|
|
self.timer = QtCore.QTimer(self)
|
|
self.timer.timeout.connect(self.next_move)
|
|
|
|
self.score = 0
|
|
self._speed = self.SPEED
|
|
self._ispaused = False
|
|
self._isdead = True
|
|
|
|
self.setFrameStyle(QtWidgets.QFrame.Box | QtWidgets.QFrame.Raised)
|
|
self.setLineWidth(3)
|
|
|
|
self.setFocusPolicy(QtCore.Qt.StrongFocus)
|
|
self.setSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.MinimumExpanding)
|
|
|
|
def _init_game(self):
|
|
raise NotImplementedError
|
|
|
|
@property
|
|
def cellwidth(self):
|
|
return int(self.contentsRect().width() // self.WIDTH)
|
|
|
|
# square height
|
|
@property
|
|
def cellheight(self):
|
|
return int(self.contentsRect().height() // self.HEIGHT)
|
|
|
|
def start(self):
|
|
if self._isdead:
|
|
self._init_game()
|
|
self.new_status.emit(f'Score: {self.score}')
|
|
self.timer.start(self._speed)
|
|
self._isdead = False
|
|
self.setFocus()
|
|
|
|
def stop(self, msg):
|
|
self.new_status.emit(f'Score {self.score} // ' + msg)
|
|
self._isdead = True
|
|
self.timer.stop()
|
|
|
|
def pause(self):
|
|
if self._ispaused and not self._isdead:
|
|
self.new_status.emit(f'Score {self.score}')
|
|
self.timer.start(self._speed)
|
|
else:
|
|
self.new_status.emit(f'Score {self.score} // Paused')
|
|
self.timer.stop()
|
|
|
|
self._ispaused = not self._ispaused
|
|
|
|
def next_move(self):
|
|
raise NotImplementedError
|
|
|
|
def draw_square(self, painter, x, y, color):
|
|
color = QtGui.QColor(color)
|
|
painter.fillRect(x+1, y+1, self.cellwidth-2, self.cellheight-2, color)
|
|
|
|
def draw_circle(self, painter, x, y, color):
|
|
painter.save()
|
|
|
|
color = QtGui.QColor(color)
|
|
painter.setPen(QtGui.QPen(color))
|
|
painter.setBrush(QtGui.QBrush(color))
|
|
painter.drawEllipse(x+1, y+1, self.cellwidth, self.cellheight)
|
|
|
|
painter.restore()
|
|
|
|
def keyPressEvent(self, evt):
|
|
if evt.key() == QtCore.Qt.Key_P:
|
|
self.pause()
|
|
else:
|
|
super().keyPressEvent(evt)
|
|
|
|
|
|
class SnakeBoard(Board):
|
|
SPEED = 125
|
|
WIDTH = 35
|
|
HEIGHT = 35
|
|
|
|
def __init__(self, parent=None):
|
|
super().__init__(parent=parent)
|
|
|
|
self.snake = [[int(SnakeBoard.WIDTH//2), int(SnakeBoard.HEIGHT//2)],
|
|
[int(SnakeBoard.WIDTH//2)+1, int(SnakeBoard.HEIGHT//2)]]
|
|
self.current_x_head, self.current_y_head = self.snake[0]
|
|
self.direction = 'l'
|
|
self.next_direction = []
|
|
|
|
self._direction_pairs = {'l': 'r', 'u': 'd', 'r': 'l', 'd': 'u'}
|
|
|
|
self.food = None
|
|
self.grow_snake = False
|
|
|
|
def _init_game(self):
|
|
self.snake = [[int(SnakeBoard.WIDTH//2), int(SnakeBoard.HEIGHT//2)],
|
|
[int(SnakeBoard.WIDTH//2)+1, int(SnakeBoard.HEIGHT//2)]]
|
|
self.current_x_head, self.current_y_head = self.snake[0]
|
|
self.direction = 'l'
|
|
|
|
self.food = None
|
|
self.grow_snake = False
|
|
self.new_food()
|
|
|
|
def next_move(self):
|
|
self.snake_move()
|
|
self.got_food()
|
|
self.check_death()
|
|
self.update()
|
|
|
|
def snake_move(self):
|
|
if self.next_direction:
|
|
turn = self.next_direction.pop()
|
|
if self.direction != self._direction_pairs[turn]:
|
|
self.direction = turn
|
|
|
|
if self.direction == 'l':
|
|
self.current_x_head -= 1
|
|
elif self.direction == 'r':
|
|
self.current_x_head += 1
|
|
|
|
# y increases top to bottom
|
|
elif self.direction == 'u':
|
|
self.current_y_head -= 1
|
|
elif self.direction == 'd':
|
|
self.current_y_head += 1
|
|
|
|
head = (self.current_x_head, self.current_y_head)
|
|
self.snake.insert(0, head)
|
|
|
|
if not self.grow_snake:
|
|
self.snake.pop()
|
|
else:
|
|
self.new_status.emit(f'Score: {self.score}')
|
|
self.grow_snake = False
|
|
|
|
def got_food(self):
|
|
head = self.snake[0]
|
|
if self.food == head:
|
|
self.new_food()
|
|
self.grow_snake = True
|
|
self.score += 1
|
|
|
|
def new_food(self):
|
|
x = random.randint(3, SnakeBoard.WIDTH-3)
|
|
y = random.randint(3, SnakeBoard.HEIGHT-3)
|
|
|
|
while (x, y) in self.snake:
|
|
x = random.randint(3, SnakeBoard.WIDTH-3)
|
|
y = random.randint(3, SnakeBoard.HEIGHT-3)
|
|
|
|
self.food = (x, y)
|
|
|
|
def check_death(self):
|
|
rip_message = ''
|
|
is_dead = False
|
|
if (self.current_x_head < 1) or (self.current_x_head > SnakeBoard.WIDTH-2) or \
|
|
(self.current_y_head < 1) or (self.current_y_head > SnakeBoard.HEIGHT-2):
|
|
rip_message = 'Snake found wall :('
|
|
is_dead = True
|
|
|
|
head = self.snake[0]
|
|
for snake_i in self.snake[1:]:
|
|
if snake_i == head:
|
|
rip_message = 'Snake bit itself :('
|
|
is_dead = True
|
|
break
|
|
|
|
if is_dead:
|
|
self.stop(rip_message)
|
|
|
|
def keyPressEvent(self, event):
|
|
key = event.key()
|
|
if key in (QtCore.Qt.Key_Left, QtCore.Qt.Key_A):
|
|
self.next_direction.append('l')
|
|
|
|
elif key in (QtCore.Qt.Key_Right, QtCore.Qt.Key_D):
|
|
self.next_direction.append('r')
|
|
|
|
elif key in (QtCore.Qt.Key_Down, QtCore.Qt.Key_S):
|
|
self.next_direction.append('d')
|
|
|
|
elif key in (QtCore.Qt.Key_Up, QtCore.Qt.Key_W):
|
|
self.next_direction.append('u')
|
|
|
|
else:
|
|
return super().keyPressEvent(event)
|
|
|
|
def paintEvent(self, event):
|
|
painter = QtGui.QPainter(self)
|
|
|
|
rect = self.contentsRect()
|
|
boardtop = rect.bottom() - SnakeBoard.HEIGHT * self.cellheight
|
|
boardleft = rect.left()
|
|
|
|
for pos in self.snake:
|
|
self.draw_circle(painter,
|
|
int(boardleft+pos[0]*self.cellwidth),
|
|
int(boardtop+pos[1]*self.cellheight),
|
|
'blue')
|
|
if self.food is not None:
|
|
self.draw_square(painter,
|
|
int(boardleft+self.food[0]*self.cellwidth),
|
|
int(boardtop+self.food[1]*self.cellheight),
|
|
'orange')
|
|
|
|
|
|
class TetrisBoard(Board):
|
|
WIDTH = 10
|
|
HEIGHT = 20
|
|
SPEED = 300
|
|
|
|
def __init__(self, parent=None):
|
|
super().__init__(parent=parent)
|
|
|
|
self._shapes = {
|
|
1: ZShape,
|
|
2: SShape,
|
|
3: Line,
|
|
4: TShape,
|
|
5: Square,
|
|
6: MirrorL
|
|
}
|
|
|
|
self._init_game()
|
|
|
|
def _init_game(self):
|
|
self.curr_x = 0
|
|
self.curr_y = 0
|
|
self.curr_piece = None
|
|
self.board = np.zeros((TetrisBoard.WIDTH, TetrisBoard.HEIGHT + 2), dtype=int)
|
|
|
|
def next_move(self):
|
|
if self.curr_piece is None:
|
|
self.make_new_piece()
|
|
else:
|
|
self.move_down()
|
|
|
|
def try_move(self, piece, x, y):
|
|
if piece is None:
|
|
return False
|
|
|
|
if x+piece.x.min() < 0 or x+piece.x.max() >= TetrisBoard.WIDTH:
|
|
return False
|
|
|
|
if y-piece.y.max() < 0 or y-piece.y.min() >= TetrisBoard.HEIGHT+2:
|
|
return False
|
|
|
|
if np.any(self.board[piece.x+x, y-piece.y]) != 0:
|
|
return False
|
|
|
|
if piece != self.curr_piece:
|
|
self.curr_piece = piece
|
|
|
|
self.curr_x = x
|
|
self.curr_y = y
|
|
|
|
self.update()
|
|
|
|
return True
|
|
|
|
def make_new_piece(self):
|
|
new_piece = self._shapes[random.randint(1, len(self._shapes))]()
|
|
|
|
startx = TetrisBoard.WIDTH//2
|
|
starty = TetrisBoard.HEIGHT+2 - 1 + new_piece.y.min()
|
|
if not self.try_move(new_piece, startx, starty):
|
|
self.stop('Game over :(')
|
|
|
|
def move_down(self):
|
|
if not self.try_move(self.curr_piece, self.curr_x, self.curr_y-1):
|
|
self.final_destination_reached()
|
|
|
|
def drop_to_bottom(self):
|
|
new_y = self.curr_y
|
|
|
|
while new_y > 0:
|
|
if not self.try_move(self.curr_piece, self.curr_x, new_y-1):
|
|
break
|
|
new_y -= 1
|
|
|
|
self.final_destination_reached()
|
|
|
|
def final_destination_reached(self):
|
|
x = self.curr_x+self.curr_piece.x
|
|
y = self.curr_y-self.curr_piece.y
|
|
self.board[x, y] = next(k for k, v in self._shapes.items() if isinstance(self.curr_piece, v))
|
|
|
|
self.remove_lines()
|
|
|
|
self.curr_piece = None
|
|
self.make_new_piece()
|
|
|
|
def remove_lines(self):
|
|
full_rows = np.where(np.all(self.board, axis=0))[0]
|
|
num_rows = len(full_rows)
|
|
|
|
if num_rows:
|
|
temp = np.zeros_like(self.board)
|
|
temp[:, :temp.shape[1]-num_rows] = np.delete(self.board, full_rows, axis=1)
|
|
self.board = temp
|
|
|
|
self.score += num_rows
|
|
self.new_status.emit(f'Lines: {self.score}')
|
|
|
|
if self.score % 10 == 0:
|
|
self._speed += 0.9
|
|
self.timer.setInterval(int(self._speed))
|
|
|
|
self.update()
|
|
|
|
def keyPressEvent(self, event):
|
|
key = event.key()
|
|
|
|
if self.curr_piece is None:
|
|
return super().keyPressEvent(event)
|
|
|
|
if key == QtCore.Qt.Key_Left:
|
|
self.try_move(self.curr_piece, self.curr_x-1, self.curr_y)
|
|
|
|
elif key == QtCore.Qt.Key_Right:
|
|
self.try_move(self.curr_piece, self.curr_x+1, self.curr_y)
|
|
|
|
elif key == QtCore.Qt.Key_Down:
|
|
if not self.try_move(self.curr_piece.rotate(), self.curr_x, self.curr_y):
|
|
self.curr_piece.rotate(clockwise=False)
|
|
|
|
elif key == QtCore.Qt.Key_Up:
|
|
if not self.try_move(self.curr_piece.rotate(clockwise=False), self.curr_x, self.curr_y):
|
|
self.curr_piece.rotate()
|
|
|
|
elif key == QtCore.Qt.Key_Space:
|
|
self.drop_to_bottom()
|
|
|
|
else:
|
|
super().keyPressEvent(event)
|
|
|
|
def paintEvent(self, event):
|
|
painter = QtGui.QPainter(self)
|
|
rect = self.contentsRect()
|
|
board_top = rect.bottom() - TetrisBoard.HEIGHT*self.cellheight
|
|
|
|
for i in range(TetrisBoard.WIDTH):
|
|
for j in range(TetrisBoard.HEIGHT):
|
|
shape = self.board[i, j]
|
|
|
|
if shape:
|
|
color = self._shapes[shape].color
|
|
self.draw_square(painter,
|
|
rect.left() + i*self.cellwidth,
|
|
board_top + (TetrisBoard.HEIGHT-j-1)*self.cellheight, color)
|
|
|
|
if self.curr_piece is not None:
|
|
x = self.curr_x + self.curr_piece.x
|
|
y = self.curr_y - self.curr_piece.y
|
|
|
|
for i in range(4):
|
|
if TetrisBoard.HEIGHT < y[i]+1:
|
|
continue
|
|
|
|
self.draw_square(painter, rect.left() + x[i] * self.cellwidth,
|
|
board_top + (TetrisBoard.HEIGHT-y[i]-1) * self.cellheight,
|
|
self.curr_piece.color)
|
|
|
|
|
|
class Tetromino:
|
|
SHAPE = np.array([[0], [0]])
|
|
color = None
|
|
|
|
def __init__(self):
|
|
self.shape = self.SHAPE
|
|
|
|
def rotate(self, clockwise: bool = True):
|
|
if clockwise:
|
|
self.shape = np.vstack((-self.shape[1], self.shape[0]))
|
|
else:
|
|
self.shape = np.vstack((self.shape[1], -self.shape[0]))
|
|
|
|
return self
|
|
|
|
@property
|
|
def x(self):
|
|
return self.shape[0]
|
|
|
|
@property
|
|
def y(self):
|
|
return self.shape[1]
|
|
|
|
|
|
class ZShape(Tetromino):
|
|
SHAPE = np.array([[0, 0, -1, -1],
|
|
[-1, 0, 0, 1]])
|
|
color = 'green'
|
|
|
|
|
|
class SShape(Tetromino):
|
|
SHAPE = np.array([[0, 0, 1, 1],
|
|
[-1, 0, 0, 1]])
|
|
color = 'purple'
|
|
|
|
|
|
class Line(Tetromino):
|
|
SHAPE = np.array([[0, 0, 0, 0],
|
|
[-1, 0, 1, 2]])
|
|
color = 'red'
|
|
|
|
|
|
class TShape(Tetromino):
|
|
SHAPE = np.array([[-1, 0, 1, 0],
|
|
[0, 0, 0, 1]])
|
|
color = 'orange'
|
|
|
|
|
|
class Square(Tetromino):
|
|
SHAPE = np.array([[0, 1, 0, 1],
|
|
[0, 0, 1, 1]])
|
|
color = 'yellow'
|
|
|
|
|
|
class LShape(Tetromino):
|
|
SHAPE = np.array([[-1, 0, 0, 0],
|
|
[1, -1, 0, 1]])
|
|
color = 'blue'
|
|
|
|
|
|
class MirrorL(Tetromino):
|
|
SHAPE = np.array([[1, 0, 0, 0],
|
|
[-1, -1, 0, 1]])
|
|
color = 'lightGray'
|
|
|
|
|
|
class Field(QtWidgets.QToolButton):
|
|
NUM_COLORS = {
|
|
1: '#1e46a4',
|
|
2: '#f28e2b',
|
|
3: '#e15759',
|
|
4: '#76b7b2',
|
|
5: '#59a14f',
|
|
6: '#edc948',
|
|
7: '#b07aa1',
|
|
8: '#ff9da7',
|
|
'X': '#ff0000',
|
|
}
|
|
|
|
flag_change = QtCore.pyqtSignal(bool)
|
|
|
|
def __init__(self, x, y, parent=None):
|
|
super(Field, self).__init__(parent=parent)
|
|
|
|
self.setFixedSize(QtCore.QSize(30, 30))
|
|
f = self.font()
|
|
f.setPointSize(24)
|
|
f.setWeight(75)
|
|
self.setFont(f)
|
|
|
|
self.x = x
|
|
self.y = y
|
|
|
|
self.neighbors = []
|
|
self.grid = self.parent()
|
|
|
|
_size = self.grid.gridsize
|
|
for x_i in range(max(0, self.x-1), min(self.x+2, _size[0])):
|
|
for y_i in range(max(0, self.y-1), min(self.y+2, _size[1])):
|
|
if (x_i, y_i) == (self.x, self.y):
|
|
continue
|
|
self.neighbors.append((x_i, y_i))
|
|
|
|
self.is_mine = False
|
|
self.is_flagged = False
|
|
self.is_known = False
|
|
self.has_died = False
|
|
|
|
def mousePressEvent(self, evt: QtGui.QMouseEvent) -> None:
|
|
if self.grid.status == 'finished':
|
|
return
|
|
|
|
if evt.button() == QtCore.Qt.RightButton:
|
|
self.set_flag()
|
|
elif evt.button() == QtCore.Qt.LeftButton:
|
|
self.select()
|
|
else:
|
|
super().mousePressEvent(evt)
|
|
|
|
def __str__(self) -> str:
|
|
if self.is_mine:
|
|
return 'X'
|
|
else:
|
|
return str(self.visible_mines)
|
|
|
|
@property
|
|
def visible_mines(self) -> int:
|
|
return sum(self.grid.map[x_i][y_i].is_mine for x_i, y_i in self.neighbors)
|
|
|
|
@QtCore.pyqtSlot()
|
|
def select(self):
|
|
if self.is_flagged:
|
|
return
|
|
|
|
if self.is_mine:
|
|
self.setText('X')
|
|
num = 'X'
|
|
self.has_died = True
|
|
self.setStyleSheet(f'color: {self.NUM_COLORS[num]}')
|
|
else:
|
|
self.is_known = True
|
|
self.setEnabled(False)
|
|
self.setAutoRaise(True)
|
|
|
|
num = self.visible_mines
|
|
if num != 0:
|
|
self.setText(str(num))
|
|
self.setStyleSheet(f'color: {self.NUM_COLORS[num]}')
|
|
else:
|
|
self.grid.reveal_neighbors(self)
|
|
|
|
self.clicked.emit()
|
|
|
|
@QtCore.pyqtSlot()
|
|
def set_flag(self):
|
|
if self.is_flagged:
|
|
self.setText('')
|
|
else:
|
|
self.setText('!')
|
|
self.is_flagged = not self.is_flagged
|
|
self.has_died = False
|
|
|
|
self.clicked.emit()
|
|
self.flag_change.emit(self.is_flagged)
|
|
|
|
|
|
class QMines(QtWidgets.QMainWindow):
|
|
LEVELS = {
|
|
'easy': ((9, 9), 10),
|
|
'middle': ((16, 16), 40),
|
|
'hard': ((16, 30), 99),
|
|
'very hard': ((16, 30), 10),
|
|
}
|
|
|
|
def __init__(self, parent=None):
|
|
super().__init__(parent=parent)
|
|
|
|
self.map = []
|
|
|
|
self.status = 'waiting'
|
|
self.open_fields = 0
|
|
self.num_flags = 0
|
|
|
|
self._start = 0
|
|
|
|
self.gridsize, self.mines = (1, 1), 1
|
|
|
|
self._init_ui()
|
|
|
|
def _init_ui(self):
|
|
layout = QtWidgets.QGridLayout()
|
|
layout.setSpacing(0)
|
|
self.central = QtWidgets.QWidget()
|
|
self.setCentralWidget(self.central)
|
|
|
|
layout.addItem(QtWidgets.QSpacerItem(0, 0, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding),
|
|
0, 0)
|
|
|
|
self.grid_layout = QtWidgets.QGridLayout()
|
|
self.grid_layout.setSpacing(0)
|
|
self.map_widget = QtWidgets.QFrame()
|
|
self.map_widget.setFrameStyle(2)
|
|
self.map_widget.setLayout(self.grid_layout)
|
|
layout.addWidget(self.map_widget, 1, 1)
|
|
|
|
self.new_game = QtWidgets.QPushButton('New game')
|
|
self.new_game.pressed.connect(self._init_map)
|
|
layout.addWidget(self.new_game, 0, 1)
|
|
|
|
layout.addItem(QtWidgets.QSpacerItem(0, 0, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding),
|
|
2, 2)
|
|
|
|
self.central.setLayout(layout)
|
|
|
|
self.timer = QtCore.QTimer()
|
|
self.timer.setInterval(1000)
|
|
self.timer.timeout.connect(self.update_time)
|
|
|
|
self.timer_message = QtWidgets.QLabel('0 s')
|
|
self.statusBar().addWidget(self.timer_message)
|
|
|
|
self.mine_message = QtWidgets.QLabel(f'0 / {self.mines}')
|
|
self.statusBar().addWidget(self.mine_message)
|
|
|
|
self.dead_message = QtWidgets.QLabel('')
|
|
self.statusBar().addWidget(self.dead_message)
|
|
|
|
self.level_cb = QtWidgets.QComboBox()
|
|
self.level_cb.addItems(list(self.LEVELS.keys()))
|
|
self.level_cb.currentTextChanged.connect(self._init_map)
|
|
self.statusBar().addPermanentWidget(self.level_cb)
|
|
|
|
self._init_map('easy')
|
|
|
|
def _init_map(self, lvl: str = None):
|
|
if lvl is None:
|
|
lvl = self.level_cb.currentText()
|
|
|
|
self._clear_map()
|
|
|
|
self.gridsize, self.mines = QMines.LEVELS[lvl]
|
|
w, h = self.gridsize
|
|
self.map = [[None] * h for _ in range(w)]
|
|
|
|
for x in range(w):
|
|
for y in range(h):
|
|
pos = Field(x, y, parent=self)
|
|
pos.clicked.connect(self.start_game)
|
|
pos.clicked.connect(self.update_status)
|
|
pos.flag_change.connect(self.update_flag)
|
|
self.grid_layout.addWidget(pos, x+1, y+1)
|
|
self.map[x][y] = pos
|
|
|
|
self.set_mines()
|
|
|
|
def _clear_map(self):
|
|
self.status = 'waiting'
|
|
self.open_fields = 0
|
|
self.num_flags = 0
|
|
|
|
self._start = 0
|
|
|
|
self.map = []
|
|
|
|
while self.grid_layout.count():
|
|
child = self.grid_layout.takeAt(0)
|
|
w = child.widget()
|
|
if w:
|
|
self.grid_layout.removeWidget(w)
|
|
w.deleteLater()
|
|
else:
|
|
self.grid_layout.removeItem(child)
|
|
|
|
def set_mines(self):
|
|
count = 0
|
|
w, h = self.gridsize
|
|
while count < self.mines:
|
|
n = random.randint(0, w * h - 1)
|
|
row = n // h
|
|
col = n % h
|
|
pos = self.map[row][col] # type: Field
|
|
if pos.is_mine:
|
|
continue
|
|
pos.is_mine = True
|
|
count += 1
|
|
|
|
self.status = 'waiting'
|
|
self.open_fields = 0
|
|
self.num_flags = 0
|
|
self._start = 0
|
|
|
|
self.timer_message.setText('0 s')
|
|
self.mine_message.setText(f'0 / {self.mines}')
|
|
self.dead_message.setText('')
|
|
|
|
def reveal_neighbors(self, pos: Field):
|
|
for x_i, y_i in pos.neighbors:
|
|
field_i = self.map[x_i][y_i] # type: Field
|
|
if field_i.isEnabled():
|
|
field_i.select()
|
|
|
|
def start_game(self):
|
|
if self.status == 'waiting':
|
|
self.status = 'running'
|
|
self._start = time.time()
|
|
self.timer.start(1000)
|
|
|
|
def update_time(self):
|
|
if self.status == 'running':
|
|
self.timer_message.setText(f'{time.time()-self._start:3.0f} s')
|
|
|
|
def update_status(self):
|
|
if self.status == 'finished':
|
|
return
|
|
|
|
pos = self.sender() # type: Field
|
|
if pos.is_known:
|
|
self.open_fields += 1
|
|
if self.open_fields == self.gridsize[0] * self.gridsize[1] - self.mines:
|
|
self.timer.stop()
|
|
|
|
_ = QtWidgets.QMessageBox.information(self, 'Game finished', 'Game finished!!!')
|
|
self.status = 'finished'
|
|
|
|
elif pos.has_died:
|
|
dead_cnt = self.dead_message.text()
|
|
if dead_cnt == '':
|
|
self.dead_message.setText('(Deaths: 1)')
|
|
else:
|
|
self.dead_message.setText(f'(Deaths: {int(dead_cnt[9:-1])+1})')
|
|
|
|
@QtCore.pyqtSlot(bool)
|
|
def update_flag(self, state: bool):
|
|
num_mines = int(self.mine_message.text().split()[0])
|
|
if state:
|
|
num_mines += 1
|
|
else:
|
|
num_mines -= 1
|
|
|
|
self.mine_message.setText(f'{num_mines} / {self.mines}')
|
|
|