renaming

marl_factory_grid/environment/groups/agents.py

@@ -0,0 +1,29 @@
+from marl_factory_grid.environment.groups.env_objects import EnvObjects
+from marl_factory_grid.environment.groups.mixins import PositionMixin
+from marl_factory_grid.environment.entity.agent import Agent
+
+
+class Agents(PositionMixin, EnvObjects):
+    _entity = Agent
+    is_blocking_light = False
+    can_move = True
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @property
+    def obs_pairs(self):
+        return [(a.name, a) for a in self]
+
+    @property
+    def action_space(self):
+        from gymnasium import spaces
+        space = spaces.Tuple([spaces.Discrete(len(x.actions)) for x in self])
+        return space
+
+    @property
+    def named_action_space(self):
+        named_space = dict()
+        for agent in self:
+            named_space[agent.name] = {action.name: idx for idx, action in enumerate(agent.actions)}
+        return named_space

marl_factory_grid/environment/groups/env_objects.py

@@ -0,0 +1,33 @@
+from marl_factory_grid.environment.groups.objects import Objects
+from marl_factory_grid.environment.entity.object import EnvObject
+
+
+class EnvObjects(Objects):
+
+    _entity = EnvObject
+    is_blocking_light: bool = False
+    can_collide: bool = False
+    has_position: bool = False
+    can_move: bool = False
+
+    @property
+    def encodings(self):
+        return [x.encoding for x in self]
+
+    def __init__(self, size, *args, **kwargs):
+        super(EnvObjects, self).__init__(*args, **kwargs)
+        self.size = size
+
+    def add_item(self, item: EnvObject):
+        assert self.has_position or (len(self) <= self.size)
+        super(EnvObjects, self).add_item(item)
+        return self
+
+    def summarize_states(self):
+        return [entity.summarize_state() for entity in self.values()]
+
+    def delete_env_object(self, env_object: EnvObject):
+        del self[env_object.name]
+
+    def delete_env_object_by_name(self, name):
+        del self[name]

marl_factory_grid/environment/groups/global_entities.py

@@ -0,0 +1,63 @@
+from collections import defaultdict
+from operator import itemgetter
+from typing import Dict
+
+from marl_factory_grid.environment.groups.objects import Objects
+from marl_factory_grid.utils.helpers import POS_MASK
+
+
+class Entities(Objects):
+    _entity = Objects
+
+    @staticmethod
+    def neighboring_positions(pos):
+        return (POS_MASK + pos).reshape(-1, 2)
+
+    def get_near_pos(self, pos):
+        return [y for x in itemgetter(*(tuple(x) for x in self.neighboring_positions(pos)))(self.pos_dict) for y in x]
+
+    def render(self):
+        return [y for x in self for y in x.render() if x is not None]
+
+    @property
+    def names(self):
+        return list(self._data.keys())
+
+    def __init__(self):
+        self.pos_dict = defaultdict(list)
+        super().__init__()
+
+    def iter_entities(self):
+        return iter((x for sublist in self.values() for x in sublist))
+
+    def add_items(self, items: Dict):
+        return self.add_item(items)
+
+    def add_item(self, item: dict):
+        assert_str = 'This group of entity has already been added!'
+        assert not any([key for key in item.keys() if key in self.keys()]), assert_str
+        self._data.update(item)
+        for val in item.values():
+            val.add_observer(self)
+        return self
+
+    def __delitem__(self, name):
+        assert_str = 'This group of entity does not exist in this collection!'
+        assert any([key for key in name.keys() if key in self.keys()]), assert_str
+        self[name]._observers.delete(self)
+        for entity in self[name]:
+            entity.del_observer(self)
+        return super(Entities, self).__delitem__(name)
+
+    @property
+    def obs_pairs(self):
+        return [y for x in self for y in x.obs_pairs]
+
+    def by_pos(self, pos: (int, int)):
+        return self.pos_dict[pos]
+        # found_entities = [y for y in (x.by_pos(pos) for x in self.values() if hasattr(x, 'by_pos')) if y is not None]
+        # return found_entities
+
+    @property
+    def positions(self):
+        return [k for k, v in self.pos_dict.items() for _ in v]

marl_factory_grid/environment/groups/mixins.py

@@ -0,0 +1,97 @@
+from marl_factory_grid.environment import constants as c
+
+from marl_factory_grid.environment.entity.entity import Entity
+
+
+# noinspection PyUnresolvedReferences,PyTypeChecker,PyArgumentList
+class PositionMixin:
+
+    _entity = Entity
+    is_blocking_light: bool = True
+    can_collide: bool = True
+    has_position: bool = True
+
+    def render(self):
+        return [y for y in [x.render() for x in self] if y is not None]
+
+    @classmethod
+    def from_tiles(cls, tiles, *args, entity_kwargs=None, **kwargs):
+        collection = cls(*args, **kwargs)
+        entities = [cls._entity(tile, str_ident=i,
+                                **entity_kwargs if entity_kwargs is not None else {})
+                    for i, tile in enumerate(tiles)]
+        collection.add_items(entities)
+        return collection
+
+    @classmethod
+    def from_coordinates(cls, positions: [(int, int)], tiles, *args, entity_kwargs=None, **kwargs, ):
+        return cls.from_tiles([tiles.by_pos(position) for position in positions], tiles.size, *args,
+                              entity_kwargs=entity_kwargs,
+                              **kwargs)
+
+    @property
+    def tiles(self):
+        return [entity.tile for entity in self]
+
+    def __delitem__(self, name):
+        idx, obj = next((i, obj) for i, obj in enumerate(self) if obj.name == name)
+        obj.tile.leave(obj)
+        super().__delitem__(name)
+
+    def by_pos(self, pos: (int, int)):
+        pos = tuple(pos)
+        try:
+            return next(e for e in self if e.pos == pos)
+        except StopIteration:
+            pass
+        except ValueError:
+            print()
+
+    @property
+    def positions(self):
+        return [e.pos for e in self]
+
+    def notify_del_entity(self, entity: Entity):
+        try:
+            self.pos_dict[entity.pos].remove(entity)
+        except (ValueError, AttributeError):
+            pass
+
+
+# noinspection PyUnresolvedReferences,PyTypeChecker
+class IsBoundMixin:
+
+    @property
+    def name(self):
+        return f'{self.__class__.__name__}({self._bound_entity.name})'
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}#{self._bound_entity.name}({self._data})'
+
+    def bind(self, entity):
+        # noinspection PyAttributeOutsideInit
+        self._bound_entity = entity
+        return c.VALID
+
+    def belongs_to_entity(self, entity):
+        return self._bound_entity == entity
+
+
+# noinspection PyUnresolvedReferences,PyTypeChecker
+class HasBoundedMixin:
+
+    @property
+    def obs_names(self):
+        return [x.name for x in self]
+
+    def by_entity(self, entity):
+        try:
+            return next((x for x in self if x.belongs_to_entity(entity)))
+        except StopIteration:
+            return None
+
+    def idx_by_entity(self, entity):
+        try:
+            return next((idx for idx, x in enumerate(self) if x.belongs_to_entity(entity)))
+        except StopIteration:
+            return None

marl_factory_grid/environment/groups/objects.py

@@ -0,0 +1,141 @@
+from collections import defaultdict
+from typing import List
+
+import numpy as np
+
+from marl_factory_grid.environment.entity.object import Object
+
+
+class Objects:
+    _entity = Object
+
+    @property
+    def observers(self):
+        return self._observers
+
+    @property
+    def obs_tag(self):
+        return self.__class__.__name__
+
+    @staticmethod
+    def render():
+        return []
+
+    @property
+    def obs_pairs(self):
+        return [(self.name, self)]
+
+    @property
+    def names(self):
+        # noinspection PyUnresolvedReferences
+        return [x.name for x in self]
+
+    @property
+    def name(self):
+        return f'{self.__class__.__name__}'
+
+    def __init__(self, *args, **kwargs):
+        self._data = defaultdict(lambda: None)
+        self._observers = list()
+        self.pos_dict = defaultdict(list)
+
+    def __len__(self):
+        return len(self._data)
+
+    def __iter__(self):
+        return iter(self.values())
+
+    def add_item(self, item: _entity):
+        assert_str = f'All item names have to be of type {self._entity}, but were {item.__class__}.,'
+        assert isinstance(item, self._entity), assert_str
+        assert self._data[item.name] is None, f'{item.name} allready exists!!!'
+        self._data.update({item.name: item})
+        item.set_collection(self)
+        for observer in self.observers:
+            observer.notify_add_entity(item)
+        return self
+
+    # noinspection PyUnresolvedReferences
+    def del_observer(self, observer):
+        self.observers.remove(observer)
+        for entity in self:
+            if observer in entity.observers:
+                entity.del_observer(observer)
+
+    # noinspection PyUnresolvedReferences
+    def add_observer(self, observer):
+        self.observers.append(observer)
+        for entity in self:
+            if observer not in entity.observers:
+                entity.add_observer(observer)
+
+    def __delitem__(self, name):
+        for observer in self.observers:
+            observer.notify_del_entity(name)
+        # noinspection PyTypeChecker
+        del self._data[name]
+
+    def add_items(self, items: List[_entity]):
+        for item in items:
+            self.add_item(item)
+        return self
+
+    def keys(self):
+        return self._data.keys()
+
+    def values(self):
+        return self._data.values()
+
+    def items(self):
+        return self._data.items()
+
+    def _get_index(self, item):
+        try:
+            return next(i for i, v in enumerate(self._data.values()) if v == item)
+        except StopIteration:
+            return None
+
+
+
+    def __getitem__(self, item):
+        if isinstance(item, (int, np.int64, np.int32)):
+            if item < 0:
+                item = len(self._data) - abs(item)
+            try:
+                return next(v for i, v in enumerate(self._data.values()) if i == item)
+            except StopIteration:
+                return None
+        try:
+            return self._data[item]
+        except KeyError:
+            return None
+        except TypeError:
+            print('Ups')
+            raise TypeError
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}[{dict(self._data)}]'
+
+    def notify_change_pos(self, entity: object):
+        try:
+            self.pos_dict[entity.last_pos].remove(entity)
+        except (ValueError, AttributeError):
+            pass
+        if entity.has_position:
+            try:
+                self.pos_dict[entity.pos].append(entity)
+            except (ValueError, AttributeError):
+                pass
+
+    def notify_del_entity(self, entity: Object):
+        try:
+            self.pos_dict[entity.pos].remove(entity)
+        except (ValueError, AttributeError):
+            pass
+
+    def notify_add_entity(self, entity: Object):
+        try:
+            entity.add_observer(self)
+            self.pos_dict[entity.pos].append(entity)
+        except (ValueError, AttributeError):
+            pass

marl_factory_grid/environment/groups/utils.py

@@ -0,0 +1,77 @@
+from typing import List, Union
+
+import numpy as np
+
+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 HasBoundedMixin, PositionMixin
+from marl_factory_grid.environment.entity.util import GlobalPosition
+from marl_factory_grid.utils import helpers as h
+from marl_factory_grid.environment import constants as c
+
+
+class Combined(PositionMixin, EnvObjects):
+
+    @property
+    def name(self):
+        return f'{super().name}({self._ident or self._names})'
+
+    @property
+    def names(self):
+        return self._names
+
+    def __init__(self, names: List[str], *args, identifier: Union[None, str] = None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._ident = identifier
+        self._names = names or list()
+
+    @property
+    def obs_tag(self):
+        return self.name
+
+    @property
+    def obs_pairs(self):
+        return [(name, None) for name in self.names]
+
+
+class GlobalPositions(HasBoundedMixin, EnvObjects):
+
+    _entity = GlobalPosition
+    is_blocking_light = False,
+    can_collide = False
+
+    def __init__(self, *args, **kwargs):
+        super(GlobalPositions, self).__init__(*args, **kwargs)
+
+
+class Zones(Objects):
+
+    @property
+    def accounting_zones(self):
+        return [self[idx] for idx, name in self.items() if name != c.DANGER_ZONE]
+
+    def __init__(self, parsed_level):
+        raise NotImplementedError('This needs a Rework')
+        super(Zones, self).__init__()
+        slices = list()
+        self._accounting_zones = list()
+        self._danger_zones = list()
+        for symbol in np.unique(parsed_level):
+            if symbol == c.VALUE_OCCUPIED_CELL:
+                continue
+            elif symbol == c.DANGER_ZONE:
+                self + symbol
+                slices.append(h.one_hot_level(parsed_level, symbol))
+                self._danger_zones.append(symbol)
+            else:
+                self + symbol
+                slices.append(h.one_hot_level(parsed_level, symbol))
+                self._accounting_zones.append(symbol)
+
+        self._zone_slices = np.stack(slices)
+
+    def __getitem__(self, item):
+        return self._zone_slices[item]
+
+    def add_items(self, other: Union[str, List[str]]):
+        raise AttributeError('You are not allowed to add additional Zones in runtime.')

marl_factory_grid/environment/groups/wall_n_floors.py

@@ -0,0 +1,54 @@
+import random
+from typing import List
+
+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.mixins import PositionMixin
+from marl_factory_grid.environment.entity.wall_floor import Wall, Floor
+
+
+class Walls(PositionMixin, EnvObjects):
+    _entity = Wall
+    symbol = c.SYMBOL_WALL
+
+    def __init__(self, *args, **kwargs):
+        super(Walls, self).__init__(*args, **kwargs)
+        self._value = c.VALUE_OCCUPIED_CELL
+
+    @classmethod
+    def from_coordinates(cls, argwhere_coordinates, *args, **kwargs):
+        tiles = cls(*args, **kwargs)
+        # noinspection PyTypeChecker
+        tiles.add_items([cls._entity(pos) for pos in argwhere_coordinates])
+        return tiles
+
+    @classmethod
+    def from_tiles(cls, tiles, *args, **kwargs):
+        raise RuntimeError()
+
+
+class Floors(Walls):
+    _entity = Floor
+    symbol = c.SYMBOL_FLOOR
+    is_blocking_light: bool = False
+    can_collide: bool = False
+
+    def __init__(self, *args, **kwargs):
+        super(Floors, self).__init__(*args, **kwargs)
+        self._value = c.VALUE_FREE_CELL
+
+    @property
+    def occupied_tiles(self):
+        tiles = [tile for tile in self if tile.is_occupied()]
+        random.shuffle(tiles)
+        return tiles
+
+    @property
+    def empty_tiles(self) -> List[Floor]:
+        tiles = [tile for tile in self if tile.is_empty()]
+        random.shuffle(tiles)
+        return tiles
+
+    @classmethod
+    def from_tiles(cls, tiles, *args, **kwargs):
+        raise RuntimeError()