Esempio n. 1
0
class TetrisGrid(GameObject):
    
    def __init__(self, Tetris3d, width, height):
        self.Tetris3d = Tetris3d
        self.grid = []
        self.tempGrid = []
        self.width = width
        self.height = height
        self.run = None
        self.gameover = 0
        self.dropTime = 500
        self.db = TetrisDB('score.db')
        self.keyDown = { 'key': None, 'time': None }
        self.initKeyEvent = None    
        self.score = TetrisNum(-15,-16.53,0)
        self.level = TetrisNum(-15,-19.34,0)
        
        for row in range(self.height):
            self.grid.append(self.getEmptyRow())
        
        for row in range(self.height):
            temp = []
            for column in range(self.width):
                temp.append(Cube(1, [1,1,1]))
            self.tempGrid.append(temp)
        
        self.tCube = TetrisCube(randrange(0,7), [2.55, 10.5, 16])
        self.helperCube = TetrisCube(self.tCube.type, [2.55, 10.5, 16])
        self.updateHelperCube()
        for color in self.helperCube.colors:
            color[0] = 0.2
            color[1] = 0.2
            color[2] = 0.2
        self.cubeTime = glutGet(GLUT_ELAPSED_TIME)
        self.completeRows = []
        self.tempRows = None
        self.nextCube = TetrisNextCube(randrange(0,7), [-13.45, 3.5, 16])
        self.blinkTime = 0
        self.cheatChangeCube = None
        self.cheatHelperCube = None
        try:
            open('slidecheat')
            self.cheatSlideCube = True
        except:
            self.cheatSlideCube = None
        self.blinkCount = 0
        
        for row in range(self.height):
            self.completeRows.append(True)
        
        self.level.value = 1

    def update(self, delay):
        if self.run:
            self.keyEvents()
            self.stickCube()
            self.completeRow()
            self.updateGrid()
            self.updateHelperCube()
    
    def display(self):
        if self.run == True:
            rowPos = 0
            for row in self.grid:
                colPos = 0
                for cube in row:
                    if cube:
                        glPushMatrix()
                        glTranslated(2.55, 10.5, 0)
                        glTranslated((self.width - colPos - 1) * 1.1, -rowPos * 1.1, 16)
                        cube.display()
                        glPopMatrix()
                    colPos += 1
                rowPos += 1
            if type(self.tCube) == types.InstanceType:
                self.tCube.display()
                if self.cheatHelperCube:
                    self.helperCube.display()
            self.score.display()
            self.level.display()
            self.nextCube.display()
    
    def getEmptyRow(self):
        row = []
        for col in range(self.width):
            row.append(None)
        return row
    
    def clearGrid(self):
        for row in range(self.height):
            for col in range(self.width):
                self.grid[row][col] = None
        self.score.value = 0
        self.level.value = 1
        self.nextCube.setType(randrange(0,7))
        self.tCube.setType(randrange(0,7))
        self.dropTime = 500
    
    def keyboard(self, key, x, y):
        if self.run:
            if ord(key) == 32 and type(self.tCube) == types.InstanceType: # spacebar
                while not self.checkCollision():
                    self.moveVert(1)
                if self.cheatSlideCube == True:
                    self.cubeTime = glutGet(GLUT_ELAPSED_TIME)
                else:
                    self.cubeTime -= self.dropTime
            if ord(key) > ord('0') and ord(key) < ord('8') and self.cheatChangeCube == True and type(self.tCube) == types.InstanceType:
                self.tCube.setType(ord(key) - ord('8'))
    
    def keyboardSpecial(self, key, x, y):
        if self.run:
            # cube thingy
            if key == 100: # left arrow key
                self.moveHoriz(1)
                self.initKeyEvent = True
                self.keyDown['key'] = 'left'
                self.keyDown['time'] = glutGet(GLUT_ELAPSED_TIME)
            if key == 102: # right arrow key
                self.moveHoriz(-1)
                self.initKeyEvent = True
                self.keyDown['key'] = 'right'
                self.keyDown['time'] = glutGet(GLUT_ELAPSED_TIME)
            if key == 103: # down arrow key
                self.moveVert(1)
                self.initKeyEvent = True
                self.keyDown['key'] = 'down'
                self.keyDown['time'] = glutGet(GLUT_ELAPSED_TIME)
            if key == 101: # up arrow key
                self.rotate()
                self.initKeyEvent = True
                self.keyDown['key'] = 'up'
                self.keyDown['time'] = glutGet(GLUT_ELAPSED_TIME)
            #cube thingy
    
    def keyboardSpecialUp(self, key, x, y):
        if self.run:
            if key == 100 and self.keyDown['key'] == 'left': # left arrow key
                self.keyDown['key'] = None
                self.keyDown['time'] = None
            if key == 102 and self.keyDown['key'] == 'right': # right arrow key
                self.keyDown['key'] = None
                self.keyDown['time'] = None
            if key == 103 and self.keyDown['key'] == 'down': # down arrow key
                self.keyDown['key'] = None
                self.keyDown['time'] = None
            if key == 101 and self.keyDown['key'] == 'up': # up arrow key
                self.keyDown['key'] = None
                self.keyDown['time'] = None
    
    def keyEvents(self):
        if self.keyDown['key'] != None:
            key = self.keyDown['key']
            time = self.keyDown['time']
            
            if self.initKeyEvent == True:
                halt = 140
            else:
                halt = 35
            if time + halt < glutGet(GLUT_ELAPSED_TIME):
                if key == 'left':
                    self.moveHoriz(1)
                elif key == 'right':
                    self.moveHoriz(-1)
                elif key == 'down':
                    self.moveVert(1)
                elif key == 'up':
                    self.rotate()
                self.initKeyEvent = None
                self.keyDown['time'] = glutGet(GLUT_ELAPSED_TIME)
    
    def stickCube(self):
        if self.cubeTime + self.dropTime < glutGet(GLUT_ELAPSED_TIME) and type(self.tCube) == types.InstanceType:
            if self.checkCollision():
                if self.tCube.position[0][0] == 0 and self.tCube.position[0][1] == self.tCube.types[self.tCube.type][0][1]:
                    self.gameOver()
                for row, col in self.tCube.position:
                    self.grid[row][self.width - 1 - col] = Cube(1, self.tCube.getColor())
                self.tCube = None
    
    def checkCollision(self, cube = None):
        if cube == None: cube = self.tCube
        for row, col in cube.position:
            if (row + 1 >= self.height) or (self.grid[row + 1][self.width - 1 - col]):
                return True
        return None

    def completeRow(self):
        if self.tCube == None:
            for rowNumber in range(20):
                self.completeRows[rowNumber] = True
            rowNumber = 0
            for row in self.grid:
                if row.count(None) > 0:
                    self.completeRows[rowNumber] = None
                rowNumber += 1
            if self.completeRows.count(True) > 0:
                self.tCube = 'blinkrows'
                self.blinkCount = 6
    
    def updateGrid(self):
        if type(self.tCube) == types.InstanceType:
            if self.cubeTime + self.dropTime < glutGet(GLUT_ELAPSED_TIME):
                self.moveVert(1)
                self.cubeTime = glutGet(GLUT_ELAPSED_TIME)
        
        elif self.tCube == None:
            self.tCube = TetrisCube(self.nextCube.cube.type, [2.55, 10.5, 16])
            self.nextCube.setType(randrange(0,7))
            self.cubeTime = glutGet(GLUT_ELAPSED_TIME)
        
        elif self.tCube == 'blinkrows':
            if self.blinkCount > 0:
                if self.blinkTime + (self.dropTime / 8) < glutGet(GLUT_ELAPSED_TIME):
                    rowNum = 0
                    for rowStatus in self.completeRows:
                        if rowStatus == True:
                            tempRow = self.grid[rowNum]
                            self.grid[rowNum] = self.tempGrid[rowNum]
                            self.tempGrid[rowNum] = tempRow
                        rowNum += 1
                    self.blinkCount -= 1
                    self.blinkTime = glutGet(GLUT_ELAPSED_TIME)
            else:
                if self.cheatHelperCube: addScore = 4
                else: addScore = 5
                rowNum = 0
                for rowStatus in self.completeRows:
                    if rowStatus == True:
                        self.grid.pop(rowNum)
                        self.grid.insert(0, self.getEmptyRow())
                        addScore *= 2
                    rowNum += 1
                if self.isGridEmpty() == True:
                    addScore *= 2
                self.addScore(addScore)
                self.tCube = None
    
    def updateHelperCube(self):
        if type(self.tCube) != types.InstanceType:
            return
        update = None
        cube = 0
        for pos in self.helperCube.position:
            if pos[1] != self.tCube.position[cube][1]:
                update = True
            elif pos[0] == self.tCube.position[cube][0] and pos[1] == self.tCube.position[cube][1]:
                update = True
            cube += 1
        if self.helperCube.type != self.tCube.type:
            update = True
        if update:
            self.helperCube.setType(self.tCube.type)
            for cube in range(len(self.helperCube.position)):
                self.helperCube.position[cube][0] = self.tCube.position[cube][0]
                self.helperCube.position[cube][1] = self.tCube.position[cube][1]
            drop = True
            while drop:
                if self.checkCollision(self.helperCube):
                    drop = None
                else:
                    for pos in self.helperCube.position:
                        pos[0] += 1
    
    def isGridEmpty(self):
        if self.grid[self.height - 1].count(None) == self.width:
            return True
        else:
            return None
    
    def gameOver(self):
        scores = self.db.getToTen()
        self.run = None
        self.gameover = 1
        if (len(scores) == 10 and self.score.getValue() < scores[9][1]) or (self.score.getValue() == 0):
            self.Tetris3d.objects['TetrisHUD'].setState('gameoverMenu')
        else:
            self.Tetris3d.objects['TetrisHUD'].setState('enterName')
    
    def addScore(self, score):
        self.score.add(score)
        if self.score.value >= 250 * self.level.value:
            self.level.add(1)
            self.dropTime -= 25
            if self.dropTime < 100:
                self.dropTime = 100
    
    # cube movement
    def moveHoriz(self, length):
        if type(self.tCube) == types.InstanceType:
            move = True
            for row, col in self.tCube.position:
                if (col + length < 0) or (col + length >= self.width):
                    move = None
                elif self.grid[row][self.width - 1 - col - length]:
                    move = None
            #test border
            if move:
                for pos in self.tCube.position:
                    pos[1] += length
    
    def moveVert(self, length):
        if type(self.tCube) == types.InstanceType:
            move = True
            for row, col in self.tCube.position:
                if row + length >= self.height:
                    move = None
                elif self.grid[row + length][self.width - 1 - col]:
                    move = None
            if move:
                for pos in self.tCube.position:
                    pos[0] += length
    
    def rotate(self):
        if type(self.tCube) == types.InstanceType:
            rotate = True
            for row, col in self.tCube.getRotation():
                if (row < -1 or row >= self.height): # top/bottom border test
                    rotate = None
                    break
                if (col < 0 or col >= self.width): # left/right border test
                    rotate = None
                    break
                if row != -1:
                    if self.grid[row][self.width - 1 - col]: # grid test
                        rotate = None
                        break
            if rotate:
                self.tCube.rotate()