我们讲解了俄罗斯方块的各个宏观的部分，这次就是更细致的编程了，不过代码量实在不小，如果完全贴出来估计会吓退很多人，所以我打算这里只贴出数据和方法名，至于方法里的代码就省略了，一切有兴趣的朋友，请参考最后放出来的源文件。

这个是main调用的Tetris类，这个类实现了我们所看到的游戏画面，是整个俄罗斯方块游戏的核心代码。为了明晰，它还会调用shape类来实现当前的shape，下面会讲：

class Tetris(object):
    W = 12          # board区域横向多少个格子
    H = 20          # 纵向多少个格子
    TILEW = 20      # 每个格子的高/宽的像素数
    START = (100, 20) # board在屏幕上的位置
    SPACE = 1000    # 方块在多少毫秒内会落下(现在是level 1)

    def __init__(self, screen):
        pass

    def update(self, elapse):
        # 在游戏阶段，每次都会调用这个，用来接受输入，更新画面
        pass

    def move(self, u, d, l, r):
        # 控制当前方块的状态
        pass

    def check_line(self):
        # 判断已经落下方块的状态，然后调用kill_line
        pass

    def kill_line(self, filled=[]):
        # 删除填满的行，需要播放个消除动画
        pass

    def get_score(self, num):
        # 计算得分
       pass

    def add_to_board(self):
        # 将触底的方块加入到board数组中
       pass

    def create_board_image(self):
        # 创造出一个稳定方块的图像
        pass

    def next(self):
        # 产生下一个方块
        pass

    def draw(self):
        # 把当前状态画出来
        pass

    def display_info(self):
        # 显示各种信息（分数，等级等），调用下面的_display***
        pass

    def _display_score(self):
        pass

    def _display_next(self):
        pass

    def game_over(self):
        # 游戏结束
        pass

这里的东西基本都是和python语言本身相关的，pygame的内容并不多，所以就不多讲了。看一下__init__的内容，了解了结构和数据，整个运作也就能明白了：

    def __init__(self, screen)
        self.stat = "game"
        self.WIDTH = self.TILEW * self.W
        self.HEIGHT = self.TILEW * self.H
        self.screen = screen
        # board数组，空则为None
        self.board = []
        for i in xrange(self.H):
            line = [ None ] * self.W
            self.board.append(line)
        # 一些需要显示的信息
        self.level = 1
        self.killed = 0
        self.score = 0
        # 多少毫秒后会落下，当然在init里肯定是不变的(level总是一）
        self.time = self.SPACE * 0.8 ** (self.level - 1)
        # 这个保存自从上一次落下后经历的时间
        self.elapsed = 0
        # used for judge pressed firstly or for a  long time
        self.pressing = 0
        # 当前的shape
        self.shape = Shape(self.START,
                (self.WIDTH, self.HEIGHT), (self.W, self.H))
        # shape需要知道周围世界的事情
        self.shape.set_board(self.board)
        # 这个是“世界”的“快照”
        self.board_image = pygame.Surface((self.WIDTH, self.HEIGHT))
        # 做一些初始化的绘制
        self.screen.blit(pygame.image.load(
            util.file_path("background.jpg")).convert(), (0, 0))
        self.display_info()

注意我们这里update方法的实现有些不同，并不是等待一个事件就立刻相应。记得一开是说的左右移动的对应么？按下去自然立刻移动，但如果按下了没有释放，那么方块就会持续移动，为了实现这一点，我们需要把event.get和get_pressed混合使用，代码如下：

    def update(self, elapse):
        for e in pygame.event.get():    # 这里是普通的
            if e.type == KEYDOWN:
                self.pressing = 1           # 一按下，记录“我按下了”，然后就移动
                self.move(e.key == K_UP, e.key == K_DOWN,
                        e.key == K_LEFT, e.key == K_RIGHT)
                if e.key == K_ESCAPE:
                    self.stat = 'menu'
            elif e.type == KEYUP and self.pressing:
                self.pressing = 0        # 如果释放，就撤销“我按下了”的状态
            elif e.type == QUIT:
                self.stat = 'quit'
        if self.pressing:         # 即使没有获得新的事件，也要根据“我是否按下”来查看
            pressed = pygame.key.get_pressed()    # 把按键状态交给move
            self.move(pressed[K_UP], pressed[K_DOWN],
                    pressed[K_LEFT], pressed[K_RIGHT])
        self.elapsed += elapse    # 这里是在指定时间后让方块自动落下
        if self.elapsed >= self.time:
            self.next()
            self.elapsed = self.elapsed - self.time
            self.draw()
        return self.stat

稍微看一下消除动画的实现，效果就是如果哪一行填满了，就在把那行删除前闪两下：

    def kill_line(self, filled=[]):
        if len(filled) == 0:
            return
        # 动画的遮罩
        mask = pygame.Surface((self.WIDTH, self.TILEW), SRCALPHA, 32)
        for i in xrange(5):
            if i % 2 == 0:
                # 比较透明
                mask.fill((255, 255, 255, 100))
            else:
                # 比较不透明
                mask.fill((255, 255, 255, 200))
            self.screen.blit(self.board_image, self.START)
            # 覆盖在满的行上面
            for line in filled:
                self.screen.blit(mask, (
                        self.START[0],
                        self.START[1] + line * self.TILEW))
                pygame.display.update()
            pygame.time.wait(80)
        # 这里是使用删除填满的行再在顶部填空行的方式，比较简单
        # 如果清空再让方块下落填充，就有些麻烦了
        [self.board.pop(l) for l in sorted(filled, reverse=True)]
        [self.board.insert(0, [None] * self.W) for l in filled]
        self.get_score(len(filled))

这个类本身没有操纵shape的能力，第一块代码中move的部分，其实是简单的调用了self.shape的方法。而shape则响应当前的按键，做各种动作。同时，shape还有绘制自身和下一个图像的能力。

class Shape(object):
    # shape是画在一个矩阵上面的
    # 因为我们有不同的模式，所以矩阵的信息也要详细给出
    SHAPEW = 4    # 这个是矩阵的宽度
    SHAPEH = 4    # 这个是高度
    SHAPES = (
        (   ((0,0,0,0),     #
             (0,1,1,0),     #   [][]
             (0,1,1,0),     #   [][]
             (0,0,0,0),),   #
        ),
        # 还有很多图形，省略，具体请查看代码
        ),
    )
    COLORS = ((0xcc, 0x66, 0x66), # 各个shape的颜色
        )

    def __init__(self, board_start, (board_width, board_height), (w, h)):
        self.start = board_start
        self.W, self.H = w, h           # board的横、纵的tile数
        self.length = board_width / w   # 一个tille的长宽(正方形)
        self.x, self.y = 0, 0     # shape的起始位置
        self.index = 0          # 当前shape在SHAPES内的索引
        self.indexN = 0         # 下一个shape在SHAPES内的索引
        self.subindex = 0       # shape是在怎样的一个朝向
        self.shapes = []        # 记录当前shape可能的朝向
        self.color = ()
        self.shape = None
        # 这两个Surface用来存放当前、下一个shape的图像
        self.image = pygame.Surface(
                (self.length * self.SHAPEW, self.length * self.SHAPEH),
                SRCALPHA, 32)
        self.image_next = pygame.Surface(
                (self.length * self.SHAPEW, self.length * self.SHAPEH),
                SRCALPHA, 32)
        self.board = []         # 外界信息
        self.new()            # let's dance!

    def set_board(self, board):
        # 接受外界状况的数组
        pass

    def new(self):
        # 新产生一个方块
        # 注意这里其实是新产生“下一个”方块，而马上要落下的方块则
        # 从上一个“下一个”方块那里获得
        pass

    def rotate(self):
        # 翻转
        pass

    def move(self, r, c):
        # 左右下方向的移动

    def check_legal(self, r=0, c=0):
        # 用在上面的move判断中，“这样的移动”是否合法（如是否越界）
        # 合法才会实际的动作
        pass

    def at_bottom(self):
        # 是否已经不能再下降了
        pass

    def draw_current_shape(self):
        # 绘制当前shhape的图像
        pass
    def draw_next_shape(self):
        # 绘制下一个shape的图像
        pass
    def _draw_shape(self, surface, shape, color):
        # 上两个方法的支援方法
        # 注意这里的绘制是绘制到一个surface中方便下面的draw方法blit
        # 并不是画到屏幕上
        pass

    def draw(self, screen):
        # 更新shape到屏幕上
        pass

框架如上所示，一个Shape类主要是有移动旋转和标识自己的能力，当用户按下按键时，Tetris会把这些按键信息传递给Shape，然后它相应之后在返回到屏幕之上。

这样的Tetris和Shape看起来有些复杂，不过想清楚了还是可以接受的，主要是因为我们得提供多种模式，所以分割的细一些容易继承和发展。比如说，我们实现一种方块一落下就消失的模式，之需要这样做就可以了：

class Tetris1(Tetris):
    """ 任何方块一落下即消失的模式，只需要覆盖check_line方法，
    不是返回一个填满的行，而是返回所有有东西的行 """
    def check_line(self):
        self.add_to_board()
        filled = []
        for i in xrange(self.H-1, -1, -1):
            line = self.board[i]
            sum = 0
            for t in line:
                sum += 1 if t else 0
            if sum != 0:    # 这里与一般的不同
                filled.append(i)
            else:
                break
        if i == 0 and sum !=0:
            self.game_over()
        self.create_board_image() # used for killing animation
        self.kill_line(filled)
        self.create_board_image() # used for update

这次全是代码，不禁让人感到索然。

游戏玩起来很开心，开发嘛，说白了就是艰难而持久的战斗（个人开发还要加上“孤独”这个因素），代码是绝对不可能缺少的。所以大家也就宽容一点，网上找个游戏玩了几下感觉不行就不要骂街了，多多鼓励：）谁来做都不容易啊！

我们这次基本就把代码都实现了，下一次就有个完整的可以动作的东西了。