eight puzzle now available, clones now available

marl_factory_grid/utils/config_parser.py

@@ -1,4 +1,5 @@
 import ast
+from collections import defaultdict
 
 from os import PathLike
 from pathlib import Path
@@ -22,13 +23,21 @@ class FactoryConfigParser(object):
         self.config_path = Path(config_path)
         self.custom_modules_path = Path(custom_modules_path) if custom_modules_path is not None else custom_modules_path
         self.config = yaml.safe_load(self.config_path.open())
+        self._n_abbr_dict = None
 
     def __getattr__(self, item):
         return self['General'][item]
 
     def _get_sub_list(self, primary_key: str, sub_key: str):
         return [{key: [s for k, v in val.items() if k == sub_key for s in v] for key, val in x.items()
-                 } for x in self.config[primary_key]]
+                 } for x in self.config.get(primary_key, [])]
+
+    def _n_abbr(self, n):
+        assert isinstance(n, int)
+        if self._n_abbr_dict is None:
+            self._n_abbr_dict = defaultdict(lambda: 'th', {1: 'st', 2: 'nd', 3: 'rd'})
+        return self._n_abbr_dict[n]
+
 
     @property
     def agent_actions(self):
@@ -143,11 +152,18 @@ class FactoryConfigParser(object):
             observations.extend(x for x in self.agents[name]['Observations'] if x != c.DEFAULTS)
             positions = [ast.literal_eval(x) for x in self.agents[name].get('Positions', [])]
             other_kwargs = {k: v for k, v in self.agents[name].items() if k not in
-                            ['Actions', 'Observations', 'Positions']}
+                            ['Actions', 'Observations', 'Positions', 'Clones']}
             parsed_agents_conf[name] = dict(
                 actions=parsed_actions, observations=observations, positions=positions, other=other_kwargs
                                             )
 
+            clones = self.agents[name].get('Clones', 0)
+            if clones:
+                if isinstance(clones, int):
+                    clones = [f'{name}_the_{n}{self._n_abbr(n)}' for n in range(clones)]
+                for clone in clones:
+                    parsed_agents_conf[clone] = parsed_agents_conf[name].copy()
+
         return parsed_agents_conf
 
     def load_env_rules(self) -> List[Rule]:

marl_factory_grid/utils/logging/envmonitor.py

@@ -58,3 +58,6 @@ class EnvMonitor(Wrapper):
             pickle.dump(self._monitor_df.reset_index(), f, protocol=pickle.HIGHEST_PROTOCOL)
         if auto_plotting_keys:
             plot_single_run(filepath, column_keys=auto_plotting_keys)
+
+    def report_possible_colum_keys(self):
+        print(self._monitor_df.columns)

marl_factory_grid/utils/states.py

@@ -6,7 +6,7 @@ import numpy as np
 from marl_factory_grid.algorithms.static.utils import points_to_graph
 from marl_factory_grid.environment import constants as c
 from marl_factory_grid.environment.entity.entity import Entity
-from marl_factory_grid.environment.rules import Rule
+from marl_factory_grid.environment.rules import Rule, SpawnAgents
 from marl_factory_grid.utils.results import Result, DoneResult
 
 
@@ -28,18 +28,19 @@ class StepRules:
         self.rules.append(item)
         return True
 
-    def do_all_reset(self, state):
-        for rule in self.rules:
-            if rule_reset_printline := rule.on_reset(state):
-                state.print(rule_reset_printline)
-        return c.VALID
-
     def do_all_init(self, state, lvl_map):
         for rule in self.rules:
             if rule_init_printline := rule.on_init(state, lvl_map):
                 state.print(rule_init_printline)
         return c.VALID
 
+    def do_all_reset(self, state):
+        SpawnAgents().on_reset(state)
+        for rule in self.rules:
+            if rule_reset_printline := rule.on_reset(state):
+                state.print(rule_reset_printline)
+        return c.VALID
+
     def tick_step_all(self, state):
         results = list()
         for rule in self.rules:
@@ -193,7 +194,7 @@ class Gamestate(object):
                 results.extend(on_check_done_result)
         return results
 
-    def get_all_pos_with_collisions(self) -> List[Tuple[(int, int)]]:
+    def get_collision_positions(self) -> List[Tuple[(int, int)]]:
         """
         Returns a list positions [(x, y), ... ] on which collisions occur. This does not include agents,
         that were unable to move because their target direction was blocked, also a form of collision.