基于 Python 的横版 2D 动作类小游戏

游戏代码

游戏整体代码（基于 pygame 模块开发）

// An highlighted block
import pygame
import random


# Colors (R, G, B)
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)

WIDTH = 1280  # 游戏窗口宽度
HEIGHT = 700  # 游戏窗口高度
FPS = 100  # Frames Per Second

speed = 6  # 要求是 3 的倍数，类中用到了 speed / 3
gongji = 10

geshu = 5  # 地图个数


# 将一系列动作图片加载到一个列表中
def load_sprites(image_path, image_name_prefix, number_of_image, size_x=0, size_y=0):

    images = []  # 保存连续动作图片的列表

    for i in range(0, number_of_image):

        path = image_path + image_name_prefix + str(i) + '.png'  # 创建路径
        image = pygame.image.load(path).convert_alpha()  # 加载图片并将其转换为像素格式
        image.set_colorkey(WHITE)

        if size_x > 0 and size_y > 0:
            image = pygame.transform.scale(image, (size_x, size_y))  # 调节图片大小

        images.append(image)

    return images


# 加载单个图片
def load_image(image_path, image_name, size_x=0, size_y=0):

    path = image_path + image_name + '.png'  # 创建路径
    image = pygame.image.load(path).convert_alpha()  # 加载图片并将其转换为像素格式
    image.set_colorkey(WHITE)

    if size_x > 0 and size_y > 0:
        image = pygame.transform.scale(image, (size_x, size_y))  # 调节图片大小

    return image


def begin():
    global running
    beijing_rect.left = 0
    beijing_rect.top = 0
    title_rect.left = 300
    title_rect.top = 150
    screen.blit(beijing, beijing_rect)
    screen.blit(title, title_rect)
    pygame.display.flip()
    wait = True
    while wait:
        clock.tick(FPS)
        for shijian in pygame.event.get():
            if shijian.type == pygame.QUIT:
                running = False
                wait = False
            if shijian.type == pygame.KEYUP:
                wait = False


class Player(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)

        self.idle_images = load_sprites('image/Player/Idle/', 'Idle_', 1)
        self.idle_fan_images = load_sprites('image/Player/Idle/', 'Idle_fan_', 1)
        self.running_images = load_sprites('image/Player/Run/', 'Run_', 4)
        self.running_fan_images = load_sprites('image/Player/Run/', 'Run_fan_', 4)
        self.hurt_images = load_sprites('image/Player/Hurt/', 'Hurt_', 1)
        self.hurt_fan_images = load_sprites('image/Player/Hurt/', 'Hurt_fan_', 1)

        self.die_images = load_sprites('image/Player/Die/', 'Die_', 5)
        self.die_fan_images = load_sprites('image/Player/Die/', 'Die_', 5)
        for i in range(5):
            self.die_fan_images[i] = pygame.transform.flip(self.die_fan_images[i], True, False)
        self.combo_images = load_sprites('image/Player/Combo/', 'Combo_', 9)
        self.combo_fan_images = load_sprites('image/Player/Combo/', 'Combo_', 9)
        for i in range(9):
            self.combo_fan_images[i] = pygame.transform.flip(self.combo_fan_images[i], True, False)
        self.skill_0_images = load_sprites('image/Player/Skill/Skill_0/', 'Ren_', 7)
        self.skill_0_fan_images = load_sprites('image/Player/Skill/Skill_0/', 'Ren_', 7)
        for i in range(7):
            self.skill_0_fan_images[i] = pygame.transform.flip(self.skill_0_fan_images[i], True, False)
        self.skill_1_images = load_sprites('image/Player/Skill/Skill_1/', 'Ren_', 7)
        self.skill_1_fan_images = load_sprites('image/Player/Skill/Skill_1/', 'Ren_', 7)
        for i in range(7):
            self.skill_1_fan_images[i] = pygame.transform.flip(self.skill_1_fan_images[i], True, False)
        self.skill_2_images = load_sprites('image/Player/Skill/Skill_2/', 'Ren_', 7)
        self.skill_2_fan_images = load_sprites('image/Player/Skill/Skill_2/', 'Ren_', 7)
        for i in range(7):
            self.skill_2_fan_images[i] = pygame.transform.flip(self.skill_2_fan_images[i], True, False)

        self.huifu_images = load_sprites('image/Player/Skill/Buff/', 'Ren_', 18)
        self.huifu_fan_images = load_sprites('image/Player/Skill/Buff/', 'Ren_', 18)
        for i in range(18):
            self.huifu_fan_images[i] = pygame.transform.flip(self.huifu_fan_images[i], True, False)
        self.texiao_images = load_sprites('image/Player/Skill/Buff/', 'Texiao_', 5)
        self.texiao_fan_images = load_sprites('image/Player/Skill/Buff/', 'Texiao_', 5)
        for i in range(5):
            self.texiao_fan_images[i] = pygame.transform.flip(self.texiao_fan_images[i], True, False)

        self.win_images = load_sprites('image/Player/Win/', 'Win_', 5)
        self.win_fan_images = load_sprites('image/Player/Win/', 'Win_', 5)
        for i in range(5):
            self.texiao_fan_images[i] = pygame.transform.flip(self.texiao_fan_images[i], True, False)

        self.born_images = load_sprites('image/Player/Born/', 'Born_', 17)

        self.image = self.idle_images[0]

        self.rect = self.idle_images[0].get_rect()

        self.born_rect = self.born_images[0].get_rect()

        self.radius = int(self.rect.width * 1 / 5)  # 规定碰撞半径

        self.rect.bottom = HEIGHT - 50
        self.rect.left = 50

        self.born_rect.bottom = self.rect.bottom - 50
        self.born_rect.left = self.rect.left + 60

        self.hp = 100
        self.mp = 100
        self.gongji = gongji

        self.born_index = 0
        self.idle_index = 0
        self.running_index = 0
        self.die_index = 0
        self.hurt_index = 0
        self.fight_index = 0
        self.skill_index = 0
        self.buff_index = 0
        self.win_index = 0

        self.fan = False

        self.speed_heng = speed
        self.speed_shu = speed * 3 / 4

        self.born = True
        self.idle = False
        self.running = False
        self.die = False
        self.hurt = False
        self.fighting = False
        self.win = False

        self.combo = False

        self.skill = False
        self.skill_0 = False
        self.skill_1 = False
        self.skill_2 = False

        self.huifu = False
        self.brave = False

        self.daji = False

        self.bofang_win = True
        self.bofang_defeat = True

        self.count = 0  # 调节动作快慢
        self.hurt_count = 0  # 调节受伤动作持续时间
        self.fight_count = 0
        self.skill_count = 5
        self.brave_count = 0
        self.buff_count = 5

    def update(self):

        global gameover

        # 首先判断是否死亡
        if self.hp <= 1:
            self.die = True
            self.idle = False
            self.running = False
            self.hurt = False
            self.fighting = False
            self.huifu = False
            self.brave = False
            if self.die_index == 4:
                gameover = True
            self.hp = 1

        if self.die and self.bofang_defeat:
            defeat_sound.play()
            self.bofang_defeat = False

        if self.win and self.bofang_win:
            win_sound.play()
            self.bofang_win = False

        # 被打击时停止一切活动,但是技能不会被打断
        if self.hurt and not self.skill:
            self.idle = False
            self.running = False
            self.fighting = False

            self.running_index = 0
            self.fight_index = 0

        # 出生
        if self.born:
            if self.born_index == 16:
                self.born = False

        # 确定当前动作

        if self.fan:
            if self.idle:
                self.image = self.idle_fan_images[self.idle_index]
            if self.running:
                self.image = self.running_fan_images[self.running_index]
            if self.die:
                self.image = self.die_fan_images[self.die_index]
            if self.hurt:
                self.image = self.hurt_fan_images[self.hurt_index]
            if self.fighting:
                if self.combo:
                    self.image = self.combo_fan_images[self.fight_index]
                if self.skill_0:
                    self.image = self.skill_0_fan_images[self.skill_index]
                if self.skill_1:
                    self.image = self.skill_1_fan_images[self.skill_index]
                if self.skill_2:
                    self.image = self.skill_2_fan_images[self.skill_index]
            if self.huifu or self.brave:
                self.image = self.huifu_fan_images[self.buff_index]

            if self.win:
                self.image = self.win_fan_images[self.win_index]

        else:
            if self.idle:
                self.image = self.idle_images[self.idle_index]
            if self.running:
                self.image = self.running_images[self.running_index]
            if self.die:
                self.image = self.die_images[self.die_index]
            if self.hurt:
                self.image = self.hurt_images[self.hurt_index]
            if self.fighting:
                if self.combo:
                    self.image = self.combo_images[self.fight_index]
                if self.skill_0:
                    self.image = self.skill_0_images[self.skill_index]
                if self.skill_1:
                    self.image = self.skill_1_images[self.skill_index]
                if self.skill_2:
                    self.image = self.skill_2_images[self.skill_index]
            if self.huifu or self.brave:
                self.image = self.huifu_images[self.buff_index]

            if self.win:
                self.image = self.win_images[self.win_index]

        if self.born:
            self.image = self.born_images[self.born_index]

        # 玩家攻击碰撞检测

        if self.fighting:
            enemy = pygame.sprite.spritecollide(player, enemy_sprites, False, pygame.sprite.collide_circle)
            if self.combo and (
                    self.fight_index == 2 or self.fight_index == 4 or self.fight_index == 6) and self.daji:
                for diren in enemy:
                    if abs(player.rect.center[1] - diren.rect.center[1]) < 30:
                        diren.hurt = True
                        if self.fight_index == 2:
                            diren.hp -= 0.5 * self.gongji
                        if self.fight_index == 4:
                            diren.hp -= self.gongji
                        if self.fight_index == 2:
                            diren.hp -= 1.5 * self.gongji
                self.daji = False

            if (self.skill_0 or self.skill_1) and self.skill_index == 3 and self.daji:
                for diren in enemy:
                    if abs(player.rect.center[1] - diren.rect.center[1]) < 30:
                        diren.hurt = True
                        diren.hp -= 3 * self.gongji
                self.daji = False

            if self.skill_2 and self.skill_index == 3 and self.daji:
                for diren in enemy:
                    if abs(player.rect.center[1] - diren.rect.center[1]) < 30:
                        diren.hurt = True
                        diren.hp -= 5 * self.gongji
                self.daji = False

        # 根据输入判定下一步行为动作

        keystate = pygame.key.get_pressed()

        # 移动

        if keystate[pygame.K_w] or keystate[pygame.K_a] or keystate[pygame.K_s] or keystate[pygame.K_d]:
            self.running = True
            self.idle = False

        else:
            self.running = False
            self.idle = True
            self.running_index = 0  # 恢复初始动作

        # 攻击

        if (keystate[pygame.K_j] or keystate[pygame.K_u] or keystate[pygame.K_i] or keystate[pygame.K_o]) and \
                not self.win:

            self.fighting = True

        if self.fighting and not self.die:

            if keystate[pygame.K_j] and not self.skill:
                self.combo = True
                self.idle = False

                self.running = False
                self.running_index = 0  # 恢复初始动作

            elif self.combo and (self.fight_index == 2 or self.fight_index == 4 or self.fight_index == 6):
                self.combo = False
                self.fight_index = 0
                self.fight_count = 0
                if not running:
                    self.idle = True

            if self.skill_0 or self.skill_1 or self.skill_2 or self.huifu or self.brave:
                self.skill = True
            else:
                self.skill = False

            if keystate[pygame.K_u] and not self.combo and not self.skill and self.mp >= 30:
                self.mp -= 30

                self.skill_0 = True
                self.idle = False

                self.running = False
                self.running_index = 0  # 恢复初始动作

                jineng = PlayerSkillZhan()
                all_sprites.add(jineng)

            elif self.skill_0 and self.skill_index == 6:
                self.skill_0 = False
                self.skill_index = 0
                self.skill_count = 5
                if not running:
                    self.idle = True

            if keystate[pygame.K_i] and not self.combo and not self.skill and self.mp >= 30:
                self.mp -= 30

                self.skill_1 = True
                self.idle = False

                self.running = False
                self.running_index = 0  # 恢复初始动作

                jineng = PlayerSkillTiao()
                all_sprites.add(jineng)

            elif self.skill_1 and self.skill_index == 6:
                self.skill_1 = False
                self.skill_index = 0
                self.skill_count = 5
                if not running:
                    self.idle = True

            if keystate[pygame.K_o] and not self.combo and not self.skill and self.mp >= 50:
                self.mp -= 50

                self.skill_2 = True
                self.idle = False

                self.running = False
                self.running_index = 0  # 恢复初始动作

                jineng = PlayerSkillChop()
                all_sprites.add(jineng)

            elif self.skill_2 and self.skill_index == 6:
                self.skill_2 = False
                self.skill_index = 0
                self.skill_count = 5
                if not running:
                    self.idle = True

        if keystate[pygame.K_k] and not self.combo and not self.skill and not self.die and not self.win:
            self.huifu = True
            self.buff_count = 5

            self.idle = False
            self.running = False
            self.running_index = 0  # 恢复初始动作

            jineng = PlayerBuff()
            all_sprites.add(jineng)

        elif self.huifu and self.buff_index == 17:
            self.huifu = False
            self.buff_index = 0
            if not running:
                self.idle = True

        elif self.huifu:
            self.hp += 0.2
            if self.hp >= 100:
                self.hp = 100

        if keystate[pygame.K_l] and not self.combo and not self.skill and not self.die and not self.win:
            self.brave = True
            self.buff_count = 5

            self.idle = False
            self.running = False
            self.running_index = 0  # 恢复初始动作

            jineng = PlayerBuff()
            all_sprites.add(jineng)

        elif self.brave and self.buff_index == 17:
            self.brave = False
            self.buff_index = 0
            self.buff_count = 5
            if not running:
                self.idle = True

        if self.brave and self.buff_index == 15:
            self.gongji = 2 * gongji
            self.brave_count = 0
        elif self.brave_count >= 300:
            self.gongji = gongji

        # 及时取消玩家释放技能状态

        if self.skill_0 or self.skill_1 or self.skill_2 or self.huifu or self.brave:
            self.skill = True
        else:
            self.skill = False

        if not self.combo and not self.skill_0 and not self.skill_1 and not self.skill_2:

            self.fighting = False

        # 玩家移动

        # 调整玩家进行攻击动作时的移动速度
        if self.fighting:
            self.speed_heng = speed / 3
        else:
            self.speed_heng = speed

        # 移动
        if not self.die and not self.skill and not self.born and not self.win:
            if keystate[pygame.K_a]:
                self.fan = True
                self.rect.x = self.rect.x - self.speed_heng
            if keystate[pygame.K_d]:
                self.fan = False
                if not background.bianjie:
                    self.rect.x = self.rect.x + self.speed_heng
            if keystate[pygame.K_w]:
                self.rect.y = self.rect.y - self.speed_shu
            if keystate[pygame.K_s]:
                self.rect.y = self.rect.y + self.speed_shu

        # 限制玩家位置

        if self.rect.left < 0:
            self.rect.left = 0
        if self.rect.right > WIDTH:
            self.rect.right = WIDTH
        if self.rect.top < HEIGHT / 4 - 20:
            self.rect.top = HEIGHT / 4 - 20
        if self.rect.bottom > HEIGHT - 100:
            self.rect.bottom = HEIGHT - 100

        # 控制各个动作的频率

        if self.running and self.count % 6 == 0:
            self.running_index = (self.running_index + 1) % 4
        if self.die and self.count % 10 == 0 and self.die_index < 4:
            self.die_index = self.die_index + 1
        if self.hurt and self.hurt_count % 15 == 0:
            self.hurt = False

        if self.fighting and self.combo and self.fight_count % 6 == 0:
            self.daji = True
            self.fight_index = (self.fight_index + 1) % 9

        if self.fighting and (self.skill_0 or self.skill_1 or self.skill_2) and self.skill_count % 6 == 0:
            self.daji = True
            self.skill_index = self.skill_index + 1

        if self.huifu and self.buff_count % 6 == 0:
            self.buff_index = self.buff_index + 1

        if self.brave and self.buff_count % 6 == 0:
            self.buff_index = self.buff_index + 1

        if self.born and self.count % 6 == 0:
            self.born_index = self.born_index + 1

        if self.win and self.count % 6 == 0:
            self.win_index = (self.win_index + 1) % 5

        # 控制回蓝速度

        if self.count % 10 == 0:
            self.mp += 1
            if self.mp > 100:
                self.mp = 100

        # 更新各项计数器

        self.count = self.count + 1
        self.hurt_count = self.hurt_count + 1
        self.fight_count = self.fight_count + 1
        self.skill_count = self.skill_count + 1
        self.buff_count = self.buff_count + 1

    def draw(self):
        if self.born:
            screen.blit(self.image, self.born_rect)
        else:
            screen.blit(self.image, self.rect)


class PlayerSkillZhan(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)

        self.skill_0_images = skill_0_L0_images
        self.skill_0_fan_images = skill_0_L0_fan_images

        self.skill_index = 0

        if player.fan:
            self.image = self.skill_0_fan_images[self.skill_index]
        else:
            self.image = self.skill_0_images[self.skill_index]

        self.rect = self.image.get_rect()

        self.rect.bottom = player.rect.bottom - 10

        if player.fan:
            self.rect.left = player.rect.left - 20
        else:
            self.rect.left = player.rect.left - 35

        self.skill_count = 0

    def update(self):

        self.rect.bottom = player.rect.bottom - 10

        if player.fan:
            self.rect.left = player.rect.left - 20
        else:
            self.rect.left = player.rect.left - 35

        if player.fan:
            self.image = self.skill_0_fan_images[self.skill_index]

        else:
            self.image = self.skill_0_images[self.skill_index]

        if self.skill_count % 6 == 0:
            self.skill_index = self.skill_index + 1
            if self.skill_index > 5:
                self.kill()

        self.skill_count = self.skill_count + 1

    def draw(self):

        screen.blit(self.image, self.rect)


class PlayerSkillTiao(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)

        self.skill_1_images = skill_1_L0_images
        self.skill_1_fan_images = skill_1_L0_fan_images

        self.skill_index = 0

        if player.fan:
            self.image = self.skill_1_fan_images[self.skill_index]
        else:
            self.image = self.skill_1_images[self.skill_index]

        self.rect = self.image.get_rect()

        self.rect.bottom = player.rect.bottom

        if player.fan:
            self.rect.left = player.rect.left - 400
        else:
            self.rect.left = player.rect.left - 400

        self.skill_count = 0

    def update(self):

        self.rect.bottom = player.rect.bottom

        if player.fan:
            self.rect.left = player.rect.left - 400
        else:
            self.rect.left = player.rect.left - 400

        if player.fan:
            self.image = self.skill_1_fan_images[self.skill_index]

        else:
            self.image = self.skill_1_images[self.skill_index]

        if self.skill_count % 6 == 0:
            self.skill_index = self.skill_index + 1
            if self.skill_index > 5:
                self.kill()

        self.skill_count = self.skill_count + 1

    def draw(self):

        screen.blit(self.image, self.rect)


class PlayerSkillChop(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)

        self.skill_2_images = skill_2_L0_images
        self.skill_2_fan_images = skill_2_L0_fan_images

        self.skill_index = 0

        if player.fan:
            self.image = self.skill_2_fan_images[self.skill_index]
        else:
            self.image = self.skill_2_images[self.skill_index]

        self.rect = self.image.get_rect()

        self.rect.bottom = player.rect.bottom - 15

        self.rect.left = player.rect.left - 5

        self.skill_count = 0

    def update(self):

        self.rect.bottom = player.rect.bottom - 15

        self.rect.left = player.rect.left - 5

        if player.fan:
            self.image = self.skill_2_fan_images[self.skill_index]

        else:
            self.image = self.skill_2_images[self.skill_index]

        if self.skill_count % 6 == 0:
            self.skill_index = self.skill_index + 1
            if self.skill_index > 5:
                self.kill()

        self.skill_count = self.skill_count + 1

    def draw(self):

        screen.blit(self.image, self.rect)


class PlayerBuff(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)

        self.huifu_images = huifu_images
        self.huifu_fan_images = huifu_fan_images

        self.skill_index = 0

        if player.fan:
            self.image = self.huifu_fan_images[self.skill_index]
        else:
            self.image = self.huifu_images[self.skill_index]

        self.rect = self.image.get_rect()

        self.rect.bottom = player.rect.bottom

        self.rect.left = player.rect.left

        self.skill_count = 0

    def update(self):

        if player.fan:
            self.image = self.huifu_fan_images[self.skill_index]

        else:
            self.image = self.huifu_images[self.skill_index]

        if self.skill_count % 6 == 0:
            self.skill_index = self.skill_index + 1
            if self.skill_index > 16:
                self.kill()

        self.skill_count = self.skill_count + 1

    def draw(self):

        screen.blit(self.image, self.rect)


class Bone(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)

        self.idle_images = load_sprites('image/Monster/Bone/Idle/', 'Idle_', 4)
        self.idle_fan_images = load_sprites('image/Monster/Bone/Idle/', 'Idle_', 4)
        for i in range(4):
            self.idle_fan_images[i] = pygame.transform.flip(self.idle_fan_images[i], True, False)
        self.walk_images = load_sprites('image/Monster/Bone/Walk/', 'Walk_', 4)
        self.walk_fan_images = load_sprites('image/Monster/Bone/Walk/', 'Walk_', 4)
        for i in range(4):
            self.walk_fan_images[i] = pygame.transform.flip(self.walk_fan_images[i], True, False)
        self.attack_images = load_sprites('image/Monster/Bone/Attack/', 'Attack_', 8)
        self.attack_fan_images = load_sprites('image/Monster/Bone/Attack/', 'Attack_', 8)
        for i in range(8):
            self.attack_fan_images[i] = pygame.transform.flip(self.attack_fan_images[i], True, False)
        self.die_images = load_sprites('image/Monster/Bone/Die/', 'Die_', 3)
        self.die_fan_images = load_sprites('image/Monster/Bone/Die/', 'Die_', 3)
        for i in range(3):
            self.die_fan_images[i] = pygame.transform.flip(self.die_fan_images[i], True, False)
        self.hurt_images = load_sprites('image/Monster/Bone/Hurt/', 'Jump_', 1)
        self.hurt_fan_images = load_sprites('image/Monster/Bone/Hurt/', 'Jump_', 1)
        for i in range(1):
            self.hurt_fan_images[i] = pygame.transform.flip(self.hurt_fan_images[i], True, False)

        self.skill_blood_images = load_sprites('image/Monster/Bone/Skill/', 'Blood_', 3)
        self.skill_blood_fan_images = load_sprites('image/Monster/Bone/Skill/', 'Blood_', 3)
        for i in range(3):
            self.skill_blood_fan_images[i] = pygame.transform.flip(self.skill_blood_fan_images[i], True, False)
        self.skill_splash_images = load_sprites('image/Monster/Bone/Skill/', 'Splash_', 4)
        self.skill_splash_fan_images = load_sprites('image/Monster/Bone/Skill/', 'Splash_', 4)
        for i in range(4):
            self.skill_splash_fan_images[i] = pygame.transform.flip(self.skill_splash_fan_images[i], True, False)
        self.skill_range_images = load_sprites('image/Monster/Bone/Skill/', 'Range_', 8)
        self.skill_range_fan_images = load_sprites('image/Monster/Bone/Skill/', 'Range_', 8)
        for i in range(8):
            self.skill_range_fan_images[i] = pygame.transform.flip(self.skill_range_fan_images[i], True, False)

        self.image = self.idle_images[0]

        self.rect = self.idle_images[0].get_rect()

        self.rect.left = WIDTH
        self.rect.bottom = HEIGHT - 30

        self.radius = int(self.rect.width * 1 / 5)

        self.hp = 400

        self.idle_index = 0
        self.walk_index = 0
        self.attack_index = 0
        self.die_index = 0
        self.hurt_index = 0
        self.skill_index = 0

        self.daji = False  # 控制玩家掉血频率

        self.fan = False

        self.speed_heng = speed * 2 / 3
        self.speed_shu = speed / 2

        self.idle = True
        self.walk = False
        self.attack = False
        self.die = False
        self.hurt = False
        self.skill = False

        self.fang = False

        self.hurt_count = 0  # 调节受伤动作持续时间
        self.count = 0  # 调节动作快慢

    def update(self):

        # 首先判断是否死亡
        if self.hp <= 0:
            self.die = True
            self.idle = False
            self.walk = False
            self.attack = False
            self.hurt = False
            self.skill = False
            if self.die_index > 2:
                self.die_index = 2
                self.kill()

        # 被打击时停止一切活动
        if self.hurt:
            self.idle = False
            self.walk = False
            self.skill = False
            self.attack = False

            self.idle_index = 0
            self.walk_index = 0
            self.skill_index = 0
            self.attack_index = 0

        if self.fan:
            if self.idle:
                self.image = self.idle_fan_images[self.idle_index]
            if self.walk:
                self.image = self.walk_fan_images[self.walk_index]
            if self.attack:
                self.image = self.attack_fan_images[self.attack_index]
            if self.die:
                self.image = self.die_fan_images[self.die_index]
            if self.hurt:
                self.image = self.hurt_fan_images[self.hurt_index]
            if self.skill:
                self.image = self.skill_range_fan_images[self.skill_index]
        else:
            if self.idle:
                self.image = self.idle_images[self.idle_index]
            if self.walk:
                self.image = self.walk_images[self.walk_index]
            if self.attack:
                self.image = self.attack_images[self.attack_index]
            if self.die:
                self.image = self.die_images[self.die_index]
            if self.hurt:
                self.image = self.hurt_images[self.hurt_index]
            if self.skill:
                self.image = self.skill_range_images[self.skill_index]

        # 选择动作

        if 650 < abs(self.rect.center[0] - player.rect.center[0]) < 800 or \
                (abs(self.rect.center[1] - player.rect.center[1]) > 10 and
                 abs(self.rect.center[0] - player.rect.center[0]) < 800) or \
                (abs(self.rect.center[0] - player.rect.center[0]) > 800 and
                 self.rect.center[0] < player.rect.center[0]) or \
                (self.rect.left < 0 or self.rect.right > WIDTH):
            self.idle = False
            self.walk = True
            self.attack = False
            self.skill = False
            # 恢复初始动作
            self.attack_index = 0
            self.skill_index = 0

        if 2 * self.radius < abs(self.rect.center[0] - player.rect.center[0]) < 650 and \
                abs(self.rect.center[1] - player.rect.center[1]) < 10 and \
                not (self.rect.left < 0 or self.rect.right > WIDTH):
            self.idle = False
            self.walk = False
            self.attack = False
            self.skill = True
            # 恢复初始动作
            self.walk_index = 0
            self.attack_index = 0

        if abs(self.rect.center[0] - player.rect.center[0]) < 2 * self.radius and \
                abs(self.rect.center[1] - player.rect.center[1]) < 10 and \
                not (self.rect.left < 0 or self.rect.right > WIDTH):
            self.idle = False
            self.walk = False
            self.attack = True
            self.skill = False
            # 恢复初始动作
            self.walk_index = 0
            self.skill_index = 0

        if ((abs(self.rect.center[0] - player.rect.center[0]) >= 800 and
                self.rect.center[0] > player.rect.center[0]) and
                not (self.rect.left < 0 or self.rect.right > WIDTH)) or player.die:
            self.idle = True
            self.walk = False
            self.attack = False
            self.skill = False
            # 恢复初始动作
            self.walk_index = 0
            self.attack_index = 0
            self.skill_index = 0

        # 移动

        if self.walk and ((player.rect.center[0] < self.rect.center[0] and
                          abs(self.rect.center[0] - player.rect.center[0]) > 550) or self.rect.right > WIDTH):
            self.rect.x = self.rect.x - self.speed_heng

        if self.walk and ((player.rect.center[0] > self.rect.center[0] and
                          abs(self.rect.center[0] - player.rect.center[0]) > 550) or self.rect.left < 0):
            self.rect.x = self.rect.x + self.speed_heng

        if self.walk and player.rect.center[1] < self.rect.center[1]:
            self.rect.y = self.rect.y - self.speed_shu

        if self.walk and player.rect.center[1] > self.rect.center[1]:
            self.rect.y = self.rect.y + self.speed_shu

        # 判断朝向

        if player.rect.center[0] < self.rect.center[0]:
            self.fan = False

        else:
            self.fan = True

        # 随地图移动

        if background.dong:
            if not player.skill:
                if player.fighting:
                    self.rect.x = self.rect.x - background.speed
                else:
                    self.rect.x = self.rect.x - background.speed

        if self.rect.top < HEIGHT / 4 - 20:
            self.rect.top = HEIGHT / 4 - 20
        if self.rect.bottom > HEIGHT - 100:
            self.rect.bottom = HEIGHT - 100

        if self.idle and self.count % 6 == 0:
            self.idle_index = (self.idle_index + 1) % 4
        if self.walk and self.count % 6 == 0:
            self.walk_index = (self.walk_index + 1) % 4
        if self.attack and self.count % 6 == 0:
            if self.attack_index == 5:
                self.daji = True
            self.attack_index = (self.attack_index + 1) % 8
        if self.die and self.count % 10 == 0:
            self.die_index = self.die_index + 1
        if self.hurt and self.hurt_count % 15 == 0:
            self.hurt = False
        if self.skill and self.count % 6 == 0:
            if self.skill_index == 5:
                self.fang = True
            self.skill_index = (self.skill_index + 1) % 8

        # 攻击

        # 释放技能
        if self.skill and self.fang:
            self.fang = False
            xue = BoneSkill()
            all_sprites.add(xue)
            bone_skill.add(xue)

        # 判断是否攻击（是否和玩家碰撞）
        if self.attack:
            if abs(player.rect.center[0] - self.rect.center[0]) < 2 * self.radius and \
                    abs(player.rect.center[1] - self.rect.center[1]) < 30 and self.daji:
                self.daji = False
                player.hurt = True
                player.hp -= 20

        self.hurt_count = self.hurt_count + 1
        self.count = self.count + 1

    def draw(self):

        screen.blit(self.image, self.rect)


class BoneSkill(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)

        self.skill_blood_images = load_sprites('image/Monster/Bone/Skill/', 'Blood_', 3)
        self.skill_blood_fan_images = load_sprites('image/Monster/Bone/Skill/', 'Blood_', 3)
        for i in range(3):
            self.skill_blood_fan_images[i] = pygame.transform.flip(self.skill_blood_fan_images[i], True, False)
        self.skill_splash_images = load_sprites('image/Monster/Bone/Skill/', 'Splash_', 4)
        self.skill_splash_fan_images = load_sprites('image/Monster/Bone/Skill/', 'Splash_', 4)
        for i in range(4):
            self.skill_splash_fan_images[i] = pygame.transform.flip(self.skill_splash_fan_images[i], True, False)

        self.image = self.skill_blood_images[0]

        self.rect = self.skill_blood_images[0].get_rect()

        # 确定初始方向，不再更改
        if bone.fan:
            self.fan = True
        else:
            self.fan = False

        self.rect.bottom = bone.rect.center[1]

        if self.fan:
            self.rect.left = bone.rect.center[0]
        else:
            self.rect.right = bone.rect.center[0]

        self.blood_index = 0
        self.splash_index = 0

        self.speed_heng = 1.5 * speed

        self.blood = True
        self.splash = False

        self.count = 0  # 调节动作快慢

    def update(self, *args):

        if self.fan:
            if self.blood:
                self.image = self.skill_blood_fan_images[self.blood_index]
            if self.splash:
                self.image = self.skill_splash_images[self.splash_index]
        else:
            if self.blood:
                self.image = self.skill_blood_images[self.blood_index]
            if self.splash:
                self.image = self.skill_splash_fan_images[self.splash_index]

        # 判断和玩家碰撞

        if abs(player.rect.center[0] - self.rect.center[0]) < 30 and \
                abs(player.rect.center[1] - 30 - self.rect.center[1]) < 30 and not self.splash:

            self.splash = True
            self.blood = False

            self.rect.y = self.rect.y - 60

            if self.fan:
                self.rect.x = self.rect.x - 80

            player.hurt = True
            player.hp -= 40

        if self.blood:
            if self.fan:
                self.rect.x = self.rect.x + self.speed_heng
            else:
                self.rect.x = self.rect.x - self.speed_heng

        if self.rect.right < 0 and self.rect.right < bone.rect.left:
            self.kill()
        if self.rect.left > WIDTH and self.rect.right > bone.rect.right:
            self.kill()
        if self.splash_index == 3:
            self.kill()

        if self.blood and self.count % 6 == 0:
            self.blood_index = (self.blood_index + 1) % 3
        if self.splash and self.count % 6 == 0:
            self.splash_index = self.splash_index + 1

        self.count = self.count + 1

    def draw(self):

        screen.blit(self.image, self.rect)


class SmallBone(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)

        self.idle_images = load_sprites('image/Monster/Small_Bone/Idle/', 'Idle_', 4)
        self.idle_fan_images = load_sprites('image/Monster/Small_Bone/Idle/', 'Idle_', 4)
        for i in range(4):
            self.idle_fan_images[i] = pygame.transform.flip(self.idle_fan_images[i], True, False)
        self.walk_images = load_sprites('image/Monster/Small_Bone/Walk/', 'Walk_', 4)
        self.walk_fan_images = load_sprites('image/Monster/Small_Bone/Walk/', 'Walk_', 4)
        for i in range(4):
            self.walk_fan_images[i] = pygame.transform.flip(self.walk_fan_images[i], True, False)
        self.attack_images = load_sprites('image/Monster/Small_Bone/Attack/', 'Attack_', 5)
        self.attack_fan_images = load_sprites('image/Monster/Small_Bone/Attack/', 'Attack_', 5)
        for i in range(5):
            self.attack_fan_images[i] = pygame.transform.flip(self.attack_fan_images[i], True, False)
        self.die_images = load_sprites('image/Monster/Small_Bone/Die/', 'Die_', 4)
        self.die_fan_images = load_sprites('image/Monster/Small_Bone/Die/', 'Die_', 4)
        for i in range(4):
            self.die_fan_images[i] = pygame.transform.flip(self.die_fan_images[i], True, False)
        self.hurt_images = load_sprites('image/Monster/Small_Bone/Hurt/', 'Fly_', 1)
        self.hurt_fan_images = load_sprites('image/Monster/Small_Bone/Hurt/', 'Fly_', 1)
        for i in range(1):
            self.hurt_fan_images[i] = pygame.transform.flip(self.hurt_fan_images[i], True, False)

        self.image = self.idle_images[0]

        self.rect = self.idle_images[0].get_rect()

        self.weizhi = random.randint(0, 1)
        if self.weizhi == 0:
            self.rect.right = 0 - random.randint(0, 50)
        else:
            self.rect.left = WIDTH + random.randint(0, 50)
        self.rect.bottom = random.randint(HEIGHT - 200, HEIGHT - 80)

        self.radius = int(self.rect.width * 1 / 4)

        self.hp = 60

        self.idle_index = 0
        self.walk_index = 0
        self.attack_index = 0
        self.die_index = 0
        self.hurt_index = 0

        self.daji = False  # 控制玩家掉血频率

        self.fan = False

        self.speed_heng = speed * 0.8
        self.speed_shu = speed * 0.6

        self.idle = True
        self.walk = False
        self.attack = False
        self.die = False
        self.hurt = False

        self.fang = False

        self.hurt_count = 0  # 调节受伤动作持续时间
        self.count = 0  # 调节动作快慢

    def update(self):

        # 首先判断是否死亡
        if self.hp <= 0:
            self.die = True
            self.idle = False
            self.walk = False
            self.attack = False
            self.hurt = False
            if self.die_index > 3:
                self.die_index = 3
                self.kill()

        # 被打击时停止一切活动
        if self.hurt:
            self.idle = False
            self.walk = False
            self.attack = False

            self.idle_index = 0
            self.walk_index = 0
            self.attack_index = 0

        if self.fan:
            if self.idle:
                self.image = self.idle_fan_images[self.idle_index]
            if self.walk:
                self.image = self.walk_fan_images[self.walk_index]
            if self.attack:
                self.image = self.attack_fan_images[self.attack_index]
            if self.die:
                self.image = self.die_fan_images[self.die_index]
            if self.hurt:
                self.image = self.hurt_fan_images[self.hurt_index]
        else:
            if self.idle:
                self.image = self.idle_images[self.idle_index]
            if self.walk:
                self.image = self.walk_images[self.walk_index]
            if self.attack:
                self.image = self.attack_images[self.attack_index]
            if self.die:
                self.image = self.die_images[self.die_index]
            if self.hurt:
                self.image = self.hurt_images[self.hurt_index]

        # 选择动作

        if 2 * self.radius < abs(self.rect.center[0] - player.rect.center[0]) < 1000 or \
                abs(self.rect.center[1] - player.rect.center[1]) > 10 or \
                self.rect.right > WIDTH:
            self.idle = False
            self.walk = True
            self.attack = False
            # 恢复初始动作
            self.attack_index = 0

        if abs(self.rect.center[0] - player.rect.center[0]) <= 2 * self.radius and \
                abs(self.rect.center[1] - player.rect.center[1]) < 10:
            self.idle = False
            self.walk = False
            self.attack = True
            # 恢复初始动作
            self.walk_index = 0

        if ((abs(self.rect.center[0] - player.rect.center[0]) >= 1000 and
                self.rect.center[0] > player.rect.center[0]) and
                not self.rect.right > WIDTH) or player.die:
            self.idle = True
            self.walk = False
            self.attack = False
            # 恢复初始动作
            self.walk_index = 0
            self.attack_index = 0

        # 移动

        if self.walk and (player.rect.center[0] < self.rect.center[0] or self.rect.right > WIDTH) and not self.die:
            self.rect.x = self.rect.x - self.speed_heng

        if self.walk and player.rect.center[0] > self.rect.center[0] and not self.die:
            self.rect.x = self.rect.x + self.speed_heng

        if self.walk and player.rect.center[1] < self.rect.center[1] and \
                abs(self.rect.center[0] - player.rect.center[0]) <= 2 * self.radius and not self.die:
            self.rect.y = self.rect.y - self.speed_shu

        if self.walk and player.rect.center[1] > self.rect.center[1] and \
                abs(self.rect.center[0] - player.rect.center[0]) <= 2 * self.radius and not self.die:
            self.rect.y = self.rect.y + self.speed_shu

        # 判断朝向

        if player.rect.center[0] < self.rect.center[0]:
            self.fan = False

        else:
            self.fan = True

        # 随地图移动

        if background.dong:
            if not player.skill:
                if player.fighting:
                    self.rect.x = self.rect.x - background.speed
                else:
                    self.rect.x = self.rect.x - background.speed

        # 位置限制

        if self.rect.top < HEIGHT / 4 - 20:
            self.rect.top = HEIGHT / 4 - 20
        if self.rect.bottom > HEIGHT - 100:
            self.rect.bottom = HEIGHT - 100

        # 更新动作

        if self.idle and self.count % 6 == 0:
            self.idle_index = (self.idle_index + 1) % 4
        if self.walk and self.count % 6 == 0:
            self.walk_index = (self.walk_index + 1) % 4
        if self.attack and self.count % 6 == 0:
            if self.attack_index == 3:
                self.daji = True
            self.attack_index = (self.attack_index + 1) % 5
        if self.die and self.count % 10 == 0:
            self.die_index = self.die_index + 1
        if self.hurt and self.hurt_count % 15 == 0:
            self.hurt = False

        # 攻击

        # 判断是否攻击（是否和玩家碰撞）
        if self.attack:
            if abs(player.rect.center[0] - self.rect.center[0]) < 2 * self.radius and \
                    abs(player.rect.center[1] - self.rect.center[1]) < 30 and self.daji:
                self.daji = False
                player.hurt = True
                player.hp -= 5

        self.hurt_count = self.hurt_count + 1
        self.count = self.count + 1

    def draw(self):

        screen.blit(self.image, self.rect)


class Backgrounds:

    def __init__(self, name, no):

        self.name = name
        self.no = no

        self.images_0 = load_sprites('image/Background/' + self.name + '/', self.name + '_', self.no)
        self.images_1 = load_sprites('image/Background/' + self.name + '/', self.name + '_', self.no)

        for i in range(self.no):
            self.rect_0 = self.images_0[i].get_rect()
            self.rect_0.bottom = HEIGHT
            self.rect_1 = self.images_1[i].get_rect()
            self.rect_1.bottom = HEIGHT
            self.rect_0.left = 0
            self.rect_1.left = self.rect_0.right

        self.bianjie = False
        self.dong = False

        self.speed = speed

    def update(self):

        if player.fighting:
            self.speed = speed / 3
        else:
            self.speed = speed

        if player.skill:
            self.speed = 0

        if (WIDTH / 2 < player.rect.right and ditu.rect_1_1.right > WIDTH) or ditu.go:
            self.bianjie = True
        else:
            self.bianjie = False

        keystate = pygame.key.get_pressed()

        if self.bianjie and keystate[pygame.K_d] and not player.die:

            self.dong = True

            self.rect_0.left = self.rect_0.left - self.speed
            self.rect_1.left = self.rect_1.left - self.speed

            if self.rect_0.right < 0:
                self.rect_0.left = self.rect_1.right
            if self.rect_1.right < 0:
                self.rect_1.left = self.rect_0.right

        else:
            self.dong = False

    def draw(self):
        for i in range(self.no):
            screen.blit(self.images_0[i], self.rect_0)
            screen.blit(self.images_1[i], self.rect_1)


class Map:

    def __init__(self, name):

        self.name = name

        # 加载一套地图的起始地图
        path = 'image/Map/' + self.name + '/' + self.name + '_start' + '.png'
        self.image_start = pygame.image.load(path).convert_alpha()
        self.image_start.set_colorkey(WHITE)
        self.rect_start = self.image_start.get_rect()

        self.rect_start.left = 0
        self.rect_start.bottom = HEIGHT + 20  # 开始地图和后面的地图连接不顺，因此下降二十

        # 加载一套地图的两个可循环地图
        self.images_0 = load_sprites('image/Map/' + self.name + '/', self.name + '_Loop_', 2)
        self.images_1 = load_sprites('image/Map/' + self.name + '/', self.name + '_Loop_', 2)

        for i in range(2):
            self.rect_0 = self.images_0[i].get_rect()
            self.rect_0.bottom = HEIGHT
            self.rect_1 = self.images_1[i].get_rect()
            self.rect_1.bottom = HEIGHT

        self.rect_0_0 = self.images_0[0].get_rect()
        self.rect_0_1 = self.images_0[1].get_rect()
        self.rect_1_0 = self.images_1[0].get_rect()
        self.rect_1_1 = self.images_1[1].get_rect()

        self.rect_0_0.left = self.rect_start.right
        self.rect_0_1.left = self.rect_0_0.right
        self.rect_1_0.left = self.rect_0_1.right
        self.rect_1_1.left = self.rect_1_0.right

        self.dong = False
        self.go = False  # 用于扩张地图，使地图进入下一次循环

        self.speed = speed

    def update(self):

        if player.fighting:
            self.speed = speed / 3
        else:
            self.speed = speed

        if player.skill:
            self.speed = 0

        if background.dong:  # 背景移动，地图跟着移动

            self.rect_start.left = self.rect_start.left - self.speed

            self.rect_0_0.left = self.rect_0_0.left - self.speed
            self.rect_0_1.left = self.rect_0_1.left - self.speed
            self.rect_1_0.left = self.rect_1_0.left - self.speed
            self.rect_1_1.left = self.rect_1_1.left - self.speed

            if self.rect_0_0.right < 0:
                self.rect_0_0.left = self.rect_1_1.right
            if self.rect_0_1.right < 0:
                self.rect_0_1.left = self.rect_0_0.right
            if self.rect_1_0.right < 0:
                self.rect_1_0.left = self.rect_0_1.right
            if self.rect_1_1.right < 0:
                self.rect_1_1.left = self.rect_1_0.right

    def draw(self):

        screen.blit(self.image_start, self.rect_start)
        screen.blit(self.images_0[0], self.rect_0_0)
        screen.blit(self.images_0[1], self.rect_0_1)
        screen.blit(self.images_1[0], self.rect_1_0)
        screen.blit(self.images_1[1], self.rect_1_1)


class Interface:
    def __init__(self):

        # 加载图片

        self.path = 'image/Interface/'

        self.image_top = load_image(self.path, 'Top')
        self.image_hero_icon = load_image(self.path, 'Hero_Icon', 90, 90)
        self.image_back = load_image(self.path, 'Back', 400, 20)
        self.image_hp = load_image(self.path, 'HP', 400, 20)
        self.image_mp = load_image(self.path, 'MP', 400, 20)
        self.image_distance_point = load_image(self.path, 'Distance_Point')
        self.image_fight_black = load_image(self.path, 'Fight_Black')

        # 定位

        self.top_rect = self.image_top.get_rect()
        self.hero_icon_rect = self.image_hero_icon.get_rect()
        self.back_rect_0 = self.image_back.get_rect()
        self.back_rect_1 = self.image_back.get_rect()
        self.back_rect_2 = self.image_back.get_rect()
        self.hp_rect = self.image_hp.get_rect()
        self.mp_rect = self.image_mp.get_rect()
        self.distance_point_rect = self.image_distance_point.get_rect()
        self.fight_black_rect = self.image_fight_black.get_rect()

        self.top_rect.left = 0
        self.top_rect.top = 0

        # 上下左右各有 5 的偏移
        self.hero_icon_rect.left = self.top_rect.center[0] - self.hero_icon_rect.width / 2 - 5
        self.hero_icon_rect.top = -5

        self.back_rect_0.left = self.top_rect.width / 4 - self.back_rect_0.width / 2 - 20
        self.back_rect_0.top = 10

        self.back_rect_1.left = self.back_rect_0.left
        self.back_rect_1.top = self.back_rect_0.bottom + 10

        self.back_rect_2.left = self.top_rect.width * 3 / 4 - self.back_rect_0.width / 2 + 20
        self.back_rect_2.top = 10

        self.hp_rect.left = self.back_rect_0.left
        self.hp_rect.top = 10

        self.mp_rect.left = self.back_rect_1.left
        self.mp_rect.top = self.back_rect_0.bottom + 10

        self.distance_point_rect.left = self.back_rect_2.left
        self.distance_point_rect.top = self.back_rect_2.top

    def update(self):

        xueliang = player.hp / 100
        lanliang = player.mp / 100

        self.image_hp = load_image(self.path, 'HP', int(400 * xueliang), 20)
        self.image_mp = load_image(self.path, 'MP', int(400 * lanliang), 20)

        length = 400

        self.distance_point_rect.left = \
            (1 - (ditu.rect_1_1.right - player.rect.center[0]) / (geshu * ditu.rect_1_1.width)) * length + \
            self.back_rect_2.left

    def draw(self):
        if not player.born:
            screen.blit(self.image_top, self.top_rect)
            screen.blit(self.image_hero_icon, self.hero_icon_rect)
            screen.blit(self.image_back, self.back_rect_0)
            screen.blit(self.image_back, self.back_rect_1)
            screen.blit(self.image_back, self.back_rect_2)
            screen.blit(self.image_hp, self.hp_rect)
            screen.blit(self.image_mp, self.mp_rect)
            screen.blit(self.image_distance_point, self.distance_point_rect)


class SkillButton:
    def __init__(self):

        # 加载图片

        self.path = 'image/Player/Skill/Button/'

        self.image_large_0_zuo = load_image(self.path, 'Skill_Button_L_0')
        self.image_large_0_you = load_image(self.path, 'Skill_Button_L_0')
        self.image_large_1_zuo = load_image(self.path, 'Skill_Button_L_1')
        self.image_large_1_you = load_image(self.path, 'Skill_Button_L_1')
        self.image_mid_0_zuo_1 = load_image(self.path, 'Skill_Button_M_0')
        self.image_mid_0_you_1 = load_image(self.path, 'Skill_Button_M_0')
        self.image_mid_0_zuo_2 = load_image(self.path, 'Skill_Button_M_0')
        self.image_mid_0_you_2 = load_image(self.path, 'Skill_Button_M_0')
        self.image_mid_1_zuo_1 = load_image(self.path, 'Skill_Button_M_1')
        self.image_mid_1_you_1 = load_image(self.path, 'Skill_Button_M_1')
        self.image_mid_1_zuo_2 = load_image(self.path, 'Skill_Button_M_1')
        self.image_mid_1_you_2 = load_image(self.path, 'Skill_Button_M_1')

        self.image_attack = load_image(self.path, 'Attack')
        self.image_hp = load_image(self.path, 'Hp')
        self.image_brave = load_image(self.path, 'Brave')
        self.image_chop = load_image(self.path, 'Chop')
        self.image_slash = load_image(self.path, 'Slash')
        self.image_up = load_image(self.path, 'Up')

        self.image_cool = load_image(self.path, 'Cool')  # 待用

        # 定位

        self.large_0_zuo_rect = self.image_large_0_zuo.get_rect()
        self.large_0_you_rect = self.image_large_0_you.get_rect()
        self.large_1_zuo_rect = self.image_large_1_zuo.get_rect()
        self.large_1_you_rect = self.image_large_1_you.get_rect()
        self.mid_0_zuo_1_rect = self.image_mid_0_zuo_1.get_rect()
        self.mid_0_you_1_rect = self.image_mid_0_you_1.get_rect()
        self.mid_0_zuo_2_rect = self.image_mid_0_zuo_2.get_rect()
        self.mid_0_you_2_rect = self.image_mid_0_you_2.get_rect()
        self.mid_1_zuo_1_rect = self.image_mid_1_zuo_1.get_rect()
        self.mid_1_you_1_rect = self.image_mid_1_you_1.get_rect()
        self.mid_1_zuo_2_rect = self.image_mid_1_zuo_2.get_rect()
        self.mid_1_you_2_rect = self.image_mid_1_you_2.get_rect()

        self.large_1_zuo_rect.bottom = HEIGHT
        self.large_1_zuo_rect.left = 0
        self.large_0_zuo_rect.bottom = self.large_1_zuo_rect.bottom
        self.large_0_zuo_rect.left = self.large_1_zuo_rect.left

        self.large_1_you_rect.bottom = HEIGHT
        self.large_1_you_rect.right = WIDTH
        self.large_0_you_rect.bottom = self.large_1_you_rect.bottom
        self.large_0_you_rect.left = self.large_1_you_rect.left

        self.mid_1_zuo_1_rect.bottom = HEIGHT
        self.mid_1_zuo_1_rect.left = self.large_1_zuo_rect.right
        self.mid_0_zuo_1_rect.bottom = self.mid_1_zuo_1_rect.bottom
        self.mid_0_zuo_1_rect.left = self.mid_1_zuo_1_rect.left
        self.mid_1_you_1_rect.bottom = HEIGHT
        self.mid_1_you_1_rect.right = WIDTH - self.mid_1_zuo_1_rect.left
        self.mid_0_you_1_rect.bottom = self.mid_1_you_1_rect.bottom
        self.mid_0_you_1_rect.right = self.mid_1_you_1_rect.right

        self.mid_1_zuo_2_rect.bottom = HEIGHT
        self.mid_1_zuo_2_rect.left = self.mid_1_zuo_1_rect.right
        self.mid_0_zuo_2_rect.bottom = self.mid_1_zuo_2_rect.bottom
        self.mid_0_zuo_2_rect.left = self.mid_1_zuo_2_rect.left
        self.mid_1_you_2_rect.bottom = HEIGHT
        self.mid_1_you_2_rect.right = WIDTH - self.mid_1_zuo_2_rect.left
        self.mid_0_you_2_rect.bottom = self.mid_1_you_2_rect.bottom
        self.mid_0_you_2_rect.right = self.mid_1_you_2_rect.right

        self.image_zuo_1 = self.image_large_1_zuo
        self.image_zuo_2 = self.image_mid_1_zuo_1
        self.image_zuo_3 = self.image_mid_1_zuo_2

        self.image_you_1 = self.image_large_1_you
        self.image_you_2 = self.image_mid_1_you_1
        self.image_you_3 = self.image_mid_1_you_2

        self.count_zuo_1 = 0
        self.count_zuo_2 = 0
        self.count_zuo_3 = 0
        self.count_you_1 = 0
        self.count_you_2 = 0
        self.count_you_3 = 0

    def update(self):
        if player.combo:
            self.image_zuo_1 = self.image_large_0_zuo
            self.count_zuo_1 = 0
        elif self.image_zuo_1 == self.image_large_0_zuo and self.count_zuo_1 == 3:
            self.image_zuo_1 = self.image_large_1_zuo

        if player.skill_0:
            self.image_you_3 = self.image_mid_0_you_2
            self.count_you_3 = 0
        elif self.image_you_3 == self.image_mid_0_you_2 and self.count_you_3 == 3:
            self.image_you_3 = self.image_mid_1_you_2

        if player.skill_1:
            self.image_you_2 = self.image_mid_0_you_1
            self.count_you_2 = 0
        elif self.image_you_2 == self.image_mid_0_you_1 and self.count_you_2 == 3:
            self.image_you_2 = self.image_mid_1_you_1

        if player.skill_2:
            self.image_you_1 = self.image_large_0_you
            self.count_you_1 = 0
        elif self.image_you_1 == self.image_large_0_you and self.count_you_1 == 3:
            self.image_you_1 = self.image_large_1_you

        if player.huifu:
            self.image_zuo_2 = self.image_mid_0_zuo_1
            self.count_zuo_2 = 0
        elif self.image_zuo_2 == self.image_mid_0_zuo_1 and self.count_zuo_2 == 3:
            self.image_zuo_2 = self.image_mid_1_zuo_1

        if player.brave:
            self.image_zuo_3 = self.image_mid_0_zuo_2
            self.count_zuo_3 = 0
        elif self.image_zuo_3 == self.image_mid_0_zuo_2 and self.count_zuo_3 == 3:
            self.image_zuo_3 = self.image_mid_1_zuo_2

        self.count_zuo_1 += 1
        self.count_zuo_2 += 1
        self.count_zuo_3 += 1
        self.count_you_1 += 1
        self.count_you_2 += 1
        self.count_you_3 += 1

    def draw(self):
        if not player.born:
            screen.blit(self.image_zuo_1, self.large_1_zuo_rect)
            screen.blit(self.image_zuo_2, self.mid_1_zuo_1_rect)
            screen.blit(self.image_zuo_3, self.mid_1_zuo_2_rect)
            screen.blit(self.image_you_1, self.large_1_you_rect)
            screen.blit(self.image_you_2, self.mid_1_you_1_rect)
            screen.blit(self.image_you_3, self.mid_1_you_2_rect)

            screen.blit(self.image_attack, self.large_1_zuo_rect)
            screen.blit(self.image_hp, self.mid_1_zuo_1_rect)
            screen.blit(self.image_brave, self.mid_1_zuo_2_rect)
            screen.blit(self.image_chop, self.large_1_you_rect)
            screen.blit(self.image_up, self.mid_1_you_1_rect)
            screen.blit(self.image_slash, self.mid_1_you_2_rect)


if __name__ == "__main__":
    pygame.init()

    pygame.mixer.init()  # 声音初始化
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    pygame.display.set_caption('Take Heaven')
    clock = pygame.time.Clock()

    # 加载图片

    skill_0_L0_images = load_sprites('image/Player/Skill/Skill_0/', 'Slash_L0_', 6)
    skill_0_L0_fan_images = load_sprites('image/Player/Skill/Skill_0/', 'Slash_L0_', 6)
    for j in range(6):
        skill_0_L0_fan_images[j] = pygame.transform.flip(skill_0_L0_fan_images[j], True, False)
    skill_1_L0_images = load_sprites('image/Player/Skill/Skill_1/', 'Slash_L0_', 6)
    skill_1_L0_fan_images = load_sprites('image/Player/Skill/Skill_1/', 'Slash_L0_', 6)
    for j in range(6):
        skill_1_L0_fan_images[j] = pygame.transform.flip(skill_1_L0_fan_images[j], True, False)
    skill_2_L0_images = load_sprites('image/Player/Skill/Skill_2/', 'Chop_L0_', 6)
    skill_2_L0_fan_images = load_sprites('image/Player/Skill/Skill_2/', 'Chop_L0_', 6)
    for j in range(6):
        skill_2_L0_fan_images[j] = pygame.transform.flip(skill_2_L0_fan_images[j], True, False)

    skill_0_L1_images = load_sprites('image/Player/Skill/Skill_0/', 'Slash_L1_', 8)
    skill_0_L1_fan_images = load_sprites('image/Player/Skill/Skill_0/', 'Slash_L1_', 6)
    for j in range(6):
        skill_0_L1_fan_images[j] = pygame.transform.flip(skill_0_L1_fan_images[j], True, False)
    skill_1_L1_images = load_sprites('image/Player/Skill/Skill_1/', 'Slash_L1_', 6)
    skill_1_L1_fan_images = load_sprites('image/Player/Skill/Skill_1/', 'Slash_L1_', 6)
    for j in range(6):
        skill_1_L1_fan_images[j] = pygame.transform.flip(skill_1_L1_fan_images[j], True, False)
    skill_2_L1_images = load_sprites('image/Player/Skill/Skill_2/', 'Chop_L1_', 6)
    skill_2_L1_fan_images = load_sprites('image/Player/Skill/Skill_2/', 'Chop_L1_', 6)
    for j in range(6):
        skill_2_L1_fan_images[j] = pygame.transform.flip(skill_2_L1_fan_images[j], True, False)

    huifu_images = load_sprites('image/Player/Skill/Buff/', 'Texiao_', 17)
    huifu_fan_images = load_sprites('image/Player/Skill/Buff/', 'Texiao_', 17)
    for j in range(17):
        huifu_fan_images[j] = pygame.transform.flip(huifu_fan_images[j], True, False)

    beijing = load_image('image/Start/', 'Background')
    beijing_rect = beijing.get_rect()
    title = load_image('image/Start/', 'Title')
    title_rect = title.get_rect()

    pygame.mixer.music.load('music/background.mid')
    pygame.mixer.music.set_volume(0.5)

    win_sound = pygame.mixer.Sound('music/win.wav')
    defeat_sound = pygame.mixer.Sound('music/defeat.wav')

    bofang = True

    Boss = 0
    Monster = 0
    shengyu = 0

    all_sprites = pygame.sprite.Group()
    bone_skill = pygame.sprite.Group()
    enemy_sprites = pygame.sprite.Group()

    # 提前加载

    bone = Bone()

    smallbones = []
    for xiaogui in range(22):
        smallbone = SmallBone()
        smallbones.append(smallbone)

    player = Player()

    all_sprites.add(player)

    ditu = Map('Bone_Path')

    background = Backgrounds('Sunset', 3)

    interface = Interface()

    skillbutton = SkillButton()

    running = True
    gameover = False
    start = True

    while running:

        if start:
            begin()
            start = False

        if not running:
            break

        # 处理事件（输入）

        clock.tick(FPS)
        for event in pygame.event.get():   # 检查输入
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN:
                pass

        # 更新

        if not player.born and bofang:
            pygame.mixer.music.play(loops=-1)
            bofang = False

        # 到达最终地图出现Boss

        if player.rect.right > (WIDTH / 2 + 10):
            if Boss == 0:
                all_sprites.add(bone)
                enemy_sprites.add(bone)
                Boss += 1

        lucheng = player.rect.left - ditu.rect_start.left + 100
        if lucheng % 1000 == 0 and Monster < 16:
            for jishu in range(4):
                all_sprites.add(smallbones[Monster])
                enemy_sprites.add(smallbones[Monster])
                Monster += 1

        if Boss == 1 and Monster < 22:
            all_sprites.add(smallbones[Monster])
            enemy_sprites.add(smallbones[Monster])
            Monster += 1

        if bone.die:
            for dijun in enemy_sprites:
                shengyu += 1
            if shengyu == 0:
                player.win = True
            shengyu = 0

        background.update()

        ditu.update()

        all_sprites.update()

        bone_skill.update()

        interface.update()

        skillbutton.update()

        # 绘制屏幕

        screen.fill(BLACK)  # 覆盖

        background.draw()

        ditu.draw()

        # 在路径上使所有精灵形成前后关系

        for sprite in all_sprites:
            if 0 < sprite.rect.center[1] <= 300:
                sprite.draw()

        for hang in range(18):
            for sprite in all_sprites:
                if 300 + 10 * hang < sprite.rect.center[1] <= 300 + 10 * (hang + 1):
                    sprite.draw()

        # 使血液飞溅效果永远在玩家之前
        for sprite in bone_skill:
            if sprite.splash:
                sprite.draw()

        interface.draw()

        skillbutton.draw()

        pygame.display.flip()  # 画完翻面

    pygame.quit()