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

最新推荐文章于 2024-02-28 23:31:15 发布

信息化未来

最新推荐文章于 2024-02-28 23:31:15 发布

阅读量5.9k

点赞数

分类专栏：助孩成长文章标签： python 游戏 pygame

本文链接：https://blog.csdn.net/fqfq123456/article/details/127345055

版权

助孩成长专栏收录该内容

74 篇文章 17 订阅

订阅专栏

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

CSDN话题挑战赛第2期
参赛话题：学习笔记

主要需求

以前用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()  # 绘制玩家当前分解动作图片

3、动作与图片索引

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

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

    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]  # 再变成第一张分解动作图片

4、定义爆炸动作

destroy = None  # 精灵是否销毁

    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

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()  # 开始执行游戏

双精灵试验视频

双精灵

双精灵代码实现

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()  # 开始执行游戏

总结

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

源码获取

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

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

信息化未来

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
3
评论
小学生python游戏编程7----角色精灵定义

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

扫一扫