Use bag instance IDs required by the client protocol. Apply confirmed feel and giftDate values across stale queries, skip cooling targets, and schedule ready gifts independently of random polling. Replan cultivation locally and retain local strategy errors in diagnostics.
489 lines
27 KiB
Python
489 lines
27 KiB
Python
from __future__ import annotations
|
||
from dataclasses import replace
|
||
import json
|
||
from pathlib import Path
|
||
import time
|
||
from .model import Action, Catalog, Planner, Policy, Snapshot, seconds
|
||
from .daily import DailyLedger, DailyPolicy, selected_entries
|
||
from .sweeping import SweepPolicy, SweepRunner
|
||
from .quests import QuestPolicy, TaskPlanner
|
||
from .market import PurchaseBudget
|
||
from .management import expansion_quote, manual_monster_actions
|
||
from .gifts import GiftPlanner
|
||
from .master_sync import MasterSync
|
||
from .stage_cache import StageCache
|
||
from .drop_statistics import reward_text
|
||
from .cultivation import CultivationSelector
|
||
|
||
|
||
class Engine:
|
||
def __init__(self, catalog, client=None, budget_path=None):
|
||
self.catalog, self.client = catalog, client
|
||
folder = Path(budget_path).parent if budget_path else None
|
||
self.cultivation = CultivationSelector(catalog, folder / "cultivation_choices.json" if folder else None)
|
||
self.planner = Planner(catalog, self.cultivation)
|
||
self.hatch_planner = Planner(catalog, self.cultivation)
|
||
self.pending_hatches = []
|
||
self.gift_planner = GiftPlanner(catalog, self.cultivation)
|
||
self.policy = Policy()
|
||
self.quest_policy = QuestPolicy()
|
||
self.tasks = TaskPlanner(catalog)
|
||
self.snapshot = None
|
||
self.demo = client is None
|
||
self.auto = False
|
||
self.last_heartbeat = 0
|
||
self.heartbeat_enabled = True
|
||
self.purchase_budget = PurchaseBudget(budget_path)
|
||
self.last_draw = ""
|
||
self.growth_cache = {}
|
||
self.growth_attempts = {}
|
||
self.master_sync = MasterSync(catalog)
|
||
self.last_executed = False
|
||
self.stage_cache = StageCache(catalog, folder / "maps.json" if folder else None)
|
||
self.daily_policy = DailyPolicy()
|
||
self.daily_ledger = DailyLedger(folder / "daily_claims.json" if folder else None)
|
||
self.sweep_policy = SweepPolicy()
|
||
self.sweeper = SweepRunner(catalog, folder / "sweep_runs.json" if folder else None)
|
||
|
||
def read_snapshot(self, *, sync_master=True):
|
||
self.snapshot = self.client.snapshot()
|
||
self.master_sync.apply(self.snapshot)
|
||
if sync_master:
|
||
self.master_sync.settle(self.client, self.snapshot)
|
||
present = self.snapshot.monsters
|
||
self.growth_cache = {mid: entry for mid, entry in self.growth_cache.items() if mid in present}
|
||
self.growth_attempts = {key: stamp for key, stamp in self.growth_attempts.items() if key[0] in present}
|
||
rows = []
|
||
fields = ("gAtk", "gDef", "gHp", "gDex")
|
||
for mon in self.snapshot.raw["monsters"]:
|
||
mid = int(mon["id"])
|
||
entry = self.growth_cache.get(mid)
|
||
if entry:
|
||
start = seconds(mon.get("timeStart"))
|
||
if str(mon.get("typeId")) != entry["type"] or start > 0 and entry["start"] > 0 and start != entry["start"]:
|
||
self.growth_cache.pop(mid, None)
|
||
else:
|
||
confirmed = int(mon.get("mode") or 0) >= entry.get("mode", 0)
|
||
if entry.get("mode") == 2:
|
||
confirmed = confirmed and all(q is not None for q in self.catalog.quality(mon))
|
||
for field in fields:
|
||
if field in entry and mon.get(field) != entry[field]:
|
||
confirmed = False
|
||
if confirmed:
|
||
self.growth_cache.pop(mid, None)
|
||
else:
|
||
mon = dict(mon)
|
||
mon["mode"] = max(int(mon.get("mode") or 0), entry.get("mode", 0))
|
||
mon.update({field: entry[field] for field in fields if field in entry})
|
||
rows.append(mon)
|
||
self.snapshot.raw["monsters"] = rows
|
||
self.gift_planner.apply_confirmed(self.snapshot)
|
||
self.sweeper.recover_reward_event(self.snapshot, getattr(getattr(self.client, "trace", None), "path", None))
|
||
return self.snapshot
|
||
|
||
def master_sync_due(self):
|
||
return not self.demo and bool(self.master_sync.pending(self.snapshot))
|
||
|
||
def sync_master(self):
|
||
self.read_snapshot()
|
||
return self.snapshot, self.plans(), "已同步等级 / 体力"
|
||
|
||
def refresh_stages(self):
|
||
self.auto = False
|
||
if not self.demo:
|
||
self.read_snapshot()
|
||
elif self.snapshot is None:
|
||
self.snapshot = demo_snapshot(self.catalog)
|
||
self.stage_cache.get(self.snapshot, refresh=True)
|
||
return self.snapshot, self.plans(), "已刷新关卡并保存当前账号的地图缓存"
|
||
|
||
def remember_growth(self, response):
|
||
# MonsterCenter.checkGrowUpHandler treats these two arrays as the
|
||
# authoritative stage and growth values, including after a stale read.
|
||
if not isinstance(response, dict):
|
||
return
|
||
current = self.snapshot.monsters
|
||
for key in ("datas", "stackMonsterInfos"):
|
||
for row in response.get(key) or []:
|
||
if not isinstance(row, dict) or row.get("monsterId") is None:
|
||
continue
|
||
mid = int(row["monsterId"])
|
||
mon = current.get(mid)
|
||
if mon is None:
|
||
continue
|
||
entry = self.growth_cache.setdefault(mid, {"type": str(mon.get("typeId")), "start": seconds(mon.get("timeStart"))})
|
||
if key == "datas" and row.get("mode") in (0, 1, 2):
|
||
entry["mode"] = max(entry.get("mode", 0), int(row["mode"]))
|
||
else:
|
||
entry.update({field: row[field] for field in ("gAtk", "gDef", "gHp", "gDex") if row.get(field) is not None})
|
||
|
||
def settle_pending_growth(self, force=False):
|
||
pending = self.snapshot.growth_pending(self.catalog)
|
||
now = time.monotonic()
|
||
if not pending or not force and all(now - self.growth_attempts.get(key, -1e12) < 60 for key in pending):
|
||
return False
|
||
for key in pending:
|
||
self.growth_attempts[key] = now
|
||
response = self.client.settle_growth()
|
||
self.remember_growth(response)
|
||
self.read_snapshot()
|
||
return True
|
||
|
||
def growth_sync_due(self):
|
||
if self.snapshot is None:
|
||
return False
|
||
now = time.monotonic()
|
||
return any(now - self.growth_attempts.get(key, -1e12) >= 60 for key in self.snapshot.growth_pending(self.catalog))
|
||
|
||
def sync_growth(self):
|
||
if self.demo:
|
||
if self.snapshot is None:
|
||
self.snapshot = demo_snapshot(self.catalog)
|
||
for mon in self.snapshot.raw["monsters"]:
|
||
if mon.get("process") == 2:
|
||
mon["mode"] = self.snapshot.expected_growth_mode(mon, self.catalog)
|
||
else:
|
||
self.read_snapshot()
|
||
self.settle_pending_growth()
|
||
pending = self.snapshot.growth_pending(self.catalog)
|
||
message = "已自动同步孵化 / 成长状态"
|
||
if pending:
|
||
message += f";仍有 {len(pending)} 只等待服务器确认阶段或资质"
|
||
return self.snapshot, self.plans(), message
|
||
|
||
def keep_alive(self):
|
||
if self.demo:
|
||
return "离线演示无需心跳"
|
||
self.last_heartbeat = time.monotonic()
|
||
self.client.call("heartBeatService/keepAlive")
|
||
return "会话心跳已更新"
|
||
|
||
def poll(self, *, hatch_only=False, defer_hatch=False):
|
||
self.last_executed = False
|
||
settled = False
|
||
if self.demo:
|
||
if self.snapshot is None:
|
||
self.snapshot = demo_snapshot(self.catalog)
|
||
for mon in self.snapshot.raw["monsters"]:
|
||
if mon.get("process") == 2:
|
||
mon["mode"] = self.snapshot.expected_growth_mode(mon, self.catalog)
|
||
else:
|
||
self.read_snapshot(sync_master=not hatch_only)
|
||
if not hatch_only:
|
||
settled = self.settle_pending_growth()
|
||
message = "状态已刷新" + (";已请求孵化 / 成长结算" if settled else "")
|
||
if self.sweeper.recovered_event:
|
||
message += ";已解除旧版对已结算奖励事件的误阻塞"
|
||
self.sweeper.recovered_event = False
|
||
if self.snapshot.growth_pending(self.catalog):
|
||
message += ";成长状态等待服务器确认,将自动检查"
|
||
try:
|
||
plans = self.plans()
|
||
except (ValueError, TypeError, KeyError, AttributeError) as error:
|
||
self.auto = False
|
||
return self.snapshot, [], "状态已读取;策略暂不可用:" + str(error)
|
||
actions = self.pending_hatches if hatch_only else plans
|
||
action = actions[0] if actions else None
|
||
if action and defer_hatch and action.kind == "hatch":
|
||
action = None
|
||
if self.auto and action is not None:
|
||
self.last_executed = True
|
||
if action.kind == "daily":
|
||
entry = next(row for row in selected_entries(self.catalog, self.snapshot, self.daily_policy, self.daily_ledger) if row.action == action)
|
||
self.claim_daily_entry(entry)
|
||
return self.snapshot, self.plans(), ("[演示] " if self.demo else "") + action.description
|
||
if action.kind == "sweep":
|
||
stage = self.sweeper.next(self.snapshot, self.sweep_policy)
|
||
if self.demo:
|
||
return self.snapshot, plans, "扫荡需要登录真实账号;演示不会提交战斗"
|
||
result = self.sweeper.run(self.client, self.snapshot, stage, self.sweep_policy)
|
||
self.read_snapshot()
|
||
label = "探索奖励事件已结算" if self.sweeper.last_outcome == "event" else "扫荡完成"
|
||
message = f"{label}:{stage.number} {stage.name} / 难度{stage.level};" + reward_text(self.sweeper.last_reward)
|
||
if self.sweeper.statistics_error:
|
||
message += ";" + self.sweeper.statistics_error
|
||
return self.snapshot, self.plans(), message
|
||
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)
|
||
if self.demo:
|
||
self.apply_demo(action)
|
||
else:
|
||
response = self.client.call(action.path, action.payload)
|
||
if action.kind == "buy":
|
||
self.record_draw(response.get("eggs") or [])
|
||
if action.kind == "gift":
|
||
try:
|
||
self.gift_planner.remember_success(self.snapshot, action, response)
|
||
except ValueError:
|
||
self.auto = False
|
||
raise
|
||
self.read_snapshot(sync_master=not hatch_only)
|
||
if action.kind == "hatch":
|
||
stack_id = action.payload["eggs"][0]["stackId"]
|
||
slot = next((slot for slot in self.snapshot.raw["stacks"] if int(slot["id"]) == stack_id), None)
|
||
if slot is None or int(slot.get("monsterId") or 0) <= 0:
|
||
self.auto = False
|
||
raise ValueError("装填已返回,但坑位状态尚未同步;已停止,请刷新核对后再继续")
|
||
if action.kind == "feed" and any(mid in self.snapshot.monsters for mid in action.payload["foods"]):
|
||
self.auto = False
|
||
raise ValueError("喂养已返回,但素材状态尚未同步;已停止,请刷新核对后再继续")
|
||
message = ("[演示] " if self.demo else "") + action.description
|
||
if action.kind == "buy" and self.last_draw:
|
||
message += ";" + self.last_draw
|
||
try:
|
||
plans = self.plans()
|
||
except (ValueError, TypeError, KeyError, AttributeError) as error:
|
||
self.auto = False
|
||
plans = []
|
||
message += ";状态已读取,策略暂不可用:" + str(error)
|
||
if not plans and self.planner.notes:
|
||
message += ";" + ";".join(dict.fromkeys(self.planner.notes))
|
||
return self.snapshot, plans, message
|
||
|
||
def plans(self):
|
||
if self.policy.keep_better_quality or self.policy.gift_auto_representative:
|
||
self.cultivation.select(self.snapshot)
|
||
quests = self.tasks.plan(self.snapshot, self.quest_policy, self.policy)
|
||
types, eggs = self.tasks.reservations(self.snapshot)
|
||
reserved = dict(self.policy.reserved_eggs)
|
||
for key, count in eggs.items():
|
||
reserved[key] = max(reserved.get(key, 0), count)
|
||
policy = replace(self.policy, reserved_types=list(set(self.policy.reserved_types) | types), reserved_eggs=reserved)
|
||
self.hatch_planner.notes = []
|
||
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 []
|
||
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)
|
||
return daily + quests + gifts + ranch + sweep_actions
|
||
|
||
def claim_daily_entry(self, entry):
|
||
self.daily_ledger.record(self.snapshot, entry.key)
|
||
if not self.demo:
|
||
self.client.call(entry.action.path, entry.action.payload)
|
||
self.read_snapshot()
|
||
|
||
def claim_daily(self):
|
||
self.auto = False
|
||
if not self.demo:
|
||
self.read_snapshot()
|
||
# Fresh status after every claim, bounded by the initially available IDs.
|
||
keys = [row.key for row in selected_entries(self.catalog, self.snapshot, self.daily_policy, self.daily_ledger)]
|
||
done = 0
|
||
for key in keys:
|
||
row = next((r for r in selected_entries(self.catalog, self.snapshot, self.daily_policy, self.daily_ledger) if r.key == key), None)
|
||
if row:
|
||
self.claim_daily_entry(row)
|
||
done += 1
|
||
return self.snapshot, self.plans(), ("[演示] " if self.demo else "") + f"已处理 {done} 项勾选奖励;自动执行已暂停"
|
||
|
||
def record_draw(self, eggs):
|
||
totals = {}
|
||
for egg in eggs:
|
||
if isinstance(egg, dict) and egg.get("typeId") is not None:
|
||
key = str(egg["typeId"])
|
||
totals[key] = totals.get(key, 0) + int(egg.get("num") or 0)
|
||
parts = [f"{self.catalog.monster(key).get('name', key)} ×{count}" for key, count in totals.items()]
|
||
self.last_draw = f"抽蛋完成,共 {sum(totals.values())} 枚:" + "、".join(parts[:8]) + ("…" if len(parts) > 8 else "")
|
||
|
||
def set_monster_lock(self, monster_ids, locked):
|
||
self.auto = False
|
||
ids = list(dict.fromkeys(int(mid) for mid in monster_ids))
|
||
if not ids or any(mid <= 0 for mid in ids):
|
||
raise ValueError("请先选择需要锁定 / 解锁的魔物")
|
||
if not self.demo:
|
||
self.read_snapshot()
|
||
monsters = self.snapshot.monsters
|
||
if any(mid not in monsters for mid in ids):
|
||
raise ValueError("选中的魔物已不存在,请刷新后重新选择")
|
||
if not locked and any(monsters[mid].get("sysLock") for mid in ids):
|
||
raise ValueError("选中包含系统锁定魔物,普通解锁不能解除系统锁,请重新选择")
|
||
changed = 0
|
||
for mid in ids:
|
||
if bool(monsters[mid].get("lock")) == bool(locked):
|
||
continue
|
||
if self.demo:
|
||
monsters[mid]["lock"] = int(locked)
|
||
else:
|
||
self.client.call("monsterService/monsterLock", {"monsterId": mid, "lock": int(locked)})
|
||
self.read_snapshot()
|
||
if bool(self.snapshot.monsters.get(mid, {}).get("lock")) != bool(locked):
|
||
raise ValueError("服务器返回的锁定状态未更新,已停止后续操作")
|
||
changed += 1
|
||
message = ("[演示] " if self.demo else "") + f"已{'锁定' if locked else '解锁'} {changed} 只魔物;自动执行已暂停"
|
||
return self.snapshot, self.plans(), message
|
||
|
||
def manage_monsters(self, kind, monster_ids, target_id=0):
|
||
self.auto = False
|
||
if not self.demo:
|
||
self.read_snapshot()
|
||
actions = manual_monster_actions(self.catalog, self.snapshot, kind, monster_ids, target_id)
|
||
for action in actions:
|
||
if self.demo:
|
||
field = "foods" if kind == "feed" else "monsterId" if "monsterId" in action.payload else "monsterIds"
|
||
for mid in action.payload[field]:
|
||
self.apply_demo(replace(action, payload=action.payload | {field: [mid]}))
|
||
else:
|
||
self.client.call(action.path, action.payload)
|
||
self.read_snapshot()
|
||
consumed = action.payload.get("foods") or action.payload.get("monsterId") or action.payload.get("monsterIds") or []
|
||
if any(int(mid) in self.snapshot.monsters for mid in consumed):
|
||
raise ValueError("操作已返回,但魔物记录尚未更新;请刷新核对,不会重复提交")
|
||
return self.snapshot, self.plans(), ("[演示] " if self.demo else "") + ";".join(a.description for a in actions) + ";自动执行已暂停"
|
||
|
||
def expand(self, quote):
|
||
self.auto = False
|
||
if not self.demo:
|
||
self.read_snapshot()
|
||
fresh = expansion_quote(self.catalog, self.snapshot, quote.kind, quote.currency, quote.position)
|
||
if fresh != quote:
|
||
raise ValueError("扩建费用或次数已变化,请刷新后重新确认")
|
||
old_rooms = {int(r["id"]) for r in self.snapshot.raw["rooms"]}
|
||
if self.demo:
|
||
raw = self.snapshot.raw
|
||
raw["master"][quote.currency] -= quote.cost
|
||
counter = ("numAdd" if quote.currency == "money" else "numKeAdd") + ("Stack" if quote.kind == "stack" else "Room")
|
||
raw["history"][counter] += 1
|
||
if quote.kind == "stack":
|
||
raw["stacks"].append({"id": max([int(s["id"]) for s in raw["stacks"]] + [0]) + 1,
|
||
"position": quote.position, "monsterId": -1, "openType": quote.payload["openType"]})
|
||
else:
|
||
type_id = 1000 if "1000" in self.catalog.data["room_info"] else int(raw["rooms"][0]["typeId"])
|
||
raw["rooms"].append({"id": max(old_rooms or {0}) + 1, "typeId": type_id, "openType": 1 if quote.currency == "money" else 2})
|
||
else:
|
||
self.client.call(quote.path, quote.payload)
|
||
self.read_snapshot()
|
||
verified = (any(int(s.get("position", -1)) == quote.position for s in self.snapshot.raw["stacks"]) if quote.kind == "stack"
|
||
else bool({int(r["id"]) for r in self.snapshot.raw["rooms"]} - old_rooms))
|
||
if not verified:
|
||
raise ValueError("扩建请求已返回,但尚未读取到新增记录;请刷新核对,不会自动重复提交")
|
||
return self.snapshot, self.plans(), ("[演示] " if self.demo else "") + quote.description + ",已完成"
|
||
|
||
def apply_demo(self, action):
|
||
if action.kind == "collect" and sum(len(d["monsterId"]) for d in action.payload["datas"]) > 1:
|
||
for data in action.payload["datas"]:
|
||
for mid in data["monsterId"]:
|
||
self.apply_demo(replace(action, payload={"datas": [{"monsterId": [mid], "roomId": data["roomId"]}]}))
|
||
return
|
||
if action.kind == "feed" and len(action.payload["foods"]) > 1:
|
||
for mid in action.payload["foods"]:
|
||
self.apply_demo(replace(action, payload=action.payload | {"foods": [mid]}))
|
||
return
|
||
raw = self.snapshot.raw
|
||
if action.kind.startswith("quest_"):
|
||
self.apply_demo_quest(action)
|
||
return
|
||
if action.kind == "buy":
|
||
market = self.catalog.data["markets"][action.payload["id"]]
|
||
count = action.payload["num"]
|
||
gift_every = int(market.get("freegift") or 0)
|
||
received = count + (count // gift_every if gift_every > 0 else 0)
|
||
# Deterministic offline example, not a prediction of the server draw.
|
||
type_id = int(next(iter(market["eggs"].values()))[0])
|
||
item = next((i for i in raw["items"] if int(i["typeId"]) == type_id), None)
|
||
if item:
|
||
item["num"] += received
|
||
else:
|
||
raw["items"].append({"id": max([int(i["id"]) for i in raw["items"]] + [500]) + 1, "typeId": type_id, "num": received})
|
||
raw["master"]["money"] -= int(market["money"]) * count
|
||
self.record_draw([{"typeId": type_id, "num": received}])
|
||
return
|
||
if action.kind == "collect":
|
||
data = action.payload["datas"][0]
|
||
mid = data["monsterId"][0]
|
||
self.snapshot.monsters[mid].update(process=3, roomId=data["roomId"])
|
||
elif action.kind in ("sell", "feed"):
|
||
mid = (action.payload.get("monsterId") or action.payload.get("monsterIds") or action.payload.get("foods"))[0]
|
||
mon = self.snapshot.monsters[mid]
|
||
if action.kind == "sell":
|
||
raw["master"]["money"] += self.catalog.monster(mon["typeId"])["sell_money"]
|
||
else:
|
||
target = self.snapshot.monsters[action.payload["targetId"]]
|
||
target["exp"] = target.get("exp", 0) + self.catalog.feed_exp(mon)
|
||
raw["monsters"] = [m for m in raw["monsters"] if m["id"] != mid]
|
||
elif action.kind == "gift":
|
||
target = self.snapshot.monsters[action.payload["monsterId"]]
|
||
item = next(i for i in raw["items"] if int(i["id"]) == action.payload["itemId"])
|
||
gain = int(self.catalog.monster(target.get("typeId")).get("like", {}).get(str(item["typeId"]), 0))
|
||
target["feel"] = max(0, min(self.catalog.max_feel(target), int(target.get("feel") or 0) + gain))
|
||
target["giftTime"] = int(time.time())
|
||
item["num"] -= 1
|
||
return
|
||
else:
|
||
egg = action.payload["eggs"][0]
|
||
item = next(i for i in raw["items"] if i["id"] == egg["itemId"])
|
||
item["num"] -= 1
|
||
mid = max([m["id"] for m in raw["monsters"]] + [100]) + 1
|
||
row = self.catalog.monster(item["typeId"])
|
||
mon = {"id": mid, "typeId": item["typeId"], "process": 2, "mode": 0, "level": 1, "exp": 0, "timeStart": int(time.time() * 1000), "roomId": 0}
|
||
mon.update({"g" + s.capitalize(): row[s + "_grow_min"] for s in ("atk", "def", "hp", "dex")})
|
||
raw["monsters"].append(mon)
|
||
next(s for s in raw["stacks"] if s["id"] == egg["stackId"])["monsterId"] = mid
|
||
return
|
||
for slot in raw["stacks"]:
|
||
if slot.get("monsterId") == mid:
|
||
slot["monsterId"] = 0
|
||
|
||
def apply_demo_quest(self, action):
|
||
raw = self.snapshot.raw
|
||
history = raw.setdefault("history", {})
|
||
tasks = raw.setdefault("currentTasks", [])
|
||
if action.kind == "quest_reset":
|
||
history["loopTaskTime"] = int(time.time())
|
||
history["loopTaskNum"] = self.catalog.data["game_setting"].get("loopTaskMaxNum", 6)
|
||
elif action.kind == "quest_accept":
|
||
type_id = action.payload["taskTypeId"]
|
||
tasks.append({"id": max([t["id"] for t in tasks] + [1000]) + 1, "typeId": type_id, "curStep": 1, "stepValue": 0})
|
||
history["loopTaskNum"] -= 1
|
||
offers = history["loopTask"][str(action.payload["city"])]
|
||
offers[:] = [t for t in offers if str(t) != type_id]
|
||
else:
|
||
task = next(t for t in tasks if int(t["id"]) == action.payload["taskId"])
|
||
info = self.catalog.data["task_info"][str(task["typeId"])]
|
||
if action.kind == "quest_complete":
|
||
raw["master"]["money"] += int(info.get("reward", {}).get("money", 0))
|
||
raw["master"]["ke"] = raw["master"].get("ke", 0) + int(info.get("reward", {}).get("ke", 0))
|
||
tasks.remove(task)
|
||
else:
|
||
step = info["steps"][task["curStep"] - 1]
|
||
value = step.get("statusValue") or {}
|
||
if value.get("remove"):
|
||
ids = action.payload.get("removeIds") or []
|
||
if step["statusType"] == "getMoney":
|
||
raw["master"]["money"] -= int(value["money"])
|
||
elif step["statusType"] == "getItem" or int(value.get("mode", 2)) == 0:
|
||
left = int(value["num"])
|
||
for item in raw["items"]:
|
||
if int(item["id"]) in ids:
|
||
used = min(left, int(item["num"]))
|
||
item["num"] -= used
|
||
left -= used
|
||
else:
|
||
raw["monsters"] = [m for m in raw["monsters"] if int(m["id"]) not in ids]
|
||
for slot in raw["stacks"]:
|
||
if slot.get("monsterId") in ids:
|
||
slot["monsterId"] = 0
|
||
task["curStep"] += 1
|
||
|
||
|
||
def demo_snapshot(catalog):
|
||
types = [int(k) for k, row in catalog.monsters.items() if row.get("star") == 1 and not row.get("npc")][:4]
|
||
monsters = []
|
||
for i, type_id in enumerate(types):
|
||
row = catalog.monster(type_id)
|
||
mon = {"id": 101 + i, "typeId": type_id, "level": 1, "exp": 0, "process": 2, "mode": 2 if i < 2 else 0,
|
||
"timeStart": int((time.time() - catalog.total_time(type_id) + (0 if i < 2 else 200)) * 1000), "roomId": 0, "lock": 0}
|
||
mon.update({"g" + s.capitalize(): row[s + "_grow_min"] for s in ("atk", "def", "hp", "dex")})
|
||
monsters.append(mon)
|
||
target = dict(monsters[0]) | {"id": 900, "process": 3, "mode": 2, "level": 20, "potentialLevel": 7, "roomId": 1, "lock": 1}
|
||
room_type = next(k for k, row in catalog.data["room_info"].items() if row.get("maxNum", 0) >= 10)
|
||
return Snapshot({"master": {"id": 1, "roleName": "离线演示", "level": 62, "exp": 456789, "money": 12345, "ke": 2000, "ti": 100},
|
||
"stacks": [{"id": i + 1, "position": i, "monsterId": 101 + i if i < 4 else 0, "openType": 3} for i in range(6)],
|
||
"monsters": monsters + [target], "items": [{"id": 501 + i, "typeId": t, "num": 8} for i, t in enumerate(types)] + [{"id": 600, "typeId": 20047, "num": 3}],
|
||
"rooms": [{"id": 1, "typeId": int(room_type), "openType": 3, "name": "主牧场"}], "teams": [{"monsters": [900]}], "activityHistory": {},
|
||
"history": {"unlockCity": {"1": True}, "openFarmBuild": True, "numAddStack": 0, "numKeAddStack": 0, "numAddRoom": 0, "numKeAddRoom": 0}})
|