这是本人去年按照一个英文教程制作的一个2D简单版本的Minecraft。代码非本人风格。今天看来，这代码可读性不好。仅以发表出来，以供有需要的人阅读。

"""游戏规则：
按空格键捡东西，按数字键放东西，按数字键同时单击鼠标左键合成物质
"""

import random
import pygame,sys
from pygame.locals import *

BLACK = (0,0,0)
BROWN = (153,76,0)
GREEN = (0,255,0)
BLUE = (0,0,255)
WHITE = (255,255,255)

cloudx = -200
cloudy = 0

DIRT = 0
GRASS = 1
WATER = 2
COAL = 3
CLOUD = 4
WOOD = 5
FIRE = 6
SAND = 7
GLASS = 8
ROCK  = 9
STONE = 10
BRICK = 11
DIAMOND = 12

textures = {
           DIRT : pygame.image.load('dirt.png'),
           GRASS: pygame.image.load('grass.png'),
           WATER: pygame.image.load('water.png'),
           COAL : pygame.image.load('coal.png'),
           CLOUD: pygame.image.load('cloud.png'),
           WOOD : pygame.image.load('wood.png'),
           FIRE : pygame.image.load('fire.png'),
           SAND : pygame.image.load('sand.png'),
           GLASS: pygame.image.load('glass.png'),
           ROCK : pygame.image.load('rock.png'),
           STONE: pygame.image.load('stone.png'),
           BRICK: pygame.image.load('brick.png'),
           DIAMOND:pygame.image.load('diamond.png')
          }

inventory = {
               DIRT : 0,
               GRASS: 0,
               WATER: 0,
               COAL : 0,
               WOOD : 0,
               FIRE : 0,
               SAND : 0,
               GLASS: 0,
               ROCK : 0,
               STONE: 0,
               BRICK: 0,
               DIAMOND:0
            }

TILESIZE = 20
MAPWIDTH = 50
MAPHEIGHT = 20

PLAYER = pygame.image.load("player.png")
playerPos = [0,0]

resource = [DIRT,GRASS,WATER,COAL,WOOD,FIRE,SAND,GLASS,ROCK,STONE,BRICK,DIAMOND]

tilemap = [ [DIRT for w in range(MAPWIDTH)] for h in range(MAPHEIGHT) ]

for rw in range(MAPHEIGHT):
    for cl in range(MAPWIDTH):
        randomNumber = random.randint(0,20)
        if randomNumber == 0:
            tile = COAL
        elif randomNumber ==1 or randomNumber < 5:
            tile = WATER
        elif randomNumber >=5 and randomNumber <=6:
            tile = SAND
        elif randomNumber > 6 and randomNumber <9:
            tile = WOOD            
        elif randomNumber > 9 and randomNumber <11:
            tile = ROCK
        elif randomNumber > 11 and randomNumber <18:
            tile = GRASS          
        else:
            tile = DIRT
        tilemap[rw][cl] = tile
        
controls = {
             DIRT   : 49,           # 1键
             GRASS  : 50,
             WATER  : 51,
             COAL   : 52,
             WOOD   : 53,
             FIRE   : 54,
             SAND   : 55,           # 7键
             GLASS  : 56,           # 8键 
             ROCK   : 57,           # 9键
             STONE  : 48,           # 0键
             BRICK  : 45,           # -键 
             DIAMOND: 61            # =键
            }

"合成规则"
craft = {
           FIRE : { WOOD :2,ROCK : 2 }, # 两块木片和2块岩石合成一把火
           STONE: { ROCK :2},           
           BRICK : { STONE:2,FIRE : 1},
           SAND : { ROCK : 2 },
           GLASS: { FIRE :1,SAND : 2 },
           DIAMOND:{ WOOD:2,COAL : 3,GLASS:2 } 
         }
    
pygame.init()
DISPLAYSURF = pygame.display.set_mode((MAPWIDTH*TILESIZE,MAPHEIGHT*TILESIZE +50 ))

INVFONT = pygame.font.Font('FreeSansBold.ttf',18)
fpsClock = pygame.time.Clock()
while True:
    for event in pygame.event.get():
        if event.type == QUIT:
            pygame.quit()
            sys.exit()
        elif event.type == KEYDOWN:
            if event.key == K_RIGHT and playerPos[0] < MAPWIDTH  - 1:
                playerPos[0] +=1
            if event.key == K_LEFT and playerPos[0] > 0 :
                playerPos[0] -=1
            if event.key == K_UP and playerPos[1]>0:
                playerPos[1] -=1
            if event.key == K_DOWN and playerPos[1] < MAPHEIGHT -1 :
                playerPos[1] +=1
            if event.key == K_SPACE:                           # 按空格键捡东西
                currentTile = tilemap[playerPos[1]][playerPos[0]]
                inventory[currentTile] +=1
                tilemap[playerPos[1]][playerPos[0]] = DIRT     # 捡到东西后，变成地面了
                
            for key in controls:
                
                if (event.key == controls[key]):                    

                    if pygame.mouse.get_pressed()[0] :
                        print("单击左键")
                        if key not in craft :break             # 按的键代表某物质，不在合成表里则不合成
                        canBeMade = True                       # 假设能被合成
                        for i in craft[key]:
                            if craft[key][i] > inventory[i]:   # 合成所需的数量大于仓库中数量
                                canBeMade = False              # 无法合成
                                break
                        if canBeMade == True:                  # 如果能被合成
                            for i in craft[key]:               # 仓库中的每项都根据规则减去相应的数量
                                inventory[i] -= craft[key][i]  #
                            inventory[key] += 1                # 合成的这种物质数量加1 
                    else:
                        "按数字键放东西在史蒂夫所在的位置"
                        currentTile = tilemap[playerPos[1]][playerPos[0]]
                        if inventory[key] > 0:                 # 如果仓库中这种物质数量大于0
                            inventory[key] -= 1                # 那么数量减去1 
                            tilemap[playerPos[1]][playerPos[0]] = key  # 放到史蒂夫所在的位置
                            inventory[currentTile] += 1                # 仓库中相应数量加1

                    
    DISPLAYSURF.fill(BLACK)           
    for row in range(MAPHEIGHT):
        for column in range(MAPWIDTH):
            DISPLAYSURF.blit(textures[tilemap[row][column]],(column*TILESIZE,row*TILESIZE,TILESIZE,TILESIZE))

    DISPLAYSURF.blit(PLAYER,(playerPos[0]*TILESIZE,playerPos[1]*TILESIZE))
    
    DISPLAYSURF.blit(textures[CLOUD].convert_alpha(),(cloudx,cloudy))
    cloudx +=1
    if cloudx > MAPWIDTH * TILESIZE:
        cloudy = random.randint(0,MAPHEIGHT*TILESIZE)
        cloudx = -200

    placePosition = 10
    for item in resource:
        DISPLAYSURF.blit(textures[item],(placePosition,MAPHEIGHT*TILESIZE + 20))
        placePosition +=30
        textObj = INVFONT.render(str(inventory[item]),True,WHITE,BLACK)
        DISPLAYSURF.blit(textObj,(placePosition,MAPHEIGHT*TILESIZE+20))
        placePosition +=50
        
    pygame.display.update()
    fpsClock.tick(24)

可以用来教少年们进行个加密解密启蒙的小程序。

"""加密程序"""
plain_text = "This is a test. ABC abc"

encrypted_text = ""          # 加密后的文本
for c in plain_text:
    x = ord(c)               # 求它的ASCII码
    x = x + 1
    c2 = chr(x)              # 取ASCII码对应的字符
    encrypted_text = encrypted_text + c2
print(encrypted_text)

"""解密程序"""
encrypted_text = "Uijt!jt!b!uftu/!BCD!bcd"

plain_text = ""
for c in encrypted_text:
    x = ord(c)
    x = x - 1
    c2 = chr(x)
    plain_text = plain_text + c2
    
print(plain_text)

tkinter画线的末端风格BUTT、PROJECTING和ROUND，连接风格ROUND、BEVEL、MITER展示

在画线条的时候，起笔应该是个什么样式？还有在线条折回的时候又应该是个什么样式呢？
一根线条有两端，起笔或抬笔的样式，我们把它叫末端风格，英文名为Cap style。
tkinter定义了三种，第一种叫BUTT，它是方形的风格，起点详见下图。
第二种叫PROJECTING,也是方形风格，不过起始点不同。
第三种风格叫ROUND，是圆形风格。

在线条折回的时候，也有三种风格可供选择，这叫做连接样式，英文名为：Join style。
第一种是ROUND风格，第二种是BEVEL风格，第三种是MITER风格。详见下图一目了然！

pygame的surface代表着一张图像。如果要在pygame 的屏幕上显示文字，那么首先要把文字渲染成surface，如果把这个surface直接保存为png图像，那么就实现了文字转png图像了。连续的保存，再合成它们就能制作 gif图了。通过pygame.font.get_default_font()命令能获取缺省的字体文件，它返回一个字符串。通过pygame.font.Font则能新建字体对象。用字体对象就能把具体的文字渲染成surface了，最后就只剩下保存。代码如下所示：

>>> import pygame
>>> pygame.init()
(6, 0)
>>> fnt = pygame.font.get_default_font()
>>> fnt
'freesansbold.ttf'
>>> fntobj = pygame.font.Font(fnt,20)
>>> myword = fntobj.render("I love Python",True,(255,0,0))
>>> pygame.image.save(myword,"c:/myword.png")
>>>

pygame.font.Font的第一个参数是字体文件，第二个参数是字体大小。
在fntobj.render参数中，第一个是要写的字，第二个是反锯齿，第三个是颜色。
surface有get_width和get_height命令，这样就能获取所生成的图像的大小。

下面的函数需要imageio模块支持，它能把一系列png图片合成gif。如果要生成一个按 I love Python 逐字显示的gif动画该如何编程呢？有了下面的函数，结合上面的知识，相信你一定能够编出来。

def make_gif_image(path_image,gif_filename):
   """读取路径下面的所有png文件，形成gif图形"""
   amounts = len([ image for image in os.listdir(path_image) if os.path.splitext(image)[-1] == ".png"])
   images = [ path + os.sep + str(i) + ".png" for i in range(0,amounts)]
   frames = [imageio.imread(image) for image in images]
   imageio.mimsave(gif_filename, frames, 'GIF', duration=0.4)

要学习如何旋转图形，首先要学习一下Rect类。在pygame中有pygame.Rect这个类，它是矩形类。通过它新建一个矩形对象，可以用来代表图形surface对象的坐标，宽度与高度，通常也就是这么做的。
surface有get_rect方法，能获取自己的矩形对象。示例代码如下：

>>> import pygame
>>> pygame.init()
(6, 0)
>>> screen = pygame.display.set_mode((480,360))
>>> square = pygame.Surface((100,100)).convert_alpha()
>>> square.fill((0,0,255))
<rect(0, 0, 100, 100)>
>>> rect = square.get_rect()
>>> rect
<rect(0, 0, 100, 100)>
>>> screen.blit(square,rect)
<rect(0, 0, 100, 100)>
>>> pygame.display.update()    # 刷新屏幕显示出square
>>>

上面新建了screen和square，这是两个surface。运行后，我们能看到一个蓝色的正方形显示在屏幕左上角。
rect有x,y属性，如果把rect.x和rect.y都设为100，我们就能把矩形渲染到坐标为(100,100)的位置了。

>>> rect.x = rect.y = 100
>>> screen.blit(square,rect)
<rect(100, 100, 100, 100)>
>>> pygame.display.update()    # 刷新屏幕显示出square
>>>

运行上面的代码，又有一个蓝色的矩形出现了，原先矩形并没有擦除。这是由于我们没有把screen还原成全黑色所造成的，所以它还保留着左上角蓝色正方形。
我们也可以设定矩形的中心点坐标，如rect.centerx = 100的时候，那么这个矩形的x坐标应该是多少呢？矩形的边长是100，它的左上角x坐标就应该是50。
同理，如果用rect.centery = 100设定矩形的中心点y坐标为100时，它的左上角y坐标也是50。

下在我们来测试一下，这回先把screen给黑掉。

>>> screen.fill((0,0,0))
<rect(0, 0, 480, 360)>
>>> rect.centerx = 100
>>> rect.centery = 100
>>> screen.blit(square,rect)
<rect(50, 50, 100, 100)>
>>> pygame.display.update()
>>>

如果要对正方形进行旋转的话，pygame.transform.rotate的这个方法能对square进行旋转，它会返回一个新的surface。
这个旋转是以图形的中心点为旋转中心的。旋转后，图形的宽度和高度会发生变化，我们对它进行重新渲染，这样好像square就旋转了。
当然，要在同一个位置进行渲染，所以首先要设定好矩形对象的中心点坐标。以下是让图形进行旋转的代码。

"""pygame图像旋转教程

 
# 矩形对象有left,right,top,bottom,width,height,centerx,centery等属性，分别对应它的
# 最左x坐标，最右x坐标，最上y坐标，最下y坐标，宽度，高度，中心点x坐标，中心点y坐标值。

"""

import math
import pygame
from pygame.locals import *            # 导入pygame定义的常量

width,height = 480,360

pygame.init()

screen = pygame.display.set_mode((width,height))

square = pygame.Surface((100,100)).convert_alpha()
square.fill((0,255,255))

centerx = width//2                      # 中心点x坐标
centery = height//2                     # 中心点y坐标
angle = 0                               # 旋转角度

running = True

while running:
    event = pygame.event.poll()         # 从事件队列中取一个事件
    if event.type == QUIT:running = False
    s = pygame.transform.rotate(square,math.radians(angle)) # 旋转square   
    s_rect = s.get_rect()               # 获取surface的矩形对象
    s_rect.centerx = centerx            # 设定图形的中心点x坐标
    s_rect.centery = centery            # 设定图形的中心点y坐标
    screen.fill((0,0,0))                # 填充screen为黑色
    screen.blit(s,s_rect)               # 把旋转后的s图形按s_rect之描述贴到screen上
    pygame.display.update()             # 更新屏幕显示 
    angle +=1
    
pygame.quit()

如果要对外部的图形进行旋转，可以用pygame.image.load(图形文件名)加载图像形成surface。

Pygame有Surface类，它用来实例化存储在内存中的图形。如果要加载外部的图像，可以用pygame.image.load命令，它返回的是surface。
由于Pygame的surface提供了一套方法可以操作surface，如设置透明度，缩放，旋转，甚至对它直接进行像素级操作，所以可以做图形处理。我们加载两张图片，把它们合成，那么新的图片就出来了。以下是把名为“太空.png“的和名为”nezha.png”的图片进行合成的最简单示例，方便理解。

"""pygame最简单的合成与透明度演示程序"""

import pygame                           # 导入pygame模块

pygame.init()

screen = pygame.display.set_mode((1,1)) # 新建屏幕对象

background = pygame.image.load("太空.png").convert()  #转换成透明度图
nezha = pygame.image.load("nezha.png")  # 加载哪吒图
nezha.set_alpha(100)                    # 设置合成图像时，它的alpha值
background.blit(nezha,(100,0))          # 把nezha贴到(100,0)坐标

pygame.image.save(background,"bg.png")  # 保存图形
pygame.quit()

当两张图像合成一张图片时，每个像素是由每张图片的像素合成的。上面的程序中nezha的alpha值为100，这表示它和另一个图像合成时，它贡献100/256比例的像素值，而另一个图像将使用155/256的比例。如果它的alpha值是0，它合成到另一个图像上，它将是透明的。如果它的alpha值是255，则它是不透明的，完全覆盖在另一张图片上。为了理解，我们来估个试验。

下面的screen 由 pygame.display.set_mode((100,100))建立。我们把它填充为红色。image1是一个蓝色的图形。通过image1.set_alpha能设置它在合成时所贡献的像素比值。如果它的值是0,它将不贡献一点像素，这时屏幕会显示纯红色，如果它的值在0到255之间，它会贡献相应比例的像素值。如果它是255，它所占的比例就是100%。这时就是纯蓝色了。运行下面的程序，屏幕会从红色快速地过度到蓝色。也即image1会从完全透明过度到不透明。

"""pygame的surface设置alpha试验"""

import pygame

pygame.init()

screen = pygame.display.set_mode((100,100))
screen.fill((255,0,0))       # screen是红色的 

image1 = pygame.Surface((100,100))
image1.fill((0,0,255))

# 下面让屏幕从红色显示到蓝色
for a in range(0,256):         # 值从0到255变化
    image1.set_alpha(a)        # 设置合成时的alpha值
    screen.blit(image1,(0,0))  # 合成到screen
    print(screen.get_at((0,0)))# 打印screen左上角像素值
    pygame.display.update()    # 刷新显示
    screen.fill((255,0,0))     # 让screen的颜色回到红色

刚才说了Surface类提供了方法可以对图像进行缩放，下面的例子对图像进行了缩放。

"""
pygame合成图片与缩放演示程序。

 

"""
nezhas = []

import pygame                           # 导入pygame模块

pygame.init()                           # pygame初始化

screen = pygame.display.set_mode((1,1)) # 新建屏幕对象

background = pygame.image.load("太空.png").convert_alpha()
bgheight = background.get_height()      # 获取背景高度
nezha = pygame.image.load("nezha.png")  # 加载哪吒图
    
nezha_width = nezha.get_width()         # 获取宽度
nezha_height = nezha.get_height()       # 获取高度
k = nezha_height / nezha_width          # 高度和宽度的比值
background.blit(nezha,(0,bgheight-nezha_height)) # 把nezha图放在background左下角

for width in range(10,420,50):
    print(width)
    height = int(width * k) 
    n  = pygame.transform.scale(nezha,(width,height))  # 缩放图形
    n.set_alpha(width//2)            # 设置透明度 
    background.blit(n,(width*2,250)) # 贴一张图到background上     

pygame.image.save(background,"combine.png") # 保存图像

pygame.quit()                        # 退出pygame

在pygame中有一个Surface概念，它的中文意思为表面。它用来代表图像，当新建了一个surface时，它是一幅黑色的图形。这个图形是以左上角为原点的。
用screen = pygame.display.set_mode((width,height))建立的是一个surface，width和height是surface的宽度和高度。
用type(screen)查看，结果是<class ‘pygame.Surface’>。它通常用于在pygame的游戏主循环中最先被渲染的图形。

当然，只有一个surface，那么在pygame中只会显示一个黑乎乎的界面。通常我们会建立更多的surface，然后把这些surface依次渲染到screen上。

请在IDLE中输入以下命令测试：

>>> import pygame
>>> pygame.init()
(6, 0)
>>> width,height = 800,600
>>> screen = pygame.display.set_mode((width,height))
>>> type(screen)
<class 'pygame.Surface'>
>>>

现在，我们来建立另一个surface，用 square = pygame.Surface((360,360)) 命令，新建一个叫square的，宽度和高度是360和360像素的正方形。
现在，这个正方形是黑色的，如果我们把它渲染到screen上，什么也看不见，还是黑乎乎的一片。通过square.fill((255,0,0))把它的颜色填充为红色。
然后用screen.blit(square,(100,100))就能把square渲染到screen上。如果不能理解渲染的意思，可以理解为把square贴到screen上即可。
贴在屏幕坐标左上角(100,100)的位置。到此为正方形还是没有显示出来，要把它显示出来还有最后一步，就是刷新屏幕显示。调用pygame.display.update()即可。
成功后在分辨率为800×600的黑色屏幕上会显示一个大大的红色正方形。请输入以下命令测试。

>>> square = pygame.Surface((360,360))
>>> square.fill((255,0,0))
<rect(0, 0, 360, 360)>
>>> screen.blit(square,(100,100))
<rect(100, 100, 360, 360)>
>>> pygame.display.update()
>>>

最后，退出pygame可以用pygame.quit()命令。以下是完整的代码，加了一个窗口标题：

"""
pygame教程之surface表面
在pygame中有一个Surface概念，它的中文意思为表面。.
它用来代表图像，当新建了一个surface时，它代表内存中的一幅黑色的图形。

"""


import pygame                      # 导入pygame模块

pygame.init()                      # pygame初始化  
 
width,height = 800,600             # 定义全局变量

screen = pygame.display.set_mode((width,height)) # 新建屏幕，它是一个surface

pygame.display.set_caption("pygame教程之surface表面，作者：李兴球")
 
square = pygame.Surface((360,360)) # 新建square，它是一个surface

square.fill((255,0,0))             # 填充square为红色
 
screen.blit(square,(100,100))      # 把square贴在screen上
 
pygame.display.update()            # 刷新合成后的屏幕显示


#pygame.quit()             # 开了这个会一闪而过

要移动这个正方形，那就需要不断地改变它的渲染坐标，并且把以前所渲染的都擦除掉。这就需要一个循环，假设正方形的坐标用x,y表示，它每次水平移动的距离用dx表示，我们把正方形变小，通过for循环500次，不断地填充背景屏幕，不断地渲染正方形，这个速度很快，让它 移动起来。代码如下所示：

"""
移动500次的红色小正方形。

"""

import pygame                      # 导入pygame模块

pygame.init()                      # pygame初始化  
 
width,height = 800,600             # 定义全局变量

screen = pygame.display.set_mode((width,height)) # 新建屏幕，它是一个surface

pygame.display.set_caption("pygame教程之surface表面，作者：李兴球")
 
square = pygame.Surface((36,36)) # 新建square，它是一个surface

square.fill((255,0,0))             # 填充square为红色

x , y = 100,100                    # 代表矩形的渲染坐标 
dx = 1                             # 代表矩形每次移动的水平距离

for n in range(500):
    screen.fill((0,0,0))           # 填充屏幕为黑色
    screen.blit(square,(x,y))      # 把square贴在screen上
    x = x + dx                     # 水平坐标增加dx
    pygame.display.update()        # 刷新合成后的屏幕显示


#pygame.quit()             # 开了这个会窗口会关闭

上面的正方形向右移动，如果要让它斜着移动怎么办呢？如果读懂了上面的代码，那么相信你完全可以编写出代码来。这就当成一个小练习吧，请自行完成。

这是用pygame制作的动态图片显示程序。

"""本程序定义了一个GIFImage类，这个类是Matthew编写，10年前的类，现在运行不了。
修改后可以， modifyed by lixingqiu@2019/4/8"""

import pygame
from PIL import Image
from pygame.locals import *

import time

class GIFImage(object):
    def __init__(self, filename):
        self.filename = filename
        self.image = Image.open(filename)
        self.frames = []
        self.get_frames()

        self.cur = 0
        self.ptime = time.time()

        self.running = True
        self.breakpoint = len(self.frames)-1
        self.startpoint = 0
        self.reversed = False

    def get_rect(self):
        return pygame.rect.Rect((0,0), self.image.size)

    def get_frames(self):
        image = self.image

        pal = image.getpalette()
        base_palette = []
        for i in range(0, len(pal), 3):
            rgb = pal[i:i+3]
            base_palette.append(rgb)

        all_tiles = []
        try:
            while 1:
                if not image.tile:
                    image.seek(0)
                if image.tile:
                    all_tiles.append(image.tile[0][3][0])
                image.seek(image.tell()+1)
        except EOFError:
            image.seek(0)

        all_tiles = tuple(set(all_tiles))

        try:
            while 1:
                try:
                    duration = image.info["duration"]
                except:
                    duration = 100

                duration *= .001 # 转换成毫秒
                cons = False

                x0, y0, x1, y1 = (0, 0) + image.size
                if image.tile:
                    tile = image.tile
                else:
                    image.seek(0)
                    tile = image.tile
                if len(tile) > 0:
                    x0, y0, x1, y1 = tile[0][1]

                if all_tiles:
                    if all_tiles in ((6,), (7,)):
                        cons = True
                        pal = image.getpalette()
                        palette = []
                        for i in range(0, len(pal), 3):
                            rgb = pal[i:i+3]
                            palette.append(rgb)
                    elif all_tiles in ((7, 8), (8, 7)):
                        pal = image.getpalette()
                        palette = []
                        for i in range(0, len(pal), 3):
                            rgb = pal[i:i+3]
                            palette.append(rgb)
                    else:
                        palette = base_palette
                else:
                    palette = base_palette

                pi = pygame.image.fromstring(image.tobytes(), image.size, image.mode)
                pi.set_palette(palette)
                if "transparency" in image.info:
                    pi.set_colorkey(image.info["transparency"])
                pi2 = pygame.Surface(image.size, SRCALPHA)
                if cons:
                    for i in self.frames:
                        pi2.blit(i[0], (0,0))
                pi2.blit(pi, (x0, y0), (x0, y0, x1-x0, y1-y0))

                self.frames.append([pi2, duration])
                image.seek(image.tell()+1)
        except EOFError:
            pass

    def render(self, screen, pos):
        if self.running:
            if time.time() - self.ptime > self.frames[self.cur][1]:
                if self.reversed:
                    self.cur -= 1
                    if self.cur < self.startpoint:
                        self.cur = self.breakpoint
                else:
                    self.cur += 1
                    if self.cur > self.breakpoint:
                        self.cur = self.startpoint

                self.ptime = time.time()

        screen.blit(self.frames[self.cur][0], pos)

    def seek(self, num):
        self.cur = num
        if self.cur < 0:
            self.cur = 0
        if self.cur >= len(self.frames):
            self.cur = len(self.frames)-1

    def set_bounds(self, start, end):
        """设置起始帧和结束帧"""
        if start < 0:
            start = 0
        if start >= len(self.frames):
            start = len(self.frames) - 1
        if end < 0:
            end = 0
        if end >= len(self.frames):
            end = len(self.frames) - 1
        if end < start:
            end = start
        self.startpoint = start
        self.breakpoint = end

    def pause(self):
        self.running = False

    def play(self):
        self.running = True

    def rewind(self):
        self.seek(0)
        
    def fastforward(self):
        self.seek(self.length()-1)

    def get_height(self):
        return self.image.size[1]
    def get_width(self):
        return self.image.size[0]
    def get_size(self):
        return self.image.size
    def length(self):
        return len(self.frames)
    def reverse(self):
        self.reversed = not self.reversed
    def reset(self):
        self.cur = 0
        self.ptime = time.time()
        self.reversed = False

    def copy(self):
        new = GIFImage(self.filename)
        new.running = self.running
        new.breakpoint = self.breakpoint
        new.startpoint = self.startpoint
        new.cur = self.cur
        new.ptime = self.ptime
        new.reversed = self.reversed
        return new
    
def event_check():
    """事件检测函数"""
    for event in pygame.event.get():
        if event.type == QUIT:
           return False
    return True
    
def main():
    
    pygame.init()
    lixingqiu = GIFImage("李兴球/8.gif")
    width,height = lixingqiu.get_size()
    screen = pygame.display.set_mode((width, height))
    
    # 当事件检测返回真则继续while循环
    while event_check():         
        lixingqiu.render(screen, (0, 0)) # 渲染gif图
        pygame.display.flip()       # 刷新显示
        
    pygame.quit()                   # 关闭窗口              
    

if __name__ == "__main__":
    
    main()