原文： https://pythonspot.com/snake-with-pygame/

Pygame 贪食蛇 - 图1

在本教程中，您将学习如何制作蛇游戏。 该游戏是一款街机游戏，逻辑非常简单，这就是为什么它是演示如何使用 Pygame 构建游戏的理想示例的原因。

玩家被表示为蛇，如果它吃了一个苹果，蛇就会成长。 游戏的目的是在不撞到自己的情况下尽可能多地吃苹果。 在游戏的早期阶段这很容易，但是随着蛇的长度增加，难度变得越来越大。

入门：基本结构和事件处理。

我们定义了一个Player类，它可以保持玩家在屏幕上的位置及其移动的速度。 另外，我们定义Player实例可以执行的动作（动作）：

  1. class Player:
  2.     x = 10
  3.     y = 10
  4.     speed = 1
  6.     def moveRight(self):
  7.         self.x = self.x + self.speed
  9.     def moveLeft(self):
  10.         self.x = self.x - self.speed
  12.     def moveUp(self):
  13.         self.y = self.y - self.speed
  15.     def moveDown(self):
  16.         self.y = self.y + self.speed

可以使用移动方法创建玩家对象，并可以修改变量。
我们将这些方法链接到事件。 在 Pygame 中，我们可以使用以下代码获得非阻塞式键盘输入：

  1. pygame.event.pump()
  2. keys = pygame.key.get_pressed() 
  4. if (keys[K_RIGHT]):
  5.    print "Right arrow pressed."

完整的代码使我们能够在屏幕上移动玩家：

  1. from pygame.locals import *
  2. import pygame
  4. class Player:
  5.     x = 10
  6.     y = 10
  7.     speed = 1
  9.     def moveRight(self):
  10.         self.x = self.x + self.speed
  12.     def moveLeft(self):
  13.         self.x = self.x - self.speed
  15.     def moveUp(self):
  16.         self.y = self.y - self.speed
  18.     def moveDown(self):
  19.         self.y = self.y + self.speed
  21. class App:
  23.     windowWidth = 800
  24.     windowHeight = 600
  25.     player = 0
  27.     def __init__(self):
  28.         self._running = True
  29.         self._display_surf = None
  30.         self._image_surf = None
  31.         self.player = Player() 
  33.     def on_init(self):
  34.         pygame.init()
  35.         self._display_surf = pygame.display.set_mode((self.windowWidth,self.windowHeight), pygame.HWSURFACE)
  37.         pygame.display.set_caption('Pygame pythonspot.com example')
  38.         self._running = True
  39.         self._image_surf = pygame.image.load("pygame.png").convert()
  41.     def on_event(self, event):
  42.         if event.type == QUIT:
  43.             self._running = False
  45.     def on_loop(self):
  46.         pass
  48.     def on_render(self):
  49.         self._display_surf.fill((0,0,0))
  50.         self._display_surf.blit(self._image_surf,(self.player.x,self.player.y))
  51.         pygame.display.flip()
  53.     def on_cleanup(self):
  54.         pygame.quit()
  56.     def on_execute(self):
  57.         if self.on_init() == False:
  58.             self._running = False
  60.         while( self._running ):
  61.             pygame.event.pump()
  62.             keys = pygame.key.get_pressed() 
  64.             if (keys[K_RIGHT]):
  65.                 self.player.moveRight()
  67.             if (keys[K_LEFT]):
  68.                 self.player.moveLeft()
  70.             if (keys[K_UP]):
  71.                 self.player.moveUp()
  73.             if (keys[K_DOWN]):
  74.                 self.player.moveDown()
  76.             if (keys[K_ESCAPE]):
  77.                 self._running = False
  79.             self.on_loop()
  80.             self.on_render()
  81.         self.on_cleanup()
  83. if __name__ == "__main__" :
  84.     theApp = App()
  85.     theApp.on_execute()

现在，您可以使用箭头键在屏幕上移动该块。

Pygame 贪食蛇 - 图2

pygame 的例子。在屏幕上移动块

构建玩家（蛇）

玩家控制具有初始长度的蛇。 按下箭头键时，这条蛇总是在移动并改变其移动方向。 为此，更新玩家类：

  1. class Player:
  2.     x = 0
  3.     y = 0
  4.     speed = 32
  5.     direction = 0
  7.     def update(self):
  8.         if self.direction == 0:
  9.             self.x = self.x + self.speed
  10.         if self.direction == 1:
  11.             self.x = self.x - self.speed
  12.         if self.direction == 2:
  13.             self.y = self.y - self.speed
  14.         if self.direction == 3:
  15.             self.y = self.y + self.speed
  17.     def moveRight(self):
  18.         self.direction = 0
  20.     def moveLeft(self):
  21.         self.direction = 1
  23.     def moveUp(self):
  24.         self.direction = 2
  26.     def moveDown(self):
  27.         self.direction = 3

并且不要忘记增加游戏循环的延迟。

  1. import time
  2. ...
  3. time.sleep (100.0 / 1000.0);

它开始更多地起蛇的作用，但是还没有基本长度。 我们跟踪蛇的旧位置并移动蛇的头部。 我们还将绘制方法移到了蛇中。 复制代码，您将得到一条动静的蛇：

  1. from pygame.locals import *
  2. import pygame
  3. import time
  5. class Player:
  6.     x = []
  7.     y = []
  8.     step = 44
  9.     direction = 0
  10.     length = 3
  12.     updateCountMax = 2
  13.     updateCount = 0
  15.     def __init__(self, length):
  16.        self.length = length
  17.        for i in range(0,length):
  18.            self.x.append(0)
  19.            self.y.append(0)
  21.     def update(self):
  23.         self.updateCount = self.updateCount + 1
  24.         if self.updateCount > self.updateCountMax:
  26.             # update previous positions
  27.             for i in range(self.length-1,0,-1):
  28.                 print "self.x[" + str(i) + "] = self.x[" + str(i-1) + "]"
  29.                 self.x[i] = self.x[i-1]
  30.                 self.y[i] = self.y[i-1]
  32.             # update position of head of snake
  33.             if self.direction == 0:
  34.                 self.x[0] = self.x[0] + self.step
  35.             if self.direction == 1:
  36.                 self.x[0] = self.x[0] - self.step
  37.             if self.direction == 2:
  38.                 self.y[0] = self.y[0] - self.step
  39.             if self.direction == 3:
  40.                 self.y[0] = self.y[0] + self.step
  42.             self.updateCount = 0
  44.     def moveRight(self):
  45.         self.direction = 0
  47.     def moveLeft(self):
  48.         self.direction = 1
  50.     def moveUp(self):
  51.         self.direction = 2
  53.     def moveDown(self):
  54.         self.direction = 3 
  56.     def draw(self, surface, image):
  57.         for i in range(0,self.length):
  58.             surface.blit(image,(self.x[i],self.y[i])) 
  60. class App:
  62.     windowWidth = 800
  63.     windowHeight = 600
  64.     player = 0
  66.     def __init__(self):
  67.         self._running = True
  68.         self._display_surf = None
  69.         self._image_surf = None
  70.         self.player = Player(10) 
  72.     def on_init(self):
  73.         pygame.init()
  74.         self._display_surf = pygame.display.set_mode((self.windowWidth,self.windowHeight), pygame.HWSURFACE)
  76.         pygame.display.set_caption('Pygame pythonspot.com example')
  77.         self._running = True
  78.         self._image_surf = pygame.image.load("pygame.png").convert()
  80.     def on_event(self, event):
  81.         if event.type == QUIT:
  82.             self._running = False
  84.     def on_loop(self):
  85.         self.player.update()
  86.         pass
  88.     def on_render(self):
  89.         self._display_surf.fill((0,0,0))
  90.         self.player.draw(self._display_surf, self._image_surf)
  91.         pygame.display.flip()
  93.     def on_cleanup(self):
  94.         pygame.quit()
  96.     def on_execute(self):
  97.         if self.on_init() == False:
  98.             self._running = False
  100.         while( self._running ):
  101.             pygame.event.pump()
  102.             keys = pygame.key.get_pressed() 
  104.             if (keys[K_RIGHT]):
  105.                 self.player.moveRight()
  107.             if (keys[K_LEFT]):
  108.                 self.player.moveLeft()
  110.             if (keys[K_UP]):
  111.                 self.player.moveUp()
  113.             if (keys[K_DOWN]):
  114.                 self.player.moveDown()
  116.             if (keys[K_ESCAPE]):
  117.                 self._running = False
  118.             self.on_loop()
  119.             self.on_render()
  121.             time.sleep (50.0 / 1000.0);
  122.         self.on_cleanup()
  124. if __name__ == "__main__" :
  125.     theApp = App()
  126.     theApp.on_execute()

结果：

Pygame 贪食蛇 - 图3

python 贪食蛇

游戏逻辑

蛇游戏有一些规则：

  • 如果蛇吃了一个苹果，那么苹果会移动到新位置。

  • 如果蛇吃了一个苹果，蛇的长度就会增加。

  • 如果一条蛇自行倒下，请继续游戏。

我们首先创建一个新类，使我们能够创建苹果：

  1. class Apple:
  2.     x = 0
  3.     y = 0
  4.     step = 44
  6.     def __init__(self,x,y):
  7.         self.x = x * self.step
  8.         self.y = y * self.step
  10.     def draw(self, surface, image):
  11.         surface.blit(image,(self.x, self.y))

为简单起见，我们将苹果显示为绿色立方体。 我们有这个基本代码，但是除了移动蛇和显示苹果外，它没有做太多的事情：

  1. from pygame.locals import *
  2. import pygame
  3. import time
  5. class Apple:
  6.     x = 0
  7.     y = 0
  8.     step = 44
  10.     def __init__(self,x,y):
  11.         self.x = x * self.step
  12.         self.y = y * self.step
  14.     def draw(self, surface, image):
  15.         surface.blit(image,(self.x, self.y)) 
  17. class Player:
  18.     x = []
  19.     y = []
  20.     step = 44
  21.     direction = 0
  22.     length = 3
  24.     updateCountMax = 2
  25.     updateCount = 0
  27.     def __init__(self, length):
  28.        self.length = length
  29.        for i in range(0,length):
  30.            self.x.append(0)
  31.            self.y.append(0)
  33.     def update(self):
  35.         self.updateCount = self.updateCount + 1
  36.         if self.updateCount > self.updateCountMax:
  38.             # update previous positions
  39.             for i in range(self.length-1,0,-1):
  40.                 print "self.x[" + str(i) + "] = self.x[" + str(i-1) + "]"
  41.                 self.x[i] = self.x[i-1]
  42.                 self.y[i] = self.y[i-1]
  44.             # update position of head of snake
  45.             if self.direction == 0:
  46.                 self.x[0] = self.x[0] + self.step
  47.             if self.direction == 1:
  48.                 self.x[0] = self.x[0] - self.step
  49.             if self.direction == 2:
  50.                 self.y[0] = self.y[0] - self.step
  51.             if self.direction == 3:
  52.                 self.y[0] = self.y[0] + self.step
  54.             self.updateCount = 0
  56.     def moveRight(self):
  57.         self.direction = 0
  59.     def moveLeft(self):
  60.         self.direction = 1
  62.     def moveUp(self):
  63.         self.direction = 2
  65.     def moveDown(self):
  66.         self.direction = 3 
  68.     def draw(self, surface, image):
  69.         for i in range(0,self.length):
  70.             surface.blit(image,(self.x[i],self.y[i])) 
  72. class App:
  74.     windowWidth = 800
  75.     windowHeight = 600
  76.     player = 0
  77.     apple = 0
  79.     def __init__(self):
  80.         self._running = True
  81.         self._display_surf = None
  82.         self._image_surf = None
  83.         self._apple_surf = None
  84.         self.player = Player(10) 
  85.         self.apple = Apple(5,5)
  87.     def on_init(self):
  88.         pygame.init()
  89.         self._display_surf = pygame.display.set_mode((self.windowWidth,self.windowHeight), pygame.HWSURFACE)
  91.         pygame.display.set_caption('Pygame pythonspot.com example')
  92.         self._running = True
  93.         self._image_surf = pygame.image.load("pygame.png").convert()
  94.         self._apple_surf = pygame.image.load("apple.png").convert()
  96.     def on_event(self, event):
  97.         if event.type == QUIT:
  98.             self._running = False
  100.     def on_loop(self):
  101.         self.player.update()
  102.         pass
  104.     def on_render(self):
  105.         self._display_surf.fill((0,0,0))
  106.         self.player.draw(self._display_surf, self._image_surf)
  107.         self.apple.draw(self._display_surf, self._apple_surf)
  108.         pygame.display.flip()
  110.     def on_cleanup(self):
  111.         pygame.quit()
  113.     def on_execute(self):
  114.         if self.on_init() == False:
  115.             self._running = False
  117.         while( self._running ):
  118.             pygame.event.pump()
  119.             keys = pygame.key.get_pressed() 
  121.             if (keys[K_RIGHT]):
  122.                 self.player.moveRight()
  124.             if (keys[K_LEFT]):
  125.                 self.player.moveLeft()
  127.             if (keys[K_UP]):
  128.                 self.player.moveUp()
  130.             if (keys[K_DOWN]):
  131.                 self.player.moveDown()
  133.             if (keys[K_ESCAPE]):
  134.                 self._running = False
  136.             self.on_loop()
  137.             self.on_render()
  139.             time.sleep (50.0 / 1000.0);
  140.         self.on_cleanup()
  142. if __name__ == "__main__" :
  143.     theApp = App()
  144.     theApp.on_execute()

因此，我们必须添加游戏逻辑。 要知道蛇的位置是否与苹果的位置匹配，我们必须进行碰撞检测。 这只是意味着要使蛇的坐标与苹果的坐标相交。 我们创建一个新方法来做到这一点：

  1. def isCollision(self,x1,y1,x2,y2,bsize):
  2.     if x1 >= x2 and x1 <= x2 + bsize:
  3.         if y1 >= y2 and y1 <= y2 + bsize:
  4.             return True
  5.     return False

给定其块大小bsize，如果坐标(x1, y1)与(x2, y2)相交，则它将返回True。 我们调用此方法来确定蛇是否与苹果碰撞。 我们需要检查整个蛇，而不仅是头部，因为我们不希望苹果的新位置位于蛇的某个位置。 我们使用相同的isCollision方法来确定蛇是否与自身碰撞（等于输掉游戏）。

完整来源：

  2. from pygame.locals import *
  3. from random import randint
  4. import pygame
  5. import time
  7. class Apple:
  8.     x = 0
  9.     y = 0
  10.     step = 44
  12.     def __init__(self,x,y):
  13.         self.x = x * self.step
  14.         self.y = y * self.step
  16.     def draw(self, surface, image):
  17.         surface.blit(image,(self.x, self.y)) 
  19. class Player:
  20.     x = [0]
  21.     y = [0]
  22.     step = 44
  23.     direction = 0
  24.     length = 3
  26.     updateCountMax = 2
  27.     updateCount = 0
  29.     def __init__(self, length):
  30.        self.length = length
  31.        for i in range(0,2000):
  32.            self.x.append(-100)
  33.            self.y.append(-100)
  35.        # initial positions, no collision.
  36.        self.x[1] = 1*44
  37.        self.x[2] = 2*44
  39.     def update(self):
  41.         self.updateCount = self.updateCount + 1
  42.         if self.updateCount > self.updateCountMax:
  44.             # update previous positions
  45.             for i in range(self.length-1,0,-1):
  46.                 self.x[i] = self.x[i-1]
  47.                 self.y[i] = self.y[i-1]
  49.             # update position of head of snake
  50.             if self.direction == 0:
  51.                 self.x[0] = self.x[0] + self.step
  52.             if self.direction == 1:
  53.                 self.x[0] = self.x[0] - self.step
  54.             if self.direction == 2:
  55.                 self.y[0] = self.y[0] - self.step
  56.             if self.direction == 3:
  57.                 self.y[0] = self.y[0] + self.step
  59.             self.updateCount = 0
  61.     def moveRight(self):
  62.         self.direction = 0
  64.     def moveLeft(self):
  65.         self.direction = 1
  67.     def moveUp(self):
  68.         self.direction = 2
  70.     def moveDown(self):
  71.         self.direction = 3 
  73.     def draw(self, surface, image):
  74.         for i in range(0,self.length):
  75.             surface.blit(image,(self.x[i],self.y[i])) 
  77. class Game:
  78.     def isCollision(self,x1,y1,x2,y2,bsize):
  79.         if x1 >= x2 and x1 <= x2 + bsize:
  80.             if y1 >= y2 and y1 <= y2 + bsize:
  81.                 return True
  82.         return False
  84. class App:
  86.     windowWidth = 800
  87.     windowHeight = 600
  88.     player = 0
  89.     apple = 0
  91.     def __init__(self):
  92.         self._running = True
  93.         self._display_surf = None
  94.         self._image_surf = None
  95.         self._apple_surf = None
  96.         self.game = Game()
  97.         self.player = Player(3) 
  98.         self.apple = Apple(5,5)
  100.     def on_init(self):
  101.         pygame.init()
  102.         self._display_surf = pygame.display.set_mode((self.windowWidth,self.windowHeight), pygame.HWSURFACE)
  104.         pygame.display.set_caption('Pygame pythonspot.com example')
  105.         self._running = True
  106.         self._image_surf = pygame.image.load("block.jpg").convert()
  107.         self._apple_surf = pygame.image.load("block.jpg").convert()
  109.     def on_event(self, event):
  110.         if event.type == QUIT:
  111.             self._running = False
  113.     def on_loop(self):
  114.         self.player.update()
  116.         # does snake eat apple?
  117.         for i in range(0,self.player.length):
  118.             if self.game.isCollision(self.apple.x,self.apple.y,self.player.x[i], self.player.y[i],44):
  119.                 self.apple.x = randint(2,9) * 44
  120.                 self.apple.y = randint(2,9) * 44
  121.                 self.player.length = self.player.length + 1
  123.         # does snake collide with itself?
  124.         for i in range(2,self.player.length):
  125.             if self.game.isCollision(self.player.x[0],self.player.y[0],self.player.x[i], self.player.y[i],40):
  126.                 print("You lose! Collision: ")
  127.                 print("x[0] (" + str(self.player.x[0]) + "," + str(self.player.y[0]) + ")")
  128.                 print("x[" + str(i) + "] (" + str(self.player.x[i]) + "," + str(self.player.y[i]) + ")")
  129.                 exit(0)
  131.         pass
  133.     def on_render(self):
  134.         self._display_surf.fill((0,0,0))
  135.         self.player.draw(self._display_surf, self._image_surf)
  136.         self.apple.draw(self._display_surf, self._apple_surf)
  137.         pygame.display.flip()
  139.     def on_cleanup(self):
  140.         pygame.quit()
  142.     def on_execute(self):
  143.         if self.on_init() == False:
  144.             self._running = False
  146.         while( self._running ):
  147.             pygame.event.pump()
  148.             keys = pygame.key.get_pressed() 
  150.             if (keys[K_RIGHT]):
  151.                 self.player.moveRight()
  153.             if (keys[K_LEFT]):
  154.                 self.player.moveLeft()
  156.             if (keys[K_UP]):
  157.                 self.player.moveUp()
  159.             if (keys[K_DOWN]):
  160.                 self.player.moveDown()
  162.             if (keys[K_ESCAPE]):
  163.                 self._running = False
  165.             self.on_loop()
  166.             self.on_render()
  168.             time.sleep (50.0 / 1000.0);
  169.         self.on_cleanup()
  171. if __name__ == "__main__" :
  172.     theApp = App()
  173.     theApp.on_execute()

结论：

您学习了如何使用 Python 创建游戏蛇以及碰撞检测，图像加载和事件处理等概念。 可以向这个小玩具游戏添加很多东西，但这只是一个非常简单的示例。:-)

下一教程