小学生python游戏编程7----角色精灵定义

主要需求

以前用pgzero做的游戏角色也好，敌人也好，一般用一张照片来表达，明显的不生动好玩，有时象僵尸，如何能生动的表达角色，敌人，今天就来学习使用pgzero来重新定义一下角色或敌人，就仿pygame中的暂叫作精灵吧。即用多副图片来表示角色，像玩家角色，一般会考虑，向左，向右，向上，向下时不同动作表不同的一组图片表示。
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

图片来自素材免费的网站：https://www.aigei.com/game2d/pkg/immortal_xia/?tab=file，真的不是多得的好网站

主要设计

1、总功能设计

定义一个精灵类，实现功能，可以控制每个精灵由哪些图片组成，每个动作指定相关图片索引，精灵可以在0左上，1向上，2右上，3向右，4 右下，5向下，6左下，7向左,8爆炸不同，设定图片索引。每个精灵可以以不同的速度移动，为以后想做些战略方面的小游戏作准备，如敌人随机出现，多角度击角色等。

2、功能实现

简单类的定义

class Jingling():  # 定义玩家控制的精灵类，带分解动画和移动功能
    actors = []  # 所有的分解动作图片，存在列表当中
    images_num = None  # 分解动作图片的张数
    images_index = None  # 需要显示的动作图片的序号
    images_speed = None  # 用于控制行走动画速度
    jingl_x = None  # 玩家的x坐标
    jingl_y = None  # 玩家的y坐标
    vx = None  # 玩家x方向的速度
    vy = None
    jingl_si = None  # 向方首索引
    jingl_yi = None  # 向方尾索引
    jingl_sy =[[],[],[],[],[],[],[],[]]  # 精灵索引，0左上，1向上，2右上，3向右，4 右下，5向下，6左下，7向左

    # 使用构造函数传递参数对对象初始化，分解动作图像列表，x,y坐标，x方向速度
    def __init__(self, actors, jingl_x, jingl_y, vx, vy, jingl_sy):
        self.actors = actors
        self.images_num = len(actors)  # 分解动作图片的张数
        self.jingl_x = jingl_x  # 设置精灵的x坐标
        self.jingl_y = jingl_y  # 设置精灵的y坐标
        self.vx = vx  # 设置玩家x方向的速度
        self.vy = vy  # 设置玩家x方向的速度
        self.images_index = 0  # 需要显示的动作图片的序号
        self.images_speed = 0  # 用于控制行走动画速度
        self.jingl_sy = jingl_sy
        for i in range(self.images_num):
            self.actors[i].x = jingl_x  # 设置所有分解动作图片的x坐标
            self.actors[i].y = jingl_y  # 设置所有分解动作图片的y坐标

    def draw(self):  # 绘制函数
        self.actors[self.images_index].draw()  # 绘制玩家当前分解动作图片
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

3、动作与图片索引

jingl_sy = [[], [], [], [], [], [], [], [], []]  # 精灵索引，0左上，1向上，2右上，3向右，4 右下，5向下，6左下，7向左,8爆炸
1

分别定义上下左右，左上，左下，右上，右下，爆炸等动作时如何引用索引

    def Movedown(self):  # 向下移动时的一些操作
        fy = 5
        if len(self.jingl_sy[fy]) == 2:
            if self.images_index < self.jingl_sy[fy][0] or self.images_index > self.jingl_sy[fy][1]:
                self.images_index = self.jingl_sy[fy][0]
            self.jingl_y += self.vy  # 精灵向下移动
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].y = self.jingl_y

            if (self.jingl_y > HEIGHT):  # 精灵走到最下边
                self.jingl_y = 0  # 再从最下边出现
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[fy][1]:  # 放完最后一个分解动作图片了
                    self.images_index = self.jingl_sy[fy][0]  # 再变成第一张分解动作图片
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4、定义爆炸动作

destroy = None  # 精灵是否销毁
1

    def Baozha(self):  # 爆炸
        fy = 8
        if len(self.jingl_sy[fy]) == 2:
            if self.images_index < self.jingl_sy[fy][0] or self.images_index > self.jingl_sy[fy][1]:
                self.images_index = self.jingl_sy[fy][0]

            self.jingl_x += int(self.vx / 2)  # 精灵向右下移动
            self.jingl_y += int(self.vy / 2)
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].x = self.jingl_x
                self.actors[i].y = self.jingl_y

            if (self.images_index > self.jingl_sy[fy][1]):  # 精灵走到最右边
                self.destroy = True
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[fy][1]:  # 放完最后一个分解动作图片了
                    self.destroy = True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5、使用类，结合图片索引，传递参数

精灵的分解动作图片、初始位置、速度、图片索引
actor_jqr = []
for i in range(73):
actor_jqr.append(Actor(‘dragon\’ + ‘%04d’ % i))
sy = [[0, 7], [32, 39], [24, 31], [16, 23], [48, 55], [40, 47], [56, 63], [8, 15], [65, 67]]
Jingling1 = Jingling(actor_jqr, WIDTH / 10, HEIGHT / 4, 5, 5, sy)

6、整数前补0，合成图片目录

%04d’ % i
这个可以试试体会一下
在这里插入图片描述

精灵类功能视频

20221016_112031

代码实现

import pgzrun  # 导入游戏库
from pgzero.actor import Actor
from pgzero.screen import Screen
# 拼间 两字，首字全拼尾字简，三字首字全拼尾均简
screen: Screen  # 类型标注
from pgzero.keyboard import keyboard

WIDTH = 900  # 设置窗口的宽度
HEIGHT = 600  # 设置窗口的高度
TITLE = "精灵类定义"

class Jingling():  # 定义玩家控制的精灵类，带分解动画和移动功能
    actors = []  # 所有的分解动作图片，存在列表当中
    images_num = None  # 分解动作图片的张数
    images_index = None  # 需要显示的动作图片的序号
    images_speed = None  # 用于控制行走动画速度
    jingl_x = None  # 玩家的x坐标
    jingl_y = None  # 玩家的y坐标
    vx = None  # 玩家x方向的速度
    vy = None
    jingl_si = None  # 向方首索引
    jingl_yi = None  # 向方尾索引
    jingl_sy =[[],[],[],[],[],[],[],[]]  # 精灵索引，0左上，1向上，2右上，3向右，4 右下，5向下，6左下，7向左

    # 使用构造函数传递参数对对象初始化，分解动作图像列表，x,y坐标，x方向速度
    def __init__(self, actors, jingl_x, jingl_y, vx, vy, jingl_sy):
        self.actors = actors
        self.images_num = len(actors)  # 分解动作图片的张数
        self.jingl_x = jingl_x  # 设置精灵的x坐标
        self.jingl_y = jingl_y  # 设置精灵的y坐标
        self.vx = vx  # 设置玩家x方向的速度
        self.vy = vy  # 设置玩家x方向的速度
        self.images_index = 0  # 需要显示的动作图片的序号
        self.images_speed = 0  # 用于控制行走动画速度
        self.jingl_sy = jingl_sy
        for i in range(self.images_num):
            self.actors[i].x = jingl_x  # 设置所有分解动作图片的x坐标
            self.actors[i].y = jingl_y  # 设置所有分解动作图片的y坐标

    def draw(self):  # 绘制函数
        self.actors[self.images_index].draw()  # 绘制玩家当前分解动作图片

    def MoveLU(self):  # 向左上移动时的一些操作
        if len(self.jingl_sy[0]) == 2:
            if self.images_index < self.jingl_sy[0][0] or self.images_index > self.jingl_sy[0][1]:
                self.images_index = self.jingl_sy[0][0]

            self.jingl_x -= int(self.vx/2)  # 精灵向左上移动
            self.jingl_y -= int(self.vy / 2)
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].x = self.jingl_x
                self.actors[i].y = self.jingl_y

            if (self.jingl_x < 0):  # 精灵走到最左边
                self.jingl_x = WIDTH  # 再从最左边出现
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[0][1]:  # 放完最后一个分解动作图片了
                    self.images_index = self.jingl_sy[0][0]  # 再变成第一张分解动作图片

    def MoveLeft(self):  # 向右移动时的一些操作
        if len(self.jingl_sy[7]) == 2:
            if self.images_index < self.jingl_sy[7][0] or self.images_index > self.jingl_sy[7][1]:
                self.images_index = self.jingl_sy[7][0]
            self.jingl_x -= self.vx   # 精灵向左移动
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].x = self.jingl_x

            if (self.jingl_x < 0):  # 精灵走到最左边
                self.jingl_x = WIDTH  # 再从最左边出现
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[7][1]:  # 放完最后一个分解动作图片了
                    self.images_index = self.jingl_sy[7][0]  # 再变成第一张分解动作图片
        else:
            print('无向左图片')
    
    def MoveRight(self):  # 向右移动时的一些操作
        if len(self.jingl_sy[3]) == 2:
            if self.images_index < self.jingl_sy[3][0] or self.images_index > self.jingl_sy[3][1]:
                self.images_index = self.jingl_sy[3][0]
            self.jingl_x += self.vx   # 精灵向左移动
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].x = self.jingl_x

            if (self.jingl_x > WIDTH):  # 精灵走到最左边
                self.jingl_x =0   # 再从最左边出现
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[3][1]:  # 放完最后一个分解动作图片了
                    self.images_index = self.jingl_sy[3][0]  # 再变成第一张分解动作图片

    def Movedown(self):  # 向下移动时的一些操作
        fy=5
        if len(self.jingl_sy[fy]) == 2:
            if self.images_index < self.jingl_sy[fy][0] or self.images_index > self.jingl_sy[fy][1]:
                self.images_index = self.jingl_sy[fy][0]
            self.jingl_y += self.vy   # 精灵向下移动
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].y = self.jingl_y

            if (self.jingl_y > HEIGHT):  # 精灵走到最下边
                self.jingl_y =0   # 再从最下边出现
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[fy][1]:  # 放完最后一个分解动作图片了
                    self.images_index = self.jingl_sy[fy][0]  # 再变成第一张分解动作图片

    def Moveup(self):  # 向上移动时的一些操作
        fy=1
        if len(self.jingl_sy[fy]) == 2:
            if self.images_index < self.jingl_sy[fy][0] or self.images_index > self.jingl_sy[fy][1]:
                self.images_index = self.jingl_sy[fy][0]
            self.jingl_y -= self.vy   # 精灵向上移动
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].y = self.jingl_y

            if (self.jingl_y < 0):  # 精灵走到最上边
                self.jingl_y = HEIGHT   # 再从最上边出现
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[fy][1]:  # 放完最后一个分解动作图片了
                    self.images_index = self.jingl_sy[fy][0]  # 再变成第一张分解动作图片
                    
    def MoveLD(self):  # 向左下移动时的一些操作
        fy = 6
        if len(self.jingl_sy[fy]) == 2:
            if self.images_index < self.jingl_sy[fy][0] or self.images_index > self.jingl_sy[fy][1]:
                self.images_index = self.jingl_sy[fy][0]

            self.jingl_x -= int(self.vx/2)  # 精灵向左下移动
            self.jingl_y += int(self.vy / 2)
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].x = self.jingl_x
                self.actors[i].y = self.jingl_y

            if (self.jingl_x < 0):  # 精灵走到最左边
                self.jingl_x = WIDTH  # 再从最左边出现
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[fy][1]:  # 放完最后一个分解动作图片了
                    self.images_index = self.jingl_sy[fy][0]  # 再变成第一张分解动作图片

    def MoveRU(self):  # 向右下移动时的一些操作
        fy = 2
        if len(self.jingl_sy[fy]) == 2:
            if self.images_index < self.jingl_sy[fy][0] or self.images_index > self.jingl_sy[fy][1]:
                self.images_index = self.jingl_sy[fy][0]

            self.jingl_x += int(self.vx/2)  # 精灵向右下移动
            self.jingl_y -= int(self.vy / 2)
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].x = self.jingl_x
                self.actors[i].y = self.jingl_y

            if (self.jingl_x > WIDTH):  # 精灵走到最右边
                self.jingl_x = 0  # 再从最左边出现
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[fy][1]:  # 放完最后一个分解动作图片了
                    self.images_index = self.jingl_sy[fy][0]  # 再变成第一张分解动作图片

    def MoveRD(self):  # 向右下移动时的一些操作
        fy = 4
        if len(self.jingl_sy[fy]) == 2:
            if self.images_index < self.jingl_sy[fy][0] or self.images_index > self.jingl_sy[fy][1]:
                self.images_index = self.jingl_sy[fy][0]

            self.jingl_x += int(self.vx/2)  # 精灵向右下移动
            self.jingl_y += int(self.vy / 2)
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].x = self.jingl_x
                self.actors[i].y = self.jingl_y

            if (self.jingl_x > WIDTH):  # 精灵走到最右边
                self.jingl_x = 0  # 再从最左边出现
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[fy][1]:  # 放完最后一个分解动作图片了
                    self.images_index = self.jingl_sy[fy][0]  # 再变成第一张分解动作图片

# 定义两个Jingling对象，并初始化
# 两个精灵的分解动作图片、初始位置、速度都不一样
actor_jqr = []
for i in range(73):
    actor_jqr.append(Actor('dragon\\' + '%04d' % i))
sy =  [[0,7],[32,39],[24,31],[16,23],[48,55],[40,47],[56,63],[8,15]]
Jingling1 = Jingling(actor_jqr, WIDTH / 10, HEIGHT / 4, 5, 5,sy)


def draw():  # 绘制模块，每帧重复执
    screen.fill('gray')  # 灰色背景
    Jingling1.draw()  # 绘制精灵1


def update():  # 更新模块，每帧重复操作
    if keyboard.q:  # 如果按下键盘Q键
        Jingling1.MoveLU()  # 精灵1向左上移动
    if keyboard.left or keyboard.a:  # 如果按下键盘左键
        Jingling1.MoveLeft()  # 精灵1向左移动
    if keyboard.right or keyboard.d:  # 如果按下键盘右键
        Jingling1.MoveRight()  # 精灵1向右移动
    if keyboard.down or keyboard.x:  # 如果按下键盘向下键
        Jingling1.Movedown()  # 精灵1向下移动
    if keyboard.up or keyboard.w:  # 如果按下键盘向下键
        Jingling1.Moveup()  # 精灵1向下移动
    if keyboard.z:
        Jingling1.MoveLD()
    if keyboard.c:
        Jingling1.MoveRD()
    if keyboard.e:
        Jingling1.MoveRU()

pgzrun.go()  # 开始执行游戏

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223

双精灵试验视频

双精灵

双精灵代码实现

import pgzrun  # 导入游戏库
from pgzero.actor import Actor
from pgzero.screen import Screen

# 拼间 两字，首字全拼尾字简，三字首字全拼尾均简
screen: Screen  # 类型标注
from pgzero.keyboard import keyboard

WIDTH = 800  # 设置窗口的宽度
HEIGHT = 600  # 设置窗口的高度


class Jingling():  # 定义玩家控制的精灵类，带分解动画和移动功能
    actors = []  # 所有的分解动作图片，存在列表当中
    images_num = None  # 分解动作图片的张数
    images_index = None  # 需要显示的动作图片的序号
    images_speed = None  # 用于控制行走动画速度
    jingl_x = None  # 玩家的x坐标
    jingl_y = None  # 玩家的y坐标
    vx = None  # 玩家x方向的速度
    vy = None
    jingl_si = None  # 向方首索引
    jingl_yi = None  # 向方尾索引
    jingl_sy = [[], [], [], [], [], [], [], [], []]  # 精灵索引，0左上，1向上，2右上，3向右，4 右下，5向下，6左下，7向左,8爆炸
    destroy = None  # 精灵是否销毁

    # 使用构造函数传递参数对对象初始化，分解动作图像列表，x,y坐标，x方向速度
    def __init__(self, actors, jingl_x, jingl_y, vx, vy, jingl_sy):
        self.actors = actors
        self.images_num = len(actors)  # 分解动作图片的张数
        self.jingl_x = jingl_x  # 设置精灵的x坐标
        self.jingl_y = jingl_y  # 设置精灵的y坐标
        self.vx = vx  # 设置玩家x方向的速度
        self.vy = vy  # 设置玩家x方向的速度
        self.images_index = 0  # 需要显示的动作图片的序号
        self.images_speed = 0  # 用于控制行走动画速度
        self.jingl_sy = jingl_sy  # 精灵索引
        self.destroy = False  # 精灵是否销毁
        for i in range(self.images_num):
            self.actors[i].x = jingl_x  # 设置所有分解动作图片的x坐标
            self.actors[i].y = jingl_y  # 设置所有分解动作图片的y坐标

    def draw(self):  # 绘制函数
        if not self.destroy:
            self.actors[self.images_index].draw()  # 绘制玩家当前分解动作图片
        # else:
        #     self.actors[self.images_index].clear()

    def MoveLU(self):  # 向左上移动时的一些操作
        if len(self.jingl_sy[0]) == 2:
            if self.images_index < self.jingl_sy[0][0] or self.images_index > self.jingl_sy[0][1]:
                self.images_index = self.jingl_sy[0][0]

            self.jingl_x -= int(self.vx / 2)  # 精灵向左上移动
            self.jingl_y -= int(self.vy / 2)
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].x = self.jingl_x
                self.actors[i].y = self.jingl_y

            if (self.jingl_x < 0):  # 精灵走到最左边
                self.jingl_x = WIDTH  # 再从最左边出现
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[0][1]:  # 放完最后一个分解动作图片了
                    self.images_index = self.jingl_sy[0][0]  # 再变成第一张分解动作图片

    def MoveLeft(self):  # 向右移动时的一些操作
        if len(self.jingl_sy[7]) == 2:
            if self.images_index < self.jingl_sy[7][0] or self.images_index > self.jingl_sy[7][1]:
                self.images_index = self.jingl_sy[7][0]
            self.jingl_x -= self.vx  # 精灵向左移动
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].x = self.jingl_x

            if (self.jingl_x < 0):  # 精灵走到最左边
                self.jingl_x = WIDTH  # 再从最左边出现
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[7][1]:  # 放完最后一个分解动作图片了
                    self.images_index = self.jingl_sy[7][0]  # 再变成第一张分解动作图片
        else:
            print('无向左图片')

    def MoveRight(self):  # 向右移动时的一些操作
        if len(self.jingl_sy[3]) == 2:
            if self.images_index < self.jingl_sy[3][0] or self.images_index > self.jingl_sy[3][1]:
                self.images_index = self.jingl_sy[3][0]
            self.jingl_x += self.vx  # 精灵向左移动
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].x = self.jingl_x

            if (self.jingl_x > WIDTH):  # 精灵走到最左边
                self.jingl_x = 0  # 再从最左边出现
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[3][1]:  # 放完最后一个分解动作图片了
                    self.images_index = self.jingl_sy[3][0]  # 再变成第一张分解动作图片

    def Movedown(self):  # 向下移动时的一些操作
        fy = 5
        if len(self.jingl_sy[fy]) == 2:
            if self.images_index < self.jingl_sy[fy][0] or self.images_index > self.jingl_sy[fy][1]:
                self.images_index = self.jingl_sy[fy][0]
            self.jingl_y += self.vy  # 精灵向下移动
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].y = self.jingl_y

            if (self.jingl_y > HEIGHT):  # 精灵走到最下边
                self.jingl_y = 0  # 再从最下边出现
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[fy][1]:  # 放完最后一个分解动作图片了
                    self.images_index = self.jingl_sy[fy][0]  # 再变成第一张分解动作图片

    def Moveup(self):  # 向上移动时的一些操作
        fy = 1
        if len(self.jingl_sy[fy]) == 2:
            if self.images_index < self.jingl_sy[fy][0] or self.images_index > self.jingl_sy[fy][1]:
                self.images_index = self.jingl_sy[fy][0]
            self.jingl_y -= self.vy  # 精灵向上移动
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].y = self.jingl_y

            if (self.jingl_y < 0):  # 精灵走到最上边
                self.jingl_y = HEIGHT  # 再从最上边出现
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[fy][1]:  # 放完最后一个分解动作图片了
                    self.images_index = self.jingl_sy[fy][0]  # 再变成第一张分解动作图片

    def MoveLD(self):  # 向左下移动时的一些操作
        fy = 6
        if len(self.jingl_sy[fy]) == 2:
            if self.images_index < self.jingl_sy[fy][0] or self.images_index > self.jingl_sy[fy][1]:
                self.images_index = self.jingl_sy[fy][0]

            self.jingl_x -= int(self.vx / 2)  # 精灵向左下移动
            self.jingl_y += int(self.vy / 2)
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].x = self.jingl_x
                self.actors[i].y = self.jingl_y

            if (self.jingl_x < 0):  # 精灵走到最左边
                self.jingl_x = WIDTH  # 再从最左边出现
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[fy][1]:  # 放完最后一个分解动作图片了
                    self.images_index = self.jingl_sy[fy][0]  # 再变成第一张分解动作图片

    def MoveRU(self):  # 向右下移动时的一些操作
        fy = 2
        if len(self.jingl_sy[fy]) == 2:
            if self.images_index < self.jingl_sy[fy][0] or self.images_index > self.jingl_sy[fy][1]:
                self.images_index = self.jingl_sy[fy][0]

            self.jingl_x += int(self.vx / 2)  # 精灵向右下移动
            self.jingl_y -= int(self.vy / 2)
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].x = self.jingl_x
                self.actors[i].y = self.jingl_y

            if (self.jingl_x > WIDTH):  # 精灵走到最右边
                self.jingl_x = 0  # 再从最左边出现
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[fy][1]:  # 放完最后一个分解动作图片了
                    self.images_index = self.jingl_sy[fy][0]  # 再变成第一张分解动作图片

    def MoveRD(self):  # 向右下移动时的一些操作
        fy = 4
        if len(self.jingl_sy[fy]) == 2:
            if self.images_index < self.jingl_sy[fy][0] or self.images_index > self.jingl_sy[fy][1]:
                self.images_index = self.jingl_sy[fy][0]

            self.jingl_x += int(self.vx / 2)  # 精灵向右下移动
            self.jingl_y += int(self.vy / 2)
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].x = self.jingl_x
                self.actors[i].y = self.jingl_y

            if (self.jingl_x > WIDTH):  # 精灵走到最右边
                self.jingl_x = 0  # 再从最左边出现
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[fy][1]:  # 放完最后一个分解动作图片了
                    self.images_index = self.jingl_sy[fy][0]  # 再变成第一张分解动作图片

    def Baozha(self):  # 爆炸
        fy = 8
        if len(self.jingl_sy[fy]) == 2:
            if self.images_index < self.jingl_sy[fy][0] or self.images_index > self.jingl_sy[fy][1]:
                self.images_index = self.jingl_sy[fy][0]

            self.jingl_x += int(self.vx / 2)  # 精灵向右下移动
            self.jingl_y += int(self.vy / 2)
            for i in range(self.images_num):  # 所有分解动作图片更新x坐标
                self.actors[i].x = self.jingl_x
                self.actors[i].y = self.jingl_y

            if (self.images_index > self.jingl_sy[fy][1]):  # 精灵走到最右边
                self.destroy = True
            self.images_speed += 1  # 用于控制动作动画速度
            if self.images_speed % 5 == 0:  # 动作动画速度是移动速度的1/5
                self.images_index += 1  # 每一帧分解动作图片序号加1
                if self.images_index >= self.jingl_sy[fy][1]:  # 放完最后一个分解动作图片了
                    self.destroy = True


# 定义两个Jingling对象，并初始化
# 两个精灵的分解动作图片、初始位置、速度都不一样
actor_jqr = []
for i in range(73):
    actor_jqr.append(Actor('dragon\\' + '%04d' % i))
sy = [[0, 7], [32, 39], [24, 31], [16, 23], [48, 55], [40, 47], [56, 63], [8, 15], [65, 67]]
Jingling1 = Jingling(actor_jqr, WIDTH / 10, HEIGHT / 4, 5, 5, sy)

muchs = []
for i in range(73):
    muchs.append(Actor('in_god\\' + '%04d' % i))
sy = [[0, 7], [32, 39], [24, 31], [16, 23], [48, 55], [40, 47], [56, 63], [8, 15], []]
much = Jingling(muchs, WIDTH / 10, HEIGHT / 4, 8, 8, sy)


def draw():  # 绘制模块，每帧重复执
    screen.fill('gray')  # 灰色背景
    Jingling1.draw()  # 绘制精灵1
    much.draw()


def Jingl_key(Jingling1):
    if keyboard.q:  # 如果按下键盘Q键
        Jingling1.MoveLU()  # 精灵1向左上移动
    if keyboard.left or keyboard.a:  # 如果按下键盘左键
        Jingling1.MoveLeft()  # 精灵1向左移动
    if keyboard.right or keyboard.d:  # 如果按下键盘右键
        Jingling1.MoveRight()  # 精灵1向右移动
    if keyboard.down or keyboard.x:  # 如果按下键盘向下键
        Jingling1.Movedown()  # 精灵1向下移动
    if keyboard.up or keyboard.w:  # 如果按下键盘向下键
        Jingling1.Moveup()  # 精灵1向下移动
    if keyboard.z:
        Jingling1.MoveLD()
    if keyboard.c:
        Jingling1.MoveRD()
    if keyboard.e:
        Jingling1.MoveRU()

    if keyboard.s:
        Jingling1.Baozha()


def update():  # 更新模块，每帧重复操作
    Jingl_key(Jingling1)
    Jingl_key(much)


pgzrun.go()  # 开始执行游戏

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266

总结

通过此次的《角色精灵定义》类实现，让我对python定义类，实现精灵的各种动作进一步了解，通过慢慢完善此类的功能，可以实现很多好玩的游戏功能，如果大家感兴趣，可以多多关注支持点赞。

源码获取

可关注博主后，私聊博主免费获取
需要技术指导，育娃新思考，企业软件合作等更多服务请联系博主

今天是以此模板持续更新此育儿专栏的第 7 /50次。
可以关注我，点赞我、评论我、收藏我啦。

相关阅读:
蓝牙核心规范（V5.4）10.5-BLE 入门笔记之HCI
前端——重要发送表单数据 post
平面设计师一定要知道的趁手工具
 微服务调用没有返回值，无法组成对象，但是会有feign的信息
 【matplotlib 实战】--雷达图
 Java零基础-集合：集合的搜索算法
 QT打开网页或者资源管理器：QDesktopServices以及QSettings 用法
 浏览器中的302你真的知道吗
 Java利用poi实现word,excel,ppt,pdf等各类型文档密码检测
 PythonOpenCV随机粘贴图像
原文地址：https://blog.csdn.net/fqfq123456/article/details/127345055