engulf: limited exp zone

sandbox/engulf/behaviour.py

 from random import choice
 
 from sandbox.engulf.const import COLLECTION_GRASS
+from sandbox.engulf.exceptions import NotFoundWhereToGo
 from synergine2.simulation import SubjectBehaviour, SimulationMechanism, SimulationBehaviour, SubjectBehaviourSelector
 from synergine2.simulation import Event
 from synergine2.utils import ChunkManager
         return True  # for now, want move every time
 
     def action(self, data) -> [Event]:
-        direction = self.get_random_direction()
-        position = get_position_for_direction(self.subject.position, direction)
-        self.subject.position = position
-        self.subject.previous_direction = direction
-
-        return [MoveTo(self.subject.id, position)]
+        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:

sandbox/engulf/run.py

       * alone/not alone: - be alone + not alone
 
 """
+import logging
 import os
 import sys
 
-import logging
-
 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, GrassSpawnBehaviour, MoveTo, EatEvent
+from sandbox.engulf.behaviour import GrassGrownUp, GrassSpawn, MoveTo, EatEvent
 
 from synergine2.config import Config
 from synergine2.log import get_default_logger
 from sandbox.engulf.subject import Cell, Grass
-from sandbox.engulf.const import COLLECTION_GRASS
 from synergine2.core import Core
 from synergine2.cycle import CycleManager
 from synergine2.terminals import TerminalManager, Terminal, TerminalPackage
-from synergine2.xyz import XYZSimulation
-from sandbox.engulf.simulation import EngulfSubjects
+from sandbox.engulf.simulation import EngulfSubjects, Engulf
 from synergine2.xyz_utils import get_around_positions_of, get_distance_between_points
 
 
-class Engulf(XYZSimulation):
-    behaviours_classes = [
-        GrassSpawnBehaviour,
-    ]
-
-
 class GameTerminal(Terminal):
     subscribed_events = [
         GrassGrownUp,

sandbox/engulf/simulation.py

 # coding: utf-8
+from sandbox.engulf.behaviour import GrassSpawnBehaviour
 from sandbox.engulf.subject import Cell, Grass
-from synergine2.xyz import XYZSubjects, XYZSubjectMixin
+from synergine2.xyz import XYZSubjects, XYZSubjectMixin, XYZSimulation
 
 __author__ = 'bux'
 
 
         if isinstance(p_object, Grass):
             self.grass_xyz[p_object.position] = 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

synergine2/xyz.py

         if self.have_to_check_position_is_possible() \
            and not self.simulation.is_possible_subject_position(p_object, p_object.position):
             raise PositionNotPossible('Position {} for {} is not possible'.format(
-                p_object.position,
-                p_object,
+                str(p_object.position),
+                str(p_object),
             ))
 
         self.xyz[p_object.position] = p_object