用python+PYQT4写的一个俄罗斯方块游戏------申精！

life-boy

1. #!/usr/bin/python  
   
2. # tetris.py  
   
3. import sys  
   
4. import random  
   
5. from PyQt4 import QtCore, QtGui  
   
6. class Tetris(QtGui.QMainWindow):  
   
7.     def __init__(self):  
   
8.         QtGui.QMainWindow.__init__(self)  
   
9.         self.setGeometry(300, 300, 180, 380)  
   
10.         self.setWindowTitle('Tetris')  
    
11.         self.tetrisboard = Board(self)  
    
12.         self.setCentralWidget(self.tetrisboard)  
    
13.         self.statusbar = self.statusBar()  
    
14.         self.connect(self.tetrisboard, QtCore.SIGNAL("messageToStatusbar(QString)"),  
    
15.             self.statusbar, QtCore.SLOT("showMessage(QString)"))  
    
16.         self.tetrisboard.start()  
    
17.         self.center()  
    
18.     def center(self):  
    
19.         screen = QtGui.QDesktopWidget().screenGeometry()  
    
20.         size =  self.geometry()  
    
21.         self.move((screen.width()-size.width())/2,  
    
22.             (screen.height()-size.height())/2)  
    
23. class Board(QtGui.QFrame):  
    
24.     BoardWidth = 10  
    
25.     BoardHeight = 22  
    
26.     Speed = 300  
    
27.     def __init__(self, parent):  
    
28.         QtGui.QFrame.__init__(self, parent)  
    
29.         self.timer = QtCore.QBasicTimer()  
    
30.         self.isWaitingAfterLine = False  
    
31.         self.curPiece = Shape()  
    
32.         self.nextPiece = Shape()  
    
33.         self.curX = 0  
    
34.         self.curY = 0  
    
35.         self.numLinesRemoved = 0  
    
36.         self.board = []  
    
37.         self.setFocusPolicy(QtCore.Qt.StrongFocus)  
    
38.         self.isStarted = False  
    
39.         self.isPaused = False  
    
40.         self.clearBoard()  
    
41.         self.nextPiece.setRandomShape()  
    
42.     def shapeAt(self, x, y):  
    
43.         return self.board[(y * Board.BoardWidth) + x]  
    
44.     def setShapeAt(self, x, y, shape):  
    
45.         self.board[(y * Board.BoardWidth) + x] = shape  
    
46.     def squareWidth(self):  
    
47.         return self.contentsRect().width() / Board.BoardWidth  
    
48.     def squareHeight(self):  
    
49.         return self.contentsRect().height() / Board.BoardHeight  
    
50.     def start(self):  
    
51.         if self.isPaused:  
    
52.             return  
    
53.         self.isStarted = True  
    
54.         self.isWaitingAfterLine = False  
    
55.         self.numLinesRemoved = 0  
    
56.         self.clearBoard()  
    
57.         self.emit(QtCore.SIGNAL("messageToStatusbar(QString)"),  
    
58.             str(self.numLinesRemoved))  
    
59.         self.newPiece()  
    
60.         self.timer.start(Board.Speed, self)  
    
61.     def pause(self):  
    
62.         if not self.isStarted:  
    
63.             return  
    
64.         self.isPaused = not self.isPaused  
    
65.         if self.isPaused:  
    
66.             self.timer.stop()  
    
67.             self.emit(QtCore.SIGNAL("messageToStatusbar(QString)"), "paused")  
    
68.         else:  
    
69.             self.timer.start(Board.Speed, self)  
    
70.             self.emit(QtCore.SIGNAL("messageToStatusbar(QString)"),  
    
71.                 str(self.numLinesRemoved))  
    
72.         self.update()  
    
73.     def paintEvent(self, event):  
    
74.         painter = QtGui.QPainter(self)  
    
75.         rect = self.contentsRect()  
    
76.         boardTop = rect.bottom() - Board.BoardHeight * self.squareHeight()  
    
77.         for i in range(Board.BoardHeight):  
    
78.             for j in range(Board.BoardWidth):  
    
79.                 shape = self.shapeAt(j, Board.BoardHeight - i - 1)  
    
80.                 if shape != Tetrominoes.NoShape:  
    
81.                     self.drawSquare(painter,  
    
82.                         rect.left() + j * self.squareWidth(),  
    
83.                         boardTop + i * self.squareHeight(), shape)  
    
84.         if self.curPiece.shape() != Tetrominoes.NoShape:  
    
85.             for i in range(4):  
    
86.                 x = self.curX + self.curPiece.x(i)  
    
87.                 y = self.curY - self.curPiece.y(i)  
    
88.                 self.drawSquare(painter, rect.left() + x * self.squareWidth(),  
    
89.                     boardTop + (Board.BoardHeight - y - 1) * self.squareHeight(),  
    
90.                     self.curPiece.shape())  
    
91.     def keyPressEvent(self, event):  
    
92.         if not self.isStarted or self.curPiece.shape() == Tetrominoes.NoShape:  
    
93.             QtGui.QWidget.keyPressEvent(self, event)  
    
94.             return  
    
95.         key = event.key()  
    
96.         if key == QtCore.Qt.Key_P:  
    
97.             self.pause()  
    
98.             return  
    
99.         if self.isPaused:  
    
100.             return  
     
101.         elif key == QtCore.Qt.Key_Left:  
     
102.             self.tryMove(self.curPiece, self.curX - 1, self.curY)  
     
103.         elif key == QtCore.Qt.Key_Right:  
     
104.             self.tryMove(self.curPiece, self.curX + 1, self.curY)  
     
105.         elif key == QtCore.Qt.Key_Down:  
     
106.             self.tryMove(self.curPiece.rotatedRight(), self.curX, self.curY)  
     
107.         elif key == QtCore.Qt.Key_Up:  
     
108.             self.tryMove(self.curPiece.rotatedLeft(), self.curX, self.curY)  
     
109.         elif key == QtCore.Qt.Key_Space:  
     
110.             self.dropDown()  
     
111.         elif key == QtCore.Qt.Key_D:  
     
112.             self.oneLineDown()  
     
113.         else:  
     
114.             QtGui.QWidget.keyPressEvent(self, event)  
     
115.     def timerEvent(self, event):  
     
116.         if event.timerId() == self.timer.timerId():  
     
117.             if self.isWaitingAfterLine:  
     
118.                 self.isWaitingAfterLine = False  
     
119.                 self.newPiece()  
     
120.             else:  
     
121.                 self.oneLineDown()  
     
122.         else:  
     
123.             QtGui.QFrame.timerEvent(self, event)  
     
124.     def clearBoard(self):  
     
125.         for i in range(Board.BoardHeight * Board.BoardWidth):  
     
126.             self.board.append(Tetrominoes.NoShape)  
     
127.     def dropDown(self):  
     
128.         newY = self.curY  
     
129.         while newY > 0:  
     
130.             if not self.tryMove(self.curPiece, self.curX, newY - 1):  
     
131.                 break  
     
132.             newY -= 1  
     
133.         self.pieceDropped()  
     
134.     def oneLineDown(self):  
     
135.         if not self.tryMove(self.curPiece, self.curX, self.curY - 1):  
     
136.             self.pieceDropped()  
     
137.     def pieceDropped(self):  
     
138.         for i in range(4):  
     
139.             x = self.curX + self.curPiece.x(i)  
     
140.             y = self.curY - self.curPiece.y(i)  
     
141.             self.setShapeAt(x, y, self.curPiece.shape())  
     
142.         self.removeFullLines()  
     
143.         if not self.isWaitingAfterLine:  
     
144.             self.newPiece()  
     
145.     def removeFullLines(self):  
     
146.         numFullLines = 0  
     
147.         rowsToRemove = []  
     
148.         for i in range(Board.BoardHeight):  
     
149.             n = 0  
     
150.             for j in range(Board.BoardWidth):  
     
151.                 if not self.shapeAt(j, i) == Tetrominoes.NoShape:  
     
152.                     n = n + 1  
     
153.             if n == 10:  
     
154.                 rowsToRemove.append(i)  
     
155.         rowsToRemove.reverse()  
     
156.         for m in rowsToRemove:  
     
157.             for k in range(m, Board.BoardHeight):  
     
158.                 for l in range(Board.BoardWidth):  
     
159.                     self.setShapeAt(l, k, self.shapeAt(l, k + 1))  
     
160.         numFullLines = numFullLines + len(rowsToRemove)  
     
161.         if numFullLines > 0:  
     
162.             self.numLinesRemoved = self.numLinesRemoved + numFullLines  
     
163.             self.emit(QtCore.SIGNAL("messageToStatusbar(QString)"),  
     
164.                 str(self.numLinesRemoved))  
     
165.             self.isWaitingAfterLine = True  
     
166.             self.curPiece.setShape(Tetrominoes.NoShape)  
     
167.             self.update()  
     
168.     def newPiece(self):  
     
169.         self.curPiece = self.nextPiece  
     
170.         self.nextPiece.setRandomShape()  
     
171.         self.curX = Board.BoardWidth / 2 + 1  
     
172.         self.curY = Board.BoardHeight - 1 + self.curPiece.minY()  
     
173.         if not self.tryMove(self.curPiece, self.curX, self.curY):  
     
174.             self.curPiece.setShape(Tetrominoes.NoShape)  
     
175.             self.timer.stop()  
     
176.             self.isStarted = False  
     
177.             self.emit(QtCore.SIGNAL("messageToStatusbar(QString)"), "Game over")  
     
178.     def tryMove(self, newPiece, newX, newY):  
     
179.         for i in range(4):  
     
180.             x = newX + newPiece.x(i)  
     
181.             y = newY - newPiece.y(i)  
     
182.             if x < 0 or x >= Board.BoardWidth or y < 0 or y >= Board.BoardHeight:  
     
183.                 return False  
     
184.             if self.shapeAt(x, y) != Tetrominoes.NoShape:  
     
185.                 return False  
     
186.         self.curPiece = newPiece  
     
187.         self.curX = newX  
     
188.         self.curY = newY  
     
189.         self.update()  
     
190.         return True  
     
191.     def drawSquare(self, painter, x, y, shape):  
     
192.         colorTable = [0x000000, 0xCC6666, 0x66CC66, 0x6666CC,  
     
193.                       0xCCCC66, 0xCC66CC, 0x66CCCC, 0xDAAA00]  
     
194.         color = QtGui.QColor(colorTable[shape])  
     
195.         painter.fillRect(x + 1, y + 1, self.squareWidth() - 2,  
     
196.             self.squareHeight() - 2, color)  
     
197.         painter.setPen(color.light())  
     
198.         painter.drawLine(x, y + self.squareHeight() - 1, x, y)  
     
199.         painter.drawLine(x, y, x + self.squareWidth() - 1, y)  
     
200.         painter.setPen(color.dark())  
     
201.         painter.drawLine(x + 1, y + self.squareHeight() - 1,  
     
202.             x + self.squareWidth() - 1, y + self.squareHeight() - 1)  
     
203.         painter.drawLine(x + self.squareWidth() - 1,  
     
204.             y + self.squareHeight() - 1, x + self.squareWidth() - 1, y + 1)  
     
205. class Tetrominoes(object):  
     
206.     NoShape = 0  
     
207.     ZShape = 1  
     
208.     SShape = 2  
     
209.     LineShape = 3  
     
210.     TShape = 4  
     
211.     SquareShape = 5  
     
212.     LShape = 6  
     
213.     MirroredLShape = 7  
     
214. class Shape(object):  
     
215.     coordsTable = (  
     
216.         ((0, 0),     (0, 0),     (0, 0),     (0, 0)),  
     
217.         ((0, -1),    (0, 0),     (-1, 0),    (-1, 1)),  
     
218.         ((0, -1),    (0, 0),     (1, 0),     (1, 1)),  
     
219.         ((0, -1),    (0, 0),     (0, 1),     (0, 2)),  
     
220.         ((-1, 0),    (0, 0),     (1, 0),     (0, 1)),  
     
221.         ((0, 0),     (1, 0),     (0, 1),     (1, 1)),  
     
222.         ((-1, -1),   (0, -1),    (0, 0),     (0, 1)),  
     
223.         ((1, -1),    (0, -1),    (0, 0),     (0, 1))  
     
224.     )  
     
225.     def __init__(self):  
     
226.         self.coords = [[0,0] for i in range(4)]  
     
227.         self.pieceShape = Tetrominoes.NoShape  
     
228.         self.setShape(Tetrominoes.NoShape)  
     
229.     def shape(self):  
     
230.         return self.pieceShape  
     
231.     def setShape(self, shape):  
     
232.         table = Shape.coordsTable[shape]  
     
233.         for i in range(4):  
     
234.             for j in range(2):  
     
235.                 self.coords[i][j] = table[i][j]  
     
236.         self.pieceShape = shape  
     
237.     def setRandomShape(self):  
     
238.         self.setShape(random.randint(1, 7))  
     
239.     def x(self, index):  
     
240.         return self.coords[index][0]  
     
241.     def y(self, index):  
     
242.         return self.coords[index][1]  
     
243.     def setX(self, index, x):  
     
244.         self.coords[index][0] = x  
     
245.     def setY(self, index, y):  
     
246.         self.coords[index][1] = y  
     
247.     def minX(self):  
     
248.         m = self.coords[0][0]  
     
249.         for i in range(4):  
     
250.             m = min(m, self.coords[i][0])  
     
251.         return m  
     
252.     def maxX(self):  
     
253.         m = self.coords[0][0]  
     
254.         for i in range(4):  
     
255.             m = max(m, self.coords[i][0])  
     
256.         return m  
     
257.     def minY(self):  
     
258.         m = self.coords[0][1]  
     
259.         for i in range(4):  
     
260.             m = min(m, self.coords[i][1])  
     
261.         return m  
     
262.     def maxY(self):  
     
263.         m = self.coords[0][1]  
     
264.         for i in range(4):  
     
265.             m = max(m, self.coords[i][1])  
     
266.         return m  
     
267.     def rotatedLeft(self):  
     
268.         if self.pieceShape == Tetrominoes.SquareShape:  
     
269.             return self  
     
270.         result = Shape()  
     
271.         result.pieceShape = self.pieceShape  
     
272.         for i in range(4):  
     
273.             result.setX(i, self.y(i))  
     
274.             result.setY(i, -self.x(i))  
     
275.         return result  
     
276.     def rotatedRight(self):  
     
277.         if self.pieceShape == Tetrominoes.SquareShape:  
     
278.             return self  
     
279.         result = Shape()  
     
280.         result.pieceShape = self.pieceShape  
     
281.         for i in range(4):  
     
282.             result.setX(i, -self.y(i))  
     
283.             result.setY(i, self.x(i))  
     
284.         return result  
     
285. app = QtGui.QApplication(sys.argv)  
     
286. tetris = Tetris()  
     
287. tetris.show()  
     
288. sys.exit(app.exec_())  

复制代码

iamlike

赞的

ACMost

赞一个……

a515200

最好附上你这个版本的pyqt的安装文件,以及其他一些第三方库

caoyu1099

正在学习python，赞

Kabie

改的太少了……

1. #!/usr/bin/env python
   
2. 
   
3. 
   
4. #############################################################################
   
5. ##
   
6. ## Copyright (C) 2010 Riverbank Computing Limited.
   
7. ## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
   
8. ## All rights reserved.
   
9. ##
   
10. ## This file is part of the examples of PyQt.
    
11. ##
    
12. ## $QT_BEGIN_LICENSE:BSD$
    
13. ## You may use this file under the terms of the BSD license as follows:
    
14. ##
    
15. ## "Redistribution and use in source and binary forms, with or without
    
16. ## modification, are permitted provided that the following conditions are
    
17. ## met:
    
18. ##   * Redistributions of source code must retain the above copyright
    
19. ##     notice, this list of conditions and the following disclaimer.
    
20. ##   * Redistributions in binary form must reproduce the above copyright
    
21. ##     notice, this list of conditions and the following disclaimer in
    
22. ##     the documentation and/or other materials provided with the
    
23. ##     distribution.
    
24. ##   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
    
25. ##     the names of its contributors may be used to endorse or promote
    
26. ##     products derived from this software without specific prior written
    
27. ##     permission.
    
28. ##
    
29. ## THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    
30. ## "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    
31. ## LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    
32. ## A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    
33. ## OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    
34. ## SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    
35. ## LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    
36. ## DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    
37. ## THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    
38. ## (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    
39. ## OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
    
40. ## $QT_END_LICENSE$
    
41. ##
    
42. #############################################################################
    
43. 
    
44. 
    
45. import random
    
46. 
    
47. from PyQt4 import QtCore, QtGui
    
48. 
    
49. 
    
50. NoShape, ZShape, SShape, LineShape, TShape, SquareShape, LShape, MirroredLShape = range(8)
    
51. 
    
52. 
    
53. class TetrixWindow(QtGui.QWidget):
    
54.     def __init__(self):
    
55.         super(TetrixWindow, self).__init__()
    
56. 
    
57.         self.board = TetrixBoard()
    
58. 
    
59.         nextPieceLabel = QtGui.QLabel()
    
60.         nextPieceLabel.setFrameStyle(QtGui.QFrame.Box | QtGui.QFrame.Raised)
    
61.         nextPieceLabel.setAlignment(QtCore.Qt.AlignCenter)
    
62.         self.board.setNextPieceLabel(nextPieceLabel)
    
63. 
    
64.         scoreLcd = QtGui.QLCDNumber(5)
    
65.         scoreLcd.setSegmentStyle(QtGui.QLCDNumber.Filled)
    
66.         levelLcd = QtGui.QLCDNumber(2)
    
67.         levelLcd.setSegmentStyle(QtGui.QLCDNumber.Filled)
    
68.         linesLcd = QtGui.QLCDNumber(5)
    
69.         linesLcd.setSegmentStyle(QtGui.QLCDNumber.Filled)
    
70. 
    
71.         startButton = QtGui.QPushButton("&Start")
    
72.         startButton.setFocusPolicy(QtCore.Qt.NoFocus)
    
73.         quitButton = QtGui.QPushButton("&Quit")
    
74.         quitButton.setFocusPolicy(QtCore.Qt.NoFocus)
    
75.         pauseButton = QtGui.QPushButton("&Pause")
    
76.         pauseButton.setFocusPolicy(QtCore.Qt.NoFocus)
    
77. 
    
78.         startButton.clicked.connect(self.board.start)
    
79.         pauseButton.clicked.connect(self.board.pause)
    
80.         quitButton.clicked.connect(QtGui.qApp.quit)
    
81.         self.board.scoreChanged.connect(scoreLcd.display)
    
82.         self.board.levelChanged.connect(levelLcd.display)
    
83.         self.board.linesRemovedChanged.connect(linesLcd.display)
    
84. 
    
85.         layout = QtGui.QGridLayout()
    
86.         layout.addWidget(self.createLabel("NEXT"), 0, 0)
    
87.         layout.addWidget(nextPieceLabel, 1, 0)
    
88.         layout.addWidget(self.createLabel("LEVEL"), 2, 0)
    
89.         layout.addWidget(levelLcd, 3, 0)
    
90.         layout.addWidget(startButton, 4, 0)
    
91.         layout.addWidget(self.board, 0, 1, 6, 1)
    
92.         layout.addWidget(self.createLabel("SCORE"), 0, 2)
    
93.         layout.addWidget(scoreLcd, 1, 2)
    
94.         layout.addWidget(self.createLabel("LINES REMOVED"), 2, 2)
    
95.         layout.addWidget(linesLcd, 3, 2)
    
96.         layout.addWidget(quitButton, 4, 2)
    
97.         layout.addWidget(pauseButton, 5, 2)
    
98.         self.setLayout(layout)
    
99. 
    
100.         self.setWindowTitle("Tetrix")
     
101.         self.resize(550, 370)
     
102. 
     
103.     def createLabel(self, text):
     
104.         lbl = QtGui.QLabel(text)
     
105.         lbl.setAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignBottom)
     
106.         return lbl
     
107. 
     
108. 
     
109. class TetrixBoard(QtGui.QFrame):
     
110.     BoardWidth = 10
     
111.     BoardHeight = 22
     
112. 
     
113.     scoreChanged = QtCore.pyqtSignal(int)
     
114. 
     
115.     levelChanged = QtCore.pyqtSignal(int)
     
116. 
     
117.     linesRemovedChanged = QtCore.pyqtSignal(int)
     
118. 
     
119.     def __init__(self, parent=None):
     
120.         super(TetrixBoard, self).__init__(parent)
     
121. 
     
122.         self.timer = QtCore.QBasicTimer()
     
123.         self.nextPieceLabel = None
     
124.         self.isWaitingAfterLine = False
     
125.         self.curPiece = TetrixPiece()
     
126.         self.nextPiece = TetrixPiece()
     
127.         self.curX = 0
     
128.         self.curY = 0
     
129.         self.numLinesRemoved = 0
     
130.         self.numPiecesDropped = 0
     
131.         self.score = 0
     
132.         self.level = 0
     
133.         self.board = None
     
134. 
     
135.         self.setFrameStyle(QtGui.QFrame.Panel | QtGui.QFrame.Sunken)
     
136.         self.setFocusPolicy(QtCore.Qt.StrongFocus)
     
137.         self.isStarted = False
     
138.         self.isPaused = False
     
139.         self.clearBoard()
     
140. 
     
141.         self.nextPiece.setRandomShape()
     
142. 
     
143.     def shapeAt(self, x, y):
     
144.         return self.board[(y * TetrixBoard.BoardWidth) + x]
     
145. 
     
146.     def setShapeAt(self, x, y, shape):
     
147.         self.board[(y * TetrixBoard.BoardWidth) + x] = shape   
     
148. 
     
149.     def timeoutTime(self):
     
150.         return 1000 / (1 + self.level)
     
151. 
     
152.     def squareWidth(self):
     
153.         return self.contentsRect().width() / TetrixBoard.BoardWidth
     
154. 
     
155.     def squareHeight(self):
     
156.         return self.contentsRect().height() / TetrixBoard.BoardHeight
     
157. 
     
158.     def setNextPieceLabel(self, label):
     
159.         self.nextPieceLabel = label
     
160. 
     
161.     def sizeHint(self):
     
162.         return QtCore.QSize(TetrixBoard.BoardWidth * 15 + self.frameWidth() * 2,
     
163.                 TetrixBoard.BoardHeight * 15 + self.frameWidth() * 2)
     
164. 
     
165.     def minimumSizeHint(self):
     
166.         return QtCore.QSize(TetrixBoard.BoardWidth * 5 + self.frameWidth() * 2,
     
167.                 TetrixBoard.BoardHeight * 5 + self.frameWidth() * 2)
     
168. 
     
169.     def start(self):
     
170.         if self.isPaused:
     
171.             return
     
172. 
     
173.         self.isStarted = True
     
174.         self.isWaitingAfterLine = False
     
175.         self.numLinesRemoved = 0
     
176.         self.numPiecesDropped = 0
     
177.         self.score = 0
     
178.         self.level = 1
     
179.         self.clearBoard()
     
180. 
     
181.         self.linesRemovedChanged.emit(self.numLinesRemoved)
     
182.         self.scoreChanged.emit(self.score)
     
183.         self.levelChanged.emit(self.level)
     
184. 
     
185.         self.newPiece()
     
186.         self.timer.start(self.timeoutTime(), self)
     
187. 
     
188.     def pause(self):
     
189.         if not self.isStarted:
     
190.             return
     
191. 
     
192.         self.isPaused = not self.isPaused
     
193.         if self.isPaused:
     
194.             self.timer.stop()
     
195.         else:
     
196.             self.timer.start(self.timeoutTime(), self)
     
197. 
     
198.         self.update()
     
199. 
     
200.     def paintEvent(self, event):
     
201.         super(TetrixBoard, self).paintEvent(event)
     
202. 
     
203.         painter = QtGui.QPainter(self)
     
204.         rect = self.contentsRect()
     
205. 
     
206.         if self.isPaused:
     
207.             painter.drawText(rect, QtCore.Qt.AlignCenter, "Pause")
     
208.             return
     
209. 
     
210.         boardTop = rect.bottom() - TetrixBoard.BoardHeight * self.squareHeight()
     
211. 
     
212.         for i in range(TetrixBoard.BoardHeight):
     
213.             for j in range(TetrixBoard.BoardWidth):
     
214.                 shape = self.shapeAt(j, TetrixBoard.BoardHeight - i - 1)
     
215.                 if shape != NoShape:
     
216.                     self.drawSquare(painter,
     
217.                             rect.left() + j * self.squareWidth(),
     
218.                             boardTop + i * self.squareHeight(), shape)
     
219. 
     
220.         if self.curPiece.shape() != NoShape:
     
221.             for i in range(4):
     
222.                 x = self.curX + self.curPiece.x(i)
     
223.                 y = self.curY - self.curPiece.y(i)
     
224.                 self.drawSquare(painter, rect.left() + x * self.squareWidth(),
     
225.                         boardTop + (TetrixBoard.BoardHeight - y - 1) * self.squareHeight(),
     
226.                         self.curPiece.shape())
     
227. 
     
228.     def keyPressEvent(self, event):
     
229.         if not self.isStarted or self.isPaused or self.curPiece.shape() == NoShape:
     
230.             super(TetrixBoard, self).keyPressEvent(event)
     
231.             return
     
232. 
     
233.         key = event.key()
     
234.         if key == QtCore.Qt.Key_Left:
     
235.             self.tryMove(self.curPiece, self.curX - 1, self.curY)
     
236.         elif key == QtCore.Qt.Key_Right:
     
237.             self.tryMove(self.curPiece, self.curX + 1, self.curY)
     
238.         elif key == QtCore.Qt.Key_Down:
     
239.             self.tryMove(self.curPiece.rotatedRight(), self.curX, self.curY)
     
240.         elif key == QtCore.Qt.Key_Up:
     
241.             self.tryMove(self.curPiece.rotatedLeft(), self.curX, self.curY)
     
242.         elif key == QtCore.Qt.Key_Space:
     
243.             self.dropDown()
     
244.         elif key == QtCore.Qt.Key_D:
     
245.             self.oneLineDown()
     
246.         else:
     
247.             super(TetrixBoard, self).keyPressEvent(event)
     
248. 
     
249.     def timerEvent(self, event):
     
250.         if event.timerId() == self.timer.timerId():
     
251.             if self.isWaitingAfterLine:
     
252.                 self.isWaitingAfterLine = False
     
253.                 self.newPiece()
     
254.                 self.timer.start(self.timeoutTime(), self)
     
255.             else:
     
256.                 self.oneLineDown()
     
257.         else:
     
258.             super(TetrixBoard, self).timerEvent(event)
     
259. 
     
260.     def clearBoard(self):
     
261.         self.board = [NoShape for i in range(TetrixBoard.BoardHeight * TetrixBoard.BoardWidth)]
     
262. 
     
263.     def dropDown(self):
     
264.         dropHeight = 0
     
265.         newY = self.curY
     
266.         while newY > 0:
     
267.             if not self.tryMove(self.curPiece, self.curX, newY - 1):
     
268.                 break
     
269.             newY -= 1
     
270.             dropHeight += 1
     
271. 
     
272.         self.pieceDropped(dropHeight)
     
273. 
     
274.     def oneLineDown(self):
     
275.         if not self.tryMove(self.curPiece, self.curX, self.curY - 1):
     
276.             self.pieceDropped(0)
     
277. 
     
278.     def pieceDropped(self, dropHeight):
     
279.         for i in range(4):
     
280.             x = self.curX + self.curPiece.x(i)
     
281.             y = self.curY - self.curPiece.y(i)
     
282.             self.setShapeAt(x, y, self.curPiece.shape())
     
283. 
     
284.         self.numPiecesDropped += 1
     
285.         if self.numPiecesDropped % 25 == 0:
     
286.             self.level += 1
     
287.             self.timer.start(self.timeoutTime(), self)
     
288.             self.levelChanged.emit(self.level)
     
289. 
     
290.         self.score += dropHeight + 7
     
291.         self.scoreChanged.emit(self.score)
     
292.         self.removeFullLines()
     
293. 
     
294.         if not self.isWaitingAfterLine:
     
295.             self.newPiece()
     
296. 
     
297.     def removeFullLines(self):
     
298.         numFullLines = 0
     
299. 
     
300.         for i in range(TetrixBoard.BoardHeight - 1, -1, -1):
     
301.             lineIsFull = True
     
302. 
     
303.             for j in range(TetrixBoard.BoardWidth):
     
304.                 if self.shapeAt(j, i) == NoShape:
     
305.                     lineIsFull = False
     
306.                     break
     
307. 
     
308.             if lineIsFull:
     
309.                 numFullLines += 1
     
310.                 for k in range(TetrixBoard.BoardHeight - 1):
     
311.                     for j in range(TetrixBoard.BoardWidth):
     
312.                         self.setShapeAt(j, k, self.shapeAt(j, k + 1))
     
313. 
     
314.                 for j in range(TetrixBoard.BoardWidth):
     
315.                     self.setShapeAt(j, TetrixBoard.BoardHeight - 1, NoShape)
     
316. 
     
317.         if numFullLines > 0:
     
318.             self.numLinesRemoved += numFullLines
     
319.             self.score += 10 * numFullLines
     
320.             self.linesRemovedChanged.emit(self.numLinesRemoved)
     
321.             self.scoreChanged.emit(self.score)
     
322. 
     
323.             self.timer.start(500, self)
     
324.             self.isWaitingAfterLine = True
     
325.             self.curPiece.setShape(NoShape)
     
326.             self.update()
     
327. 
     
328.     def newPiece(self):
     
329.         self.curPiece = self.nextPiece
     
330.         self.nextPiece.setRandomShape()
     
331.         self.showNextPiece()
     
332.         self.curX = TetrixBoard.BoardWidth // 2 + 1
     
333.         self.curY = TetrixBoard.BoardHeight - 1 + self.curPiece.minY()
     
334. 
     
335.         if not self.tryMove(self.curPiece, self.curX, self.curY):
     
336.             self.curPiece.setShape(NoShape)
     
337.             self.timer.stop()
     
338.             self.isStarted = False
     
339. 
     
340.     def showNextPiece(self):
     
341.         if self.nextPieceLabel is not None:
     
342.             return
     
343. 
     
344.         dx = self.nextPiece.maxX() - self.nextPiece.minX() + 1
     
345.         dy = self.nextPiece.maxY() - self.nextPiece.minY() + 1
     
346. 
     
347.         pixmap = QtGui.QPixmap(dx * self.squareWidth(), dy * self.squareHeight())
     
348.         painter = QtGui.QPainter(pixmap)
     
349.         painter.fillRect(pixmap.rect(), self.nextPieceLabel.palette().background())
     
350. 
     
351.         for int in range(4):
     
352.             x = self.nextPiece.x(i) - self.nextPiece.minX()
     
353.             y = self.nextPiece.y(i) - self.nextPiece.minY()
     
354.             self.drawSquare(painter, x * self.squareWidth(),
     
355.                     y * self.squareHeight(), self.nextPiece.shape())
     
356. 
     
357.         self.nextPieceLabel.setPixmap(pixmap)
     
358. 
     
359.     def tryMove(self, newPiece, newX, newY):
     
360.         for i in range(4):
     
361.             x = newX + newPiece.x(i)
     
362.             y = newY - newPiece.y(i)
     
363.             if x < 0 or x >= TetrixBoard.BoardWidth or y < 0 or y >= TetrixBoard.BoardHeight:
     
364.                 return False
     
365.             if self.shapeAt(x, y) != NoShape:
     
366.                 return False
     
367. 
     
368.         self.curPiece = newPiece
     
369.         self.curX = newX
     
370.         self.curY = newY
     
371.         self.update()
     
372.         return True
     
373. 
     
374.     def drawSquare(self, painter, x, y, shape):
     
375.         colorTable = [0x000000, 0xCC6666, 0x66CC66, 0x6666CC,
     
376.                       0xCCCC66, 0xCC66CC, 0x66CCCC, 0xDAAA00]
     
377. 
     
378.         color = QtGui.QColor(colorTable[shape])
     
379.         painter.fillRect(x + 1, y + 1, self.squareWidth() - 2,
     
380.                 self.squareHeight() - 2, color)
     
381. 
     
382.         painter.setPen(color.light())
     
383.         painter.drawLine(x, y + self.squareHeight() - 1, x, y)
     
384.         painter.drawLine(x, y, x + self.squareWidth() - 1, y)
     
385. 
     
386.         painter.setPen(color.dark())
     
387.         painter.drawLine(x + 1, y + self.squareHeight() - 1,
     
388.                 x + self.squareWidth() - 1, y + self.squareHeight() - 1)
     
389.         painter.drawLine(x + self.squareWidth() - 1,
     
390.                 y + self.squareHeight() - 1, x + self.squareWidth() - 1, y + 1)
     
391. 
     
392. 
     
393. class TetrixPiece(object):
     
394.     coordsTable = (
     
395.         ((0, 0),     (0, 0),     (0, 0),     (0, 0)),
     
396.         ((0, -1),    (0, 0),     (-1, 0),    (-1, 1)),
     
397.         ((0, -1),    (0, 0),     (1, 0),     (1, 1)),
     
398.         ((0, -1),    (0, 0),     (0, 1),     (0, 2)),
     
399.         ((-1, 0),    (0, 0),     (1, 0),     (0, 1)),
     
400.         ((0, 0),     (1, 0),     (0, 1),     (1, 1)),
     
401.         ((-1, -1),   (0, -1),    (0, 0),     (0, 1)),
     
402.         ((1, -1),    (0, -1),    (0, 0),     (0, 1))
     
403.     )
     
404. 
     
405.     def __init__(self):
     
406.         self.coords = [[0,0] for _ in range(4)]
     
407.         self.pieceShape = NoShape
     
408. 
     
409.         self.setShape(NoShape)
     
410. 
     
411.     def shape(self):
     
412.         return self.pieceShape
     
413. 
     
414.     def setShape(self, shape):
     
415.         table = TetrixPiece.coordsTable[shape]
     
416.         for i in range(4):
     
417.             for j in range(2):
     
418.                 self.coords[i][j] = table[i][j]
     
419. 
     
420.         self.pieceShape = shape
     
421. 
     
422.     def setRandomShape(self):
     
423.         self.setShape(random.randint(1, 7))
     
424. 
     
425.     def x(self, index):
     
426.         return self.coords[index][0]
     
427. 
     
428.     def y(self, index):
     
429.         return self.coords[index][1]
     
430. 
     
431.     def setX(self, index, x):
     
432.         self.coords[index][0] = x
     
433. 
     
434.     def setY(self, index, y):
     
435.         self.coords[index][1] = y
     
436. 
     
437.     def minX(self):
     
438.         m = self.coords[0][0]
     
439.         for i in range(4):
     
440.             m = min(m, self.coords[i][0])
     
441. 
     
442.         return m
     
443. 
     
444.     def maxX(self):
     
445.         m = self.coords[0][0]
     
446.         for i in range(4):
     
447.             m = max(m, self.coords[i][0])
     
448. 
     
449.         return m
     
450. 
     
451.     def minY(self):
     
452.         m = self.coords[0][1]
     
453.         for i in range(4):
     
454.             m = min(m, self.coords[i][1])
     
455. 
     
456.         return m
     
457. 
     
458.     def maxY(self):
     
459.         m = self.coords[0][1]
     
460.         for i in range(4):
     
461.             m = max(m, self.coords[i][1])
     
462. 
     
463.         return m
     
464. 
     
465.     def rotatedLeft(self):
     
466.         if self.pieceShape == SquareShape:
     
467.             return self
     
468. 
     
469.         result = TetrixPiece()
     
470.         result.pieceShape = self.pieceShape
     
471.         for i in range(4):
     
472.             result.setX(i, self.y(i))
     
473.             result.setY(i, -self.x(i))
     
474. 
     
475.         return result
     
476. 
     
477.     def rotatedRight(self):
     
478.         if self.pieceShape == SquareShape:
     
479.             return self
     
480. 
     
481.         result = TetrixPiece()
     
482.         result.pieceShape = self.pieceShape
     
483.         for i in range(4):
     
484.             result.setX(i, -self.y(i))
     
485.             result.setY(i, self.x(i))
     
486. 
     
487.         return result
     
488. 
     
489. 
     
490. if __name__ == '__main__':
     
491. 
     
492.     import sys
     
493. 
     
494.     app = QtGui.QApplication(sys.argv)
     
495.     window = TetrixWindow()
     
496.     window.show()
     
497.     random.seed(None)
     
498.     sys.exit(app.exec_())
     

复制代码

softsongs

鼓励！
Keep up!

masaic117

赞一个……

xiaoquwl

是原创么