# L.3 — VectorUpdate (0xF74E) handler chain + jump pseudocode

Source: `docs/research/named-retail/acclient_2013_pseudo_c.txt` (Sept 2013 EoR PDB-named).

All retail line numbers below refer to that file (`acclient_2013_pseudo_c.txt`).

---

## 1. `CM_Physics::DispatchSB_VectorUpdate` — packet → handler

**Address:** `0x006acd20` (line 692119)

```
006acd20  enum NetBlobProcessedStatus CM_Physics::DispatchSB_VectorUpdate(
              class SmartBox* arg1,
              class NetBlob* arg2)
{
    NetBlob* ebx = arg2;
    if (ebx == 0 || arg1 == 0) return 3;
    uint8_t* buf_     = ebx->buf_;       // body bytes
    uint32_t bufSize_ = ebx->bufSize_;
    if (*(uint32_t*)buf_ != 0xf74e) return 3;          // line 692130 — opcode gate

    uint32_t guid    = *(uint32_t*)(buf_ + 4);          // line 692136 — object id
    arg2 = &buf_[8];

    Vector3 velocity;                                    // line 692139
    AC1Legacy::Vector3::UnPack(&velocity, &arg2, ...);

    Vector3 omega;                                       // line 692141
    AC1Legacy::Vector3::UnPack(&omega, &arg2, ...);

    PhysicsTimestampPack ts;                             // line 692143
    PhysicsTimestampPack::UnPack(&ts, &arg2, ...);

    return SmartBox::HandleVectorUpdate(arg1, ebx, guid, &velocity, &omega, &ts);
}
```

Wire layout: `[opcode:u32 0xF74E][guid:u32][velocity:Vector3][omega:Vector3][ts:PhysicsTimestampPack]`.
The PhysicsTimestampPack carries `ts1` (port-event sequence) and `ts2` (vector
event sequence, used in DoVectorUpdate as `update_times[3]`).

---

## 2. `SmartBox::HandleVectorUpdate` — sequence gate

**Address:** `0x00453480` (line 92195)

```
00453480  enum NetBlobProcessedStatus SmartBox::HandleVectorUpdate(
              SmartBox* this,
              NetBlob* arg2,           // raw blob (re-queued on early)
              uint32_t  arg3,          // guid
              Vector3 const* arg4,     // velocity (world)
              Vector3 const* arg5,     // omega (world)
              PhysicsTimestampPack const* arg6)
{
    int32_t ebp = arg6->ts2;            // vector event ts (line 92199)
    int32_t esi = arg6->ts1;            // port event ts (line 92201)
    CPhysicsObj* obj = CObjectMaint::GetObjectA(this->m_pObjMaint, arg3);

    if (obj != 0)
    {
        int32_t ebx = obj->update_times[8];          // last-seen port-event ts
        // Signed compare across 16-bit wrap (lines 92210-92218 standard
        // wrap-aware "newer?" macro): if ebx == esi → in sync, dispatch.
        if (ebx == esi)
        {
            SmartBox::DoVectorUpdate(this, obj, arg4, arg5, ebp);
            return 1;     // PROCESSED
        }
        if (ebx != esi)
            return 2;     // OUT_OF_ORDER (newer port event hasn't arrived)
    }

    // Object not yet known — queue the blob for later.
    CObjectMaint::QueueBlobForObject(this->m_pObjMaint, arg3, arg2);
    return 4;             // DEFERRED
}
```

Note: VectorUpdate is gated against `update_times[8]` (the
**port-event timestamp**), not `update_times[3]`. This means a VectorUpdate
will *not* be applied unless the latest 0xF748 PortalCellUpdate / position
event has already been processed. This is how retail keeps the velocity
write coherent with the position the server intended.

---

## 3. `SmartBox::DoVectorUpdate` — the actual write

**Address:** `0x004521c0` (line 91208)

```
004521c0  void SmartBox::DoVectorUpdate(
              SmartBox* this,
              CPhysicsObj* arg2,
              Vector3 const* arg3,    // velocity (world)
              Vector3 const* arg4,    // omega (world)
              uint16_t arg5)          // ts2 (vector-event ts)
{
    int32_t esi = arg2->update_times[3];      // last vector ts on object
    int32_t edi = arg5;
    // Wrap-aware "edi newer than esi" check (lines 91217-91227).
    // The decompiler's flag arithmetic collapses to 0 here; the real
    // gate is `edi != esi`.
    if (edi != esi)
    {
        arg2->update_times[3] = edi;                   // line 91229

        if (arg2 != this->player)
        {
            CPhysicsObj::set_velocity(arg2, arg3, 1);  // line 91233 — REMOTE
            CPhysicsObj::set_omega   (arg2, arg4, 1);
        }
        else if (this->cmdinterp->vtable->UsePositionFromServer() != 0)
        {
            CPhysicsObj::set_velocity(arg2, arg3, 1);  // line 91238 — LOCAL only when server-driven
            CPhysicsObj::set_omega   (arg2, arg4, 1);
        }
    }
}
```

**Critical observations** (relevant to acdream's K-fix15 question):

1. **Retail does NOT set the Gravity flag here.** It does not touch
   `state` at all. It only writes `m_velocityVector` (via set_velocity)
   and `m_omegaVector` (via set_omega). Gravity is already-on for
   creatures by default (set when the body enters the world via
   `enter_default_state` → `LeaveGround`); VectorUpdate does not
   need to re-set it.
2. **Retail does NOT clear Contact / OnWalkable here.** The
   transient-state bits stay whatever they were. Clearing them is the
   job of `set_on_walkable(false)` which fires from
   `CMotionInterp::jump` (local jumps only), or from the next physics
   tick when the sphere-sweep finds no contact plane.
3. **Retail just writes the velocity.** The next per-tick
   `CPhysicsObj::UpdateObjectInternal` reads `m_velocityVector`,
   adds gravity acceleration (computed by `calc_acceleration`),
   integrates position, and the sphere-sweep handles contact.

So acdream's `OnLiveVectorUpdated` (GameWindow.cs:3246-3304) is doing
*more* than retail: it also clears Contact/OnWalkable + sets Gravity
when v.Z > 0.5. The reason this is necessary in acdream is that
acdream's per-tick path (`UpdatePhysicsInternal`) gates gravity on
`!OnWalkable` rather than reading the `state.Gravity` bit — see
`PhysicsBody.calc_acceleration` and the per-tick velocity integration.
Retail's per-tick reads `state & GRAVITY` (always set for creatures)
AND `transient_state & (CONTACT | ON_WALKABLE)` to short-circuit
acceleration to zero (see calc_acceleration below).

`set_velocity(arg3, /*arg3=*/1)` clamps |v| ≤ 50 (MaxVelocity) and
sets `transient_state.Active`. The `arg3=1` flag distinguishes
network-source (1) from local-source (0); only used to gate
update_time refresh.

---

## 4. `CPhysicsObj::set_velocity`

**Address:** `0x005113f0` (line 279361)

```
005113f0  void CPhysicsObj::set_velocity(
              CPhysicsObj* this, Vector3 const* arg2, int32_t arg3)
{
    if (Vector3::operator!=(arg2, &this->m_velocityVector) != 0)   // line 279364
    {
        this->m_velocityVector = *arg2;                             // 279366-368
        // Magnitude clamp to 50 (MaxVelocity squared = 2500).
        long double mag2 = vx*vx + vy*vy + vz*vz;                   // 279372
        if (50f*50f < mag2)                                         // 279377
        {
            AC1Legacy::Vector3::normalize(&this->m_velocityVector); // 279383
            this->m_velocityVector.x *= 50f;                        // 279384
            this->m_velocityVector.y *= 50f;
            this->m_velocityVector.z *= 50f;
        }
        this->jumped_this_frame = 1;                                // 279389 ★
    }

    // Set Active transient flag (bit 7 = 0x80) when state.Gravity bit not set.
    if ((this->state & 1) == 0)                                     // line 279392 ★
    {
        if (this->transient_state >= 0)
        {
            this->update_time = Timer::cur_time;                    // 279398-399
        }
        this->transient_state |= 0x80;                              // 279402 — Active
    }
}
```

Two side effects beyond the velocity write:
- **`jumped_this_frame = 1`** (offset +0x9C). Skips contact resolution
  this frame; gives gravity room to lift the body off the floor before
  the sweep clamps it back. Critical for jump start — without this, the
  +Z velocity gets immediately killed by the floor sweep on frame N+1.
- **`transient_state |= Active (0x80)`**. Marks the object for
  per-tick processing (UpdateObjectInternal early-outs if Active is
  not set).

Note line 279392: `(this->state & 1)` is testing bit 0, which is the
**Static** flag, not Gravity. Retail only blocks the Active bit-set
on static objects.

---

## 5. `CPhysicsObj::set_local_velocity`

**Address:** `0x005114d0` (line 279408)

```
005114d0  void CPhysicsObj::set_local_velocity(
              CPhysicsObj* this, Vector3 const* arg2, int32_t arg3)
{
    // Multiply local-frame velocity by orientation matrix (frame.m_fl2gv,
    // 9 floats at offset 0x...). worldX = m_fl2gv[0]*lx + m_fl2gv[3]*ly + m_fl2gv[6]*lz
    Vector3 worldVel = orientation × arg2;
    CPhysicsObj::set_velocity(this, &worldVel, arg3);
}
```

Used by `CMotionInterp::LeaveGround` to convert the body-local launch
vector (forward/right/up relative to facing) into a world vector.

---

## 6. `OBJECTINFO::kill_velocity` (clear_velocity equivalent)

**Address:** `0x0050cfe0` (line 274467)

```
0050cfe0  void OBJECTINFO::kill_velocity(OBJECTINFO* this)
{
    CPhysicsObj* obj = this->object;
    Vector3 zero = (0, 0, 0);
    CPhysicsObj::set_velocity(obj, &zero, 0);    // arg3=0 (local source)
}
```

Retail does not have a separate `clear_velocity` — it just zeros via
set_velocity. Called from collision handlers when a wall hit kills
forward motion (lines 272567, 273237).

---

## 7. `CMotionInterp::LeaveGround` — outbound jump trigger

**Address:** `0x00528b00` (line 306022)

```
00528b00  void CMotionInterp::LeaveGround(CMotionInterp* this)
{
    if (!this->physics_obj) return;

    // Creature gate: only run for creatures (or when no weenie).
    CWeenieObject* w = this->weenie_obj;
    bool isCreature = w == 0 ? true : w->vtable->IsCreature();
    if (!(w == 0 || isCreature)) return;

    CPhysicsObj* po = this->physics_obj;
    // Only if state.Gravity bit set (state & 4 — line 306037).
    if ((po->state & 4) == 0) return;                  // ★ Gravity gate

    Vector3 leaveVel;                                  // line 306039
    CMotionInterp::get_leave_ground_velocity(this, &leaveVel);
    CPhysicsObj::set_local_velocity(po, &leaveVel, 1); // line 306041

    this->standing_longjump = 0;                       // 306043
    this->jump_extent       = 0f;                      // 306044 ★ extent reset

    CPhysicsObj::RemoveLinkAnimations(po);             // 306045
    CMotionInterp::apply_current_movement(this, 0, 0); // 306046
}
```

**Order matters:** `get_leave_ground_velocity` is called BEFORE
`jump_extent` is zeroed. After LeaveGround returns, calling
`get_jump_v_z()` returns 0 (because the extent gate at the top
fires). acdream's `PlayerMovementController` correctly captures
`jumpVz` before calling `LeaveGround` for that reason
(PlayerMovementController.cs:440).

LeaveGround does NOT clear Contact / OnWalkable — that already
happened upstream in `CMotionInterp::jump` via
`CPhysicsObj::set_on_walkable(po, 0)` (line 305811).

---

## 8. `CMotionInterp::HitGround` — landing trigger

**Address:** `0x00528ac0` (line 305996)

```
00528ac0  void CMotionInterp::HitGround(CMotionInterp* this)
{
    if (!this->physics_obj) return;

    CWeenieObject* w = this->weenie_obj;
    bool isCreature = w == 0 ? true : w->vtable->IsCreature();
    if (!(w == 0 || isCreature)) return;

    CPhysicsObj* po = this->physics_obj;
    if ((po->state & 4) == 0) return;                  // Gravity gate

    CPhysicsObj::RemoveLinkAnimations(po);             // 306013
    CMotionInterp::apply_current_movement(this, 0, 0); // 306014 — re-pose
}
```

**HitGround does NOT touch velocity.** It only clears the link-anim
and re-applies the current motion (which routes back through
`apply_current_movement → get_state_velocity → set_local_velocity`,
which writes the new ground velocity back to the body).

---

## 9. `MovementManager::HitGround` / `LeaveGround` — wrappers

**HitGround:** `0x00524300` (line 300425)
**LeaveGround:** `0x00524320` (line 300444)

```
00524300  void MovementManager::HitGround(MovementManager* this)
{
    if (this->motion_interpreter)
        CMotionInterp::HitGround(this->motion_interpreter);
    if (this->moveto_manager)
        MoveToManager::HitGround(this->moveto_manager);
}
```

LeaveGround mirrors this. These are the public entry points; the
**caller is `CPhysicsObj::set_on_walkable`**.

---

## 10. `CPhysicsObj::set_on_walkable` — the trigger source

**Address:** `0x00511310` (line 279287)

```
00511310  void CPhysicsObj::set_on_walkable(CPhysicsObj* this, int32_t arg2)
{
    uint32_t ts = this->transient_state;
    uint32_t newTs = (arg2 == 0) ? (ts & ~0x2) : (ts | 0x2);
    this->transient_state = newTs;

    if ((ts & 0x2) == 0)                  // was NOT on-walkable
    {
        if (arg2 != 0)                    // → becoming on-walkable
        {
            if (this->movement_manager)
                MovementManager::HitGround(this->movement_manager);   // ★ LANDING
        }
    }
    else if (arg2 == 0)                   // was on-walkable, becoming off
    {
        if (this->movement_manager)
        {
            MovementManager::LeaveGround(this->movement_manager);     // ★ LAUNCH
            CPhysicsObj::calc_acceleration(this);
            return;
        }
    }
    CPhysicsObj::calc_acceleration(this);
}
```

So the **edge detector** lives here:
- `OnWalkable: 0 → 1` fires `HitGround` (landing).
- `OnWalkable: 1 → 0` fires `LeaveGround` (launch).

`set_on_walkable` itself is called from two places:

1. **`CMotionInterp::jump`** (line 305811): `set_on_walkable(po, 0)` —
   forces the launch edge.
2. **`CPhysicsObj::set_frame`** ground-floor sphere-sweep result
   (lines 283474-283509). After the per-tick sphere-sweep stores its
   resulting collision_info, this block walks contact_plane.N.z vs
   `PhysicsGlobals::floor_z` (the cosine of max walkable slope, ≈
   0.66 → 49°). If the contact plane is steep enough, `set_on_walkable(0)`;
   if walkable, `set_on_walkable(1)`. **This is how landing detection
   fires automatically in retail** — the per-tick sweep finds a walkable
   surface under the body, set_on_walkable flips 0→1, HitGround fires.

So the answer to "how does retail's HitGround fire" is: **from
`set_frame` (called by the per-tick sphere sweep)**, not from a
separate trigger. The sweep computes the new contact plane; if it
classifies as walkable, the edge fires HitGround.

---

## 11. `CMotionInterp::jump` — the entry point

**Address:** `0x00528780` (line 305792)

```
00528780  uint32_t CMotionInterp::jump(CMotionInterp* this, float arg2, int32_t* arg3)
{
    CPhysicsObj* po = this->physics_obj;
    if (po == 0) return 8;

    CPhysicsObj::interrupt_current_movement(po);             // 305800
    uint32_t result = CMotionInterp::jump_is_allowed(this, arg2, arg3);
    if (result != 0) {
        this->standing_longjump = 0;                          // 305805
        return result;                                        // failure code
    }

    this->jump_extent = arg2;                                 // 305810 ★ extent
    CPhysicsObj::set_on_walkable(po, 0);                      // 305811 ★ launch
    return 0;
}
```

The launch sequence is:
1. `jump_is_allowed` validates (returns 0 on success).
2. Store extent.
3. `set_on_walkable(false)` → triggers `LeaveGround` via the wrapper
   chain in step 10 above. LeaveGround reads `jump_extent` to compose
   `get_leave_ground_velocity` and writes it via `set_local_velocity`.
4. Returns to caller (PlayerInputControl::Event_Jump_NonAutonomous,
   line 376264) which sends 0xF61C MoveToState + 0xF74E VectorUpdate
   (via Event_Jump → JumpPack).

---

## 12. `CMotionInterp::get_jump_v_z` — vertical component

**Address:** `0x00527aa0` (line 304953)

```
00527aa0  float CMotionInterp::get_jump_v_z(CMotionInterp const* this)
{
    float extent = this->jump_extent;                       // 304957
    if (extent < 0.000199999995f) return 0.0f;              // 304959 (epsilon)
    if (extent > 1.0f) extent = 1.0f;                       // 304968-973 clamp

    CWeenieObject* w = this->weenie_obj;                    // 304975
    if (w == 0) return /* fallback */;                      // returns last-result reg (10.0f from DAT)

    return w->vtable->InqJumpVelocity(extent, ...);         // 304980
}
```

`InqJumpVelocity` is the per-character jump-skill curve. Returns
the actual launch v_z in m/s (e.g. extent=1.0 with jump-skill 300
→ ~7.8 m/s peak from PlayerWeenie).

---

## 13. `CMotionInterp::get_leave_ground_velocity` — full launch vector

**Address:** `0x005280c0` (line 305404)

```
005280c0  void CMotionInterp::get_leave_ground_velocity(
              CMotionInterp* this, Vector3* arg2)
{
    CMotionInterp::get_state_velocity(this, arg2);          // 305408 — XY (body-local)
    arg2->z = CMotionInterp::get_jump_v_z(this);            // 305409+305411

    // If all three components are |x| < 0.0002 (near-zero):
    if (|arg2->x| < eps && |arg2->y| < eps && |arg2->z| < eps)
    {
        // Project current world velocity into body-local frame via the
        // transposed orientation matrix m_fl2gv.
        // (lines 305434-305440)
        arg2->x = m_fl2gv[0]*velX + m_fl2gv[1]*velY + m_fl2gv[2]*velZ;
        arg2->y = m_fl2gv[3]*velX + m_fl2gv[4]*velY + m_fl2gv[5]*velZ;
        arg2->z = m_fl2gv[6]*velX + m_fl2gv[7]*velY + m_fl2gv[8]*velZ;
    }
}
```

The fast-path is the common case: `get_state_velocity` writes (X=strafe,
Y=forward, Z=0); then we overwrite Z with v_z. The fallback only fires
when state-velocity AND jump_v_z are all near zero (e.g. zero-extent
jump while standing still); it preserves residual world velocity.

---

## 14. `CMotionInterp::jump_is_allowed`

**Address:** `0x005282b0` (line 305509)

```
005282b0  uint32_t CMotionInterp::jump_is_allowed(
              CMotionInterp* this, float arg2, int32_t* arg3)
{
    CPhysicsObj* po = this->physics_obj;
    if (po == 0) return 0x24;                               // (no obj) GeneralFail

    // Creature path:
    CWeenieObject* w = this->weenie_obj;
    bool wIsCreature = w ? w->vtable->IsCreature() : true;
    if (w != 0 && !wIsCreature)
    {
        // Non-creature — always allowed-ish, fall through to weenie checks.
        goto label_5282f6;
    }

    // Creature: require Gravity flag set AND grounded (Contact + OnWalkable).
    if ((po->state & 4) == 0) return 0x24;                  // 305561 — no gravity, can't jump
    uint8_t ts = po->transient_state;
    if (!((ts & 0x1) && (ts & 0x2))) return 0x24;           // 305566 — not grounded → 0x24

label_5282f6:
    if (CPhysicsObj::IsFullyConstrained(po)) return 0x47;   // 305524

    // Pending-queue check.
    LListData* head = this->pending_motions.head_;
    uint32_t pendingErr = head ? head->jumpErr : 0;
    if (head == 0 || pendingErr == 0)
    {
        pendingErr = CMotionInterp::jump_charge_is_allowed(this);
        if (pendingErr == 0)
        {
            uint32_t mErr = CMotionInterp::motion_allows_jump(this,
                            this->interpreted_state.forward_command);
            if (mErr != 0) return mErr;
            if (this->weenie_obj == 0) return mErr;        // 0
            // Stamina cost check.
            if (w->vtable->JumpStaminaCost(arg2, arg3) != 0)
                return 0;
            return 0x47;                                    // not enough stamina
        }
    }
    return pendingErr;
}
```

Error codes:
- `0x00` = success
- `0x24` = `CantJumpInAir` / general motion failure
- `0x47` = `CantJumpFromPosition` (constrained, weenie-blocked, or stamina)
- `0x48` = `CantJumpFromMotion` (motion command blocks jump — emote, etc.)
- `0x49` = weenie-blocked (load-down)

---

## 15. `CMotionInterp::contact_allows_move`

**Address:** `0x00528240` (line 305471)

```
00528240  int32_t CMotionInterp::contact_allows_move(
              CMotionInterp const* this, uint32_t arg2)
{
    if (this->physics_obj == 0) return 0;
    // Always allow these "anchor" commands regardless of grounding:
    if (arg2 == 0x40000015 || arg2 == 0x40000011) return 1;  // (305481-482)
    if (arg2 >= 0x6500000d && arg2 <= 0x6500000e) return 1;  // (305478) — sidestep cmds
    // Non-creature → allow.
    CWeenieObject* w = this->weenie_obj;
    if (w != 0 && !w->vtable->IsCreature()) return 1;        // (305490)
    // No gravity → allow.
    if ((this->physics_obj->state & 4) == 0) return 1;       // (305495)
    // Grounded (Contact + OnWalkable) → allow.
    uint8_t ts = this->physics_obj->transient_state;
    if ((ts & 0x1) && (ts & 0x2)) return 1;                  // (305500)
    return 0;
}
```

This is the per-command grounding check. Walk/run only succeed when
grounded; emotes/sidesteps always succeed.

---

## 16. `CPhysicsObj::calc_acceleration` — gravity application

**Address:** `0x00510950` (line 278533)

```
00510950  void CPhysicsObj::calc_acceleration(CPhysicsObj* this)
{
    uint8_t ts = this->transient_state;
    // Grounded: zero accel (and zero omega). Tests Contact && OnWalkable
    // && (state & "Hooked-from-floor" bit). Real semantics: grounded creature
    // gets no gravity acceleration.
    if ((ts & 1) && (ts & 2) && (this->state & 0x???) == 0)
    {
        accel = (0, 0, 0);
        omega = (0, 0, 0);
        return;
    }
    // Gravity flag NOT set: zero accel.
    if ((this->state & 4) == 0)              // line 278549 — Gravity bit (state & 4)
    {
        accel = (0, 0, 0);
        return;
    }
    // Airborne with gravity: apply downward gravity.
    accel = (0, 0, PhysicsGlobals::gravity);  // line 278559 (gravity = -9.8 m/s²)
}
```

So the **state.Gravity bit (0x4)** is what enables gravity application
in retail. It's set when the creature enters the world and stays set;
it does NOT need to be re-set on each jump. Acdream's `OnLiveVectorUpdated`
explicitly setting `State |= Gravity` is defensive — if your remote-tracking
code preserved the bit from the moment the body was created, this would
be a no-op.

---

## 17. State writes during a complete jump arc — answers to the brief

| Phase | What happens | Who writes what |
|---|---|---|
| **Pre-jump** | Standing, OnWalkable=1, Contact=1, Gravity=set, vel=0 | initial state |
| **Player jump start** | `MotionInterp::jump(extent)` succeeds | `jump_extent = extent`; `set_on_walkable(0)` (clears OnWalkable=2 bit) |
| ↳ via set_on_walkable | edge 1→0 fires `MovementManager::LeaveGround` | TransientState OnWalkable bit cleared; calc_acceleration recalcs (now (0,0,-9.8) since !grounded) |
| ↳ via LeaveGround | computes launch vector | `set_local_velocity(leaveVel)` → `set_velocity(worldVel)` writes m_velocityVector + sets Active + sets `jumped_this_frame=1`; clears `jump_extent=0` |
| **Per-tick airborne** | UpdateObjectInternal | reads m_velocityVector, integrates pos += vel·dt + ½·accel·dt²; vel.Z += accel.Z·dt |
| **Mid-arc** | sphere-sweep finds no walkable plane | OnWalkable stays 0 |
| **Server VectorUpdate** | `0xF74E` arrives | Only `m_velocityVector` + `m_omegaVector` overwritten. Contact/OnWalkable/Gravity untouched. |
| **Landing (sweep finds floor)** | `set_frame` block 283474-283509 reclassifies contact_plane | If N.z ≥ floor_z: `set_on_walkable(true)` |
| ↳ edge 0→1 | fires `MovementManager::HitGround` | TransientState OnWalkable bit set; calc_acceleration → (0,0,0); HitGround calls RemoveLinkAnimations + apply_current_movement (which re-poses + writes new ground velocity via get_state_velocity → set_local_velocity) |

**Mid-arc UPs from server:** retail does NOT have a separate "snap" or
"integrate" path. A server PortalCellUpdate (0xF748) during flight will
just write the new position via `CPhysicsObj::SetPositionInternal` (same
sequence-gate logic in `CObjectMaint::QueuePortalCellUpdate`), and the
sphere-sweep that next tick decides if landing happened. The arc is
purely client-integrated; server position events override it
authoritatively when they arrive.

**Cycle transition Falling → Ready/Walk/Run on landing:** retail does NOT
explicitly transition. `HitGround` calls `apply_current_movement` which
re-pushes the existing `interpreted_state.forward_command`. If the player
is still holding W, that's RunForward, and the cycle naturally reverts.
The Falling animation is layered as a link-animation that
`RemoveLinkAnimations` clears at HitGround. (acdream's
`SetCycle(landingCmd)` in GameWindow.cs:3487 is a more explicit
re-pose; equivalent effect.)

---

## 18. Cross-check vs acdream

| acdream method | retail counterpart | Match? |
|---|---|---|
| `MotionInterpreter.jump` (line 691) | `CMotionInterp::jump` 0x00528780 | ✅ matches: jump_is_allowed, JumpExtent, set_on_walkable(false) |
| `MotionInterpreter.get_jump_v_z` (722) | 0x00527aa0 | ✅ matches: epsilon gate, clamp, weenie call |
| `MotionInterpreter.get_leave_ground_velocity` (759) | 0x005280c0 | ✅ matches incl. fallback projection |
| `MotionInterpreter.LeaveGround` (901) | 0x00528b00 | ✅ matches order (vel-before-extent-reset) |
| `MotionInterpreter.HitGround` (924) | 0x00528ac0 | ✅ matches |
| `MotionInterpreter.jump_is_allowed` | 0x005282b0 | ✅ matches |
| `MotionInterpreter.contact_allows_move` | 0x00528240 | ✅ matches |
| `PhysicsBody.set_velocity` (206) | 0x005113f0 | ⚠️ **MISSING `jumped_this_frame = 1`** + missing transient_state.Active gate on `state & 1` (Static) |
| `PhysicsBody.set_local_velocity` (236) | 0x005114d0 | ✅ matches (Quaternion equivalent of matrix multiply) |
| `GameWindow.OnLiveVectorUpdated` (3246) | `SmartBox::DoVectorUpdate` 0x004521c0 | ⚠️ **acdream sets Gravity / clears Contact+OnWalkable; retail does NOT.** Acdream's behavior is defensive; retail relies on the bits already being correct from launch. |

### Issues / divergences worth filing

1. **`PhysicsBody.set_velocity` is missing `jumped_this_frame = 1`.**
   Without this flag the next-tick collision sweep clamps the +Z
   velocity to zero before gravity can lift the body. Effective bug:
   first-frame after launch the body may be re-clamped to floor.
   Acdream may be papering over this elsewhere (e.g. by deferring
   sweep until N+2) — worth verifying whether per-tick code reads a
   `JumpedThisFrame` member.

2. **Acdream `OnLiveVectorUpdated` extra writes vs retail.** Acdream
   sets `State |= Gravity` and clears Contact+OnWalkable when v.Z>0.5.
   Retail's `SmartBox::DoVectorUpdate` does only set_velocity + set_omega.
   The reason acdream needs the extra writes is that acdream's per-tick
   integrator gates gravity on `!OnWalkable` instead of `state & Gravity`.
   If we ported `calc_acceleration` faithfully (state.Gravity bit set
   at body creation, persists across jumps), the OnLiveVectorUpdated
   bit-setting would become unnecessary.

3. **K-fix15 question (airborne + IsOnGround + Velocity.Z<=0):** retail's
   landing detection has nothing to do with Velocity.Z. It uses the
   sphere-sweep's contact plane (per `CPhysicsObj::set_frame`
   collision_info path) and compares `contact_plane.N.z` against
   `floor_z`. Acdream's velocity-Z-based landing heuristic in
   `OnLivePositionUpdated` is a pragmatic shortcut (we don't have a
   full sphere-sweep on remotes), but is materially divergent from
   retail. Long-term, when remote sphere-sweep lands, swap to the
   N.z gate.

---

## File written

`docs/research/2026-05-04-l3-port/10-vector-update-jump.md`
