945 lines
56 KiB
C#
945 lines
56 KiB
C#
using System.Text.RegularExpressions;
|
||
using Ananta.SDK.Network;
|
||
using Ananta.SDK.Rpc;
|
||
using Ananta.SDK.Serialization;
|
||
using Ananta.Server.Configuration;
|
||
using Ananta.Server.Protocol.Client4229938;
|
||
using Ananta.Server.RpcTypes.Client4229938;
|
||
using SceneMethods = Ananta.Server.RpcTypes.Client4229938.Methods.GameScene;
|
||
|
||
namespace Ananta.Server.Handlers.Game;
|
||
|
||
/// <summary>
|
||
/// Bowling ("保龄球") + the GameGround zone family.
|
||
///
|
||
/// WHY THIS FILE EXISTS
|
||
/// The client's mini-game code is complete (lua\LX6\MiniGame\BowlingGame\, 26 files) and the server
|
||
/// side is empty. The hard gate is <see cref="MethodId.SyncGameGroundZoneInfo"/> (68004609): the
|
||
/// client only builds a bowling session when the server pushes a BowlingZoneInfo. Without it
|
||
/// gameInstance.zoneInfo stays nil, no panel appears and nothing else is reachable.
|
||
///
|
||
/// The byte layouts below are taken from two mutually-confirming authoritative sources — the
|
||
/// client's own Lua serializer and the client's IL2CPP metadata — and NOT from
|
||
/// Drmk.Proxy/proxy/rpc_schema.json, whose `schemas` table is a stale older build. See
|
||
/// <c>.workbuddy/bowling_wire_spec.md</c> for the full derivation and the evidence.
|
||
///
|
||
/// CLIENT FLOW (BowlingGameManager.lua):
|
||
/// player interacts with the alley machine (C# BowlingGameBridge -> CreateAndStartGameCs)
|
||
/// -> TriggerClientGameFromGadget_Async(entityInstanceId)
|
||
/// -> EnterGame(gadgetUid, BowlingGameType.Single, 0)
|
||
/// -> ClientToGameSceneDelegate:EnterBowlingZone(gadgetUid, 0, 0) [67832701, Invoke]
|
||
/// server: reply u64, then push SyncGameGroundZoneInfo(tag 5 + BowlingZoneInfo)
|
||
/// -> OnSyncGameGroundZoneInfo -> CreateGameFromServerImpl -> _Async
|
||
/// -> WaitSceneItemAndGadget_Async:
|
||
/// 1) up to 5 s for CheckDisableSceneItems(ballList) && (pinList).
|
||
/// NOTE that this helper calls SceneItemMgr:TagAndLoadGameobject(id) itself, so the
|
||
/// CLIENT loads the objects — the server only has to make the holds exist.
|
||
/// 2) array.concat(self.sceneItemBallIdList, zoneInfo.BowlingBallSceneItemIdList)
|
||
/// -> the two id lists MUST NOT be null (an empty list is fine).
|
||
/// 3) up to 20 s for SpoonGadgetManager:RegisterWaitLoad({GadgetUId}); on timeout the
|
||
/// client aborts the session via LeaveBowling(gadgetUId, true).
|
||
/// -> GameType == Single && !isPlayAgain -> RealStartGame()
|
||
///
|
||
/// The holds in step 1 are produced by pushing the balls/pins as DESTRUCTIBLES through
|
||
/// SyncDestructibleGridAOIDecrease (68969593) — destructibles and scene items share one id space
|
||
/// (DestructibleHUDCtrl.lua resolves a destructible id via SceneItemMgr:GetSceneItemHold), so this
|
||
/// replaces the earlier "client Lua hot-patch creates the balls" plan entirely — no fastpatch is
|
||
/// needed for the objects.
|
||
///
|
||
/// ⚠ Do NOT go back to SyncDestructibleGridAOIIncrease (68934309): that id has no implementation on
|
||
/// this client build and is silently dropped. See the long note further down this file.
|
||
/// </summary>
|
||
internal sealed partial class GameRouter
|
||
{
|
||
/// <summary>Per-connection bowling session, parked in Session.Items like the world-entry state.</summary>
|
||
private const string BowlingStateKey = "client4229938-bowling";
|
||
|
||
private sealed class BowlingSession
|
||
{
|
||
internal ulong GadgetUId;
|
||
internal string ZoneSessionId = "";
|
||
internal long StartedUtcTicks;
|
||
internal readonly List<ulong> BallIds = new();
|
||
internal readonly List<ulong> PinIds = new();
|
||
}
|
||
|
||
private BowlingSession GetBowlingSession(RpcContext ctx)
|
||
{
|
||
if (ctx.Session.Items.TryGetValue(BowlingStateKey, out var raw) && raw is BowlingSession existing)
|
||
return existing;
|
||
|
||
var created = new BowlingSession();
|
||
ctx.Session.Items[BowlingStateKey] = created;
|
||
return created;
|
||
}
|
||
|
||
// ★ 规则 104 适配（DRMK-PS_09_HyNB-v0.3，2026-09-24）：源版是
|
||
// `private static long _bowlingSceneItemSeq = 910000000000L;` 的进程内自增号段。
|
||
//
|
||
// ⛑⛑ **这个号段不能改**。客户端 BF1 补丁（AnantaBowlingLoader.exe / agent.js）里写死
|
||
// var ID_BASE = 0xd3e03a0c01; // = 910000000001
|
||
// var BATCH = 15; // 10 瓶 + 5 球
|
||
// idx = (n - ID_BASE) % BATCH; ← 靠这个下标决定这条 id 是球瓶还是球
|
||
// 把号段抬到 941e9（本仓 910 段另有 RuntimePayloadFactory.cs:1238 的
|
||
// `UniqueId = 910000000000UL + templateId` 背包弹药 uid，确有冲突顾虑）会让
|
||
// `(n - ID_BASE)` 变成负数/错位，瓶子会被当成球、球被当成瓶子。
|
||
// ⇒ 保留 910000000001 起点，改用 IdCounterStore **按 15 个一批**落盘递增：
|
||
// 高水位持久化（规则 104 满足）且每批起点仍严格对齐 ID_BASE 的 15 倍数。
|
||
private const string BowlingSceneItemBatchCounter = "Bowling.SceneItemBatch";
|
||
private const ulong BowlingSceneItemIdBase = 910000000001UL; // == agent.js ID_BASE 0xd3e03a0c01
|
||
private const int BowlingSceneItemBatchSize = 15; // 10 瓶 + 5 球（== agent.js BATCH）
|
||
|
||
// 局内 session 后缀（只进日志与 ZoneSessionId 字符串，不是实体 id，但同样落盘保持单调）。
|
||
private const string BowlingZoneSeqCounter = "Bowling.ZoneSeq";
|
||
|
||
// ---------------------------------------------------------------------------------------
|
||
// ★ Official alley frame — measured live off WorldMap_Release::BowlingSceneNode (2026-09-23).
|
||
//
|
||
// Why this exists: the first cut of this router laid the lane out RELATIVE TO WHEREVER THE
|
||
// PLAYER STOOD (state.LastReportedPlayerPosition). The assumption behind it — "the private
|
||
// server keeps no alley geometry of its own, the alley holds only furniture" — is wrong.
|
||
// The alley ships a complete gameplay rig, and it is all in the baked scene:
|
||
//
|
||
// MiniGameMachine_Bowling_<uid>/ItemViewNode/.../BowlingSceneNode ← ⚠ gadget CHILD, not scene-baked
|
||
// (old numbers below assumed the
|
||
// gadget root of the day; see the
|
||
// correction block further down)
|
||
// ├─ Bowling_lane_Collider plane 19.02 x 0.2 x 1.49 + L/R side cubes + BlockL/BlockR
|
||
// ├─ PivotNode/BallSpawnPoint (2693.29, 0.12, 1590.44)
|
||
// ├─ PivotNode/PlayerPoint (2689.30, 0.02, 1590.83)
|
||
// ├─ PivotNode/PinPointN <- head pin (2711.42, 0.02, 1590.03)
|
||
// ├─ ArrowTips(Clone) 21 lane arrows, z = 1590.55, x 2693.34 … 2699.64
|
||
// ├─ VirtualCamera / EndVirtualCamera / CinemachineConfiner
|
||
// └─ a node literally named
|
||
// "碰撞体必须要是 Destructible 层的，不然不会和保龄球产生碰撞"
|
||
// WorldMap_Release::Gameplay_Bowling02 the throw timeline (actors + camera, ~2693.29,1590.44)
|
||
// WorldMap_Release::GadgetInstanceRoot/MiniGameMachine_Bowling_<uid>/ItemViewNode/BowlingGameNode(Right)
|
||
// the two lane rigs (pin racks land at x≈2711.3)
|
||
//
|
||
// Lane axis is +x (yaw 90°). Two lanes exist side by side 2 m apart; only the z = 1590.44 one
|
||
// (the "Right" lane) has a lane collider in BowlingSceneNode, and the dev note above says the
|
||
// ball only collides with a Destructible-layer collider — so lane R is the one to use.
|
||
//
|
||
// Symptom this fixes: with the old player-relative layout the player stands at the machine in
|
||
// the alley doorway, so balls/pins spawned at +2 m / +8 m FORWARD FROM THE DOOR and the whole
|
||
// mini-game played out in the doorway instead of on the lane.
|
||
//
|
||
// These are absolute world coordinates from the official rig; the lane is axis-aligned, so no
|
||
// yaw math is applied to the pin/ball layout. To move the game to the LEFT lane, add +2.0 to
|
||
// every Z below (and re-check that a collider exists there).
|
||
// ---------------------------------------------------------------------------------------
|
||
// ---- 2026-09-23 11:40 二次修正：机器本身原先就摆错了 15 m -------------------------------
|
||
// The block above still had ONE wrong premise: the (2693.29 / 1590.44) rig is a child of the
|
||
// MiniGameMachine_Bowling gadget, so it is only there if the GADGET is there. The gadget was
|
||
// being spawned at (2689.57, 1591.53) — which is the alley DOORWAY (it even sits on top of
|
||
// sector_high_87_54_sound/SoundGate_1 @ (2689.57, 1.22, 1591.48)). The alley's own 11 painted
|
||
// lanes are at z = 1563.99 … 1582.66 (2 m pitch). Hence: proper interaction point showed up at
|
||
// the door while the lanes were 15 m away.
|
||
//
|
||
// Correct gadget root (two independent derivations agree to 5 mm):
|
||
// root = (2688.73, 0.02, 1576.845) yaw 271.30 [gym_tools\bowl_machine_spawn.py]
|
||
// (a) foul line flush with the painted lane head: painted head x 2692.445 - prefab 3.72
|
||
// (b) player's own screenshot stance 2686.92 + prefab StandPosRight offset 1.81
|
||
// prefab-local offsets (measured):
|
||
// lane centre lines z = root - 1.515 / root + 0.485 (2 m apart, NOT the node z)
|
||
// lane surface x = root + 3.72 … root + 22.74 (19.02 long, foul line at +3.72)
|
||
// head pin x = root + 21.72, z = root - 1.515
|
||
// => the constants below are root + those offsets, i.e. the absolute world coords of the
|
||
// gadget that is currently spawned at (2688.73, 0.02, 1576.845).
|
||
// If the gadget is ever moved (bowl_machine_spawn.py --lane <z>), add the same delta here:
|
||
// Δ = (newRootX - 2688.73, newRootZ - 1576.845)
|
||
// 2026-09-23 修正：玩家实际站在 L 道(z≈1577.3, 官方锚点 BowlingGameStart=2689.35/1577.291)。
|
||
// 之前用的是 R 道(z=1575.3)，导致"球瓶在相邻一条道"——差整整一条道(2m)。
|
||
// 现直接对齐官方 L 道锚点：BowlingPinPlacementL=2710.49/1577.346（= 道中心线）。
|
||
//
|
||
// ★★ 2026-09-23 三次修正（bowl_audit_before.txt 实测，铁证）：
|
||
// 上面原本写的 "BowlingGameNode(L)=2692.50/1577.755" 是**机器轴心**节点，它横向偏了
|
||
// 道中心线 0.41~0.43 m，不能拿来当球的 z 基准。真正的道中心线是
|
||
// BowlingPinPlacementL.z = 1577.35 （官方烘焙细板实测 1577.33，差 2 cm）
|
||
// 本文件上方第 125 行的配方其实早就写明答案："lane centre lines = root + 0.485
|
||
// （NOT the node z）"。旧值 1577.75 = root + 0.905 恰好就是 node z，代码违反了自己的注释。
|
||
// 后果：整排球横移 0.42 m，最外球压到道边条；而瓶一直用 1577.35，所以看起来只有球歪。
|
||
// ---------------------------------------------------------------------------------------
|
||
// ★★ 2026-09-23 第四次修正 —— 改用客户端 GameObject 的实测真值（frida gobjs，权威）
|
||
//
|
||
// 旧常量把球瓶放在 z = 1577.35。那**不是任何一条道**：
|
||
// 球馆里只有 4 台机器（MiniGameMachine_Bowling_*），每台两条道（BowlingPinPlacementL / R）。
|
||
// 4 台机器的 L 道 z = 1566.773 / 1572.119 / 1576.114 / 1581.446。
|
||
// 1577.35 落在机器 3 与机器 4 之间的空档里，而玩家实际站在机器 1（z ≈ 1566.6）
|
||
// ⇒ 球瓶被推到 10.8 m 之外，什么都看不到。
|
||
//
|
||
// 实测数据（gobjs "BowlingPinPlacement" / "BowlingGameNode" / "BowlingGameStart" /
|
||
// "MiniGameMachine_Bowling"，每条 4 个实例 = 4 台机器）：
|
||
// · machineRoot.z + 0.485 = 该机器 L 道的中心线 z ← 本文件第 125 行的配方本来就是对的
|
||
// · 同一台机器 L / R 两个瓶位相差正好 2.00 m
|
||
// · x 方向：发球线 BowlingGameStart 2689.11 → 机器轴心 BowlingGameNode 2692.26 →
|
||
// 瓶阵 BowlingPinPlacement 2710.25，约 18 m，与标准保龄球道长度吻合
|
||
// · 所有锚点 y = 0.02（场地地面）
|
||
// ---------------------------------------------------------------------------------------
|
||
// ★ Lane / machine numbering — MEASURED, not invented (2026-09-23 late, confirmed by the player).
|
||
//
|
||
// The alley numbers its eight lanes 1..8 with lane 1 at the LARGEST z and lane 8 at the
|
||
// SMALLEST z, i.e. the numbering runs OPPOSITE to ascending z. The player stood at z=1566.77
|
||
// and read the painted number "7" on that lane — which is this array's index 0. So:
|
||
//
|
||
// asc-z order (small→large): 1564.77 1566.77 1570.12 1572.12 1574.11 1576.11 1579.45 1581.45
|
||
// game lane number : 8 7 6 5 4 3 2 1
|
||
//
|
||
// MachineNo/LaneNo below are the IN-GAME labels. Do not "fix" them back to ascending order —
|
||
// the geometry is right, only the naming was reversed before, which made every log line read
|
||
// one machine off (what the player pointed out as "why does it call this machine 1 when the
|
||
// number on the lane is 7, shouldn't it be machine 4 L?" — it should, and now it does).
|
||
private readonly record struct BowlingLane(
|
||
int MachineNo, int LaneNo,
|
||
float MachineX, float MachineZ, float LaneZ, float PinApexX,
|
||
float StartX, float StartZ, float GameNodeX, float GameNodeZ);
|
||
|
||
private static readonly BowlingLane[] BowlingLanes =
|
||
[
|
||
new(4, 7, 2688.4900f, 1566.2720f, 1566.7732f, 2710.2510f, 2689.1104f, 1566.7180f, 2692.2559f, 1567.1820f),
|
||
new(4, 8, 2688.4900f, 1566.2720f, 1564.7737f, 2710.2056f, 2689.1104f, 1566.7180f, 2692.2559f, 1567.1820f),
|
||
new(3, 5, 2688.6079f, 1571.6180f, 1572.1193f, 2710.3689f, 2689.2283f, 1572.0641f, 2692.3738f, 1572.5281f),
|
||
new(3, 6, 2688.6079f, 1571.6180f, 1570.1198f, 2710.3235f, 2689.2283f, 1572.0641f, 2692.3738f, 1572.5281f),
|
||
new(2, 3, 2688.6990f, 1575.6130f, 1576.1143f, 2710.4600f, 2689.3193f, 1576.0591f, 2692.4648f, 1576.5231f),
|
||
new(2, 4, 2688.6990f, 1575.6130f, 1574.1147f, 2710.4146f, 2689.3193f, 1576.0591f, 2692.4648f, 1576.5231f),
|
||
new(1, 1, 2688.8230f, 1580.9449f, 1581.4462f, 2710.5840f, 2689.4434f, 1581.3910f, 2692.5889f, 1581.8550f),
|
||
new(1, 2, 2688.8230f, 1580.9449f, 1579.4467f, 2710.5386f, 2689.4434f, 1581.3910f, 2692.5889f, 1581.8550f),
|
||
];
|
||
|
||
/// <summary>
|
||
/// The lane the player is standing on: nearest by z. The 8 entries are the alley's two lanes on
|
||
/// each of its four machines; picking by z means the balls and pins land where the player is
|
||
/// instead of on a hard-coded lane 10 m away.
|
||
/// </summary>
|
||
private static BowlingLane BowlingPickLane(float playerZ)
|
||
{
|
||
var best = BowlingLanes[0];
|
||
var bestD = float.MaxValue;
|
||
foreach (var lane in BowlingLanes)
|
||
{
|
||
var d = MathF.Abs(lane.LaneZ - playerZ);
|
||
if (d < bestD) { bestD = d; best = lane; }
|
||
}
|
||
return best;
|
||
}
|
||
|
||
private const float BowlingPinBaseY = 0.02f; // 场地地面高度（实测锚点 y）
|
||
private const float BowlingPinDepthStep = 0.26f; // per pin row, away from the player (+x)
|
||
private const float BowlingPinLateralStep = 0.30f; // within a row, across the lane (z)
|
||
private const float BowlingBallRackBack = 1.0f; // ball rack sits this far behind the foul line
|
||
private const float BowlingBallLateralStep = 0.35f;
|
||
private const float BowlingLaneHeadY = 0.12f; // 球心高度（球半径 ~0.11 + 地面 0.02）
|
||
|
||
// ---------------------------------------------------------------------------------------
|
||
// ★ WHY THE BALLS AND PINS NEVER APPEARED (root-caused 2026-09-23 LATE — replaces two earlier
|
||
// and WRONG theories that used to sit in this comment block)
|
||
//
|
||
// Symptom: "[BowlingGameManager] scene item 9100000000NN hold not found" for all 15 ids, then
|
||
// "pool[101] is nil" x73 and "[BowlingCharacter] AttachBallToHandr: self.currentBallGo is nil"
|
||
// — i.e. no ball in the hand AND no pins, which is ONE bug, not two.
|
||
//
|
||
// ★ TRUE CAUSE: the holds were never created, because the server pushed the wrong method id.
|
||
// SyncDestructibleGridAOIIncrease (68934309) does NOT exist on this client build. Proof: frida
|
||
// scanned all 69 259 classes across every assembly and the name appears ONLY on
|
||
// UX.Game.IGameSceneToClient (the interface) and UX.Game.Client.NullGameSceneToClientImpl (the
|
||
// no-op). LX6.Service.GameSceneToClientImpl — the class registered for S2C dispatch — does not
|
||
// have it. So the message was dropped with no error line at all, which is why this took so long:
|
||
// "no deserialize failure in the client log" was mistaken for "the client accepted it".
|
||
//
|
||
// The live sibling is SyncDestructibleGridAOIDecrease (68969593), and the ADD travels inside its
|
||
// `aoiInfo` parameter. That is the same trap the Gadget channel documents for itself — see
|
||
// Methods/GameScene/GadgetGridMethods4229938.cs: "only the *Decrease* side has a method id; the
|
||
// add is carried inside GadgetGridAOIIncrease aoiInfo". And the Gadget channel works: it is what
|
||
// put the interaction buttons in the right place.
|
||
//
|
||
// Corroborating measurement: with the alley fully loaded and the player standing in it,
|
||
// SceneItemMgr held exactly ONE SceneItemHold in the whole world — the one a frida experiment
|
||
// had built by hand via AddSceneItem(16). The client's own scene-item AOI had produced nothing,
|
||
// and SceneItemBlob.placeIdToGridSeekId (5434 authored placements) has no bowling entry near
|
||
// the alley cell (67,39). So the pins and balls are NOT baked scene items anywhere: the server
|
||
// has to hand them over explicitly, through aoiInfo.addInfos.
|
||
//
|
||
// Two theories this block used to assert, both now disproven:
|
||
// ✗ "68934309 DOES create the holds; only the GameObject load fails" — there were no holds.
|
||
// ✗ "PathId 1838106492 / 1959229003 are not scene-item pathIds so the prefab cannot resolve"
|
||
// — the pairing is right (confirmed in SceneItemPathInfoRuntime, 4325 live entries) and the
|
||
// BallCfgId/BallPathId pair is the one frida verified end-to-end. PathId was never the
|
||
// problem; it only looked like the sole candidate while the real bug hid in the method id.
|
||
//
|
||
// These values stay overridable from the hot-reloaded config/bowling_wire.json so a future
|
||
// pairing can be dropped in WITHOUT rebuilding or restarting the server.
|
||
// ---------------------------------------------------------------------------------------
|
||
private static readonly object BowlingWireLock = new();
|
||
private static string? _bowlingWireFile;
|
||
private static long _bowlingWireStamp = -1;
|
||
private static uint _ballCfg = BowlingWire.BallCfgId;
|
||
private static int _ballPath = BowlingWire.BallPathId;
|
||
private static uint _pinCfg = BowlingWire.PinCfgId;
|
||
private static int _pinPath = BowlingWire.PinPathId;
|
||
private static int _destructibleTag = BowlingWire.DestructibleTagBase;
|
||
|
||
// ---------------------------------------------------------------------------------------
|
||
// ★★ 球架的 5 个球（2026-09-24：「切球不能在这 5 个球中变换」的修复）
|
||
//
|
||
// 症状：按「切球」把下标在 1..5 之间切，拿到的球长得一模一样。
|
||
// 根因：服务端把 5 个球全按同一对 (ballCfg, ballPath) 推出去 ⇒ 客户端池子里是 5 个同款球。
|
||
// 而客户端取球是**纯按下标**：BowlingBallLauncher.CreateAnimBall ->
|
||
// gBowlingGameManager:Rent(self.CurBallIndex) -> Rent 内
|
||
// self.gameInstance.sceneItemBallList[type]。
|
||
// 下标顺序 = zoneInfo.BowlingBallSceneItemIdList 顺序 = 服务端 BallIds 顺序
|
||
// （客户端的 RegisterSceneItemBall 在本 build 里只有定义没有调用，列表完全来自服务端）。
|
||
// 完整的下标↔重量推导 + 活体 pathId 真表见 BowlingWire.BallSlotCfgIds 的注释。
|
||
// 修法：按推送顺序（= 客户端下标 1..5）用 5 组不同的 (cfg, pathId) = 8/10/12/14/16 磅。
|
||
//
|
||
// ballSet 语义（config/bowling_wire.json 热加载，默认 0）：
|
||
// 0 = 用 BowlingWire.BallSlotCfgIds/PathIds 的 5 个不同球（正常模式）
|
||
// 1 = 退回旧行为：5 个球全部用 ballCfgId/ballPathId 那一对（诊断 / 对照组）
|
||
// ballCfgN / ballPathN（N=1..5）可单槽覆盖，便于一次重启里做 A/B，
|
||
// 例：{"ballPath1":1838106492} 只把 1 号球换成对照球，其余不动。
|
||
// ---------------------------------------------------------------------------------------
|
||
private static int _ballSet;
|
||
private static uint[] _ballSlotCfg = (uint[])BowlingWire.BallSlotCfgIds.Clone();
|
||
private static int[] _ballSlotPath = (int[])BowlingWire.BallSlotPathIds.Clone();
|
||
|
||
// ---------------------------------------------------------------------------------------
|
||
// ★ 临时诊断开关：球瓶 (cfg,path) 交叉替换 + 计数编码实验（2026-09-24 第二轮）
|
||
//
|
||
// 症状：球瓶有物理、有撞击音效，但看不见。
|
||
//
|
||
// 已确证（本轮 ConfigDump 离线取证，全部可复现）：
|
||
// · SceneitemConfig.json 里 cfg 80003145 = "DefaultSceneItem/DefaultSceneItem_bowlingalley_
|
||
// bowlingpin001a" ⇒ **球瓶 cfg 是对的**（球 80002967 = ..._bowlingsphere004a）。
|
||
// modelId 对照：52007069=pin, 52007070=sphere004a, 52007071=003a, 52007072=002a, 52007073=001a。
|
||
// · SoundDestructibleConfig.Id **就是场景物的 pathId**（实测规则，6 个已验 pathId 中 5 个命中，
|
||
// 材质名与物体类型全部吻合：1838106492→plastic_bowling_ball、2132486638→plastic_bin、
|
||
// 1843390629/680591215→soft_sofa；唯一未命中的 1838106493 是那个改用 ModelResPath 的 16 磅球）。
|
||
// ⇒ 1959229003 出现在该表且 FillInMaterial = "wooden_bowling_pin"，
|
||
// **它很可能真的是球瓶的 pathId**（上一轮"它只是音效材质 id"的判断是错的）。
|
||
// · pathId 不是资源名哈希（fnv1a/fnv1/djb2/sdbm/java/crc32/murmur3/xxh32/md5/sha1 × 14 种写法
|
||
// 全部落空），也不是小整数索引 ⇒ 只能实测，不能离线推算。
|
||
// · 客户端那 4325 条 PathInfo 表里按保龄球 cfg 白名单只命中 5 条、全是球，不含 80003145。
|
||
//
|
||
// ⇒ 现在剩下两个变量：cfg 与 path 到底哪个决定"有没有模型/渲染哪种模型"。
|
||
// 本开关把 10 个球瓶按 4/3/2/1 分成 4 组，同时改 cfg 和 path：
|
||
// 组0（4 个）= (80002967, 1838106492) ← 球的**原配对**，纯对照组。
|
||
// ★ 这 4 个只要渲染出来，就证明"服务端推的场景物能出模型"，本机制成立。
|
||
// 组1（3 个）= (80003145, 1838106492) ← 球瓶 cfg + 球的 path ⇒ 检验是不是 cfg 决定模型
|
||
// 组2（2 个）= (80003145, 1838106494)
|
||
// 组3（1 个）= (80003145, 1838106495)
|
||
//
|
||
// 读数对照表（看球瓶/球各现几个）：
|
||
// 4 球 + 3 瓶 ⇒ cfg 决定模型 ⇒ 直接可用 (80003145, 1838106492) 收工
|
||
// 4 球 + 3 球 + 2 瓶 ⇒ path 决定模型，且 1838106494 就是球瓶 ⇒ 收工
|
||
// 4 球 + 3 球 + 1 瓶 ⇒ path 决定模型，且 1838106495 就是球瓶 ⇒ 收工
|
||
// 4 球 + 3 球 + 0 瓶 ⇒ 494/495 都不是 ⇒ 下一轮试 1838106496，以及回测 1959229003
|
||
// 只有 4 球、组1 什么都没出 ⇒ cfg/path 必须是**成对匹配**的 ⇒ 只能靠 path 逐个试
|
||
// 连 4 球都不出 ⇒ 推过去的东西根本不渲染（"球看得见"其实是 BF1 手上那颗，
|
||
// 不是我们推的 5 颗）⇒ 要换整体思路，别再猜 pathId 了
|
||
//
|
||
// 打开方式：config/bowling_wire.json 写 {"pinPathProbe":1}。删掉或写 0 即恢复用 pinPathId。
|
||
// ---------------------------------------------------------------------------------------
|
||
private static int _pinPathProbe = 0;
|
||
private static readonly uint[] PinPathProbeCfgs = { 80002967u, 80003145u, 80003145u, 80003145u };
|
||
private static readonly int[] PinPathProbePaths = { 1838106492, 1838106492, 1838106494, 1838106495 };
|
||
private static readonly int[] PinPathProbeQuota = { 4, 3, 2, 1 };
|
||
|
||
/// <summary>把第 ordinal 个球瓶（0 起，按推送顺序）映射到候选下标。见 _pinPathProbe。</summary>
|
||
private static int PinPathProbeCandidate(int ordinal)
|
||
{
|
||
int acc = 0;
|
||
for (int i = 0; i < PinPathProbeQuota.Length; i++)
|
||
{
|
||
acc += PinPathProbeQuota[i];
|
||
if (ordinal < acc) return i;
|
||
}
|
||
return PinPathProbeQuota.Length - 1;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Hot-reloaded bowling wire overrides. File: <c>config/bowling_wire.json</c> next to the
|
||
/// server (same folder as private-server.json). Shape:
|
||
/// <c>{"ballCfgId":80002967,"ballPathId":1838106492,"pinCfgId":80003145,"pinPathId":1959229003,"destructibleTag":1}</c>
|
||
/// Missing file / missing key / unparsable value = keep the compiled-in default. Re-read
|
||
/// whenever the file's last-write tick changes, so an edit takes effect on the next zone entry.
|
||
///
|
||
/// <c>destructibleTag</c> (default 1, alternate 255) picks the polymorphic marker byte used for
|
||
/// each DestructibleInfo on the wire — see BowlingWire.DestructibleTagBase for why the old
|
||
/// hard-coded 0xFF made the client answer "deserialize failed ... parameter=DestructibleInfo"
|
||
/// and create no balls or pins at all.
|
||
///
|
||
/// <c>pinPathProbe</c> (0 = off) turns on the 10-pin (cfg,path) A/B sweep described above
|
||
/// <see cref="_pinPathProbe"/>; 0 (or omitting the key) restores the plain pinCfgId/pinPathId pair.
|
||
/// </summary>
|
||
private static (uint ballCfg, int ballPath, uint pinCfg, int pinPath) BowlingWireNow()
|
||
{
|
||
try
|
||
{
|
||
if (_bowlingWireFile == null)
|
||
{
|
||
var candidates = new List<string>();
|
||
Action<string> addDir = (string dir) =>
|
||
{
|
||
if (string.IsNullOrEmpty(dir)) return;
|
||
var d = new DirectoryInfo(dir);
|
||
for (int up = 0; up < 6 && d != null; up++, d = d.Parent)
|
||
candidates.Add(Path.Combine(d.FullName, "config", "bowling_wire.json"));
|
||
};
|
||
addDir(AppContext.BaseDirectory);
|
||
try { addDir(Directory.GetCurrentDirectory()); } catch { }
|
||
|
||
_bowlingWireFile = candidates.FirstOrDefault(File.Exists) ?? "";
|
||
}
|
||
|
||
if (_bowlingWireFile.Length == 0) goto done;
|
||
|
||
var stamp = new FileInfo(_bowlingWireFile).LastWriteTimeUtc.Ticks;
|
||
if (stamp == _bowlingWireStamp) goto done;
|
||
|
||
lock (BowlingWireLock)
|
||
{
|
||
if (stamp == _bowlingWireStamp) goto done;
|
||
var txt = File.ReadAllText(_bowlingWireFile);
|
||
_ballCfg = BowlingWire.BallCfgId;
|
||
_ballPath = BowlingWire.BallPathId;
|
||
_pinCfg = BowlingWire.PinCfgId;
|
||
_pinPath = BowlingWire.PinPathId;
|
||
_destructibleTag = BowlingWire.DestructibleTagBase;
|
||
_pinPathProbe = 0;
|
||
_pinAsGadget = 0;
|
||
_gadgetProbePathId = 79300636;
|
||
_gadgetPushDelayMs = 0;
|
||
_ballSet = 0;
|
||
_ballSlotCfg = (uint[])BowlingWire.BallSlotCfgIds.Clone();
|
||
_ballSlotPath = (int[])BowlingWire.BallSlotPathIds.Clone();
|
||
foreach (var kv in ParseFlatJson(txt))
|
||
{
|
||
switch (kv.Key)
|
||
{
|
||
case "ballCfgId": _ballCfg = kv.Value.u; break;
|
||
case "ballPathId": _ballPath = kv.Value.i; break;
|
||
case "ballSet": _ballSet = kv.Value.i; break;
|
||
case "ballCfg1": _ballSlotCfg[0] = kv.Value.u; break;
|
||
case "ballCfg2": _ballSlotCfg[1] = kv.Value.u; break;
|
||
case "ballCfg3": _ballSlotCfg[2] = kv.Value.u; break;
|
||
case "ballCfg4": _ballSlotCfg[3] = kv.Value.u; break;
|
||
case "ballCfg5": _ballSlotCfg[4] = kv.Value.u; break;
|
||
case "ballPath1": _ballSlotPath[0] = kv.Value.i; break;
|
||
case "ballPath2": _ballSlotPath[1] = kv.Value.i; break;
|
||
case "ballPath3": _ballSlotPath[2] = kv.Value.i; break;
|
||
case "ballPath4": _ballSlotPath[3] = kv.Value.i; break;
|
||
case "ballPath5": _ballSlotPath[4] = kv.Value.i; break;
|
||
case "pinCfgId": _pinCfg = kv.Value.u; break;
|
||
case "pinPathId": _pinPath = kv.Value.i; break;
|
||
case "destructibleTag": _destructibleTag = kv.Value.i; break;
|
||
case "pinPathProbe": _pinPathProbe = kv.Value.i; break;
|
||
case "pinAsGadget": _pinAsGadget = kv.Value.i; break;
|
||
case "gadgetProbePathId": _gadgetProbePathId = kv.Value.i; break;
|
||
case "gadgetPushDelayMs": _gadgetPushDelayMs = kv.Value.i; break;
|
||
}
|
||
}
|
||
_bowlingWireStamp = stamp;
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// never let a bad override file break zone entry
|
||
}
|
||
|
||
done:
|
||
return (_ballCfg, _ballPath, _pinCfg, _pinPath);
|
||
}
|
||
|
||
/// <summary>Minimal flat {"k":number|"s"} reader — no JSON dependency in this assembly.</summary>
|
||
private static IEnumerable<KeyValuePair<string, (uint u, int i)>> ParseFlatJson(string txt)
|
||
{
|
||
foreach (Match m in Regex.Matches(txt, "\"(?<k>\\w+)\"\\s*:\\s*\"?(?<v>-?\\d+)\"?"))
|
||
{
|
||
if (!long.TryParse(m.Groups["v"].Value, out var v)) continue;
|
||
yield return new KeyValuePair<string, (uint, int)>(
|
||
m.Groups["k"].Value, ((uint)(v & 0xFFFFFFFFL), (int)v));
|
||
}
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------------
|
||
// EnterBowlingZone (67832701) — args: u64 gadgetuid, byte gametype, u32 agentid
|
||
// ---------------------------------------------------------------------------------------
|
||
[Handler(MethodId.EnterBowlingZone, HandlerPacketKind.Invoke)]
|
||
private async Task EnterBowlingZone4229938(Connection conn, UxRpcMessage msg)
|
||
{
|
||
// ClientToGameSceneDelegate.EnterBowlingZone(gadgetuid : u64, gametype : byte, agentid : u32)
|
||
ulong gadgetUId = 0;
|
||
byte gameType = BowlingWire.BowlingGameTypeSingle;
|
||
uint agentTemplateId = 0;
|
||
if (msg.Body is { Length: >= 13 })
|
||
{
|
||
gadgetUId = BitConverter.ToUInt64(msg.Body, 0);
|
||
gameType = msg.Body[8];
|
||
agentTemplateId = BitConverter.ToUInt32(msg.Body, 9);
|
||
}
|
||
|
||
await StartBowlingZoneAsync(conn, msg.Context, gadgetUId, gameType, agentTemplateId, "EnterBowlingZone");
|
||
|
||
// The invoke's return value is the agent id handed to EnterGame's callback; 0 for Single.
|
||
await conn.ReturnAsync(msg, 0UL);
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------------
|
||
// GmEnterBowlingZone (69135013) — the GM-console door into the very same zone entry.
|
||
//
|
||
// Measured against this build, not guessed:
|
||
// * ClientToGameSceneGMDelegate.lua:417-425 serialises
|
||
// (gadgetuid : u64, gametype : u32, agentid : u32) -> 16 bytes. The live log confirmed
|
||
// "-- rpc GmEnterBowlingZone [0x041EEAA5] 16b".
|
||
// * RPCDeserializeAuto.lua:16312 gives 69135013 an EMPTY return reader, i.e. this one is void
|
||
// (unlike EnterBowlingZone at :15955, which reads back a u64 agent id).
|
||
//
|
||
// These are two DIFFERENT RPCs and neither implies the other. The in-world GM console — which is
|
||
// exactly what the debug API's /api/gm/send drives via SyncDoGmCommand — only ever sends
|
||
// 69135013. So with EnterBowlingZone whitelisted and this one missing, the command fell through
|
||
// to DefaultUnknownInvoke4229938's typed-default body: the client got a structurally valid empty
|
||
// reply and simply did nothing, /api/gm/send reported "尚未回显", and the server log showed
|
||
// "! [RPC4229938] unimplemented GmEnterBowlingZone [0x041EEAA5] -> typed-default void 0b".
|
||
// The gameplay path (walking up to the alley machine) uses 67832701 and was never affected.
|
||
// ---------------------------------------------------------------------------------------
|
||
[Handler(MethodId.GmEnterBowlingZone, HandlerPacketKind.Invoke)]
|
||
private async Task GmEnterBowlingZone4229938(Connection conn, UxRpcMessage msg)
|
||
{
|
||
ulong gadgetUId = 0;
|
||
uint gameType = BowlingWire.BowlingGameTypeSingle;
|
||
uint agentId = 0;
|
||
if (msg.Body is { Length: >= 16 })
|
||
{
|
||
gadgetUId = BitConverter.ToUInt64(msg.Body, 0);
|
||
gameType = BitConverter.ToUInt32(msg.Body, 8);
|
||
agentId = BitConverter.ToUInt32(msg.Body, 12);
|
||
}
|
||
|
||
conn.Log.Info($"[BOWLING] GmEnterBowlingZone gadgetUId={gadgetUId} gameType={gameType} agentId={agentId} bytes={msg.Body.Length}");
|
||
|
||
// gameType is a u32 on the wire here and a byte everywhere downstream; clamp is fine because
|
||
// the only values the client's own BowlingGameType enum defines are 0/1/2.
|
||
var narrowType = gameType <= byte.MaxValue ? (byte)gameType : BowlingWire.BowlingGameTypeSingle;
|
||
await StartBowlingZoneAsync(conn, msg.Context, gadgetUId, narrowType, agentId, "GmEnterBowlingZone");
|
||
|
||
await conn.ReturnEmptyOkAsync(msg);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Shared body of both zone-entry doors (EnterBowlingZone / GmEnterBowlingZone): mint the
|
||
/// per-connection zone session, push the balls + pins as destructibles, then push the
|
||
/// SyncGameGroundZoneInfo(tag 5) payload the client's manager gates on. The caller owns the
|
||
/// RPC reply, because the two doors have different return shapes.
|
||
/// </summary>
|
||
private async Task StartBowlingZoneAsync(Connection conn, RpcContext ctx, ulong gadgetUId, byte gameType, uint agentTemplateId, string source)
|
||
{
|
||
var state = GetWorldState(ctx);
|
||
var session = GetBowlingSession(ctx);
|
||
session.GadgetUId = gadgetUId;
|
||
session.ZoneSessionId = $"bowl-{ctx.Session.Id}-{IdCounterStore.Next(BowlingZoneSeqCounter, 1)}";
|
||
session.StartedUtcTicks = DateTime.UtcNow.Ticks;
|
||
session.BallIds.Clear();
|
||
session.PinIds.Clear();
|
||
|
||
var playerPos = state.LastReportedPlayerPosition;
|
||
var lane = BowlingPickLane(playerPos.Z);
|
||
var laneHeadX = lane.GameNodeX + 0.24f;
|
||
conn.Log.Info(
|
||
$"[BOWLING] {source} gadgetUId={gadgetUId} gameType={gameType} agentTemplateId={agentTemplateId} " +
|
||
$"machine={lane.MachineNo} lane={lane.LaneNo} laneZ={lane.LaneZ:F3} " +
|
||
$"machineXZ={lane.MachineX:F2}/{lane.MachineZ:F3} " +
|
||
$"pinApex=({lane.PinApexX:F3},{BowlingPinBaseY:F2},{lane.LaneZ:F3}) " +
|
||
$"laneHead=({laneHeadX:F2},{BowlingLaneHeadY:F2},{lane.LaneZ:F3}) " +
|
||
$"player=({playerPos.X:F1},{playerPos.Y:F1},{playerPos.Z:F1}) " +
|
||
$"playerToLaneHead={MathF.Sqrt(MathF.Pow(laneHeadX - playerPos.X, 2f) + MathF.Pow(lane.LaneZ - playerPos.Z, 2f)):F2}m");
|
||
|
||
// Balls + pins first: the client's 5 s window starts as soon as the zone info lands, and the
|
||
// zone info is what tells it which ids to wait for. Both are id-stable, so the lists below
|
||
// and the destructible push describe the same objects.
|
||
await PushBowlingSceneItemsAsync(conn, session, playerPos);
|
||
|
||
var zoneInfo = new BowlingZoneInfo
|
||
{
|
||
GameType = gameType,
|
||
CurrentRound = 0,
|
||
CurrentSubRound = 0,
|
||
CurrentTurn = 0,
|
||
// Non-null EMPTY score object, deliberately NOT null. The client's own writer declares this
|
||
// member nullable=false (Base.WriteComplex(writer, val.ScoreInfo, ..., "ScoreInfo", false)),
|
||
// so the official server ALWAYS sends a body here and the client's game code is written
|
||
// against a present ScoreInfo. Sending the null marker (0x00) would still decode — the
|
||
// reader is Base.ReadComplex, which returns nil for 0x00 — but it risks a nil deref inside
|
||
// the client's bowling manager, and it is a shape the official server never emits.
|
||
ScoreInfo = new BowlingScoreInfo(),
|
||
BowlingPinSceneItemIdList = new List<ulong>(session.PinIds),
|
||
BowlingBallSceneItemIdList = new List<ulong>(session.BallIds),
|
||
ZoneSessionId = session.ZoneSessionId,
|
||
GadgetUId = gadgetUId,
|
||
TaskId = 0,
|
||
StartReason = BowlingWire.ZoneStartReasonSingle,
|
||
GameTypeRandom = false,
|
||
SyncReason = BowlingWire.ZoneSyncReasonEnter, // MUST be Enter(0): the manager branches on it
|
||
ZoneType = BowlingWire.ZoneTypeBowling, // 2 (NOT the polymorphic tag, which is 5)
|
||
ZoneState = BowlingWire.ZoneStateIdle,
|
||
ParticipantInfos = new List<BowlingParticipantInfo>(), // empty, never null
|
||
CountDownInfo = new GameGroundZoneCountDownInfo(),
|
||
};
|
||
|
||
await conn.NotifyAsync(MethodId.SyncGameGroundZoneInfo, zoneInfo);
|
||
conn.Log.Info($"[BOWLING] pushed SyncGameGroundZoneInfo tag=5 balls={session.BallIds.Count} pins={session.PinIds.Count} source={source}");
|
||
|
||
// ★ 诊断实验：把 10 个球瓶再叠一层 gadget（健身房器材那条已验证可见的通道）。
|
||
// 放在 zone info **之后**推，免得拖慢进场；见 GameRouter.BowlingPinGadget.cs。
|
||
// 默认关闭，config 里 pinAsGadget=1 才走。
|
||
await PushBowlingPinGadgetsAsync(conn, session, playerPos);
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------------
|
||
// LeaveBowling (67245027) — args: u64 gadgetuid, bool abort
|
||
// ---------------------------------------------------------------------------------------
|
||
[Handler(MethodId.LeaveBowling, HandlerPacketKind.Both)]
|
||
private async Task LeaveBowling4229938(Connection conn, UxRpcMessage msg)
|
||
{
|
||
ulong gadgetUId = 0;
|
||
bool abort = false;
|
||
if (msg.Body is { Length: >= 9 })
|
||
{
|
||
gadgetUId = BitConverter.ToUInt64(msg.Body, 0);
|
||
abort = msg.Body[8] != 0;
|
||
}
|
||
|
||
if (msg.Context.Session.Items.TryGetValue(BowlingStateKey, out var raw) && raw is BowlingSession session)
|
||
{
|
||
session.BallIds.Clear();
|
||
session.PinIds.Clear();
|
||
session.GadgetUId = 0;
|
||
}
|
||
|
||
conn.Log.Info($"[BOWLING] LeaveBowling gadgetUId={gadgetUId} abort={abort} -> Ok");
|
||
await conn.ReturnEmptyOkAsync(msg);
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------------
|
||
// In-session RPCs. These are all Invokes from ClientToGameSceneDelegate and each caller does
|
||
// .Callback = function(err) try_handle_error(err, name) end, so a missing reply stalls the loop.
|
||
// The server keeps no score book: it answers Ok and lets the client's own mini-game drive.
|
||
// (Scoring/modes belong to P2; online/agent modes belong to P3.)
|
||
// ---------------------------------------------------------------------------------------
|
||
[Handler(MethodId.RecordBowlingScore, HandlerPacketKind.Both)]
|
||
[Handler(MethodId.RecordAgentBowlingScore, HandlerPacketKind.Both)]
|
||
[Handler(MethodId.RecordAllBowlingScoreAndDrop, HandlerPacketKind.Both)]
|
||
[Handler(MethodId.AskBowlingRelease, HandlerPacketKind.Both)]
|
||
[Handler(MethodId.AskAgentBowlingRelease, HandlerPacketKind.Both)]
|
||
[Handler(MethodId.AskBowlingBuyTicket, HandlerPacketKind.Both)]
|
||
[Handler(MethodId.BroadcastBowlingClientInfo, HandlerPacketKind.Both)]
|
||
[Handler(MethodId.SetGameGroundPlayerReady, HandlerPacketKind.Both)]
|
||
[Handler(MethodId.SetGameGroundPlayerPlayAgain, HandlerPacketKind.Both)]
|
||
[Handler(MethodId.SetGameGroundPlayerSurrender, HandlerPacketKind.Both)]
|
||
[Handler(MethodId.LeaveGameGroundZone, HandlerPacketKind.Both)]
|
||
private async Task BowlingGenericAccept4229938(Connection conn, UxRpcMessage msg)
|
||
{
|
||
conn.Log.Info($"[BOWLING] {msg.MethodId} bytes={msg.Body.Length} -> Ok");
|
||
await conn.ReturnEmptyOkAsync(msg);
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------------
|
||
// Helpers
|
||
// ---------------------------------------------------------------------------------------
|
||
|
||
/// <summary>
|
||
/// Push the bowling balls (5) and pins (10) as destructibles so the client creates + loads the
|
||
/// matching SceneItem holds. reason = AoiAddAndRemoveReason.Init (0) — the field is NOT a
|
||
/// DestructibleCreateReason; see BowlingWire.AoiReasonInit.
|
||
///
|
||
/// Why this is the right channel: mid 68969593 lands on
|
||
/// <c>LX6.Service.GameSceneToClientImpl.SyncDestructibleGridAOIDecrease(aoiInfo, addGridInfo,
|
||
/// removeGridInfo)</c>, whose <c>aoiInfo</c> is the <c>UX.Game.DestructibleGridAOIIncrease</c> this
|
||
/// file already builds — addInfos / indexList / addUniqueIds / removeIds all ride inside it. The
|
||
/// client then materialises the holds, and <c>SceneItemMgr</c> is what serves the
|
||
/// <c>GetSceneItemHold</c> lookup that BowlingGameManager.CheckDisableSceneItems gates on.
|
||
///
|
||
/// (The previous version of this comment named mid 68934309 /
|
||
/// <c>SceneItemMgr.SyncSceneItemGridAOIIncrease</c>. That method does exist on SceneItemMgr, but
|
||
/// no S2C handler on the client ever reaches it: GameSceneToClientImpl has no
|
||
/// SyncDestructibleGridAOIIncrease at all, so 68934309 is dropped on arrival. Existence of a
|
||
/// client method is NOT evidence that a method id reaches it.)
|
||
///
|
||
/// The game repositions/rents them itself afterwards (BowlingPinSetter.CreatePin ->
|
||
/// BowlingGameManager:Rent), so the spawn position only has to be close enough for the client's
|
||
/// 5 s CheckDisableSceneItems window — it is not the final lane layout. It does still have to be
|
||
/// ON THE LANE, though: the first cut spawned them relative to the player and the whole mini-game
|
||
/// played out in the alley doorway. Positions below come from the lane table measured off the
|
||
/// alley's own GameObjects (see the BowlingLanes block at the top of this file); each lane runs
|
||
/// along +x and is 2 m from its neighbour in z.
|
||
/// </summary>
|
||
private async Task PushBowlingSceneItemsAsync(Connection conn, BowlingSession session, Vec3 playerPos)
|
||
{
|
||
var (ballCfg, ballPath, pinCfg, pinPath) = BowlingWireNow();
|
||
|
||
// The lane the player is standing on (see BowlingLanes). Re-picked here so this helper is
|
||
// correct even when called from a door that did not compute it.
|
||
var lane = BowlingPickLane(playerPos.Z);
|
||
var laneHeadX = lane.GameNodeX + 0.24f;
|
||
|
||
var infos = new List<DestructibleInfo>();
|
||
var infosFF = new List<DestructibleInfoMarkFF>(); // same values, 0xFF marker (hot fallback)
|
||
var ids = new List<ulong>();
|
||
var cells = new Dictionary<(int, int), bool>();
|
||
var ballWireLog = new List<string>(); // 每槽实际推的 (cfg,path)，进日志便于核对
|
||
|
||
// ★ 一批 15 个 id，批号走 IdCounterStore 落盘（见上方 BowlingSceneItemIdBase 的说明）：
|
||
// 批内第 i 个 = base + i ⇒ (id - ID_BASE) % 15 == i，与客户端 BF1 补丁的
|
||
// idx = (n - ID_BASE) % BATCH 严格对齐（i<10 瓶、i>=10 球）。
|
||
var batch = (ulong)IdCounterStore.Next(BowlingSceneItemBatchCounter, 0);
|
||
var batchBase = BowlingSceneItemIdBase + batch * (ulong)BowlingSceneItemBatchSize;
|
||
var slot = 0;
|
||
|
||
void Add(float x, float y, float z, uint cfgId, int pathId, List<ulong> bucket)
|
||
{
|
||
var id = batchBase + (ulong)slot++;
|
||
|
||
// ★ The polymorphic marker byte is the one field that differs between the two variants.
|
||
// DestructibleInfo is tag-marked (see BowlingWire.DestructibleTagBase); 0xFF is only
|
||
// valid where a metatable fallback exists, which the C# dispatch of 68963429 does not have.
|
||
var pos = new UXVector3 { X = x, Y = y, Z = z };
|
||
infos.Add(new DestructibleInfo
|
||
{
|
||
InstanceId = id,
|
||
UniqueId = id,
|
||
CfgId = cfgId,
|
||
PathId = pathId,
|
||
Position = pos,
|
||
Facing = new UXVector3 { X = 0, Y = 0, Z = 0 },
|
||
IScale = 100,
|
||
NavId = 0,
|
||
ForceLod0 = false,
|
||
BindPid = 0,
|
||
Hp = 1f,
|
||
State = BowlingWire.DestructibleStateActive,
|
||
BreakStage = 0,
|
||
OccupantInfos = new List<SceneDeviceOccupantInfo>(),
|
||
DropWeaponId = 0,
|
||
StackCount = 1,
|
||
EffectIds = new List<int>(),
|
||
NoSleep = true,
|
||
ReleaserId = 0,
|
||
SkillInfo = null,
|
||
});
|
||
infosFF.Add(new DestructibleInfoMarkFF
|
||
{
|
||
InstanceId = id,
|
||
UniqueId = id,
|
||
CfgId = cfgId,
|
||
PathId = pathId,
|
||
Position = new UXVector3 { X = x, Y = y, Z = z },
|
||
Facing = new UXVector3 { X = 0, Y = 0, Z = 0 },
|
||
IScale = 100,
|
||
NavId = 0,
|
||
ForceLod0 = false,
|
||
BindPid = 0,
|
||
Hp = 1f,
|
||
State = BowlingWire.DestructibleStateActive,
|
||
BreakStage = 0,
|
||
OccupantInfos = new List<SceneDeviceOccupantInfo>(),
|
||
DropWeaponId = 0,
|
||
StackCount = 1,
|
||
EffectIds = new List<int>(),
|
||
NoSleep = true,
|
||
ReleaserId = 0,
|
||
SkillInfo = null,
|
||
});
|
||
ids.Add(id);
|
||
bucket.Add(id);
|
||
cells[((int)MathF.Floor(x / 40f), (int)MathF.Floor(z / 40f))] = true;
|
||
}
|
||
|
||
// 10 pins in a 1-2-3-4 triangle on the official pin deck. Row 0 is the HEAD PIN (nearest the
|
||
// player), each further row sits BowlingPinDepthStep closer to the back of the house and is
|
||
// one pin wider. Numbers taken from the alley's own BowlingGameNodeRight/BowlingPinPlacementR
|
||
// children (apex 2711.29 / 1590.03, lateral 0.31, depth 0.26).
|
||
int pinOrdinal = 0; // 0..9，仅在 _pinPathProbe 打开时用
|
||
for (int r = 0; r < 4; r++)
|
||
{
|
||
int n = r + 1;
|
||
for (int c = 0; c < n; c++)
|
||
{
|
||
float lateral = (c - (n - 1) * 0.5f) * BowlingPinLateralStep;
|
||
float depth = r * BowlingPinDepthStep;
|
||
// ★ 诊断：按 4/3/2/1 把 10 个球瓶分给 4 组 (cfg,path)；见 _pinPathProbe 的读数对照表。
|
||
uint thisPinCfg = pinCfg;
|
||
int thisPinPath = pinPath;
|
||
if (_pinPathProbe != 0)
|
||
{
|
||
int ci = PinPathProbeCandidate(pinOrdinal);
|
||
thisPinCfg = PinPathProbeCfgs[ci];
|
||
thisPinPath = PinPathProbePaths[ci];
|
||
}
|
||
Add(lane.PinApexX + depth, BowlingPinBaseY, lane.LaneZ + lateral,
|
||
thisPinCfg, thisPinPath, session.PinIds);
|
||
pinOrdinal++;
|
||
}
|
||
}
|
||
|
||
// 5 balls in a row on the approach, just behind the foul line (the official
|
||
// BowlingSceneNode/PivotNode/BallSpawnPoint is the foul line itself).
|
||
//
|
||
// ★★ 顺序即语义：第 b 次 Add 的球会被客户端放进 sceneItemBallList[b+1]，而
|
||
// CreateAnimBall/SelectBall 的 CurBallIndex 就是 1..5（= 8/10/12/14/16 磅）。
|
||
// 所以这里必须按下标取 (cfg,path)，**不能**再全用同一对 —— 否则「切球看不出变化」。
|
||
// 见 BowlingWire.BallSlotCfgIds 与字段 _ballSet 的注释。
|
||
for (int b = 0; b < BowlingWire.BallSlotCount; b++)
|
||
{
|
||
float lateral = (b - 2f) * BowlingBallLateralStep;
|
||
uint thisBallCfg = ballCfg;
|
||
int thisBallPath = ballPath;
|
||
if (_ballSet == 0 && b < _ballSlotCfg.Length && b < _ballSlotPath.Length)
|
||
{
|
||
thisBallCfg = _ballSlotCfg[b];
|
||
thisBallPath = _ballSlotPath[b];
|
||
}
|
||
|
||
Add(laneHeadX - BowlingBallRackBack, BowlingLaneHeadY, lane.LaneZ + lateral,
|
||
thisBallCfg, thisBallPath, session.BallIds);
|
||
|
||
ballWireLog.Add($"{b + 1}=(lb{2 * (b + 1) + 6}:{thisBallCfg}/{thisBallPath})");
|
||
}
|
||
|
||
cells[((int)MathF.Floor(playerPos.X / 40f), (int)MathF.Floor(playerPos.Z / 40f))] = true;
|
||
var indexList = new List<SceneMethods.GridIndex>();
|
||
foreach (var c in cells.Keys) indexList.Add(new SceneMethods.GridIndex { X = c.Item1, Z = c.Item2 });
|
||
|
||
var payload = new DestructibleGridAOIIncrease
|
||
{
|
||
PlayerStandardIndex = new SceneMethods.GridIndex
|
||
{
|
||
X = (int)MathF.Floor(playerPos.X / 40f),
|
||
Z = (int)MathF.Floor(playerPos.Z / 40f),
|
||
},
|
||
AddInfos = infos,
|
||
IndexList = indexList,
|
||
AddUniqueIds = new List<ulong>(ids),
|
||
RemoveIds = new List<ulong>(),
|
||
Reason = BowlingWire.AoiReasonInit,
|
||
};
|
||
|
||
// ★★ THE channel that actually creates the holds: SyncDestructibleGridAOIDecrease (68969593).
|
||
//
|
||
// NOT SyncDestructibleGridAOIIncrease (68934309). That id is DEAD on this client build: a
|
||
// full scan of every class in every assembly (69 259 classes, frida `h4findmeth`) finds it
|
||
// only on the interface UX.Game.IGameSceneToClient and on the no-op
|
||
// UX.Game.Client.NullGameSceneToClientImpl — LX6.Service.GameSceneToClientImpl, the class
|
||
// that actually handles S2C, does not implement it. So the message was dropped silently and
|
||
// NOT ONE scene item hold was ever created (measured: SceneItemMgr held exactly one hold in
|
||
// the whole world, and that one was hand-built by a frida experiment).
|
||
//
|
||
// The live sibling carries the ADD inside `aoiInfo` and takes two plain cell specs — the
|
||
// exact same naming trap the Gadget channel documents for itself, and that channel is the
|
||
// one that already works (SyncGadgetGridAOIDecrease 68956797 = the interaction buttons).
|
||
var gridArgs = new SyncDestructibleGridAOIDecreaseArgs4229938
|
||
{
|
||
aoiInfo = payload,
|
||
addGridInfo = new SceneMethods.GridAOIDecrease
|
||
{
|
||
// Sector 0 is the base/outdoor sector. The alley cell (67,39) resolves to
|
||
// [0] / [0, 780747247] in the gadget-grid log, and its first group is [0].
|
||
SectorIdList = new List<int> { 0 },
|
||
BuildingId = 0,
|
||
StandardIndexList = indexList
|
||
.Select(c => new SceneMethods.GridIndex { X = c.X, Z = c.Z })
|
||
.ToList(),
|
||
ExceptIds = new List<ulong>(),
|
||
},
|
||
removeGridInfo = new SceneMethods.GridAOIDecrease(),
|
||
};
|
||
var gridBytes = UxSerializer.Serialize(gridArgs);
|
||
await conn.NotifyRawAsync(MethodId.SyncDestructibleGridAOIDecrease, gridBytes);
|
||
|
||
// ★ The marker byte on each item is what decides whether the client can read this at all.
|
||
// Default = the concrete base tag (1); 255 is the Lua-tree-compatible spelling and stays
|
||
// available for one in-game A/B if a future build disagrees. See BowlingWire.DestructibleTagBase.
|
||
byte[] addBytes;
|
||
string tagLabel;
|
||
if (_destructibleTag == BowlingWire.DestructibleTagAltFF)
|
||
{
|
||
addBytes = UxSerializer.Serialize(new DestructibleObjectAddListMarkFF { AddInfos = infosFF });
|
||
tagLabel = "0xFF(lua-compat)";
|
||
}
|
||
else
|
||
{
|
||
addBytes = UxSerializer.Serialize(new DestructibleObjectAddList { AddInfos = infos });
|
||
tagLabel = "1(concrete base tag)";
|
||
}
|
||
// ★ NotifyRawAsync, NOT NotifyAsync: addBytes is already a serialized UX body. Before the
|
||
// byte[] overload existed on Connection, this resolved to the generic NotifyAsync<byte[]>,
|
||
// whose UxSerializer path treats a top-level byte[] as a *buffer value* and prefixes it with
|
||
// 0xFF + Int7(length) — so the client read "1518 DestructibleInfo items" from a 1518-byte
|
||
// body, failed on item 1, and the whole scene-item layer (ball rack + pin deck) stayed
|
||
// unregistered. Empty ball pool -> AttachBallToHandr: self.currentBallGo is nil.
|
||
// ★ SIDE-CHANNEL: dump exactly what we are about to push, so a client-side patch
|
||
// (frida) can synthesise a matching SceneItemPlaceInfoData for each id. The client's
|
||
// ONLY gate into the scene-item layer is
|
||
// SceneItemBlob.TryGetSceneItemPlaceInfoDataByPlaceId(uniqueId, out MA_Ref, out blobType)
|
||
// and the official level bakes ZERO balls/pins (verified offline: cell (67,39)'s blob
|
||
// holds only 19 chairs/benches/bins; BowlingConfig.json is empty). So frida must fake
|
||
// the lookup — and to fake it faithfully it needs these numbers.
|
||
try
|
||
{
|
||
var sb = new System.Text.StringBuilder();
|
||
sb.Append("{\"t\":").Append(DateTimeOffset.UtcNow.ToUnixTimeSeconds()).Append(",\"items\":[");
|
||
for (int i = 0; i < infos.Count; i++)
|
||
{
|
||
var it = infos[i];
|
||
bool isPin = session.PinIds.Contains(it.UniqueId);
|
||
var inv = System.Globalization.CultureInfo.InvariantCulture;
|
||
if (i > 0) sb.Append(',');
|
||
sb.Append("{\"id\":").Append(it.UniqueId)
|
||
.Append(",\"cfg\":").Append(it.CfgId)
|
||
.Append(",\"path\":").Append(it.PathId)
|
||
.Append(",\"kind\":").Append(isPin ? "\"pin\"" : "\"ball\"")
|
||
.Append(",\"x\":").Append(it.Position.X.ToString("0.#####", inv))
|
||
.Append(",\"y\":").Append(it.Position.Y.ToString("0.#####", inv))
|
||
.Append(",\"z\":").Append(it.Position.Z.ToString("0.#####", inv))
|
||
.Append(",\"scale\":").Append(it.IScale)
|
||
.Append('}');
|
||
}
|
||
sb.Append("],\"lane\":{\"machine\":").Append(lane.MachineNo)
|
||
.Append(",\"lane\":").Append(lane.LaneNo)
|
||
.Append(",\"laneZ\":").Append(lane.LaneZ.ToString("0.####", System.Globalization.CultureInfo.InvariantCulture))
|
||
.Append("},\"player\":{\"x\":")
|
||
.Append(playerPos.X.ToString("0.####", System.Globalization.CultureInfo.InvariantCulture))
|
||
.Append(",\"z\":")
|
||
.Append(playerPos.Z.ToString("0.####", System.Globalization.CultureInfo.InvariantCulture))
|
||
.Append("}}");
|
||
var json = sb.ToString();
|
||
foreach (var p in new[]
|
||
{
|
||
@"D:\Ananta\gym_tools\_bowling_push.json",
|
||
Path.Combine(AppContext.BaseDirectory, "config", "bowling_push.json"),
|
||
})
|
||
{
|
||
try
|
||
{
|
||
var dir = Path.GetDirectoryName(p);
|
||
if (!string.IsNullOrEmpty(dir)) Directory.CreateDirectory(dir);
|
||
File.WriteAllText(p, json);
|
||
}
|
||
catch { }
|
||
}
|
||
}
|
||
catch { }
|
||
|
||
await conn.NotifyRawAsync(MethodId.SyncDestructibleObjectAddList, addBytes);
|
||
|
||
conn.Log.Info(
|
||
$"[BOWLING] pushed destructibles balls={session.BallIds.Count} pins={session.PinIds.Count} " +
|
||
$"cells={indexList.Count} reason=AoiInit(0) machine={lane.MachineNo} lane={lane.LaneNo} " +
|
||
$"laneZ={lane.LaneZ:F3} " +
|
||
$"ballRack=({laneHeadX - BowlingBallRackBack:F2},{BowlingLaneHeadY:F2},{lane.LaneZ:F3}) " +
|
||
$"headPin=({lane.PinApexX:F3},{BowlingPinBaseY:F2},{lane.LaneZ:F3}) " +
|
||
$"wire=ballSet{_ballSet} pin({pinCfg}/{pinPath}) " +
|
||
$"balls=[{string.Join(" ", ballWireLog)}] " +
|
||
$"src={(_bowlingWireFile is { Length: > 0 } ? Path.GetFileName(_bowlingWireFile) : "compiled-in")} " +
|
||
$"gridAOIDecrease(68969593)={gridBytes.Length}b objectAddList={addBytes.Length}b " +
|
||
$"reason=Bowling(14) itemTag={tagLabel}");
|
||
}
|
||
}
|