Add simulated challenges to selected uncleared maps

This commit is contained in:
AttilaNet
2026-11-09 08:11:57 +08:00
parent df0259febf
commit f9631c3363
11 changed files with 628 additions and 47 deletions
+128 -2
View File
@@ -6,6 +6,7 @@ import json
from pathlib import Path
import threading
import time
from types import SimpleNamespace
from .model import Action, Catalog, Planner, Policy, Snapshot, seconds
from .daily import DailyLedger, DailyPolicy, selected_entries
from .sweeping import SweepPolicy, SweepRunner
@@ -19,6 +20,8 @@ from .drop_statistics import reward_text
from .cultivation import CultivationSelector
from .battles import BattleJournal, BattleOrchestrator, CancelledBeforeDispatch, digest, gameplay_response, public_data, value
from .progression import ProgressionIntent, ProgressionPlanner, ProgressionPolicy
from .battle_messages import battle_message
from .maps import stages
def account_serial(method):
@@ -94,6 +97,9 @@ class Engine:
self._commission_planner_available = False
self._commission_offer_reason = ""
self._commission_offer_checks = {}
self._map_challenge_reasons = {}
self._map_reason_snapshot = None
self._map_reason_team = ""
self._progression_records = []
self._progression_error = ""
self._planner_pending = False
@@ -200,6 +206,26 @@ class Engine:
self.battle_journal.save()
def _battle_observer(self, event, intent, response):
if value(intent, "kind") == "map_battle":
stage = SimpleNamespace(stage_id=str(value(intent, "stage_id")), level=str(value(intent, "difficulty")))
key = self.sweeper.key(self.snapshot, stage)
if event == "started":
record = self.battle_journal.pending(self.snapshot)
if record is not None:
record["map_roster_signature"] = self._map_roster_signature(self.snapshot, value(intent, "team", self.sweep_policy.team))
self.sweeper.state["counts"][key] = self.sweeper.used(self.snapshot, stage) + 1
self.sweeper.save()
elif event == "cancelled_before_start":
self.sweeper.state["counts"][key] = max(0, self.sweeper.used(self.snapshot, stage) - 1)
self.sweeper.save()
elif event == "loss":
record = self.battle_journal.pending(self.snapshot) or {}
self.sweeper.state.setdefault("challenge_failures", {})[key] = record.get("map_roster_signature") or self._map_roster_signature(self.snapshot, value(intent, "team", self.sweep_policy.team))
self.sweeper.save()
elif event in ("settled", "event"):
self.sweeper.state.setdefault("challenge_failures", {}).pop(key, None)
self.sweeper.save()
return None
farming = self._is_farm(intent)
if value(intent, "kind") != "progression_battle" and not farming:
return None
@@ -293,6 +319,10 @@ class Engine:
record = self.battle_journal.pending(self.snapshot)
if not self.auto or self._progression_cancel.is_set() or not self.battles.resumable_task_clock(record):
return ""
if record.get("kind") == "map_battle":
intent = {key: record.get(key) for key in ("kind", "task_id", "task_type_id", "step_number",
"stage_id", "difficulty", "battle_kind", "team", "path")}
return self.battles.resume_task_clock(self.client, self.snapshot, intent, self._map_policy(), cancel=self._progression_cancel)
pending = self.progression_planner.pending(self.snapshot) if self.progression_planner else None
if not pending or not isinstance(pending.get("intent"), dict):
return ""
@@ -377,6 +407,7 @@ class Engine:
def _battle_request(self, snapshot, intent, policy, request):
self._ensure_progression()
self._select_battle_runtime(policy.battle_mode)
if self._battle_snapshot_source is not snapshot:
self._battle_snapshot_source = snapshot
self._battle_snapshot_digest = digest(snapshot.raw)
@@ -419,6 +450,8 @@ class Engine:
return value(intent, "kind") in ("sweep", "progression_sweep", "progression_farm_sweep", "progression_map_sweep") or value(intent, "battle_kind") == "sweep"
def _intent_policy(self, intent):
if value(intent, "kind") == "map_battle":
return self._map_policy()
if not self._is_commission(intent):
return self.progression_policy
quest = self.quest_policy
@@ -757,11 +790,14 @@ class Engine:
self._refresh_progression_cache()
if self._progression_pending():
self.pending_hatches = []
pending_map = (self.battle_journal.pending(self.snapshot) or {}).get("kind") == "map_battle"
recovered = self._resume_pending_task_clock() if not self.demo else ""
if recovered:
self.last_executed = True
if not self.battle_journal.pending(self.snapshot):
self.read_snapshot(sync_master=False)
if pending_map:
self.stage_cache.get(self.snapshot, refresh=True)
return self.snapshot, self.plans(), recovered
pending = self.battle_journal.pending(self.snapshot) or {}
return self.snapshot, [], message + ";" + (pending.get("message") or "有待核对的任务 / 战斗,已暂停冲突操作") + ";后台每2分钟自动核对"
@@ -795,6 +831,8 @@ class Engine:
if self.sweeper.statistics_error:
message += ";" + self.sweeper.statistics_error
return self.snapshot, self.plans(), message
if action.kind == "map_challenge":
return self._run_map_challenge(action.payload["intent"])
if action.kind == "buy":
price = int(self.catalog.data["markets"][action.payload["id"]]["money"])
self.purchase_budget.record(self.snapshot.now, price * action.payload["num"], self.policy.daily_buy_money)
@@ -850,6 +888,94 @@ class Engine:
self.battle_journal.update(record, "unknown", message="委托请求结果未确认,禁止自动重试", error_type=type(error).__name__)
raise
def _map_policy(self):
return SimpleNamespace(enabled=self.sweep_policy.enabled and self.sweep_policy.allow_challenge,
team=self.sweep_policy.team, reserve_ti=self.sweep_policy.keep_stamina,
max_money=max(0, int(self.snapshot.raw["master"].get("money") or 0)) if self.snapshot else 0,
allow_items=True, item_reserves=dict(self.quest_policy.item_reserves),
stop_after_loss=0, battle_mode="experimental")
def _map_roster_signature(self, snapshot, team):
selected = next((row for row in snapshot.raw.get("teams", []) if row.get("teamName") == team
and row.get("teamType") == "battleTeam"), {})
ids = {int(mid) for mid in selected.get("monsters", []) if mid and int(mid) > 0}
transient = {"exp", "timeStart", "nicName", "roomId"}
return digest({"team": selected,
"master": {key: val for key, val in snapshot.raw["master"].items() if key == "level" or key.startswith("global")},
"monsters": sorted([{key: val for key, val in mon.items() if key not in transient}
for mon in snapshot.raw.get("monsters", []) if int(mon["id"]) in ids], key=lambda mon: int(mon["id"])),
"attributes": sorted([row for row in snapshot.raw.get("monsterAttributes", []) or [] if int(row.get("monsterId") or 0) in ids],
key=lambda row: int(row["monsterId"]))})
def map_stage_reason(self, snapshot, stage, policy, *, team_ids=None):
"""Lightweight page status; runtime inspection belongs to the account worker."""
if self._progression_pending():
return "有待核对的任务 / 战斗,后台会自动检查"
reason = self.sweeper.reason(snapshot, stage, policy, team_ids=team_ids, challenge=not stage.sweep)
if reason:
return battle_message(reason)
rule = policy.rules.get(stage.stage_id) or {}
if rule.get("enabled") and self.sweeper.used(snapshot, stage) >= max(0, int(rule.get("limit") or 0)):
return "已达本日次数上限"
if stage.sweep:
return ""
if not policy.allow_challenge:
return "未开启未满星时自动挑战"
failed = self.sweeper.state.get("challenge_failures", {}).get(self.sweeper.key(snapshot, stage))
if failed and failed == self._map_roster_signature(snapshot, policy.team):
return "打不过;调整战队或提升魔物属性后自动重试"
if self._map_reason_snapshot is snapshot and self._map_reason_team == policy.team:
return self._map_challenge_reasons.get((stage.stage_id, stage.level), "")
return ""
def _next_map_action(self):
if not self.sweep_policy.enabled or self.demo:
return None
self._map_challenge_reasons = {}
self._map_reason_snapshot, self._map_reason_team = self.snapshot, self.sweep_policy.team
for stage in sorted(stages(self.catalog, self.snapshot), key=lambda row: (row.city, row.number, row.stage_id, row.level)):
rule = self.sweep_policy.rules.get(stage.stage_id) or {}
if not rule.get("enabled") or str(rule.get("level", "3")) != stage.level:
continue
if self.map_stage_reason(self.snapshot, stage, self.sweep_policy):
continue
if stage.sweep:
return Action("sweep", f"扫荡 {stage.number} {stage.name} / 难度{stage.level}", "", {})
self._ensure_progression()
if self.progression_planner.pending(self.snapshot):
self._planner_pending = True
return None
self._select_battle_runtime("experimental")
self._battle_snapshot_digest = digest(self.snapshot.raw)
intent = {"kind": "map_battle", "description": f"挑战 {stage.number} {stage.name} / 难度{stage.level}",
"path": "stageService/stageStart", "task_id": 0, "task_type_id": "", "step_number": 0,
"stage_id": stage.stage_id, "difficulty": int(stage.level), "battle_kind": "ordinary_stage",
"position": f"city{stage.city}_wild_stage{stage.stage_id}_level{stage.level}",
"team": self.sweep_policy.team, "battle_mode": "experimental"}
supported, reason = self._battle_capability(intent)
self._map_challenge_reasons[(stage.stage_id, stage.level)] = battle_message(reason)
if supported:
return Action("map_challenge", intent["description"], "", {"intent": intent})
return None
def _run_map_challenge(self, intent):
stage = next((row for row in stages(self.catalog, self.snapshot) if row.stage_id == str(value(intent, "stage_id"))
and row.level == str(value(intent, "difficulty"))), None)
if stage is None or not self.sweep_policy.enabled or not self.sweep_policy.allow_challenge:
return self.snapshot, self.plans(), "自动挑战已关闭或关卡状态已改变"
reason = self.map_stage_reason(self.snapshot, stage, self.sweep_policy)
if reason:
return self.snapshot, self.plans(), reason
self._ensure_progression()
self._select_battle_runtime("experimental")
message = self.battles.run(self.client, self.snapshot, intent, self._map_policy(),
cancel=self._progression_cancel, ranch=self.policy)
if not self._progression_cancel.is_set():
self.read_snapshot(sync_master=False)
if not self._progression_pending():
self.stage_cache.get(self.snapshot, refresh=True)
return self.snapshot, self.plans(), battle_message(message)
def plans(self):
if self.snapshot is None or self._progression_pending():
self.pending_hatches = []
@@ -868,8 +994,8 @@ class Engine:
self.pending_hatches = self.hatch_planner.hatch_actions(self.snapshot, policy)
left = self.purchase_budget.remaining(self.snapshot.now, policy.daily_buy_money)
daily = [row.action for row in selected_entries(self.catalog, self.snapshot, self.daily_policy, self.daily_ledger)] if self.daily_policy.enabled else []
sweep = self.sweeper.next(self.snapshot, self.sweep_policy) if self.sweep_policy.enabled and not self.demo else None
sweep_actions = [Action(kind="sweep", path="", payload={}, description=f"扫荡 {sweep.number} {sweep.name} / 难度{sweep.level}")] if sweep else []
map_action = self._next_map_action()
sweep_actions = [map_action] if map_action else []
gifts = self.gift_planner.plan(self.snapshot, policy, self.quest_policy)
ranch = self.planner.plan(self.snapshot, policy, left)
self.planner.notes.extend(self.gift_planner.notes)