WIP: removing tiles

marl_factory_grid/modules/items/groups.py

@@ -1,15 +1,14 @@
-from typing import List
+from marl_factory_grid.modules.items import constants as i
+from marl_factory_grid.environment import constants as c
 
 from marl_factory_grid.environment.groups.env_objects import EnvObjects
 from marl_factory_grid.environment.groups.objects import Objects
 from marl_factory_grid.environment.groups.mixins import PositionMixin, IsBoundMixin, HasBoundMixin
-from marl_factory_grid.environment.entity.wall_floor import Floor
 from marl_factory_grid.environment.entity.agent import Agent
 from marl_factory_grid.modules.items.entitites import Item, DropOffLocation
 
 
 class Items(PositionMixin, EnvObjects):
-
     _entity = Item
     is_blocking_light: bool = False
     can_collide: bool = False
@@ -17,9 +16,19 @@ class Items(PositionMixin, EnvObjects):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
+    @staticmethod
+    def trigger_item_spawn(state, n_items, spawn_frequency):
+        if item_to_spawns := max(0, (n_items - len(state[i.ITEM]))):
+            floor_list = state.entities.floorlist[:item_to_spawns]
+            state[i.ITEM].spawn(floor_list)
+            state.print(f'{item_to_spawns} new items have been spawned; next spawn in {spawn_frequency}')   # spawn in self._next_item_spawn ?
+            return len(floor_list)
+        else:
+            state.print('No Items are spawning, limit is reached.')
+            return 0
+
 
 class Inventory(IsBoundMixin, EnvObjects):
-
     _accepted_objects = Item
 
     @property
@@ -27,7 +36,7 @@ class Inventory(IsBoundMixin, EnvObjects):
         return self.name
 
     def __init__(self, agent: Agent, *args, **kwargs):
-        super(Inventory, self).__init__(*args,  **kwargs)
+        super(Inventory, self).__init__(*args, **kwargs)
         self._collection = None
         self.bind(agent)
 
@@ -47,7 +56,6 @@ class Inventory(IsBoundMixin, EnvObjects):
 
 
 class Inventories(HasBoundMixin, Objects):
-
     _entity = Inventory
     var_can_move = False
 
@@ -58,7 +66,7 @@ class Inventories(HasBoundMixin, Objects):
         self._lazy_eval_transforms = []
 
     def spawn(self, agents):
-        inventories = [self._entity(agent, self.size,)
+        inventories = [self._entity(agent, self.size, )
                        for _, agent in enumerate(agents)]
         self.add_items(inventories)
 
@@ -77,12 +85,22 @@ class Inventories(HasBoundMixin, Objects):
     def summarize_states(self, **kwargs):
         return [val.summarize_states(**kwargs) for key, val in self.items()]
 
+    @staticmethod
+    def trigger_inventory_spawn(state):
+        state[i.INVENTORY].spawn(state[c.AGENT])
+
 
 class DropOffLocations(PositionMixin, EnvObjects):
-
     _entity = DropOffLocation
     is_blocking_light: bool = False
     can_collide: bool = False
 
     def __init__(self, *args, **kwargs):
         super(DropOffLocations, self).__init__(*args, **kwargs)
+
+    @staticmethod
+    def trigger_drop_off_location_spawn(state, n_locations):
+        empty_tiles = state.entities.floorlist[: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/items/rules.py

@@ -4,7 +4,6 @@ from marl_factory_grid.environment.rules import Rule
 from marl_factory_grid.environment import constants as c
 from marl_factory_grid.utils.results import TickResult
 from marl_factory_grid.modules.items import constants as i
-from marl_factory_grid.modules.items.entitites import DropOffLocation
 
 
 class ItemRules(Rule):
@@ -19,10 +18,10 @@ class ItemRules(Rule):
         self.n_locations = n_locations
 
     def on_init(self, state, lvl_map):
-        self.trigger_drop_off_location_spawn(state)
+        state[i.DROP_OFF].trigger_drop_off_location_spawn(state, self.n_locations)
         self._next_item_spawn = self.spawn_frequency
-        self.trigger_inventory_spawn(state)
-        self.trigger_item_spawn(state)
+        state[i.INVENTORY].trigger_inventory_spawn(state)
+        state[i.ITEM].trigger_item_spawn(state, self.n_items, self.spawn_frequency)
 
     def tick_step(self, state):
         for item in list(state[i.ITEM].values()):
@@ -34,26 +33,11 @@ class ItemRules(Rule):
                 pass
 
         if not self._next_item_spawn:
-            self.trigger_item_spawn(state)
+            state[i.ITEM].trigger_item_spawn(state, self.n_items, self.spawn_frequency)
         else:
             self._next_item_spawn = max(0, self._next_item_spawn - 1)
         return []
 
-    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]
-            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}')
-            return len(empty_tiles)
-        else:
-            state.print('No Items are spawning, limit is reached.')
-            return 0
-
-    @staticmethod
-    def trigger_inventory_spawn(state):
-        state[i.INVENTORY].spawn(state[c.AGENT])
-
     def tick_post_step(self, state) -> List[TickResult]:
         for item in list(state[i.ITEM].values()):
             if item.auto_despawn >= 1:
@@ -64,7 +48,7 @@ class ItemRules(Rule):
                 pass
 
         if not self._next_item_spawn:
-            if spawned_items := self.trigger_item_spawn(state):
+            if spawned_items := state[i.ITEM].trigger_item_spawn(state, self.n_items, self.spawn_frequency):
                 return [TickResult(self.name, validity=c.VALID, value=spawned_items, entity=None)]
             else:
                 return [TickResult(self.name, validity=c.NOT_VALID, value=0, entity=None)]
@@ -72,8 +56,3 @@ class ItemRules(Rule):
             self._next_item_spawn = max(0, self._next_item_spawn-1)
             return []
 
-    def trigger_drop_off_location_spawn(self, state):
-        empty_tiles = state[c.FLOOR].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)