45 lines
1.8 KiB
Markdown
45 lines
1.8 KiB
Markdown
# Step 08 — Resolve (move _to_ the wall, not through it)
|
|
|
|
Detection is done. Now for **response** — actually reacting to the hit. This
|
|
first half is almost embarrassingly small, but it introduces the idea the whole
|
|
loop (step 10) is built on: **the frame isn't all-or-nothing.**
|
|
|
|
## Concept
|
|
|
|
`sweptAABB` hands you a `Hit` with a `time` between 0 and 1 — the fraction of
|
|
the frame at which you'd collide. So instead of moving the full displacement `v`
|
|
(which would bury you inside the wall), you move only the part of it that
|
|
happens _before_ impact:
|
|
|
|
```
|
|
no hit → newPos = pos + v (nothing in the way: take the whole move)
|
|
hit at t → newPos = pos + v * t (stop exactly at the contact point)
|
|
```
|
|
|
|
That's it — you already have `add` and `scale`; this is them, gated on the hit.
|
|
|
|
### The leftover that matters
|
|
|
|
Here's the seed for step 10: if you hit at `t = 0.3`, you only used **30%** of
|
|
this frame. The other **70%** is still owed to the player — they should keep
|
|
moving for the rest of the frame, just not _into_ the wall. That leftover time
|
|
is exactly why sliding (step 09) and the loop (step 10) exist. A collision
|
|
doesn't end the frame; it **interrupts** it.
|
|
|
|
> Real-engine footnote: production code usually moves to `t - EPSILON` (a hair
|
|
> _short_ of contact) so floating-point error can't leave the box a sliver
|
|
> inside the wall, where the next frame's sweep would start already-overlapping.
|
|
> Your `nage` does this with `Math.max(0, time - EPSILON)`. We keep the kata
|
|
> exact so the numbers stay clean — just know that tiny backoff is there for a
|
|
> real reason.
|
|
|
|
## Task
|
|
|
|
Implement `resolve(pos, v, hit)` in `resolve.ts`: return the full move when
|
|
`hit` is `null`, otherwise the position at contact. `vec/add/scale` and the
|
|
`Hit` type are in `given.ts`.
|
|
|
|
```sh
|
|
bun test workshop/steps/08-resolve
|
|
```
|