feedback7 R22-RENDER: a pushed / pulled enemy slides to where the sim put it, a dying flyer keeps its lift through the Die clip, a long Die clip plays whole (PR #380 by @xcdoge); golden: unchanged
The sim displaces at once (battle/displacement.js), so the snapshots only show the destination: a ≤ 2.5-tile push was lerped over one snapshot interval (3 frames, 0.58 tiles in one frame — frame-loop repro over a real battle), a longer pull snapped. render/app.js now starts UnitView.slideTo as soon as the interval it samples ends on the snapshot that carries the destination (a `displace` fx still queued up to SnapshotBuffer.nextSnapT); the view holds where it stood until that snapshot is shown, then eases into the sampled position under a constant deceleration (v0 = 2D/T, a = v0/T, T = 0.14·√D in 0.12–0.45 s — ours, [ASSUMED]: no source gives the official timing; docs/research/13 has the official impulse-and-friction classes). A unit that dies on the way finishes the slide and lies where the push put it. Death: DIE_CLIP_MAX 1.6 → 8 s (data/assets.json: 234 enemy Die clips, the longest 7.97 s, 25 over 1.6 s), and a flyer holds FLY_HOVER until the fade tail (DIE_FADE_TAIL 0.55 s). Substantially @xcdoge's code (PR #380: the slide, the death timing, research 13 / 14, most tests), authored as theirs. Changed on review: the corpse no longer goes back to where it stood (the PR's test asserted that; the sim's body is at the destination); the PR's pre-pass scanned (renderT − 0.5, renderT] after processEvents had taken those events, so it never fired and the slide started a frame before landing — it now looks ahead to the next snapshot and holds the view until then; the slide eases into the live sample instead of the fixed destination (no jump back onto an enemy that walked on); each step uses its mean velocity (the end-of-step speed ran 9 % short, then jumped); the constants' comments say the timing is ours; research 14 no longer cites a sweep script and a data guard that were not in the PR. Golden: unchanged (client only). Tests: test/render/unitview.test.js 35/35 (slide: deceleration, idempotence, facing, snapshots in flight, friction, √D, corpse lies where pushed, hold-then-ease without a landing jump, a never-shown slide handed back; the app.js frame order over a real battle: a 1.7-tile push over ≥ 8 frames with every step < 0.35 tiles, a push-kill's body staying at the destination; death: a dying flyer's lift, every Die clip within DIE_CLIP_MAX and a 7.97 s clip scheduled whole); test/sim/displace-fx.test.js 1/1; render/interp 16/16; docs tests pass.
This commit is contained in:
xcdoge authored and sganggs committed
1 parent
8a64edc9e9
commit
2669b6ab57
8 files changed
+686
-6
No files matched your search
@@ -19,6 +19,8 @@ Tags: **[DATA]** client game data · **[VERIFIED]** official or wiki rule text,
|
||||
| `07-assets.md` / `07-assets.json` | Verified URL patterns and resolved URLs for avatars, portraits, skills, bond/item/band icons, UI, Spine (ops + enemies), BGM/SFX, fonts; build plan. Addendum: spot check 40/40 OK. | `operators[*]`, `enemies[*]`, `bonds`, `items`, `bands`, `autochessUi`, `audio` |
|
||||
| `11-limits-official.md` | Official limits read from the client (2.7.71 il2cpp) and the community: bond layers cap at **999** per bond (`MAX_GARRISON_STACK`, `AddBondCount` = min(L + n, 999)); in boss battles outside training a single hit of **≥ 300000** on a leader (`IsBossEnemy` = an `autoChessData.bossInfoDict` enemyId) is **cancelled** ("限伤", `MAX_BATTLE_DAMAGE`); implemented in DESIGN §20.12. | `shared/constants.js BOND_LAYER_CAP / BOSS_HIT_LIMIT` |
|
||||
| `12-flying-visuals-official.md` | Official flying visuals and model placement, read from the client (PR #211 by @xcdoge; ported into 0.2.0 by the owner's decision of 2026-10-06): the fly offset is the single model-independent constant **0.35** (`CharacterAnimator..ctor` stores `Vector3(0,0.35,0)` at field +0x114; `_SetFlyMountPointOffset` / `_SetFlyHitOffset` add it while flying, negate it on landing) — in the client's *character* space, whose unit is the standard prefab scale 0.27, so **0.35 / 0.27 ≈ 1.3 tiles**, confirmed by pixel-measuring an official screenshot (1.2–1.4). `FLY_HOVER` 0.32 → **1.3**, flat (no per-model term). The same sweep found two model quirks: `modelScaleY` 1.263 (帝国炮火先兆者 pair, vertically stretched) and `mirrorX` (木制瑞印, mirrored prefab). | `public/js/render/units.js FLY_HOVER / enemyModelScaleY`, `data/enemies.json`, `tools/local-extract/enemy_model_offsets.py` |
|
||||
| `13-knockback-official.md` | Push / pull (推拉) in the official client (PR #380 by @xcdoge; written in Chinese): the knockback abilities (`Knockback`, `KnockBackWithDirection`, `KnockBackWithCharacterDirection`, `DragTowardSource`) carry an impulse (`m_force`) and a velocity decaying under friction (`m_friction*`, the tile's `additionalFriction` — `GrasslandType` NORMAL_LAND / ICE_LAND / SLIME_LAND); the data has no `move_duration` / `move_distance` key (distances are emergent; 力度 comes from `skill_table` / `enemy_database`); every tile of this mode's 11 maps is normal land. Also noted, not modelled: wall bounces (`_bounceTimesAsDamageTimes`) and `unbalanceProtectDueTime`. The client's slide (`v0 = 2D/T`, `a = v0/T`, T = 0.14·√D in 0.12–0.45 s) is ours [ASSUMED: no source gives the official timing]. | `render/units.js DISPLACE_SLIDE / slideTo`, `render/app.js` `displace` fx |
|
||||
| `14-death-animations.md` | Enemy death animations (PR #380 by @xcdoge): the art never drops the body (the PR author's 234-clip sweep — no Die/Idle/Move/Attack clip translates the root), the 1.6 s death cap cut 25 clips short (盐风主教昆图斯 7.97 s) so it is 8 s, and a flying unit keeps its lift for the whole Die clip, dropping only inside the fade tail (the client removes its fly offset in `CharacterAnimator.OnFinish`). | `render/units.js DIE_CLIP_MAX / DIE_FADE_TAIL` |
|
||||
|
||||
## 2. Match structure
|
||||
|
||||
|
||||
@@ -0,0 +1,134 @@
|
||||
# 13 · 推拉（击退 / 拖拽）的官方实现：冲量 + 摩擦
|
||||
|
||||
这份文档回答两个问题：**官方推拉到底怎么动**，以及**摩擦是谁的参数**。结论全部来自官方客户端本体的
|
||||
`global-metadata.dat`（il2cpp 元数据）、官方 gamedata（社区镜像 Kengxxiao/ArknightsGameData）与官方 AB 资源包，
|
||||
并附上每一步的验证方式，便于复核。
|
||||
|
||||
## 0. 结论速览
|
||||
|
||||
| 问题 | 答案 |
|
||||
|---|---|
|
||||
| 官方怎么动 | **冲量 + 摩擦**：给被推者一个力（`m_force` / `m_forceVectorX/Y`），速度**逐帧被摩擦衰减**直到停下 |
|
||||
| 有固定时长/距离吗 | **没有**：数据里不存在 `move_duration` / `move_distance` / `move_tiles` 键（`moveDuration`、`moveTiles` 属于 UI 类）⇒ 位移量是**涌现**的，这也是社区只能给出"**推力-位移近似对应表**"的原因 |
|
||||
| "力度"从哪来 | **官方数据**：`skill_table.json` 的 blackboard `force`（41 个技能带它），敌人侧在 `enemy_database.json`（8 条） |
|
||||
| 摩擦是谁的参数 | **地板（地形）+ 单位质量**，**不是**技能参数：`GrasslandType { NORMAL_LAND, ICE_LAND, SLIME_LAND }`，每格是一条 `GrasslandData { modeIdx, grasslandType, additionalFriction }`，运行时还会被 `UpdateFrictionFactor` / `RestoreFrictionFactor` 临时改写 |
|
||||
| 卫戍协议里有几种地板 | **实际只有普通地面**：11 张地图共 18 种格子字符，无冰面/黏液 ⇒ 本模式下摩擦恒定，滑行时长**不必按地板分档** |
|
||||
| 飞行目标怎么算 | **没有独立的空中摩擦**（`boatAirFactor` / `m_airBase` 属于"船"玩法）：飞行用的是**同一套**公式（单位摩擦 × 所在格子的 `additionalFriction`）；差别只在**运动模式**（`ENEMY_MOTION_TYPE_FLY`、`HEIGHT_CHANGED_TO_FLY_BLOCK_MOTION_MODE` ⇒ 忽略地面阻挡），以及**失衡免疫 / 静态刚体**的空中单位根本不可位移 |
|
||||
| 曲线形状 | 恒定减速 ⇒ `d/D = 2k − k²`（ease-out quad）、`T ∝ √D`；客户端用的 `T = 0.14·√D`（夹 0.12–0.45 s）是我们拟定的 [ASSUMED]，没有来源给出官方时长 |
|
||||
|
||||
## 1. 官方类与字段（`global-metadata.dat`）
|
||||
|
||||
推拉能力的类簇（与 PRTS 的"推与拉"术语逐字对应）：
|
||||
|
||||
```
|
||||
Knockback · KnockBackWithDirection · KnockBackWithCharacterDirection · KnockBackTargetsByRootTile · DragTowardSource
|
||||
_decreaseForceLevelWhenNotInDirection（PRTS"特殊修正"−2 力度）· _dontChangeFaceByDirection · _GetPushDir
|
||||
TOO_CLOSE_TOLERANCE_SQR（PRTS"< 0.25 格转径向"）
|
||||
```
|
||||
|
||||
运动学字段（同一批类里）：
|
||||
|
||||
```
|
||||
m_force · m_forceVectorX/Y · forceScale · m_mass · m_velocity · get_mass · get_rigidbody2D
|
||||
m_friction · m_frictionBase · m_frictionFactor · get_frictionFactor · m_frictionFactorAdditional · get_additionalFriction
|
||||
UpdateFrictionFactor · RestoreFrictionFactor · _UpdateFrictionFactorAdditional · RestoreCached…
|
||||
_ApplyForce · _UpdateVelocityAndPos · _UpdateAllUnitDeltaPos · _GetForceByDirectionAndDamage
|
||||
m_bounceFrictionFactor · bounce · bounceease · _bounceTimesAsDamageTimes · _bounceBBKey · _bounceConditionValidator
|
||||
unbalanceProtectDueTime
|
||||
```
|
||||
|
||||
⇒ `m_force*`（冲量）+ `m_velocity` / `_UpdateVelocityAndPos`（逐帧速度积分）+ `m_friction*`（衰减）就是"冲量 + 摩擦"；
|
||||
`UpdateFrictionFactor` / `RestoreFrictionFactor`（改完还要还原）说明摩擦**由外部临时提供**，不是能力自带。
|
||||
|
||||
## 2. 地板（地形）摩擦
|
||||
|
||||
地板系统就在**卫戍协议自己的格子类**里（同簇可见 `TileState { SHARED, MY_SIDE, MATE_SIDE }`、
|
||||
`CooperateStartTile` / `CooperateEndTile` / `CoopFootballTile`、`get_modeIndex` / `get_tilePlayerSide` /
|
||||
`_OnPlayerDying` / `_OnPlayerRevive`）：
|
||||
|
||||
```
|
||||
_grasslandDatas · GrasslandType { NORMAL_LAND, ICE_LAND, SLIME_LAND } · GrasslandData { modeIdx, grasslandType, additionalFriction }
|
||||
DynamicBuffQuickSandTile（流沙）· DynamicBuffTile · DirectionTile（带方向的格子）
|
||||
```
|
||||
|
||||
⇒ 每格可带 `additionalFriction`，即"**地板提供摩擦**"。另有冰面相关因子（`iceFactor`、`iceTile`、`OnIce`、`Frozen`）
|
||||
与"船/水/空"那套（`m_boatFrictionFactor`、`m_boatAirFactor`、`m_airBase`、`m_waterFlowForce*` —— 属于多索雷斯船玩法，
|
||||
**不是**飞行单位）。
|
||||
|
||||
### 卫戍协议实际用到哪些地板
|
||||
|
||||
`docs/research/05-maps.json`（11 张地图）里出现过的全部格子字符：
|
||||
|
||||
```
|
||||
# ×1776（墙/虚空） r ×580（道路） X ×477（分区隔断） f ×448（地面） a ×330 b ×250 A ×165
|
||||
p ×77（预览栏） d ×76（装置） S ×66（起点） I / E ×33（路线起/终） h ×24（手牌栏） O ×22 m ×12 i ×8 g ×8 R ×4
|
||||
```
|
||||
|
||||
**没有冰面或黏液** ⇒ 本模式下所有可站地板摩擦一致。
|
||||
|
||||
## 3. 力度来自官方数据（不是我们拟定的）
|
||||
|
||||
`excel/skill_table.json` 的 blackboard 里 **`force` 出现 357 次、41 个技能**，例如：
|
||||
|
||||
| 技能 | 名称 | 力度（按等级） |
|
||||
|---|---|---|
|
||||
| `skchr_weedy_1` / `_3` | 温蒂 炮管敲击 / 液氮大炮 | 0,1,2 / 1,2,3 |
|
||||
| `skchr_forcer_1` / `_2` | 见行者 护身射击 / 惊爆射击 | 0,1,2 / 1,2,3 |
|
||||
| `skchr_panda_1` / `_2` | 食铁兽 铁意六合 / 崩拳式 | 0,1,2 / 1,2,3 |
|
||||
| `skchr_rope_1` / `_2` | 崖心 勾爪发射 / 复式勾爪 | 0,1,2 / 0,1,2 |
|
||||
| `skchr_glady_1` / `_3` | 歌蕾蒂娅 缺水的大洋裂断 / 缺水的碎漩狂舞 | 0,1,2 / 0,1,2 |
|
||||
| `skchr_sqrrel_1` / `_2` | 阿消 水蒸气泵 / 高压水炮 | 0,1,2 / 0,1,2 |
|
||||
| `skchr_moeshd_2` | 可颂 磁爆锤 | 1,2,3 |
|
||||
| `sktok_archook` | 钩索 token 发射 | **11** |
|
||||
|
||||
同一张表里 **没有** `friction` / `mass` / `knockback` 键 ⇒ **力度是数据（可查表），摩擦与质量在引擎里**。
|
||||
|
||||
### 靠"职业"就能推拉的干员
|
||||
|
||||
`character_table.json` 的 `subProfessionId` 有两个专门职业，**普通攻击**即推/拉，力不在技能 blackboard 里：
|
||||
|
||||
- **`pusher`（推击手）**：阿消 · 见行者 · 食铁兽 · 温蒂
|
||||
- **`hookmaster`（钩索师）**：暗索 · 歌蕾蒂娅 · 杏仁 · 雪雉 · 崖心
|
||||
|
||||
其余靠技能/天赋推拉的还有：Misery、灰烬、黑键、燧石、溯光星源、可颂、焰狐龙梓兰、傀影、莱伊、罗宾、圣聆初雪、
|
||||
琳琅诗怀雅、乌尔比安，以及 `勾爪` / `暴风雪` / `喷拒器` / `猎潮的骑士` / `流形` / `weedy_token` 等 token 与装置。
|
||||
|
||||
## 4. 顺带查清的两条官方机制（尚未建模）
|
||||
|
||||
- **撞墙弹跳**：`bounce` / `bounceease` / `m_bounceFrictionFactor` / `_bounceBBKey`，并且 **`_bounceTimesAsDamageTimes`
|
||||
—— 弹跳次数计入伤害次数**（温蒂 / 推击手那类撞墙伤害的官方口径）。
|
||||
- **失衡保护**：`unbalanceProtectDueTime` —— 连续推拉之间有保护窗口。
|
||||
|
||||
## 5. 客户端的做法（本次实现）
|
||||
|
||||
`render/units.js`：模拟位移是**瞬时**的（`sim/battle/displacement.js` 在一次调用里走完 0.1 格步进），快照只带终点，
|
||||
所以客户端补上中间帧——`UnitView.slideTo(x, y, { friction })` 建立一次滑行，`update()` **逐帧做速度积分**
|
||||
（`v ← max(0, v − a·dt)`、`d ← d + v·dt`），终点由模拟给出（**权威**），`v0 = 2D/T`、`a = v0/T` 保证
|
||||
`T` 秒内正好走完 `D` 且速度归零 —— 即官方"冲量 + 摩擦"的等效形式；`T = 0.14·√D`（夹 0.12–0.45 s）是我们拟定的
|
||||
[ASSUMED]（让画面按模拟的距离到位；没有来源给出官方时长），`friction` 是**地板因子**（本模式恒为 1；将来有冰面就乘
|
||||
< 1 ⇒ 滑得更久）。`render/app.js` 在插值器开始显示「以带终点的快照结尾」的那一段时就用 `displace` fx 启动滑行：
|
||||
到达那张快照之前画面停在原处，之后从原处减速滑入模拟的实时位置（终点，以及敌人随后继续走的路），落地不跳。
|
||||
**模拟层、协议、golden 一律未改。**
|
||||
|
||||
滑行途中死亡：滑行照常走完，尸体停在被推到的位置（模拟里它已经在那里；0.2.2 合入时改掉了原 PR 的「回到出发格」）；
|
||||
倒地的单位交给 `setDown` 放到它的格子上。
|
||||
|
||||
## 6. 复核方式
|
||||
|
||||
1. 元数据：`node` 读 `global-metadata.dat`，搜上列标识符（本文件所有类名/字段名都是这样得到的）。
|
||||
2. 力度表：`zh_CN/gamedata/excel/skill_table.json` → 各技能的 `levels[].blackboard` 里 `key === 'force'`；
|
||||
敌人侧 `levels/enemydata/enemy_database.json`。
|
||||
3. 职业：`excel/character_table.json` 的 `subProfessionId ∈ {pusher, hookmaster}`。
|
||||
4. 地板：`docs/research/05-maps.json` 的格子字符统计（本文件 §2）。
|
||||
|
||||
## 7. 附：官方 AB 资源包的读取要点（踩过的坑）
|
||||
|
||||
供以后要读官方战斗配置时参考（本次为定位"摩擦是不是数据"而打通）：
|
||||
|
||||
- `Flags` 里的 `0x200`（`UsesAssetBundleEncryption`）在本客户端上是**虚设**：blocksInfo 既没有 70 字节加密前导，
|
||||
也不需要任何 16 字节 key（暴力扫 `global-metadata.dat` 144 万候选、`GameAssembly.dll` 5 万候选均无命中即因此）。
|
||||
- blocksInfo 位置 = `align16(headerEnd)`；**块数据是连续存储**的（不要逐块对齐）。
|
||||
- 压缩：`comp 3` = 普通 LZ4 ✓；`comp 4 / 5` = Arknights 自定义 LZ4AK（nibble 交换后按 LZ4 解，
|
||||
终止条件是 `op === uncompressedSize`，**严格相等**）。
|
||||
- 包内官方配置是**带 `$type` 的 JSON**（如 `Torappu.Battle.Action.Nodes+SetBodyDirection`），
|
||||
内嵌类型树 ⇒ 字段名可直接读；但**摩擦不在其中**（本文档 §2 已说明原因）。
|
||||
@@ -0,0 +1,109 @@
|
||||
# 14 · Enemy death animations: the art never drops the body, and 25 clips were being cut short
|
||||
|
||||
A player report — "a dying 帝国炮火先兆者 seems to drop at the very end", then "what about the other enemies'
|
||||
animations?" — answered by reading the client's own data and its code.
|
||||
|
||||
## 0. TL;DR
|
||||
|
||||
- **No enemy animation moves the whole body.** Playing all 251 enemies' clips and sampling every bone's world position,
|
||||
the **root bone's vertical displacement is 0.000 tiles in every Die (234), Idle (235), Move (234) and Attack (215)
|
||||
clip**. Limbs move (up to 2.16 tiles for “帝国的甲胄”'s arms); the body never does. Every vertical placement is the
|
||||
renderer's: the fly lift, the model's own art hang (`.skel bounds.y`) and nothing else.
|
||||
- **A dying flyer dropped at the wrong moment.** The client removes its fly offset in `CharacterAnimator.OnFinish` —
|
||||
when the finish state ends, not when the unit dies — so a drone stays aloft through the death animation and drops as
|
||||
it goes. The remake dropped it the instant `alive` went false, so the death clip played on the ground. Fixed: the lift
|
||||
is held for the Die clip and released inside the fade tail (§4).
|
||||
- **25 death clips were cut short by a 1.6 s cap** — 盐风主教昆图斯's 7.97 s clip played 20 % of itself, 鼠王 37 %,
|
||||
杰斯顿·威廉姆斯 40 %, and 22 more (§3). The cap is now 8 s, above every clip in the data.
|
||||
- 17 manifest entries have no Die clip at all; they are the ground items/collectibles (§5).
|
||||
|
||||
## 1. How the clips were read [DATA]
|
||||
|
||||
A sweep script of the PR author (PR #380, not in this repository) reads `data/assets.json` + the extracted `.skel` files
|
||||
and **plays** each clip: `Skeleton` + `AnimationState`, stepped at 30 Hz, `state.apply(skeleton)` and
|
||||
`skeleton.updateWorldTransform()` after every step, recording the range of `skeleton.y` (the root) and of every
|
||||
`bone.worldY`. Ranges are converted to tiles with the model's `modelScale` (320 skeleton units = one tile at scale 1 —
|
||||
the conversion the flying-visuals write-up uses for the same models).
|
||||
|
||||
Do **not** try to read the timelines directly: in this build of `@pixi-spine/runtime-3.8` they hold packed numeric
|
||||
arrays (`timeline.frames[0]` is a number, not `{time, x, y}`), so a keyframe walk silently reports zero motion — the
|
||||
first attempt here did, and 270 Attack clips "had no rotation". Sampling the played skeleton is layout-agnostic and
|
||||
matches what the client draws.
|
||||
|
||||
## 2. Nothing translates the body [DATA]
|
||||
|
||||
| clip | read | root displacement > 0.01 tiles |
|
||||
|---|---|---|
|
||||
| Die | 234 | **0** |
|
||||
| Idle / Default | 235 | **0** |
|
||||
| Move / Walk | 234 | **0** |
|
||||
| Attack | 215 | **0** |
|
||||
|
||||
The largest single-bone travel inside a Die clip is 2.16 tiles (“帝国的甲胄”, a flailing limb), then 1.40 (节日气球),
|
||||
1.29 (“独轮车玩具”), 1.18 (业余竞演者) — normal animation, not a fall. A "the body sinks" effect can therefore only come
|
||||
from the code paths that place the model (`FLY_HOVER`, the `zTarget` ease, `lift`, and the artist's `bounds.y`).
|
||||
|
||||
## 3. Death clip durations, and the 1.6 s cap that cut them [DATA]
|
||||
|
||||
234 Death clips: shortest **0.50 s**, median **1.00 s**, longest **7.97 s**. `render/units.js` used
|
||||
`clamp(d / rate, 0.35, 1.6)`, so **25 clips were trimmed** (11 %), every one of them a boss or elite:
|
||||
|
||||
| enemy | Die clip | played by the old cap |
|
||||
|---|---|---|
|
||||
| 盐风主教昆图斯 | 7.97 s | 1.60 s (20 %) |
|
||||
| 鼠王 | 4.33 s | 37 % |
|
||||
| 杰斯顿·威廉姆斯 | 4.00 s | 40 % |
|
||||
| W / 泥岩 | 3.33 s | 48 % |
|
||||
| 假想敌：胄 ×2 | 3.10 s | 52 % |
|
||||
| “巨大的丑东西” | 2.83 s | 56 % |
|
||||
| 腐败骑士 | 2.67 s | 60 % |
|
||||
| 高普尼克 ×2 / 卢西恩，“猩红血钻” / 假想敌：管 ×2 | 2.33 s | 69 % |
|
||||
| 假想敌：弦 | 2.30 s | 70 % |
|
||||
| 雪孩子 / 伊利昂的木驮兽 / 鸭爵 ×2 / 纠缠藤蔓 / 凋零骑士 | 2.00 s | 80 % |
|
||||
| 陷落雪祀 | 1.80 s | 89 % |
|
||||
| “帝国的甲胄” / 底海滑动者 / 富营养的滑动者 | 1.67 s | 96 % |
|
||||
|
||||
The lower bound (0.35 s) trims nothing: the shortest real clip is 0.50 s. The client plays its clip out — its `OnFinish`
|
||||
fires when the finish state ends — so the cap only ever made the remake's deaths shorter than the official's.
|
||||
|
||||
## 4. A dying flyer drops at the end of the clip, like the client [DATA]
|
||||
|
||||
The client's fly offset is one constant (`Vector3(0, 0.35f, 0)` in `Torappu.Battle.CharacterAnimator`, applied by
|
||||
`_SetFlyMountPointOffset` / `_SetFlyHitOffset` while a unit flies and negated when it lands; the remake draws 0.35 in
|
||||
character space ≈ **1.3 tiles** as `FLY_HOVER` — the flying-visuals write-up has the full derivation). Its only direct
|
||||
caller is `OnFinish` (#62924, call site
|
||||
0x1805feb87), disassembled as `xor edx, edx; mov rcx, rbx; call _SetFlyMountPointOffset` — **arg 0**, the negation
|
||||
branch — followed by clearing `[this+0x128]` and a tail call to another cleanup. `OnFinish` has no direct `call` site of
|
||||
its own: it is a virtual lifecycle method (there is a `<>xLuaBaseProxy_OnFinish`), so the battle framework calls it
|
||||
through the vtable when the character's **finish** state ends.
|
||||
|
||||
Since the Die clips carry no vertical motion (§2):
|
||||
|
||||
- **Client**: the drone stays aloft for the whole death animation and drops as the finish state ends.
|
||||
- **Remake before**: `hoverTo = this.flying && this.alive ? FLY_HOVER : 0` — `die()` clears `alive` *before* the clip
|
||||
plays, so every flyer sank to the ground inside ≈0.42 s (lerp τ = 1/6 s) and played its death clip **on the ground**.
|
||||
- **Remake now**: the hover target is `this.alive || (this.dying > DIE_FADE_TAIL && !this.down)` — the flyer holds
|
||||
`FLY_HOVER` for the whole clip (the view fades over the last `DIE_FADE_TAIL` = 0.55 s of `dying`) and drops inside
|
||||
that fade, which is the client's `OnFinish` moment. A knocked-down (`down`) flyer still lies on the ground.
|
||||
|
||||
All 27 flying enemies of the data have a Die clip of 0.67–1.00 s, well inside the cap, so the cap change never touches
|
||||
them; 帝国炮火先兆者 and 帝国炮火中枢先兆者 are unexceptional (Die 1.00 s, root displacement 0.000).
|
||||
|
||||
## 5. The 17 entries with no Die clip [DATA]
|
||||
|
||||
未装配刀片 · 防护背心 · 冲击式施术单元 (deployable equipment) and 木制瑞印 · 红木瑞印 · 小说卷轴 · 诗画卷轴 · 青铜镜 ·
|
||||
黄铜镜 · 木制镇纸 · 红木镇纸 · 青瓷茶器 · 彩瓷茶器 · 铜矛头 · 铁矛头 · 铜灯盘 · 铁灯盘 (the collectible/relic props). They take
|
||||
the documented frozen-first-idle-frame path (see the `die()` comment in `render/spine.js`), which is right for an item
|
||||
that is picked up rather than killed.
|
||||
|
||||
## 6. Implementation (2026-10-06, client-only)
|
||||
|
||||
- `public/js/render/units.js`: new `DIE_FADE_TAIL = 0.55` (the fade tail `die()` already appended as a literal) and
|
||||
`DIE_CLIP_MAX = 8`; `dying = clamp(d / rate, 0.35, DIE_CLIP_MAX) + DIE_FADE_TAIL`; the hover target as in §4; the three
|
||||
`0.55` literals in `die()` / the knockdown branch / the fade now use `DIE_FADE_TAIL`.
|
||||
- `test/render/unitview.test.js`: a dying flyer keeps `FLY_HOVER` through the Die clip and is under a quarter of it
|
||||
inside the fade (a walker stays at 0); a data guard — no enemy Die clip of `data/assets.json` exceeds `DIE_CLIP_MAX`
|
||||
(234 clips, the longest 7.97 s: the §3 durations re-checked from the manifest when this was merged in 0.2.2) — and
|
||||
the 7.97 s clip is scheduled whole, the view still on screen 5 s in.
|
||||
- The root-displacement sweep of §2 is the PR author's measurement (their script is not in the repository).
|
||||
- Client-only: the server serves `units.js` per request, so a hard refresh (Ctrl+F5) applies it — no restart.
|
||||
@@ -1412,6 +1412,14 @@ export async function createFieldView(host, options = {}) {
|
||||
consumedIds.add(e[4].id);
|
||||
if (consumedIds.size > 200) consumedIds.delete(consumedIds.values().next().value);
|
||||
}
|
||||
// 推拉: a push / pull (battle/displacement.js) moves the enemy inside one call; its `displace` fx carries the
|
||||
// destination ['fx', 'displace', x, y, { id }] and the view slides there (UnitView.slideTo, PR #380) — normally
|
||||
// started already by syncBattle's look-ahead, which this repeats harmlessly
|
||||
if (e[1] === 'displace') {
|
||||
const d = e[4] && typeof e[4] === 'object' ? e[4] : null;
|
||||
const v = d && d.id != null ? views.get(d.id) : null;
|
||||
if (v && v.slideTo) v.slideTo(Number(e[2]), Number(e[3]));
|
||||
}
|
||||
// an enemy's mode change — the `form` of a sim setForm fx (shared/protocol.js fxForm: 掠海漂移体 → 爬行模式, user
|
||||
// playtest #5 item 1; 转译基底's forms, a 逐火 ember and its revival, the leaders' 重生, 守墓石像 — user report after
|
||||
// 0.1.0) — switches the view's clip set (UnitView.setForm; a kind without a clip set of that skeleton changes
|
||||
@@ -1464,10 +1472,24 @@ export async function createFieldView(host, options = {}) {
|
||||
if (best) { tiles.flashObjective(best[0], best[1]); board3d?.flashObjective(best[0], best[1]); }
|
||||
}
|
||||
|
||||
/** syncBattle's look-ahead: a queued `displace` fx ['fx', 'displace', x, y, { id }] starts that view's slide. */
|
||||
let slideAt = 0;
|
||||
function startSlide(e) {
|
||||
if (!Array.isArray(e) || e[0] !== 'fx' || e[1] !== 'displace') return;
|
||||
const extra = e[4] && typeof e[4] === 'object' ? e[4] : null;
|
||||
const v = extra && extra.id != null ? views.get(extra.id) : null;
|
||||
if (v && v.slideTo) v.slideTo(Number(e[2]), Number(e[3]), { at: slideAt });
|
||||
}
|
||||
let renderT0Battle = null; // game time of the first rendered battle frame (spawn puffs skip the initial wave)
|
||||
let downSeq = 0; // syncBattle pass counter: a view still marked down after a pass left the `down` list
|
||||
function syncBattle(renderT) {
|
||||
if (renderT0Battle == null) renderT0Battle = renderT;
|
||||
// A push / pull's slide starts as soon as the interval sampled below ends on the snapshot that carries the
|
||||
// destination: its `displace` fx is due only when renderT reaches that snapshot, and by then sample() has already
|
||||
// lerped (≤ teleport) or snapped the enemy most of the way — no frames in between (PR #380). The fx are still queued
|
||||
// here (processEvents took only those ≤ renderT); the view holds until `at`, then eases into the sim's position.
|
||||
slideAt = interp.nextSnapT(renderT);
|
||||
if (slideAt > renderT) interp.forEachUpcoming(renderT, slideAt, startSlide);
|
||||
interp.sample(renderT, sample);
|
||||
for (const [id, s] of sample) {
|
||||
let v = views.get(id);
|
||||
|
||||
@@ -283,6 +283,16 @@ export class SnapshotBuffer {
|
||||
return ans;
|
||||
}
|
||||
|
||||
/**
|
||||
* Game time of the first snapshot after `time` (default renderT) — the newer end of the interval sample() interpolates
|
||||
* — or NaN when there is none (extrapolating). render/app.js starts a push's slide while that interval is shown.
|
||||
*/
|
||||
nextSnapT(time = this.renderT) {
|
||||
const s = this.snaps;
|
||||
const i = this._indexAt(time) + 1;
|
||||
return Number.isFinite(time) && i < s.length ? s[i].t : NaN;
|
||||
}
|
||||
|
||||
/**
|
||||
* The `down` list (knocked-out operators waiting to redeploy, see header) of the snapshot shown at `time` (default
|
||||
* renderT) — the same snapshot sample() reads flags from — or null.
|
||||
|
||||
+102
-6
@@ -161,6 +161,36 @@ const RAISED_Z = 0.12;
|
||||
* ride the body (`hover`); range highlights are tiles.
|
||||
*/
|
||||
export const FLY_HOVER = 1.3;
|
||||
/**
|
||||
* A push / pull slide (推拉, PR #380 by @xcdoge): real seconds per √tile of travel. The sim displaces at once —
|
||||
* server/sim/battle/displacement.js walks its 0.1-tile steps inside one call — so the snapshots only ever show the
|
||||
* destination, and a pushed / pulled enemy appeared at the end of its path (a ≤ 2.5-tile push in one snapshot interval,
|
||||
* a longer pull snapped). The view now slides there under a constant deceleration (UnitView.slideTo): the official
|
||||
* knockback abilities (`Knockback`, `KnockBackWithDirection`, `DragTowardSource` in the client's metadata) carry an
|
||||
* impulse (`m_force`) and a velocity decaying under friction (`m_friction`, the tile's `additionalFriction`), and the data
|
||||
* has no per-skill duration (docs/research/13-knockback-official.md). The duration T = DISPLACE_SLIDE·√D, kept in
|
||||
* 0.12–0.45 s, is ours [ASSUMED: a fit so the view arrives where the sim put it — no source gives the official
|
||||
* timing]; v0 = 2D/T, a = v0/T then run the distance in exactly T. Purely visual: the sim's timing, damage, blocking and
|
||||
* the golden digests are untouched.
|
||||
*/
|
||||
export const DISPLACE_SLIDE = 0.14;
|
||||
/**
|
||||
* Terrain friction factor of a slide: 1 = normal land, < 1 = slippery (ICE_LAND) slides longer. Every tile of this mode
|
||||
* is normal land (its 11 maps have no ice or slime), so it is always 1.
|
||||
*/
|
||||
export const SLIDE_FRICTION = 1;
|
||||
/**
|
||||
* Seconds of the death fade that follows the Die clip in `dying` (die(): the clip, then this tail). A flying unit keeps
|
||||
* its lift for the whole clip and drops only inside this tail (PR #380: the official client removes its fly offset in
|
||||
* `CharacterAnimator.OnFinish`, when the finish state ends — docs/research/14-death-animations.md).
|
||||
*/
|
||||
const DIE_FADE_TAIL = 0.55;
|
||||
/**
|
||||
* Longest Die clip a death plays out (s): the longest enemy Die clip of data/assets.json is 盐风主教昆图斯's 7.97 s (234
|
||||
* enemy Die clips; the old 1.6 s cap cut 25 of them short — the bosses' most), and the official client plays its clip
|
||||
* out (PR #380). It only bounds a view whose data lies.
|
||||
*/
|
||||
export const DIE_CLIP_MAX = 8;
|
||||
|
||||
/** b.snap `down` entry states (server/sim/constants.js DOWN_STATE). */
|
||||
export const DOWN_STATE = Object.freeze({ COUNTING: 0, WAIT_DP: 1, WAIT_TILE: 2 });
|
||||
@@ -393,6 +423,7 @@ export class UnitView {
|
||||
this.tier = clamp(Number(info.tier) || 1, 1, 6);
|
||||
this.x = Number(info.x) || 0; this.y = Number(info.y) || 0; this.z = 0;
|
||||
this.zTarget = null; // battle: standing height the feet ease towards (tile top under the unit; 0 for enemies)
|
||||
this.slide = null; // a push / pull slide (slideTo): held, then easing into the sim's position (update)
|
||||
/** @type {number|null} */
|
||||
this.shadowZ = null; // an enemy flyer's shadow height (the tile top under it), else null: the shadow is at z
|
||||
/** @type {number|null} */
|
||||
@@ -726,13 +757,18 @@ export class UnitView {
|
||||
// the element gauge shown (b.snap `elem`): element, fill 0..1, cooldown end (game s) and length
|
||||
this.el = typeof s.el === 'string' ? s.el : null;
|
||||
this.elFill = this.el ? s.elFill || 0 : 0; this.elUntil = this.el ? s.elUntil || 0 : 0; this.elDur = this.el ? s.elDur || 0 : 0;
|
||||
this.x = s.x; this.y = s.y;
|
||||
// a push / pull slide owns the drawn position (slideTo): the sample only anchors where it eases to, from the
|
||||
// snapshot that carries the destination on (`at`) — before that the sample is still sliding or snapping there
|
||||
const sl = this.slide;
|
||||
if (!sl) { this.x = s.x; this.y = s.y; }
|
||||
else if (!(t < sl.at)) { sl.lx = s.x; sl.ly = s.y; sl.live = true; }
|
||||
this.flying = !!(s.flags & UF.FLYING) || this.info.motion === 'FLY';
|
||||
// enemies keep to the road plane: ground enemies only ever walk low tiles (a rounding step onto a block edge must not
|
||||
// pop them up), and a flyer hovers FLY_HOVER above the road whatever tile it crosses — the official lift is one
|
||||
// constant over the route (docs/research/12), so a block under it is no step (GitHub #277: a flyer passing over one
|
||||
// high-ground / forbidden block rose and dropped like stairs). Its shadow still lies on the tile top under it.
|
||||
const floor = groundZ(this.ctx, s.x, s.y);
|
||||
// While sliding, the floor is read under the view's own (mid-flight) position, not the destination's.
|
||||
const floor = this.slide ? groundZ(this.ctx, this.x, this.y) : groundZ(this.ctx, s.x, s.y);
|
||||
const gz = this.isEnemy ? 0 : floor;
|
||||
if (this.zTarget == null) this.z = gz;
|
||||
this.zTarget = gz;
|
||||
@@ -755,6 +791,39 @@ export class UnitView {
|
||||
|
||||
setWorld(x, y, z = 0) { this.x = x; this.y = y; this.z = z; }
|
||||
|
||||
/**
|
||||
* Slide to a displacement's destination (推拉, the `displace` fx at (x, y)) instead of appearing there (DISPLACE_SLIDE).
|
||||
* `at` (game s): the time of the snapshot that carries the destination — render/app.js starts the slide as soon as the
|
||||
* interpolator shows the interval before it, and until the render clock reaches `at` the view holds where it stood
|
||||
* (the sample in between is a lerp or a snap towards the destination). From then on it eases from there into the
|
||||
* sampled position — the destination, and the walk the enemy resumes from it —, so it lands without a jump. Without
|
||||
* `at` the destination counts as shown. A unit that dies on the way finishes the slide: its body lies where the push
|
||||
* put it (the sim's position); a dead one is placed there, a knocked-down one is left to setDown.
|
||||
*/
|
||||
slideTo(x, y, opts = {}) {
|
||||
if (!Number.isFinite(x) || !Number.isFinite(y)) return;
|
||||
// already on the way there: app.js starts the slide ahead of the event, then the event itself asks again
|
||||
if (this.slide && this.slide.x1 === x && this.slide.y1 === y) return;
|
||||
if (this.down) { this.slide = null; return; }
|
||||
const dx = x - this.x, dy = y - this.y;
|
||||
const D = Math.hypot(dx, dy);
|
||||
if (!this.alive || !(D > 0.05)) { this.x = x; this.y = y; this.slide = null; return; }
|
||||
const f = Number.isFinite(opts.friction) && opts.friction > 0 ? opts.friction : SLIDE_FRICTION;
|
||||
// a slippery tile (f < 1) slides longer; the duration still follows √D (constant deceleration)
|
||||
const T = Math.max(0.05, (opts.dur > 0 ? opts.dur : clamp(DISPLACE_SLIDE * Math.sqrt(D), 0.12, 0.45)) / f);
|
||||
// v0 = 2D/T and a = v0/T run the distance in exactly T with the velocity reaching 0 there, integrated in update().
|
||||
// The official turns a displaced unit towards the force (its _dontChangeFaceByDirection is an opt-in flag), while
|
||||
// our facing comes from the snapshot's vx — which points back down the route the enemy resumes after the
|
||||
// displacement, i.e. against the push. The slide therefore owns the facing until it lands.
|
||||
if (this.isEnemy) this.visFacing = dx < 0 ? -1 : 1;
|
||||
const v0 = 2 * D / T;
|
||||
const at = Number.isFinite(opts.at) ? opts.at : -Infinity;
|
||||
this.slide = {
|
||||
x1: x, y1: y, sx: this.x, sy: this.y, ux: dx / D, uy: dy / D, D, done: 0, v: v0, a: v0 / T, t: 0, dur: T,
|
||||
at, live: at === -Infinity, lx: x, ly: y, ox: 0, oy: 0, run: false, wait: 0,
|
||||
};
|
||||
}
|
||||
|
||||
setFacing(f) {
|
||||
if (this.isEnemy) { this.facing = f === -1 ? -1 : 1; return; }
|
||||
// the legacy ±1 only speaks about left / right: an UP / DOWN operator keeps its direction
|
||||
@@ -909,7 +978,7 @@ export class UnitView {
|
||||
if (this.actor && !d) d = this._fallDur();
|
||||
const rate = this.ctx.animRate?.() || 1;
|
||||
this.dieT = 0;
|
||||
this.dying = clamp(d / rate, 0.35, 1.6) + 0.55;
|
||||
this.dying = clamp(d / rate, 0.35, DIE_CLIP_MAX) + DIE_FADE_TAIL;
|
||||
this.dieDur = this.dying;
|
||||
if (instant) { this.dieT = 30; if (this.actor) this.actor.update(30); }
|
||||
}
|
||||
@@ -948,7 +1017,7 @@ export class UnitView {
|
||||
if (!d) {
|
||||
if (!this.down) return;
|
||||
this.down = null;
|
||||
if (!this.alive) { this.dying = 0.55; this.dieDur = 0.55; }
|
||||
if (!this.alive) { this.dying = DIE_FADE_TAIL; this.dieDur = DIE_FADE_TAIL; }
|
||||
return;
|
||||
}
|
||||
if (this.alive) this.die(instant);
|
||||
@@ -969,6 +1038,31 @@ export class UnitView {
|
||||
/** @param {number} dt real seconds @param {any} cam camera @param {number} t real clock */
|
||||
update(dt, cam, t) {
|
||||
if (this.destroyed) return;
|
||||
// a displacement's slide (slideTo): held where it stood until the snapshot with the destination is shown, then
|
||||
// eased into the sampled position (sync keeps `lx, ly` current) under a constant deceleration
|
||||
if (this.slide) {
|
||||
const sl = this.slide;
|
||||
if (this.down) this.slide = null; // a knocked-down view lies on its tile (setDown)
|
||||
else if (!sl.live) {
|
||||
this.x = sl.sx; this.y = sl.sy;
|
||||
// never shown (the unit left the snapshots, a stalled stream): the snapshot takes the view back
|
||||
if ((sl.wait += dt) > 0.5) this.slide = null;
|
||||
} else {
|
||||
if (!sl.run) { sl.run = true; sl.ox = sl.sx - sl.lx; sl.oy = sl.sy - sl.ly; }
|
||||
const step = Math.min(dt, 0.1); // a hidden tab's catch-up frame must not overshoot
|
||||
const v0 = sl.v;
|
||||
sl.v = Math.max(0, sl.v - sl.a * step); // friction: the velocity decays every frame
|
||||
// the step's mean velocity — exact under a constant deceleration (the end-of-step speed fell ~D·dt/T short:
|
||||
// 9 % of a 0.18 s slide at 60 fps, then a jump onto the end)
|
||||
sl.done = Math.min(sl.D, sl.done + (v0 + sl.v) / 2 * step);
|
||||
sl.t += step;
|
||||
if (this.isEnemy) this.visFacing = sl.ux < 0 ? -1 : 1;
|
||||
const k = 1 - sl.done / sl.D; // the share of the way still to go
|
||||
this.x = sl.lx + sl.ox * k; this.y = sl.ly + sl.oy * k;
|
||||
// the clock or the spent velocity lands it on the sampled position
|
||||
if (sl.t >= sl.dur - 1e-9 || sl.done >= sl.D - 1e-9 || sl.v <= 1e-9) { this.x = sl.lx; this.y = sl.ly; this.slide = null; }
|
||||
}
|
||||
}
|
||||
const P = this.P;
|
||||
// the model for the state the frame's events and snapshot left (Front ⇄ Back when it went down / stood up: die, revive)
|
||||
if (this._modelDirty) { this._modelDirty = false; this._syncModel(); }
|
||||
@@ -987,7 +1081,9 @@ export class UnitView {
|
||||
const d = this.shadowZTarget - this.shadowZ;
|
||||
this.shadowZ = Math.abs(d) < 1e-3 ? this.shadowZTarget : this.shadowZ + d * Math.min(1, dt * 12);
|
||||
}
|
||||
const hoverTo = this.flying && this.alive ? FLY_HOVER : 0;
|
||||
// a flyer keeps its lift through the Die clip and drops only as it fades out: the client removes the fly offset in
|
||||
// CharacterAnimator.OnFinish, when the finish state ends; a knocked-down flyer lies on the ground
|
||||
const hoverTo = this.flying && (this.alive || (this.dying > DIE_FADE_TAIL && !this.down)) ? FLY_HOVER : 0;
|
||||
if (this.hover !== hoverTo) this.hover = Math.abs(hoverTo - this.hover) < 1e-3 ? hoverTo : this.hover + (hoverTo - this.hover) * Math.min(1, dt * 6);
|
||||
const p = cam.project(this.x, this.y, this.z + this.hover + this.lift, this.screen);
|
||||
const s = p.s;
|
||||
@@ -1001,7 +1097,7 @@ export class UnitView {
|
||||
} else if (this.dying > 0) {
|
||||
this.dieT += dt;
|
||||
this.dying -= dt;
|
||||
const tail = 0.55;
|
||||
const tail = DIE_FADE_TAIL;
|
||||
if (this.dying < tail) alpha *= Math.max(0, this.dying / tail);
|
||||
if (this.dying <= 0) { this.dying = 0; this.remove = true; alpha = 0; }
|
||||
}
|
||||
|
||||
@@ -435,3 +435,277 @@ describe('a fast enemy walks on its Run cycle (PR #275)', () => {
|
||||
assert.equal(hound.actor.roles.skill.loop, 'Skill_02', 'the cast slot survives that too');
|
||||
});
|
||||
});
|
||||
|
||||
// 推拉 (player report): the sim displaces instantly (battle/displacement.js walks 0.1-tile steps inside one call) and the
|
||||
// snapshot only carries the destination, so the view eases there (app.js `displace` fx → UnitView.slideTo) instead of
|
||||
// appearing at the end of the path.
|
||||
describe('a push / pull slide (推拉: the official impulse under friction)', () => {
|
||||
const view = async (id = 1) => {
|
||||
const ctx = fakeViewCtx(fake.P, { assets: store({ spine: true }), cam });
|
||||
const v = new UnitView(ctx, { id, side: 'enemy', kind: 'enemy', defId: 'enemy_1007_slime', x: 5, y: 12, maxHp: 100 }, {});
|
||||
await tick(); await tick();
|
||||
return v;
|
||||
};
|
||||
// 推进 n 帧（update 会把单帧 dt 截到 0.1 s，所以必须多帧走完）
|
||||
const step = (v, dur, n = 60) => { for (let i = 0; i < n; i++) v.update(dur / n, cam(), 0); };
|
||||
|
||||
test('slideTo runs a real deceleration: the velocity falls every frame and stops on the destination', async () => {
|
||||
const v = await view();
|
||||
v.slideTo(7.7, 12);
|
||||
const sl = v.slide;
|
||||
assert.ok(sl, 'a slide is in flight');
|
||||
assert.ok(sl.v > 0 && sl.a > 0, 'it starts with a speed and a deceleration');
|
||||
assert.ok(Math.abs(sl.v * sl.v / (2 * sl.a) - 2.7) < 1e-6, 'v²/2a = the distance (constant deceleration)');
|
||||
let prev = sl.v;
|
||||
let monotone = true;
|
||||
for (let i = 0; i < 40; i++) {
|
||||
v.update(sl.dur / 80, cam(), 0);
|
||||
if (v.slide && v.slide.v > prev + 1e-9) monotone = false;
|
||||
if (!v.slide) break;
|
||||
prev = v.slide.v;
|
||||
}
|
||||
assert.ok(monotone, 'the velocity only ever decreases');
|
||||
step(v, sl.dur);
|
||||
assert.equal(v.x, 7.7, 'it arrives exactly on the authoritative destination');
|
||||
assert.equal(v.y, 12, 'the cross axis holds');
|
||||
assert.equal(v.slide, null);
|
||||
});
|
||||
|
||||
test('starting a slide from the destination is a no-op (why app.js pre-scans the frame)', async () => {
|
||||
// The trap this guards: app.js's snapshot loop runs before processEvents, and the snapshot already carries the
|
||||
// displacement's destination, so a fx handler that runs after it finds the view there and has nothing to animate —
|
||||
// the reported pause with no frames. app.js therefore starts the slide from the pre-snapshot position.
|
||||
const v = await view(8);
|
||||
v.sync({ x: 7.7, y: 12, hp: 100, maxHp: 100, sp: 0, spMax: 0, flags: 0, anim: 0 });
|
||||
assert.equal(v.x, 7.7);
|
||||
v.slideTo(7.7, 12);
|
||||
assert.equal(v.slide, null, 'no slide when the view is already there');
|
||||
});
|
||||
|
||||
test('a second request for the same destination never restarts the slide in flight', async () => {
|
||||
const v = await view(9);
|
||||
v.slideTo(7.7, 12);
|
||||
const first = v.slide;
|
||||
for (let i = 0; i < 10; i++) v.update(first.dur / 40, cam(), 0);
|
||||
const mid = v.x, done = v.slide.done;
|
||||
v.slideTo(7.7, 12); // the fx handler, later in the same frame
|
||||
assert.equal(v.slide, first, 'the same slide object, not a restart');
|
||||
assert.equal(v.x, mid, 'the position is untouched');
|
||||
assert.equal(v.slide.done, done);
|
||||
step(v, first.dur);
|
||||
assert.equal(v.x, 7.7, 'and it still lands');
|
||||
});
|
||||
|
||||
test('a pushed enemy faces the way it is pushed, not the route it resumes', async () => {
|
||||
// The official turns a displaced unit towards the force (_dontChangeFaceByDirection is an opt-in flag); our facing
|
||||
// comes from the snapshot's vx, which after a displacement points back down the route the enemy walks again —
|
||||
// i.e. against the push (player report: 被推开敌人的方向反过来了).
|
||||
const v = await view(10);
|
||||
v.sync({ x: 5, y: 12, hp: 100, maxHp: 100, sp: 0, spMax: 0, flags: 0, anim: 0, vx: -1.2 });
|
||||
assert.equal(v.visFacing, -1, 'walking left before the push');
|
||||
v.slideTo(7.7, 12); // pushed to the right
|
||||
assert.equal(v.visFacing, 1, 'faces the push at once');
|
||||
for (let i = 0; i < 20; i++) v.update(v.slide.dur / 40, cam(), 0);
|
||||
assert.equal(v.visFacing, 1, 'still facing the push in flight');
|
||||
v.slideTo(5.2, 12); // now pulled back to the left
|
||||
assert.equal(v.visFacing, -1, 'and the other way for a pull');
|
||||
});
|
||||
|
||||
test('a snapshot in flight does not teleport it (the slide owns the position until it lands)', async () => {
|
||||
const v = await view(7);
|
||||
v.slideTo(7.7, 12);
|
||||
const dur = v.slide.dur;
|
||||
for (let i = 0; i < 12; i++) v.update(dur / 40, cam(), 0);
|
||||
const mid = v.x;
|
||||
assert.ok(mid > 5.2 && mid < 7.6, `mid-flight (${mid})`);
|
||||
// the sim's snapshots already carry the destination (it displaced the enemy inside one call), so a plain sync
|
||||
// would snap the view there — the reported "no frames in between"
|
||||
v.sync({ x: 7.7, y: 12, hp: 100, maxHp: 100, sp: 0, spMax: 0, flags: 0, anim: 0 });
|
||||
assert.equal(v.x, mid, 'the snapshot does not move a sliding view');
|
||||
assert.equal(v.y, 12);
|
||||
step(v, dur);
|
||||
assert.equal(v.x, 7.7, 'and it still lands on the destination');
|
||||
// once landed, snapshots drive it again
|
||||
v.update(dur, cam(), 0);
|
||||
v.sync({ x: 6.4, y: 12, hp: 100, maxHp: 100, sp: 0, spMax: 0, flags: 0, anim: 0 });
|
||||
assert.equal(v.x, 6.4, 'a landed view follows the snapshot again');
|
||||
});
|
||||
|
||||
test('a slippery floor (a smaller friction factor) slides longer and lands just the same', async () => {
|
||||
const dry = await view(2), ice = await view(3);
|
||||
dry.slideTo(7.7, 12);
|
||||
ice.slideTo(7.7, 12, { friction: 0.5 });
|
||||
assert.ok(ice.slide.dur > dry.slide.dur * 1.5, `ice ${ice.slide.dur} > dry ${dry.slide.dur}`);
|
||||
step(ice, ice.slide.dur * 1.05, 90);
|
||||
assert.equal(ice.x, 7.7, 'the destination is authoritative whatever the floor');
|
||||
});
|
||||
|
||||
test('the duration follows √distance, not distance', async () => {
|
||||
const near = await view(4), far = await view(5);
|
||||
near.slideTo(6.2, 12); far.slideTo(10.5, 12); // 1.2 vs 5.5 tiles
|
||||
assert.ok(far.slide.dur > near.slide.dur, `${far.slide.dur} > ${near.slide.dur}`);
|
||||
assert.ok(far.slide.dur / near.slide.dur < 2.6, 'sub-linear (∝ √d)');
|
||||
});
|
||||
|
||||
test('a trivial move snaps, an unknown target is ignored; a unit that dies on the way lies where it was pushed', async () => {
|
||||
const v = await view(6);
|
||||
v.slideTo(5.01, 12);
|
||||
assert.equal(v.slide, null); assert.equal(v.x, 5.01, 'a sub-0.05 tile move is not a displacement');
|
||||
v.slideTo(NaN, 12);
|
||||
assert.equal(v.slide, null); assert.equal(v.x, 5.01);
|
||||
v.slideTo(7.7, 12);
|
||||
step(v, v.slide.dur / 3, 20);
|
||||
assert.ok(v.x > 5 && v.x < 7.7, `moving (${v.x})`);
|
||||
// the sim's displacement already put the body at the destination (a Weedy wall kill dies there): the corpse
|
||||
// finishes the slide and stays — PR #380 sent it back to where it stood, and the next snapshot then jumped it
|
||||
v.die();
|
||||
v.update(1, cam(), 0);
|
||||
v.update(0.1, cam(), 0);
|
||||
assert.equal(v.x, 7.7, 'the corpse lies where the push put it');
|
||||
assert.equal(v.slide, null);
|
||||
const dead = await view(11);
|
||||
dead.die();
|
||||
dead.slideTo(7.7, 12);
|
||||
assert.equal(dead.slide, null, 'a dead view does not start a slide');
|
||||
assert.equal(dead.x, 7.7, 'it is placed on the destination');
|
||||
});
|
||||
|
||||
test('held until the snapshot with the destination is shown (`at`), then eased into the sampled position — the walk it resumes included — with no jump on landing', async () => {
|
||||
const v = await view(12);
|
||||
v.sync({ x: 5, y: 12, hp: 100, maxHp: 100, sp: 0, spMax: 0, flags: 0, anim: 1, vx: -0.8 }, 2.9);
|
||||
v.slideTo(7.7, 12, { at: 3 }); // app.js: the interval ending on the destination's snapshot is shown
|
||||
for (const [x, t] of [[5.9, 2.93], [6.8, 2.96]]) { // the interpolator lerps there in the meantime
|
||||
v.sync({ x, y: 12, hp: 100, maxHp: 100, sp: 0, spMax: 0, flags: 0, anim: 1, vx: 27 }, t);
|
||||
v.update(1 / 60, cam(), 0);
|
||||
assert.equal(v.x, 5, `held where it stood at ${t}`);
|
||||
}
|
||||
// from the destination's snapshot on the sample anchors the slide, and the enemy walks back down its route
|
||||
let live = 7.7, prev = v.x, maxStep = 0, frames = 0;
|
||||
for (let t = 3; v.slide && frames < 120; t += 1 / 30, frames++) {
|
||||
v.sync({ x: live, y: 12, hp: 100, maxHp: 100, sp: 0, spMax: 0, flags: 0, anim: 1, vx: -0.8 }, t);
|
||||
v.update(1 / 60, cam(), 0);
|
||||
maxStep = Math.max(maxStep, Math.abs(v.x - prev)); prev = v.x;
|
||||
live -= 0.8 / 30;
|
||||
}
|
||||
assert.ok(frames >= 8, `a slide of ${frames} frames, not a jump`);
|
||||
assert.equal(v.slide, null);
|
||||
assert.ok(maxStep < 0.4, `no frame moves more than ${maxStep.toFixed(3)} tiles`);
|
||||
const landed = v.x;
|
||||
v.sync({ x: live, y: 12, hp: 100, maxHp: 100, sp: 0, spMax: 0, flags: 0, anim: 1, vx: -0.8 }, 3 + frames / 30);
|
||||
assert.ok(Math.abs(v.x - landed) < 0.05, `landed on the walking enemy (${landed.toFixed(3)} → ${v.x.toFixed(3)})`);
|
||||
});
|
||||
|
||||
test('a slide that is never shown (the unit left the snapshots) hands the view back', async () => {
|
||||
const v = await view(13);
|
||||
v.slideTo(7.7, 12, { at: 3 });
|
||||
for (let i = 0; i < 40; i++) v.update(1 / 60, cam(), 0);
|
||||
assert.equal(v.slide, null);
|
||||
v.sync({ x: 6.1, y: 12, hp: 100, maxHp: 100, sp: 0, spMax: 0, flags: 0, anim: 1 }, 3.4);
|
||||
assert.equal(v.x, 6.1);
|
||||
});
|
||||
});
|
||||
|
||||
// the app.js frame order (render/app.js: processEvents takes the events ≤ renderT, then syncBattle's look-ahead starts a
|
||||
// slide for a `displace` fx still queued up to the next snapshot, then sample → sync, then update) run over a real
|
||||
// battle: a pushed enemy is drawn sliding, not snapped
|
||||
describe('a push through SnapshotBuffer and UnitView in the app.js frame order (PR #380)', () => {
|
||||
async function pushed({ kill = false } = {}) {
|
||||
const { makeBattle, enemyRec } = await import('../helpers/battleHarness.js');
|
||||
const { SnapshotBuffer } = await import('../../public/js/render/interp.js');
|
||||
const { snapFrame } = await import('../../server/match/fields.js');
|
||||
const h = makeBattle({ defs: { enemies: { enemy_walker: enemyRec({ key: 'enemy_walker', hp: 1e6, speed: 0.8 }) } },
|
||||
enemies: [{ key: 'enemy_walker', time: 0, route: 0 }], content: 'none', autoFinish: false, timeLimit: 60 });
|
||||
const frames = [];
|
||||
let e = null, info = null, moved = 0, dest = null;
|
||||
for (let i = 0; i < 30 * 6; i++) {
|
||||
h.step();
|
||||
e = e || h.enemy('enemy_walker');
|
||||
if (!moved && h.b.time >= 3) {
|
||||
moved = h.b.displace(e, { x: 1, y: 0 }, 1.7);
|
||||
dest = e.x;
|
||||
if (kill) h.b.kill(e, null);
|
||||
}
|
||||
if (i % 3 === 2) {
|
||||
const ev = h.b.drainEvents();
|
||||
info = info || ev.find((x) => x[0] === 'spawn')?.[1];
|
||||
const s = h.b.snapshot();
|
||||
frames.push({ at: s.t / 2, snap: snapFrame('f', s), ev, gt: s.t });
|
||||
}
|
||||
}
|
||||
assert.ok(moved > 1, `the sim pushed it ${moved} tiles`);
|
||||
const ctx = fakeViewCtx(fake.P, { cam });
|
||||
const v = new UnitView(ctx, { ...info, id: e.id }, {});
|
||||
const buf = new SnapshotBuffer(), sample = new Map(), xs = [];
|
||||
const start = (ev, at) => { if (ev[0] === 'fx' && ev[1] === 'displace' && ev[4]?.id === e.id) v.slideTo(Number(ev[2]), Number(ev[3]), at == null ? {} : { at }); };
|
||||
for (let f = 0, fi = 0; f < 60 * 3; f++) {
|
||||
const now = f / 60;
|
||||
for (; fi < frames.length && frames[fi].at <= now; fi++) { buf.push(frames[fi].snap, frames[fi].at); buf.pushEvents(frames[fi].ev, frames[fi].at, frames[fi].gt); }
|
||||
const renderT = buf.update(now);
|
||||
if (!Number.isFinite(renderT)) continue;
|
||||
for (const ev of buf.takeEvents(renderT, [])) { start(ev); if (ev[0] === 'die' && ev[1] === e.id && v.alive) v.die(); }
|
||||
const at = buf.nextSnapT(renderT);
|
||||
if (at > renderT) buf.forEachUpcoming(renderT, at, (ev) => start(ev, at));
|
||||
buf.sample(renderT, sample);
|
||||
if (sample.get(e.id)) v.sync(sample.get(e.id), renderT);
|
||||
v.update(1 / 60, cam(), now);
|
||||
if (renderT > 2.8 && renderT < 3.8) xs.push(v.x);
|
||||
}
|
||||
return { xs, dest };
|
||||
}
|
||||
|
||||
test('a 1.7-tile push is drawn over a dozen frames, every frame a step under 0.35 tiles', async () => {
|
||||
const { xs } = await pushed();
|
||||
let big = 0, moving = 0;
|
||||
for (let i = 1; i < xs.length; i++) { const d = Math.abs(xs[i] - xs[i - 1]); big = Math.max(big, d); if (d > 0.02) moving++; }
|
||||
assert.ok(moving >= 8, `${moving} frames show it moving (the bare interpolator: 3)`);
|
||||
assert.ok(big < 0.35, `largest step ${big.toFixed(3)} tiles (the bare interpolator: 0.58)`);
|
||||
});
|
||||
|
||||
test('killed right after the push, the body slides on to where the sim left it and stays there', async () => {
|
||||
const { xs, dest } = await pushed({ kill: true });
|
||||
assert.ok(Math.abs(xs[xs.length - 1] - dest) < 0.011, `${xs[xs.length - 1]} vs ${dest}`);
|
||||
const from = xs.findIndex((x, i) => i > 0 && x > xs[i - 1] + 0.01); // the slide's first frame (it walked left before)
|
||||
assert.ok(from > 0);
|
||||
for (let i = from; i < xs.length; i++) assert.ok(xs[i] >= xs[i - 1] - 1e-9, `never back towards where it stood (frame ${i})`);
|
||||
});
|
||||
});
|
||||
|
||||
// PR #380, death: a flyer holds its lift through the Die clip (the official client drops its fly offset in
|
||||
// CharacterAnimator.OnFinish) and a long Die clip plays whole (DIE_CLIP_MAX, data/assets.json's longest 7.97 s)
|
||||
describe('death timing (PR #380): a dying flyer drops inside the fade, a long Die clip plays whole', () => {
|
||||
test('a dying flyer keeps FLY_HOVER through its Die clip and sinks only in the fade tail; a walker stays down', async () => {
|
||||
const { FLY_HOVER, UF } = { ...(await import('../../public/js/render/units.js')), ...(await import('../../shared/constants.js')) };
|
||||
const ctx = fakeViewCtx(fake.P, { cam });
|
||||
const fly = new UnitView(ctx, { id: 21, side: 'enemy', kind: 'enemy', defId: 'enemy_fly', motion: 'FLY', x: 5, y: 12, maxHp: 100 }, {});
|
||||
fly.sync({ x: 5, y: 12, hp: 100, maxHp: 100, sp: 0, spMax: 0, flags: UF.FLYING, anim: 1 }, 1);
|
||||
for (let i = 0; i < 120; i++) fly.update(1 / 60, cam(), 0);
|
||||
assert.ok(Math.abs(fly.hover - FLY_HOVER) < 1e-3, 'aloft while alive');
|
||||
fly.die(); // no clip known: 0.35 s of clip, then the 0.55 s fade
|
||||
for (let i = 0; i < 18; i++) fly.update(1 / 60, cam(), 0);
|
||||
assert.ok(Math.abs(fly.hover - FLY_HOVER) < 1e-3, `still aloft in the Die clip (${fly.hover.toFixed(3)})`);
|
||||
for (let i = 0; i < 30; i++) fly.update(1 / 60, cam(), 0);
|
||||
assert.ok(fly.hover < FLY_HOVER * 0.25, `sinking in the fade (${fly.hover.toFixed(3)})`);
|
||||
const walker = new UnitView(ctx, { id: 22, side: 'enemy', kind: 'enemy', defId: 'enemy_walk', x: 5, y: 12, maxHp: 100 }, {});
|
||||
walker.die();
|
||||
walker.update(1 / 60, cam(), 0);
|
||||
assert.equal(walker.hover, 0);
|
||||
});
|
||||
|
||||
test('every enemy Die clip of data/assets.json is within DIE_CLIP_MAX, and a 7.97 s one is scheduled whole', async () => {
|
||||
const { DIE_CLIP_MAX, dieClipDur } = await import('../../public/js/render/units.js');
|
||||
const durs = Object.values(ASSETS.enemies).map((e) => dieClipDur(e && e.spine)).filter((d) => d > 0);
|
||||
assert.ok(durs.length > 200, `${durs.length} enemy Die clips`);
|
||||
const longest = Math.max(...durs);
|
||||
assert.ok(longest <= DIE_CLIP_MAX, `longest Die clip ${longest} s ≤ ${DIE_CLIP_MAX}`);
|
||||
assert.ok(durs.filter((d) => d > 1.6).length > 0, 'the old 1.6 s cap cut some clips short');
|
||||
const entry = { skel: '/s/q.skel', atlas: '/s/q.atlas', textures: ['/s/q.png'], anims: { idle: 'Idle', die: 'Die' }, animations: { Idle: 1, Die: longest } };
|
||||
const assets = { ...store({ spine: true }), spineEntry: () => entry };
|
||||
const v = new UnitView(fakeViewCtx(fake.P, { assets, cam }), { id: 23, side: 'enemy', kind: 'enemy', defId: 'enemy_1521_dslily', x: 5, y: 12, maxHp: 100 }, {});
|
||||
await tick(); await tick();
|
||||
assert.ok(v.actor, 'the model is up');
|
||||
v.die();
|
||||
assert.ok(Math.abs(v.dying - (longest + 0.55)) < 1e-6, `the whole clip, then the fade (${v.dying.toFixed(3)} s)`);
|
||||
for (let i = 0; i < 300; i++) v.update(1 / 60, cam(), 0);
|
||||
assert.ok(!v.remove && v.alpha > 0.5, 'still on screen 5 s in');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,33 @@
|
||||
// The contract between server/sim/battle/displacement.js and render/app.js: a displacement puts a
|
||||
// ['fx', 'displace', x, y, { id }] tuple into the stream the client renders. The client must read the destination
|
||||
// from the tuple's own slots — e[4] carries the id only, and reading x/y from it silently produced NaN, which made
|
||||
// slideTo a no-op (player report: 有停顿但没有中间帧).
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { makeBattle, enemyRec } from '../helpers/battleHarness.js';
|
||||
|
||||
const walker = (o = {}) => enemyRec({ key: 'enemy_walker', hp: 1e6, speed: 1, ...o });
|
||||
|
||||
test('a displacement puts a `displace` fx into the event stream the client receives', () => {
|
||||
const h = makeBattle({
|
||||
defs: { enemies: { enemy_walker: walker({ speed: 0.01 }) } },
|
||||
enemies: [{ key: 'enemy_walker', pos: [10, 6] }],
|
||||
content: 'none', autoFinish: false,
|
||||
});
|
||||
h.step();
|
||||
const e = h.enemy('enemy_walker');
|
||||
h.b.drainEvents(); // clear the spawn/etc. batch
|
||||
const moved = h.b.displace(e, { x: 1, y: 0 }, 2, { force: 1 });
|
||||
assert.ok(moved > 1.8, 'the enemy moved: ' + moved);
|
||||
const evs = h.b.drainEvents();
|
||||
const fx = (evs || []).filter((t) => Array.isArray(t) && t[0] === 'fx');
|
||||
const disp = fx.find((t) => t[1] === 'displace');
|
||||
assert.ok(disp, 'the stream carries a displace fx: ' + JSON.stringify(fx));
|
||||
// the fx rounds its coordinates to 2 decimals (events.js fx), the unit keeps full precision
|
||||
assert.ok(Math.abs(disp[2] - e.x) <= 0.01, 'e[2] is the destination x: ' + disp[2] + ' vs ' + e.x);
|
||||
assert.ok(Math.abs(disp[3] - e.y) <= 0.01, 'e[3] is the destination y: ' + disp[3] + ' vs ' + e.y);
|
||||
assert.equal(disp[4] && disp[4].id, e.id, 'e[4].id is the displaced unit');
|
||||
assert.equal(disp[4].x, undefined, 'e[4] carries no x — reading it gave NaN, so no slide ever ran');
|
||||
assert.equal(disp[4].y, undefined, 'e[4] carries no y either');
|
||||
});
|
||||
|
||||
Reference in new issue
Block a user