def update(self, player: PlayerSprite, enemies: Group, screen: Surface):
if (self._data.health <= 0):
self.kill()
enemies.remove(self)
try:
for enemy in enemies:
if sprite.collide_circle(self, enemy) and enemy != self:
distance = math.hypot((enemy.rect.x - self.rect.x),
(enemy.rect.y - self.rect.y))
if (distance < 400):
target_direction = Vector2(
(self.rect.x - enemy.rect.x),
(self.rect.y - enemy.rect.y))
target_direction.scale_to_length(self._data.vel *
0.001)
self.rect.x += target_direction.x
self.rect.y += target_direction.y
# Delete enemy when it comes into contact with player
if sprite.collide_mask(
player, self) is not None and not player.invulnerable:
player.take_damage(1)
self.kill()
enemies.remove(self)
# Type 2 enemy specification
# Auto fire towards player at a given rate
n = time.get_ticks()
if (self._charging) <= 1000:
self._charging = n - self._start
self._pstart = time.get_ticks()
target_direction = Vector2(-self.rect.x + player.rect.x,
-self.rect.y + player.rect.y)
target_direction.scale_to_length(self._data.vel * 2)
self.rect.x += target_direction.x
self.rect.y += target_direction.y
elif (self._charging > 1000):
self._pausing = time.get_ticks() - self._pstart
if (self._pausing) > 550:
self._charging = 0
self._pausing = 0
self._start = time.get_ticks()
screen_rect = screen.get_rect()
self.rect.clamp_ip(screen_rect)
self._data.pos = Vector2(self.rect.center)
self._calc_rotation(player)
except ValueError:
return
def update(self, player: PlayerSprite, enemies: Group, screen: Surface):
if self._data.health <= 0:
self.dead = True
self.kill()
if sprite.collide_mask(player,
self) is not None and not player.invulnerable:
player.take_damage(1.5)
self.take_damage(50)
state = self._data.state
if state is BossState.MOVEDOWN:
target_direction = Vector2(0, 1)
self._data.attack_speed = 2000
self._calc_rotation(player)
self.image.set_alpha(255)
self._data.vel = 6
self._weapon.fire(player, self._data.attack_speed, 10, self.rect)
self._weapon.update()
self.invulnerable_start = time.get_ticks()
elif state is BossState.MOVEUP:
target_direction = Vector2(0, -1)
self._data.attack_speed = 2000
self._calc_rotation(player)
self.image.set_alpha(255)
self._data.vel = 6
self._weapon.fire(player, self._data.attack_speed, 10, self.rect)
self._weapon.update()
self.invulnerable_start = time.get_ticks()
elif state is BossState.TRANSITION:
target_direction = Vector2(0, 0)
self._weapon = self.temp_weapon
self._weapon.spawn()
self._data.invulnerable = True
self.image.set_alpha(100)
self._set_enraged_image(ResourceContainer())
elif state is BossState.ENRAGED:
self._data.invulnerable = False
target_direction = player._data.pos - self._data.pos
target_direction = self._avoid_player(player, target_direction)
self._data.attack_speed = 900
self._calc_rotation(player)
self.image.set_alpha(255)
self._data.vel = 7
self._weapon.fire(player, self._data.attack_speed, 20, self.rect,
3)
self._weapon.update()
if target_direction.length() != 0:
target_direction.scale_to_length(self._data.vel)
screen_rect = screen.get_rect()
self._data.pos += target_direction
self.rect = self.image.get_rect(center=self._data.pos)
self.rect.clamp_ip(screen_rect)
def update(self, player: PlayerSprite, enemies: Group,
screen: Surface) -> None:
if self._data.health <= 0:
self.kill()
# self._bullets.update()
rand_pos_x = random.randint(player._data.pos.x + 50, WINDOW_WIDTH)
rand_pos_y = random.randint(player._data.pos.y + 50, WINDOW_HEIGHT)
# Delete enemy when it comes into contact with player
if sprite.collide_mask(player,
self) is not None and not player.invulnerable:
player.take_damage(1)
self._data.health -= 30
state = self._data.state
if state is BossState.CHARGE:
target_direction = player._data.pos - self._data.pos
if target_direction != 0:
target_direction.scale_to_length(self._data.vel * 3)
self._data.vel = 5
self._data.attack_speed = 150
self._calc_rotation(player)
self._data.pos += target_direction
elif state is BossState.STATIONARY:
target_direction = Vector2(0, 0)
self._data.attack_speed = 15000
self._calc_rotation(player)
self._data.pos += target_direction
elif state is BossState.TELEPORT:
self._data.attack_speed = 0
self._data.vel = 5
self._calc_rotation(player)
self._data.pos.x = rand_pos_x
self._data.pos.y = rand_pos_y
screen_rect = screen.get_rect()
self.rect = self.image.get_rect(center=self._data.pos)
self.rect.clamp_ip(screen_rect)
if state is BossState.TELEPORT:
self._weapon.fire(player, self._data.attack_speed, 15, self.rect,
4)
else:
self._weapon.fire(player, self._data.attack_speed, 15, self.rect,
2)
self._weapon.update()
def update(self, player: PlayerSprite, enemies: Group, screen: Surface):
if (self._data.health <= 0):
self.kill()
enemies.remove(self)
rand_pos_x = random.randint(40, WINDOW_WIDTH / 2)
rand_pos_y = random.randint(40, WINDOW_HEIGHT / 2)
for enemy in enemies:
if sprite.collide_circle(self, enemy) and enemy != self:
distance = math.hypot((enemy.rect.x - self.rect.x),
(enemy.rect.y - self.rect.y))
if (distance < 400):
target_direction = Vector2((self.rect.x - enemy.rect.x),
(self.rect.y - enemy.rect.y))
target_direction.scale_to_length(self._data.vel * 0.001)
self.rect.x += target_direction.x
self.rect.y += target_direction.y
# Delete enemy when it comes into contact with player
if sprite.collide_mask(player,
self) is not None and not player.invulnerable:
player.take_damage(1)
self.kill()
enemies.remove(self)
n = time.get_ticks()
if (n - self.weapon.prev_shot) > 2000 and not self._moved:
self.rect.x = rand_pos_x
self.rect.y = rand_pos_y
self._moved = True
elif (n - self.weapon.prev_shot) > 3000 and self._moved:
if self._weapon.fire(player, self._data.attack_speed, 15,
self.rect):
self._moved = False
else:
self.rect.x = self.rect.x
self.rect.y = self.rect.y
screen_rect = screen.get_rect()
self.rect.clamp_ip(screen_rect)
self._data.pos = Vector2(self.rect.center)
self._calc_rotation(player)
self._weapon.update()
def update(self, player: PlayerSprite, enemies: Group, screen: Surface) -> None:
if self._data.health <= 0:
self.kill()
# Delete enemy when it comes into contact with player
if sprite.collide_mask(player, self) is not None and not player.invulnerable:
player.take_damage(3)
self.take_damage(100)
state = self._data.state
if state is BossState.RETURN:
target_direction = self._data._initial_spawn - self._data.pos
self._data.invulnerable = True
self._data.attack_speed = 10000
self._spin()
self.image.set_alpha(100)
elif state is BossState.STATIONARY:
target_direction = Vector2(0, 0)
self._data.invulnerable = True
self._data.attack_speed = 1500
self._calc_rotation(player)
self.image.set_alpha(100)
self._data.vel = 5
elif state is BossState.ROAM:
target_direction = player._data.pos - self._data.pos
target_direction = self._avoid_player(player, target_direction)
self._data.attack_speed = 200
self._data.invulnerable = False
self._calc_rotation(player)
self.image.set_alpha(255)
self._data.vel = 5
screen_rect = screen.get_rect()
if target_direction.length() != 0:
target_direction.scale_to_length(self._data.vel)
self._data.pos += target_direction
self.rect = self.image.get_rect(center=self._data.pos)
self.rect.clamp_ip(screen_rect)
self._weapon.fire(player, self._data.attack_speed, 15, self.rect)
self._weapon.update()
def update(self, player: PlayerSprite, enemies: Group, screen: Surface):
if(self._data.health <= 0):
self.kill()
enemies.remove(self)
for enemy in enemies:
# Check for nearby enemies to avoid collision
if sprite.collide_circle(self, enemy) and enemy != self:
distance = math.hypot(
(enemy.rect.x - self.rect.x), (enemy.rect.y - self.rect.y))
if (distance < 400):
target_direction = Vector2(
(self.rect.x - enemy.rect.x), (self.rect.y - enemy.rect.y))
target_direction.scale_to_length(
self._data.vel * 0.001)
self.rect.x += target_direction.x
self.rect.y += target_direction.y
target_direction = Vector2(
- self.rect.x + player.rect.x + random.randrange(0, 30),
- self.rect.y + player.rect.y + random.randrange(0, 30))
target_direction.scale_to_length(self._data.vel * 0.7)
# Delete enemy when it comes into contact with player
if sprite.collide_mask(player, self) is not None and not player.invulnerable:
player.take_damage(1)
self.kill()
enemies.remove(self)
self.rect.x += target_direction.x
self.rect.y += target_direction.y
screen_rect = screen.get_rect()
self.rect.clamp_ip(screen_rect)
self._data.pos = Vector2(self.rect.center)
self._calc_rotation(player)
class PlayerManager(Manager):
def __init__(self, res_container: ResourceContainer):
super().__init__(res_container)
self._player = None
def spawn(self):
player_data = PlayerData(
4, 750,
Vector2(display.Info().current_w / 2,
display.Info().current_h / 2), 10)
self._player = PlayerSprite(self._res_container, player_data)
def draw(self, screen):
self._player.draw(screen)
def update(self, screen, enemies: sprite.Group(), newRoom):
self._player.update(screen, newRoom)
if enemies is not None:
for enemy in enemies:
if isinstance(enemy, WeaponEnemy):
hits = sprite.spritecollide(
self._player, enemy._weapon._bullets, True,
lambda sp1, sp2: not sp1.invulnerable and sprite.
collide_mask(sp1, sp2))
for bullet in hits:
if bullet._data.type5:
draw.circle(screen, RED,
(bullet.rect.x, bullet.rect.y), 100,
100)
display.flip()
display.update()
display.flip()
display.update()
self._player.take_damage(enemy._damage)
bullet.kill()
@property
def player(self):
return self._player
def update(self, player: PlayerSprite, enemies: Group, screen: Surface):
if(self._data.health <= 0):
self.kill()
enemies.remove(self)
# Check for nearby enemies, only move in certain case
for enemy in enemies:
if sprite.collide_circle(self, enemy) and enemy != self:
distance = math.hypot(
(enemy.rect.x - self.rect.x), (enemy.rect.y - self.rect.y))
if (distance < 400):
target_direction = Vector2(
(self.rect.x - enemy.rect.x), (self.rect.y - enemy.rect.y))
target_direction.scale_to_length(
self._data.vel * 0.001)
self.rect.x += target_direction.x
self.rect.y += target_direction.y
# Type 2 enemy backs away from player
distance = math.hypot(
(player.rect.x - self.rect.x), (player.rect.y - self.rect.y))
if (distance > 550):
self._data._stopMoving = False
# Enemy moves toward player given that they are either type 1 or sufficiently far enough from player
if not self._data._stopMoving:
target_direction = Vector2(
- self.rect.x + player.rect.x + random.randrange(0, 30), - self.rect.y + player.rect.y + random.randrange(0, 30))
target_direction.scale_to_length(self._data.vel * 0.9)
# Delete enemy when it comes into contact with player
if sprite.collide_mask(player, self) is not None and not player.invulnerable:
player.take_damage(1)
self.kill()
enemies.remove(self)
# Stop moving towards player at a certain distance
if sprite.collide_circle(self, player):
self._data._stopMoving = True
distance = math.hypot(
(player.rect.x-self.rect.x), (player.rect.y - self.rect.y))
# Move back if in danger zone
if(distance < 550):
target_direction = Vector2(
(self.rect.x - player.rect.x), (self.rect.y - player.rect.y))
target_direction.scale_to_length(self._data.vel * 1.01)
self.rect.x += target_direction.x
self.rect.y += target_direction.y
# All other cases are given movement data here
if self._data._stopMoving is False:
self.rect.x += target_direction.x
self.rect.y += target_direction.y
screen_rect = screen.get_rect()
self.rect.clamp_ip(screen_rect)
self._data.pos = Vector2(self.rect.center)
self._calc_rotation(player)
self._weapon.fire(player, self._data.attack_speed,
15, self.rect, 550)
self._weapon.update(player, screen)