• python/pygame 挑战魂斗罗 笔记(三)

    感觉最难的部分已经解决了，下面开始发射子弹。

    一、建立ContraBullet.py文件，Bullit类：

    1、设定子弹速度

    Config.py中设定子弹移动速度为常量Constant.BULLET_SPEED = 8。

    2、载入子弹图片：

    图片也是6张，子弹发出后逐渐变大(这是为什么呢)？同样建立bullet_list列表和bullet_number索引。载入图片后获取rect属性再按照人物放大比例放大，加到子弹列表中。

    3、子弹图片索引

    设置一个计数器变量counter，随着循环增加到30，也就是1/2个FPS，就让子弹图片索引增加1，改变子弹图片样式。

    1. import os.path
    2.  
    3. import pygame
    4.  
    5. from Config import Constant
    6.  
    7.  
    8. class Bullet(pygame.sprite.Sprite):
    9.     def __init__(self, x, y):
    10.         pygame.sprite.Sprite.__init__(self)
    11.         self.bullet_list = []
    12.         self.bullet_number = 0
    13.         for i in range(6):
    14.             image = pygame.image.load(os.path.join('image', 'bullet', 'bullet' + str(i + 1) + '.png'))
    15.             rect = image.get_rect()
    16.             image = pygame.transform.scale(
    17.                 image, (rect.width * Constant.PLAYER_SCALE, rect.height * Constant.PLAYER_SCALE))
    18.             self.bullet_list.append(image)
    19.         self.image = self.bullet_list[self.bullet_number]
    20.         self.rect = self.image.get_rect()
    21.         self.rect.centerx = x
    22.         self.rect.centery = y
    23.         self.speed_x = 0
    24.         self.speed_y = 0
    25.  
    26.         self.counter = 0
    27.  
    28.     def update(self):
    29.         if self.counter >= 30:
    30.             self.bullet_number += 1
    31.             if self.bullet_number > 5:
    32.                 self.bullet_number = 0
    33.         else:
    34.             self.counter += 1
    35.         self.image = self.bullet_list[self.bullet_number]
    36.         self.rect.x += self.speed_x
    37.         self.rect.y += self.speed_y

    二、Bill类增加按键判定以及shoot发射方法：

    1、设定k键为发射子弹以及子弹发射间隔时间、子弹x、y方向移速和不同角度子弹发射位置等变量。
    1.             self.bullet_time = 0
    2.             self.bullet_speed_x = 0
    3.             self.bullet_speed_y = 0
    4.             self.bullet_x = self.rect.right
    5.             self.bullet_y = self.rect.y + 11.5 * Constant.PLAYER_SCALE
    2、建立shoot发射子弹方法：

    主要是理清各种方向、状态下子弹的发射位置和x、y方向的速度。

    1.     def shoot(self):
    2.         if self.direction == 'right':
    3.             self.bullet_speed_x = Constant.BULLET_SPEED
    4.             self.bullet_x = self.rect.right
    5.         elif self.direction == 'left':
    6.             self.bullet_speed_x = -Constant.BULLET_SPEED
    7.             self.bullet_x = self.rect.left
    8.  
    9.         if self.image_type == 'stand':
    10.             self.bullet_y = self.rect.y + 11.5 * Constant.PLAYER_SCALE
    11.             self.bullet_speed_y = 0
    12.         elif self.image_type == 'down':
    13.             self.bullet_y = self.rect.y + 24 * Constant.PLAYER_SCALE
    14.             self.bullet_speed_y = 0
    15.         elif self.image_type == 'up':
    16.             self.bullet_y = self.rect.y
    17.             self.bullet_speed_x = 0
    18.             self.bullet_speed_y = -Constant.BULLET_SPEED
    19.         elif self.image_type == 'oblique_down':
    20.             self.bullet_y = self.rect.y + 20.5 * Constant.PLAYER_SCALE
    21.             self.bullet_speed_y = Constant.BULLET_SPEED
    22.         elif self.image_type == 'oblique_up':
    23.             self.bullet_y = self.rect.y
    24.             self.bullet_speed_y = -Constant.BULLET_SPEED
    25.  
    26.         if self.bullet_time >= 30:
    27.             bill_bullet = ContraBullet.Bullet(self.bullet_x, self.bullet_y)
    28.             bill_bullet.speed_x = self.bullet_speed_x
    29.             bill_bullet.speed_y = self.bullet_speed_y
    30.             Variable.all_sprites.add(bill_bullet)
    31.             self.bullet_time = 0
    32.         else:
    33.             self.bullet_time += 1

    子弹发射成功！ 

    三、添加敌人：

    1、敌人图片载入

    敌人就简单一点吧，只选择了一个图片形象的，PS处理完，一共7张图片，6个行走运动的，1个射击状态的，这里让敌人从游戏窗口外面开始落下来，坠落状态的图片就省去了。

    设定一个敌人图片列表，同样需要载入图片并按照PLAYER_SCALE比例放大。

    再设定一些变量，来控制敌人的产生时间间隔以及发射子弹间隔等。

    1. import os.path
    2. import random
    3.  
    4. import pygame
    5.  
    6. from Config import Constant, Variable
    7.  
    8.  
    9. class Enemy(pygame.sprite.Sprite):
    10.     def __init__(self):
    11.         pygame.sprite.Sprite.__init__(self)
    12.         self.enemy_list = []
    13.         for i in range(7):
    14.             image = pygame.image.load(os.path.join('image', 'enemy', 'enemy' + str(i + 1) + '.png'))
    15.             rect = image.get_rect()
    16.             image = pygame.transform.scale(
    17.                 image, (rect.width * Constant.PLAYER_SCALE, rect.height * Constant.PLAYER_SCALE))
    18.             image = pygame.transform.flip(image, True, False)
    19.             self.enemy_list.append(image)
    20.         self.order = 0
    21.         self.shooting = False
    22.         if self.shooting:
    23.             self.image = self.enemy_list[6]
    24.         else:
    25.             self.image = self.enemy_list[self.order]
    26.         self.rect = self.image.get_rect()
    27.         self.rect.x = random.randrange(Constant.WIDTH, Constant.WIDTH * 5)
    28.         self.rect.y = 100
    29.  
    30.         self.counter = 0
    31.         self.speed = 2
    32.         self.floor = 0
    33.  
    34.         self.last_time = 0
    35.         self.now_time = 0
    2、敌人的产生方法

    定义一个敌人的组，用来判定碰撞及控制敌人数量。

    0-100之间取一个随机数，等与50时产生一个敌人，分别加入敌人组和所有精灵组。

    1. def new_enemy():
    2.     if Variable.step == 2 and len(Variable.enemy_sprites) <= 3:
    3.         i = random.randint(0, 100)
    4.         if i == 50:
    5.             enemy = Enemy()
    6.             Variable.all_sprites.add(enemy)
    7.             Variable.enemy_sprites.add(enemy)
    3、移动及射击

    先写个索引循环方法，控制order，每完成一次移动图片，计数器counter+1，到5时射击一次。也就是6张移动图片轮回5次就射击一次。

    1.     def order_loop(self):
    2.         self.now_time = pygame.time.get_ticks()
    3.         if self.now_time - self.last_time >= 150:
    4.             self.order += 1
    5.             if self.order > 6:
    6.                 self.counter += 1
    7.                 self.order = 0
    8.                 if self.counter >= 5:
    9.                     self.shooting = True
    10.             self.last_time = self.now_time

     再定义一个射击方法，子弹的位置和移动速度

    1.     def shoot(self):
    2.         enemy_bullet = ContraBullet.Bullet(self.rect.left, self.rect.y + 7.5 * Constant.PLAYER_SCALE)
    3.         enemy_bullet.speed_x = -10
    4.         Variable.all_sprites.add(enemy_bullet)
    5.         self.shooting = False
    6.         self.counter = 0

     更新update，实现移动、图片改变及射击。同样也是让敌人一直处于下落状态，碰到地面碰撞体就停止下落，并向左移动。这里写的比较简单，没有考虑敌人的跳跃问题。

    1.     def update(self):
    2.         if self.shooting:
    3.             self.image = self.enemy_list[6]
    4.         else:
    5.             self.image = self.enemy_list[self.order]
    6.         self.rect.y += Constant.GRAVITY * 10
    7.         self.order_loop()
    8.  
    9.         if self.shooting:
    10.             self.shoot()
    11.  
    12.         collider_ground = pygame.sprite.groupcollide(Variable.enemy_sprites, Variable.collider, False, False)
    13.         for e, l in collider_ground.items():
    14.             self.floor = l[0].rect.top
    15.             e.rect.bottom = self.floor
    16.             e.rect.x -= self.speed

    四、全部文件：

    剩下的就是各种碰撞检测和关头了，这里就不再写啦。把所有文件都完整贴一遍。

    1、Contra.py主循环文件

    感觉都挺长时间没改动这个文件了，就增加了一个ContraEnemy.new_enemy()。

    1. # Contra.py
    2. import sys
    3. import pygame
    4.  
    5. import ContraBill
    6. import ContraMap
    7. import ContraEnemy
    8. from Config import Constant, Variable
    9.  
    10.  
    11. def control():
    12.     for event in pygame.event.get():
    13.         if event.type == pygame.QUIT:
    14.             Variable.game_start = False
    15.         if event.type == pygame.KEYDOWN:
    16.             if event.key == pygame.K_RETURN:
    17.                 Variable.step = 1
    18.  
    19.  
    20. class Main:
    21.     def __init__(self):
    22.         pygame.init()
    23.         self.game_window = pygame.display.set_mode((Constant.WIDTH, Constant.HEIGHT))
    24.         self.clock = pygame.time.Clock()
    25.  
    26.     def game_loop(self):
    27.         while Variable.game_start:
    28.             control()
    29.             if Variable.stage == 1:
    30.                 ContraMap.new_stage()
    31.                 ContraBill.new_player()
    32.                 ContraEnemy.new_enemy()
    33.  
    34.             if Variable.stage == 2:
    35.                 pass
    36.  
    37.             if Variable.stage == 3:
    38.                 pass
    39.  
    40.             Variable.all_sprites.draw(self.game_window)
    41.             Variable.all_sprites.update()
    42.  
    43.             self.clock.tick(Constant.FPS)
    44.             pygame.display.set_caption(f'魂斗罗  1.0    {self.clock.get_fps():.2f}')
    45.             pygame.display.update()
    46.  
    47.         pygame.quit()
    48.         sys.exit()
    49.  
    50.  
    51. if __name__ == '__main__':
    52.     main = Main()
    53.     main.game_loop()
    2、ContraMap.py第一关背景地图及地面碰撞体文件

    别的关的背景地图也是按照这个方式，再单独测算每个台阶的位置和长度，一条条的把地面碰撞体给绘制出来就可以了。

    1. # ContraMap.py
    2. import os
    3. import pygame
    4.  
    5. from Config import Constant, Variable
    6.  
    7.  
    8. class StageMap(pygame.sprite.Sprite):
    9.     def __init__(self, order):
    10.         pygame.sprite.Sprite.__init__(self)
    11.         self.image_list = []
    12.         self.order = order
    13.         for i in range(1, 9):
    14.             image = pygame.image.load(os.path.join('image', 'map', 'stage' + str(i) + '.png'))
    15.             rect = image.get_rect()
    16.             image = pygame.transform.scale(image, (rect.width * Constant.MAP_SCALE, rect.height * Constant.MAP_SCALE))
    17.             self.image_list.append(image)
    18.         self.image = self.image_list[self.order]
    19.         self.rect = self.image.get_rect()
    20.         self.rect.x = 0
    21.         self.rect.y = 0
    22.         self.speed = 0
    23.  
    24.     def update(self):
    25.         if self.order == 2:
    26.             print('纵向地图')
    27.         else:
    28.             if Variable.step == 0 and self.rect.x >= -Constant.WIDTH:
    29.                 self.rect.x -= 10
    30.             if Variable.step == 1 and self.rect.x > -Constant.WIDTH * 2:
    31.                 self.rect.x -= 10
    32.                 if self.rect.x == -Constant.WIDTH * 2:
    33.                     Variable.step = 2
    34.                     Variable.all_sprites.add(Variable.collider)
    35.  
    36.  
    37. def new_stage():
    38.     if Variable.map_switch:
    39.         stage_map = StageMap(Variable.stage - 1)
    40.         Variable.all_sprites.add(stage_map)
    41.         Variable.map_storage.add(stage_map)
    42.         Variable.map_switch = False
    43.  
    44.  
    45. class CollideGround(pygame.sprite.Sprite):
    46.     def __init__(self, length, x, y):
    47.         pygame.sprite.Sprite.__init__(self)
    48.         self.image = pygame.Surface((length * Constant.MAP_SCALE, 3))
    49.         self.image.fill((255, 0, 0))
    50.         self.rect = self.image.get_rect()
    51.         self.rect.x = x * Constant.MAP_SCALE - Constant.WIDTH * 2
    52.         self.rect.y = y * Constant.MAP_SCALE
    53.  
    54.  
    55. Variable.collider83.add(
    56.     CollideGround(511, 2176, 83),
    57.     CollideGround(161, 2847, 83),
    58.     CollideGround(64, 3296, 83)
    59. )
    60.  
    61. Variable.collider115.add(
    62.     CollideGround(736, 832, 115),
    63.     CollideGround(128, 1568, 115),
    64.     CollideGround(160, 1695, 115),
    65.     CollideGround(128, 1856, 115),
    66.     CollideGround(256, 1984, 115),
    67.     CollideGround(224, 2656, 115),
    68.     CollideGround(65, 3040, 115),
    69.     CollideGround(64, 3264, 115),
    70.     CollideGround(64, 3392, 115),
    71.     CollideGround(128, 3808, 115)
    72. )
    73.  
    74. Variable.collider146.add(
    75.     CollideGround(97, 959, 146),
    76.     CollideGround(66, 1215, 146),
    77.     CollideGround(225, 2400, 146),
    78.     CollideGround(96, 2976, 146),
    79.     CollideGround(64, 3136, 146),
    80.     CollideGround(160, 3424, 146),
    81.     CollideGround(64, 3744, 146),
    82.     CollideGround(32, 3936, 146)
    83. )
    84.  
    85. Variable.collider163.add(
    86.     CollideGround(95, 1440, 163),
    87.     CollideGround(64, 2304, 163),
    88.     CollideGround(32, 2912, 163),
    89.     CollideGround(32, 2328, 163),
    90.     CollideGround(32, 3328, 163),
    91.     CollideGround(97, 3840, 163)
    92. )
    93.  
    94. Variable.collider178.add(
    95.     CollideGround(32, 1055, 178),
    96.     CollideGround(32, 1151, 178),
    97.     CollideGround(65, 2720, 178),
    98.     CollideGround(64, 2816, 178),
    99.     CollideGround(96, 3168, 178),
    100.     CollideGround(63, 3648, 178),
    101.     CollideGround(32, 3969, 178)
    102. )
    103.  
    104. Variable.collider211.add(
    105.     CollideGround(63, 1088, 211),
    106.     CollideGround(63, 1407, 211),
    107.     CollideGround(97, 2208, 211),
    108.     CollideGround(192, 2528, 211),
    109.     CollideGround(33, 3135, 211),
    110.     CollideGround(33, 3295, 211),
    111.     CollideGround(97, 3520, 211),
    112.     CollideGround(242, 3807, 211)
    113. )
    114.  
    115. Variable.collider.add(Variable.collider83, Variable.collider115, Variable.collider146, Variable.collider163,
    116.                       Variable.collider178, Variable.collider211, Variable.collider231)
    3、ContraBill.py主角玩家文件

    主角Bill向下跳跃，后来想了想，是不是可以考虑写一个矮点的碰撞体紧随Bill的脚下，然后由这个碰撞体来检测是否和地面碰撞体碰撞，这样就不用等Bill的top超过地面碰撞体就可以把它加回来了。而且在往上跳时，也不会因为两层地面距离太近直接跳到上面层了，感觉体验感应该会好些。

    1. # ContraBill.py
    2. import os
    3. import pygame
    4.  
    5. import ContraBullet
    6.  
    7. from Config import Constant, Variable
    8.  
    9.  
    10. class Bill(pygame.sprite.Sprite):
    11.     def __init__(self):
    12.         pygame.sprite.Sprite.__init__(self)
    13.         self.image_dict = {
    14.             'be_hit': [],
    15.             'down': [],
    16.             'jump': [],
    17.             'oblique_down': [],
    18.             'oblique_up': [],
    19.             'run': [],
    20.             'shoot': [],
    21.             'stand': [],
    22.             'up': []
    23.         }
    24.         for i in range(6):
    25.             for key in self.image_dict:
    26.                 image = pygame.image.load(os.path.join('image', 'bill', str(key), str(key) + str(i + 1) + '.png'))
    27.                 rect = image.get_rect()
    28.                 image_scale = pygame.transform.scale(
    29.                     image, (rect.width * Constant.PLAYER_SCALE, rect.height * Constant.PLAYER_SCALE))
    30.                 self.image_dict[key].append(image_scale)
    31.  
    32.             self.image_order = 0
    33.             self.image_type = 'stand'
    34.  
    35.             self.image = self.image_dict[self.image_type][self.image_order]
    36.             self.rect = self.image.get_rect()
    37.             self.rect.x = 100
    38.             self.rect.y = 100
    39.             self.direction = 'right'
    40.  
    41.             self.now_time = 0
    42.             self.last_time = 0
    43.  
    44.             self.falling = True
    45.             self.jumping = False
    46.             self.moving = False
    47.             self.floor = 0
    48.  
    49.             self.bullet_time = 0
    50.             self.bullet_speed_x = 0
    51.             self.bullet_speed_y = 0
    52.             self.bullet_x = self.rect.right
    53.             self.bullet_y = self.rect.y + 11.5 * Constant.PLAYER_SCALE
    54.  
    55.     def update(self):
    56.         self.image = self.image_dict[self.image_type][self.image_order]
    57.         if self.direction == 'left':
    58.             self.image = pygame.transform.flip(self.image, True, False)
    59.  
    60.         if self.rect.top >= self.floor:
    61.             for i in Variable.sprite_storage:
    62.                 Variable.collider.add(i)
    63.                 Variable.sprite_storage.remove(i)
    64.  
    65.         key_pressed = pygame.key.get_pressed()
    66.  
    67.         if self.falling:
    68.             self.fall()
    69.  
    70.         if self.jumping:
    71.             self.jump()
    72.  
    73.         if self.moving:
    74.             self.move()
    75.  
    76.         self.order_loop()
    77.  
    78.         collider_ground = pygame.sprite.groupcollide(Variable.player_sprites, Variable.collider, False, False)
    79.         for p, l in collider_ground.items():
    80.             self.floor = l[0].rect.top
    81.             p.rect.bottom = self.floor
    82.  
    83.             if key_pressed[pygame.K_k]:
    84.                 self.shoot()
    85.  
    86.             if key_pressed[pygame.K_d]:
    87.                 self.direction = 'right'
    88.                 self.moving = True
    89.                 if key_pressed[pygame.K_w]:
    90.                     self.image_type = 'oblique_up'
    91.                 elif key_pressed[pygame.K_s]:
    92.                     self.image_type = 'oblique_down'
    93.                 elif key_pressed[pygame.K_j]:
    94.                     self.image_type = 'jump'
    95.                     self.jumping = True
    96.                     self.falling = False
    97.                 else:
    98.                     self.image_type = 'run'
    99.             elif key_pressed[pygame.K_a]:
    100.                 self.direction = 'left'
    101.                 self.moving = True
    102.                 if key_pressed[pygame.K_w]:
    103.                     self.image_type = 'oblique_up'
    104.                 elif key_pressed[pygame.K_s]:
    105.                     self.image_type = 'oblique_down'
    106.                 elif key_pressed[pygame.K_j]:
    107.                     self.image_type = 'jump'
    108.                     self.jumping = True
    109.                     self.falling = False
    110.                 else:
    111.                     self.image_type = 'run'
    112.  
    113.             elif key_pressed[pygame.K_w]:
    114.                 self.image_type = 'up'
    115.                 self.moving = False
    116.  
    117.             elif key_pressed[pygame.K_s]:
    118.                 self.image_type = 'down'
    119.                 self.moving = False
    120.  
    121.             else:
    122.                 self.image_type = 'stand'
    123.                 self.moving = False
    124.  
    125.             if key_pressed[pygame.K_s] and key_pressed[pygame.K_j]:
    126.                 self.image_type = 'oblique_down'
    127.                 Variable.collider.remove(l[0])
    128.                 Variable.sprite_storage.add(l[0])
    129.  
    130.     def shoot(self):
    131.         if self.direction == 'right':
    132.             self.bullet_speed_x = Constant.BULLET_SPEED
    133.             self.bullet_x = self.rect.right
    134.         elif self.direction == 'left':
    135.             self.bullet_speed_x = -Constant.BULLET_SPEED
    136.             self.bullet_x = self.rect.left
    137.  
    138.         if self.image_type == 'stand':
    139.             self.bullet_y = self.rect.y + 11.5 * Constant.PLAYER_SCALE
    140.             self.bullet_speed_y = 0
    141.         elif self.image_type == 'down':
    142.             self.bullet_y = self.rect.y + 24 * Constant.PLAYER_SCALE
    143.             self.bullet_speed_y = 0
    144.         elif self.image_type == 'up':
    145.             self.bullet_y = self.rect.y
    146.             self.bullet_speed_x = 0
    147.             self.bullet_speed_y = -Constant.BULLET_SPEED
    148.         elif self.image_type == 'oblique_down':
    149.             self.bullet_y = self.rect.y + 20.5 * Constant.PLAYER_SCALE
    150.             self.bullet_speed_y = Constant.BULLET_SPEED
    151.         elif self.image_type == 'oblique_up':
    152.             self.bullet_y = self.rect.y
    153.             self.bullet_speed_y = -Constant.BULLET_SPEED
    154.  
    155.         if self.bullet_time >= 30:
    156.             bill_bullet = ContraBullet.Bullet(self.bullet_x, self.bullet_y)
    157.             bill_bullet.speed_x = self.bullet_speed_x
    158.             bill_bullet.speed_y = self.bullet_speed_y
    159.             Variable.all_sprites.add(bill_bullet)
    160.             self.bullet_time = 0
    161.         else:
    162.             self.bullet_time += 1
    163.  
    164.     def order_loop(self):
    165.         self.now_time = pygame.time.get_ticks()
    166.         if self.now_time - self.last_time >= 100:
    167.             self.image_order += 1
    168.             if self.image_order > 5:
    169.                 self.image_order = 0
    170.             self.last_time = self.now_time
    171.  
    172.     def move(self):
    173.         if self.direction == 'right' and self.rect.right <= Constant.WIDTH - 80 * Constant.MAP_SCALE:
    174.             self.rect.x += Constant.SPEED_X
    175.             if self.rect.centerx >= Constant.WIDTH / 2:
    176.                 x = self.rect.centerx - Constant.WIDTH / 2
    177.                 for j in Variable.map_storage:
    178.                     if j.rect.right >= Constant.WIDTH:
    179.                         for i in Variable.all_sprites:
    180.                             i.rect.x -= x
    181.  
    182.         elif self.direction == 'left' and self.rect.left >= 40 * Constant.MAP_SCALE:
    183.             self.rect.x -= Constant.SPEED_X
    184.             if self.rect.centerx <= Constant.WIDTH / 2:
    185.                 x = Constant.WIDTH / 2 - self.rect.centerx
    186.                 for j in Variable.map_storage:
    187.                     if j.rect.left <= -Constant.WIDTH * 2:
    188.                         for i in Variable.all_sprites:
    189.                             i.rect.x += x
    190.  
    191.     def jump(self):
    192.         Constant.SPEED_Y += Constant.GRAVITY
    193.         self.rect.y += Constant.SPEED_Y
    194.         if Constant.SPEED_Y == 0:
    195.             self.jumping = False
    196.             self.falling = True
    197.             Constant.SPEED_Y = -10
    198.  
    199.     def fall(self):
    200.         self.rect.y += Constant.GRAVITY * 10
    201.  
    202.  
    203. def new_player():
    204.     if Variable.step == 2 and Variable.player_switch:
    205.         bill = Bill()
    206.         Variable.all_sprites.add(bill)
    207.         Variable.player_sprites.add(bill)
    208.         Variable.player_switch = False
    4、ContraEnemy.py

    敌人这里写的太简单了，连出游戏窗口的判定都没写！我记得正常游戏里面还有一些在墙上的炮台啥的，还有随机掉落的各种buff以及关头。

    1. import os.path
    2. import random
    3.  
    4. import pygame
    5.  
    6. import ContraBullet
    7. from Config import Constant, Variable
    8.  
    9.  
    10. class Enemy(pygame.sprite.Sprite):
    11.     def __init__(self):
    12.         pygame.sprite.Sprite.__init__(self)
    13.         self.enemy_list = []
    14.         for i in range(7):
    15.             image = pygame.image.load(os.path.join('image', 'enemy', 'enemy' + str(i + 1) + '.png'))
    16.             rect = image.get_rect()
    17.             image = pygame.transform.scale(
    18.                 image, (rect.width * Constant.PLAYER_SCALE, rect.height * Constant.PLAYER_SCALE))
    19.             image = pygame.transform.flip(image, True, False)
    20.             self.enemy_list.append(image)
    21.         self.order = 0
    22.         self.shooting = False
    23.         if self.shooting:
    24.             self.image = self.enemy_list[6]
    25.         else:
    26.             self.image = self.enemy_list[self.order]
    27.         self.rect = self.image.get_rect()
    28.         self.rect.x = random.randrange(Constant.WIDTH, Constant.WIDTH * 5)
    29.         self.rect.y = 100
    30.  
    31.         self.counter = 0
    32.         self.speed = 2
    33.         self.floor = 0
    34.  
    35.         self.last_time = 0
    36.         self.now_time = 0
    37.  
    38.     def update(self):
    39.         if self.shooting:
    40.             self.image = self.enemy_list[6]
    41.         else:
    42.             self.image = self.enemy_list[self.order]
    43.         self.rect.y += Constant.GRAVITY * 10
    44.         self.order_loop()
    45.  
    46.         if self.shooting:
    47.             self.shoot()
    48.  
    49.         collider_ground = pygame.sprite.groupcollide(Variable.enemy_sprites, Variable.collider, False, False)
    50.         for e, l in collider_ground.items():
    51.             self.floor = l[0].rect.top
    52.             e.rect.bottom = self.floor
    53.             e.rect.x -= self.speed
    54.  
    55.     def order_loop(self):
    56.         self.now_time = pygame.time.get_ticks()
    57.         if self.now_time - self.last_time >= 150:
    58.             self.order += 1
    59.             if self.order > 6:
    60.                 self.counter += 1
    61.                 self.order = 0
    62.                 if self.counter >= 5:
    63.                     self.shooting = True
    64.             self.last_time = self.now_time
    65.  
    66.     def shoot(self):
    67.         enemy_bullet = ContraBullet.Bullet(self.rect.left, self.rect.y + 7.5 * Constant.PLAYER_SCALE)
    68.         enemy_bullet.speed_x = -10
    69.         Variable.all_sprites.add(enemy_bullet)
    70.         self.shooting = False
    71.         self.counter = 0
    72.  
    73.  
    74. def new_enemy():
    75.     if Variable.step == 2 and len(Variable.enemy_sprites) <= 3:
    76.         i = random.randint(0, 100)
    77.         if i == 50:
    78.             enemy = Enemy()
    79.             Variable.all_sprites.add(enemy)
    80.             Variable.enemy_sprites.add(enemy)
    5、ContraBullet.py

    子弹这里没有区分双方的子弹，同样也没写出游戏窗口后kill。

    1. import os.path
    2.  
    3. import pygame
    4.  
    5. from Config import Constant
    6.  
    7.  
    8. class Bullet(pygame.sprite.Sprite):
    9.     def __init__(self, x, y):
    10.         pygame.sprite.Sprite.__init__(self)
    11.         self.bullet_list = []
    12.         self.bullet_number = 0
    13.         for i in range(6):
    14.             image = pygame.image.load(os.path.join('image', 'bullet', 'bullet' + str(i + 1) + '.png'))
    15.             rect = image.get_rect()
    16.             image = pygame.transform.scale(
    17.                 image, (rect.width * Constant.PLAYER_SCALE, rect.height * Constant.PLAYER_SCALE))
    18.             self.bullet_list.append(image)
    19.         self.image = self.bullet_list[self.bullet_number]
    20.         self.rect = self.image.get_rect()
    21.         self.rect.centerx = x
    22.         self.rect.centery = y
    23.         self.speed_x = 0
    24.         self.speed_y = 0
    25.  
    26.         self.counter = 0
    27.  
    28.     def update(self):
    29.         if self.counter >= 30:
    30.             self.bullet_number += 1
    31.             if self.bullet_number > 5:
    32.                 self.bullet_number = 0
    33.         else:
    34.             self.counter += 1
    35.         self.image = self.bullet_list[self.bullet_number]
    36.         self.rect.x += self.speed_x
    37.         self.rect.y += self.speed_y
    6、Config.py

    把游戏的全局常量、变量单独写出来，感觉在调用时还是挺方便的。

    1. # Config.py
    2. import pygame
    3.  
    4.  
    5. class Constant:
    6.     WIDTH = 1200
    7.     HEIGHT = 720
    8.     FPS = 60
    9.  
    10.     MAP_SCALE = 3
    11.     PLAYER_SCALE = 2.5
    12.  
    13.     SPEED_X = 3
    14.     SPEED_Y = -10
    15.     GRAVITY = 0.5
    16.  
    17.     BULLET_SPEED = 8
    18.  
    19.  
    20. class Variable:
    21.     all_sprites = pygame.sprite.Group()
    22.     player_sprites = pygame.sprite.Group()
    23.     enemy_sprites = pygame.sprite.Group()
    24.  
    25.     collider = pygame.sprite.Group()
    26.     collider83 = pygame.sprite.Group()
    27.     collider115 = pygame.sprite.Group()
    28.     collider146 = pygame.sprite.Group()
    29.     collider163 = pygame.sprite.Group()
    30.     collider178 = pygame.sprite.Group()
    31.     collider211 = pygame.sprite.Group()
    32.     collider231 = pygame.sprite.Group()
    33.  
    34.     sprite_storage = pygame.sprite.Group()
    35.     map_storage = pygame.sprite.Group()
    36.  
    37.     game_start = True
    38.  
    39.     map_switch = True
    40.     player_switch = True
    41.  
    42.     enemy_counter = 0
    43.  
    44.     stage = 1
    45.     step = 0

  • 相关阅读:
    网络编码中的椭圆曲线多重签名方案
    Prompt Playground 7月开发记录(2)： Avalonia 应用开发
    Yarn工作机制流程
    多线程之ConcurrentHashMap原理
    Vue官方文档（48）: vuex的基本使用
    【Nacos】Nacos集群模式启动报错&解决方案
    Visual Studio 2019 简单安装教程
    C---链表
    （面试题）面试官为啥总是让我们手撕call、apply、bind?
    DFT specification file & string
  • 原文地址：https://blog.csdn.net/2302_76282232/article/details/137676971