def update(self, dt, events):
if not self.collected:
dist = mathHelpers.distance_to(self.get_pos(),
Player.instance.get_pos())
if dist < 0.5:
Player.instance.keys += 1
self.collected = True
self.agent_pack_name = ""
def update(self, dt, events):
if not self.collected:
dist = mathHelpers.distance_to(self.get_pos(),
Player.instance.get_pos())
if dist < 0.5:
levelData.Level.currentMap.num_of_collected += 1
self.collected = True
self.agent_pack_name = ""
def attack(self, target, dt):
import random
self.look_at(self.target, dt * 2)
self.target.health -= dt * 30
self.target.look_at(self, dt)
self.target.angleY += dt * random.randint(-400, 400)
self.target.rotate(dt * random.randint(-3, 3))
dist_to_player = mathHelpers.distance_to(self.get_pos(),
Player.instance.get_pos())
self.play_sound(dist_to_player, "Attack", True)
def update(self, dt, events):
if not self.open:
dist = mathHelpers.distance_to(self.get_pos(),
Player.instance.get_pos())
if not self.open:
if dist < 0.5:
if Player.instance.keys > 0:
Player.instance.keys -= 1
self.open = True
self.agent_pack_name = ""
elif dist < 1 and Player.instance.keys == 0:
Player.instance.move(-Player.instance.dirX * 0.5,
-Player.instance.dirY * 0.5, dt)
def update(self, dt, events):
import os
super().update(dt, events)
if self.channel == None:
self.channel = pygame.mixer.find_channel(True)
if self.target is not None:
dist_to_player = mathHelpers.distance_to(self.get_pos(),
Player.instance.get_pos())
if isinstance(self.target,
Player) and dist_to_player < 3 and self.canSeePlayer:
self.attack(self.target, dt)
if isinstance(
self.target,
Player) and dist_to_player < 3 and not self.canSeePlayer:
self.look_at(self.target, dt)
if dist_to_player < 5:
self.play_sound(dist_to_player, Enemy.enemy_status.name)
def update(self, dt, events):
super().update(dt, events)
# Status time will lower faster if there is more enemies
# PS: Its a feature
Enemy.enemy_status_time_left -= dt
if Enemy.enemy_status_time_left < 0:
Enemy.enemy_status_time_left = 0
if Enemy.enemy_status == EnemyStatus.Alert:
Enemy.enemy_status = EnemyStatus.Evasion
elif Enemy.enemy_status == EnemyStatus.Evasion:
Enemy.enemy_status = EnemyStatus.Caution
elif Enemy.enemy_status == EnemyStatus.Caution:
Enemy.enemy_status = EnemyStatus.Normal
if Enemy.enemy_status != EnemyStatus.Normal:
Enemy.reset_enemy_status_time()
if Enemy.enemy_status == EnemyStatus.Normal:
self.change_target(self.patrolPoint)
if Player.instance in [x[0] for x in self.entitiesInSight]:
self.canSeePlayer = True
Enemy.change_enemy_status(EnemyStatus.Alert)
else:
self.canSeePlayer = False
if self.canSeePlayer or Enemy.enemy_status == EnemyStatus.Alert:
self.change_target(Player.instance)
if Enemy.enemy_status == EnemyStatus.Evasion:
if self.pathFindingNodesTarget != Player.instance:
self.change_target(Player.instance)
if self.pathFindingComplete:
# pick random point on the map
while len(self.pathFindingNodes) == 0:
random_pos = Entity(
levelData.Level.currentMap.pick_random_point())
self.change_target(random_pos)
if Enemy.enemy_status == EnemyStatus.Caution:
if self.pathFindingComplete:
# pick random point on the map
random_pos = Entity(
levelData.Level.currentMap.pick_random_point())
dx, dy = mathHelpers.slope(self.get_pos(),
random_pos.get_pos())
targetDistance = math.hypot(dx, dy)
if len(self.pathFindingNodes) == 0 or targetDistance < 1:
while len(
self.pathFindingNodes) == 0 and targetDistance < 1:
random_pos = Entity(
levelData.Level.currentMap.pick_random_point())
dx, dy = mathHelpers.slope(self.get_pos(),
random_pos.get_pos())
targetDistance = math.hypot(dx, dy)
self.change_target(random_pos)
if (Enemy.enemy_status == EnemyStatus.Evasion
or Enemy.enemy_status == EnemyStatus.Alert
or Enemy.enemy_status == EnemyStatus.Caution):
self.FOV = self.originalFov * 1.5
self.FOVDepth = self.originalFovDepth * 1.5
else:
self.FOV = self.originalFov
self.FOVDepth = self.originalFovDepth
if self.target is not None:
dx, dy = mathHelpers.slope(self.get_pos(), self.target.get_pos())
targetDistance = math.hypot(dx, dy)
if self.pathFindingNodes is not None and len(
self.pathFindingNodes) > 0:
nextStep = self.pathFindingNodes[0]
nextPathNodeDistance = mathHelpers.distance_to(
self.get_pos(), nextStep)
adjustedNextStep = (nextStep[0] + 0.5, nextStep[1] + 0.5)
self.move_to(Entity(adjustedNextStep), dt)
if nextPathNodeDistance < 0.1:
self.pathFindingNodes.pop(0)
else:
self.pathFindingComplete = True
if targetDistance > 0.5:
self.move_to(self.target, dt)
if isinstance(self.target, Node) and targetDistance < 0.5:
self.timeGuarded += dt
self.rotate(math.radians(36) * dt)
if self.timeGuarded > 1:
self.change_patrol_point()