remove engulf and life_game projects

sandbox/engulf/behaviour.py

@@ -1,443 +0,0 @@
-# coding: utf-8
-import typing
-from random import choice
-
-from sandbox.engulf.const import COLLECTION_GRASS, COLLECTION_CELL, COLLECTION_ALIVE, COLLECTION_PREY
-from sandbox.engulf.exceptions import NotFoundWhereToGo
-from synergine2.simulation import Event
-from synergine2.simulation import SubjectBehaviour, SimulationMechanism, SimulationBehaviour, SubjectBehaviourSelector
-from synergine2.utils import ChunkManager
-from synergine2_xyz.xyz import DIRECTIONS, DIRECTION_SLIGHTLY, \
-    get_direction_from_north_degree
-from synergine2_xyz.mechanism import ProximitySubjectMechanism
-from synergine2_xyz.utils import get_around_positions_of_positions, get_position_for_direction
-
-# Import for typing hint
-if False:
-    from sandbox.engulf.subject import Grass
-    from sandbox.engulf.subject import PreyCell
-
-
-class GrassGrownUp(Event):
-    def __init__(self, subject_id, density, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.subject_id = subject_id
-        self.density = density
-
-    def repr_debug(self) -> str:
-        return '{}: subject_id:{}, density:{}'.format(
-            self.__class__.__name__,
-            self.subject_id,
-            self.density,
-        )
-
-
-class GrassSpawn(Event):
-    def __init__(self, subject_id, position, density, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.subject_id = subject_id
-        self.position = position
-        self.density = density
-
-    def repr_debug(self) -> str:
-        return '{}: subject_id:{}, position:{}, density:{}'.format(
-            self.__class__.__name__,
-            self.subject_id,
-            self.position,
-            self.density,
-        )
-
-
-class GrassSpotablePositionsMechanism(SimulationMechanism):
-    parallelizable = True
-
-    def run(self, process_number: int=None, process_count: int=None):
-        chunk_manager = ChunkManager(process_count)
-        positions = list(self.simulation.subjects.grass_xyz.keys())
-        positions_chunks = chunk_manager.make_chunks(positions)
-        spotables = []
-
-        for position in positions_chunks[process_number]:
-            arounds = get_around_positions_of_positions(position)
-            from_subject = self.simulation.subjects.grass_xyz[position][0]
-            around_data = {
-                'from_subject': from_subject,
-                'around': [],
-            }
-            for around in arounds:
-                if around not in self.simulation.subjects.grass_xyz and self.simulation.is_possible_position(around):
-                    around_data['around'].append(around)
-
-            if around_data['around']:
-                spotables.append(around_data)
-
-        return spotables
-
-
-class GrowUp(SubjectBehaviour):
-    frequency = 20
-
-    def run(self, data):
-        return True
-
-    def action(self, data) -> [Event]:
-        self.subject.density += 1
-        return [GrassGrownUp(
-            self.subject.id,
-            self.subject.density,
-        )]
-
-
-class GrassSpawnBehaviour(SimulationBehaviour):
-    frequency = 100
-    use = [GrassSpotablePositionsMechanism]
-
-    def run(self, data):
-        spawns = []
-
-        for around_data in data[GrassSpotablePositionsMechanism]:
-            from_subject = around_data['from_subject']
-            arounds = around_data['around']
-            if from_subject.density >= 40:
-                spawns.extend(arounds)
-
-        return spawns
-
-    @classmethod
-    def merge_data(cls, new_data, start_data=None):
-        start_data = start_data or []
-        start_data.extend(new_data)
-        return start_data
-
-    def action(self, data) -> [Event]:
-        from sandbox.engulf.subject import Grass  # cyclic
-        events = []
-
-        for position in data:
-            if position not in list(self.simulation.subjects.grass_xyz.keys()):
-                new_grass = Grass(
-                    config=self.config,
-                    simulation=self.simulation,
-                    position=position,
-                    density=20,
-                )
-                self.simulation.subjects.append(new_grass)
-                events.append(GrassSpawn(
-                    new_grass.id,
-                    new_grass.position,
-                    new_grass.density,
-                ))
-
-        return events
-
-
-class GrassEatableDirectProximityMechanism(ProximitySubjectMechanism):
-    distance = 1.41  # distance when on angle
-    feel_collections = [COLLECTION_GRASS]
-
-    def acceptable_subject(self, subject: 'Grass') -> bool:
-        return subject.density >= self.config.simulation.eat_grass_required_density
-
-
-class PreyEatableDirectProximityMechanism(ProximitySubjectMechanism):
-    distance = 1.41  # distance when on angle
-    feel_collections = [COLLECTION_CELL]
-
-    def acceptable_subject(self, subject: 'PreyCell') -> bool:
-        # TODO: N'attaquer que des "herbivores" ?
-        from sandbox.engulf.subject import PreyCell  # cyclic
-        return isinstance(subject, PreyCell)
-
-
-class MoveTo(Event):
-    def __init__(self, subject_id: int, position: tuple, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.subject_id = subject_id
-        self.position = position
-
-    def repr_debug(self) -> str:
-        return '{}: subject_id:{}, position:{}'.format(
-            type(self).__name__,
-            self.subject_id,
-            self.position,
-        )
-
-
-class EatEvent(Event):
-    def __init__(self, eaten_id: int, eater_id: int, eaten_new_density: float, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.eaten_id = eaten_id
-        self.eater_id = eater_id
-        self.eaten_new_density = eaten_new_density
-
-
-class EatenEvent(Event):
-    def __init__(self, eaten_id: int, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.eaten_id = eaten_id
-
-
-class AttackEvent(Event):
-    def __init__(self, attacker_id: int, attacked_id: int, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.attacker_id = attacker_id
-        self.attacked_id = attacked_id
-
-
-class SearchFood(SubjectBehaviour):
-    mechanism_data_class = NotImplemented
-
-    def get_required_appetite(self) -> float:
-        raise NotImplementedError()
-
-    def run(self, data):
-        if self.subject.appetite < self.get_required_appetite():
-            return False
-
-        if not data[self.mechanism_data_class]:
-            return False
-
-        direction_degrees = [d['direction'] for d in data[self.mechanism_data_class]]
-        return get_direction_from_north_degree(choice(direction_degrees))
-
-    def action(self, data) -> [Event]:
-        direction = data
-        position = get_position_for_direction(self.subject.position, direction)
-        self.subject.position = position
-        self.subject.previous_direction = direction
-
-        return [MoveTo(self.subject.id, position)]
-
-
-class SearchGrass(SearchFood):
-    """
-    Si une nourriture a une case de distance et cellule non rassasié, move dans sa direction.
-    """
-    use = [GrassEatableDirectProximityMechanism]
-    mechanism_data_class = use[0]
-
-    def get_required_appetite(self) -> float:
-        return self.config.simulation.search_food_appetite_required
-
-
-class SearchPrey(SearchFood):
-    """
-    Si une nourriture a une case de distance et cellule non rassasié, move dans sa direction.
-    """
-    use = [PreyEatableDirectProximityMechanism]
-    mechanism_data_class = use[0]
-
-    def get_required_appetite(self) -> float:
-        return self.config.simulation.search_and_attack_prey_apetite_required
-
-
-class EatGrass(SubjectBehaviour):
-    def run(self, data):
-        if self.subject.appetite < self.config.simulation.eat_grass_required_density:
-            return False
-
-        for grass in self.simulation.collections.get(COLLECTION_GRASS, []):
-            # TODO: Use simulation/xyz pre calculated indexes
-            if grass.position == self.subject.position:
-                return grass.id
-
-    def action(self, data) -> [Event]:
-        subject_id = data
-
-        grass = self.simulation.subjects.index[subject_id]  # TODO: cas ou grass disparu ?
-        grass.density -= self.config.simulation.eat_grass_density_reduction
-
-        self.subject.appetite -= self.config.simulation.eat_grass_appetite_reduction
-
-        # TODO: Comment mettre des logs (ne peuvent pas être passé aux subprocess)?
-
-        return [EatEvent(
-            eater_id=self.subject.id,
-            eaten_id=subject_id,
-            eaten_new_density=grass.density,
-        )]
-
-
-class EatPrey(SubjectBehaviour):
-    def run(self, data):
-        if self.subject.appetite < self.config.simulation.search_and_attack_prey_apetite_required:
-            return False
-
-        for prey in self.simulation.collections.get(COLLECTION_PREY, []):
-            # TODO: Use simulation/xyz pre calculated indexes
-            if prey.position == self.subject.position:
-                return prey.id
-
-    def action(self, data) -> [Event]:
-        subject_id = data
-
-        # Cell already eaten ?
-        if subject_id not in self.simulation.subjects.index:
-            return []
-
-        prey = self.simulation.subjects.index[subject_id]
-        self.simulation.subjects.remove(prey)
-        self.subject.appetite -= self.config.simulation.eat_prey_required_density
-
-        return [EatenEvent(
-            eaten_id=prey.id,
-        )]
-
-
-class Explore(SubjectBehaviour):
-    """
-    Produit un mouvement au hasard (ou un immobilisme)
-    """
-    use = []
-
-    def run(self, data):
-        # TODO: Il faut pouvoir dire tel behaviour concerne que tel collections
-        if COLLECTION_ALIVE not in self.subject.collections:
-            return False
-
-        return True
-
-    def action(self, data) -> [Event]:
-        try:
-            position, direction = self.get_random_position_and_direction()
-            self.subject.position = position
-            self.subject.previous_direction = direction
-            return [MoveTo(self.subject.id, position)]
-        except NotFoundWhereToGo:
-            return []
-
-    def get_random_position_and_direction(self) -> tuple:
-        attempts = 0
-
-        while attempts <= 5:
-            attempts += 1
-            direction = self.get_random_direction()
-            position = get_position_for_direction(self.subject.position, direction)
-
-            if self.simulation.is_possible_subject_position(self.subject, position):
-                return position, direction
-
-            # If blocked, permit any direction (not slightly)
-            if attempts >= 3:
-                self.subject.previous_direction = None
-
-        raise NotFoundWhereToGo()
-
-    def get_random_direction(self):
-        if not self.subject.previous_direction:
-            return choice(DIRECTIONS)
-        return choice(DIRECTION_SLIGHTLY[self.subject.previous_direction])
-
-
-class Hungry(SubjectBehaviour):
-    def run(self, data):
-        return True
-
-    def action(self, data) -> [Event]:
-        self.subject.appetite += self.config.simulation.hungry_reduction
-        return []
-
-    def get_random_direction(self):
-        if not self.subject.previous_direction:
-            return choice(DIRECTIONS)
-        return choice(DIRECTION_SLIGHTLY[self.subject.previous_direction])
-
-
-class Attack(SubjectBehaviour):
-    use = [PreyEatableDirectProximityMechanism]
-
-    def run(self, data):
-        if self.subject.appetite < self.config.simulation.search_and_attack_prey_apetite_required:
-            return False
-
-        eatable_datas = data[PreyEatableDirectProximityMechanism]
-        attackable_datas = []
-
-        for eatable_data in eatable_datas:
-            if COLLECTION_ALIVE in eatable_data['subject'].collections:
-                attackable_datas.append(eatable_data)
-
-        if attackable_datas:
-            return choice(attackable_datas)
-        return False
-
-    def action(self, data) -> [Event]:
-        attacked = self.simulation.subjects.index[data['subject'].id]
-
-        try:
-            # TODO il faut automatiser/Refactoriser le fait de retirer/ajouter un collection
-            self.simulation.collections[COLLECTION_ALIVE].remove(attacked)
-            attacked.collections.remove(COLLECTION_ALIVE)
-        except ValueError:
-            pass  # On considere qu'il a ete tué par une autre, TODO: en être sur ?
-
-        return [AttackEvent(attacker_id=self.subject.id, attacked_id=data['subject'].id)]
-
-
-class CellBehaviourSelector(SubjectBehaviourSelector):
-    # If behaviour in sublist, only one be kept in sublist
-    behaviour_hierarchy = (  # TODO: refact it
-        (
-            EatPrey,
-            EatGrass,  # TODO: Introduce priority with appetite
-            Attack,
-            SearchPrey,
-            SearchGrass,  # TODO: Introduce priority with appetite
-            Explore,
-        ),
-    )
-
-    def reduce_behaviours(
-        self,
-        behaviours: typing.Dict[typing.Type[SubjectBehaviour], object],
-    ) -> typing.Dict[typing.Type[SubjectBehaviour], object]:
-        reduced_behaviours = {}  # type: typing.Dict[typing.Type[SubjectBehaviour], object]
-
-        for behaviour_class, behaviour_data in behaviours.items():
-            if not self.behaviour_class_in_sublist(behaviour_class):
-                reduced_behaviours[behaviour_class] = behaviour_data
-            elif self.behaviour_class_is_prior(behaviour_class, behaviours):
-                reduced_behaviours[behaviour_class] = behaviour_data
-
-        return reduced_behaviours
-
-    def behaviour_class_in_sublist(self, behaviour_class: typing.Type[SubjectBehaviour]) -> bool:
-        for sublist in self.behaviour_hierarchy:
-            if behaviour_class in sublist:
-                return True
-        return False
-
-    def behaviour_class_is_prior(
-        self,
-        behaviour_class: typing.Type[SubjectBehaviour],
-        behaviours: typing.Dict[typing.Type[SubjectBehaviour], object],
-    ) -> bool:
-        for sublist in self.behaviour_hierarchy:
-            if behaviour_class in sublist:
-                behaviour_position = sublist.index(behaviour_class)
-                other_behaviour_top_position = self.get_other_behaviour_top_position(
-                    behaviour_class,
-                    behaviours,
-                    sublist,
-                )
-                if other_behaviour_top_position is not None and behaviour_position > other_behaviour_top_position:
-                    return False
-        return True
-
-    def get_other_behaviour_top_position(
-        self,
-        exclude_behaviour_class,
-        behaviours,
-        sublist,
-    ) -> typing.Union[None, int]:
-        position = None
-        for behaviour_class in behaviours.keys():
-            if behaviour_class != exclude_behaviour_class:
-                try:
-                    behaviour_position = sublist.index(behaviour_class)
-                    if position is None or behaviour_position < position:
-                        position = behaviour_position
-                except ValueError:
-                    pass
-
-        return position

sandbox/engulf/config.yaml

@@ -1,13 +0,0 @@
-core:
-    cycle_duration: 0.5
-terminals:
-    sync: True
-simulation:
-    start_appetite: 50
-    hungry_reduction: 0.25
-    search_food_appetite_required: 30
-    search_and_attack_prey_apetite_required: 50
-    eat_grass_required_density: 25
-    eat_prey_required_density: 100
-    eat_grass_appetite_reduction: 5
-    eat_grass_density_reduction: 25

sandbox/engulf/const.py

@@ -1,9 +0,0 @@
-# coding: utf-8
-
-
-COLLECTION_CELL = 'CELL'
-COLLECTION_PREY = 'PREY'
-COLLECTION_PREDATOR = 'PREDATOR'
-COLLECTION_ALIVE = 'ALIVE'
-COLLECTION_EATABLE = 'EATABLE'
-COLLECTION_GRASS = 'GRASS'

sandbox/engulf/exceptions.py

@@ -1,6 +0,0 @@
-# coding: utf-8
-from synergine2_xyz.xyz import XYZException
-
-
-class NotFoundWhereToGo(XYZException):
-    pass

sandbox/engulf/gui.py

@@ -1,184 +0,0 @@
-# coding: utf-8
-from random import randint
-
-import cocos
-from cocos.actions import MoveTo, Repeat, ScaleBy, Reverse, RotateTo
-from cocos.sprite import Sprite
-from sandbox.engulf.behaviour import GrassGrownUp, GrassSpawn, MoveTo as MoveToEvent, EatEvent, AttackEvent, EatenEvent
-from sandbox.engulf.subject import Cell, Grass, PreyCell, PredatorCell
-from synergine2.terminals import TerminalPackage, Terminal
-from synergine2_cocos2d.gui import Gui, GridLayerMixin
-from synergine2_cocos2d.gui import MainLayer as BaseMainLayer
-
-cell_scale = ScaleBy(1.1, duration=0.25)
-
-
-class CellsLayer(GridLayerMixin, BaseMainLayer):
-    def __init__(self, game: 'Game', *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.game = game
-        self.cell_positions = {}
-        self.cell_ids = {}
-
-    @property
-    def move_duration(self):
-        return self.game.cycle_duration
-
-    @property
-    def fake_move_rotate_duration(self):
-        return self.move_duration / 3
-
-    def born(self, subject_id: int, grid_position, cell_type):
-        png = 'resources/cell.png' if cell_type is PreyCell else 'resources/cellp.png'
-
-        cell = Sprite(png)
-        cell.rotation = randint(0, 360)
-        self.grid_manager.scale_sprite(cell)
-        self.grid_manager.position_sprite(cell, grid_position)
-        self.cell_positions[grid_position] = cell
-        self.cell_ids[subject_id] = cell
-        cell.do(Repeat(cell_scale + Reverse(cell_scale)))
-        self.add(cell)
-
-    def move(self, subject_id: int, position: tuple):
-        if subject_id not in self.cell_ids:
-            return  # Cell eaten before
-
-        cell = self.cell_ids[subject_id]
-
-        window_position = self.grid_manager.get_window_position(position[0], position[1])
-        move_action = MoveTo(window_position, self.move_duration)
-
-        fake_rotate = RotateTo(randint(0, 360), self.fake_move_rotate_duration)
-
-        cell.do(move_action)
-        cell.do(fake_rotate)
-
-    def attack(self, attacker_id: int, attacked_id: int):
-        attacker = self.cell_ids[attacker_id]
-        attacker.do(ScaleBy(1.7, duration=0.25))
-
-    def eaten(self, eaten_id: int):
-        eaten = self.cell_ids[eaten_id]
-        self.remove(eaten)
-        # TODO: refact: On a pas nettoyer self.cell_positions par exemple
-        del self.cell_ids[eaten_id]
-
-
-class GrassLayer(GridLayerMixin, BaseMainLayer):
-    def __init__(self, game: 'Game', *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.game = game
-        self.grasses = {}
-
-    def born(self, subject_id, grid_position, opacity=100):
-        grass = Sprite('resources/grass.png')
-        grass.rotation = randint(0, 360)
-        grass.opacity = opacity
-        self.grid_manager.scale_sprite(grass)
-        self.grid_manager.position_sprite(grass, grid_position)
-        self.grasses[subject_id] = grass
-        self.add(grass)
-
-    def set_density(self, subject_id, density):
-        self.grasses[subject_id].opacity = density
-
-
-class MainLayer(GridLayerMixin, BaseMainLayer):
-    def __init__(self, game: 'Game', terminal: Terminal, *args, **kwargs):
-        super().__init__(terminal, *args, **kwargs)
-        self.game = game
-        self.terminal = terminal
-
-        self.cells = CellsLayer(game=game, terminal=terminal)
-        self.add(self.cells)
-
-        self.grasses = GrassLayer(game=game, terminal=terminal)
-        self.add(self.grasses)
-
-
-class Game(Gui):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        self.main_layer = MainLayer(game=self, terminal=self.terminal)
-        self.main_scene = cocos.scene.Scene(self.main_layer)
-
-        # Event registering
-        self.terminal.register_event_handler(
-            GrassGrownUp,
-            self.on_grass_grown_up,
-        )
-        self.terminal.register_event_handler(
-            GrassSpawn,
-            self.on_grass_spawn,
-        )
-        self.terminal.register_event_handler(
-            MoveToEvent,
-            self.on_move_to,
-        )
-        self.terminal.register_event_handler(
-            EatEvent,
-            self.on_eat,
-        )
-        self.terminal.register_event_handler(
-            AttackEvent,
-            self.on_attack,
-        )
-        self.terminal.register_event_handler(
-            EatenEvent,
-            self.on_eaten,
-        )
-
-    def get_main_scene(self):
-        return self.main_scene
-
-    def before_received(self, package: TerminalPackage):
-        if package.subjects:  # It's thirst package
-            for subject in package.subjects:
-                if isinstance(subject, PreyCell):
-                    self.main_layer.cells.born(subject.id, subject.position, PreyCell)
-                if isinstance(subject, PredatorCell):
-                    self.main_layer.cells.born(subject.id, subject.position, PredatorCell)
-                if isinstance(subject, Grass):
-                    self.main_layer.grasses.born(
-                        subject.id,
-                        subject.position,
-                        subject.density,
-                    )
-
-    def on_grass_spawn(self, event: GrassSpawn):
-        self.main_layer.grasses.born(
-            event.subject_id,
-            event.position,
-            event.density,
-        )
-
-    def on_grass_grown_up(self, event: GrassGrownUp):
-        self.main_layer.grasses.set_density(
-            event.subject_id,
-            event.density,  # TODO: Recupe ces données depuis local plutôt que event ?
-        )
-
-    def on_move_to(self, event: MoveToEvent):
-        self.main_layer.cells.move(
-            event.subject_id,
-            event.position,
-        )
-
-    def on_eat(self, event: EatEvent):
-        self.main_layer.grasses.set_density(
-            event.eaten_id,
-            event.eaten_new_density,
-        )
-
-    def on_attack(self, event: AttackEvent):
-        self.main_layer.cells.attack(
-            event.attacker_id,
-            event.attacked_id,
-        )
-
-    def on_eaten(self, event: EatenEvent):
-        self.main_layer.cells.eaten(
-            event.eaten_id,
-        )

sandbox/engulf/run.py

@@ -1,192 +0,0 @@
-"""
-
-Engulf is simulation containing:
-
-* Subjects who need to:
-  * eat
-    * low energy ground stuff
-    * other alive subjects
-    * other dead subjects
-  * sleep
-  * want to be not alone
-    * with non aggressive subjects
-  * want to be alone
-  * reproduce
-    * with non aggressive subjects
-    * and transmit tendencies because their cultures can be
-      * eat: - eat background stuff, + eat subjects
-      * alone/not alone: - be alone + not alone
-
-"""
-import logging
-import os
-import sys
-import typing
-
-synergine2_ath = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '../../'))
-sys.path.append(synergine2_ath)
-
-from random import randint, seed
-from sandbox.engulf.behaviour import GrassGrownUp, GrassSpawn, MoveTo, EatEvent, AttackEvent, EatenEvent
-
-from synergine2.config import Config
-from synergine2.log import get_default_logger
-from sandbox.engulf.subject import Grass, PreyCell, PredatorCell
-from synergine2.core import Core
-from synergine2.cycle import CycleManager
-from synergine2.terminals import TerminalManager, Terminal, TerminalPackage
-from sandbox.engulf.simulation import EngulfSubjects, Engulf
-from synergine2_xyz.utils import get_around_positions_of, get_distance_between_points
-
-
-class GameTerminal(Terminal):
-    subscribed_events = [
-        GrassGrownUp,
-        GrassSpawn,
-        MoveTo,
-        EatEvent,
-        AttackEvent,
-        EatenEvent,
-    ]
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.gui = None
-        self.asynchronous = False  # TODO: config
-
-    def receive(self, package: TerminalPackage):
-        self.gui.before_received(package)
-        super().receive(package)
-        self.gui.after_received(package)
-
-    def run(self):
-        from sandbox.engulf import gui
-        self.gui = gui.Game(self.config, self.logger, self)
-        self.gui.run()
-
-
-def fill_with_random_cells(
-    config,
-    subjects: EngulfSubjects,
-    count: int,
-    start_position: tuple,
-    end_position: tuple,
-    cell_class: typing.Type[PreyCell],
-) -> None:
-    cells = []
-
-    while len(cells) < count:
-        position = (
-            randint(start_position[0], end_position[0]+1),
-            randint(start_position[1], end_position[1]+1),
-            0,
-        )
-        if position not in subjects.cell_xyz:
-            cell = cell_class(
-                config,
-                simulation=subjects.simulation,
-                position=position,
-            )
-            cells.append(cell)
-            subjects.append(cell)
-
-
-def fill_with_random_grass(
-    config,
-    subjects: EngulfSubjects,
-    start_count: int,
-    start_position: tuple,
-    end_position: tuple,
-    density: int=5,
-) -> None:
-    grasses = []
-
-    while len(grasses) < start_count:
-        position = (
-            randint(start_position[0], end_position[0]+1),
-            randint(start_position[1], end_position[1]+1),
-            0,
-        )
-
-        if position not in subjects.grass_xyz:
-            grass = Grass(
-                config,
-                simulation=subjects.simulation,
-                position=position,
-            )
-            grasses.append(grass)
-            subjects.append(grass)
-
-    for grass in grasses:
-        for around in get_around_positions_of(grass.position, distance=density):
-            if around not in subjects.grass_xyz:
-                if subjects.simulation.is_possible_position(around):
-                    new_grass = Grass(
-                        config,
-                        simulation=subjects.simulation,
-                        position=around,
-                    )
-                    distance = get_distance_between_points(around, grass.position)
-                    new_grass.density = 100 - round((distance * 100) / 7)
-                    subjects.append(new_grass)
-
-
-def main():
-    seed(42)
-
-    config = Config()
-    config.load_files(['sandbox/engulf/config.yaml'])
-    logger = get_default_logger(level=logging.DEBUG)
-
-    simulation = Engulf(config)
-    subjects = EngulfSubjects(simulation=simulation)
-    fill_with_random_cells(
-        config,
-        subjects,
-        30,
-        (-34, -34, 0),
-        (34, 34, 0),
-        cell_class=PreyCell,
-    )
-    fill_with_random_cells(
-        config,
-        subjects,
-        30,
-        (-34, -34, 0),
-        (34, 34, 0),
-        cell_class=PredatorCell,
-    )
-    fill_with_random_grass(
-        config,
-        subjects,
-        5,
-        (-34, -34, 0),
-        (34, 34, 0),
-    )
-    simulation.subjects = subjects
-
-    core = Core(
-        config=config,
-        logger=logger,
-        simulation=simulation,
-        cycle_manager=CycleManager(
-            config=config,
-            logger=logger,
-            simulation=simulation,
-        ),
-        terminal_manager=TerminalManager(
-            config=config,
-            logger=logger,
-            terminals=[GameTerminal(
-                config,
-                logger,
-                asynchronous=False,
-            )]
-        ),
-        cycles_per_seconds=1/config.core.cycle_duration,
-    )
-    core.run()
-
-
-if __name__ == '__main__':
-    main()

sandbox/engulf/simulation.py

@@ -1,61 +0,0 @@
-# coding: utf-8
-from sandbox.engulf.behaviour import GrassSpawnBehaviour
-from sandbox.engulf.subject import Cell, Grass
-from synergine2_xyz.xyz import XYZSubjectMixin
-from synergine2_xyz.subjects import XYZSubjects
-from synergine2_xyz.simulation import XYZSimulation
-
-__author__ = 'bux'
-
-
-class EngulfSubjects(XYZSubjects):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        # TODO: accept multiple subjects as same position
-        # TODO: init xyz with given list
-        self.cell_xyz = {}
-        self.grass_xyz = {}
-
-    def remove(self, value: XYZSubjectMixin):
-        super().remove(value)
-
-        if isinstance(value, Cell):
-            try:
-                self.cell_xyz.get(value.position, []).remove(value)
-                if not self.cell_xyz[value.position]:
-                    del self.cell_xyz[value.position]
-            except ValueError:
-                pass
-
-        if isinstance(value, Grass):
-            del self.grass_xyz[value.position]
-
-    def append(self, p_object: XYZSubjectMixin):
-        super().append(p_object)
-
-        if isinstance(p_object, Cell):
-            self.cell_xyz.setdefault(p_object.position, []).append(p_object)
-
-        if isinstance(p_object, Grass):
-            self.grass_xyz.setdefault(p_object.position, []).append(p_object)
-
-
-class Engulf(XYZSimulation):
-    behaviours_classes = [
-        GrassSpawnBehaviour,
-    ]
-
-    def is_possible_position(self, position: tuple) -> bool:
-        top_left = (-35, -35, 0)
-        bottom_right = (35, 35, 0)
-
-        pos_x = position[0]
-        pos_y = position[1]
-
-        if pos_x < top_left[0] or pos_x > bottom_right[0]:
-            return False
-
-        if pos_y < top_left[1] or pos_y > bottom_right[1]:
-            return False
-
-        return True

sandbox/engulf/subject.py

@@ -1,75 +0,0 @@
-# coding: utf-8
-from sandbox.engulf.behaviour import GrowUp, SearchGrass, EatGrass, Explore, CellBehaviourSelector, Hungry, Attack, \
-    SearchPrey, EatPrey
-from sandbox.engulf.const import COLLECTION_CELL, COLLECTION_ALIVE, COLLECTION_EATABLE, COLLECTION_GRASS, \
-    COLLECTION_PREY, COLLECTION_PREDATOR
-from synergine2.simulation import Subject
-from synergine2_xyz.xyz import XYZSubjectMixin
-
-
-class Cell(XYZSubjectMixin, Subject):
-    collections = [
-        COLLECTION_CELL,
-        COLLECTION_ALIVE,
-        COLLECTION_EATABLE,
-    ]
-    # TODO: Mettre en place la "selection/choix": car il y a deux move possible chaque cycle ci-dessous.
-    behaviours_classes = [
-        Explore,
-        Hungry,
-    ]
-    behaviour_selector_class = CellBehaviourSelector
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self._appetite = self.config.simulation.start_appetite  # /100
-
-    @property
-    def appetite(self) -> float:
-        return self._appetite
-
-    @appetite.setter
-    def appetite(self, value) -> None:
-        if value > 100:
-            self._appetite = 100
-        elif value < 0:
-            self._appetite = 0
-        else:
-            self._appetite = value
-
-
-class PreyCell(Cell):
-    collections = Cell.collections[:] + [COLLECTION_PREY]
-    behaviours_classes = Cell.behaviours_classes[:] + [SearchGrass, EatGrass]
-
-
-class PredatorCell(Cell):
-    collections = Cell.collections[:] + [COLLECTION_PREDATOR]
-    behaviours_classes = Cell.behaviours_classes[:] + [SearchPrey, Attack, EatPrey]
-
-
-class Grass(XYZSubjectMixin, Subject):
-    collections = [
-        COLLECTION_EATABLE,
-        COLLECTION_GRASS,
-    ]
-    behaviours_classes = [
-        GrowUp,
-    ]
-
-    def __init__(self, *args, **kwargs):
-        self._density = kwargs.pop('density', 100.0)
-        super().__init__(*args, **kwargs)
-
-    @property
-    def density(self) -> float:
-        return self._density
-
-    @density.setter
-    def density(self, value: float) -> None:
-        if value > 100:
-            self._density = 100
-        elif value < 0:
-            self._density = 0
-        else:
-            self._density = value

sandbox/life_game/config.yaml

@@ -1,4 +0,0 @@
-core:
-    cycle_duration: 0.5
-terminals:
-    sync: True

sandbox/life_game/gui.py

@@ -1,152 +0,0 @@
-# coding: utf-8
-import cocos
-from cocos.actions import ScaleBy, Repeat, Reverse, RotateBy
-from cocos.director import director
-from cocos.layer import ScrollableLayer, Layer
-from cocos.sprite import Sprite
-from pyglet.window import key as wkey
-from random import randint
-from sandbox.life_game.simulation import CellBornEvent
-from sandbox.life_game.simulation import CellDieEvent, Cell, InvertCellStateBehaviour, \
-    EmptyPositionWithLotOfCellAroundEvent
-from synergine2.config import Config
-from synergine2.log import SynergineLogger
-from synergine2.terminals import Terminal
-from synergine2.terminals import TerminalPackage
-from synergine2_cocos2d.gui import Gui, GridLayerMixin, MainLayer as BaseMainLayer
-
-cell_scale = ScaleBy(1.1, duration=0.25)
-cell_rotate = RotateBy(360, duration=30)
-flash_flash = ScaleBy(8, duration=0.5)
-flash_rotate = RotateBy(360, duration=6)
-
-
-class Cells(GridLayerMixin, Layer):
-    def __init__(self):
-        super().__init__()
-        self.cells = {}
-        self.flashs = []
-
-    def born(self, grid_position):
-        if grid_position in self.cells:
-            return  # cell can be added by gui
-
-        cell = Sprite('resources/cells_l.png')
-        cell.rotation = randint(0, 360)
-        self.grid_manager.scale_sprite(cell)
-        self.grid_manager.position_sprite(cell, grid_position)
-        cell.do(Repeat(cell_scale + Reverse(cell_scale)))
-        cell.do(Repeat(cell_rotate + Reverse(cell_rotate)))
-        self.cells[grid_position] = cell
-        self.add(cell)
-
-    def die(self, grid_position):
-        try:
-            self.remove(self.cells[grid_position])
-            del self.cells[grid_position]
-        except KeyError:
-            pass  # Cell can be removed by gui
-
-    def flash(self, position):
-        flash = Sprite('resources/flash.png')
-        flash.opacity = 40
-        flash.scale = 0.1
-        flash.rotation = randint(0, 360)
-        flash.do(flash_flash + Reverse(flash_flash))
-        flash.do(Repeat(flash_rotate + Reverse(flash_rotate)))
-        self.grid_manager.position_sprite(flash, position)
-        self.flashs.append(flash)
-        self.add(flash)
-
-
-class MainLayer(GridLayerMixin, BaseMainLayer):
-    is_event_handler = True
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        self.background = Sprite('resources/banner-1711735_640.jpg')
-        self.background.position = 0, 0
-        self.background.opacity = 70
-        self.background.scale = 5
-        self.add(self.background, z=1)
-
-        self.cells = Cells()
-        self.add(self.cells)
-
-        self.cross = Sprite('resources/cross31x31.png')
-        self.cross.position = 0, 0
-        self.cross.opacity = 50
-        self.add(self.cross)
-
-        # Set scene center on center of screen
-        window_size = director.get_window_size()
-        self.position = window_size[0] // 2, window_size[1] // 2
-
-    def on_mouse_press(self, x, y, buttons, modifiers):
-        x, y = director.get_virtual_coordinates(x, y)
-        grid_position = self.grid_manager.get_grid_position(x, y)
-
-        self.terminal.send(TerminalPackage(
-            simulation_actions=[(InvertCellStateBehaviour, {'position': grid_position})],
-        ))
-
-    def on_mouse_motion(self, x, y, dx, dy):
-        x, y = director.get_virtual_coordinates(x, y)
-        grid_position = self.grid_manager.get_grid_position(x, y)
-        window_position = self.grid_manager.get_window_position(grid_position[0], grid_position[1])
-
-        self.cross.position = window_position
-
-
-class LifeGameGui(Gui):
-    def __init__(
-            self,
-            config: Config,
-            logger: SynergineLogger,
-            terminal: Terminal,
-            read_queue_interval: float=1 / 60.0,
-    ):
-        super().__init__(config, logger, terminal, read_queue_interval)
-
-        self.main_layer = MainLayer(terminal=self.terminal)
-        self.main_scene = cocos.scene.Scene(self.main_layer)
-        self.positions = {}
-
-        self.terminal.register_event_handler(CellDieEvent, self.on_cell_die)
-        self.terminal.register_event_handler(CellBornEvent, self.on_cell_born)
-        self.terminal.register_event_handler(
-            EmptyPositionWithLotOfCellAroundEvent,
-            self.on_empty_cell_with_lot_of_cell_around,
-        )
-
-    def get_main_scene(self):
-        return self.main_scene
-
-    def before_received(self, package: TerminalPackage):
-        if package.subjects:  # It's thirst package
-            for subject in package.subjects:
-                if isinstance(subject, Cell):
-                    self.positions[subject.id] = subject.position
-                    self.main_layer.cells.born(subject.position)
-
-        for flash in self.main_layer.cells.flashs[:]:
-            self.main_layer.cells.flashs.remove(flash)
-            self.main_layer.cells.remove(flash)
-
-    def on_cell_die(self, event: CellDieEvent):
-        try:
-            self.main_layer.cells.die(self.positions[event.subject_id])
-        except KeyError:
-            pass
-
-    def on_cell_born(self, event: CellBornEvent):
-        if event.subject_id not in self.terminal.subjects:
-            return
-
-        subject = self.terminal.subjects.get(event.subject_id)
-        self.positions[event.subject_id] = subject.position
-        self.main_layer.cells.born(subject.position)
-
-    def on_empty_cell_with_lot_of_cell_around(self, event: EmptyPositionWithLotOfCellAroundEvent):
-        self.main_layer.cells.flash(event.position)

sandbox/life_game/run.py

@@ -1,158 +0,0 @@
-# coding: utf-8
-import logging
-import os
-import sys
-
-synergine2_ath = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '../../'))
-sys.path.append(synergine2_ath)
-
-import collections
-
-from synergine2.config import Config
-from synergine2.log import get_default_logger
-from sandbox.life_game.simulation import Cell, LifeGame, \
-    EmptyPositionWithLotOfCellAroundEvent
-from sandbox.life_game.simulation import Empty
-from sandbox.life_game.simulation import CellDieEvent
-from sandbox.life_game.simulation import CellBornEvent
-from sandbox.life_game.utils import get_subjects_from_str_representation
-from synergine2.core import Core
-from synergine2.cycle import CycleManager
-from synergine2.simulation import Event
-from synergine2.terminals import Terminal
-from synergine2.terminals import TerminalPackage
-from synergine2.terminals import TerminalManager
-from synergine2_xyz.utils import get_str_representation_from_positions
-
-
-class SimplePrintTerminal(Terminal):
-    subscribed_events = [
-        CellDieEvent,
-        CellBornEvent,
-    ]
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self._cycle_born_count = 0
-        self._cycle_die_count = 0
-        self.register_event_handler(CellDieEvent, self.record_die)
-        self.register_event_handler(CellBornEvent, self.record_born)
-
-    def record_die(self, event: Event):
-        self._cycle_die_count += 1
-
-    def record_born(self, event: Event):
-        self._cycle_born_count += 1
-
-    def receive(self, package: TerminalPackage):
-        self._cycle_born_count = 0
-        self._cycle_die_count = 0
-        super().receive(package)
-        self.print_str_representation()
-
-    def print_str_representation(self):
-        items_positions = collections.defaultdict(list)
-        for subject in self.subjects.values():
-            if type(subject) == Cell:
-                items_positions['1'].append(subject.position)
-            if type(subject) == Empty:
-                items_positions['0'].append(subject.position)
-        print(get_str_representation_from_positions(
-            items_positions,
-            separator=' ',
-            force_items_as=(('0', ' '),),
-            # force_positions_as=(
-            #     ((-3, -10, 0), 'V'),
-            #     ((-2, -9, 0), 'X'),
-            # )
-        ))
-
-        # Display current cycle events
-        print('This cycle: {0} born, {1} dead'.format(
-            self._cycle_born_count,
-            self._cycle_die_count,
-        ))
-
-        print()
-
-
-class CocosTerminal(Terminal):
-    subscribed_events = [
-        CellDieEvent,
-        CellBornEvent,
-        EmptyPositionWithLotOfCellAroundEvent,
-    ]
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.subjects = None
-        self.gui = None
-
-    def receive(self, package: TerminalPackage):
-        self.gui.before_received(package)
-        super().receive(package)
-        self.gui.after_received(package)
-
-    def run(self):
-        from sandbox.life_game import gui
-        self.gui = gui.LifeGameGui(self.config, self.logger, self)
-        self.gui.run()
-
-
-def main():
-    start_str_representation = """
-        0 0 0 0 0 0 0 0 0 0 0 0 0
-        0 0 0 1 1 1 1 0 0 0 0 0 0
-        0 0 0 1 0 0 1 0 0 0 0 0 0
-        0 1 1 1 0 0 1 1 1 0 0 0 0
-        0 1 0 0 0 0 0 0 1 0 0 0 0
-        0 1 0 0 0 0 0 0 1 0 0 0 0
-        0 1 1 1 0 0 1 1 1 0 0 0 0
-        0 0 0 1 0 0 1 0 0 0 0 0 0
-        0 0 0 1 1 1 1 0 0 0 0 0 0
-        0 0 0 0 0 0 0 0 0 0 0 0 0
-        0 0 0 0 0 0 0 0 0 0 0 0 0
-        0 0 0 0 0 0 0 0 0 0 0 0 0
-        0 0 0 0 0 0 0 0 0 0 0 0 0
-        0 0 0 0 0 0 0 0 0 0 0 0 0
-        0 0 0 0 0 1 1 1 0 0 0 0 0
-        0 0 0 0 0 0 0 1 0 0 0 0 0
-        0 0 0 0 0 0 1 0 0 0 0 0 0
-        0 0 0 0 0 0 0 0 0 0 0 0 0
-        0 0 0 0 0 0 0 0 0 0 0 0 0
-    """
-
-    config = Config()
-    config.load_files(['sandbox/life_game/config.yaml'])
-    logger = get_default_logger(level=logging.DEBUG)
-
-    simulation = LifeGame(config)
-    subjects = get_subjects_from_str_representation(
-        start_str_representation,
-        simulation,
-    )
-    simulation.subjects = subjects
-
-    core = Core(
-        config=config,
-        logger=logger,
-        simulation=simulation,
-        cycle_manager=CycleManager(
-            config=config,
-            logger=logger,
-            simulation=simulation,
-        ),
-        terminal_manager=TerminalManager(
-            config=config,
-            logger=logger,
-            terminals=[
-                CocosTerminal(config, logger),
-                SimplePrintTerminal(config, logger),
-            ]
-        ),
-    )
-    core.run()
-
-
-if __name__ == '__main__':
-    main()

sandbox/life_game/simulation.py

@@ -1,189 +0,0 @@
-# coding: utf-8
-from synergine2.simulation import Event
-from synergine2.simulation import SimulationBehaviour
-from synergine2.simulation import Subject, SimulationMechanism
-from synergine2.simulation import SubjectBehaviour
-from synergine2.utils import ChunkManager
-from synergine2_xyz.xyz import ProximityMixin
-from synergine2_xyz.mechanism import ProximitySubjectMechanism
-from synergine2_xyz.simulation import XYZSimulation
-from synergine2_xyz.xyz import XYZSubjectMixin
-from synergine2_xyz.utils import get_around_positions_of_positions, get_min_and_max
-
-COLLECTION_CELL = 'COLLECTION_CELL'  # Collections of Cell type
-
-
-class CellDieEvent(Event):
-    def __init__(self, subject_id, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.subject_id = subject_id
-
-
-class CellBornEvent(Event):
-    def __init__(self, subject_id, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.subject_id = subject_id
-
-
-class EmptyPositionWithLotOfCellAroundEvent(Event):
-    def __init__(self, position, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.position = position
-
-
-class CellProximityMechanism(ProximitySubjectMechanism):
-    distance = 1.41  # distance when on angle
-    feel_collections = [COLLECTION_CELL]
-
-
-class CellAroundAnEmptyPositionMechanism(ProximityMixin, SimulationMechanism):
-    distance = 1.41  # distance when on angle
-    feel_collections = [COLLECTION_CELL]
-    parallelizable = True
-
-    def run(self, process_number: int=None, process_count: int=None):
-        chunk_manager = ChunkManager(process_count)
-        positions = self.simulation.subjects.xyz.keys()
-        min_x, max_x, min_y, max_y, min_z, max_z = get_min_and_max(positions)
-        xs = list(range(min_x, max_x+1))
-        xs_chunks = chunk_manager.make_chunks(xs)
-
-        results = {}
-        for z in range(min_z, max_z+1):
-            for y in range(min_y, max_y+1):
-                for x in xs_chunks[process_number]:
-                    subject_here = self.simulation.subjects.xyz.get((x, y, z))
-                    if not subject_here or isinstance(subject_here, Empty):
-                        subjects = self.get_for_position(
-                            position=(x, y, z),
-                            simulation=self.simulation,
-                        )
-                        results[(x, y, z)] = subjects
-
-        return results
-
-
-class CellDieBehaviour(SubjectBehaviour):
-    use = [CellProximityMechanism]
-
-    def run(self, data):
-        around_count = len(data[CellProximityMechanism])
-        if around_count in [2, 3]:
-            return False
-        # If we return around_count, when around_count is 0,
-        # cycle manager will consider as False
-        return True
-
-    def action(self, data):
-        new_empty = Empty(
-            config=self.config,
-            simulation=self.simulation,
-            position=self.subject.position,
-        )
-        self.simulation.subjects.remove(self.subject)
-        self.simulation.subjects.append(new_empty)
-        return [CellDieEvent(self.subject.id)]
-
-
-class CellBornBehaviour(SubjectBehaviour):
-    use = [CellProximityMechanism]
-
-    def run(self, data):
-        around_count = len(data[CellProximityMechanism])
-        if around_count == 3:
-            return 3
-        return False
-
-    def action(self, data):
-        new_cell = Cell(
-            config=self.config,
-            simulation=self.simulation,
-            position=self.subject.position,
-        )
-
-        positions_to_complete = get_around_positions_of_positions(self.subject.position)
-        for position in positions_to_complete:
-            if position not in self.simulation.subjects.xyz:
-                new_empty = Empty(
-                    config=self.config,
-                    simulation=self.simulation,
-                    position=position,
-                )
-                # Ici on casse le SimplePrintTerminal (car on créer des ligne avec des espaces manquants ?)
-                self.simulation.subjects.append(new_empty)
-
-        self.simulation.subjects.remove(self.subject)
-        self.simulation.subjects.append(new_cell)
-        return [CellBornEvent(new_cell.id)]
-
-
-class InvertCellStateBehaviour(SimulationBehaviour):
-    def run(self, data):
-        pass  # This behaviour is designed to be launch by terminal
-
-    def action(self, data) -> [Event]:
-        position = data['position']
-        cell_at_position = self.simulation.subjects.xyz.get(position, None)
-
-        if not cell_at_position or isinstance(cell_at_position, Empty):
-            new_cell = Cell(
-                config=self.config,
-                simulation=self.simulation,
-                position=position,
-            )
-            if cell_at_position:
-                self.simulation.subjects.remove(cell_at_position)
-            self.simulation.subjects.append(new_cell)
-            return [CellBornEvent(new_cell.id)]
-
-        new_empty = Empty(
-            config=self.config,
-            simulation=self.simulation,
-            position=position,
-        )
-
-        self.simulation.subjects.remove(cell_at_position)
-        self.simulation.subjects.append(new_empty)
-        return [CellDieEvent(new_empty)]
-
-
-class LotOfCellsSignalBehaviour(SimulationBehaviour):
-    use = [CellAroundAnEmptyPositionMechanism]
-
-    def run(self, data):
-        positions = []
-
-        for position, subjects in data[CellAroundAnEmptyPositionMechanism].items():
-            if len(subjects) >= 4:
-                positions.append(position)
-
-        return positions
-
-    @classmethod
-    def merge_data(cls, new_data, start_data=None):
-        start_data = start_data or []
-        start_data.extend(new_data)
-        return start_data
-
-    def action(self, data) -> [Event]:
-        events = []
-
-        for position in data:
-            events.append(EmptyPositionWithLotOfCellAroundEvent(position))
-
-        return events
-
-
-class Cell(XYZSubjectMixin, Subject):
-    collections = Subject.collections[:]
-    collections.extend([COLLECTION_CELL])
-    behaviours_classes = [CellDieBehaviour]
-
-
-class Empty(XYZSubjectMixin, Subject):
-    """Represent empty position where cell can spawn"""
-    behaviours_classes = [CellBornBehaviour]
-
-
-class LifeGame(XYZSimulation):
-    behaviours_classes = [LotOfCellsSignalBehaviour]

sandbox/life_game/utils.py

@@ -1,29 +0,0 @@
-# coding: utf-8
-from sandbox.life_game.simulation import Cell
-from sandbox.life_game.simulation import Empty
-from synergine2.simulation import Simulation
-from synergine2_xyz.subjects import XYZSubjects
-from synergine2_xyz.utils import get_positions_from_str_representation
-
-
-def get_subjects_from_str_representation(
-    str_representations: str,
-    simulation: Simulation,
-) -> [Cell, Empty]:
-    subjects = XYZSubjects(simulation=simulation)
-    items_positions = get_positions_from_str_representation(str_representations)
-    for item, positions in items_positions.items():
-        for position in positions:
-            if item == '0':
-                subjects.append(Empty(
-                    config=simulation.config,
-                    simulation=simulation,
-                    position=position,
-                ))
-            if item == '1':
-                subjects.append(Cell(
-                    config=simulation.config,
-                    simulation=simulation,
-                    position=position,
-                ))
-    return subjects