Create engine/time_manager.py

engine/time_manager.py

@@ -0,0 +1,84 @@
+"""
+Time Manager for Nexus-Core
+Simplified adaptive time control
+"""
+
+import time
+from typing import Optional
+
+
+class TimeManager:
+    """Adaptive time allocation for searches"""
+    
+    def __init__(self):
+        self.start_time = 0.0
+        self.allocated_time = 0.0
+        self.hard_limit = 0.0
+        self.move_overhead = 0.050  # 50ms overhead
+    
+    def allocate_time(
+        self,
+        time_left: float,
+        increment: float = 0.0,
+        moves_to_go: Optional[int] = None,
+        move_number: int = 1
+    ) -> tuple[float, float]:
+        """Calculate time allocation"""
+        
+        # Emergency reserve
+        emergency_reserve = min(2.0, time_left * 0.1)
+        available_time = max(0, time_left - emergency_reserve - self.move_overhead)
+        
+        # Estimate moves remaining
+        if moves_to_go:
+            expected_moves = moves_to_go
+        else:
+            expected_moves = max(20, 40 - move_number // 2)
+        
+        # Base allocation
+        base_time = available_time / expected_moves
+        increment_bonus = increment * 0.8
+        
+        # Soft limit
+        soft_limit = base_time + increment_bonus
+        
+        # Hard limit (3x soft or 50% remaining)
+        hard_limit = min(
+            soft_limit * 3.0,
+            available_time * 0.5
+        )
+        
+        # Minimums
+        soft_limit = max(soft_limit, 0.1)
+        hard_limit = max(hard_limit, soft_limit)
+        
+        return soft_limit, hard_limit
+    
+    def start_search(self, allocated_time: float, hard_limit: float):
+        """Initialize timer"""
+        self.start_time = time.time()
+        self.allocated_time = allocated_time
+        self.hard_limit = hard_limit
+    
+    def should_stop(self, depth: int, best_move_stable: bool = False) -> bool:
+        """Check if should stop"""
+        elapsed = time.time() - self.start_time
+        
+        # Hard limit
+        if elapsed >= self.hard_limit:
+            return True
+        
+        # Soft limit with stable move
+        if elapsed >= self.allocated_time:
+            if best_move_stable or depth >= 4:
+                return True
+        
+        return False
+    
+    def elapsed(self) -> float:
+        """Get elapsed time"""
+        return time.time() - self.start_time
+    
+    def remaining(self) -> float:
+        """Get remaining time"""
+        return max(0, self.allocated_time - self.elapsed())