refactor: Update AgentInfo class to use Civilian instead of Human for entity comparison

Author: shima004

adf_core_python/core/agent/info/agent_info.py

@@ -2,6 +2,7 @@
 from typing import Any
 
 from rcrs_core.agents.agent import Agent
+from rcrs_core.entities.civilian import Civilian
 from rcrs_core.entities.entity import Entity
 from rcrs_core.entities.human import Human
 from rcrs_core.worldmodel.changeSet import ChangeSet
@@ -137,8 +138,8 @@ def some_one_on_board(self) -> Human | None:
         """
         entity_id: EntityID = self.get_entity_id()
         for entity in self._world_model.get_entities():
-            if isinstance(entity, Human):
-                if entity.get_position_property() == entity_id:
+            if isinstance(entity, Civilian):
+                if entity.get_position() == entity_id:
                     return entity
         return None
 

adf_core_python/implement/extend_action/default_extend_action_transport.py

@@ -21,6 +21,7 @@
 from adf_core_python.core.agent.precompute.precompute_data import PrecomputeData
 from adf_core_python.core.component.extaction.ext_action import ExtAction
 from adf_core_python.core.component.module.algorithm.path_planning import PathPlanning
+from adf_core_python.core.logger.logger import get_agent_logger
 
 
 # TODO: refactor this class
@@ -38,6 +39,10 @@ def __init__(
         )
         self._target_entity_id: Optional[EntityID] = None
         self._threshold_to_rest: int = develop_data.get_value("threshold_to_rest", 100)
+        self._logger = get_agent_logger(
+            f"{self.__class__.__module__}.{self.__class__.__qualname__}",
+            self.agent_info,
+        )
 
         match self.scenario_info.get_mode():
             case Mode.NON_PRECOMPUTE:
@@ -102,6 +107,7 @@ def calc(self) -> ExtAction:
         )
         transport_human: Optional[Human] = self.agent_info.some_one_on_board()
         if transport_human is not None:
+            self._logger.debug(f"transport_human: {transport_human.get_id()}")
             self.result = self.calc_unload(
                 agent, self._path_planning, transport_human, self._target_entity_id
             )
@@ -135,7 +141,7 @@ def calc_rescue(
 
             target_position = human.get_position()
             if agent_position == target_position:
-                if isinstance(human, Civilian) and ((human.get_buriedness() or 0) > 0):
+                if isinstance(human, Civilian) and ((human.get_buriedness() or 0) == 0):
                     return ActionLoad(human.get_id())
             else:
                 path = path_planning.get_path(agent_position, target_position)

adf_core_python/implement/module/complex/default_human_detector.py

@@ -1,6 +1,7 @@
 from typing import Optional, cast
 
 from rcrs_core.connection.URN import Entity as EntityURN
+from rcrs_core.entities.civilian import Civilian
 from rcrs_core.entities.entity import Entity
 from rcrs_core.entities.human import Human
 from rcrs_core.worldmodel.entityID import EntityID
@@ -12,6 +13,7 @@
 from adf_core_python.core.agent.module.module_manager import ModuleManager
 from adf_core_python.core.component.module.algorithm.clustering import Clustering
 from adf_core_python.core.component.module.complex.human_detector import HumanDetector
+from adf_core_python.core.logger.logger import get_agent_logger
 
 
 class DefaultHumanDetector(HumanDetector):
@@ -36,6 +38,10 @@ def __init__(
         self.register_sub_module(self._clustering)
 
         self._result: Optional[EntityID] = None
+        self._logger = get_agent_logger(
+            f"{self.__class__.__module__}.{self.__class__.__qualname__}",
+            self._agent_info,
+        )
 
     def calculate(self) -> HumanDetector:
         transport_human: Optional[Human] = self._agent_info.some_one_on_board()
@@ -44,8 +50,11 @@ def calculate(self) -> HumanDetector:
             return self
 
         if self._result is not None:
-            if self._is_valid_human(self._result):
-                self._result = self._select_target()
+            if not self._is_valid_human(self._result):
+                self._result = None
+
+        if self._result is None:
+            self._result = self._select_target()
 
         return self
 
@@ -59,28 +68,54 @@ def _select_target(self) -> Optional[EntityID]:
         cluster_entities: list[Entity] = self._clustering.get_cluster_entities(
             cluster_index
         )
+
+        self._logger.debug(
+            f"cluster_entities: {[str(entity.get_id()) for entity in cluster_entities]}"
+        )
+
         cluster_valid_human_entities: list[Entity] = [
             entity
             for entity in cluster_entities
-            if self._is_valid_human(entity.get_id())
+            if self._is_valid_human(entity.get_id()) and isinstance(entity, Civilian)
         ]
-        if len(cluster_valid_human_entities) == 0:
-            return None
+        if len(cluster_valid_human_entities) != 0:
+            nearest_human_entity: Optional[Entity] = cluster_valid_human_entities[0]
+            nearest_distance: float = self._world_info.get_distance(
+                self._agent_info.get_entity_id(),
+                nearest_human_entity.get_id(),
+            )
+            for entity in cluster_valid_human_entities:
+                distance: float = self._world_info.get_distance(
+                    self._agent_info.get_entity_id(),
+                    entity.get_id(),
+                )
+                if distance < nearest_distance:
+                    nearest_distance = distance
+                    nearest_human_entity = entity
+            return nearest_human_entity.get_id()
 
-        nearest_human_entity: Optional[Entity] = None
-        nearest_distance: float = 10**10
-        for entity in cluster_valid_human_entities:
-            distance: float = self._world_info.get_distance(
+        world_valid_human_entities: list[Entity] = [
+            entity
+            for entity in self._world_info.get_entities_of_types([Civilian])
+            if self._is_valid_human(entity.get_id())
+        ]
+        if len(world_valid_human_entities) != 0:
+            nearest_human_entity: Optional[Entity] = world_valid_human_entities[0]
+            nearest_distance: float = self._world_info.get_distance(
                 self._agent_info.get_entity_id(),
-                entity.get_id(),
+                nearest_human_entity.get_id(),
             )
-            if distance < nearest_distance:
-                nearest_distance = distance
-                nearest_human_entity = entity
+            for entity in world_valid_human_entities:
+                distance: float = self._world_info.get_distance(
+                    self._agent_info.get_entity_id(),
+                    entity.get_id(),
+                )
+                if distance < nearest_distance:
+                    nearest_distance = distance
+                    nearest_human_entity = entity
+            return nearest_human_entity.get_id()
 
-        return (
-            nearest_human_entity.get_id() if nearest_human_entity is not None else None
-        )
+        return None
 
     def _is_valid_human(self, target_entity_id: EntityID) -> bool:
         target: Optional[Entity] = self._world_info.get_entity(target_entity_id)
@@ -94,6 +129,9 @@ def _is_valid_human(self, target_entity_id: EntityID) -> bool:
         buriedness: Optional[int] = target.get_buriedness()
         if buriedness is None or buriedness > 0:
             return False
+        damage: Optional[int] = target.get_damage()
+        if damage is None or damage == 0:
+            return False
         position_entity_id: Optional[EntityID] = target.get_position()
         if position_entity_id is None:
             return False

adf_core_python/implement/module/complex/default_search.py

@@ -1,7 +1,8 @@
 from typing import Optional, cast
 
-from rcrs_core.connection.URN import Entity as EntityURN
+from rcrs_core.entities.building import Building
 from rcrs_core.entities.entity import Entity
+from rcrs_core.entities.refuge import Refuge
 from rcrs_core.worldmodel.entityID import EntityID
 
 from adf_core_python.core.agent.communication.message_manager import MessageManager
@@ -55,10 +56,8 @@ def update_info(self, message_manager: MessageManager) -> Search:
         if self.get_count_update_info() > 1:
             return self
 
-        searched_building_ids = self._world_info.get_change_set().get_changed_entities()
-        self._unsearched_building_ids = self._unsearched_building_ids.difference(
-            searched_building_ids
-        )
+        searched_building_id = self._agent_info.get_position_entity_id()
+        self._unsearched_building_ids.discard(searched_building_id)
 
         if len(self._unsearched_building_ids) == 0:
             self._unsearched_building_ids = self._get_search_targets()
@@ -91,8 +90,7 @@ def _get_search_targets(self) -> set[EntityID]:
         building_entity_ids: list[EntityID] = [
             entity.get_id()
             for entity in cluster_entities
-            if entity.get_urn() == EntityURN.BUILDING
-            and entity.get_urn() != EntityURN.REFUGE
+            if isinstance(entity, Building) and not isinstance(entity, Refuge)
         ]
 
         return set(building_entity_ids)

adf_core_python/implement/tactics/default_tactics_ambulance_team.py

@@ -120,6 +120,10 @@ def think(
         entity_id = agent_info.get_entity_id()  # noqa: F841
 
         target_entity_id = self._human_detector.calculate().get_target_entity_id()
+        self._logger.debug(
+            f"human detector target_entity_id: {target_entity_id}",
+            time=agent_info.get_time(),
+        )
         if target_entity_id is not None:
             action = (
                 self._action_transport.set_target_entity_id(target_entity_id)
@@ -131,6 +135,9 @@ def think(
                 return action
 
         target_entity_id = self._search.calculate().get_target_entity_id()
+        self._logger.debug(
+            f"search target_entity_id: {target_entity_id}", time=agent_info.get_time()
+        )
         if target_entity_id is not None:
             action = (
                 self._action_ext_move.set_target_entity_id(target_entity_id)