Exemplo n.º 1
0
    def _spawn_show_case_ship(self, entity_id):
        self._player_ship.x = config.display_width / 4
        self._player_ship.y = config.display_height * .75
        x_pos = config.display_width / 4

        if entity_id in [
                EnemyID.ARBITRATOR, EnemyID.TERMINUS, EnemyID.JUDICATOR
        ]:
            ship = enemy_generator.generate_enemy(entity_id,
                                                  x_pos -
                                                  (config.ship_size // 4),
                                                  config.display_height / 3,
                                                  effects=self.effects)
        elif entity_id in [
                EnemyID.MOTHERSHIP, EnemyID.DESPOILER, EnemyID.PHANTOM,
                EnemyID.CYCLOPS
        ]:
            ship = enemy_generator.generate_enemy(entity_id,
                                                  x_pos -
                                                  (config.ship_size // 2),
                                                  config.display_height / 3,
                                                  effects=self.effects)
        elif entity_id in EnemyID:
            ship = enemy_generator.generate_enemy(entity_id, x_pos,
                                                  config.display_height / 3)
        else:
            return
        ship.projectile_damage = 0
        self._props.append(ship)
Exemplo n.º 2
0
 def spawn_ships(self):
     # ~18% chance of spawning small ships randomly
     if random.randint(1, 6) == 6:
         random_ship_quantity = random.randint(1, 4)
         x_posns = []
         for _ in range(random_ship_quantity):
             random_speed = random.randint(5, 15)
             rand_x = 0
             good_x = False
             while not good_x:
                 rand_x = random.randint(
                     0, config.display_width - config.ship_size)
                 try:
                     for posn in x_posns:
                         if posn - config.ship_size < rand_x < posn + config.ship_size:
                             raise ValueError
                 except ValueError:
                     continue
                 good_x = True
             ship_id = PlayerID.CITADEL
             if random.randint(1, 4) == 4:
                 ship_id = PlayerID.AEGIS
             ship = enemy_generator.generate_enemy(
                 ship_id,
                 rand_x,
                 config.display_height,
                 speed=random_speed,
                 hp=10,
                 shield=20,
                 fire_rate=config.game_fps // 2)
             x_posns.append(rand_x)
             ship.set_waypoint(wp=Waypoint(rand_x, -config.display_height))
             # They do not shoot
             ship.ready_to_fire = False
             self.friendly_ships.append(ship)
     # 4% chance of spawning a Longsword
     if random.randint(1, 25) == 25:
         count = 0
         for ship in self.friendly_ships:
             if ship.entity_id == AllyID.LONGSWORD:
                 count += 1
                 if count == 2:
                     return
         rand_x = random.randint(-config.display_width // 2,
                                 config.display_width // 2)
         ship = enemy_generator.generate_enemy(AllyID.LONGSWORD,
                                               rand_x,
                                               config.display_height,
                                               speed=2,
                                               hp=100,
                                               shield=100)
         ship.set_waypoint(wp=Waypoint(rand_x, -config.ship_size * 10))
         ship.ready_to_fire = False
         self.friendly_ships.append(ship)
         self.friendly_ships.extend(ship.spawn_turrets())
Exemplo n.º 3
0
    def spawn_enemy(self, entity_id):
        enemy_stats = self._stats.get(entity_id)
        # Creates a random starting position
        x_pos = random.randint(config.ship_size,
                               config.display_width - config.ship_size)
        # Sets their fire rate randomly, from .75 seconds to 2 seconds
        fire_rate = random.randint(self._fire_rate_range[0],
                                   self._fire_rate_range[1])
        y_pos = -config.ship_size
        if entity_id == EnemyID.TITAN:
            y_pos = -config.ship_size * 8
            x_pos = (config.display_width - (config.ship_size * 8)) // 2

        ship = enemy_generator.generate_enemy(
            entity_id,
            x_pos,
            y_pos,
            hp=enemy_stats["HP"],
            speed=enemy_stats["SPEED"],
            fire_rate=fire_rate,
            shield=enemy_stats["SHIELD"],
            ai=self,
            effects=self._model.get_effects())
        ship.y = -ship.size // 2
        self._model.enemy_ships.append(ship)
        if entity_id == EnemyID.TITAN:
            self._model.enemy_ships.extend(ship.spawn_turrets())
        return ship
Exemplo n.º 4
0
 def switch_weapon(self, weapon):
     super().switch_weapon(weapon)
     self._player_stats["DAMAGE"] = 0
     self._player_ship.x = x_pos = config.display_width / 4
     self._player_ship.y = config.display_height * .75
     x_pos -= config.ship_size
     for i in range(3):
         mandible = enemy_generator.generate_enemy(
             EnemyID.MANDIBLE, x_pos + (i * config.ship_size),
             config.display_height / 3)
         mandible.fire_rate = 0
         self._props.append(mandible)
Exemplo n.º 5
0
 def spawn_turrets(self):
     x_pos = (self.x + (self.size / 2)) - config.ship_size
     for _ in range(2):
         for i in range(3):
             y_pos = self.y + (self.size / 2) - (i * config.ship_size)
             archer = enemy_generator.generate_enemy(
                 AllyID.ARCHER,
                 x_pos,
                 y_pos,
                 hp=self.hp + self.shield,
                 fire_rate=config.game_fps // 2)
             archer.projectile_damage = 8
             archer.remove_if_offscreen = False
             self._turrets.append(archer)
         x_pos += config.ship_size
     return self._turrets
Exemplo n.º 6
0
 def spawn_turrets(self):
     # Terminus center turret
     base_size = config.ship_size
     center_x = self.x + (self.size // 2)
     left_x = center_x - base_size
     right_x = center_x + base_size
     center_y = self.y + (self.size // 2)
     # Mantis side turrets
     # Upper middle
     mantis1 = enemy_generator.generate_enemy(EnemyID.MANTIS, left_x - (base_size // 2), center_y - base_size,
                                              hp=self.max_hp, shield=self.max_shield, fire_rate=self.fire_rate // 5)
     mantis1.entity_id = EnemyID.SUBJUGATOR
     mantis1.projectile_type = ProjectileID.ENEMY_MISSILE
     mantis1.fire_variance = 20
     mantis2 = enemy_generator.generate_enemy(EnemyID.MANTIS, right_x - (base_size // 2), center_y - base_size,
                                              hp=self.max_hp, shield=self.max_shield, fire_rate=self.fire_rate // 5)
     mantis2.entity_id = EnemyID.SUBJUGATOR
     mantis2.projectile_type = ProjectileID.ENEMY_MISSILE
     mantis2.fire_variance = 20
     # Lower middle
     mantis3 = enemy_generator.generate_enemy(EnemyID.MANTIS, left_x - base_size, center_y, hp=self.max_hp,
                                              shield=self.max_shield, fire_rate=self.fire_rate // 4)
     mantis4 = enemy_generator.generate_enemy(EnemyID.MANTIS, right_x, center_y, hp=self.max_hp,
                                              shield=self.max_shield, fire_rate=self.fire_rate // 4)
     # Far left
     mantis5 = enemy_generator.generate_enemy(EnemyID.MANTIS, left_x - (1.5 * base_size), center_y - base_size,
                                              hp=self.max_hp, shield=self.max_shield, fire_rate=self.fire_rate // 3)
     # Far right
     mantis6 = enemy_generator.generate_enemy(EnemyID.MANTIS, right_x + (base_size // 2), center_y - base_size,
                                              hp=self.max_hp, shield=self.max_shield, fire_rate=self.fire_rate // 3)
     # Middle
     mantis7 = enemy_generator.generate_enemy(EnemyID.MANTIS, center_x - (base_size // 2), center_y, hp=self.max_hp,
                                              shield=self.max_shield, fire_rate=self.fire_rate // 6)
     # Middle Terminus
     terminus = enemy_generator.generate_enemy(EnemyID.TERMINUS, center_x - (.75 * base_size), center_y - base_size,
                                               hp=self.max_hp, shield=self.max_shield, fire_rate=self.fire_rate // 4,
                                               effects=self._effects)
     terminus.projectile_damage = 20
     self._turrets = [mantis1, mantis2, mantis3, mantis4, mantis5, mantis6, mantis7, terminus]
     for turret in self._turrets:
         turret.remove_if_offscreen = False
     return self._turrets
Exemplo n.º 7
0
 def spawn_ally(self):
     # 20% chance of spawning small ships randomly
     if random.randint(1, 5) == 5:
         random_ship_quantity = random.randint(1, 4)
         x_posns = []
         for _ in range(random_ship_quantity):
             random_speed = random.randint(5, 10)
             rand_x = 0
             good_x = False
             while not good_x:
                 rand_x = random.randint(
                     0, config.display_width - config.ship_size)
                 try:
                     for posn in x_posns:
                         if posn - config.ship_size < rand_x < posn + config.ship_size:
                             raise ValueError
                 except ValueError:
                     continue
                 good_x = True
             ship_id = PlayerID.CITADEL
             if random.randint(1, 4) == 4:
                 ship_id = PlayerID.AEGIS
             ship = enemy_generator.generate_enemy(
                 ship_id,
                 rand_x,
                 config.display_height,
                 speed=random_speed,
                 hp=30,
                 shield=30,
                 fire_rate=config.game_fps // 2)
             x_posns.append(rand_x)
             ship.set_waypoint(wp=Waypoint(rand_x, -config.display_height))
             self._model.friendly_ships.append(ship)
     # 5% chance of spawning a Longsword
     if random.randint(1, 20) == 20:
         # Only allows 1 on screen at once
         for ship in self._model.friendly_ships:
             if ship.entity_id == AllyID.LONGSWORD:
                 return
         rand_x = random.randint(-config.display_width // 2,
                                 config.display_width // 2)
         ship = enemy_generator.generate_enemy(AllyID.LONGSWORD,
                                               rand_x,
                                               config.display_height,
                                               speed=2,
                                               hp=2000,
                                               shield=500)
         ship.set_waypoint(wp=Waypoint(rand_x, -config.ship_size * 12))
         self._model.friendly_ships.append(ship)
         self._model.friendly_ships.extend(ship.spawn_turrets())
     # 10% chance of spawning a persistent ally
     if random.randint(1,
                       10) == 10 and len(self._model.friendly_ships) < 12:
         hp = 50
         rand_x = random.randint(0, config.display_width - config.ship_size)
         ship_id = PlayerID.CITADEL
         if random.randint(1, 4) == 4:
             ship_id = PlayerID.AEGIS
             hp *= 2
         ship = enemy_generator.generate_enemy(ship_id,
                                               rand_x,
                                               config.display_height,
                                               speed=5,
                                               hp=hp,
                                               shield=20,
                                               fire_rate=config.game_fps //
                                               2)
         self._model.friendly_ships.append(ship)
     # 10% chance of spawning an Archer turret
     if random.randint(1,
                       10) == 10 and len(self._model.friendly_ships) < 12:
         hp = 50
         rand_x = random.randint(0, config.display_width - config.ship_size)
         ship_id = AllyID.ARCHER
         ship = enemy_generator.generate_enemy(ship_id,
                                               rand_x,
                                               config.display_height,
                                               speed=5,
                                               hp=hp,
                                               shield=20,
                                               fire_rate=config.game_fps //
                                               2)
         self._model.friendly_ships.append(ship)