• 【Pygame实战】只有一个币，投《勇者大冒险》还是《街霸》?（经典复刻，谁的青春回来了？）

    导语

    不知道大家有没有这样的经历，在学校电脑课上打开一个叫做4399的神秘网站，然后精心挑选

    一款小游戏在老师讲课时默默玩耍。

    这种惊心动魄的感觉像极了偷情（滑稽.jpg），而《黄金矿工》、《暴打小朋友》、《森林冰

    火人》、《闪翼拳皇》等等小游戏就是我在电脑课上的情人，其中一款叫做《合金弹头》的游

    戏让我印象尤为深刻。​

    所有文章完整的素材+源码都在👇👇

    粉丝白嫖源码福利，请移步至CSDN社区或文末公众hao即可免费。

    它最让我感到兴奋的是可以切换各种枪械，那种随着战斗的进行鸟枪换炮的成就感是无与伦比

    的，也是这款游戏让我第一次感受到了突突突的快感。

    最近跟着这款游戏仿造了一款《勇者大冒险》游戏，这是一款横版射击游戏，一上手后我就感

    受到了当初玩合金弹头的味道，小编的青春回来了。好啦，话不多说了哈，我们正式开干叭👇

    正文

    一、运行环境

    小编使用的环境：Python3、Pycharm社区版、Pygame模块。内置模块 你安装 好python环

    境就可以了。

     模块安装：pip install -i https://pypi.douban.com/simple/ +pygame

    二、素材（图片等）

    这款《勇者大冒险》大型游戏有超多的图片素材的下面只是小部分截图太大了。

    当然要有音乐的啦👇

    ​三、代码展示

    1）boss主程序py

    1. # coding: utf-8
    2.  
    3. import pygame
    4. import sys
    5. from random import randint
    6. from pygame.sprite import Sprite
    7. from pygame.sprite import Group
    8. from bullet import *
    9.  
    10. # 控制怪物动画的速度
    11.  
    12. MAN_PAO_SPEED_THRESHOLD = 5
    13.  
    14. # 定义代表怪物类型的常量（如果程序还需要增加更多怪物，只需在此处添加常量即可）
    15. TYPE_BOSS = 2
    16.  
    17. class Boss(Sprite):
    18.     boss_produce = True
    19.     def __init__ (self, view_manager):
    20.         super().__init__()
    21.         # 定义子弹爆炸时的帧数
    22.         self.bullet_number=0
    23.  
    24.         # 定义boss未被加载初始未true
    25.         # boss血量
    26.         self.hp=20
    27.         # 定义怪物X、Y坐标的属性
    28.         self.x = 0
    29.         self.y = 0
    30.         # 定义怪物是否已经死亡的旗标
    31.         self.is_die = False
    32.         # 绘制怪物图片的左上角的X坐标
    33.         self.start_x = 0
    34.         # 绘制怪物图片的左上角的Y坐标
    35.         self.start_y = 0
    36.         # 绘制怪物图片的右下角的X坐标
    37.         self.end_x = 0
    38.         # 绘制怪物图片的右下角的Y坐标
    39.         self.end_y = 0
    40.         # 该变量控制用于控制动画刷新的速度
    41.         self.draw_count = 0
    42.         # 定义当前正在绘制怪物动画的第几帧的变量
    43.         self.draw_index = 0
    44.         # 用于记录死亡动画只绘制一次，不需要重复绘制
    45.         # 每当怪物死亡时，该变量会被初始化为等于死亡动画的总帧数
    46.         # 当怪物的死亡动画帧播放完成时，该变量的值变为0。
    47.         self.die_max_draw_count = sys.maxsize
    48.         # 定义怪物射出的子弹
    49.         self.bullet_list = Group()
    50.         # 定义Boss速度的初始值
    51.         self.SPEED=5
    52.         # -------下面代码初始化BOSS X、Y坐标------
    53.  
    54.         self.y = 0
    55.         self.x = view_manager.screen_width/2
    56.  
    57.     # 画怪物的方法
    58.     def draw(self, screen, view_manager,player):
    59.         self.draw_anim(screen, view_manager, view_manager.boss_images
    60.             if not self.is_die else view_manager.boss_die_images,player)
    61.     # 根据怪物的动画帧图片来绘制怪物动画
    62.     def draw_anim(self, screen, view_manager, bitmap_arr,player):
    63.         # 如果怪物已经死，且没有播放过死亡动画
    64.         #（self.die_max_draw_count等于初始值表明未播放过死亡动画）
    65.         if self.is_die and self.die_max_draw_count == sys.maxsize:
    66.             # 将die_max_draw_count设置与死亡动画的总帧数相等
    67.             self.die_max_draw_count = len(bitmap_arr)    # ⑤
    68.         self.draw_index %= len(bitmap_arr)
    69.  
    70.  
    71.         # 获取当前绘制的动画帧对应的位图
    72.         bitmap = bitmap_arr[self.draw_index]  # ①
    73.         if bitmap == None:
    74.             return
    75.         # 对绘制怪物动画帧位图的X坐标进行微调
    76.  
    77.         self.x -=self.SPEED
    78.         # 如果到达屏幕边界则反方向行进
    79.         if self.x <=-376 or self.x >= view_manager.screen_width+120:
    80.             self.SPEED = -self.SPEED
    81.  
    82.         # 对绘制怪物动画帧位图的Y坐标进行微调
    83.         draw_y = self.y
    84.         # 画怪物动画帧的位图
    85.         if self.SPEED>0:
    86.             bitmap=pygame.transform.flip(bitmap,True,False)
    87.         screen.blit(bitmap, (self.x, draw_y))
    88.  
    89.         self.start_x = self.x
    90.         self.start_y = draw_y
    91.         self.end_x = self.start_x + bitmap.get_width()
    92.         self.end_y = self.start_y + bitmap.get_height()
    93.         self.draw_count += 1
    94.         # 控制人、飞机的发射子弹的速度
    95.         if self.draw_count >= TYPE_BOSS:  # ③
    96.             # boss只在最后一帧才发射子弹
    97.             if  self.draw_index == len(bitmap_arr)-1 and self.x%40==0:
    98.                 self.add_bullet()
    99.  
    100.             self.draw_index += 1   # ②
    101.             self.draw_count = 0    # ④
    102.         # 每播放死亡动画的一帧，self.die_max_draw_count减1。
    103.         # 当self.die_max_draw_count等于0时，表明死亡动画播放完成。
    104.         if self.is_die:
    105.             self.die_max_draw_count -= 1   # ⑥
    106.         # 如果boss死亡 加载win的画面
    107.         if  self.die_max_draw_count<=0:
    108.             screen.blit(view_manager.win[0], (0, 0))
    109.             pygame.display.flip()
    110.             while True:
    111.                 for event in pygame.event.get():
    112.                     if event==pygame.QUIT:
    113.                         pygame.quit()
    114.                         sys.exit()
    115.         # 绘制子弹
    116.         self.draw_bullets(screen, view_manager,player)
    117.  
    118.     # 判断怪物是否被子弹打中的方法
    119.     def is_hurt(self, x, y): 
    120.         return self.start_x < x < self.end_x and self.start_y < y < self.end_y
    121.  
    122.     # 此boos对应的子弹是6
    123.     def bullet_type(self):
    124.         return 6
    125.  
    126.  
    127.     # 定义发射子弹的方法
    128.     def add_bullet(self):
    129.         # 如果没有子弹
    130.         if self.bullet_type() <= 0:
    131.             return
    132.         # 计算子弹的X、Y坐标
    133.         draw_x = self.x+30
    134.         draw_y = self.y+120
    135.  
    136.         # 创建子弹对象,由于这个boos是从上往下发射子弹所以不需要翻转图片这里pdir参数给以个3让他不执行翻转
    137.         # 让飞机只有从左往右飞时发射导弹
    138.         if self.SPEED<0:
    139.             bullet = Bullet(self.bullet_type(), draw_x, draw_y, 3)
    140.         # 将子弹添加到该怪物发射的子弹Group中
    141.             self.bullet_list.add(bullet)
    142.  
    143.     # 更新所有子弹的位置：将所有子弹的X坐标减少shift距离（子弹左移）
    144.     def update_shift(self, shift):
    145.             self.y-=shift
    146.             for bullet in self.bullet_list:
    147.                 if bullet != None:
    148.                     bullet.y = self.y
    149.  
    150.     # 绘制子弹的方法
    151.     def draw_bullets(self, screen, view_manager,player) :
    152.         # 遍历该怪物发射的所有子弹
    153.         for bullet in self.bullet_list.copy():
    154.              # 如果子弹已经越过屏幕
    155.             if bullet.boss_bang:
    156.                 # 删除已经移出屏幕的子弹
    157.                 self.bullet_list.remove(bullet)
    158.         # 绘制所有子弹
    159.         for bullet in self.bullet_list.sprites():
    160.             if bullet.y<= view_manager.screen_height-250:
    161.                 # 获取子弹对应的位图
    162.                 bitmap = bullet.bitmap(view_manager)
    163.                 # 绘制子弹的位图
    164.                 screen.blit(bitmap, (bullet.x, bullet.y))
    165.                 bullet.move(True)
    166.                 # 子弹移动
    167.                 if bitmap == None:
    168.                     continue
    169.  
    170.             elif len(self.bullet_list.sprites())>1:
    171.                 self.bullet_number+=1
    172.                 if self.bullet_number%5==0 and bullet.bullet_bang>0:
    173.                     bullet.bullet_bang-=1
    174.                     self.check_bullet(player)
    175.                 bitmap = view_manager.boss_die_images[bullet.bullet_bang]
    176.                 if  bullet.bullet_bang==0:
    177.                     bullet.boss_bang=True
    178.                 # 绘制子弹的位图
    179.                 screen.blit(bitmap, (bullet.x, bullet.y))
    180.  
    181.  
    182.                 # 判断子弹是否与玩家控制的角色碰撞（判断子弹是否打中角色）
    183.     def check_bullet(self, player):
    184.         # 遍历所有子弹
    185.         for bullet in self.bullet_list.copy():
    186.             if bullet == None or not bullet.is_effect:
    187.                 continue
    188.             # 如果玩家控制的角色被子弹打到
    189.             if player.is_hurt(bullet.x-20, bullet.x+120, bullet.y, bullet.y+80):
    190.                     # 子弹设为无效
    191.                     bullet.isEffect = False
    192.                     player.hp = player.hp - 15
    193.                     # 删除已经击中玩家控制的角色的子弹
    194.                     self.bullet_list.remove(bullet)

    2)玩家设置

    1. # coding: utf-8
    2. import pygame
    3. import sys
    4. from random import randint
    5. from pygame.sprite import Sprite
    6. from pygame.sprite import Group
    7. import pygame.font
    8.  
    9. from bullet import *
    10. import monster_manager as mm
    11.  
    12. # 定义角色的最高生命值
    13. MAX_HP = 9999999999999999999
    14. # 定义控制角色动作的常量
    15. # 此处只控制该角色包含站立、跑、跳等动作
    16. ACTION_STAND_RIGHT = 1
    17. ACTION_STAND_LEFT = 2
    18. ACTION_RUN_RIGHT = 3
    19. ACTION_RUN_LEFT = 4
    20. ACTION_JUMP_RIGHT = 5
    21. ACTION_JUMP_LEFT = 6
    22. # 定义角色向右移动的常量
    23. DIR_RIGHT = 1
    24. # 定义角色向左移动的常量
    25. DIR_LEFT = 2
    26.  
    27. # 定义控制角色移动的常量
    28. # 此处控制该角色只包含站立、向右移动、向左移动三种移动方式
    29. MOVE_STAND = 0
    30. MOVE_RIGHT = 1
    31. MOVE_LEFT = 2
    32. MAX_LEFT_SHOOT_TIME = 6
    33.  
    34. class Player(Sprite):
    35.     def __init__(self, view_manager, name, hp):
    36.         super().__init__()
    37.         self.boos_time_updata_y = False
    38.         self.bullet_clear = 0
    39.         # Boos时间时地图不在跟随移动角色可以自由移动，规定x轴，y轴坐标
    40.         self.boss_time_move_x=0
    41.         self.boss_time_move_y=0
    42.         # BOSS时间
    43.         self.pesses_boss_time=False# BOSS时间
    44.  
    45.         self.name = name # 保存角色名字的成员变量
    46.         self.hp = hp # 保存角色生命值的成员变量
    47.         self.view_manager = view_manager
    48.         # 保存角色所使用枪的类型（以后可考虑让角色能更换不同的枪）
    49.         self.gun = 0
    50.         # 保存角色当前动作的成员变量（默认向右站立）
    51.         self.action = ACTION_STAND_RIGHT
    52.         # 代表角色X坐标的属性
    53.         self._x = -1
    54.         # 代表角色Y坐标的属性
    55.         self.y = -1
    56.         # 保存角色射出的所有子弹
    57.         self.bullet_list = Group()
    58.         # 保存角色移动方式的成员变量
    59.         self.move = MOVE_STAND
    60.         # 控制射击状态的保留计数器
    61.         # 每当用户发射一枪时，left_shoot_time会被设为MAX_LEFT_SHOOT_TIME，然后递减
    62.         # 只有当left_shoot_time变为0时，用户才能发射下一枪
    63.         self.left_shoot_time = 0
    64.         # 保存角色是否跳动的属性
    65.         self._is_jump = False
    66.         # 保存角色是否跳到最高处的成员变量
    67.         self.is_jump_max = False
    68.         # 控制跳到最高处的停留时间
    69.         self.jump_stop_count = 0
    70.         # 当前正在绘制角色脚部动画的第几帧
    71.         self.index_leg = 0
    72.         # 当前正在绘制角色头部动画的第几帧
    73.         self.index_head = 0
    74.         # 当前绘制头部图片的X坐标
    75.         self.current_head_draw_x = 0
    76.         # 当前绘制头部图片的Y坐标
    77.         self.current_head_draw_y = 0
    78.         # 当前正在画的脚部动画帧的图片
    79.         self.current_leg_bitmap = None
    80.         # 当前正在画的头部动画帧的图片
    81.         self.current_head_bitmap = None
    82.         # 该变量控制用于控制动画刷新的速度
    83.         self.draw_count = 0
    84.         # 加载中文字体
    85.         self.font = pygame.font.Font('images/msyh.ttf', 20)
    86.  
    87.     # 计算该角色当前方向：action成员变量为奇数代表向右
    88.     def get_dir(self):
    89.         return DIR_RIGHT if self.action % 2 == 1 else DIR_LEFT
    90.  
    91.     def get_x(self):
    92.         return self._x
    93.     def set_x(self, x_val):
    94.             self._x = x_val % (self.view_manager.map.get_width() +
    95.                 self.view_manager.X_DEFAULT)
    96.             # 如果角色移动到屏幕最左边
    97.             if self._x < self.view_manager.X_DEFAULT:
    98.                 self._x = self.view_manager.X_DEFAULT
    99.     x = property(get_x, set_x)
    100.  
    101.     def get_is_jump(self):
    102.         return self._is_jump
    103.     def set_is_jump(self, jump_val):
    104.         self._is_jump = jump_val
    105.         self.jump_stop_count = 6
    106.     is_jump = property(get_is_jump, set_is_jump)
    107.  
    108.     # 返回该角色在游戏界面上的位移
    109.     def shift(self):
    110.         if self.x <= 0 or self.y <= 0:
    111.             self.init_position()
    112.         return self.view_manager.X_DEFAULT - self.x
    113.  
    114.     # 判断角色是否已经死亡
    115.     def is_die(self):
    116.         return self.hp <= 0
    117.  
    118.     # 初始化角色的初始化位置，角色能跳的最大高度
    119.     def init_position(self):
    120.         self.x = self.view_manager.screen_width * 15 / 100
    121.         self.y = self.view_manager.screen_height * 75 / 100
    122.  
    123.     # 画角色的方法
    124.     def draw(self, screen):
    125.         if not self.pesses_boss_time:
    126.             # 绘制角色向右站立的动画图片
    127.             if self.action == ACTION_STAND_RIGHT:
    128.                 self.draw_anim(screen, self.view_manager.leg_stand_images,
    129.                     self.view_manager.head_stand_images, DIR_RIGHT)
    130.             # 绘制角色向左站立的动画图片
    131.             elif self.action == ACTION_STAND_LEFT:
    132.                 self.draw_anim(screen, self.view_manager.leg_stand_images,
    133.                     self.view_manager.head_stand_images, DIR_LEFT)
    134.             # 绘制角色向右跑动的动画图片
    135.             elif self.action == ACTION_RUN_RIGHT:
    136.                 self.draw_anim(screen, self.view_manager.leg_run_images,
    137.                     self.view_manager.head_run_images, DIR_RIGHT)
    138.  
    139.             # 绘制角色向左跑动的动画图片
    140.             elif self.action == ACTION_RUN_LEFT:
    141.                 self.draw_anim(screen, self.view_manager.leg_run_images,
    142.                     self.view_manager.head_run_images, DIR_LEFT)
    143.             # 绘制角色向右跳动的动画图片
    144.             elif self.action == ACTION_JUMP_RIGHT:
    145.                 self.draw_anim(screen, self.view_manager.leg_jump_images,
    146.                     self.view_manager.head_jump_images, DIR_RIGHT)
    147.             # 绘制角色向左跳动的动画图片
    148.             elif self.action == ACTION_JUMP_LEFT:
    149.                 self.draw_anim(screen, self.view_manager.leg_jump_images,
    150.                     self.view_manager.head_jump_images, DIR_LEFT)
    151.         else:
    152.             # 绘制角色向右站立的动画图片
    153.             if self.action == ACTION_STAND_RIGHT:
    154.                 self.draw_anim(screen, self.view_manager.leg_stand_images,
    155.                                self.view_manager.look_up_images, DIR_RIGHT)
    156.             # 绘制角色向左站立的动画图片
    157.             elif self.action == ACTION_STAND_LEFT:
    158.                 self.draw_anim(screen, self.view_manager.leg_stand_images,
    159.                                self.view_manager.look_up_images, DIR_LEFT)
    160.             # 绘制角色向右跑动的动画图片
    161.             elif self.action == ACTION_RUN_RIGHT:
    162.                 self.draw_anim(screen, self.view_manager.leg_run_images,
    163.                                self.view_manager.look_up_images, DIR_RIGHT)
    164.  
    165.             # 绘制角色向左跑动的动画图片
    166.             elif self.action == ACTION_RUN_LEFT:
    167.                 self.draw_anim(screen, self.view_manager.leg_run_images,
    168.                                self.view_manager.look_up_images, DIR_LEFT)
    169.             # 绘制角色向右跳动的动画图片
    170.             elif self.action == ACTION_JUMP_RIGHT:
    171.                 self.draw_anim(screen, self.view_manager.leg_jump_images,
    172.                                self.view_manager.look_up_images, DIR_RIGHT)
    173.             # 绘制角色向左跳动的动画图片
    174.             elif self.action == ACTION_JUMP_LEFT:
    175.                 self.draw_anim(screen, self.view_manager.leg_jump_images,
    176.                                self.view_manager.look_up_images, DIR_LEFT)
    177.     # 绘制角色的动画帧
    178.     def draw_anim(self, screen, leg_arr, head_arr_from, pdir):
    179.         head_arr = head_arr_from
    180.         if not self.pesses_boss_time:
    181.             # 射击状态停留次数每次减1
    182.             if self.left_shoot_time > 0 :
    183.                 head_arr = self.view_manager.head_shoot_images
    184.                 self.left_shoot_time -= 1
    185.             else:
    186.                 head_arr = self.view_manager.head_stand_images
    187.                 self.left_shoot_time -= 1
    188.         else:
    189.             # 射击状态停留次数每次减1
    190.             if self.left_shoot_time > 0:
    191.                 head_arr = self.view_manager.look_up_shoot_images
    192.                 self.left_shoot_time -= 1
    193.             else:
    194.                 head_arr = self.view_manager.look_up_images
    195.                 self.left_shoot_time -= 1
    196.         self.index_leg %= len(leg_arr)
    197.         self.index_head %= len(head_arr)
    198.  
    199.         # 先画脚
    200.         bitmap = leg_arr[self.index_leg]
    201.         draw_x = self.view_manager.X_DEFAULT
    202.         draw_y = self.y - bitmap.get_height()
    203.         if self.pesses_boss_time:
    204.             draw_x=self.boss_time_move_x
    205.         # draw_y=self.y
    206.         # 根据角色方向判断是否需要翻转图片
    207.         if pdir == DIR_RIGHT:
    208.             # 对图片执行镜像（第二个参数控制水平镜像，第三个参数控制垂直镜像）
    209.             bitmap_mirror = pygame.transform.flip(bitmap, True, False)
    210.             screen.blit(bitmap_mirror, (draw_x, draw_y))
    211.         else:
    212.             screen.blit(bitmap, (draw_x, draw_y))           
    213.         self.current_leg_bitmap = bitmap
    214.         # 再画头
    215.         bitmap2 = head_arr[self.index_head]
    216.         draw_x -= (bitmap2.get_width() - bitmap.get_width() >> 1)
    217.         if self.action == ACTION_STAND_LEFT:
    218.             draw_x += 6
    219.         draw_y = draw_y - bitmap2.get_height() + 10
    220.         # 根据角色方向判断是否需要翻转图片
    221.         if self.get_dir() == DIR_RIGHT:
    222.             # 对图片执行镜像（第二个参数控制水平镜像，第三个参数控制垂直镜像）
    223.             bitmap2_mirror = pygame.transform.flip(bitmap2, True, False)
    224.             screen.blit(bitmap2_mirror, (draw_x, draw_y))
    225.         else:
    226.             screen.blit(bitmap2, (draw_x, draw_y))  
    227.         self.current_head_draw_x = draw_x
    228.         self.current_head_draw_y = draw_y
    229.         self.current_head_bitmap = bitmap2
    230.         # self.draw_count控制该方法每调用4次才会切换到下一帧位图
    231.         self.draw_count += 1
    232.         if self.draw_count >= 4:
    233.             self.draw_count = 0
    234.             self.index_leg += 1
    235.             self.index_head += 1
    236.         # 画子弹
    237.         self.draw_bullet(screen)
    238.         # 画左上角的角色、名字、血量
    239.         self.draw_head(screen)
    240.  
    241.     # 绘制左上角的角色、名字、生命值的方法
    242.     def draw_head(self, screen):
    243.         if self.view_manager.head == None:
    244.             return
    245.         # 对图片执行镜像（第二个参数控制水平镜像，第三个参数控制垂直镜像）
    246.         head_mirror = pygame.transform.flip(self.view_manager.head, True, False)
    247.         # 画头像
    248.         screen.blit(head_mirror, (0, 0))
    249.         # 将名字渲染成图像
    250.         name_image = self.font.render(self.name, True, (230, 23, 23))
    251.         # 画名字
    252.         screen.blit(name_image, (self.view_manager.head.get_width(), 10))
    253.         # 将生命值渲染成图像
    254.         hp_image = self.font.render("HP:" + str(self.hp), True, (230, 23, 23))
    255.         # 画生命值
    256.         screen.blit(hp_image, (self.view_manager.head.get_width(), 30))
    257.  
    258.     # 判断该角色是否被子弹打中的方法
    259.     def is_hurt(self, start_x, end_x, start_y, end_y):
    260.         if self.current_head_bitmap == None or self.current_leg_bitmap == None:
    261.             return False
    262.         # 计算角色的图片所覆盖的矩形区域
    263.         player_start_x = self.current_head_draw_x
    264.         player_end_x = player_start_x + self.current_head_bitmap.get_width()
    265.         player_start_y = self.current_head_draw_y
    266.         player_end_y = player_start_y + self.current_head_bitmap.get_height() + \
    267.             self.current_leg_bitmap.get_height()
    268.         # 如果子弹出现的位置与角色图片覆盖的矩形区域有重叠，即可判断角色被子弹打中
    269.         return (player_start_x < start_x < player_end_x \
    270.             or player_start_x < end_x < player_end_x) \
    271.             and (player_start_y < start_y < player_end_y \
    272.             or player_start_y < end_y < player_end_y)
    273.  
    274.     # 发射子弹的方法
    275.     def add_bullet(self, view_manager):
    276.  
    277.         if not self.pesses_boss_time:
    278.         # 计算子弹的初始X坐标
    279.             bullet_x = self.view_manager.X_DEFAULT + 50 if self.get_dir() \
    280.             == DIR_RIGHT else self.view_manager.X_DEFAULT - 50
    281.         else:bullet_x = self.boss_time_move_x
    282.         if not self.pesses_boss_time:
    283.             # 创建子弹对象
    284.             bullet = Bullet(BULLET_TYPE_1, bullet_x, self.y - 60, self.get_dir())
    285.  
    286.         else:
    287.             # 创建子弹对象
    288.             bullet = Bullet(7, bullet_x+20, self.y-100, self.get_dir())
    289.  
    290.  
    291.         # 将子弹添加到用户发射的子弹Group中
    292.         self.bullet_list.add(bullet)
    293.         # 发射子弹时，将self.left_shoot_time设置为射击状态最大值
    294.         self.left_shoot_time = MAX_LEFT_SHOOT_TIME
    295.         # 播放射击音效
    296.         view_manager.sound_effect[0].play()
    297.  
    298.     # 画子弹
    299.     def draw_bullet(self, screen):
    300.  
    301.         delete_list = []
    302.         if self.pesses_boss_time:
    303.             if self.bullet_clear < 2:
    304.                 self.bullet_clear += 1
    305.         # 遍历角色发射的所有子弹
    306.         for bullet in self.bullet_list.sprites():
    307.             # 将所有越界的子弹收集到delete_list列表中
    308.             if bullet.x < 0 or bullet.x > self.view_manager.screen_width:
    309.                 delete_list.append(bullet)
    310.             if self.bullet_clear == 1:
    311.                 print(self.bullet_clear)
    312.                 self.bullet_list.remove(bullet)
    313.  
    314.         # 清除所有越界的子弹
    315.         self.bullet_list.remove(delete_list)
    316.         # 遍历用户发射的所有子弹
    317.         for bullet in self.bullet_list.sprites():
    318.             # 获取子弹对应的位图
    319.             bitmap = bullet.bitmap(self.view_manager)
    320.             # 子弹移动
    321.             bullet.move(self.pesses_boss_time)
    322.             # 画子弹，根据子弹方向判断是否需要翻转图片
    323.             if bullet.dir == DIR_LEFT and not self.pesses_boss_time:
    324.                 # 对图片执行镜像（第二个参数控制水平镜像，第三个参数控制垂直镜像）
    325.                 bitmap_mirror = pygame.transform.flip(bitmap, True, False)
    326.                 screen.blit(bitmap_mirror, (bullet.x, bullet.y))
    327.             else:
    328.                 screen.blit(bitmap, (bullet.x, bullet.y))
    329.  
    330.     # 处理角色移动的方法
    331.     def move_position(self, screen):
    332.         # 如果不是boss时间让怪物移动怪物
    333.         if  not self.pesses_boss_time:
    334.             if self.move == MOVE_RIGHT:
    335.                 # 更新怪物的位置
    336.                 mm.update_posistion(screen, self.view_manager, self, 6)
    337.                 # 更新角色位置
    338.                 self._x += 6
    339.                 if not self.is_jump:
    340.                     # 不跳的时候，需要设置动作
    341.                     self.action = ACTION_RUN_RIGHT
    342.             elif self.move == MOVE_LEFT:
    343.                 if self.x - 6 < self.view_manager.X_DEFAULT:
    344.                     # 更新怪物的位置
    345.                     mm.update_posistion(screen, self.view_manager, self, \
    346.                         -(self.x - self.view_manager.X_DEFAULT))
    347.                 else:
    348.                     # 更新怪物的位置
    349.                     mm.update_posistion(screen, self.view_manager, self, -6)
    350.                 # 更新角色位置
    351.                 self.x -= 6
    352.                 if not self.is_jump:
    353.                     # 不跳的时候，需要设置动作
    354.                     self.action = ACTION_RUN_LEFT
    355.             elif self.action != ACTION_JUMP_RIGHT and self.action != ACTION_JUMP_LEFT:
    356.                 if not self.is_jump:
    357.                     # 不跳的时候，需要设置动作
    358.                     self.action = ACTION_STAND_RIGHT
    359.         # 否则玩家动
    360.         else:
    361.  
    362.             if self.move == MOVE_RIGHT:
    363.                 # # 更新角色位置
    364.                 self.boss_time_move_x+=6
    365.                 if not self.is_jump:
    366.                     # 不跳的时候，需要设置动作
    367.                     self.action = ACTION_RUN_RIGHT
    368.             elif self.move == MOVE_LEFT:
    369.                 # 更新角色位置
    370.                 self.boss_time_move_x -= 6
    371.                 if not self.is_jump:
    372.                     # 不跳的时候，需要设置动作
    373.                     self.action = ACTION_RUN_LEFT
    374.             elif self.action != ACTION_JUMP_RIGHT and self.action != ACTION_JUMP_LEFT:
    375.                 if not self.is_jump:
    376.                     # 不跳的时候，需要设置动作
    377.                     self.action = ACTION_STAND_RIGHT
    378.     # 处理角色移动与跳的逻辑关系
    379.     def logic(self, screen):
    380.         if self.boos_time_updata_y:
    381.             self.y = 500
    382.             self.x = 100
    383.             self.boos_time_updata_y = False
    384.         if not self.is_jump:
    385.             self.move_position(screen)
    386.             return
    387.         # 如果还没有跳到最高点
    388.         if not self.is_jump_max:
    389.             self.action = ACTION_JUMP_RIGHT if self.get_dir() == \
    390.                 DIR_RIGHT else ACTION_JUMP_LEFT
    391.             # 更新Y坐标
    392.             self.y -= 8
    393.             # 设置子弹在Y方向上具有向上的加速度
    394.             self.set_bullet_y_accelate(-2)
    395.             # 已经达到最高点
    396.             if self.y <= self.view_manager.Y_JUMP_MAX:
    397.                 self.is_jump_max = True
    398.         else:
    399.             self.jump_stop_count -= 1
    400.             # 如果在最高点停留次数已经使用完
    401.             if self.jump_stop_count <= 0:
    402.                 # 更新Y坐标
    403.                 self.y += 8
    404.                 # 设置子弹在Y方向上具有向下的加速度
    405.                 self.set_bullet_y_accelate(2)
    406.                 # 已经掉落到最低点
    407.                 if self.y >= self.view_manager.Y_DEFALUT:
    408.                     # 恢复Y坐标
    409.                     self.y = self.view_manager.Y_DEFALUT
    410.                     self.is_jump = False
    411.                     self.is_jump_max = False
    412.                     self.action = ACTION_STAND_RIGHT
    413.                 else:
    414.                     # 未掉落到最低点，继续使用跳的动作
    415.                     self.action = ACTION_JUMP_RIGHT if self.get_dir() == \
    416.                     DIR_RIGHT else ACTION_JUMP_LEFT
    417.         # 控制角色移动
    418.         self.move_position(screen)
    419.  
    420.     # 更新子弹的位置（子弹位置同样会受到角色的位移的影响）
    421.     def update_bullet_shift(self, shift):
    422.         for bullet in self.bullet_list:
    423.             bullet.x = bullet.x - shift
    424.             
    425.     # 给子弹设置垂直方向上的加速度
    426.     # 游戏的设计是：当角色跳动时，子弹会具有垂直方向上的加速度
    427.     def set_bullet_y_accelate(self, accelate):
    428.         for bullet in self.bullet_list:
    429.             if bullet.y_accelate == 0:
    430.                 bullet.y_accelate = accelate

    3）主程序运行

    1. # coding: utf-8
    2.  
    3. import pygame
    4. import sys
    5. from view_manager import ViewManager
    6. import game_functions as gf
    7. import monster_manager as mm
    8. import boss_manager as bs
    9. from player import *
    10.  
    11. def run_game():
    12.     # 初始化游戏
    13.     pygame.init()
    14.     # 初始化混音器模块
    15.     pygame.mixer.init()
    16.     # 加载背景音乐
    17.     pygame.mixer.music.load('music/background.mp3')
    18.     # 创建ViewManager对象
    19.     view_manager = ViewManager()
    20.     # 设置显示屏幕，返回Surface对象
    21.     screen = pygame.display.set_mode((view_manager.screen_width, 
    22.         view_manager.screen_height))
    23.     # 设置标题
    24.     pygame.display.set_caption('勇者大冒险')
    25.     # 创建玩家角色
    26.     player = Player(view_manager, 'P1', MAX_HP)
    27.     while(True):
    28.         pygame.time.delay(15)
    29.         # 处理游戏事件
    30.         gf.check_events(screen, view_manager, player)
    31.         # 更新游戏屏幕
    32.         gf.update_screen(screen, view_manager, mm, player,bs)
    33.         # 播放背景音乐
    34.         if pygame.mixer.music.get_busy() == False:
    35.             pygame.mixer.music.play()
    36. run_game()

    四、效果展示

    游戏说明：空格射击子弹、反向键移动即可。更多好玩儿的等大家自己体验的啦~

    1）游戏界面

    ​2）开始游戏

    ​3）跳跃射击

    ​4）BOSS时刻

    PS：如果你以前喜欢过《魂斗罗》、《合金弹头》的话，这款游戏绝对值得拥有。

    那种像素游戏中的突突突可能就是青春中简单的浪漫吧，还记得当初上电脑课最快乐的时刻，

    也莫过于反复的死亡，反复地期待着下一周的课，终于在某一周的课上打通了游戏，那时会手

    舞足蹈，引起老师关注，然后被一顿臭骂，但心底的最深处还是掩藏不住得激动。相信这款游

    戏也能给你带来相同的感动。

    总结

    不得不说刚一手我就爱上了这款游戏，在敌人的枪林弹雨中来回跳跃的感觉属实刺激。之前已

    经写过N篇游戏的文章代码啦！要来挑一挑你喜欢的嘛？

    老规矩的撒！来看文章汇总得免费的源码素材的哈👇

    老规矩，木子的文章汇总可以看到分类好的各种不同类型的文章，滴滴我大部分源码都在滴。

    🎯完整的免费源码领取处：找我吖！文末公众hao可自行领取，滴滴我也可！

    🔨推荐往期文章——

     项目1.0《小蜜蜂历险记》

    【Pygame实战】强烈推荐：教你用百行代码编写一款《小蜜蜂历险记》不信？来看看（玩儿嗨了~）

    项目1.1  扑克牌游戏

    【Pygame实战】打扑克牌嘛？赢了输了？这款打牌游戏，竟让我废寝忘食。

    项目1.2  英文单词猜猜看小游戏

    【Pygame实战】再次祭出舍不得分享的学习小技巧，用游戏玩出英文能力（O基础也能轻松get）

    项目8.3  泡泡机游戏

    【Pygame实战】超有趣的泡泡游戏来袭——愿你童心不泯，永远快乐简单哦~

    🎄文章汇总——

    汇总合集  Python—2022 |已有文章汇总 | 持续更新，直接看这篇就够了

    （更多内容+源码都在✨文章汇总哦！！欢迎阅读喜欢的文章🎉~）

  • 相关阅读:
    性能测试-基础01
    rv1126-rv1109-NFS功能
    手摸手教你 docker+jenkins+gitlab 部署你的前端项目
    一级消防工程师证书价值下降，前景茫然？
    sortablejs拖拽后新增和删除行时顺序错乱
    微服务实战系列之玩转Docker（一）
    图片水印怎么加？图片加水印方法分享
    RobotFramework之如何使用数据驱动（十二）
    Vue数据双向绑定的原理+响应式原理
    中介者模式
  • 原文地址：https://blog.csdn.net/weixin_55822277/article/details/126310479