Redone the spawn procedute and destination objects

marl_factory_grid/modules/aomas/narrow_corridor/rules.py

@@ -0,0 +1,28 @@
+from random import shuffle
+from typing import List, Tuple
+
+from marl_factory_grid.environment.rules import Rule
+from marl_factory_grid.environment import constants as c
+from marl_factory_grid.modules.destinations import constants as d
+from marl_factory_grid.modules.destinations.entitites import BoundDestination
+
+
+class NarrowCorridorSpawn(Rule):
+    def __init__(self, positions: List[Tuple[int, int]], fixed: bool = False):
+        super().__init__()
+        self.fixed = fixed
+        self.positions = positions
+
+    def on_init(self, state, lvl_map):
+        if not self.fixed:
+            shuffle(self.positions)
+        for agent in state[c.AGENT]:
+            pass
+
+    def trigger_destination_spawn(self, state):
+        for (agent_name, position_list) in self.per_agent_positions.items():
+            agent = state[c.AGENT][agent_name]
+            destinations = [BoundDestination(agent, pos) for pos in position_list]
+            state[d.DESTINATION].add_items(destinations)
+        return c.VALID
+

marl_factory_grid/modules/batteries/rules.py

@@ -70,7 +70,7 @@ class PodRules(Rule):
 
     def on_init(self, state, lvl_map):
         pod_collection = state[b.CHARGE_PODS]
-        empty_tiles = state[c.FLOOR].empty_tiles[:self.n_pods]
+        empty_tiles = state[c.FLOORS].empty_tiles[:self.n_pods]
         pods = pod_collection.from_tiles(empty_tiles, entity_kwargs=dict(
             multi_charge=self.multi_charge, charge_rate=self.charge_rate)
                                          )

marl_factory_grid/modules/clean_up/groups.py

@@ -47,7 +47,7 @@ class DirtPiles(PositionMixin, EnvObjects):
         return c.VALID
 
     def trigger_dirt_spawn(self, state, initial_spawn=False) -> bool:
-        free_for_dirt = [x for x in state[c.FLOOR]
+        free_for_dirt = [x for x in state[c.FLOORS]
                          if len(x.guests) == 0 or (
                                  len(x.guests) == 1 and
                                  isinstance(next(y for y in x.guests), DirtPile))

marl_factory_grid/modules/destinations/__init__.py

@@ -1,4 +1,4 @@
 from .actions import DestAction
 from .entitites import Destination
-from .groups import ReachedDestinations, Destinations
-from .rules import DestinationDone, DestinationReach, DestinationSpawn
+from .groups import Destinations, BoundDestinations
+from .rules import DestinationReachAll, DestinationSpawn

marl_factory_grid/modules/destinations/constants.py

@@ -3,8 +3,6 @@
 DESTINATION             = 'Destinations'
 BOUNDDESTINATION        = 'BoundDestinations'
 DEST_SYMBOL             = 1
-DEST_REACHED_REWARD     = 0.5
-DEST_REACHED            = 'ReachedDestinations'
 
 WAIT_ON_DEST    = 'WAIT'
 

marl_factory_grid/modules/destinations/entitites.py

@@ -16,42 +16,31 @@ class Destination(Entity):
     var_is_blocking_pos = False
     var_is_blocking_light = False
 
-    @property
-    def any_agent_has_dwelled(self):
-        return bool(len(self._per_agent_times))
-
-    @property
-    def currently_dwelling_names(self):
-        return list(self._per_agent_times.keys())
-
     @property
     def encoding(self):
         return d.DEST_SYMBOL
 
-    def __init__(self, *args, dwell_time: int = 0, **kwargs):
+    def __init__(self, *args, action_counts=0, **kwargs):
         super(Destination, self).__init__(*args, **kwargs)
-        self.dwell_time = dwell_time
-        self._per_agent_times = defaultdict(lambda: dwell_time)
+        self.action_counts = action_counts
+        self._per_agent_actions = defaultdict(lambda: 0)
 
     def do_wait_action(self, agent: Agent):
-        self._per_agent_times[agent.name] -= 1
+        self._per_agent_actions[agent.name] += 1
         return c.VALID
 
-    def leave(self, agent: Agent):
-        del self._per_agent_times[agent.name]
-
     @property
     def is_considered_reached(self):
         agent_at_position = any(c.AGENT.lower() in x.name.lower() for x in self.tile.guests_that_can_collide)
-        return (agent_at_position and not self.dwell_time) or any(x == 0 for x in self._per_agent_times.values())
+        return agent_at_position or any(x >= self.action_counts for x in self._per_agent_actions.values())
 
-    def agent_is_dwelling(self, agent: Agent):
-        return self._per_agent_times[agent.name] < self.dwell_time
+    def agent_did_action(self, agent: Agent):
+        return self._per_agent_actions[agent.name] >= self.action_counts
 
     def summarize_state(self) -> dict:
         state_summary = super().summarize_state()
         state_summary.update(per_agent_times=[
-            dict(belongs_to=key, time=val) for key, val in self._per_agent_times.items()], dwell_time=self.dwell_time)
+            dict(belongs_to=key, time=val) for key, val in self._per_agent_actions.items()], counts=self.action_counts)
         return state_summary
 
     def render(self):
@@ -68,9 +57,8 @@ class BoundDestination(BoundEntityMixin, Destination):
         self.bind_to(entity)
         super().__init__(*args, **kwargs)
 
-
     @property
     def is_considered_reached(self):
         agent_at_position = any(self.bound_entity == x for x in self.tile.guests_that_can_collide)
-        return (agent_at_position and not self.dwell_time) \
-            or any(x == 0 for x in self._per_agent_times[self.bound_entity.name])
+        return ((agent_at_position and not self.action_counts)
+                or self._per_agent_actions[self.bound_entity.name] >= self.action_counts >= 1)

marl_factory_grid/modules/destinations/groups.py

@@ -23,14 +23,3 @@ class BoundDestinations(HasBoundMixin, Destinations):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
-
-class ReachedDestinations(Destinations):
-    _entity = Destination
-    is_blocking_light = False
-    can_collide = False
-
-    def __init__(self, *args, **kwargs):
-        super(ReachedDestinations, self).__init__(*args, **kwargs)
-
-    def __repr__(self):
-        return super(ReachedDestinations, self).__repr__()

marl_factory_grid/modules/destinations/rules.py

@@ -1,84 +1,61 @@
-from typing import List, Union
+import ast
+from random import shuffle
+from typing import List, Union, Dict, Tuple
 from marl_factory_grid.environment.rules import Rule
 from marl_factory_grid.utils.results import TickResult, DoneResult
 from marl_factory_grid.environment import constants as c
 
 from marl_factory_grid.modules.destinations import constants as d, rewards as r
-from marl_factory_grid.modules.destinations.entitites import Destination
+from marl_factory_grid.modules.destinations.entitites import Destination, BoundDestination
 
 
-class DestinationReach(Rule):
+class DestinationReachAll(Rule):
 
-    def __init__(self, n_dests: int = 1, tiles: Union[List, None] = None):
-        super(DestinationReach, self).__init__()
-        self.n_dests = n_dests or len(tiles)
-        self._tiles = tiles
+    def __init__(self):
+        super(DestinationReachAll, self).__init__()
 
     def tick_step(self, state) -> List[TickResult]:
-
-        for dest in list(state[d.DESTINATION].values()):
+        results = []
+        for dest in list(state[next(key for key in state.entities.names if d.DESTINATION in key)]):
             if dest.is_considered_reached:
-                dest.change_parent_collection(state[d.DEST_REACHED])
+                agent = state[c.AGENT].by_pos(dest.pos)
+                results.append(TickResult(self.name, validity=c.VALID, reward=r.DEST_REACHED, entity=agent))
                 state.print(f'{dest.name} is reached now, removing...')
+                assert dest.destroy(), f'{dest.name} could not be destroyed. Critical Error.'
             else:
-                for agent_name in dest.currently_dwelling_names:
-                    agent = state[c.AGENT][agent_name]
-                    if agent.pos == dest.pos:
-                        state.print(f'{agent.name} is still waiting.')
-                        pass
-                    else:
-                        dest.leave(agent)
-                        state.print(f'{agent.name} left the destination early.')
+               pass
         return [TickResult(self.name, validity=c.VALID, reward=0, entity=None)]
 
     def tick_post_step(self, state) -> List[TickResult]:
-        results = list()
-        for reached_dest in state[d.DEST_REACHED]:
-            for guest in reached_dest.tile.guests:
-                if guest in state[c.AGENT]:
-                    state.print(f'{guest.name} just reached destination at {guest.pos}')
-                    state[d.DEST_REACHED].delete_env_object(reached_dest)
-                    results.append(TickResult(self.name, validity=c.VALID, reward=r.DEST_REACHED, entity=guest))
-        return results
-
-
-class DestinationDone(Rule):
-
-    def __init__(self):
-        super(DestinationDone, self).__init__()
-
-    def on_check_done(self, state) -> List[DoneResult]:
-        if not len(state[d.DESTINATION]):
-            return [DoneResult(self.name, validity=c.VALID, reward=r.DEST_REACHED)]
         return []
 
-
-class DoneOnReach(Rule):
-
-    def __init__(self):
-        super(DoneOnReach, self).__init__()
-
     def on_check_done(self, state) -> List[DoneResult]:
-        dests = [x.pos for x in state[d.DESTINATION]]
-        agents = [x.pos for x in state[c.AGENT]]
-
-        if any([x in dests for x in agents]):
+        if not len(state[next(key for key in state.entities.names if d.DESTINATION in key)]):
             return [DoneResult(self.name, validity=c.VALID, reward=r.DEST_REACHED)]
         return [DoneResult(self.name, validity=c.NOT_VALID, reward=0)]
 
 
+class DestinationReachAny(DestinationReachAll):
+
+    def __init__(self):
+        super(DestinationReachAny, self).__init__()
+
+    def on_check_done(self, state) -> List[DoneResult]:
+        if not len(state[next(key for key in state.entities.names if d.DESTINATION in key)]):
+            return [DoneResult(self.name, validity=c.VALID, reward=r.DEST_REACHED)]
+        return []
+
+
 class DestinationSpawn(Rule):
 
-    def __init__(self, spawn_frequency: int = 5, n_dests: int = 1,
+    def __init__(self, n_dests: int = 1,
                  spawn_mode: str = d.MODE_GROUPED):
         super(DestinationSpawn, self).__init__()
-        self.spawn_frequency = spawn_frequency
         self.n_dests = n_dests
         self.spawn_mode = spawn_mode
 
     def on_init(self, state, lvl_map):
         # noinspection PyAttributeOutsideInit
-        self._dest_spawn_timer = self.spawn_frequency
         self.trigger_destination_spawn(self.n_dests, state)
         pass
 
@@ -88,16 +65,40 @@ class DestinationSpawn(Rule):
     def tick_step(self, state) -> List[TickResult]:
         if n_dest_spawn := max(0, self.n_dests - len(state[d.DESTINATION])):
             if self.spawn_mode == d.MODE_GROUPED and n_dest_spawn == self.n_dests:
-                validity = state.rules['DestinationReach'].trigger_destination_spawn(n_dest_spawn, state)
+                validity = self.trigger_destination_spawn(n_dest_spawn, state)
                 return [TickResult(self.name, validity=validity, entity=None, value=n_dest_spawn)]
+            elif self.spawn_mode == d.MODE_SINGLE and n_dest_spawn:
+                validity = self.trigger_destination_spawn(n_dest_spawn, state)
+                return [TickResult(self.name, validity=validity, entity=None, value=n_dest_spawn)]
+            else:
+                pass
 
-    @staticmethod
-    def trigger_destination_spawn(n_dests, state, tiles=None):
-        tiles = tiles or state[c.FLOOR].empty_tiles[:n_dests]
-        if destinations := [Destination(tile) for tile in tiles]:
+    def trigger_destination_spawn(self, n_dests, state):
+        empty_positions = state[c.FLOORS].empty_tiles[:n_dests]
+        if destinations := [Destination(pos) for pos in empty_positions]:
             state[d.DESTINATION].add_items(destinations)
             state.print(f'{n_dests} new destinations have been spawned')
             return c.VALID
         else:
             state.print('No Destiantions are spawning, limit is reached.')
             return c.NOT_VALID
+
+
+class FixedDestinationSpawn(Rule):
+    def __init__(self, per_agent_positions: Dict[str, List[Tuple[int, int]]]):
+        super(Rule, self).__init__()
+        self.per_agent_positions = {key: [ast.literal_eval(x) for x in val] for key, val in per_agent_positions.items()}
+
+    def on_init(self, state, lvl_map):
+        for (agent_name, position_list) in self.per_agent_positions.items():
+            agent = next(x for x in state[c.AGENT] if agent_name in x.name)  # Fixme: Ugly AF
+            shuffle(position_list)
+            while True:
+                pos = position_list.pop()
+                if pos != agent.pos and not state[d.BOUNDDESTINATION].by_pos(pos):
+                    destination = BoundDestination(agent, state[c.FLOORS].by_pos(pos))
+                    break
+                else:
+                    continue
+            state[d.BOUNDDESTINATION].add_item(destination)
+        pass

marl_factory_grid/modules/factory/rules.py

@@ -21,7 +21,7 @@ class AgentSingleZonePlacementBeta(Rule):
             coordinates = random.choices(self.coordinates, k=len(agents))
         else:
             raise ValueError
-        tiles = [state[c.FLOOR].by_pos(pos) for pos in coordinates]
+        tiles = [state[c.FLOORS].by_pos(pos) for pos in coordinates]
         for agent, tile in zip(agents, tiles):
             agent.move(tile)
 

marl_factory_grid/modules/items/rules.py

@@ -41,7 +41,7 @@ class ItemRules(Rule):
 
     def trigger_item_spawn(self, state):
         if item_to_spawns := max(0, (self.n_items - len(state[i.ITEM]))):
-            empty_tiles = state[c.FLOOR].empty_tiles[:item_to_spawns]
+            empty_tiles = state[c.FLOORS].empty_tiles[:item_to_spawns]
             state[i.ITEM].spawn(empty_tiles)
             self._next_item_spawn = self.spawn_frequency
             state.print(f'{item_to_spawns} new items have been spawned; next spawn in {self._next_item_spawn}')
@@ -73,7 +73,7 @@ class ItemRules(Rule):
             return []
 
     def trigger_drop_off_location_spawn(self, state):
-        empty_tiles = state[c.FLOOR].empty_tiles[:self.n_locations]
+        empty_tiles = state[c.FLOORS].empty_tiles[:self.n_locations]
         do_entites = state[i.DROP_OFF]
         drop_offs = [DropOffLocation(tile) for tile in empty_tiles]
         do_entites.add_items(drop_offs)

marl_factory_grid/modules/levels/narrow_corridor.txt

@@ -0,0 +1,5 @@
+#######
+###-###
+#1---2#
+###-###
+#######

marl_factory_grid/modules/machines/rules.py

@@ -13,7 +13,7 @@ class MachineRule(Rule):
         self.n_machines = n_machines
 
     def on_init(self, state, lvl_map):
-        empty_tiles = state[c.FLOOR].empty_tiles[:self.n_machines]
+        empty_tiles = state[c.FLOORS].empty_tiles[:self.n_machines]
         state[m.MACHINES].add_items(Machine(tile) for tile in empty_tiles)
 
     def tick_pre_step(self, state) -> List[TickResult]:

marl_factory_grid/modules/maintenance/entities.py

@@ -39,7 +39,7 @@ class Maintainer(Entity):
         self._next = []
         self._last = []
         self._last_serviced = 'None'
-        self._floortile_graph = points_to_graph(state[c.FLOOR].positions)
+        self._floortile_graph = points_to_graph(state[c.FLOORS].positions)
 
     def tick(self, state):
         if found_objective := state[self.objective].by_pos(self.pos):
@@ -89,7 +89,7 @@ class Maintainer(Entity):
 
     def _predict_move(self, state):
         next_pos = self._path[0]
-        if len(state[c.FLOOR].by_pos(next_pos).guests_that_can_collide) > 0:
+        if len(state[c.FLOORS].by_pos(next_pos).guests_that_can_collide) > 0:
             action = c.NOOP
         else:
             next_pos = self._path.pop(0)

marl_factory_grid/modules/maintenance/groups.py

@@ -5,11 +5,9 @@ from marl_factory_grid.environment.entity.wall_floor import Floor
 from marl_factory_grid.environment.groups.env_objects import EnvObjects
 from marl_factory_grid.environment.groups.mixins import PositionMixin
 from ..machines.actions import MachineAction
-from ...utils.render import RenderEntity
 from ...utils.states import Gamestate
 
 from ..machines import constants as mc
-from . import constants as mi
 
 
 class Maintainers(PositionMixin, EnvObjects):

marl_factory_grid/modules/maintenance/rules.py

@@ -14,7 +14,7 @@ class MaintenanceRule(Rule):
         self.n_maintainer = n_maintainer
 
     def on_init(self, state: Gamestate, lvl_map):
-        state[M.MAINTAINERS].spawn(state[c.FLOOR].empty_tiles[:self.n_maintainer], state)
+        state[M.MAINTAINERS].spawn(state[c.FLOORS].empty_tiles[:self.n_maintainer], state)
         pass
 
     def tick_pre_step(self, state) -> List[TickResult]:

marl_factory_grid/modules/zones/rules.py

@@ -19,7 +19,7 @@ class ZoneInit(Rule):
         while z_idx:
             zone_positions = lvl_map.get_coordinates_for_symbol(z_idx)
             if len(zone_positions):
-                zones.append(Zone([state[c.FLOOR].by_pos(pos) for pos in zone_positions]))
+                zones.append(Zone([state[c.FLOORS].by_pos(pos) for pos in zone_positions]))
                 z_idx += 1
             else:
                 z_idx = 0