XYZ dev and working life game bases

sandbox/life_game/__init__.py

@@ -0,0 +1 @@
+__author__ = 'bux'

sandbox/life_game/simulation.py

@@ -0,0 +1,58 @@
+from synergine2.simulation import Subject
+from synergine2.simulation import Behaviour
+from synergine2.xyz import ProximityMechanism
+from synergine2.xyz import XYZSubjectMixin
+
+COLLECTION_CELL = 'COLLECTION_CELL'  # Collections of Cell type
+
+
+class CellProximityMechanism(ProximityMechanism):
+    distance = 1.41  # distance when on angle
+    feel_collections = [COLLECTION_CELL]
+
+
+class CellDieBehaviour(Behaviour):
+    use = [CellProximityMechanism]
+
+    def run(self, data):
+        around_count = len(data[CellProximityMechanism])
+        if around_count in [2, 3]:
+            return False
+        return True  # If we return around_count, when around_count is 0
+
+    def action(self, data):
+        new_empty = Empty(
+            simulation=self.simulation,
+            position=self.subject.position,
+        )
+        self.simulation.subjects.remove(self.subject)
+        self.simulation.subjects.append(new_empty)
+
+
+class CellBornBehaviour(Behaviour):
+    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(
+            simulation=self.simulation,
+            position=self.subject.position,
+        )
+        self.simulation.subjects.remove(self.subject)
+        self.simulation.subjects.append(new_cell)
+
+
+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]

synergine2/cycle.py

@@ -0,0 +1,66 @@
+import multiprocessing
+
+from synergine2.processing import ProcessManager
+from synergine2.simulation import Subject, Behaviour, Mechanism
+from synergine2.utils import ChunkManager
+
+
+class CycleManager(object):
+    def __init__(
+            self,
+            subjects: list,
+            process_manager: ProcessManager=None,
+    ):
+        if process_manager is None:
+            process_manager = ProcessManager(
+                process_count=multiprocessing.cpu_count(),
+                chunk_manager=ChunkManager(multiprocessing.cpu_count()),
+                job_maker=self.computing,
+            )
+
+        self.subjects = subjects
+        self._process_manager = process_manager
+        self._current_cycle = 0
+
+    def next(self):
+        results = {}
+        results_by_processes = self._process_manager.execute_jobs(self.subjects)
+        for process_results in results_by_processes:
+            results.update(process_results)
+        for subject in self.subjects[:]:  # Duplicate list to prevent conflicts with behaviours subjects manipulations
+            for behaviour_class in results[subject.id]:
+                # TODO: Ajouter une etape de selection des actions a faire (genre neuronnal)
+                # TODO: les behaviour_class ont le même uniqueid apres le process ?
+                subject.behaviours[behaviour_class].action(results[subject.id][behaviour_class])
+
+    def computing(self, subjects):
+        # compute mechanisms (prepare check to not compute slienced or not used mechanisms)
+        # compute behaviours with mechanisms data
+        # return list with per subject: [behaviour: return, behaviour: return] if behaviour return True something
+        results = {}
+        for subject in subjects:
+            mechanisms = self.get_mechanisms_to_compute(subject)
+            mechanisms_data = {}
+            behaviours_data = {}
+
+            for mechanism in mechanisms:
+                mechanisms_data[type(mechanism)] = mechanism.run()
+
+            for behaviour in self.get_behaviours_to_compute(subject):
+                # We identify behaviour data with it's class to be able to intersect it after subprocess data collect
+                behaviour_data = behaviour.run(mechanisms_data)
+                if behaviour_data:
+                    behaviours_data[type(behaviour)] = behaviour_data
+
+            results[subject.id] = behaviours_data
+            # TODO: Tester les performances si on utilise un index numerique pour les results[subject]
+            # et behaviours_data[type(behaviours_data)]
+        return results
+
+    def get_mechanisms_to_compute(self, subject: Subject) -> [Mechanism]:
+        # TODO: Implementer un systeme qui inhibe des mechanisme (ex. someil inhibe l'ouie)
+        return subject.mechanisms.values()
+
+    def get_behaviours_to_compute(self, subject: Subject) -> [Behaviour]:
+        # TODO: Implementer un systeme qui inhibe des behaviours (ex. someil inhibe avoir faim)
+        return subject.behaviours.values()

synergine2/simulation.py

@@ -0,0 +1,89 @@
+import collections
+
+from synergine2.utils import initialize_subject
+
+
+class Simulation(object):
+    def __init__(self):
+        self.collections = collections.defaultdict(list)
+        self._subjects = None
+
+    @property
+    def subjects(self):
+        return self._subjects
+
+    @subjects.setter
+    def subjects(self, value: 'Subjects'):
+        if not isinstance(value, Subjects):
+            raise Exception('Simulation.subjects must be Subjects type')
+        self._subjects = value
+
+
+class Subject(object):
+    collections = []
+    behaviours_classes = []
+
+    def __init__(self, simulation: Simulation):
+        self.id = id(self)  # We store object id because it's lost between process
+        self.simulation = simulation
+        self.behaviours = {}
+        self.mechanisms = {}
+
+        for collection in self.collections:
+            self.simulation.collections[collection].append(self)
+
+        initialize_subject(
+            simulation=simulation,
+            subject=self,
+        )
+
+
+class Subjects(list):
+    def __init__(self, *args, **kwargs):
+        self.simulation = kwargs.pop('simulation')
+        super().__init__(*args, **kwargs)
+
+    def remove(self, value: Subject):
+        super().remove(value)
+        for collection_name in value.collections:
+            self.simulation.collections[collection_name].remove(value)
+
+
+class Mechanism(object):
+    def __init__(
+            self,
+            simulation: Simulation,
+            subject: Subject,
+    ):
+        self.simulation = simulation
+        self.subject = subject
+
+    def run(self):
+        raise NotImplementedError()
+
+
+class Behaviour(object):
+    def __init__(
+            self,
+            simulation: Simulation,
+            subject: Subject,
+    ):
+        self.simulation = simulation
+        self.subject = subject
+
+    def run(self, data):
+        """
+        Method called in subprocess.
+        If return equivalent to False, behaviour produce nothing.
+        If return equivalent to True, action bahaviour method
+        will be called with these data
+        Note: Returned data will be transfered from sub processes.
+              Prefer scalar types.
+        """
+        raise NotImplementedError()
+
+    def action(self, data):
+        """
+        Method called in main process
+        """
+        raise NotImplementedError()

synergine2/utils.py

@@ -10,3 +10,27 @@ class ChunkManager(object):
             a, j = j, j + (i + k) // self._chunks_numbers
             x.append(data[a:j])
         return x
+
+
+def get_mechanisms_classes(subject: 'Subject') -> ['Mechanisms']:
+    mechanisms_classes = []
+    for behaviour_class in subject.behaviours_classes:
+        mechanisms_classes.extend(behaviour_class.use)
+    return list(set(mechanisms_classes))  # Remove duplicates
+
+
+def initialize_subject(
+        simulation: 'Simulation',
+        subject: 'Subject',
+) -> None:
+    for mechanism_class in get_mechanisms_classes(subject):
+        subject.mechanisms[mechanism_class] = mechanism_class(
+            simulation=simulation,
+            subject=subject,
+        )
+
+    for behaviour_class in subject.behaviours_classes:
+        subject.behaviours[behaviour_class] = behaviour_class(
+            simulation=simulation,
+            subject=subject,
+        )

synergine2/xyz.py

@@ -0,0 +1,110 @@
+from math import sqrt
+from math import degrees
+from math import acos
+
+from synergine2.simulation import Mechanism
+from synergine2.simulation import Simulation as BaseSimulation
+
+
+"""
+
+Positions are exprimed as tuple: (x, y, z) Considering start point at top left:
+
+    Z
+   #
+  #
+ #
+#-------------> X
+|.
+| .
+|  .
+|
+Y
+"""
+
+COLLECTION_XYZ = 'COLLECTION_XYZ'
+
+
+def get_distance_between_points(a: tuple, b: tuple) -> float:
+    return abs(sqrt((b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2))
+
+
+def get_degree_from_north(a, b):
+    if a == b:
+        return 0
+
+    ax, ay = a[0], a[1]
+    bx, by = b[0], b[1]
+    Dx, Dy = ax, ay - 1
+    ab = sqrt((bx - ax) ** 2 + (by - ay) ** 2)
+    aD = sqrt((Dx - ax) ** 2 + (Dy - ay) ** 2)
+    Db = sqrt((bx - Dx) ** 2 + (by - Dy) ** 2)
+
+    degs = degrees(acos((ab ** 2 + aD ** 2 - Db ** 2) / (2 * ab * aD)))
+    if bx < ax:
+        return 360 - degs
+    return degs
+
+
+class XYZSubjectMixinMetaClass(type):
+    def __init__(cls, name, parents, attribs):
+        super().__init__(name, parents, attribs)
+        collections = getattr(cls, "collections", [])
+        if COLLECTION_XYZ not in collections:
+            collections.append(COLLECTION_XYZ)
+
+
+class XYZSubjectMixin(object, metaclass=XYZSubjectMixinMetaClass):
+    def __init__(self, *args, **kwargs):
+        """
+        :param position: tuple with (x, y, z)
+        """
+        self.position = kwargs.pop('position')
+        super().__init__(*args, **kwargs)
+
+
+class ProximityMechanism(Mechanism):
+    distance = 1
+    feel_collections = [COLLECTION_XYZ]
+    direction_round_decimals = 0
+    distance_round_decimals = 2
+
+    def run(self):
+        subjects = []
+        for feel_collection in self.feel_collections:
+            for subject in self.simulation.collections.get(feel_collection, []):
+                if subject == self.subject:
+                    continue
+
+                distance = round(
+                    self.get_distance_of(subject),
+                    self.distance_round_decimals,
+                )
+                if subject != self.subject and distance <= self.distance:
+                    direction = round(
+                        get_degree_from_north(
+                            self.subject.position,
+                            subject.position,
+                        ),
+                        self.direction_round_decimals,
+                    )
+                    subjects.append({
+                        'subject': subject,
+                        'direction': direction,
+                        'distance': distance,
+                    })
+
+        return subjects
+
+    def get_distance_of(self, subject: XYZSubjectMixin):
+        return get_distance_between_points(
+            self.subject.position,
+            subject.position,
+        )
+
+
+class Simulation(BaseSimulation):
+    """
+    TODO: xyz properties
+    """
+    pass

synergine2/xyz_utils.py

@@ -0,0 +1,88 @@
+import collections
+
+
+def get_positions_from_str_representation(str_representation):
+    # TODO: Manage z axis (like ------------ as separator)
+    lines = str_representation.split("\n")  # One item per lines
+    lines = map(lambda l: l.strip().replace(' ', ''), lines)  # Remove spaces
+    lines = filter(lambda l: bool(l), lines)  # Only line with content
+    lines = list(lines)
+
+    width = len(lines[0])
+    height = len(lines)
+
+    if not width % 2 or not height % 2:
+        raise Exception(
+            'Width and height of your representation must be odd. '
+            'Actually it\'s {0}x{1}'.format(
+                width,
+                height,
+            ))
+
+    items_positions = collections.defaultdict(list)
+
+    start_x = - int(width / 2 - 0.5)
+    start_y = - int(height / 2 - 0.5)
+    start_z = 0
+
+    current_y = start_y
+    current_z = start_z
+
+    for line in lines:
+        current_x = start_x
+        for char in line:
+            items_positions[char].append((
+                current_x,
+                current_y,
+                current_z,
+            ))
+            current_x += 1
+        current_y += 1
+
+    return items_positions
+
+
+def get_str_representation_from_positions(
+    items_positions: dict,
+    separator='',
+    tabulation='',
+    start_with='',
+    end_with='',
+) -> str:
+    positions = []
+    for item_positions in items_positions.values():
+        positions.extend(item_positions)
+    positions = sorted(positions, key=lambda p: (p[2], p[1], p[0]))
+
+    str_representation = start_with + tabulation
+
+    start_x = positions[0][0]
+    start_y = positions[0][1]
+    start_z = positions[0][2]
+
+    current_y = start_y
+    current_z = start_z
+
+    for position in positions:
+        item = None
+        for parsed_item in items_positions:
+            if position in items_positions[parsed_item]:
+                item = parsed_item
+                break
+
+        if position[1] != current_y:
+            str_representation += "\n" + tabulation
+
+        if position[2] != current_z:
+            str_representation += '----' + "\n" + tabulation
+
+        added_value = item
+        if position[0] != start_x:
+            added_value = separator + added_value
+
+        str_representation += added_value
+        current_y = position[1]
+        current_z = position[2]
+
+    return str_representation + end_with
+

tests/__init__.py

@@ -1,4 +1,12 @@
 
+# Used as parameters of str representations
+str_kwargs = dict(
+    separator=' ',
+    tabulation='            ',
+    start_with="\n",
+    end_with='\n        ',
+)
+
 
 class BaseTest(object):
     pass

tests/test_life_game.py

@@ -0,0 +1,93 @@
+import collections
+from sandbox.life_game.simulation import Cell, Empty
+from synergine2.cycle import CycleManager
+from synergine2.simulation import Simulation, Subjects
+from synergine2.utils import initialize_subject
+from synergine2.xyz_utils import get_str_representation_from_positions
+from tests import BaseTest, str_kwargs
+
+
+class TestSimpleSimulation(BaseTest):
+    def test_cycles_evolution(self):
+        simulation = Simulation()
+        subjects = self._get_subjects(simulation)
+        simulation.subjects = subjects
+
+        cycle_manager = CycleManager(
+            subjects=subjects,
+        )
+
+        assert """
+            0 0 0 0 0
+            0 1 1 1 0
+            0 0 0 0 0
+        """ == self._get_str_representation_of_subjects(
+            subjects,
+        )
+
+        cycle_manager.next()
+
+        assert """
+            0 0 1 0 0
+            0 0 1 0 0
+            0 0 1 0 0
+        """ == self._get_str_representation_of_subjects(
+            subjects,
+        )
+
+        cycle_manager.next()
+
+        assert """
+            0 0 0 0 0
+            0 1 1 1 0
+            0 0 0 0 0
+        """ == self._get_str_representation_of_subjects(
+            subjects,
+        )
+
+    def _get_subjects(self, simulation: Simulation):
+        cells = Subjects(simulation=simulation)
+
+        for position in [
+            (-1, 0, 0),
+            (0, 0, 0),
+            (1, 0, 0),
+        ]:
+            cells.append(Cell(
+                simulation=simulation,
+                position=position,
+            ))
+
+        for position in [
+            (-2, -1, 0),
+            (-1, -1, 0),
+            (0, -1, 0),
+            (1, -1, 0),
+            (2, -1, 0),
+            (-2, 0, 0),
+            (2, 0, 0),
+            (-2, 1, 0),
+            (-1, 1, 0),
+            (0, 1, 0),
+            (1, 1, 0),
+            (2, 1, 0),
+        ]:
+            cells.append(Empty(
+                simulation=simulation,
+                position=position,
+            ))
+        return cells
+
+    def _get_str_representation_of_subjects(self, subjects: list):
+        items_positions = collections.defaultdict(list)
+
+        for subject in subjects:
+            if type(subject) == Cell:
+                items_positions['1'].append(subject.position)
+            if type(subject) == Empty:
+                items_positions['0'].append(subject.position)
+
+        return get_str_representation_from_positions(
+            items_positions,
+            **str_kwargs
+        )

tests/test_xyz.py

@@ -0,0 +1,212 @@
+# -*- coding: utf-8 -*-
+from synergine2.simulation import Subject
+from synergine2.simulation import Subjects
+from synergine2.simulation import Simulation
+from synergine2.xyz import ProximityMechanism
+from synergine2.xyz import XYZSubjectMixin
+from synergine2.xyz_utils import get_positions_from_str_representation
+from synergine2.xyz_utils import get_str_representation_from_positions
+from tests import BaseTest
+from tests import str_kwargs
+
+
+class MySubject(XYZSubjectMixin, Subject):
+    pass
+
+
+class MyProximityMechanism(ProximityMechanism):
+    distance = 10
+
+
+class TestXYZ(BaseTest):
+    def test_proximity_mechanism_with_one(self):
+        simulation = Simulation()
+        subject = MySubject(simulation, position=(0, 0, 0))
+        other_subject = MySubject(simulation, position=(5, 0, 0))
+
+        simulation.subjects = Subjects(
+            [subject, other_subject],
+            simulation=simulation,
+        )
+
+        proximity_mechanism = MyProximityMechanism(
+            simulation=simulation,
+            subject=subject,
+        )
+
+        assert 5 == proximity_mechanism.get_distance_of(other_subject)
+        assert [{
+            'subject': other_subject,
+            'direction': 90.0,
+            'distance': 5.0,
+        }] == proximity_mechanism.run()
+
+    def test_proximity_mechanism_excluding(self):
+        simulation = Simulation()
+        subject = MySubject(simulation, position=(0, 0, 0))
+        other_subject = MySubject(simulation, position=(11, 0, 0))
+
+        simulation.subjects = Subjects(
+            [subject, other_subject],
+            simulation=simulation,
+        )
+
+        proximity_mechanism = MyProximityMechanism(
+            simulation=simulation,
+            subject=subject,
+        )
+
+        assert 11 == proximity_mechanism.get_distance_of(other_subject)
+        # other_subject is to far away
+        assert [] == proximity_mechanism.run()
+
+    def test_proximity_mechanism_with_multiple(self):
+        simulation = Simulation()
+        subject = MySubject(simulation, position=(0, 0, 0))
+        other_subjects = []
+
+        for i in range(3):
+            other_subjects.append(MySubject(simulation, position=(i, i, 0)))
+
+        simulation.subjects = Subjects([subject], simulation=simulation)
+        simulation.subjects.extend(other_subjects)
+
+        proximity_mechanism = MyProximityMechanism(
+            simulation=simulation,
+            subject=subject,
+        )
+
+        data = proximity_mechanism.run()
+        assert [
+            {
+                'direction': 0,
+                'subject': other_subjects[0],
+                'distance': 0.0,
+            },
+            {
+                'direction': 135.0,
+                'subject': other_subjects[1],
+                'distance': 1.41
+            },
+            {
+                'direction': 135.0,
+                'subject': other_subjects[2],
+                'distance': 2.83
+            },
+        ] == data
+
+    def test_str_representation_from_str(self):
+        str_ = """
+            0 0 1 0 0
+            0 1 1 1 0
+            0 0 1 0 0
+        """
+        items_positions = {
+            '0': [
+                (-2, -1, 0),
+                (-1, -1, 0),
+                (1, -1, 0),
+                (2, -1, 0),
+                (-2, 0, 0),
+                (2, 0, 0),
+                (-2, 1, 0),
+                (-1, 1, 0),
+                (1, 1, 0),
+                (2, 1, 0),
+            ],
+            '1': [
+                (0, -1, 0),
+                (-1, 0, 0),
+                (0, 0, 0),
+                (1, 0, 0),
+                (0, 1, 0),
+            ],
+        }
+        assert items_positions == get_positions_from_str_representation(str_)
+
+    def test_str_representation_to_str(self):
+        expected = """
+            0 0 1 0 0
+            0 1 1 1 0
+            0 0 1 0 0
+        """
+        items_positions = {
+            '0': [
+                (-2, -1, 0),
+                (-1, -1, 0),
+                (1, -1, 0),
+                (2, -1, 0),
+                (-2, 0, 0),
+                (2, 0, 0),
+                (-2, 1, 0),
+                (-1, 1, 0),
+                (1, 1, 0),
+                (2, 1, 0),
+            ],
+            '1': [
+                (0, -1, 0),
+                (-1, 0, 0),
+                (0, 0, 0),
+                (1, 0, 0),
+                (0, 1, 0),
+            ],
+        }
+
+        assert expected == \
+            get_str_representation_from_positions(
+                items_positions,
+                **str_kwargs
+            )
+
+    def test_str_representation_to_str_multi_levels(self):
+        expected = """
+            0 0 1 0 0
+            0 1 1 1 0
+            0 0 1 0 0
+            ----
+            0 0 0 0 0
+            0 0 1 0 0
+            0 0 0 0 0
+        """
+        items_positions = {
+            '0': [
+                (-2, -1, 0),
+                (-1, -1, 0),
+                (1, -1, 0),
+                (2, -1, 0),
+                (-2, 0, 0),
+                (2, 0, 0),
+                (-2, 1, 0),
+                (-1, 1, 0),
+                (1, 1, 0),
+                (2, 1, 0),
+                (-2, -1, 1),
+                (-1, -1, 1),
+                (1, -1, 1),
+                (2, -1, 1),
+                (-1, 0, 1),
+                (-2, 0, 1),
+                (2, 0, 1),
+                (-2, 1, 1),
+                (-1, 1, 1),
+                (1, 1, 1),
+                (2, 1, 1),
+                (2, -1, 1),
+                (1, 0, 1),
+                (2, 1, 1),
+            ],
+            '1': [
+                (0, -1, 0),
+                (-1, 0, 0),
+                (0, 0, 0),
+                (1, 0, 0),
+                (0, 1, 0),
+                (0, 0, 1),
+            ],
+        }
+
+        assert expected == \
+            get_str_representation_from_positions(
+                items_positions,
+                **str_kwargs
+            )