Pipong

一个基于Matplotlib的Pong游戏，说明了一种编写交互动画的方法，它很容易移植到多个后端pipong.py由Paul Ivanov撰写http://pirsquared.org

  1. import numpy as np
  2. import matplotlib.pyplot as plt
  3. from numpy.random import randn, randint
  4. from matplotlib.font_manager import FontProperties
  6. instructions = """
  7. Player A:       Player B:
  8.   'e'      up     'i'
  9.   'd'     down    'k'
  11. press 't' -- close these instructions
  12.             (animation will be much faster)
  13. press 'a' -- add a puck
  14. press 'A' -- remove a puck
  15. press '1' -- slow down all pucks
  16. press '2' -- speed up all pucks
  17. press '3' -- slow down distractors
  18. press '4' -- speed up distractors
  19. press ' ' -- reset the first puck
  20. press 'n' -- toggle distractors on/off
  21. press 'g' -- toggle the game on/off
  23.   """
  26. class Pad(object):
  27.     def __init__(self, disp, x, y, type='l'):
  28.         self.disp = disp
  29.         self.x = x
  30.         self.y = y
  31.         self.w = .3
  32.         self.score = 0
  33.         self.xoffset = 0.3
  34.         self.yoffset = 0.1
  35.         if type == 'r':
  36.             self.xoffset *= -1.0
  38.         if type == 'l' or type == 'r':
  39.             self.signx = -1.0
  40.             self.signy = 1.0
  41.         else:
  42.             self.signx = 1.0
  43.             self.signy = -1.0
  45.     def contains(self, loc):
  46.         return self.disp.get_bbox().contains(loc.x, loc.y)
  49. class Puck(object):
  50.     def __init__(self, disp, pad, field):
  51.         self.vmax = .2
  52.         self.disp = disp
  53.         self.field = field
  54.         self._reset(pad)
  56.     def _reset(self, pad):
  57.         self.x = pad.x + pad.xoffset
  58.         if pad.y < 0:
  59.             self.y = pad.y + pad.yoffset
  60.         else:
  61.             self.y = pad.y - pad.yoffset
  62.         self.vx = pad.x - self.x
  63.         self.vy = pad.y + pad.w/2 - self.y
  64.         self._speedlimit()
  65.         self._slower()
  66.         self._slower()
  68.     def update(self, pads):
  69.         self.x += self.vx
  70.         self.y += self.vy
  71.         for pad in pads:
  72.             if pad.contains(self):
  73.                 self.vx *= 1.2 * pad.signx
  74.                 self.vy *= 1.2 * pad.signy
  75.         fudge = .001
  76.         # probably cleaner with something like...
  77.         if self.x < fudge:
  78.             pads[1].score += 1
  79.             self._reset(pads[0])
  80.             return True
  81.         if self.x > 7 - fudge:
  82.             pads[0].score += 1
  83.             self._reset(pads[1])
  84.             return True
  85.         if self.y < -1 + fudge or self.y > 1 - fudge:
  86.             self.vy *= -1.0
  87.             # add some randomness, just to make it interesting
  88.             self.vy -= (randn()/300.0 + 1/300.0) * np.sign(self.vy)
  89.         self._speedlimit()
  90.         return False
  92.     def _slower(self):
  93.         self.vx /= 5.0
  94.         self.vy /= 5.0
  96.     def _faster(self):
  97.         self.vx *= 5.0
  98.         self.vy *= 5.0
  100.     def _speedlimit(self):
  101.         if self.vx > self.vmax:
  102.             self.vx = self.vmax
  103.         if self.vx < -self.vmax:
  104.             self.vx = -self.vmax
  106.         if self.vy > self.vmax:
  107.             self.vy = self.vmax
  108.         if self.vy < -self.vmax:
  109.             self.vy = -self.vmax
  112. class Game(object):
  113.     def __init__(self, ax):
  114.         # create the initial line
  115.         self.ax = ax
  116.         ax.set_ylim([-1, 1])
  117.         ax.set_xlim([0, 7])
  118.         padAx = 0
  119.         padBx = .50
  120.         padAy = padBy = .30
  121.         padBx += 6.3
  123.         # pads
  124.         pA, = self.ax.barh(padAy, .2,
  125.                            height=.3, color='k', alpha=.5, edgecolor='b',
  126.                            lw=2, label="Player B",
  127.                            animated=True)
  128.         pB, = self.ax.barh(padBy, .2,
  129.                            height=.3, left=padBx, color='k', alpha=.5,
  130.                            edgecolor='r', lw=2, label="Player A",
  131.                            animated=True)
  133.         # distractors
  134.         self.x = np.arange(0, 2.22*np.pi, 0.01)
  135.         self.line, = self.ax.plot(self.x, np.sin(self.x), "r",
  136.                                   animated=True, lw=4)
  137.         self.line2, = self.ax.plot(self.x, np.cos(self.x), "g",
  138.                                    animated=True, lw=4)
  139.         self.line3, = self.ax.plot(self.x, np.cos(self.x), "g",
  140.                                    animated=True, lw=4)
  141.         self.line4, = self.ax.plot(self.x, np.cos(self.x), "r",
  142.                                    animated=True, lw=4)
  144.         # center line
  145.         self.centerline, = self.ax.plot([3.5, 3.5], [1, -1], 'k',
  146.                                         alpha=.5, animated=True, lw=8)
  148.         # puck (s)
  149.         self.puckdisp = self.ax.scatter([1], [1], label='_nolegend_',
  150.                                         s=200, c='g',
  151.                                         alpha=.9, animated=True)
  153.         self.canvas = self.ax.figure.canvas
  154.         self.background = None
  155.         self.cnt = 0
  156.         self.distract = True
  157.         self.res = 100.0
  158.         self.on = False
  159.         self.inst = True    # show instructions from the beginning
  160.         self.background = None
  161.         self.pads = []
  162.         self.pads.append(Pad(pA, padAx, padAy))
  163.         self.pads.append(Pad(pB, padBx, padBy, 'r'))
  164.         self.pucks = []
  165.         self.i = self.ax.annotate(instructions, (.5, 0.5),
  166.                                   name='monospace',
  167.                                   verticalalignment='center',
  168.                                   horizontalalignment='center',
  169.                                   multialignment='left',
  170.                                   textcoords='axes fraction',
  171.                                   animated=False)
  172.         self.canvas.mpl_connect('key_press_event', self.key_press)
  174.     def draw(self, evt):
  175.         draw_artist = self.ax.draw_artist
  176.         if self.background is None:
  177.             self.background = self.canvas.copy_from_bbox(self.ax.bbox)
  179.         # restore the clean slate background
  180.         self.canvas.restore_region(self.background)
  182.         # show the distractors
  183.         if self.distract:
  184.             self.line.set_ydata(np.sin(self.x + self.cnt/self.res))
  185.             self.line2.set_ydata(np.cos(self.x - self.cnt/self.res))
  186.             self.line3.set_ydata(np.tan(self.x + self.cnt/self.res))
  187.             self.line4.set_ydata(np.tan(self.x - self.cnt/self.res))
  188.             draw_artist(self.line)
  189.             draw_artist(self.line2)
  190.             draw_artist(self.line3)
  191.             draw_artist(self.line4)
  193.         # pucks and pads
  194.         if self.on:
  195.             self.ax.draw_artist(self.centerline)
  196.             for pad in self.pads:
  197.                 pad.disp.set_y(pad.y)
  198.                 pad.disp.set_x(pad.x)
  199.                 self.ax.draw_artist(pad.disp)
  201.             for puck in self.pucks:
  202.                 if puck.update(self.pads):
  203.                     # we only get here if someone scored
  204.                     self.pads[0].disp.set_label(
  205.                         "   " + str(self.pads[0].score))
  206.                     self.pads[1].disp.set_label(
  207.                         "   " + str(self.pads[1].score))
  208.                     self.ax.legend(loc='center', framealpha=.2,
  209.                                    facecolor='0.5',
  210.                                    prop=FontProperties(size='xx-large',
  211.                                                        weight='bold'))
  213.                     self.background = None
  214.                     self.ax.figure.canvas.draw_idle()
  215.                     return True
  216.                 puck.disp.set_offsets([[puck.x, puck.y]])
  217.                 self.ax.draw_artist(puck.disp)
  219.         # just redraw the axes rectangle
  220.         self.canvas.blit(self.ax.bbox)
  221.         self.canvas.flush_events()
  222.         if self.cnt == 50000:
  223.             # just so we don't get carried away
  224.             print("...and you've been playing for too long!!!")
  225.             plt.close()
  227.         self.cnt += 1
  228.         return True
  230.     def key_press(self, event):
  231.         if event.key == '3':
  232.             self.res *= 5.0
  233.         if event.key == '4':
  234.             self.res /= 5.0
  236.         if event.key == 'e':
  237.             self.pads[0].y += .1
  238.             if self.pads[0].y > 1 - .3:
  239.                 self.pads[0].y = 1 - .3
  240.         if event.key == 'd':
  241.             self.pads[0].y -= .1
  242.             if self.pads[0].y < -1:
  243.                 self.pads[0].y = -1
  245.         if event.key == 'i':
  246.             self.pads[1].y += .1
  247.             if self.pads[1].y > 1 - .3:
  248.                 self.pads[1].y = 1 - .3
  249.         if event.key == 'k':
  250.             self.pads[1].y -= .1
  251.             if self.pads[1].y < -1:
  252.                 self.pads[1].y = -1
  254.         if event.key == 'a':
  255.             self.pucks.append(Puck(self.puckdisp,
  256.                                    self.pads[randint(2)],
  257.                                    self.ax.bbox))
  258.         if event.key == 'A' and len(self.pucks):
  259.             self.pucks.pop()
  260.         if event.key == ' ' and len(self.pucks):
  261.             self.pucks[0]._reset(self.pads[randint(2)])
  262.         if event.key == '1':
  263.             for p in self.pucks:
  264.                 p._slower()
  265.         if event.key == '2':
  266.             for p in self.pucks:
  267.                 p._faster()
  269.         if event.key == 'n':
  270.             self.distract = not self.distract
  272.         if event.key == 'g':
  273.             self.on = not self.on
  274.         if event.key == 't':
  275.             self.inst = not self.inst
  276.             self.i.set_visible(not self.i.get_visible())
  277.             self.background = None
  278.             self.canvas.draw_idle()
  279.         if event.key == 'q':
  280.             plt.close()

下载这个示例