"""Desktop scheduling semantics without Qt timers or concurrent Engine access.""" from __future__ import annotations import logging import math import random import threading import time FAST_KINDS = ("hatch", "gift", "explore", "breakthrough") logger = logging.getLogger(__name__) class AccountSchedule: """Deadlines belong to one worker and are inspected only on its thread.""" def __init__(self, *, clock=time.monotonic, uniform=random.uniform, wall_clock=time.time): self.clock, self.uniform = clock, uniform self.wall_clock = wall_clock self.next_poll = math.inf self._poll_deferred = False self.next_fast = {kind: math.inf for kind in FAST_KINDS} self.monitoring = False self.last_maintenance_error = {} self.game_paused = False self.retry_deadline = None self.retry_attempt = 0 self.disconnected_at = None self.disconnected_wall_at = None self.auto_relogin_failed_at = None def disconnected(self): # Read retries and settings changes must not move the first failure. if self.disconnected_at is None: self.disconnected_at = self.clock() self.disconnected_wall_at = self.wall_clock() def clear_disconnection(self): self.disconnected_at = self.disconnected_wall_at = None self.auto_relogin_failed_at = None def auto_relogin_deadline(self, config): preference = config.get("auto_relogin", {}) if not preference.get("enabled") or self.disconnected_at is None: return None origin = max(self.disconnected_at, self.auto_relogin_failed_at if self.auto_relogin_failed_at is not None else self.disconnected_at) return origin + preference.get("delay_minutes", 30) * 60 def auto_relogin_failed(self): # Back off from completion, including time spent authenticating. self.auto_relogin_failed_at = self.clock() def game_failed(self, *, retry=False): self.game_paused = True self.stop() self.retry_deadline = None if retry: self.retry_attempt += 1 delay = min(5 * 2 ** min(self.retry_attempt - 1, 4), 60) self.retry_deadline = self.clock() + delay return delay def game_resumed(self, *, clear_disconnection=True): """Resume monitored reads; the service decides if outage evidence clears.""" was_paused = self.game_paused self.game_paused = False self.retry_deadline = None self.retry_attempt = 0 if clear_disconnection: self.clear_disconnection() if self.monitoring and (was_paused or self.next_poll == math.inf): self.next_poll = min(self.next_poll, self.clock()) def monitor(self, enabled=True): self.monitoring = bool(enabled) self.next_poll = self.clock() if enabled else math.inf self._poll_deferred = False def stop(self): for kind in FAST_KINDS: self.next_fast[kind] = math.inf def poll_finished(self, config): self.next_poll = self.clock() + self.uniform(0, config.get("interval", 30)) self._poll_deferred = False def maintenance_failed(self, kind): self.last_maintenance_error[kind] = self.clock() def arm(self, engine, config, running, plans=(), *, completed=None): if completed in self.next_fast: self.next_fast[completed] = math.inf snapshot = engine.snapshot if not self.monitoring or self.game_paused or not running or snapshot is None: self.stop() return now = self.clock() policy = config.get("policy", {}) pending = bool(engine._progression_pending() or engine.explore_planner.pending(snapshot) or engine._breakthrough_pending) delays = {} if not pending: if policy.get("enabled") and policy.get("fill") and engine.pending_hatches: delays["hatch"] = self.uniform(1, 2) ready_at = engine.gift_planner.next_ready_at if policy.get("gift_enabled") and ready_at is not None: delays["gift"] = max(0, ready_at - snapshot.now) if any(action.path and (action.kind == "explore_finish" or action.kind == "explore_start" and config.get("explore_policy", {}).get("enabled")) for action in plans): delays["explore"] = 1.0 for team in snapshot.raw.get("exploreTeams") or []: if isinstance(team, dict) and team.get("status") in (1, "1"): remaining = engine.explore_planner.remaining(snapshot, team) if remaining is not None: delays["explore"] = min(delays.get("explore", math.inf), max(1.0, remaining + 1)) if policy.get("breakthrough_targets") and any(action.path and action.kind in ("potential", "breakthrough") for action in plans): delays["breakthrough"] = 1.0 for kind in FAST_KINDS: if kind not in delays: self.next_fast[kind] = math.inf elif self.next_fast[kind] == math.inf: self.next_fast[kind] = now + delays[kind] def due(self, engine, config, running): now = self.clock() deadline = self.auto_relogin_deadline(config) if deadline is not None and now >= deadline: return "auto_relogin" if self.game_paused: return "retry" if self.retry_deadline is not None and now >= self.retry_deadline else None def allowed(kind): return now - self.last_maintenance_error.get(kind, -math.inf) >= 30 poll_due = self.monitoring and now >= self.next_poll and allowed("poll") if not poll_due: self._poll_deferred = False elif self._poll_deferred: return "poll" def before_poll(kind): # Preserve maintenance/hatch priority once, then give an overdue # snapshot its turn even if the preceding work remains due. if poll_due: self._poll_deferred = True return kind connected = not engine.demo and engine.client is not None and engine.snapshot is not None if connected and engine.heartbeat_enabled and now - engine.last_heartbeat >= 240 and allowed("heartbeat"): return before_poll("heartbeat") if connected and self.monitoring and engine.pending_recovery_due() and allowed("reconcile"): return before_poll("reconcile") if connected and engine.heartbeat_enabled and engine.master_sync_due() and allowed("master_sync"): return before_poll("master_sync") if connected and engine.heartbeat_enabled and engine.growth_sync_due() and allowed("growth_sync"): return before_poll("growth_sync") if self.monitoring and running and now >= self.next_fast["hatch"] and allowed("hatch"): return before_poll("hatch") if poll_due: return "poll" if self.monitoring and running: for kind in ("gift", "explore", "breakthrough"): if now >= self.next_fast[kind] and allowed(kind): return kind return None class Scheduler: """Ask idle account queues to tick; never call an Engine from this thread.""" def __init__(self, workers, *, interval=0.2): self.workers = workers self.interval = interval self.closed = threading.Event() self.thread = threading.Thread(target=self._run, name="ranch-web-scheduler", daemon=True) self.thread.start() def _run(self): while not self.closed.wait(self.interval): try: for worker in self.workers(): try: worker.request_tick() except Exception: logger.exception("Unable to request account tick; continuing other accounts") except Exception: logger.exception("Unable to enumerate account workers; retrying next scheduler pass") def close(self): self.closed.set() if threading.current_thread() is not self.thread: self.thread.join(timeout=2)