Chinaunix首页 | 论坛 | 博客

elu

首页　| 　博文目录　| 　关于我

elu_ligao

  • 博客访问： 19292
  • 博文数量： 2
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 12
  • 用 户 组： 普通用户
  • 注册时间： 2016-09-22 13:59
个人简介

积累， 沉淀

文章分类

全部博文（2）

文章存档

2019年（1）

2016年（1）

我的朋友
最近访客
推荐博文
相关博文
python 俄罗斯方块

分类： Python/Ruby

2019-11-21 20:56:50

      俄罗斯方块， 自己基本玩的还行。
      用的python的pygame模块，先画一个简单的屏幕




点击(此处)折叠或打开

  1. import sys
  2. import pygame

  4. def main():
  5.     pygame.init()
  6.     screen = pygame.display.set_mode((500, 700))  # 画布大小
  7.     pygame.display.set_caption('俄罗斯方块')       # 设置标题样式
  8.     
  9.     while True:
  10.         for event in pygame.event.get():
  11.             if event.type == pygame.QUIT:
  12.                 pygame.quit()
  13.                 sys.exit()                    

  15. if __name__ == '__main__':
  16.     main()
运行代码后情况如下：


现在是把上面画布分为两大部分，左边为游戏区，为了更直观看到方块，一齐画上方块的网格线；右边为游戏信息区，包括积分、消除行数、下一个方块提示等信息；中间用一条竖线区分开来

点击(此处)折叠或打开

  1. import sys
  2. import pygame


  5. SIZE = 30 # 每个小方格大小

  7. BLOCK_HEIGHT_NUM = 20 # 游戏区高度方向方块数量
  8. BLOCK_WIDTH_NUM = 10 # 游戏区宽度方向方块数量

  10. BORDER_WIDTH = 4 # 游戏区边框分割线宽度
  11. BORDER_COLOR = (40, 40, 200) # 游戏区边框分割线颜色

  13. INFO_WIDTH = 160 # 信息区域宽度

  15. BG_COLOR = (60, 60, 60) # 背景色

  17. BLACK = (0, 0, 0) # 网格线颜色
  18. WIDTH = 1 # 网格线宽度

  20. SCREEN_WIDTH = (SIZE + WIDTH) * BLOCK_WIDTH_NUM + WIDTH + BORDER_WIDTH + INFO_WIDTH # 游戏屏幕的宽
  21. SCREEN_HEIGHT = (SIZE + WIDTH) * BLOCK_HEIGHT_NUM # 游戏屏幕的高


  24. # 将文字划到画布上指定位置
  25. def print_text(screen, font, x, y, text, fcolor=(255, 255, 255)):
  26.     imgText = font.render(text, True, fcolor)
  27.     screen.blit(imgText, (x, y))


  30. def main():
  31.     pygame.init()
  32.     screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
  33.     pygame.display.set_caption('俄罗斯方块')
  34.     
  35.     font1 = pygame.font.SysFont('SimHei', 24) # 黑体24
  36.     font1_width, font1_height = font1.size('得分：') # 字体高度
  37.     font1_height= int(font1_height)
  38.     font_pos_x = SCREEN_WIDTH - INFO_WIDTH + 10 # 右侧信息显示区域字体位置的X坐标
  39.     
  40.     score = 0 # 得分
  41.     removes = 0 # 消除行数
  42.     orispeed = 0.5 # 原始速度
  43.     speed = orispeed # 当前速度
  44.     
  45.     while True:
  46.         for event in pygame.event.get():
  47.             if event.type == pygame.QUIT:
  48.                 pygame.quit()
  49.                 sys.exit()
  50.                 
  51.                 
  52.         # 填充背景色
  53.         screen.fill(BG_COLOR)
  54.         # 画游戏区域分隔线
  55.         pygame.draw.line(screen, BORDER_COLOR,
  56.                          ((SIZE + WIDTH) * BLOCK_WIDTH_NUM + BORDER_WIDTH // 2, 0),
  57.                          ((SIZE + WIDTH) * BLOCK_WIDTH_NUM + BORDER_WIDTH // 2, SCREEN_HEIGHT), BORDER_WIDTH)
  58.               
  59.         # 画网格线 竖线
  60.         for x in range(BLOCK_WIDTH_NUM+1):
  61.             pygame.draw.line(screen, BLACK, (x * (SIZE + WIDTH), 0), (x * (SIZE + WIDTH), SCREEN_HEIGHT), 1)
  62.         # 画网格线 横线
  63.         for y in range(BLOCK_HEIGHT_NUM+1):
  64.             pygame.draw.line(screen, BLACK, (0, y * (SIZE + WIDTH)), (BLOCK_WIDTH_NUM * (SIZE + WIDTH), y * (SIZE + WIDTH)), 1)

  66.         
  67.         print_text(screen, font1, font_pos_x, 10, f'得分: ')
  68.         print_text(screen, font1, font_pos_x + SIZE, 10 + font1_height + 6, f'{score}')
  69.         print_text(screen, font1, font_pos_x, 20 + (font1_height + 6) * 2, f'行数: ')
  70.         print_text(screen, font1, font_pos_x + SIZE, 20 + (font1_height + 6) * 3, f'{removes}')
  71.         print_text(screen, font1, font_pos_x, 30 + (font1_height + 6) * 4, f'速度: ')
  72.         print_text(screen, font1, font_pos_x + SIZE, 30 + (font1_height + 6) * 5, f'{score // 10000}')
  73.         print_text(screen, font1, font_pos_x, 40 + (font1_height + 6) * 6, f'下一个：')
  74.         
  75.         pygame.display.flip()


  78. if __name__ == '__main__':
  79.     main()
现在运行后的效果如下：


接下来就是各种方块的绘制了
先统计方块种类，分别有 T 型、L 型、J 型、I 型、Z 型、S 型、正方形，网上找的block模块直接拿来用

点击(此处)折叠或打开

  1. import random
  2. from collections import namedtuple

  4. Point = namedtuple('Point', 'X Y')
  5. Shape = namedtuple('Shape', 'X Y Width Height')
  6. Block = namedtuple('Block', 'template start_pos end_pos name next')

  8. # 方块形状的设计，我最初我是做成 4 × 4，因为长宽最长都是4，这样旋转的时候就不考虑怎么转了，就是从一个图形替换成另一个
  9. # 其实要实现这个功能，只需要固定左上角的坐标就可以了

  11. # S形方块
  12. S_BLOCK = [Block(['.OO',
  13.                   'OO.',
  14.                   '...'], Point(0, 0), Point(2, 1), 'S', 1),
  15.            Block(['O..',
  16.                   'OO.',
  17.                   '.O.'], Point(0, 0), Point(1, 2), 'S', 0)]
  18. # Z形方块
  19. Z_BLOCK = [Block(['OO.',
  20.                   '.OO',
  21.                   '...'], Point(0, 0), Point(2, 1), 'Z', 1),
  22.            Block(['.O.',
  23.                   'OO.',
  24.                   'O..'], Point(0, 0), Point(1, 2), 'Z', 0)]
  25. # I型方块
  26. I_BLOCK = [Block(['.O..',
  27.                   '.O..',
  28.                   '.O..',
  29.                   '.O..'], Point(1, 0), Point(1, 3), 'I', 1),
  30.            Block(['....',
  31.                   '....',
  32.                   'OOOO',
  33.                   '....'], Point(0, 2), Point(3, 2), 'I', 0)]
  34. # O型方块
  35. O_BLOCK = [Block(['OO',
  36.                   'OO'], Point(0, 0), Point(1, 1), 'O', 0)]
  37. # J型方块
  38. J_BLOCK = [Block(['O..',
  39.                   'OOO',
  40.                   '...'], Point(0, 0), Point(2, 1), 'J', 1),
  41.            Block(['.OO',
  42.                   '.O.',
  43.                   '.O.'], Point(1, 0), Point(2, 2), 'J', 2),
  44.            Block(['...',
  45.                   'OOO',
  46.                   '..O'], Point(0, 1), Point(2, 2), 'J', 3),
  47.            Block(['.O.',
  48.                   '.O.',
  49.                   'OO.'], Point(0, 0), Point(1, 2), 'J', 0)]
  50. # L型方块
  51. L_BLOCK = [Block(['..O',
  52.                   'OOO',
  53.                   '...'], Point(0, 0), Point(2, 1), 'L', 1),
  54.            Block(['.O.',
  55.                   '.O.',
  56.                   '.OO'], Point(1, 0), Point(2, 2), 'L', 2),
  57.            Block(['...',
  58.                   'OOO',
  59.                   'O..'], Point(0, 1), Point(2, 2), 'L', 3),
  60.            Block(['OO.',
  61.                   '.O.',
  62.                   '.O.'], Point(0, 0), Point(1, 2), 'L', 0)]
  63. # T型方块
  64. T_BLOCK = [Block(['.O.',
  65.                   'OOO',
  66.                   '...'], Point(0, 0), Point(2, 1), 'T', 1),
  67.            Block(['.O.',
  68.                   '.OO',
  69.                   '.O.'], Point(1, 0), Point(2, 2), 'T', 2),
  70.            Block(['...',
  71.                   'OOO',
  72.                   '.O.'], Point(0, 1), Point(2, 2), 'T', 3),
  73.            Block(['.O.',
  74.                   'OO.',
  75.                   '.O.'], Point(0, 0), Point(1, 2), 'T', 0)]

  77. BLOCKS = {'O': O_BLOCK,
  78.           'I': I_BLOCK,
  79.           'Z': Z_BLOCK,
  80.           'T': T_BLOCK,
  81.           'L': L_BLOCK,
  82.           'S': S_BLOCK,
  83.           'J': J_BLOCK}


  86. def get_block():
  87.     block_name = random.choice('OIZTLSJ')
  88.     b = BLOCKS[block_name]
  89.     idx = random.randint(0, len(b) - 1)
  90.     return b[idx]


  93. def get_next_block(block):
  94.     b = BLOCKS[block.name]
  95.     return b[block.next]

现在加载block模块， 画下一个提示的方块及绘制一个下落的方块(发现上面那个网格线1的宽度可以不用特意计算)

点击(此处)折叠或打开

  1. import sys
  2. import pygame
  3. import blocks
  4. import time

  6. SIZE = 30 # 每个小方格大小

  8. BLOCK_HEIGHT_NUM = 20 # 游戏区高度方向方块数量
  9. BLOCK_WIDTH_NUM = 10 # 游戏区宽度方向方块数量

  11. BORDER_WIDTH = 4 # 游戏区边框分割线宽度
  12. BORDER_COLOR = (40, 40, 200) # 游戏区边框分割线颜色

  14. INFO_WIDTH = 160 # 信息区域宽度

  16. BG_COLOR = (60, 60, 60) # 背景色

  18. BLACK = (0, 0, 0) # 网格线颜色
  19. WIDTH = 1 # 网格线宽度

  21. SCREEN_WIDTH = SIZE * BLOCK_WIDTH_NUM + BORDER_WIDTH + INFO_WIDTH # 游戏屏幕的宽
  22. SCREEN_HEIGHT = SIZE * BLOCK_HEIGHT_NUM # 游戏屏幕的高


  25. # 将文字划到画布上指定位置
  26. def print_text(screen, font, x, y, text, fcolor=(255, 255, 255)):
  27.     imgText = font.render(text, True, fcolor)
  28.     screen.blit(imgText, (x, y))


  31. def main():
  32.     pygame.init()
  33.     screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
  34.     pygame.display.set_caption('俄罗斯方块')
  35.     
  36.     font1 = pygame.font.SysFont('SimHei', 24) # 黑体24
  37.     font1_width, font1_height = font1.size('得分：') # 字体高度
  38.     font1_height= int(font1_height)
  39.     font_pos_x = SCREEN_WIDTH - INFO_WIDTH + 10 # 右侧信息显示区域字体位置的X坐标
  40.     
  41.     score = 0 # 得分
  42.     removes = 0 # 消除行数
  43.     orispeed = 0.5 # 原始速度
  44.     speed = orispeed # 当前速度

  46.     cur_block = None # 当前下落方块
  47.     cur_pos_x, cur_pos_y = 0, 0
  48.     next_block = None # 下一个方块
  49.     block_color = (20, 128, 200) # 方块颜色
  50.     
  51.     last_drop_time = 0
  52.     
  53.     while True:
  54.         for event in pygame.event.get():
  55.             if event.type == pygame.QUIT:
  56.                 pygame.quit()
  57.                 sys.exit()
  58.             elif event.type == pygame.KEYDOWN:
  59.                 if event.key == pygame.K_RETURN:
  60.                     cur_block = blocks.get_block()
  61.                     next_block = blocks.get_block()
  62.                     cur_pos_x, cur_pos_y = (BLOCK_WIDTH_NUM - cur_block.end_pos.X - 1) // 2, -1 - cur_block.end_pos.Y
  63.                 
  64.                 
  65.         # 填充背景色
  66.         screen.fill(BG_COLOR)
  67.         # 画游戏区域分隔线
  68.         pygame.draw.line(screen, BORDER_COLOR,
  69.                          (SIZE * BLOCK_WIDTH_NUM + BORDER_WIDTH // 2, 0),
  70.                          (SIZE * BLOCK_WIDTH_NUM + BORDER_WIDTH // 2, SCREEN_HEIGHT), BORDER_WIDTH)
  71.               
  72.         # 画网格线 竖线
  73.         for x in range(BLOCK_WIDTH_NUM+1):
  74.             pygame.draw.line(screen, BLACK, (x * SIZE, 0), (x * SIZE, SCREEN_HEIGHT), 1)
  75.         # 画网格线 横线
  76.         for y in range(BLOCK_HEIGHT_NUM+1):
  77.             pygame.draw.line(screen, BLACK, (0, y * SIZE), (BLOCK_WIDTH_NUM * SIZE, y * SIZE), 1)

  79.         
  80.         # 画当前下落方块
  81.         if cur_block:
  82.             for i in range(cur_block.start_pos.Y, cur_block.end_pos.Y + 1):
  83.                 for j in range(cur_block.start_pos.X, cur_block.end_pos.X + 1):
  84.                     if cur_block.template[i][j] != '.':
  85.                         pygame.draw.rect(screen, block_color,
  86.                                          ((cur_pos_x + j) * SIZE, (cur_pos_y + i) * SIZE, SIZE, SIZE),
  87.                                          0)
  88.         cur_drop_time = time.time()
  89.         if cur_block and cur_drop_time - last_drop_time > speed:
  90.             last_drop_time = cur_drop_time
  91.             cur_pos_y += 1
  92.         
  93.         print_text(screen, font1, font_pos_x, 10, f'得分: ')
  94.         print_text(screen, font1, font_pos_x + SIZE, 10 + font1_height + 6, f'{score}')
  95.         print_text(screen, font1, font_pos_x, 20 + (font1_height + 6) * 2, f'行数: ')
  96.         print_text(screen, font1, font_pos_x + SIZE, 20 + (font1_height + 6) * 3, f'{removes}')
  97.         print_text(screen, font1, font_pos_x, 30 + (font1_height + 6) * 4, f'速度: ')
  98.         print_text(screen, font1, font_pos_x + SIZE, 30 + (font1_height + 6) * 5, f'{score // 10000}')
  99.         print_text(screen, font1, font_pos_x, 40 + (font1_height + 6) * 6, f'下一个：')

  101.         if next_block:
  102.             next_block_y = 40 + (font1_height + 6) * 7
  103.             for i in range(next_block.start_pos.Y, next_block.end_pos.Y + 1):
  104.                 for j in range(next_block.start_pos.X, next_block.end_pos.X + 1):
  105.                     if next_block.template[i][j] != '.':
  106.                         pygame.draw.rect(screen, block_color, (font_pos_x + j * SIZE, next_block_y + i * SIZE, SIZE, SIZE), 0)

  108.         
  109.         pygame.display.flip()


  112. if __name__ == '__main__':
  113.     main()
现在运行后， 方块显示出来了， 并且有当前的方块会下落，添加左右按键控制当前方块的左右移动，并考虑到方块不能移出游戏边界及到底要停靠，加上初步的判断条件

点击(此处)折叠或打开

  1. import sys
  2. import pygame
  3. import blocks
  4. import time

  6. SIZE = 30 # 每个小方格大小

  8. BLOCK_HEIGHT_NUM = 20 # 游戏区高度方向方块数量
  9. BLOCK_WIDTH_NUM = 10 # 游戏区宽度方向方块数量

  11. BORDER_WIDTH = 4 # 游戏区边框分割线宽度
  12. BORDER_COLOR = (40, 40, 200) # 游戏区边框分割线颜色

  14. INFO_WIDTH = 160 # 信息区域宽度

  16. BG_COLOR = (60, 60, 60) # 背景色

  18. BLACK = (0, 0, 0) # 网格线颜色
  19. WIDTH = 1 # 网格线宽度

  21. SCREEN_WIDTH = SIZE * BLOCK_WIDTH_NUM + BORDER_WIDTH + INFO_WIDTH # 游戏屏幕的宽
  22. SCREEN_HEIGHT = SIZE * BLOCK_HEIGHT_NUM # 游戏屏幕的高


  25. # 将文字划到画布上指定位置
  26. def print_text(screen, font, x, y, text, fcolor=(255, 255, 255)):
  27.     imgText = font.render(text, True, fcolor)
  28.     screen.blit(imgText, (x, y))


  31. def main():
  32.     pygame.init()
  33.     screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
  34.     pygame.display.set_caption('俄罗斯方块')
  35.     
  36.     font1 = pygame.font.SysFont('SimHei', 24) # 黑体24
  37.     font1_width, font1_height = font1.size('得分：') # 字体高度
  38.     font1_height= int(font1_height)
  39.     font_pos_x = SCREEN_WIDTH - INFO_WIDTH + 10 # 右侧信息显示区域字体位置的X坐标
  40.     
  41.     score = 0 # 得分
  42.     removes = 0 # 消除行数
  43.     orispeed = 0.5 # 原始速度
  44.     speed = orispeed # 当前速度

  46.     cur_block = None # 当前下落方块
  47.     cur_pos_x, cur_pos_y = 0, 0
  48.     next_block = None # 下一个方块
  49.     block_color = (20, 128, 200) # 方块颜色
  50.     
  51.     last_press_time = 0
  52.     last_drop_time = 0
  53.     
  54.     
  55.     def _judge(pos_x, pos_y, block):
  56.         if pos_y + block.end_pos.Y >= BLOCK_HEIGHT_NUM: #不能超越下边界
  57.             return False
  58.         return True

  60.     
  61.     
  62.     while True:
  63.         for event in pygame.event.get():
  64.             if event.type == pygame.QUIT:
  65.                 pygame.quit()
  66.                 sys.exit()
  67.             elif event.type == pygame.KEYDOWN:
  68.                 if event.key == pygame.K_RETURN:
  69.                     cur_block = blocks.get_block()
  70.                     next_block = blocks.get_block()
  71.                     cur_pos_x, cur_pos_y = (BLOCK_WIDTH_NUM - cur_block.end_pos.X - 1) // 2, -1 - cur_block.end_pos.Y
  72.                 
  73.                 
  74.         if event.type == pygame.KEYDOWN:
  75.             if event.key == pygame.K_LEFT:
  76.                 if cur_block and time.time() - last_press_time > 0.1:
  77.                     last_press_time = time.time()
  78.                     if cur_pos_x > - cur_block.start_pos.X:
  79.                         if _judge(cur_pos_x - 1, cur_pos_y, cur_block):
  80.                             cur_pos_x -= 1
  81.             if event.key == pygame.K_RIGHT:
  82.                 if cur_block and time.time() - last_press_time > 0.1:
  83.                     last_press_time = time.time()
  84.                     if cur_pos_x + cur_block.end_pos.X + 1 < BLOCK_WIDTH_NUM:
  85.                         if _judge(cur_pos_x + 1, cur_pos_y, cur_block):
  86.                             cur_pos_x += 1
  87.         # 填充背景色
  88.         screen.fill(BG_COLOR)
  89.         # 画游戏区域分隔线
  90.         pygame.draw.line(screen, BORDER_COLOR,
  91.                          (SIZE * BLOCK_WIDTH_NUM + BORDER_WIDTH // 2, 0),
  92.                          (SIZE * BLOCK_WIDTH_NUM + BORDER_WIDTH // 2, SCREEN_HEIGHT), BORDER_WIDTH)
  93.               
  94.         # 画网格线 竖线
  95.         for x in range(BLOCK_WIDTH_NUM+1):
  96.             pygame.draw.line(screen, BLACK, (x * SIZE, 0), (x * SIZE, SCREEN_HEIGHT), 1)
  97.         # 画网格线 横线
  98.         for y in range(BLOCK_HEIGHT_NUM+1):
  99.             pygame.draw.line(screen, BLACK, (0, y * SIZE), (BLOCK_WIDTH_NUM * SIZE, y * SIZE), 1)

  101.         
  102.         # 画当前下落方块
  103.         if cur_block:
  104.             for i in range(cur_block.start_pos.Y, cur_block.end_pos.Y + 1):
  105.                 for j in range(cur_block.start_pos.X, cur_block.end_pos.X + 1):
  106.                     if cur_block.template[i][j] != '.':
  107.                         pygame.draw.rect(screen, block_color,
  108.                                          ((cur_pos_x + j) * SIZE, (cur_pos_y + i) * SIZE, SIZE, SIZE),
  109.                                          0)
  110.         cur_drop_time = time.time()
  111.         if cur_block and cur_drop_time - last_drop_time > speed:
  112.             if not _judge(cur_pos_x, cur_pos_y + 1, cur_block):
  113.                 pass # 下一个方块在上方显示
  114.             else:
  115.                 last_drop_time = cur_drop_time
  116.                 cur_pos_y += 1
  117.         
  118.         print_text(screen, font1, font_pos_x, 10, f'得分: ')
  119.         print_text(screen, font1, font_pos_x + SIZE, 10 + font1_height + 6, f'{score}')
  120.         print_text(screen, font1, font_pos_x, 20 + (font1_height + 6) * 2, f'行数: ')
  121.         print_text(screen, font1, font_pos_x + SIZE, 20 + (font1_height + 6) * 3, f'{removes}')
  122.         print_text(screen, font1, font_pos_x, 30 + (font1_height + 6) * 4, f'速度: ')
  123.         print_text(screen, font1, font_pos_x + SIZE, 30 + (font1_height + 6) * 5, f'{score // 10000}')
  124.         print_text(screen, font1, font_pos_x, 40 + (font1_height + 6) * 6, f'下一个：')

  126.         if next_block:
  127.             next_block_y = 40 + (font1_height + 6) * 7
  128.             for i in range(next_block.start_pos.Y, next_block.end_pos.Y + 1):
  129.                 for j in range(next_block.start_pos.X, next_block.end_pos.X + 1):
  130.                     if next_block.template[i][j] != '.':
  131.                         pygame.draw.rect(screen, block_color, (font_pos_x + j * SIZE, next_block_y + i * SIZE, SIZE, SIZE), 0)

  133.         
  134.         pygame.display.flip()


  137. if __name__ == '__main__':
  138.     main()
现在运行后如下如所示：

但是现在的情况是， 当前方块下落到最底部时不会继续下落， 但是一直能左右移动，而且还未处理当前方块停靠后的下一个方块下落，这是因为对方块停靠处理方式有待完善，判断方块停靠条件，一是刚开始的时候不能一直下落掉出屏幕底部，而是当已有方块时，当前方块不能和已有方块有重叠的部分

将代码

点击(此处)折叠或打开

  1. pass # 下一个方块在上方显示
改成 

点击(此处)折叠或打开

  1. cur_block = next_block
  2. next_block = blocks.get_block()
  3. cur_pos_x, cur_pos_y = (BLOCK_WIDTH_NUM - cur_block.end_pos.X - 1) // 2, -1 - cur_block.end_pos.Y
可以有下一个方块从上方继续下落， 但是未解决已停靠在最下方的方块显示的问题
新增一个游戏区的坐标变量，再将新方块生成写进一个方法，初步类似下面这样：

点击(此处)折叠或打开

  1. import sys
  2. import pygame
  3. import blocks
  4. import time

  6. SIZE = 30 # 每个小方格大小

  8. BLOCK_HEIGHT_NUM = 20 # 游戏区高度方向方块数量
  9. BLOCK_WIDTH_NUM = 10 # 游戏区宽度方向方块数量

  11. BORDER_WIDTH = 4 # 游戏区边框分割线宽度
  12. BORDER_COLOR = (40, 40, 200) # 游戏区边框分割线颜色

  14. INFO_WIDTH = 160 # 信息区域宽度

  16. BG_COLOR = (60, 60, 60) # 背景色

  18. BLACK = (0, 0, 0) # 网格线颜色
  19. WIDTH = 1 # 网格线宽度

  21. SCREEN_WIDTH = SIZE * BLOCK_WIDTH_NUM + BORDER_WIDTH + INFO_WIDTH # 游戏屏幕的宽
  22. SCREEN_HEIGHT = SIZE * BLOCK_HEIGHT_NUM # 游戏屏幕的高


  25. # 将文字划到画布上指定位置
  26. def print_text(screen, font, x, y, text, fcolor=(255, 255, 255)):
  27.     imgText = font.render(text, True, fcolor)
  28.     screen.blit(imgText, (x, y))


  31. def main():
  32.     pygame.init()
  33.     screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
  34.     pygame.display.set_caption('俄罗斯方块')
  35.     
  36.     font1 = pygame.font.SysFont('SimHei', 24) # 黑体24
  37.     font1_width, font1_height = font1.size('得分：') # 字体高度
  38.     font1_height= int(font1_height)
  39.     font_pos_x = SCREEN_WIDTH - INFO_WIDTH + 10 # 右侧信息显示区域字体位置的X坐标
  40.     
  41.     score = 0 # 得分
  42.     removes = 0 # 消除行数
  43.     orispeed = 0.5 # 原始速度
  44.     speed = orispeed # 当前速度

  46.     game_area = None # 整个游戏区域

  48.     cur_block = None # 当前下落方块
  49.     cur_pos_x, cur_pos_y = 0, 0
  50.     next_block = None # 下一个方块
  51.     block_color = (20, 128, 200) # 方块颜色
  52.     
  53.     last_press_time = 0
  54.     last_drop_time = 0

  56.     game_area = None # 整个游戏区域
  57.     
  58.     def _judge(pos_x, pos_y, block):
  59.         if pos_y + block.end_pos.Y >= BLOCK_HEIGHT_NUM: #不能超越下边界
  60.             return False
  61.         return True


  64.     def _dock():
  65.         nonlocal cur_block, next_block, game_area, cur_pos_x, cur_pos_y
  66.         
  67.         # 记录现有方块
  68.         for _i in range(cur_block.start_pos.Y, cur_block.end_pos.Y + 1):
  69.             for _j in range(cur_block.start_pos.X, cur_block.end_pos.X + 1):
  70.                 if cur_block.template[_i][_j] != '.':
  71.                     game_area[cur_pos_y + _i][cur_pos_x + _j] = '0'
  72.                     
  73.         cur_block = next_block
  74.         next_block = blocks.get_block()
  75.         cur_pos_x, cur_pos_y = (BLOCK_WIDTH_NUM - cur_block.end_pos.X - 1) // 2, -1 - cur_block.end_pos.Y
  76.     
  77.     while True:
  78.         for event in pygame.event.get():
  79.             if event.type == pygame.QUIT:
  80.                 pygame.quit()
  81.                 sys.exit()
  82.             elif event.type == pygame.KEYDOWN:
  83.                 if event.key == pygame.K_RETURN:
  84.                     game_area = [['.'] * BLOCK_WIDTH_NUM for _ in range(BLOCK_HEIGHT_NUM)]
  85.                     cur_block = blocks.get_block()
  86.                     next_block = blocks.get_block()
  87.                     cur_pos_x, cur_pos_y = (BLOCK_WIDTH_NUM - cur_block.end_pos.X - 1) // 2, -1 - cur_block.end_pos.Y
  88.                 
  89.                 
  90.         if event.type == pygame.KEYDOWN:
  91.             if event.key == pygame.K_LEFT:
  92.                 if cur_block and time.time() - last_press_time > 0.1:
  93.                     last_press_time = time.time()
  94.                     if cur_pos_x > - cur_block.start_pos.X:
  95.                         if _judge(cur_pos_x - 1, cur_pos_y, cur_block):
  96.                             cur_pos_x -= 1
  97.             if event.key == pygame.K_RIGHT:
  98.                 if cur_block and time.time() - last_press_time > 0.1:
  99.                     last_press_time = time.time()
  100.                     if cur_pos_x + cur_block.end_pos.X + 1 < BLOCK_WIDTH_NUM:
  101.                         if _judge(cur_pos_x + 1, cur_pos_y, cur_block):
  102.                             cur_pos_x += 1
  103.         # 填充背景色
  104.         screen.fill(BG_COLOR)
  105.         # 画游戏区域分隔线
  106.         pygame.draw.line(screen, BORDER_COLOR,
  107.                          (SIZE * BLOCK_WIDTH_NUM + BORDER_WIDTH // 2, 0),
  108.                          (SIZE * BLOCK_WIDTH_NUM + BORDER_WIDTH // 2, SCREEN_HEIGHT), BORDER_WIDTH)
  109.               
  110.         # 画网格线 竖线
  111.         for x in range(BLOCK_WIDTH_NUM+1):
  112.             pygame.draw.line(screen, BLACK, (x * SIZE, 0), (x * SIZE, SCREEN_HEIGHT), 1)
  113.         # 画网格线 横线
  114.         for y in range(BLOCK_HEIGHT_NUM+1):
  115.             pygame.draw.line(screen, BLACK, (0, y * SIZE), (BLOCK_WIDTH_NUM * SIZE, y * SIZE), 1)


  118.         # 画现有方块
  119.         if game_area:
  120.             for i, row in enumerate(game_area):
  121.                 for j, cell in enumerate(row):
  122.                     if cell != '.':
  123.                         pygame.draw.rect(screen, block_color, (j * SIZE, i * SIZE, SIZE, SIZE), 0)
  124.         
  125.         # 画当前下落方块
  126.         if cur_block:
  127.             for i in range(cur_block.start_pos.Y, cur_block.end_pos.Y + 1):
  128.                 for j in range(cur_block.start_pos.X, cur_block.end_pos.X + 1):
  129.                     if cur_block.template[i][j] != '.':
  130.                         pygame.draw.rect(screen, block_color,
  131.                                          ((cur_pos_x + j) * SIZE, (cur_pos_y + i) * SIZE, SIZE, SIZE),
  132.                                          0)
  133.         cur_drop_time = time.time()
  134.         if cur_block and cur_drop_time - last_drop_time > speed:
  135.             if not _judge(cur_pos_x, cur_pos_y + 1, cur_block):
  136.                 _dock() # 下一个方块在上方显示
  137.             else:
  138.                 last_drop_time = cur_drop_time
  139.                 cur_pos_y += 1
  140.         
  141.         print_text(screen, font1, font_pos_x, 10, f'得分: ')
  142.         print_text(screen, font1, font_pos_x + SIZE, 10 + font1_height + 6, f'{score}')
  143.         print_text(screen, font1, font_pos_x, 20 + (font1_height + 6) * 2, f'行数: ')
  144.         print_text(screen, font1, font_pos_x + SIZE, 20 + (font1_height + 6) * 3, f'{removes}')
  145.         print_text(screen, font1, font_pos_x, 30 + (font1_height + 6) * 4, f'速度: ')
  146.         print_text(screen, font1, font_pos_x + SIZE, 30 + (font1_height + 6) * 5, f'{score // 10000}')
  147.         print_text(screen, font1, font_pos_x, 40 + (font1_height + 6) * 6, f'下一个：')

  149.         if next_block:
  150.             next_block_y = 40 + (font1_height + 6) * 7
  151.             for i in range(next_block.start_pos.Y, next_block.end_pos.Y + 1):
  152.                 for j in range(next_block.start_pos.X, next_block.end_pos.X + 1):
  153.                     if next_block.template[i][j] != '.':
  154.                         pygame.draw.rect(screen, block_color, (font_pos_x + j * SIZE, next_block_y + i * SIZE, SIZE, SIZE), 0)

  156.         
  157.         pygame.display.flip()


  160. if __name__ == '__main__':
  161.     main()
现在可以保存下现有的停靠方块了

但是判断停靠的方法还有问题， 下落方块和已停靠的方块不能重叠穿插，故修正_judge方法：

点击(此处)折叠或打开

  1. def _judge(pos_x, pos_y, block):
  2.         nonlocal game_area
  3.         if pos_y + block.end_pos.Y >= BLOCK_HEIGHT_NUM: #不能超越下边界
  4.             return False
  5.         for _i in range(block.start_pos.Y, block.end_pos.Y + 1): # 方块模板不能与现有方块重叠
  6.             for _j in range(block.start_pos.X, block.end_pos.X + 1):
  7.                 if pos_y + _i >= 0 and block.template[_i][_j] != '.' and game_area[pos_y + _i][pos_x + _j] != '.':
  8.                     return False
  9.         return True
此时已修正上面的问题

但会发现当长度方向上堆满方块后， 程序还一直在运行，此时应该结束游戏，就是不应该再生产新的方块了，故判断放在生成新方块的方法里，这你可以给生成新方块方法一个返回值，或者增加一个全局变量来告诉主循环，此时应退出循环结束程序了

点击(此处)折叠或打开

  1. import sys
  2. import pygame
  3. import blocks
  4. import time

  6. SIZE = 30 # 每个小方格大小

  8. BLOCK_HEIGHT_NUM = 20 # 游戏区高度方向方块数量
  9. BLOCK_WIDTH_NUM = 10 # 游戏区宽度方向方块数量

  11. BORDER_WIDTH = 4 # 游戏区边框分割线宽度
  12. BORDER_COLOR = (40, 40, 200) # 游戏区边框分割线颜色

  14. INFO_WIDTH = 160 # 信息区域宽度

  16. BG_COLOR = (60, 60, 60) # 背景色

  18. BLACK = (0, 0, 0) # 网格线颜色
  19. WIDTH = 1 # 网格线宽度

  21. SCREEN_WIDTH = SIZE * BLOCK_WIDTH_NUM + BORDER_WIDTH + INFO_WIDTH # 游戏屏幕的宽
  22. SCREEN_HEIGHT = SIZE * BLOCK_HEIGHT_NUM # 游戏屏幕的高


  25. # 将文字划到画布上指定位置
  26. def print_text(screen, font, x, y, text, fcolor=(255, 255, 255)):
  27.     imgText = font.render(text, True, fcolor)
  28.     screen.blit(imgText, (x, y))


  31. def main():
  32.     pygame.init()
  33.     screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
  34.     pygame.display.set_caption('俄罗斯方块')
  35.     
  36.     font1 = pygame.font.SysFont('SimHei', 24) # 黑体24
  37.     font1_width, font1_height = font1.size('得分：') # 字体高度
  38.     font1_height= int(font1_height)
  39.     font_pos_x = SCREEN_WIDTH - INFO_WIDTH + 10 # 右侧信息显示区域字体位置的X坐标
  40.     
  41.     score = 0 # 得分
  42.     removes = 0 # 消除行数
  43.     orispeed = 0.5 # 原始速度
  44.     speed = orispeed # 当前速度

  46.     game_area = None # 整个游戏区域

  48.     cur_block = None # 当前下落方块
  49.     cur_pos_x, cur_pos_y = 0, 0
  50.     next_block = None # 下一个方块
  51.     block_color = (20, 128, 200) # 方块颜色
  52.     
  53.     last_press_time = 0
  54.     last_drop_time = 0

  56.     game_area = None # 整个游戏区域
  57.     
  58.     game_over = True
  59.     
  60.     def _judge(pos_x, pos_y, block):
  61.         nonlocal game_area
  62.         if pos_y + block.end_pos.Y >= BLOCK_HEIGHT_NUM: #不能超越下边界
  63.             return False
  64.         for _i in range(block.start_pos.Y, block.end_pos.Y + 1): # 方块模板不能与现有方块重叠
  65.             for _j in range(block.start_pos.X, block.end_pos.X + 1):
  66.                 if pos_y + _i >= 0 and block.template[_i][_j] != '.' and game_area[pos_y + _i][pos_x + _j] != '.':
  67.                     return False
  68.         return True


  71.     def _dock():
  72.         nonlocal cur_block, next_block, game_area, cur_pos_x, cur_pos_y, game_over
  73.         
  74.         # 记录现有方块
  75.         for _i in range(cur_block.start_pos.Y, cur_block.end_pos.Y + 1):
  76.             for _j in range(cur_block.start_pos.X, cur_block.end_pos.X + 1):
  77.                 if cur_block.template[_i][_j] != '.':
  78.                     game_area[cur_pos_y + _i][cur_pos_x + _j] = '0'
  79.                     
  80.         if cur_pos_y + cur_block.start_pos.Y <= 0:
  81.             game_over = True
  82.                     
  83.         cur_block = next_block
  84.         next_block = blocks.get_block()
  85.         cur_pos_x, cur_pos_y = (BLOCK_WIDTH_NUM - cur_block.end_pos.X - 1) // 2, -1 - cur_block.end_pos.Y
  86.     
  87.     while True:
  88.         for event in pygame.event.get():
  89.             if event.type == pygame.QUIT:
  90.                 pygame.quit()
  91.                 sys.exit()
  92.             elif event.type == pygame.KEYDOWN:
  93.                 if event.key == pygame.K_RETURN:
  94.                     if game_over:
  95.                         game_over = False
  96.                         game_area = [['.'] * BLOCK_WIDTH_NUM for _ in range(BLOCK_HEIGHT_NUM)]
  97.                         cur_block = blocks.get_block()
  98.                         next_block = blocks.get_block()
  99.                         cur_pos_x, cur_pos_y = (BLOCK_WIDTH_NUM - cur_block.end_pos.X - 1) // 2, -1 - cur_block.end_pos.Y
  100.                 
  101.                 
  102.         if event.type == pygame.KEYDOWN:
  103.             if event.key == pygame.K_LEFT:
  104.                 if cur_block and time.time() - last_press_time > 0.1:
  105.                     last_press_time = time.time()
  106.                     if cur_pos_x > - cur_block.start_pos.X:
  107.                         if _judge(cur_pos_x - 1, cur_pos_y, cur_block):
  108.                             cur_pos_x -= 1
  109.             if event.key == pygame.K_RIGHT:
  110.                 if cur_block and time.time() - last_press_time > 0.1:
  111.                     last_press_time = time.time()
  112.                     if cur_pos_x + cur_block.end_pos.X + 1 < BLOCK_WIDTH_NUM:
  113.                         if _judge(cur_pos_x + 1, cur_pos_y, cur_block):
  114.                             cur_pos_x += 1
  115.         # 填充背景色
  116.         screen.fill(BG_COLOR)
  117.         # 画游戏区域分隔线
  118.         pygame.draw.line(screen, BORDER_COLOR,
  119.                          (SIZE * BLOCK_WIDTH_NUM + BORDER_WIDTH // 2, 0),
  120.                          (SIZE * BLOCK_WIDTH_NUM + BORDER_WIDTH // 2, SCREEN_HEIGHT), BORDER_WIDTH)
  121.               
  122.         # 画网格线 竖线
  123.         for x in range(BLOCK_WIDTH_NUM+1):
  124.             pygame.draw.line(screen, BLACK, (x * SIZE, 0), (x * SIZE, SCREEN_HEIGHT), 1)
  125.         # 画网格线 横线
  126.         for y in range(BLOCK_HEIGHT_NUM+1):
  127.             pygame.draw.line(screen, BLACK, (0, y * SIZE), (BLOCK_WIDTH_NUM * SIZE, y * SIZE), 1)


  130.         # 画现有方块
  131.         if game_area:
  132.             for i, row in enumerate(game_area):
  133.                 for j, cell in enumerate(row):
  134.                     if cell != '.':
  135.                         pygame.draw.rect(screen, block_color, (j * SIZE, i * SIZE, SIZE, SIZE), 0)
  136.         
  137.         # 画当前下落方块
  138.         if cur_block:
  139.             for i in range(cur_block.start_pos.Y, cur_block.end_pos.Y + 1):
  140.                 for j in range(cur_block.start_pos.X, cur_block.end_pos.X + 1):
  141.                     if cur_block.template[i][j] != '.':
  142.                         pygame.draw.rect(screen, block_color,
  143.                                          ((cur_pos_x + j) * SIZE, (cur_pos_y + i) * SIZE, SIZE, SIZE),
  144.                                          0)
  145.         if not game_over:
  146.             cur_drop_time = time.time()
  147.             if cur_block and cur_drop_time - last_drop_time > speed:
  148.                 if not _judge(cur_pos_x, cur_pos_y + 1, cur_block):
  149.                     _dock() # 下一个方块在上方显示
  150.                 else:
  151.                     last_drop_time = cur_drop_time
  152.                     cur_pos_y += 1
  153.         
  154.         print_text(screen, font1, font_pos_x, 10, f'得分: ')
  155.         print_text(screen, font1, font_pos_x + SIZE, 10 + font1_height + 6, f'{score}')
  156.         print_text(screen, font1, font_pos_x, 20 + (font1_height + 6) * 2, f'行数: ')
  157.         print_text(screen, font1, font_pos_x + SIZE, 20 + (font1_height + 6) * 3, f'{removes}')
  158.         print_text(screen, font1, font_pos_x, 30 + (font1_height + 6) * 4, f'速度: ')
  159.         print_text(screen, font1, font_pos_x + SIZE, 30 + (font1_height + 6) * 5, f'{score // 10000}')
  160.         print_text(screen, font1, font_pos_x, 40 + (font1_height + 6) * 6, f'下一个：')

  162.         if next_block:
  163.             next_block_y = 40 + (font1_height + 6) * 7
  164.             for i in range(next_block.start_pos.Y, next_block.end_pos.Y + 1):
  165.                 for j in range(next_block.start_pos.X, next_block.end_pos.X + 1):
  166.                     if next_block.template[i][j] != '.':
  167.                         pygame.draw.rect(screen, block_color, (font_pos_x + j * SIZE, next_block_y + i * SIZE, SIZE, SIZE), 0)

  169.         
  170.         pygame.display.flip()


  173. if __name__ == '__main__':
  174.     main()
现在的这个版本，一些基本的性能：生成方块， 方块左右移动，方块的停靠，长度方向上堆满游戏结束等已经完成
现在加上上键是改变方块形状的功能， 只需在event的for循环中对按下按键事件增加一个上键按钮的判断就好了

点击(此处)折叠或打开

  1. elif event.key in (pygame.K_w, pygame.K_UP):
  2.      if 0 <= cur_pos_x <= BLOCK_WIDTH_NUM - len(cur_block.template[0]):
  3.           _next_block = blocks.get_next_block(cur_block)
  4.           if _judge(cur_pos_x, cur_pos_y, _next_block):
  5.                 cur_block = _next_block
接下来就是对满行的方格进行消除，优化_dock方法， 在判断完垂直方向还有空间游戏未结束后，判断是否有满行的方格可以消除

点击(此处)折叠或打开

  1.         else:
  2.             # 计算消除
  3.             remove_idxs = []
  4.             for _i in range(cur_block.start_pos.Y, cur_block.end_pos.Y + 1):
  5.                 if all(_x == '0' for _x in game_area[cur_pos_y + _i]):
  6.                     remove_idxs.append(cur_pos_y + _i)
  7.             if remove_idxs:
  8.                 # 消除
  9.                 _i = _j = remove_idxs[-1]
  10.                 while _i >= 0:
  11.                     while _j in remove_idxs:
  12.                         _j -= 1
  13.                     if _j < 0:
  14.                         game_area[_i] = ['.'] * BLOCK_WIDTH
  15.                     else:
  16.                         game_area[_i] = game_area[_j]
  17.                     _i -= 1
  18.                     _j -= 1
到这里基本能玩起来了， 最后做细节优化，增加下键可以加快下落速度，增加暂停功能，增加直落功能， 增加信息面板的一些信息等等，下面是最终版本

点击(此处)折叠或打开

  1. import sys
  2. import pygame
  3. import blocks
  4. import time

  6. SIZE = 30 # 每个小方格大小

  8. BLOCK_HEIGHT_NUM = 20 # 游戏区高度方向方块数量
  9. BLOCK_WIDTH_NUM = 10 # 游戏区宽度方向方块数量

  11. BORDER_WIDTH = 4 # 游戏区边框分割线宽度
  12. BORDER_COLOR = (40, 40, 200) # 游戏区边框分割线颜色

  14. INFO_WIDTH = 160 # 信息区域宽度

  16. BG_COLOR = (60, 60, 60) # 背景色

  18. BLACK = (0, 0, 0) # 网格线颜色
  19. WIDTH = 1 # 网格线宽度

  21. SCREEN_WIDTH = SIZE * BLOCK_WIDTH_NUM + BORDER_WIDTH + INFO_WIDTH # 游戏屏幕的宽
  22. SCREEN_HEIGHT = SIZE * BLOCK_HEIGHT_NUM # 游戏屏幕的高


  25. # 将文字划到画布上指定位置
  26. def print_text(screen, font, x, y, text, fcolor=(255, 255, 255)):
  27.     imgText = font.render(text, True, fcolor)
  28.     screen.blit(imgText, (x, y))


  31. def main():
  32.     pygame.init()
  33.     screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
  34.     pygame.display.set_caption('俄罗斯方块')
  35.     
  36.     font1 = pygame.font.SysFont('SimHei', 24) # 黑体24
  37.     font1_width, font1_height = font1.size('得分：') # 字体高度
  38.     font1_height= int(font1_height)
  39.     font_pos_x = SCREEN_WIDTH - INFO_WIDTH + 10 # 右侧信息显示区域字体位置的X坐标
  40.     
  41.     fontgg = pygame.font.Font(None, 72)
  42.     gameover_size = fontgg.size('GAME OVER')
  43.     
  44.     score = 0 # 得分
  45.     removes = 0 # 消除行数
  46.     orispeed = 0.5 # 原始速度
  47.     speed = orispeed # 当前速度

  49.     game_area = None # 整个游戏区域

  51.     cur_block = None # 当前下落方块
  52.     cur_pos_x, cur_pos_y = 0, 0
  53.     next_block = None # 下一个方块
  54.     block_color = (20, 128, 200) # 方块颜色
  55.     
  56.     last_press_time = 0
  57.     last_drop_time = 0

  59.     game_area = None # 整个游戏区域
  60.     
  61.     game_over = True
  62.     
  63.     pause = False # 暂停
  64.     start = False # 是否开始，开始游戏后game_over为True游戏就是真正结束
  65.     last_drop_time = None # 上次下落时间
  66.     last_press_time = None # 上次按键时间
  67.     last_key_down = False
  68.     
  69.     def _judge(pos_x, pos_y, block):
  70.         nonlocal game_area
  71.         if pos_y + block.end_pos.Y >= BLOCK_HEIGHT_NUM: #不能超越下边界
  72.             return False
  73.         for _i in range(block.start_pos.Y, block.end_pos.Y + 1): # 方块模板不能与现有方块重叠
  74.             for _j in range(block.start_pos.X, block.end_pos.X + 1):
  75.                 if pos_y + _i >= 0 and block.template[_i][_j] != '.' and game_area[pos_y + _i][pos_x + _j] != '.':
  76.                     return False
  77.         return True


  80.     def _dock():
  81.         nonlocal cur_block, next_block, game_area, cur_pos_x, cur_pos_y, game_over, score, speed, removes
  82.         
  83.         # 记录现有方块
  84.         for _i in range(cur_block.start_pos.Y, cur_block.end_pos.Y + 1):
  85.             for _j in range(cur_block.start_pos.X, cur_block.end_pos.X + 1):
  86.                 if cur_block.template[_i][_j] != '.':
  87.                     game_area[cur_pos_y + _i][cur_pos_x + _j] = '0'
  88.                     
  89.         if cur_pos_y + cur_block.start_pos.Y <= 0:
  90.             game_over = True
  91.         else:
  92.             # 计算消除
  93.             remove_idxs = []
  94.             for _i in range(cur_block.start_pos.Y, cur_block.end_pos.Y + 1):
  95.                 if all(_x == '0' for _x in game_area[cur_pos_y + _i]):
  96.                     remove_idxs.append(cur_pos_y + _i)
  97.             if remove_idxs:
  98.                 # 计算得分
  99.                 remove_count = len(remove_idxs)
  100.                 removes += remove_count;
  101.                 if remove_count == 1:
  102.                     score += 100
  103.                 elif remove_count == 2:
  104.                     score += 300
  105.                 elif remove_count == 3:
  106.                     score += 700
  107.                 elif remove_count == 4:
  108.                     score += 1500
  109.                 speed = orispeed - 0.03 * (score // 10000)
  110.                 # 消除
  111.                 _i = _j = remove_idxs[-1]
  112.                 while _i >= 0:
  113.                     while _j in remove_idxs:
  114.                         _j -= 1
  115.                     if _j < 0:
  116.                         game_area[_i] = ['.'] * BLOCK_WIDTH_NUM
  117.                     else:
  118.                         game_area[_i] = game_area[_j]
  119.                     _i -= 1
  120.                     _j -= 1
  121.                     
  122.         cur_block = next_block
  123.         next_block = blocks.get_block()
  124.         cur_pos_x, cur_pos_y = (BLOCK_WIDTH_NUM - cur_block.end_pos.X - 1) // 2, -1 - cur_block.end_pos.Y
  125.     
  126.     while True:
  127.         for event in pygame.event.get():
  128.             if event.type == pygame.QUIT:
  129.                 pygame.quit()
  130.                 sys.exit()
  131.             elif event.type == pygame.KEYDOWN:
  132.                 if event.key == pygame.K_RETURN:
  133.                     last_key_down = False
  134.                     if game_over:
  135.                         game_over = False
  136.                         start = True
  137.                         score = 0
  138.                         speed = orispeed
  139.                         removes = 0
  140.                         last_drop_time = time.time()
  141.                         last_press_time = time.time()
  142.                         game_area = [['.'] * BLOCK_WIDTH_NUM for _ in range(BLOCK_HEIGHT_NUM)]
  143.                         cur_block = blocks.get_block()
  144.                         next_block = blocks.get_block()
  145.                         cur_pos_x, cur_pos_y = (BLOCK_WIDTH_NUM - cur_block.end_pos.X - 1) // 2, -1 - cur_block.end_pos.Y
  146.                     else:
  147.                         pause = not pause
  148.                 elif event.key in (pygame.K_w, pygame.K_UP):
  149.                     last_key_down = False
  150.                     if 0 <= cur_pos_x <= BLOCK_WIDTH_NUM - len(cur_block.template[0]):
  151.                         _next_block = blocks.get_next_block(cur_block)
  152.                         if _judge(cur_pos_x, cur_pos_y, _next_block):
  153.                             cur_block = _next_block
  154.                 elif event.key == pygame.K_SPACE:
  155.                     if not last_key_down or time.time() - last_press_time > 0.2 : # 连续两字短时间按键触发
  156.                         last_press_time = time.time()
  157.                         last_key_down = True
  158.                         while _judge(cur_pos_x, cur_pos_y + 1, cur_block):
  159.                             cur_pos_y += 1
  160.                             last_drop_time = time.time()
  161.                         else:
  162.                             _dock()
  163.                             
  164.         if event.type == pygame.KEYDOWN:
  165.             if event.key == pygame.K_LEFT:
  166.                 last_key_down = False
  167.                 if not game_over and not pause:
  168.                     if time.time() - last_press_time > 0.1:
  169.                         last_press_time = time.time()
  170.                         if cur_pos_x > - cur_block.start_pos.X:
  171.                             if _judge(cur_pos_x - 1, cur_pos_y, cur_block):
  172.                                 cur_pos_x -= 1
  173.             if event.key == pygame.K_RIGHT:
  174.                 last_key_down = False
  175.                 if not game_over and not pause:
  176.                     if time.time() - last_press_time > 0.1:
  177.                         last_press_time = time.time()
  178.                         if cur_pos_x + cur_block.end_pos.X + 1 < BLOCK_WIDTH_NUM:
  179.                             if _judge(cur_pos_x + 1, cur_pos_y, cur_block):
  180.                                 cur_pos_x += 1
  181.             if event.key == pygame.K_DOWN:
  182.                 last_key_down = False
  183.                 if not game_over and not pause:
  184.                     if time.time() - last_press_time > 0.1 :
  185.                         last_press_time = time.time()
  186.                         if not _judge(cur_pos_x, cur_pos_y + 1, cur_block):
  187.                             _dock()
  188.                         else:
  189.                             last_drop_time = time.time()
  190.                             cur_pos_y += 1
  191.         # 填充背景色
  192.         screen.fill(BG_COLOR)
  193.         # 画游戏区域分隔线
  194.         pygame.draw.line(screen, BORDER_COLOR,
  195.                          (SIZE * BLOCK_WIDTH_NUM + BORDER_WIDTH // 2, 0),
  196.                          (SIZE * BLOCK_WIDTH_NUM + BORDER_WIDTH // 2, SCREEN_HEIGHT), BORDER_WIDTH)

  198.         # 画现有方块
  199.         if game_area:
  200.             for i, row in enumerate(game_area):
  201.                 for j, cell in enumerate(row):
  202.                     if cell != '.':
  203.                         pygame.draw.rect(screen, block_color, (j * SIZE, i * SIZE, SIZE, SIZE), 0)
  204.                         
  205.         # 画网格线 竖线
  206.         for x in range(BLOCK_WIDTH_NUM+1):
  207.             pygame.draw.line(screen, BLACK, (x * SIZE, 0), (x * SIZE, SCREEN_HEIGHT), 1)
  208.         # 画网格线 横线
  209.         for y in range(BLOCK_HEIGHT_NUM+1):
  210.             pygame.draw.line(screen, BLACK, (0, y * SIZE), (BLOCK_WIDTH_NUM * SIZE, y * SIZE), 1)
  211.         
  212.         # 画当前下落方块
  213.         if cur_block:
  214.             for i in range(cur_block.start_pos.Y, cur_block.end_pos.Y + 1):
  215.                 for j in range(cur_block.start_pos.X, cur_block.end_pos.X + 1):
  216.                     if cur_block.template[i][j] != '.':
  217.                         pygame.draw.rect(screen, block_color,
  218.                                          ((cur_pos_x + j) * SIZE, (cur_pos_y + i) * SIZE, SIZE, SIZE),
  219.                                          0)
  220.         if not game_over:
  221.             cur_drop_time = time.time()
  222.             if cur_drop_time - last_drop_time > speed:
  223.                 if not pause:
  224.                     if not _judge(cur_pos_x, cur_pos_y + 1, cur_block):
  225.                         _dock()
  226.                     else:
  227.                         last_drop_time = cur_drop_time
  228.                         cur_pos_y += 1
  229.         else:
  230.             if start:
  231.                 print_text(screen, fontgg,
  232.                            (SCREEN_WIDTH - gameover_size[0]) // 2, (SCREEN_HEIGHT - gameover_size[1]) // 2,
  233.                            'GAME OVER', (200, 30, 30))
  234.         
  235.         print_text(screen, font1, font_pos_x, 10, f'得分: ')
  236.         print_text(screen, font1, font_pos_x + SIZE, 10 + font1_height + 6, f'{score}')
  237.         print_text(screen, font1, font_pos_x, 20 + (font1_height + 6) * 2, f'行数: ')
  238.         print_text(screen, font1, font_pos_x + SIZE, 20 + (font1_height + 6) * 3, f'{removes}')
  239.         print_text(screen, font1, font_pos_x, 30 + (font1_height + 6) * 4, f'速度: ')
  240.         print_text(screen, font1, font_pos_x + SIZE, 30 + (font1_height + 6) * 5, f'{score // 10000}')
  241.         print_text(screen, font1, font_pos_x, 40 + (font1_height + 6) * 6, f'下一个：')

  243.         if next_block:
  244.             next_block_y = 40 + (font1_height + 6) * 7
  245.             for i in range(next_block.start_pos.Y, next_block.end_pos.Y + 1):
  246.                 for j in range(next_block.start_pos.X, next_block.end_pos.X + 1):
  247.                     if next_block.template[i][j] != '.':
  248.                         pygame.draw.rect(screen, block_color, (font_pos_x + j * SIZE, next_block_y + i * SIZE, SIZE, SIZE), 0)

  250.         
  251.         pygame.display.flip()


  254. if __name__ == '__main__':
  255.     main()








阅读(1695) | 评论(0) | 转发(0) |
2

上一篇：awk 做全排列

下一篇：没有了

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6