Pyqt 编写的俄罗斯方块

 

  1 #!/usr/bin/env python

  2 # -*- coding: utf-8 -*-

  3 from __future__ import print_function

  4 from __future__ import unicode_literals

  5 from __future__ import division

  6 from __future__ import absolute_import

  7 try:

  8     str = unicode

  9 except NameError:

 10     pass

 11 

 12 import random, sys, sip

 13 try:

 14     sip.setapi("QString" ,2)

 15 except ValueError:

 16     pass

 17 

 18 from PyQt4 import QtCore, QtGui

 19 

 20 

 21 NoShape, ZShape, SShape, LineShape, TShape, SquareShape, LShape, MirroredLShape = range(8)

 22 

 23 random.seed(None)

 24 

 25 

 26 class TetrixWindow(QtGui.QWidget):

 27     def __init__(self, parent = None):

 28         QtGui.QWidget.__init__(self, parent, QtCore.Qt.Window)

 29 

 30         self.board = TetrixBoard()

 31         self.indictor = TetrixIndictor()

 32 

 33         nextPieceLabel = QtGui.QLabel(self)

 34         nextPieceLabel.setFrameStyle(QtGui.QFrame.Box | QtGui.QFrame.Raised)

 35         nextPieceLabel.setAlignment(QtCore.Qt.AlignCenter)

 36         self.board.setNextPieceLabel(nextPieceLabel)

 37 

 38         scoreLcd = QtGui.QLCDNumber(6)

 39         scoreLcd.setSegmentStyle(QtGui.QLCDNumber.Filled)

 40         levelLcd = QtGui.QLCDNumber(2)

 41         levelLcd.setSegmentStyle(QtGui.QLCDNumber.Filled)

 42         linesLcd = QtGui.QLCDNumber(6)

 43         linesLcd.setSegmentStyle(QtGui.QLCDNumber.Filled)

 44 

 45         startButton = QtGui.QPushButton(self.trUtf8("开始(&S)"))

 46         startButton.setFocusPolicy(QtCore.Qt.NoFocus)

 47         quitButton = QtGui.QPushButton(self.trUtf8("退出(&X)"))

 48         quitButton.setFocusPolicy(QtCore.Qt.NoFocus)

 49         pauseButton = QtGui.QPushButton(self.trUtf8("暂停(&P)"))

 50         pauseButton.setFocusPolicy(QtCore.Qt.NoFocus)

 51 

 52         startButton.clicked.connect(self.board.start)

 53         pauseButton.clicked.connect(self.board.pause)

 54         quitButton.clicked.connect(self.close)

 55         self.board.scoreChanged.connect(scoreLcd.display)

 56         self.board.levelChanged.connect(levelLcd.display)

 57         self.board.linesRemovedChanged.connect(linesLcd.display)

 58         self.board.act.connect(self.indictor.showIndictor)

 59 

 60         layout1 = QtGui.QHBoxLayout()

 61         layout3 = QtGui.QVBoxLayout()

 62         layout3.addWidget(self.board)

 63         layout3.addWidget(self.indictor)

 64         layout3.setSpacing(0)

 65         layout1.addLayout(layout3)

 66         layout2 = QtGui.QVBoxLayout()

 67         layout2.addWidget(self.createLabel(self.trUtf8("下一个方块")))

 68         layout2.addWidget(nextPieceLabel)

 69         layout2.addWidget(self.createLabel(self.trUtf8("级别")))

 70         layout2.addWidget(levelLcd)

 71         layout2.addWidget(self.createLabel(self.trUtf8("成绩")),)

 72         layout2.addWidget(scoreLcd)

 73         layout2.addWidget(self.createLabel(self.trUtf8("总共消去行数")))

 74         layout2.addWidget(linesLcd)

 75         layout2.addWidget(startButton)

 76         layout2.addWidget(quitButton)

 77         layout2.addWidget(pauseButton)

 78         layout1.addLayout(layout2)

 79         layout1.setStretch(0, 75)

 80         layout1.setStretch(1, 25)

 81         self.setLayout(layout1)

 82 

 83         self.setWindowTitle(self.trUtf8("俄罗斯方块(Tetrix)"))

 84         self.resize(self.logicalDpiX() / 96 * 275, self.logicalDpiY() / 96 * 380)

 85 

 86         r = self.geometry()

 87         r.moveCenter(QtGui.qApp.desktop().screenGeometry().center())

 88         self.setGeometry(r)

 89 

 90     def createLabel(self, text):

 91         lbl = QtGui.QLabel(text)

 92         lbl.setAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignBottom)

 93         return lbl

 94 

 95 

 96 class TetrixIndictor(QtGui.QWidget):

 97     """位于主游戏区下方的一个扁小的控件，用于显示当前位置落下时的位置。

 98     现在主要的问题是游戏区的大小超出了人类的眼睛的焦点区。

 99     或许可以让整个游戏界面更小一些。"""

100 

101     def __init__(self, parent = None):

102         QtGui.QWidget.__init__(self, parent)

103         self.begin = self.end = None

104         self.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Fixed)

105 

106     def showIndictor(self, curX, piece):

107         self.begin = curX + piece.minX()

108         self.end = curX + piece.maxX()

109         self.update()

110 

111     def paintEvent(self, event):

112         QtGui.QWidget.paintEvent(self, event)

113         if self.begin is None:

114             return

115         board = self.parent().board

116         pieceWidth = board.contentsRect().width() // TetrixBoard.BoardWidth

117         brush = QtGui.QBrush(QtCore.Qt.yellow)

118         painter = QtGui.QPainter(self)

119         painter.setBrush(brush)

120         painter.drawRect(board.contentsRect().left() + self.begin * pieceWidth, 0, \

121                          (self.end - self.begin + 1) * pieceWidth, self.height() - 1 )

122 

123     def sizeHint(self):

124         return QtCore.QSize(self.parent().board.width(), 8)

125 

126 

127 class TetrixBoard(QtGui.QFrame):

128     BoardWidth = 11

129     BoardHeight = 22

130 

131     scoreChanged = QtCore.pyqtSignal(int)

132     levelChanged = QtCore.pyqtSignal(int)

133     linesRemovedChanged = QtCore.pyqtSignal(int)

134     act = QtCore.pyqtSignal(int, "PyQt_PyObject")

135 

136     def __init__(self, parent = None):

137         super(TetrixBoard, self).__init__(parent)

138         self.setStyleSheet("background-color:black;border:2px solid darkGreen;")

139 

140         self.timer = QtCore.QBasicTimer()

141         self.nextPieceLabel = None

142         self.isWaitingAfterLine = False

143         self.curPiece = TetrixPiece()

144         self.nextPiece = TetrixPiece()

145         self.curX = 0

146         self.curY = 0

147         self.numLinesRemoved = 0

148         self.numPiecesDropped = 0

149         self.score = 0

150         self.level = 0

151         self.board = None

152 

153         #self.setFrameStyle(QtGui.QFrame.Panel | QtGui.QFrame.Sunken)

154         self.setFrameStyle(QtGui.QFrame.Box)

155         self.setFocusPolicy(QtCore.Qt.StrongFocus)

156         self.isStarted = False

157         self.isPaused = False

158         self.clearBoard()

159 

160         self.nextPiece.setRandomShape()

161 

162     def focusOutEvent(self, event):

163         if self.isStarted and not self.isPaused:

164             self.pause()

165         QtGui.QFrame.focusOutEvent(self, event)

166 

167     def shapeAt(self, x, y):

168         return self.board[(y * TetrixBoard.BoardWidth) + x]

169 

170     def setShapeAt(self, x, y, shape):

171         self.board[(y * TetrixBoard.BoardWidth) + x] = shape

172 

173     def timeoutTime(self):

174         return 1000 // (1 + self.level)

175 

176     def squareWidth(self):

177         return self.contentsRect().width() // TetrixBoard.BoardWidth

178 

179     def squareHeight(self):

180         return self.contentsRect().height() // TetrixBoard.BoardHeight

181 

182     def setNextPieceLabel(self, label):

183         self.nextPieceLabel = label

184         #label.setScaledContents(True)

185         label.setMinimumSize(label.width(), label.width())

186 

187     def sizeHint(self):

188         return QtCore.QSize(TetrixBoard.BoardWidth * 15 + self.frameWidth() * 2,

189                 TetrixBoard.BoardHeight * 15 + self.frameWidth() * 2)

190 

191     def minimumSizeHint(self):

192         return QtCore.QSize(TetrixBoard.BoardWidth * 15 + self.frameWidth() * 2,

193                 TetrixBoard.BoardHeight * 15 + self.frameWidth() * 2)

194 

195     def start(self):

196         if self.isPaused:

197             return

198 

199         self.isStarted = True

200         self.isWaitingAfterLine = False

201         self.numLinesRemoved = 0

202         self.numPiecesDropped = 0

203         self.score = 0

204         self.level = 1

205         self.clearBoard()

206 

207         self.linesRemovedChanged.emit(self.numLinesRemoved)

208         self.scoreChanged.emit(self.score)

209         self.levelChanged.emit(self.level)

210 

211         self.newPiece()

212         self.timer.start(self.timeoutTime(), self)

213 

214     def pause(self):

215         if not self.isStarted:

216             return

217 

218         self.isPaused = not self.isPaused

219         if self.isPaused:

220             self.timer.stop()

221         else:

222             self.timer.start(self.timeoutTime(), self)

223 

224         self.update()

225 

226     def paintEvent(self, event):

227         super(TetrixBoard, self).paintEvent(event)

228 

229         painter = QtGui.QPainter(self)

230         rect = self.contentsRect()

231 

232         if self.isPaused:

233             painter.drawText(rect, QtCore.Qt.AlignCenter, self.trUtf8("暂停"))

234             return

235 

236         boardTop = rect.bottom() - TetrixBoard.BoardHeight * self.squareHeight()

237 

238         for i in range(TetrixBoard.BoardHeight):

239             for j in range(TetrixBoard.BoardWidth):

240                 shape = self.shapeAt(j, TetrixBoard.BoardHeight - i - 1)

241                 if shape != NoShape:

242                     self.drawSquare(painter,

243                             rect.left() + j * self.squareWidth(),

244                             boardTop + i * self.squareHeight(), shape)

245 

246         if self.curPiece.shape() != NoShape:

247             for i in range(4):

248                 x = self.curX + self.curPiece.x(i)

249                 y = self.curY - self.curPiece.y(i)

250                 self.drawSquare(painter, rect.left() + x * self.squareWidth(),

251                         boardTop + (TetrixBoard.BoardHeight - y - 1) * self.squareHeight(),

252                         self.curPiece.shape())

253 

254     def keyPressEvent(self, event):

255         if not self.isStarted or self.isPaused or self.curPiece.shape() == NoShape:

256             super(TetrixBoard, self).keyPressEvent(event)

257             return

258 

259         key = event.key()

260         if key == QtCore.Qt.Key_Left:

261             self.tryMove(self.curPiece, self.curX - 1, self.curY)

262         elif key == QtCore.Qt.Key_Right:

263             self.tryMove(self.curPiece, self.curX + 1, self.curY)

264         elif key == QtCore.Qt.Key_Down:

265             self.tryMove(self.curPiece.rotatedRight(), self.curX, self.curY)

266         elif key == QtCore.Qt.Key_Up:

267             self.tryMove(self.curPiece.rotatedLeft(), self.curX, self.curY)

268         elif key == QtCore.Qt.Key_Space:

269             self.dropDown()

270         elif key == QtCore.Qt.Key_D:

271             self.oneLineDown()

272         else:

273             super(TetrixBoard, self).keyPressEvent(event)

274 

275     def timerEvent(self, event):

276         if event.timerId() == self.timer.timerId():

277             if self.isWaitingAfterLine:

278                 self.isWaitingAfterLine = False

279                 self.newPiece()

280                 self.timer.start(self.timeoutTime(), self)

281             else:

282                 self.oneLineDown()

283         else:

284             super(TetrixBoard, self).timerEvent(event)

285 

286     def clearBoard(self):

287         self.board = [NoShape for i in range(TetrixBoard.BoardHeight * TetrixBoard.BoardWidth)]

288 

289     def dropDown(self):

290         dropHeight = 0

291         newY = self.curY

292         while newY > 0:

293             if not self.tryMove(self.curPiece, self.curX, newY - 1):

294                 break

295             newY -= 1

296             dropHeight += 1

297 

298         self.pieceDropped(dropHeight)

299 

300     def oneLineDown(self):

301         if not self.tryMove(self.curPiece, self.curX, self.curY - 1):

302             self.pieceDropped(0)

303 

304     def pieceDropped(self, dropHeight):

305         for i in range(4):

306             x = self.curX + self.curPiece.x(i)

307             y = self.curY - self.curPiece.y(i)

308             self.setShapeAt(x, y, self.curPiece.shape())

309 

310         self.numPiecesDropped += 1

311         if self.numPiecesDropped % 25 == 0:

312             self.level += 1

313             self.timer.start(self.timeoutTime(), self)

314             self.levelChanged.emit(self.level)

315 

316         self.score += dropHeight + 7

317         self.scoreChanged.emit(self.score)

318         self.removeFullLines()

319 

320         if not self.isWaitingAfterLine:

321             self.newPiece()

322 

323     def removeFullLines(self):

324         numFullLines = 0

325 

326         for i in range(TetrixBoard.BoardHeight - 1, -1, -1):

327             lineIsFull = True

328 

329             for j in range(TetrixBoard.BoardWidth):

330                 if self.shapeAt(j, i) == NoShape:

331                     lineIsFull = False

332                     break

333 

334             if lineIsFull:

335                 numFullLines += 1

336                 for k in range(i, TetrixBoard.BoardHeight - 1):

337                     for j in range(TetrixBoard.BoardWidth):

338                         self.setShapeAt(j, k, self.shapeAt(j, k + 1))

339 

340                 for j in range(TetrixBoard.BoardWidth):

341                     self.setShapeAt(j, TetrixBoard.BoardHeight - 1, NoShape)

342 

343         if numFullLines > 0:

344             self.numLinesRemoved += numFullLines

345             self.score += 10 * numFullLines

346             self.linesRemovedChanged.emit(self.numLinesRemoved)

347             self.scoreChanged.emit(self.score)

348 

349             self.timer.start(200, self)

350             self.isWaitingAfterLine = True

351             self.curPiece.setShape(NoShape)

352             self.update()

353 

354     def newPiece(self):

355         self.curPiece = self.nextPiece

356         self.nextPiece = TetrixPiece()

357         self.nextPiece.setRandomShape()

358         self.showNextPiece()

359         self.curX = TetrixBoard.BoardWidth // 2

360         self.curY = TetrixBoard.BoardHeight - 1 + self.curPiece.minY()

361         self.act.emit(self.curX, self.curPiece)

362 

363         if not self.tryMove(self.curPiece, self.curX, self.curY):

364             self.curPiece.setShape(NoShape)

365             self.timer.stop()

366             self.isStarted = False

367 

368     def showNextPiece(self):

369         if self.nextPieceLabel is None:

370             return

371 

372         dx = self.nextPiece.maxX() - self.nextPiece.minX() + 1

373         dy = self.nextPiece.maxY() - self.nextPiece.minY() + 1

374 

375         self.pixmapNextPiece = QtGui.QPixmap(dx * self.squareWidth(), dy * self.squareHeight())

376         painter = QtGui.QPainter(self.pixmapNextPiece)

377         painter.fillRect(self.pixmapNextPiece.rect(), self.nextPieceLabel.palette().background())

378 

379         for i in range(4):

380             x = self.nextPiece.x(i) - self.nextPiece.minX()

381             y = self.nextPiece.y(i) - self.nextPiece.minY()

382             self.drawSquare(painter, x * self.squareWidth(),

383                     y * self.squareHeight(), self.nextPiece.shape())

384 

385         self.nextPieceLabel.setPixmap(self.pixmapNextPiece)

386 

387     def tryMove(self, newPiece, newX, newY):

388         for i in range(4):

389             x = newX + newPiece.x(i)

390             y = newY - newPiece.y(i)

391             if x < 0 or x >= TetrixBoard.BoardWidth or y < 0 or y >= TetrixBoard.BoardHeight:

392                 return False

393             if self.shapeAt(x, y) != NoShape:

394                 return False

395 

396         self.curPiece = newPiece

397         self.curX = newX

398         self.curY = newY

399         self.update()

400         self.act.emit(self.curX, self.curPiece)

401         return True

402 

403     def drawSquare(self, painter, x, y, shape):

404         colorTable = [0x000000, 0xCC6666, 0x66CC66, 0x6666CC,

405                       0xCCCC66, 0xCC66CC, 0x66CCCC, 0xDAAA00]

406 

407         color = QtGui.QColor(colorTable[shape])

408         painter.fillRect(x + 1, y + 1, self.squareWidth() - 2,

409                 self.squareHeight() - 2, color)

410 

411         painter.setPen(color.light())

412         painter.drawLine(x, y + self.squareHeight() - 1, x, y)

413         painter.drawLine(x, y, x + self.squareWidth() - 1, y)

414 

415         painter.setPen(color.dark())

416         painter.drawLine(x + 1, y + self.squareHeight() - 1,

417                 x + self.squareWidth() - 1, y + self.squareHeight() - 1)

418         painter.drawLine(x + self.squareWidth() - 1,

419                 y + self.squareHeight() - 1, x + self.squareWidth() - 1, y + 1)

420 

421 

422 class TetrixPiece(object):

423     coordsTable = (

424         ((0, 0),     (0, 0),     (0, 0),     (0, 0)),

425         ((0, -1),    (0, 0),     ( - 1, 0),    ( - 1, 1)),

426         ((0, -1),    (0, 0),     (1, 0),     (1, 1)),

427         ((0, -1),    (0, 0),     (0, 1),     (0, 2)),

428         (( - 1, 0),    (0, 0),     (1, 0),     (0, 1)),

429         ((0, 0),     (1, 0),     (0, 1),     (1, 1)),

430         (( - 1, -1),   (0, -1),    (0, 0),     (0, 1)),

431         ((1, -1),    (0, -1),    (0, 0),     (0, 1))

432     )

433 

434     def __init__(self):

435         self.coords = [[0,0] for _ in range(4)]

436         self.pieceShape = NoShape

437 

438         self.setShape(NoShape)

439 

440     def shape(self):

441         return self.pieceShape

442 

443     def setShape(self, shape):

444         table = TetrixPiece.coordsTable[shape]

445         for i in range(4):

446             for j in range(2):

447                 self.coords[i][j] = table[i][j]

448 

449         self.pieceShape = shape

450 

451     def setRandomShape(self):

452         self.setShape(random.randint(1, 7))

453 

454     def x(self, index):

455         return self.coords[index][0]

456 

457     def y(self, index):

458         return self.coords[index][1]

459 

460     def setX(self, index, x):

461         self.coords[index][0] = x

462 

463     def setY(self, index, y):

464         self.coords[index][1] = y

465 

466     def minX(self):

467         m = self.coords[0][0]

468         for i in range(4):

469             m = min(m, self.coords[i][0])

470 

471         return m

472 

473     def maxX(self):

474         m = self.coords[0][0]

475         for i in range(4):

476             m = max(m, self.coords[i][0])

477 

478         return m

479 

480     def minY(self):

481         m = self.coords[0][1]

482         for i in range(4):

483             m = min(m, self.coords[i][1])

484 

485         return m

486 

487     def maxY(self):

488         m = self.coords[0][1]

489         for i in range(4):

490             m = max(m, self.coords[i][1])

491 

492         return m

493 

494     def rotatedLeft(self):

495         if self.pieceShape == SquareShape:

496             return self

497 

498         result = TetrixPiece()

499         result.pieceShape = self.pieceShape

500         for i in range(4):

501             result.setX(i, self.y(i))

502             result.setY(i, -self.x(i))

503 

504         return result

505 

506     def rotatedRight(self):

507         if self.pieceShape == SquareShape:

508             return self

509 

510         result = TetrixPiece()

511         result.pieceShape = self.pieceShape

512         for i in range(4):

513             result.setX(i, -self.y(i))

514             result.setY(i, self.x(i))

515 

516         return result

517 

518 if __name__ == '__main__':

519     app = QtGui.QApplication(sys.argv)

520     window = TetrixWindow()

521     window.show()

522     if hasattr(app, "exec"):

523         result = getattr(app, "exec")()

524     else:

525         result = getattr(app, "exec_")()

526     sys.exit(result)