feat: add office agents for ambulance, fire, and police

Author: shima004

adf_core_python/cli/template/config/module.yaml

@@ -22,17 +22,17 @@ DefaultTacticsPoliceForce:
   CommandExecutorPolice: adf_core_python.implement.centralized.DefaultCommandExecutorPolice
   CommandExecutorScout: adf_core_python.implement.centralized.DefaultCommandExecutorScoutPolice
 
-# DefaultTacticsAmbulanceCentre:
-#   TargetAllocator: sample_team.module.complex.SampleAmbulanceTargetAllocator
-#   CommandPicker: adf_core_python.implement.centralized.DefaultCommandPickerAmbulance
+DefaultTacticsAmbulanceCenter:
+  TargetAllocator: adf_core_python.implement.module.complex.default_ambulance_target_allocator.DefaultAmbulanceTargetAllocator
+  # CommandPicker: adf_core_python.implement.centralized.DefaultCommandPickerAmbulance
 
-# DefaultTacticsFireStation:
-#   TargetAllocator: sample_team.module.complex.SampleFireTargetAllocator
-#   CommandPicker: adf_core_python.implement.centralized.DefaultCommandPickerFire
+DefaultTacticsFireStation:
+  TargetAllocator: adf_core_python.implement.module.complex.default_fire_target_allocator.DefaultFireTargetAllocator
+  # CommandPicker: adf_core_python.implement.centralized.DefaultCommandPickerFire
 
-# DefaultTacticsPoliceOffice:
-#   TargetAllocator: sample_team.module.complex.SamplePoliceTargetAllocator
-#   CommandPicker: adf_core_python.implement.centralized.DefaultCommandPickerPolice
+DefaultTacticsPoliceOffice:
+  TargetAllocator: adf_core_python.implement.module.complex.default_police_target_allocator.DefaultPoliceTargetAllocator
+  # CommandPicker: adf_core_python.implement.centralized.DefaultCommandPickerPolice
 
 SampleSearch:
   PathPlanning: adf_core_python.implement.module.algorithm.a_star_path_planning.AStarPathPlanning

adf_core_python/core/agent/office/office.py

@@ -0,0 +1,103 @@
+from adf_core_python.core.agent.agent import Agent
+from adf_core_python.core.agent.config.module_config import ModuleConfig
+from adf_core_python.core.agent.develop.develop_data import DevelopData
+from adf_core_python.core.agent.info.scenario_info import Mode
+from adf_core_python.core.agent.module.module_manager import ModuleManager
+from adf_core_python.core.agent.precompute.precompute_data import PrecomputeData
+from adf_core_python.core.component.tactics.tactics_center import TacticsCenter
+from adf_core_python.core.logger.logger import get_agent_logger
+
+
+class Office(Agent):
+    def __init__(
+        self,
+        tactics_center: TacticsCenter,
+        team_name: str,
+        is_precompute: bool,
+        is_debug: bool,
+        data_storage_name: str,
+        module_config: ModuleConfig,
+        develop_data: DevelopData,
+    ) -> None:
+        super().__init__(
+            is_precompute,
+            self.__class__.__qualname__,
+            is_debug,
+            team_name,
+            data_storage_name,
+            module_config,
+            develop_data,
+        )
+        self._tactics_center = tactics_center
+        self._team_name = team_name
+        self._is_precompute = is_precompute
+        self._is_debug = is_debug
+        self._data_storage_name = data_storage_name
+        self._module_config = module_config
+        self._develop_data = develop_data
+
+    def post_connect(self) -> None:
+        super().post_connect()
+        self.precompute_data: PrecomputeData = PrecomputeData(self._data_storage_name)
+
+        self._logger = get_agent_logger(
+            f"{self.__class__.__module__}.{self.__class__.__qualname__}",
+            self._agent_info,
+        )
+
+        self._module_manager: ModuleManager = ModuleManager(
+            self._agent_info,
+            self._world_info,
+            self._scenario_info,
+            self._module_config,
+            self._develop_data,
+        )
+
+        self._message_manager.set_channel_subscriber(
+            self._module_manager.get_channel_subscriber(
+                "MessageManager.PlatoonChannelSubscriber",
+                "adf_core_python.implement.module.communication.default_channel_subscriber.DefaultChannelSubscriber",
+            )
+        )
+        self._message_manager.set_message_coordinator(
+            self._module_manager.get_message_coordinator(
+                "MessageManager.PlatoonMessageCoordinator",
+                "adf_core_python.implement.module.communication.default_message_coordinator.DefaultMessageCoordinator",
+            )
+        )
+
+        self._tactics_center.initialize(
+            self._agent_info,
+            self._world_info,
+            self._scenario_info,
+            self._module_manager,
+            self._precompute_data,
+            self._message_manager,
+            self._develop_data,
+        )
+
+        match self._scenario_info.get_mode():
+            case Mode.PRECOMPUTATION:
+                pass
+            case Mode.PRECOMPUTED:
+                pass
+            case Mode.NON_PRECOMPUTE:
+                self._tactics_center.prepare(
+                    self._agent_info,
+                    self._world_info,
+                    self._scenario_info,
+                    self._module_manager,
+                    self.precompute_data,
+                    self._develop_data,
+                )
+
+    def think(self) -> None:
+        self._tactics_center.think(
+            self._agent_info,
+            self._world_info,
+            self._scenario_info,
+            self._module_manager,
+            self._precompute_data,
+            self._message_manager,
+            self._develop_data,
+        )

adf_core_python/core/agent/office/office_ambulance.py

@@ -0,0 +1,31 @@
+from rcrs_core.connection.URN import Entity as EntityURN
+
+from adf_core_python.core.agent.office.office import Office
+
+
+class OfficeAmbulance(Office):
+    def __init__(
+        self,
+        tactics_center,
+        team_name,
+        is_precompute,
+        is_debug,
+        data_storage_name,
+        module_config,
+        develop_data,
+    ) -> None:
+        super().__init__(
+            tactics_center,
+            team_name,
+            is_precompute,
+            is_debug,
+            data_storage_name,
+            module_config,
+            develop_data,
+        )
+
+    def post_connect(self) -> None:
+        super().post_connect()
+
+    def get_requested_entities(self) -> list[EntityURN]:
+        return [EntityURN.AMBULANCE_CENTRE]

adf_core_python/core/agent/office/office_fire.py

@@ -0,0 +1,31 @@
+from rcrs_core.connection.URN import Entity as EntityURN
+
+from adf_core_python.core.agent.office.office import Office
+
+
+class OfficeFire(Office):
+    def __init__(
+        self,
+        tactics_center,
+        team_name,
+        is_precompute,
+        is_debug,
+        data_storage_name,
+        module_config,
+        develop_data,
+    ) -> None:
+        super().__init__(
+            tactics_center,
+            team_name,
+            is_precompute,
+            is_debug,
+            data_storage_name,
+            module_config,
+            develop_data,
+        )
+
+    def post_connect(self) -> None:
+        super().post_connect()
+
+    def get_requested_entities(self) -> list[EntityURN]:
+        return [EntityURN.FIRE_STATION]

adf_core_python/core/agent/office/office_police.py

@@ -0,0 +1,31 @@
+from rcrs_core.connection.URN import Entity as EntityURN
+
+from adf_core_python.core.agent.office.office import Office
+
+
+class OfficePolice(Office):
+    def __init__(
+        self,
+        tactics_center,
+        team_name,
+        is_precompute,
+        is_debug,
+        data_storage_name,
+        module_config,
+        develop_data,
+    ) -> None:
+        super().__init__(
+            tactics_center,
+            team_name,
+            is_precompute,
+            is_debug,
+            data_storage_name,
+            module_config,
+            develop_data,
+        )
+
+    def post_connect(self) -> None:
+        super().post_connect()
+
+    def get_requested_entities(self) -> list[EntityURN]:
+        return [EntityURN.POLICE_OFFICE]

adf_core_python/core/launcher/agent_launcher.py

@@ -4,31 +4,26 @@
 from adf_core_python.core.component.abstract_loader import AbstractLoader
 from adf_core_python.core.config.config import Config
 from adf_core_python.core.launcher.config_key import ConfigKey
-
-# from rcrs_core.connection.componentLauncher import ComponentLauncher
 from adf_core_python.core.launcher.connect.component_launcher import ComponentLauncher
 from adf_core_python.core.launcher.connect.connector import Connector
-
-# from adf_core_python.core.launcher.connect.connector_ambulance_centre import (
-#     ConnectorAmbulanceCentre,
-# )
+from adf_core_python.core.launcher.connect.connector_ambulance_center import (
+    ConnectorAmbulanceCenter,
+)
 from adf_core_python.core.launcher.connect.connector_ambulance_team import (
     ConnectorAmbulanceTeam,
 )
 from adf_core_python.core.launcher.connect.connector_fire_brigade import (
     ConnectorFireBrigade,
 )
-
-# from adf_core_python.core.launcher.connect.connector_fire_station import (
-#     ConnectorFireStation,
-# )
+from adf_core_python.core.launcher.connect.connector_fire_station import (
+    ConnectorFireStation,
+)
 from adf_core_python.core.launcher.connect.connector_police_force import (
     ConnectorPoliceForce,
 )
-
-# from adf_core_python.core.launcher.connect.connector_police_office import (
-#     ConnectorPoliceOffice,
-# )
+from adf_core_python.core.launcher.connect.connector_police_office import (
+    ConnectorPoliceOffice,
+)
 from adf_core_python.core.logger.logger import get_logger
 
 
@@ -53,11 +48,11 @@ def init_connector(self) -> None:
         )
 
         self.connectors.append(ConnectorAmbulanceTeam())
-        # self.connectors.append(ConnectorAmbulanceCentre())
+        self.connectors.append(ConnectorAmbulanceCenter())
         self.connectors.append(ConnectorFireBrigade())
-        # self.connectors.append(ConnectorFireStation())
+        self.connectors.append(ConnectorFireStation())
         self.connectors.append(ConnectorPoliceForce())
-        # self.connectors.append(ConnectorPoliceOffice())
+        self.connectors.append(ConnectorPoliceOffice())
 
     def launch(self) -> None:
         host: str = self.config.get_value(ConfigKey.KEY_KERNEL_HOST, "localhost")

adf_core_python/core/launcher/connect/connector_ambulance_centre.py renamed to adf_core_python/core/launcher/connect/connector_ambulance_center.py

@@ -1,18 +1,20 @@
 import threading
 
-from rcrs_core.agents.ambulanceCenterAgent import AmbulanceCenterAgent
-
 from adf_core_python.core.agent.config.module_config import ModuleConfig
 from adf_core_python.core.agent.develop.develop_data import DevelopData
+from adf_core_python.core.agent.office.office_ambulance import OfficeAmbulance
 from adf_core_python.core.component.abstract_loader import AbstractLoader
+from adf_core_python.core.component.tactics.tactics_ambulance_center import (
+    TacticsAmbulanceCenter,
+)
 from adf_core_python.core.config.config import Config
 from adf_core_python.core.launcher.config_key import ConfigKey
 from adf_core_python.core.launcher.connect.component_launcher import ComponentLauncher
 from adf_core_python.core.launcher.connect.connector import Connector
 from adf_core_python.core.logger.logger import get_logger
 
 
-class ConnectorAmbulanceCentre(Connector):
+class ConnectorAmbulanceCenter(Connector):
     def __init__(self) -> None:
         super().__init__()
         self.logger = get_logger(__name__)
@@ -30,41 +32,45 @@ def connect(
         threads: list[threading.Thread] = []
 
         for _ in range(count):
-            # tactics_ambulance_centre: TacticsAmbulanceCentre
-            if loader.get_tactics_ambulance_center() is not None:
+            if loader.get_tactics_ambulance_center() is None:
                 self.logger.error("Cannot load ambulance centre tactics")
-                # tactics_ambulance_centre = loader.get_tactics_ambulance_centre()
-            else:
-                # tactics_ambulance_centre = DummyTacticsAmbulanceCentre()
-                pass
 
-            module_config: ModuleConfig = ModuleConfig(  # noqa: F841
+            tactics_ambulance_center: TacticsAmbulanceCenter = (
+                loader.get_tactics_ambulance_center()
+            )
+
+            module_config: ModuleConfig = ModuleConfig(
                 config.get_value(
                     ConfigKey.KEY_MODULE_CONFIG_FILE_NAME,
                     ModuleConfig.DEFAULT_CONFIG_FILE_NAME,
                 )
             )
 
-            develop_data: DevelopData = DevelopData(  # noqa: F841
+            develop_data: DevelopData = DevelopData(
                 config.get_value(ConfigKey.KEY_DEBUG_FLAG, False),
                 config.get_value(
                     ConfigKey.KEY_DEVELOP_DATA_FILE_NAME, DevelopData.DEFAULT_FILE_NAME
                 ),
             )
 
             request_id: int = component_launcher.generate_request_id()
-            # TODO: component_launcher.generate_request_ID can cause race condition
             thread = threading.Thread(
                 target=component_launcher.connect,
                 args=(
-                    AmbulanceCenterAgent(
+                    OfficeAmbulance(
+                        tactics_ambulance_center,
+                        "ambulance_center",
                         config.get_value(ConfigKey.KEY_PRECOMPUTE, False),
-                    ),  # type: ignore
+                        config.get_value(ConfigKey.KEY_DEBUG_FLAG, False),
+                        "test",
+                        module_config,
+                        develop_data,
+                    ),
                     request_id,
                 ),
-                name=f"AmbulanceCentreAgent-{request_id}",
+                name=f"AmbulanceCenterAgent-{request_id}",
             )
             threads.append(thread)
 
-        self.logger.info("Connected ambulance centre (count: %d)" % count)
+        self.logger.info("Connected ambulance center (count: %d)" % count)
         return threads