some refact and engulf bases

sandbox/engulf/gui.py

@@ -0,0 +1,48 @@
+from random import randint
+
+import cocos
+from cocos.sprite import Sprite
+from sandbox.engulf.subject import Cell
+from synergine2.terminals import TerminalPackage
+from synergine2_cocos2d.gui import Gui, GridLayerMixin
+from synergine2_cocos2d.gui import MainLayer as BaseMainLayer
+
+
+class CellsLayer(GridLayerMixin, BaseMainLayer):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.cells = {}
+
+    def born(self, grid_position):
+        cell = Sprite('resources/cell.png')
+        cell.rotation = randint(0, 360)
+        self.grid_manager.scale_sprite(cell)
+        self.grid_manager.position_sprite(cell, grid_position)
+        self.cells[grid_position] = cell
+        self.add(cell)
+
+
+class MainLayer(GridLayerMixin, BaseMainLayer):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.cells = CellsLayer(terminal=kwargs.pop('terminal'))
+        self.add(self.cells)
+
+
+class Game(Gui):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.main_layer = MainLayer(terminal=self.terminal)
+        self.main_scene = cocos.scene.Scene(self.main_layer)
+        self.positions = {}
+
+    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)

sandbox/engulf/run.py

@@ -17,4 +17,83 @@ Engulf is simulation containing:
       * eat: - eat background stuff, + eat subjects
       * alone/not alone: - be alone + not alone
 
-"""
+"""
+from random import randint
+
+from sandbox.engulf.subject import Cell
+from synergine2.core import Core
+from synergine2.cycle import CycleManager
+from synergine2.terminals import TerminalManager, Terminal, TerminalPackage
+from synergine2.xyz import Simulation
+from synergine2.xyz import XYZSubjects
+
+
+class Engulf(Simulation):
+    pass
+
+
+class GameTerminal(Terminal):
+    subscribed_events = []
+
+    def __init__(self):
+        super().__init__()
+        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.engulf import gui
+        self.gui = gui.Game(self)
+        self.gui.run()
+
+
+def get_random_subjects(
+        simulation: Simulation,
+        count: int,
+        x_min: int,
+        y_min: int,
+        x_max: int,
+        y_max: int,
+) -> [Cell]:
+    cells = XYZSubjects(simulation=simulation)
+
+    while len(cells) < count:
+        position = (
+            randint(x_min, x_max+1),
+            randint(y_min, y_max+1),
+            0
+        )
+        if position not in cells.xyz:
+            cells.append(Cell(
+                simulation=simulation,
+                position=position,
+            ))
+
+    return cells
+
+
+def main():
+    simulation = Engulf()
+    subjects = get_random_subjects(
+        simulation,
+        30,
+        -34,
+        -34,
+        34,
+        34,
+    )
+    simulation.subjects = subjects
+
+    core = Core(
+        simulation=simulation,
+        cycle_manager=CycleManager(simulation=simulation),
+        terminal_manager=TerminalManager([GameTerminal()]),
+    )
+    core.run()
+
+
+if __name__ == '__main__':
+    main()

sandbox/engulf/subject.py

@@ -0,0 +1,12 @@
+from synergine2.simulation import Subject
+from synergine2.xyz import XYZSubjectMixin
+
+COLLECTION_CELL = 'CELL'
+COLLECTION_ALIVE = 'ALIVE'
+
+
+class Cell(XYZSubjectMixin, Subject):
+    collections = [
+        COLLECTION_CELL,
+        COLLECTION_ALIVE,
+    ]

sandbox/life_game/gui.py

@@ -5,13 +5,12 @@ 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 sandbox.life_game.simulation import CellBornEvent
-from synergine2.gui import Gui
-from synergine2.terminals import TerminalPackage
 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)
@@ -19,57 +18,11 @@ flash_flash = ScaleBy(8, duration=0.5)
 flash_rotate = RotateBy(360, duration=6)
 
 
-class GridManager(object):
-    def __init__(
-        self,
-        layer: Layer,
-        square_width: int,
-        border: int=0,
-    ):
-        self.layer = layer
-        self.square_width = square_width
-        self.border = border
-
-    @property
-    def final_width(self):
-        return self.square_width + self.border
-
-    def scale_sprite(self, sprite: Sprite):
-        sprite.scale_x = self.final_width / sprite.image.width
-        sprite.scale_y = self.final_width / sprite.image.height
-
-    def position_sprite(self, sprite: Sprite, grid_position):
-        grid_x = grid_position[0]
-        grid_y = grid_position[1]
-        sprite.position = grid_x * self.final_width, grid_y * self.final_width
-
-    def get_window_position(self, grid_position_x, grid_position_y):
-        grid_x = grid_position_x
-        grid_y = grid_position_y
-        return grid_x * self.final_width, grid_y * self.final_width
-
-    def get_grid_position(self, window_x, window_y, z=0) -> tuple:
-        window_size = director.get_window_size()
-
-        window_center_x = window_size[0] // 2
-        window_center_y = window_size[1] // 2
-
-        window_relative_x = window_x - window_center_x
-        window_relative_y = window_y - window_center_y
-
-        real_width = self.final_width * self.layer.scale
-
-        return int(window_relative_x // real_width),\
-               int(window_relative_y // real_width),\
-               z
-
-
-class Cells(Layer):
+class Cells(GridLayerMixin, Layer):
     def __init__(self):
         super().__init__()
         self.cells = {}
         self.flashs = []
-        self.grid_manager = GridManager(self, 32, border=2)
 
     def born(self, grid_position):
         if grid_position in self.cells:
@@ -103,15 +56,11 @@ class Cells(Layer):
         self.add(flash)
 
 
-class MainLayer(ScrollableLayer):
+class MainLayer(GridLayerMixin, BaseMainLayer):
     is_event_handler = True
 
-    def __init__(self, terminal: Terminal):
-        super().__init__()
-
-        self.terminal = terminal
-        self.scroll_step = 100
-        self.grid_manager = GridManager(self, 32, border=2)
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
 
         self.background = Sprite('resources/banner-1711735_640.jpg')
         self.background.position = 0, 0
@@ -131,27 +80,6 @@ class MainLayer(ScrollableLayer):
         window_size = director.get_window_size()
         self.position = window_size[0] // 2, window_size[1] // 2
 
-    def on_key_press(self, key, modifiers):
-        if key == wkey.LEFT:
-            self.position = (self.position[0] + self.scroll_step, self.position[1])
-
-        if key == wkey.RIGHT:
-            self.position = (self.position[0] - self.scroll_step, self.position[1])
-
-        if key == wkey.UP:
-            self.position = (self.position[0], self.position[1] - self.scroll_step)
-
-        if key == wkey.DOWN:
-            self.position = (self.position[0], self.position[1] + self.scroll_step)
-
-        if key == wkey.A:
-            if self.scale >= 0.3:
-                self.scale -= 0.2
-
-        if key == wkey.Z:
-            if self.scale <= 4:
-                self.scale += 0.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)

synergine2/gui.py

@@ -1,32 +0,0 @@
-import cocos
-import pyglet
-
-from synergine2.terminals import Terminal
-from synergine2.terminals import TerminalPackage
-
-
-class Gui(object):
-    def __init__(
-            self,
-            terminal: Terminal,
-            read_queue_interval: float= 1/60.0,
-    ):
-        self._read_queue_interval = read_queue_interval
-        self.terminal = terminal
-        cocos.director.director.init()
-
-    def run(self):
-        pyglet.clock.schedule_interval(
-            lambda *_, **__: self.terminal.read(),
-            self._read_queue_interval,
-        )
-        cocos.director.director.run(self.get_main_scene())
-
-    def get_main_scene(self) -> cocos.cocosnode.CocosNode:
-        raise NotImplementedError()
-
-    def before_received(self, package: TerminalPackage):
-        pass
-
-    def after_received(self, package: TerminalPackage):
-        pass

synergine2_cocos2d/gui.py

@@ -0,0 +1,129 @@
+import cocos
+import pyglet
+from pyglet.window import key as wkey
+from cocos.director import director
+from cocos.layer import ScrollableLayer, Layer
+from cocos.sprite import Sprite
+
+from synergine2.terminals import Terminal
+from synergine2.terminals import TerminalPackage
+
+
+class GridManager(object):
+    def __init__(
+        self,
+        layer: Layer,
+        square_width: int,
+        border: int=0,
+    ):
+        self.layer = layer
+        self.square_width = square_width
+        self.border = border
+
+    @property
+    def final_width(self):
+        return self.square_width + self.border
+
+    def scale_sprite(self, sprite: Sprite):
+        sprite.scale_x = self.final_width / sprite.image.width
+        sprite.scale_y = self.final_width / sprite.image.height
+
+    def position_sprite(self, sprite: Sprite, grid_position):
+        grid_x = grid_position[0]
+        grid_y = grid_position[1]
+        sprite.position = grid_x * self.final_width, grid_y * self.final_width
+
+    def get_window_position(self, grid_position_x, grid_position_y):
+        grid_x = grid_position_x
+        grid_y = grid_position_y
+        return grid_x * self.final_width, grid_y * self.final_width
+
+    def get_grid_position(self, window_x, window_y, z=0) -> tuple:
+        window_size = director.get_window_size()
+
+        window_center_x = window_size[0] // 2
+        window_center_y = window_size[1] // 2
+
+        window_relative_x = window_x - window_center_x
+        window_relative_y = window_y - window_center_y
+
+        real_width = self.final_width * self.layer.scale
+
+        return int(window_relative_x // real_width),\
+               int(window_relative_y // real_width),\
+               z
+
+
+class GridLayerMixin(object):
+    def __init__(self, *args, **kwargs):
+        square_width = kwargs.pop('square_width', 32)
+        square_border = kwargs.pop('square_border', 2)
+        self.grid_manager = GridManager(
+            self,
+            square_width=square_width,
+            border=square_border,
+        )
+        super().__init__(*args, **kwargs)
+
+
+class MainLayer(ScrollableLayer):
+    is_event_handler = True
+
+    def __init__(self, terminal: Terminal, scroll_step: int=100):
+        super().__init__()
+
+        self.terminal = terminal
+        self.scroll_step = scroll_step
+        self.grid_manager = GridManager(self, 32, border=2)
+
+        # 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_key_press(self, key, modifiers):
+        if key == wkey.LEFT:
+            self.position = (self.position[0] + self.scroll_step, self.position[1])
+
+        if key == wkey.RIGHT:
+            self.position = (self.position[0] - self.scroll_step, self.position[1])
+
+        if key == wkey.UP:
+            self.position = (self.position[0], self.position[1] - self.scroll_step)
+
+        if key == wkey.DOWN:
+            self.position = (self.position[0], self.position[1] + self.scroll_step)
+
+        if key == wkey.A:
+            if self.scale >= 0.3:
+                self.scale -= 0.2
+
+        if key == wkey.Z:
+            if self.scale <= 4:
+                self.scale += 0.2
+
+
+class Gui(object):
+    def __init__(
+            self,
+            terminal: Terminal,
+            read_queue_interval: float= 1/60.0,
+    ):
+        self._read_queue_interval = read_queue_interval
+        self.terminal = terminal
+        cocos.director.director.init()
+
+    def run(self):
+        pyglet.clock.schedule_interval(
+            lambda *_, **__: self.terminal.read(),
+            self._read_queue_interval,
+        )
+        cocos.director.director.run(self.get_main_scene())
+
+    def get_main_scene(self) -> cocos.cocosnode.CocosNode:
+        raise NotImplementedError()
+
+    def before_received(self, package: TerminalPackage):
+        pass
+
+    def after_received(self, package: TerminalPackage):
+        pass