原文： http://zetcode.com/gui/pygtk/snake/

在 PyGTK 编程教程的这一部分中，我们将创建一个贪食蛇游戏克隆。

贪食蛇游戏

贪食蛇是较旧的经典视频游戏。 它最初是在 70 年代后期创建的。 后来它被带到 PC 上。 在这个游戏中，玩家控制蛇。 目的是尽可能多地吃苹果。 蛇每次吃一个苹果，它的身体就会长大。 蛇必须避开墙壁和自己的身体。 该游戏有时称为 Nibbles 。

开发

蛇的每个关节的大小为 10px。 蛇由光标键控制。 最初，蛇具有三个关节。 游戏立即开始。 如果游戏结束，我们将在棋盘中间显示"Game Over"消息。

snake.py

  1. #!/usr/bin/python
  3. # ZetCode PyGTK tutorial 
  4. #
  5. # This is a simple snake game
  6. # clone
  7. #
  8. # author: jan bodnar
  9. # website: zetcode.com 
  10. # last edited: February 2009
  12. import sys
  13. import gtk
  14. import cairo
  15. import random
  16. import glib
  18. WIDTH = 300
  19. HEIGHT = 270
  20. DOT_SIZE = 10
  21. ALL_DOTS = WIDTH * HEIGHT / (DOT_SIZE * DOT_SIZE)
  22. RAND_POS = 26
  24. x = [0] * ALL_DOTS
  25. y = [0] * ALL_DOTS
  27. class Board(gtk.DrawingArea):
  29.     def __init__(self):
  30.         super(Board, self).__init__()
  32.         self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(0, 0, 0))
  33.         self.set_size_request(WIDTH, HEIGHT)
  35.         self.connect("expose-event", self.expose)
  37.         self.init_game()
  39.     def on_timer(self):
  41.         if self.inGame:
  42.             self.check_apple()
  43.             self.check_collision()
  44.             self.move()
  45.             self.queue_draw()
  46.             return True
  47.         else:
  48.             return False
  50.     def init_game(self):
  52.         self.left = False
  53.         self.right = True
  54.         self.up = False
  55.         self.down = False
  56.         self.inGame = True
  57.         self.dots = 3
  59.         for i in range(self.dots):
  60.             x[i] = 50 - i * 10
  61.             y[i] = 50
  63.         try:
  64.             self.dot = cairo.ImageSurface.create_from_png("dot.png")
  65.             self.head = cairo.ImageSurface.create_from_png("head.png")
  66.             self.apple = cairo.ImageSurface.create_from_png("apple.png")
  67.         except Exception, e:
  68.             print e.message
  69.             sys.exit(1)
  71.         self.locate_apple()
  72.         glib.timeout_add(100, self.on_timer)
  74.     def expose(self, widget, event):
  76.         cr = widget.window.cairo_create()
  78.         if self.inGame:
  79.             cr.set_source_rgb(0, 0, 0)
  80.             cr.paint()
  82.             cr.set_source_surface(self.apple, self.apple_x, self.apple_y)
  83.             cr.paint()
  85.             for z in range(self.dots):
  86.                 if (z == 0): 
  87.                     cr.set_source_surface(self.head, x[z], y[z])
  88.                     cr.paint()
  89.                 else:
  90.                     cr.set_source_surface(self.dot, x[z], y[z])                 
  91.                     cr.paint()
  92.         else:
  93.             self.game_over(cr)
  95.     def game_over(self, cr):
  97.         w = self.allocation.width / 2
  98.         h = self.allocation.height / 2
  100.         (x, y, width, height, dx, dy) = cr.text_extents("Game Over")
  102.         cr.set_source_rgb(65535, 65535, 65535)
  103.         cr.move_to(w - width/2, h)
  104.         cr.show_text("Game Over")
  105.         self.inGame = False
  107.     def check_apple(self):
  109.         if x[0] == self.apple_x and y[0] == self.apple_y: 
  110.             self.dots = self.dots + 1
  111.             self.locate_apple()
  113.     def move(self):
  115.         z = self.dots
  117.         while z > 0:
  118.             x[z] = x[(z - 1)]
  119.             y[z] = y[(z - 1)]
  120.             z = z - 1
  122.         if self.left:
  123.             x[0] -= DOT_SIZE
  125.         if self.right: 
  126.             x[0] += DOT_SIZE
  128.         if self.up:
  129.             y[0] -= DOT_SIZE
  131.         if self.down:
  132.             y[0] += DOT_SIZE
  134.     def check_collision(self):
  136.         z = self.dots
  138.         while z > 0:
  139.             if z > 4 and x[0] == x[z] and y[0] == y[z]:
  140.                 self.inGame = False
  141.             z = z - 1
  143.         if y[0] > HEIGHT - DOT_SIZE: 
  144.             self.inGame = False
  146.         if y[0] < 0:
  147.             self.inGame = False
  149.         if x[0] > WIDTH - DOT_SIZE:
  150.             self.inGame = False
  152.         if x[0] < 0:
  153.             self.inGame = False
  155.     def locate_apple(self):
  157.         r = random.randint(0, RAND_POS)
  158.         self.apple_x = r * DOT_SIZE
  159.         r = random.randint(0, RAND_POS)
  160.         self.apple_y = r * DOT_SIZE
  162.     def on_key_down(self, event): 
  164.         key = event.keyval
  166.         if key == gtk.keysyms.Left and not self.right: 
  167.             self.left = True
  168.             self.up = False
  169.             self.down = False
  171.         if key == gtk.keysyms.Right and not self.left:
  172.             self.right = True
  173.             self.up = False
  174.             self.down = False
  176.         if key == gtk.keysyms.Up and not self.down:
  177.             self.up = True
  178.             self.right = False
  179.             self.left = False
  181.         if key == gtk.keysyms.Down and not self.up: 
  182.             self.down = True
  183.             self.right = False
  184.             self.left = False
  186. class Snake(gtk.Window):
  188.     def __init__(self):
  189.         super(Snake, self).__init__()
  191.         self.set_title('Snake')
  192.         self.set_size_request(WIDTH, HEIGHT)
  193.         self.set_resizable(False)
  194.         self.set_position(gtk.WIN_POS_CENTER)
  196.         self.board = Board()
  197.         self.connect("key-press-event", self.on_key_down)
  198.         self.add(self.board)
  200.         self.connect("destroy", gtk.main_quit)
  201.         self.show_all()
  203.     def on_key_down(self, widget, event): 
  205.         key = event.keyval
  206.         self.board.on_key_down(event)
  208. Snake()
  209. gtk.main()

首先，我们将定义一些在游戏中使用的全局变量。

WIDTH和HEIGHT常数确定电路板的大小。 DOT_SIZE是苹果的大小和蛇的点。 ALL_DOTS常数定义了板上可能的最大点数。 RAND_POS常数用于计算苹果的随机位置。 DELAY常数确定游戏的速度。

  1. x = [0] * ALL_DOTS
  2. y = [0] * ALL_DOTS

这两个列表存储蛇的所有可能关节的 x，y 坐标。

init_game()方法初始化变量，加载图像并启动超时功能。

  1. self.left = False
  2. self.right = True
  3. self.up = False
  4. self.down = False
  5. self.inGame = True
  6. self.dots = 3

游戏开始时，蛇有三个关节。 而且它正在向右行驶。

在move()方法中，我们有游戏的关键算法。 要了解它，请查看蛇的运动方式。 您控制蛇的头。 您可以使用光标键更改其方向。 其余关节在链上向上移动一个位置。 第二关节移动到第一个关节的位置，第三关节移动到第二个关节的位置，依此类推。

  1. while z > 0:
  2.     x[z] = x[(z - 1)]
  3.     y[z] = y[(z - 1)]
  4.     z = z - 1

该代码将关节向上移动。

  1. if self.left:
  2.     x[0] -= DOT_SIZE

将头向左移动。

在checkCollision()方法中，我们确定蛇是否击中了自己或撞墙之一。

  1. while z > 0:
  2.     if z > 4 and x[0] == x[z] and y[0] == y[z]:
  3.         self.inGame = False
  4.     z = z - 1

如果蛇用头撞到关节之一，我们就结束游戏。

  1. if y[0] > HEIGHT - DOT_SIZE: 
  2.     self.inGame = False

如果蛇击中了棋盘的底部，我们就结束了游戏。

locate_apple()方法在表格上随机定位一个苹果。

  1. r = random.randint(0, RAND_POS)

我们得到一个从 0 到RAND_POS-1的随机数。

  1. self.apple_x = r * DOT_SIZE
  2. ...
  3. self.apple_y = r * DOT_SIZE

这些行设置了apple对象的 x，y 坐标。

  1.     self.connect("key-press-event", self.on_key_down)
  2.     ...
  4. def on_key_down(self, widget, event): 
  6.     key = event.keyval
  7.     self.board.on_key_down(event)

我们在Snake类中捕获按键事件，并将处理委托给board对象。

在Board类的on_key_dow()方法中，我们确定玩家按下了哪些键。

  1. if key == gtk.keysyms.Left and not self.right: 
  2.     self.left = True
  3.     self.up = False
  4.     self.down = False

如果我们按左光标键，则将self.left变量设置为True。 在move()方法中使用此变量来更改蛇对象的坐标。 还要注意，当蛇向右行驶时，我们不能立即向左转。

PyGTK 中的贪食蛇游戏 - 图1

图：贪食蛇

这是使用 PyGTK 编程库编程的贪食蛇电脑游戏。