def update_path_towards_target(self, agent_entity: WorldEntity,
game_state: GameState,
target_entity: WorldEntity):
agent_cell = _translate_world_position_to_cell(
agent_entity.get_position(), game_state.entire_world_area)
target_cell = _translate_world_position_to_cell(
target_entity.get_position(), game_state.entire_world_area)
agent_cell_size = (
agent_entity.pygame_collision_rect.w // GRID_CELL_WIDTH + 1,
agent_entity.pygame_collision_rect.h // GRID_CELL_WIDTH + 1)
self.global_path_finder.register_entity_size(agent_cell_size)
path_with_cells = self.global_path_finder.run(agent_cell_size,
agent_cell, target_cell)
if path_with_cells:
# Note: Cells are expressed in non-negative values (and need to be translated to game world coordinates)
path = [
_translate_cell_to_world_position(cell,
game_state.entire_world_area)
for cell in path_with_cells
]
if DEBUG_RENDER_PATHFINDING:
_add_visual_lines_along_path(game_state, path)
self.path = path
else:
self.path = None
def control_npc(self, game_state: GameState, npc: NonPlayerCharacter, player_entity: WorldEntity,
is_player_invisible: bool, time_passed: Millis):
super().control_npc(game_state, npc, player_entity, is_player_invisible, time_passed)
self.sprint_cooldown_remaining -= time_passed
sprint_distance_limit = 250
if self.sprint_cooldown_remaining <= 0:
is_far_away = get_manhattan_distance(
npc.world_entity.get_position(), player_entity.get_position()) > sprint_distance_limit
if is_far_away:
npc.gain_buff_effect(get_buff_effect(BuffType.ENEMY_GOBLIN_SPEARMAN_SPRINT), Millis(2500))
self.sprint_cooldown_remaining = self.random_cooldown()
def handle_nearby_entities(self, player_entity: WorldEntity,
game_state: GameState, game_engine: GameEngine):
self.entity_to_interact_with = None
player_position = player_entity.get_position()
distance_to_closest_entity = sys.maxsize
for npc in game_state.non_player_characters:
if has_npc_dialog(npc.npc_type):
close_to_player = is_x_and_y_within_distance(
player_position, npc.world_entity.get_position(), 75)
distance = get_manhattan_distance_between_rects(
player_entity.rect(), npc.world_entity.rect())
if close_to_player and distance < distance_to_closest_entity:
self.entity_to_interact_with = npc
distance_to_closest_entity = distance
lootables_on_ground: List[LootableOnGround] = list(
game_state.items_on_ground)
lootables_on_ground += game_state.consumables_on_ground
for lootable in lootables_on_ground:
if boxes_intersect(player_entity.rect(),
lootable.world_entity.rect()):
self.entity_to_interact_with = lootable
distance_to_closest_entity = 0
for portal in game_state.portals:
close_to_player = is_x_and_y_within_distance(
player_position, portal.world_entity.get_position(), 75)
distance = get_manhattan_distance_between_rects(
player_entity.rect(), portal.world_entity.rect())
if close_to_player:
game_engine.handle_being_close_to_portal(portal)
if close_to_player and distance < distance_to_closest_entity:
self.entity_to_interact_with = portal
distance_to_closest_entity = distance
for warp_point in game_state.warp_points:
close_to_player = is_x_and_y_within_distance(
player_position, warp_point.world_entity.get_position(), 75)
distance = get_manhattan_distance_between_rects(
player_entity.rect(), warp_point.world_entity.rect())
if close_to_player and distance < distance_to_closest_entity:
self.entity_to_interact_with = warp_point
distance_to_closest_entity = distance
for chest in game_state.chests:
close_to_player = is_x_and_y_within_distance(
player_position, chest.world_entity.get_position(), 75)
distance = get_manhattan_distance_between_rects(
player_entity.rect(), chest.world_entity.rect())
if close_to_player and distance < distance_to_closest_entity:
self.entity_to_interact_with = chest
distance_to_closest_entity = distance
def control_npc(self, game_state: GameState, npc: NonPlayerCharacter, player_entity: WorldEntity,
is_player_invisible: bool, time_passed: Millis):
self._time_since_attack += time_passed
self._time_since_updated_path += time_passed
self._time_since_reevaluated += time_passed
enemy_entity = npc.world_entity
target: EnemyTarget = get_target(enemy_entity, game_state)
if self._time_since_updated_path > self._update_path_interval:
self._time_since_updated_path = 0
if not is_player_invisible:
self.pathfinder.update_path_towards_target(enemy_entity, game_state, target.entity)
new_next_waypoint = self.pathfinder.get_next_waypoint_along_path(enemy_entity)
should_update_waypoint = self.next_waypoint != new_next_waypoint
if self._time_since_reevaluated > self._reevaluate_next_waypoint_direction_interval:
self._time_since_reevaluated = 0
should_update_waypoint = True
if should_update_waypoint:
self.next_waypoint = new_next_waypoint
if self.next_waypoint:
direction = self.pathfinder.get_dir_towards_considering_collisions(
game_state, enemy_entity, self.next_waypoint)
if random.random() < 0.5 and direction:
direction = random.choice(get_perpendicular_directions(direction))
_move_in_dir(enemy_entity, direction)
else:
enemy_entity.set_not_moving()
if self._time_since_attack > self._attack_interval:
self._time_since_attack = 0
self._update_attack_interval()
directions_to_player = get_directions_to_position(npc.world_entity, player_entity.get_position())
new_direction = directions_to_player[0]
if random.random() < 0.3 and directions_to_player[1] is not None:
new_direction = directions_to_player[1]
npc.world_entity.direction = new_direction
npc.world_entity.set_not_moving()
center_position = npc.world_entity.get_center_position()
distance_from_enemy = 35
projectile_pos = translate_in_direction(
get_position_from_center_position(center_position, PROJECTILE_SIZE),
npc.world_entity.direction, distance_from_enemy)
projectile_speed = 0.11
projectile_entity = WorldEntity(projectile_pos, PROJECTILE_SIZE, PROJECTILE_SPRITE,
npc.world_entity.direction, projectile_speed)
projectile = Projectile(projectile_entity, create_projectile_controller(PROJECTILE_TYPE))
game_state.projectile_entities.append(projectile)
play_sound(SoundId.ENEMY_ATTACK_GOBLIN_WARLOCK)
def get_target(agent_entity: WorldEntity, game_state: GameState) -> EnemyTarget:
# Enemies should prioritize attacking a summon over attacking the player
player_summons = [npc for npc in game_state.non_player_characters
if npc.npc_category == NpcCategory.PLAYER_SUMMON]
if player_summons:
player_summon = player_summons[0]
agent_position = agent_entity.get_position()
distance_to_npc_target = get_manhattan_distance(player_summon.world_entity.get_position(),
agent_position)
distance_to_player = get_manhattan_distance(game_state.player_entity.get_position(), agent_position)
if distance_to_npc_target < distance_to_player:
return EnemyTarget.npc(player_summon.world_entity, player_summon)
return EnemyTarget.player(game_state.player_entity)
def control_npc(self, game_state: GameState, npc: NonPlayerCharacter,
player_entity: WorldEntity, _is_player_invisible: bool,
time_passed: Millis):
self._time_since_decision += time_passed
self._time_since_healing += time_passed
self._time_since_shoot += time_passed
if self._time_since_healing > self._healing_cooldown:
self._time_since_healing = 0
self._healing_cooldown = self._random_healing_cooldown()
if not npc.health_resource.is_at_max():
healing_amount = random.randint(10, 20)
npc.health_resource.gain(healing_amount)
circle_effect = VisualCircle(
(80, 200, 150), npc.world_entity.get_center_position(), 30,
50, Millis(350), 3)
game_state.visual_effects.append(circle_effect)
number_effect = create_visual_healing_text(
npc.world_entity, healing_amount)
game_state.visual_effects.append(number_effect)
play_sound(SoundId.ENEMY_SKELETON_MAGE_HEAL)
if self._time_since_shoot > self._shoot_cooldown:
self._time_since_shoot = 0
self._shoot_cooldown = self._random_shoot_cooldown()
npc.world_entity.direction = get_directions_to_position(
npc.world_entity, player_entity.get_position())[0]
npc.world_entity.set_not_moving()
center_position = npc.world_entity.get_center_position()
distance_from_enemy = 35
projectile_pos = translate_in_direction(
get_position_from_center_position(center_position,
PROJECTILE_SIZE),
npc.world_entity.direction, distance_from_enemy)
projectile_speed = 0.2
projectile_entity = WorldEntity(projectile_pos, PROJECTILE_SIZE,
Sprite.NONE,
npc.world_entity.direction,
projectile_speed)
projectile = Projectile(
projectile_entity,
create_projectile_controller(PROJECTILE_TYPE))
game_state.projectile_entities.append(projectile)
play_sound(SoundId.ENEMY_ATTACK_SKELETON_MAGE)
if self._time_since_decision > self._decision_interval:
self._time_since_decision = 0
if random.random() < 0.2:
direction = random_direction()
npc.world_entity.set_moving_in_dir(direction)
else:
npc.world_entity.set_not_moving()
def get_next_waypoint_along_path(
self, agent_entity: WorldEntity) -> Optional[Tuple[int, int]]:
if self.path:
# -----------------------------------------------
# 1: Remove first waypoint if close enough to it
# -----------------------------------------------
# TODO: Does this cause problems for specific entity sizes / movement speeds?
closeness_margin = 50
if is_x_and_y_within_distance(agent_entity.get_position(),
self.path[0], closeness_margin):
# print("Popping " + str(self.path[0]) + " as I'm so close to it.")
self.path.pop(0)
if self.path:
# print("After popping, returning " + str(self.path[0]))
return self.path[0]
else:
# print("no path after popping. stopping.")
return None
# -----------------------------------------------
# 2: Remove first waypoint if it's opposite direction of second waypoint
# -----------------------------------------------
if len(self.path) >= 2:
dir_to_waypoint_0 = get_directions_to_position(
agent_entity, self.path[0])[0]
dir_to_waypoint_1 = get_directions_to_position(
agent_entity, self.path[1])[0]
if dir_to_waypoint_0 == get_opposite_direction(
dir_to_waypoint_1):
# print("Not gonna go back. Popping " + str(self.path[0]))
self.path.pop(0)
# print("Popped first position. Next waypoint: " + str(self.path[0]))
return self.path[0]
if self.path:
return self.path[0]
else:
# print("no path found. stopping.")
return None
# print("Leaked through. returning none")
return None
def _add_visual_line_to_next_waypoint(destination, agent_entity: WorldEntity,
game_state: GameState):
start = _get_middle_of_cell_from_position(agent_entity.get_position())
end = _get_middle_of_cell_from_position(destination)
game_state.visual_effects.append(
VisualLine((150, 150, 150), start, end, Millis(100), 2))
def serialize(entity: WorldEntity):
return PlayerJson.serialize_from_position(entity.get_position())
def control_npc(self, game_state: GameState, npc: NonPlayerCharacter, player_entity: WorldEntity,
_is_player_invisible: bool, time_passed: Millis):
self._time_since_decision += time_passed
self._time_since_summoning += time_passed
self._time_since_healing += time_passed
self._time_since_shoot += time_passed
if self._time_since_summoning > self._summoning_cooldown:
necro_center_pos = npc.world_entity.get_center_position()
self._time_since_summoning = 0
self._alive_summons = [summon for summon in self._alive_summons
if summon in game_state.non_player_characters]
if len(self._alive_summons) < 3:
relative_pos_from_summoner = (random.randint(-150, 150), random.randint(-150, 150))
summon_center_pos = sum_of_vectors(necro_center_pos, relative_pos_from_summoner)
summon_type = random.choice([NpcType.ZOMBIE, NpcType.MUMMY])
summon_size = NON_PLAYER_CHARACTERS[summon_type].size
summon_pos = game_state.get_within_world(
get_position_from_center_position(summon_center_pos, summon_size), summon_size)
summon_enemy = create_npc(summon_type, summon_pos)
is_wall_blocking = game_state.walls_state.does_rect_intersect_with_wall(
rect_from_corners(necro_center_pos, summon_center_pos))
is_position_blocked = game_state.would_entity_collide_if_new_pos(summon_enemy.world_entity, summon_pos)
if not is_wall_blocking and not is_position_blocked:
self._summoning_cooldown = self._random_summoning_cooldown()
game_state.add_non_player_character(summon_enemy)
self._alive_summons.append(summon_enemy)
game_state.visual_effects.append(
VisualCircle((80, 150, 100), necro_center_pos, 40, 70, Millis(120), 3))
game_state.visual_effects.append(
VisualCircle((80, 150, 100), summon_center_pos, 40, 70, Millis(120), 3))
play_sound(SoundId.ENEMY_NECROMANCER_SUMMON)
else:
# Failed to summon, so try again without waiting full duration
self._summoning_cooldown = 500
else:
self._summoning_cooldown = self._random_summoning_cooldown()
if self._time_since_healing > self._healing_cooldown:
self._time_since_healing = 0
self._healing_cooldown = self._random_healing_cooldown()
necro_center_pos = npc.world_entity.get_center_position()
nearby_hurt_enemies = [
e for e in game_state.non_player_characters
if e.is_enemy
and is_x_and_y_within_distance(necro_center_pos, e.world_entity.get_center_position(), 200)
and e != npc and not e.health_resource.is_at_max()
]
if nearby_hurt_enemies:
healing_target = nearby_hurt_enemies[0]
healing_target.health_resource.gain(5)
healing_target_pos = healing_target.world_entity.get_center_position()
visual_line = VisualLine((80, 200, 150), necro_center_pos, healing_target_pos, Millis(350), 3)
game_state.visual_effects.append(visual_line)
play_sound(SoundId.ENEMY_NECROMANCER_HEAL)
if self._time_since_shoot > self._shoot_cooldown:
self._time_since_shoot = 0
self._shoot_cooldown = self._random_shoot_cooldown()
npc.world_entity.direction = get_directions_to_position(npc.world_entity, player_entity.get_position())[0]
npc.world_entity.set_not_moving()
center_position = npc.world_entity.get_center_position()
distance_from_enemy = 35
projectile_pos = translate_in_direction(
get_position_from_center_position(center_position, PROJECTILE_SIZE),
npc.world_entity.direction, distance_from_enemy)
projectile_speed = 0.2
projectile_entity = WorldEntity(projectile_pos, PROJECTILE_SIZE, Sprite.NONE, npc.world_entity.direction,
projectile_speed)
projectile = Projectile(projectile_entity, create_projectile_controller(PROJECTILE_TYPE))
game_state.projectile_entities.append(projectile)
play_sound(SoundId.ENEMY_ATTACK_NECRO)
if self._time_since_decision > self._decision_interval:
self._time_since_decision = 0
if random.random() < 0.2:
direction = random_direction()
npc.world_entity.set_moving_in_dir(direction)
else:
npc.world_entity.set_not_moving()
def serialize(entity: WorldEntity):
return {"position": entity.get_position()}
