Initial project structure: reusable isometric bot engine with D2R implementation

engine/safety/patterns.py

@@ -0,0 +1,73 @@
+"""Behavioral pattern randomization for anti-detection.
+
+Varies bot behavior to avoid detectable patterns like identical
+farming routes, consistent timing, or perfect execution.
+"""
+
+import random
+import logging
+from typing import List, Tuple, Callable, Any
+
+logger = logging.getLogger(__name__)
+
+
+class RouteRandomizer:
+    """Randomizes farming routes and action sequences."""
+    
+    def __init__(self, variation_factor: float = 0.15):
+        self.variation_factor = variation_factor
+    
+    def shuffle_optional_steps(
+        self, steps: List[Any], required_indices: List[int] = None,
+    ) -> List[Any]:
+        """Shuffle non-required steps while keeping required ones in order."""
+        required_indices = set(required_indices or [])
+        required = [(i, s) for i, s in enumerate(steps) if i in required_indices]
+        optional = [s for i, s in enumerate(steps) if i not in required_indices]
+        
+        random.shuffle(optional)
+        
+        result = []
+        opt_iter = iter(optional)
+        req_iter = iter(required)
+        next_req = next(req_iter, None)
+        
+        for i in range(len(steps)):
+            if next_req and next_req[0] == i:
+                result.append(next_req[1])
+                next_req = next(req_iter, None)
+            else:
+                result.append(next(opt_iter))
+        
+        return result
+    
+    def vary_route(
+        self, waypoints: List[Tuple[int, int]],
+    ) -> List[Tuple[int, int]]:
+        """Add slight variations to a route's waypoints."""
+        varied = []
+        for x, y in waypoints:
+            offset_x = int(x * self.variation_factor * random.uniform(-1, 1))
+            offset_y = int(y * self.variation_factor * random.uniform(-1, 1))
+            varied.append((x + offset_x, y + offset_y))
+        return varied
+    
+    def should_skip_optional(self, skip_chance: float = 0.1) -> bool:
+        """Randomly decide to skip an optional action."""
+        return random.random() < skip_chance
+
+
+class ActionVariator:
+    """Varies how actions are performed."""
+    
+    @staticmethod
+    def vary_count(target: int, variance: int = 1) -> int:
+        """Vary a repeat count (e.g., click 2-4 times instead of always 3)."""
+        return max(1, target + random.randint(-variance, variance))
+    
+    @staticmethod
+    def random_order(actions: List[Callable]) -> List[Callable]:
+        """Randomize the order of independent actions."""
+        shuffled = actions.copy()
+        random.shuffle(shuffled)
+        return shuffled