Initial commit
This commit is contained in:
ryanfitzpatrickio
@@ -0,0 +1,4 @@
|
||||
node_modules/
|
||||
dist/
|
||||
shots/
|
||||
.DS_Store
|
||||
Generated
+10
@@ -0,0 +1,10 @@
|
||||
# Default ignored files
|
||||
/shelf/
|
||||
/workspace.xml
|
||||
# Editor-based HTTP Client requests
|
||||
/httpRequests/
|
||||
# Ignored default folder with query files
|
||||
/queries/
|
||||
# Datasource local storage ignored files
|
||||
/dataSources/
|
||||
/dataSources.local.xml
|
||||
Generated
+8
@@ -0,0 +1,8 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="ProjectModuleManager">
|
||||
<modules>
|
||||
<module fileurl="file://$PROJECT_DIR$/.idea/tilt.iml" filepath="$PROJECT_DIR$/.idea/tilt.iml" />
|
||||
</modules>
|
||||
</component>
|
||||
</project>
|
||||
Generated
+8
@@ -0,0 +1,8 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<module type="WEB_MODULE" version="4">
|
||||
<component name="NewModuleRootManager">
|
||||
<content url="file://$MODULE_DIR$" />
|
||||
<orderEntry type="inheritedJdk" />
|
||||
<orderEntry type="sourceFolder" forTests="false" />
|
||||
</component>
|
||||
</module>
|
||||
@@ -0,0 +1,501 @@
|
||||
# tilt
|
||||
|
||||
Physics-driven hockey. Three.js for rendering, Box3D (wasm) for physics, with
|
||||
the character stack lifted from [Ludus](../ludus).
|
||||
|
||||
## Where it's at
|
||||
|
||||
Two teams of three chase a puck around a rink, under AI or on an Xbox pad,
|
||||
hitting each other and each other's sticks. No nets, no goalies, no rules.
|
||||
|
||||
- **Spike 1** — skating, the rink, physical presence, collision response.
|
||||
- **Spike 1.5** — a controller, so the feel can be judged by hand.
|
||||
- **Spike 2** — body checks: limb-level impacts, skeleton impulses, knockdowns
|
||||
and getting back up.
|
||||
- **Spike 3** — the Xbox layer (Skill Stick, analog triggers, rumble) and the
|
||||
puck: stick, possession, shooting, passing, poke checks.
|
||||
- **Spike 4** — the stick socketed to the hand, and animations for everything
|
||||
the controls can do: carry, hustle, wind-up, shot, pass, poke.
|
||||
- **Spike 5 (MVP)** — nets, a goalie, and a working **shootout**: alternating
|
||||
attempts, goal detection, a scoreboard, and bots that shoot.
|
||||
|
||||
```bash
|
||||
npm install
|
||||
npm run dev # http://localhost:5174
|
||||
npm test # headless: sim, rink, AI, pose, input, physics, hits
|
||||
npm run capture # boots the app headless and screenshots it into shots/
|
||||
```
|
||||
|
||||
In the browser:
|
||||
|
||||
| Xbox | keyboard | |
|
||||
|------|----------|-----|
|
||||
| — | **P** / Tab | take control of the skater the camera is on, or hand back |
|
||||
| **left stick** | **WASD** | skate (relative to the camera, not to the skater) |
|
||||
| **RT** | Shift | hustle — analog, so half-throttle is a real thing |
|
||||
| **LT** | Space | hockey stop |
|
||||
| **right stick** | arrows | Skill Stick: stickhandle, and pull back + push to shoot |
|
||||
| **A** | J | pass to the nearest teammate |
|
||||
| **X** | K | shoot |
|
||||
| **B** | L | poke check |
|
||||
| — | **C** | cycle broadcast → follow each of the six skaters → broadcast |
|
||||
| — | **R** | faceoff: reset everyone and the puck |
|
||||
| — | **[** **]** | tune puck magnetism live (see below) |
|
||||
| drag / wheel | | orbit / zoom |
|
||||
|
||||
Whichever input was touched last wins, so a pad can be picked up mid-game. The
|
||||
pad also rumbles on any hit you are part of, harder when you are the one
|
||||
taking it.
|
||||
|
||||
`window.tilt` exposes the match, camera, input and physics world for poking at
|
||||
from the console.
|
||||
|
||||
`npm run capture` writes `lineup`, `broadcast`, `follow`, `closeup` and `side`
|
||||
into `shots/`, and fails on any console error — which makes it the quickest
|
||||
check that a change did not break the render path.
|
||||
|
||||
### What it does
|
||||
|
||||
- NHL-dimension rink (200 × 85 ft, 28 ft corners) with the boards as static
|
||||
Box3D bodies and markings baked into one canvas texture.
|
||||
- Six skaters — two teams of three, starting in a faceoff lineup in their own
|
||||
halves — built from Ludus's 23-bone skeleton, procedural lofted body meshes
|
||||
and distance-field skinning, each with the full 18-capsule / 17-joint ragdoll
|
||||
attached and kinematically driven.
|
||||
- Skating locomotion with real momentum: you carve, you glide, and you cannot
|
||||
turn on a rail at full speed.
|
||||
- Waypoint AI with separation and board avoidance.
|
||||
- Board contact and skater-on-skater contact solved by Box3D and fed back into
|
||||
the sim as momentum.
|
||||
- Body checks that vary with the pose: shoulder, hip, body, arm or leg, graded
|
||||
from a bump through a stagger to a knockdown, with the victim's ragdoll going
|
||||
dynamic, taking the impulse, hitting the ice and getting back up.
|
||||
- A regulation puck (76 mm, 170 g) as a continuous-collision cylinder, sticks
|
||||
with kinematic blade colliders, and a possession model on a runtime dial.
|
||||
- Shooting with wind-up power off the Skill Stick, passing, poke checks, and
|
||||
contact knocking the puck off whoever is carrying it.
|
||||
|
||||
Roster size is a parameter, not a constant: `createMatch({ perTeam, teams })`,
|
||||
and the lineup, collision layers and tests all follow from it. 5-on-5 works
|
||||
today — it just has nothing to play for yet.
|
||||
|
||||
## The one idea worth knowing
|
||||
|
||||
Everything else follows from how skating is modelled. A runner's velocity
|
||||
points where they push, so friction is isotropic and stopping is nearly
|
||||
instant. A skate glides almost freely along its own length and bites hard
|
||||
across it. So movement is two separate things:
|
||||
|
||||
1. **The carve.** Each step, the momentum vector is rotated toward the blade
|
||||
line at `edgeGrip`. It is a *rotation*, not lateral friction, so turning
|
||||
redirects speed rather than destroying it — which is why a skater leans into
|
||||
a turn and comes out of it somewhere they were not pointing. A hard carve
|
||||
costs a little (`carveScrub`); a lazy one is nearly free.
|
||||
2. **Speed along that line**, which the stride adds to and a small drag
|
||||
removes.
|
||||
|
||||
That is `shared/skaterSim.js`. It is pure numbers with no three.js import, and
|
||||
it is where the feel lives. Current tuning: 7.4 m/s flat out, ~13% of speed
|
||||
lost per second of glide, a hockey stop inside a second from full speed.
|
||||
|
||||
## Layout
|
||||
|
||||
```
|
||||
shared/ pure sim — no three.js, node-testable, server-ready
|
||||
rink.js rink geometry, containment, the board outline
|
||||
skaterSim.js intent → velocity. the carve, the stride, the drag
|
||||
ai.js waypoint brains and steering
|
||||
scalar.js angle and scalar helpers
|
||||
src/
|
||||
core/ math + seeded rng (from Ludus, unchanged)
|
||||
character/
|
||||
skeleton.js 23 bones (from Ludus, unchanged)
|
||||
body.js procedural lofted body (from Ludus, unchanged)
|
||||
skinning.js distance-field weights (from Ludus, unchanged)
|
||||
skater.js assembly: mesh + kit + ragdoll + proxy + stick + animator
|
||||
skaterGear.js helmet, pads, jersey, pants, socks, skates, gloves
|
||||
stick.js stick mesh and the kinematic blade collider
|
||||
goalie.js assembly: mesh + gear + pad/body colliders + animator
|
||||
goalieGear.js pads, mask, trapper, blocker, chest, paddle
|
||||
gearMesh.js loft / carved-shell / swept-bar builders for gear
|
||||
physics/
|
||||
bridge.js three ↔ Box3D types, collision layers
|
||||
ragdoll.js 18 capsules, 17 joints (from Ludus, filters retargeted)
|
||||
world.js rink world: ice + boards
|
||||
bodyProxy.js the one dynamic capsule per skater
|
||||
puck.js the one body that genuinely needs continuous collision
|
||||
anim/
|
||||
skateAnimator.js pose buffer, state crossfade, two-bone leg IK
|
||||
poses/skate.js the numbers: stance, lean, arm carry, hockey stop
|
||||
goalieAnimator.js stance selection, leg IK onto the ice, paddle grip
|
||||
poses/goalie.js ready, butterfly, shuffle, reach
|
||||
studio/
|
||||
img2mesh.js character studio: pose presets, fixed views, capture API
|
||||
render/ rink, materials, camera
|
||||
game/
|
||||
match.js the loop
|
||||
input.js Xbox pad + keyboard, Skill Stick, camera-relative stick
|
||||
hits.js severity, limb resolution, impulses
|
||||
possession.js who has the puck, and the magnetism dial
|
||||
tools/
|
||||
capture.mjs headless boot, viewport assertions, screenshots
|
||||
hitprobe.mjs fire skaters at each other and print what lands
|
||||
img2mesh.mjs shot sheet of player + goalie for gear iteration
|
||||
```
|
||||
|
||||
### Two deliberate departures from Ludus
|
||||
|
||||
**The animator does not own movement.** In Ludus the animator integrates the
|
||||
fighter's position. Here the sim and the Box3D proxy own it and the animator is
|
||||
*told* where the body ended up. Anything else has the pose fighting the
|
||||
collision response.
|
||||
|
||||
**The feet are not planted in world space.** A walking foot is stationary while
|
||||
it bears weight; a skate is gliding the entire time, including through the
|
||||
push. Foot targets are authored in mover-local space and scaled by stride
|
||||
amplitude, so a glide collapses them to a pair of blades sitting under the hips
|
||||
with no separate "glide" pose to keep in sync. Planting them is exactly what
|
||||
would have made this read as running on ice.
|
||||
|
||||
## Why there is a proxy capsule
|
||||
|
||||
The ragdoll is kinematic while a skater is on their feet, and kinematic bodies
|
||||
do not respond to each other — two rigs driven through one another generate
|
||||
contacts and resolve none of them. So physical presence lives in one dynamic
|
||||
capsule per skater, and the ragdoll rides on top as the visible, hittable
|
||||
skeleton.
|
||||
|
||||
The loop per substep is read → step → write: pull position and velocity out of
|
||||
Box3D, let the skating sim edit that velocity, write it back, solve. Reading
|
||||
velocity back rather than only writing it is the point — a board hit or a
|
||||
shoulder arrives as a change to `vx/vz` that the sim carries forward as
|
||||
momentum.
|
||||
|
||||
The sim runs *inside* the substep loop rather than once per frame, because
|
||||
momentum only survives a collision if the thing that resolved it and the thing
|
||||
that integrates motion agree about the timestep.
|
||||
|
||||
**When a skater goes down, the two swap jobs.** The ragdoll goes dynamic and
|
||||
becomes the body, and the proxy is *disabled* — not merely ignored, because a
|
||||
body left enabled still occupies space and would leave an invisible upright
|
||||
bollard on the ice where the skater used to be. Getting up reverses it: read
|
||||
where the pelvis actually ended up, put the proxy there, move the sim to match,
|
||||
hand the skeleton back to the animator and crossfade out of the collapsed pose.
|
||||
That round trip is the seam with nowhere to hide, so most of `test/hits.mjs` is
|
||||
about it.
|
||||
|
||||
### Getting up without teleporting
|
||||
|
||||
The reverse handoff is the fiddly half, and the naive version has a specific,
|
||||
very visible failure: the skater flies out by however far they slid, then snaps
|
||||
back over the crossfade.
|
||||
|
||||
The cause is that while limp the ragdoll writes the body's displacement into the
|
||||
**root bone**, because the mover has been parked where they fell for the whole
|
||||
knockdown. The world pose is `moverAtFallPosition x bigRootOffset`. Teleporting
|
||||
the mover onto the pelvis without touching that offset applies the displacement
|
||||
a second time, and the crossfade then drags it back as the root decays to its
|
||||
skating value.
|
||||
|
||||
So `getUp` re-expresses the root in the new mover frame — `inverse(newMover) x
|
||||
oldRootWorld` — making the world pose across the handoff bit-for-bit identical.
|
||||
The crossfade then has no position to undo and only interpolates lying to
|
||||
skating. Measured across a 4.25 m slide: every bone moves **1-3 mm** at the
|
||||
handoff, and the pelvis drifts **under 10 cm** over the entire get-up.
|
||||
|
||||
Three smaller things fall out of the same fix. Facing is taken from the
|
||||
pelvis-to-chest line flattened onto the ice, because the pelvis' own forward
|
||||
axis points at the floor on someone lying face-down. The foot IK targets are
|
||||
re-read from where the blades actually are, or the legs drag across the rink to
|
||||
catch up with a stale target. And intent is suppressed while rising, so they
|
||||
stand up where they lay instead of skating off mid-animation.
|
||||
|
||||
## How a hit knows what kind of hit it is
|
||||
|
||||
Two questions, and conflating them is what makes hits feel like one canned
|
||||
event.
|
||||
|
||||
***Did* a hit land** is a physics question, answered by the proxy capsules —
|
||||
they are what actually collide. Closing speed and mass give severity.
|
||||
|
||||
***What kind* of hit was it** is a pose question, and the proxy cannot answer
|
||||
it: a capsule contact tells you two bodies met at roughly hip height, not that
|
||||
a shoulder went through a chest. So on the frame of impact we go back to the
|
||||
two 18-capsule ragdolls, which *are* posed, and find the closest pair of limbs.
|
||||
That pair is the hit — `spine3 → pelvis` is a shoulder into the body, `pelvis →
|
||||
thighL` is a hip check, and a shoulder arriving at a head is the one that should
|
||||
draw a penalty. 324 segment-segment tests, only on the frame something lands.
|
||||
|
||||
This comes out genuinely varied because it follows the skating pose rather than
|
||||
a dice roll: running down a stationary skater leads with the shoulder, while a
|
||||
head-on between two skaters both crouched low at speed is a hip check.
|
||||
|
||||
Two things that had to be got right, both found by looking at the output:
|
||||
|
||||
- **Nobody checks with their head.** A skater at speed is pitched ~30° forward,
|
||||
which makes the head the leading part of the body *geometrically*, so an
|
||||
unrestricted search credited almost every hit to a headbutt. Only shoulders,
|
||||
chest, hips and thighs can deliver. The victim side stays unrestricted, so
|
||||
head shots still register.
|
||||
- **A check drives you down and back, not over the hitter.** Putting the whole
|
||||
impulse at the contact point — which sits well above the centre of mass —
|
||||
is mostly torque, and cartwheeled the victim over the attacker's head. Most
|
||||
of it now goes through the pelvis centre, with a third at the contact point
|
||||
to shape the fall.
|
||||
|
||||
## Possession is a dial, not a decision
|
||||
|
||||
This is the one genuinely open design question in the game, so it is built as a
|
||||
dial rather than as an answer. `magnetism` runs 0..1 between the two models
|
||||
every hockey game has to choose between:
|
||||
|
||||
- **0 — pure physics.** The puck is always a free rigid body and the only thing
|
||||
that moves it is the blade collider pushing it. Authentic, and skittery to the
|
||||
point of being unplayable.
|
||||
- **1 — hard attach.** The puck is placed at the carry point every frame.
|
||||
Totally controllable, looks glued, and kills the scrambles that are the reason
|
||||
to build a physics-driven hockey game at all.
|
||||
|
||||
In between, the puck's velocity is blended toward whatever would carry it to the
|
||||
stick, so it mostly follows but can be jostled off the blade. It sits at **0.72**
|
||||
today, which is a guess, not a finding — press `[` and `]` while playing and
|
||||
find the real answer by hand.
|
||||
|
||||
### Two things the puck taught us immediately
|
||||
|
||||
**A carrier with nothing to fear is untouchable.** The first minute of 3-on-3
|
||||
with a puck produced *one* possession change and *one* hit: a skater picked it
|
||||
up and kept it for the entire minute while five others followed them around.
|
||||
Possession only becomes a contest once losing it is possible, so contact now
|
||||
knocks the puck loose (a stagger is enough — it does not need a knockdown) and
|
||||
there is a poke check that both the player and the bots use.
|
||||
|
||||
**Everyone chasing looks like a bug.** With all six converging on the puck the
|
||||
hit system fired constantly — 28 hits a minute — but the game was one moving
|
||||
scrum with nobody anywhere else on the ice. Only the nearest skater per side
|
||||
chases now; the rest find space. Contact drops to a believable handful a minute
|
||||
and the mean separation goes from a huddle to 7.7 m.
|
||||
|
||||
| | everyone chases | nearest chases |
|
||||
|---|---|---|
|
||||
| hits / min | 28 | 4 |
|
||||
| possession changes / min | 35 | 13 |
|
||||
| mean separation | huddle | 7.7 m |
|
||||
|
||||
## The stick is held, and the puck follows it
|
||||
|
||||
The first pass hung the stick off the mover and positioned it so the blade sat
|
||||
wherever the puck was being carried. That put the blade in the right place and
|
||||
the hands nowhere near it — the stick floated.
|
||||
|
||||
It is now parented to a socket on the right hand, authored in *grip space*: the
|
||||
origin is the top hand, the shaft runs down −Y, the blade is at the far end. The
|
||||
hands carry the stick, which is the correct dependency order.
|
||||
|
||||
**That inverts the puck relationship.** `possession` no longer picks a carry
|
||||
point and drags the stick to it; it reads where the blade actually is and
|
||||
carries the puck there. Stickhandling became an arm pose plus a blade target,
|
||||
which is what it is in real life, and the puck can no longer be somewhere the
|
||||
stick is not.
|
||||
|
||||
### Aimed, not bolted
|
||||
|
||||
The obvious authoring — a fixed socket rotation per stance — does not survive an
|
||||
animated arm. That rotation composes with the hand's own world rotation, so a
|
||||
grip tuned to put the blade on the ice for one arm pose swings it into the air
|
||||
in another, and every stride is a different arm pose. Measured before the fix:
|
||||
the blade sat between **0.55 m and 0.97 m** off the ice depending on gait.
|
||||
|
||||
So a stance is a blade *target* plus a roll, and the stick aims itself:
|
||||
|
||||
- **Height is solved exactly**, direction is aimed. Pointing straight at the
|
||||
target and hoping the length works out puts the blade short of an on-ice
|
||||
target, which means *above* it. Solving `dy` from the height difference makes
|
||||
blade height exact for any arm pose and any stick length.
|
||||
- **The aimed axis is grip-to-blade, not the shaft's −Y.** The blade sits
|
||||
forward of the shaft end by the toe offset, ~6° off axis; aiming −Y left the
|
||||
blade 10 cm above where the height solve said it would be.
|
||||
|
||||
Blade height is now 0.03 m across every skating stance, and 0.62 m drawn back on
|
||||
a wind-up. There is a pose test for exactly that.
|
||||
|
||||
### Animations
|
||||
|
||||
`poses/stickwork.js` authors carry, wind-up, shot, pass and poke as *override
|
||||
layers*, not states — you keep skating while you shoot, and a shot that stopped
|
||||
the legs would read as a cutscene. Arms are replaced; the spine is *multiplied*,
|
||||
because it is already carrying the skating lean and the bank, and overwriting it
|
||||
stood everybody upright the moment they picked up a stick.
|
||||
|
||||
Hustle is a continuous parameter rather than an action: as the throttle goes
|
||||
down the stick eases out in front and the left hand comes off it, so half a
|
||||
trigger is half a dangle. A wind-up is *held* for as long as the Skill Stick is
|
||||
pulled back; shot, pass and poke run once and blend out.
|
||||
|
||||
## The shootout
|
||||
|
||||
The MVP: one shooter, one goalie, one puck, and a result. Attempts alternate, so
|
||||
it is two players trading chances rather than a drill. **P** takes the shooter
|
||||
(control follows whoever is up), **R** restarts.
|
||||
|
||||
The puck starts on the dot at centre ice and the shooter a few metres back, so
|
||||
picking it up is part of the attempt — that is the only moment the carry model
|
||||
has to prove it can *gain* possession rather than keep it, and starting glued to
|
||||
the puck skipped it. Losing the handle mid-attempt does not end anything either;
|
||||
in a one-on-one the puck getting away from you is part of the rush. Only a goal,
|
||||
the goalie covering it, the puck leaving the picture, or the clock finishes an
|
||||
attempt.
|
||||
|
||||
A goalie is deliberately *not* a skater. The skating sim is a carve model —
|
||||
momentum dragged onto a blade line — and a goalie almost never carves. Reusing
|
||||
it would mean fighting the locomotion for every metre. So it is a purpose-built
|
||||
entity that plays the angle: stand on the line between puck and net, a set depth
|
||||
out, with a lateral speed limit and a reaction lag. The lag is what makes them
|
||||
beatable; a goalie always exactly on the angle is a wall, not a goalie.
|
||||
|
||||
**Saves are physics, not a dice roll.** The pads and body are kinematic
|
||||
colliders and the puck is a bullet. A shot either hits a pad or it does not.
|
||||
There is no save percentage anywhere.
|
||||
|
||||
### Four bugs it took to get the first goal
|
||||
|
||||
The first build produced **0 goals from 30 attempts**, and each fix revealed the
|
||||
next. Worth recording because every one of them looked like a goalie problem:
|
||||
|
||||
1. **The net was backwards.** For the +X end the back panel was placed at
|
||||
`line − depth`, a metre *in front* of the goal line — a solid wall across the
|
||||
mouth. Every shot in the game bounced off it before it could cross.
|
||||
2. **Both clamps in `goalieSpot` were inverted.** Between them they teleported
|
||||
the goalie onto the puck and then pinned them to the goal line, throwing away
|
||||
all the angle the depth was there to buy.
|
||||
3. **A redundant "fumble" check stripped the puck off every shooter.** It was a
|
||||
function of stiffness and magnetism, and after stiffness went up it fired
|
||||
*tighter* than the break radius it was backing up — twenty of twenty-four
|
||||
attempts ended with nobody ever shooting.
|
||||
4. **Shots were hitting the shooter's own stick.** The puck sits exactly on the
|
||||
blade — that is what carrying means — and the follow-through then swept that
|
||||
kinematic collider through the same point. Shots stopped six metres short or
|
||||
flew twelve wide. The puck is now stepped clear of the blade on release.
|
||||
|
||||
Plus two tuning errors worth naming: bots aimed at the *centre* of the net,
|
||||
which is where the goalie stands by construction; and shot spread was 0.22 rad
|
||||
at 8 m — ±1.76 m of scatter against a net 1.83 m wide.
|
||||
|
||||
Currently around **15 goals per 29 attempts**. That is a number to tune, not a
|
||||
finding — real NHL shootouts convert about a third. It jumped from 7-in-31 the
|
||||
moment shooters started skating onto the puck instead of spawning on it, because
|
||||
they now carry real speed into the shot.
|
||||
|
||||
### Bots can shoot now
|
||||
|
||||
`handleShooting` used to sit behind `if (control)`, so only a human could ever
|
||||
shoot — a bot picked the puck up and carried it until somebody took it away, and
|
||||
a minute of play produced zero shots. They now pick a corner, alternate sides,
|
||||
and their accuracy falls off with range.
|
||||
|
||||
## Performance
|
||||
|
||||
Simulation, physics and animation, excluding rendering:
|
||||
|
||||
| roster | skaters | ms/frame |
|
||||
|--------|---------|----------|
|
||||
| 3-on-3 | 6 | 0.24 |
|
||||
| 5-on-5 | 10 | 0.38 |
|
||||
|
||||
A full 5-on-5 plus goalies is well inside a 60 Hz budget with the render cost
|
||||
still to come. (`npm run capture` reports 20–30 fps, but that is SwiftShader
|
||||
software rasterisation in a headless browser, not a real GPU.)
|
||||
|
||||
## Tests
|
||||
|
||||
1171 checks, all headless, `npm test`:
|
||||
|
||||
- **skaterSim** — top speed, acceleration curve, glide decay, braking, the
|
||||
carve preserving momentum, resistance to instant reversal, determinism, and
|
||||
the `applyIntent` seam surviving garbage input.
|
||||
- **rink** — containment maths including the corner arcs, which a plain
|
||||
rectangle test gets wrong.
|
||||
- **ai** — a 3-on-3 for a simulated minute: nobody leaves the ice, nobody
|
||||
stands inside anybody, waypoints actually get reached, and the lineup puts
|
||||
each team in its own half with index order matching team order. Also a
|
||||
5-on-5, as the cheapest check that steering does not fall over with a full
|
||||
side on the ice.
|
||||
- **pose** — the animator, driven headlessly: no NaN, blades on the ice, torso
|
||||
angle, arm carry, elbow bend, bank into a turn, the stop pose. This is the
|
||||
only way "the skater looks wrong" gets caught by anything but a human
|
||||
squinting at a screenshot.
|
||||
- **input** — camera-relative steering. Its own file because the failure is
|
||||
silent and infuriating: a sign flip means the stick works from one camera
|
||||
angle and inverts from another, which reads as a physics bug. Checks that
|
||||
forward is always away from the camera, that the four directions stay square,
|
||||
that "right" is the camera's right and not its left, and end to end that
|
||||
holding forward from any camera angle and any starting facing puts the skater
|
||||
where the stick pointed.
|
||||
- **physics** — the Box3D claims: boards hold at full speed including in the
|
||||
corner seams, contact costs speed, two skaters cannot occupy the same ice, a
|
||||
bump transfers momentum, the ragdoll follows the skeleton, and a six-body
|
||||
pile-up at centre ice resolves without anyone escaping or interpenetrating.
|
||||
|
||||
- **hits** — the handoff, mostly. A knockdown must disable the proxy, leave the
|
||||
frozen sim position where it is rather than skating a disabled capsule around
|
||||
the rink, move the sim to wherever the body actually slid to on the way up,
|
||||
and restore the collision filter. Plus the things that were wrong when first
|
||||
looked at: nobody delivers a check with their head, a knockdown never lifts
|
||||
the hips above standing height, the victim carries on down the ice rather
|
||||
than bouncing back, a longer run-up hits harder, and more than one kind of
|
||||
check is reachable.
|
||||
|
||||
The render path is covered separately by `npm run capture`, which boots the app
|
||||
headless **at DPR 2** and asserts the canvas fills the window at two sizes. That
|
||||
check exists because it didn't: running captures at DPR 1 hid a canvas-sizing
|
||||
bug that made the element twice the window on any retina display.
|
||||
|
||||
## Not built yet
|
||||
|
||||
Full roadmap, ordered by difficulty: **[ROADMAP.md](ROADMAP.md)**.
|
||||
|
||||
Nets, goalies, scoring, offside/icing, penalties, faceoffs, gear textures,
|
||||
netplay.
|
||||
|
||||
## Where the next spike plugs in
|
||||
|
||||
**Nets and scoring.** It is the shortest path from "physics demo you can play"
|
||||
to "game you can win". Two static goal frames with a trigger volume behind the
|
||||
line, a whistle, and a faceoff reset — `match.reset()` already puts the puck at
|
||||
centre ice and stands everybody up. Everything needed to detect a goal exists;
|
||||
the puck is a real body with a real position.
|
||||
|
||||
Then, roughly in order of how much they would improve the thing:
|
||||
|
||||
- **Goalies** — a seventh skater per side with a different brain and a bigger
|
||||
collider. No new systems.
|
||||
- **Arm IK onto the stick.** The stick is positioned from the carry point and
|
||||
the arms do not yet reach for it. `solveGrabArm` in the Ludus animator is
|
||||
exactly this problem, already solved, and can be ported.
|
||||
- **Penalties.** Hits already carry `headshot`, `blindside`, the delivering part
|
||||
and the struck region, so boarding, charging and elbowing have the data they
|
||||
need without any new detection.
|
||||
- **Positional AI.** The brains know four states — carrying, chasing,
|
||||
supporting, defending — and pick between them off one nearest-to-puck test.
|
||||
Real forechecking and zone coverage is the next big behavioural step.
|
||||
- **Netplay.** `shared/` is still pure, deterministic and three.js-free, and
|
||||
`applyIntent` is a clamped entry point that never trusts what it is given.
|
||||
|
||||
### Three soft spots worth knowing
|
||||
|
||||
**The lower hand does not quite reach the shaft.** The left arm is 0.55 m and
|
||||
the natural two-handed grip point is ~1 m from the left shoulder on this
|
||||
skeleton, so the IK grips the nearest *reachable* point and still ends about
|
||||
0.25 m short. It reads as reaching for the stick rather than holding it. Fixing
|
||||
it properly means either a longer reach from a shoulder/spine contribution or
|
||||
accepting a higher grip; both are pose work, not architecture.
|
||||
|
||||
**Staggers are still visually unverified.** Knockdowns were tested hard — peak
|
||||
hip height, direction of travel, the full proxy/ragdoll handoff, and that
|
||||
nothing jumps on the way back up. The stagger path (physics deflecting the pose
|
||||
while animation shows through) is only asserted to *enter* the right state. It
|
||||
is far more common in play than a knockdown.
|
||||
|
||||
**Possession changes may be too frequent.** Around sixteen a minute in a 3-on-3
|
||||
with no zones, no goalies and no reason to hold position is plausible but
|
||||
untuned. It will want revisiting once there is a net to protect.
|
||||
+190
@@ -0,0 +1,190 @@
|
||||
# Roadmap
|
||||
|
||||
Where tilt is, and what parity with NHL 26 would actually take.
|
||||
|
||||
Worth stating the scale honestly up front: NHL 26 is ~30 years of iteration by a
|
||||
studio of hundreds, plus licensing. Full parity isn't a backlog, it's a company.
|
||||
This document is the real shape of the gap, ordered by difficulty, with notes on
|
||||
where the current architecture helps and where it will fight us.
|
||||
|
||||
---
|
||||
|
||||
## Built
|
||||
|
||||
- **Skating** — carve/glide momentum model. Blade line, edge grip, stride,
|
||||
hockey stop. 7.4 m/s flat out.
|
||||
- **Rink** — NHL dimensions, boards as static bodies, markings, corner arcs.
|
||||
- **Bodies** — 23-bone skeleton, procedural lofted meshes, distance-field
|
||||
skinning, 18-capsule / 17-joint ragdoll, dynamic proxy capsule per skater.
|
||||
- **Hits** — limb-level resolution from the posed ragdolls (shoulder / hip /
|
||||
body / arm / leg), graded bump → stagger → knockdown, skeleton impulses,
|
||||
knockdown and a seamless get-up.
|
||||
- **Puck** — regulation cylinder, continuous collision, boards and corners hold
|
||||
at 55 m/s.
|
||||
- **Stick** — socketed to the hand, aimed per stance, kinematic blade collider.
|
||||
- **Possession** — magnetism dial (runtime tunable), capture, carry, shot, pass,
|
||||
poke check, contact knocking the puck loose.
|
||||
- **Controls** — Xbox pad with Skill Stick (pull back / push to shoot), analog
|
||||
triggers, rumble; keyboard fallback.
|
||||
- **AI** — puck chasing, designated chaser per side, support positioning, bots
|
||||
that shoot and pass.
|
||||
- **Shootout** — nets, goalie, alternating attempts, goal detection, scoreboard.
|
||||
|
||||
**1171 headless checks.** `npm test`, `npm run capture`.
|
||||
|
||||
---
|
||||
|
||||
## Tier 1 — the genuinely hard ones
|
||||
|
||||
### Goalies (beyond the shootout MVP)
|
||||
The shootout goalie plays the angle with a reaction lag and stops pucks with
|
||||
kinematic colliders. That is enough for a shootout and nowhere near enough for
|
||||
a game.
|
||||
|
||||
A real goalie is a separate locomotion model (shuffles, t-pushes, butterfly,
|
||||
RVH, post integration), a separate animation set (glove, blocker, pad stacks,
|
||||
desperation saves), save *selection* that has to feel fair rather than optimal,
|
||||
and rebound control that decides on its own whether the game is fun.
|
||||
|
||||
**Have:** angle positioning, lag, physics saves.
|
||||
**Why hard:** the system EA still gets criticised for annually.
|
||||
|
||||
### Animation volume and quality
|
||||
The largest body of work in the project by an order of magnitude.
|
||||
|
||||
NHL runs thousands of mocap clips through motion matching. We run procedural
|
||||
poses, which got further than expected — the stride, the carve lean, the
|
||||
limb-level hits all read correctly — but it has a ceiling and broadcast hockey
|
||||
is above it. Parity means mocap plus a clip/motion-matching system, or a hybrid
|
||||
where procedural drives locomotion and clips drive everything contextual.
|
||||
|
||||
**Have:** pose-buffer + crossfade + IK + override-layer architecture a clip
|
||||
system can plug into.
|
||||
**Why hard:** content volume. Cannot be engineered around.
|
||||
|
||||
### AI that plays hockey
|
||||
Forechecking systems, D-zone coverage, breakouts, cycling, gap control, reading
|
||||
the play, line changes. Genuine multi-agent planning under adversarial pressure.
|
||||
|
||||
**Have:** four states (carry / chase / support / defend) off one nearest-to-puck
|
||||
test, and a clean intent seam anything smarter writes into.
|
||||
|
||||
### Netcode
|
||||
12 skaters, 2 goalies, a puck, sticks, plus lag compensation for hits and shots.
|
||||
|
||||
**Have:** better odds than most — `shared/` is pure, deterministic and
|
||||
three.js-free by design, and `applyIntent` is a clamped entry point that never
|
||||
trusts input.
|
||||
**Why hard:** Box3D and the ragdoll layer are *not* obviously deterministic
|
||||
across machines. **Prove that before anything else** — it gates netcode and
|
||||
replays, and finding out late would be very expensive.
|
||||
|
||||
### Possession feel
|
||||
The `magnetism` dial is at 0.72, which is a guess. Not analytically solvable —
|
||||
only iteration with real players answers it. It is what NHL retunes every year
|
||||
and still gets complaints about.
|
||||
|
||||
### Full-fidelity interaction at scale
|
||||
Stick-on-stick, stick lifts, puck off skates and shin pads and glass, board
|
||||
battles with three bodies pinned to the wall, all stable at 60 Hz.
|
||||
|
||||
**Have:** one blade collider and skater proxies. The 0.53 m proxy-equilibrium
|
||||
noted in the README gets worse with pile-ups.
|
||||
|
||||
### Presentation
|
||||
Broadcast camera direction, replays, commentary, crowd, arena atmosphere,
|
||||
celebrations, likenesses. Nearly all production, not engineering.
|
||||
|
||||
### Modes: Franchise, Be A Pro, HUT, World of Chel
|
||||
By content volume, arguably most of an NHL release. Contracts, scouting, drafts,
|
||||
trades, progression, card economy, matchmaking, live service.
|
||||
|
||||
### Licensing
|
||||
NHL/NHLPA teams, players, arenas, logos, music. Not engineering, but parity is
|
||||
impossible without it.
|
||||
|
||||
---
|
||||
|
||||
## Tier 2 — medium
|
||||
|
||||
| | Notes |
|
||||
|---|---|
|
||||
| Full game mode | Periods, clock, faceoffs after whistles, line changes. |
|
||||
| Rules: offside, icing | Detection is straightforward; edge cases are the work. |
|
||||
| Penalties | Hits already carry `headshot`, `blindside`, delivering part and struck region — boarding/charging/elbowing have the data. |
|
||||
| Faceoffs | Mechanic + animation. The lineup spawn already exists. |
|
||||
| Line changes / bench | Roster is already a parameter. |
|
||||
| Full 5-on-5 | Runs today at 0.38 ms/frame; needs positional AI to mean anything. |
|
||||
| Shot variety | Wrist, snap, slap, backhand, one-timers, deflections, tips. |
|
||||
| Dekes, dangles, toe drags | Skill Stick gesture layer exists; these are new gestures + poses. |
|
||||
| Board play / puck battles | Likely needs possession *reworked*, not extended. |
|
||||
| Stick-on-stick, stick lifts | New collider pairs and filter work. |
|
||||
| **Fighting** | Self-contained minigame — and **Ludus already has a full one**. Highest value-per-effort item on this list. |
|
||||
| Injuries / fatigue / momentum | Ragdoll and hit severity already feed it. |
|
||||
| Puck physics polish | Deflections, glass, puck on edge, knuckling. |
|
||||
| Camera systems | Several presets; we have two. |
|
||||
| Audio | Skate cuts, puck-on-stick, boards, crowd, goal horn. Currently **silent**. |
|
||||
| Replays | Cheap given a deterministic sim — record inputs, re-simulate. |
|
||||
| Difficulty sliders | Needs AI worth tuning first. |
|
||||
| Menus, profiles, settings, save | Conventional. |
|
||||
|
||||
---
|
||||
|
||||
## Tier 3 — small
|
||||
|
||||
Hours to days each.
|
||||
|
||||
### Owed / immediate
|
||||
- **Pad parity.** `P` (take shooter), `R` (restart) and `C` (camera) are
|
||||
keyboard-only, so you cannot play a shootout with a controller alone.
|
||||
`LB` (switch), `Y` (dump) and `START` are read and discarded. ~20 lines.
|
||||
- **Goalie animation depth.** Goalie is now a skinned skeleton with pads,
|
||||
trapper, blocker, mask and paddle, plus ready / shuffle / butterfly / reach
|
||||
stances. Still owed: RVH, post-integration, glove *saves* as events, and
|
||||
rebound control that is more than the pad restitution.
|
||||
- **Goal feedback.** A goal is a line of HUD text. No horn, no camera cut, no
|
||||
celebration. Cheap, disproportionate effect.
|
||||
- **Tune the shootout conversion rate.** 15-in-29 (~52%) against a real ~33%.
|
||||
Dials: `GOALIE.depth`, `GOALIE.lag`, `GOALIE.speed`, `SHOT_RANGE` and shot
|
||||
spread. Needs hands on a pad, not test output.
|
||||
|
||||
### Controls / possession
|
||||
- `LT` puck protection — the analog value is computed and discarded.
|
||||
- `RB` deke modifier.
|
||||
- Bot stickhandling (`possession.handling` is human-only; bots leave it at 0).
|
||||
- Forehand / backhand blade roll.
|
||||
- Contested capture instead of nearest-index-wins.
|
||||
|
||||
### Polish
|
||||
- Ice spray, skate trails, snow.
|
||||
- Jersey numbers and names.
|
||||
- Scoreboard, clock, period structure.
|
||||
- Basic stat tracking.
|
||||
|
||||
---
|
||||
|
||||
## Known soft spots
|
||||
|
||||
- **Lower hand does not quite reach the shaft** (~0.25 m short). The left arm is
|
||||
0.55 m and the natural grip point is ~1 m from the left shoulder on this
|
||||
skeleton, so the IK grips the nearest reachable point. Pose work, not
|
||||
architecture.
|
||||
- **Staggers are visually unverified.** Knockdowns were tested hard; the stagger
|
||||
path is only asserted to *enter* the right state, and it is far more common in
|
||||
play.
|
||||
- **Proxy interpenetration** under sustained pressure — two skaters at full
|
||||
sprint settle 0.53 m apart against 0.72 m of capsule. Documented in the README;
|
||||
gets worse in pile-ups.
|
||||
- **Shootout conversion is untuned** at ~52%.
|
||||
|
||||
---
|
||||
|
||||
## Suggested order
|
||||
|
||||
1. **Play the shootout and tune the conversion rate.** Cannot be done from here.
|
||||
2. Pad parity — small, owed, and it is what makes the MVP couch-playable.
|
||||
3. Goalie animation and goal feedback — biggest read-improvement per hour.
|
||||
4. **Prove Box3D determinism.** Cheap now, gates netcode and replays, expensive
|
||||
to discover late.
|
||||
5. Port the Ludus fighting system — highest value-per-effort in Tier 2, and the
|
||||
code already exists.
|
||||
@@ -0,0 +1,76 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no,viewport-fit=cover">
|
||||
<title>tilt — img2mesh</title>
|
||||
<link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'><text y='13' font-size='13'>🎯</text></svg>">
|
||||
<style>
|
||||
html, body { margin:0; padding:0; height:100%; overflow:hidden; background:#0a0e14;
|
||||
font-family:'SF Mono', ui-monospace, Menlo, monospace;
|
||||
touch-action:none; overscroll-behavior:none; -webkit-user-select:none; user-select:none;
|
||||
-webkit-tap-highlight-color:transparent; }
|
||||
#stage { position:absolute; inset:0; width:100%; height:100%; display:block; touch-action:none; }
|
||||
#hud { position:absolute; left:14px; top:12px; color:#8fb4d4; font-size:12px;
|
||||
line-height:1.55; white-space:pre; pointer-events:none; text-shadow:0 1px 2px #000; }
|
||||
#boot { position:absolute; inset:0; display:flex; align-items:center; justify-content:center;
|
||||
color:#6ea8dc; letter-spacing:4px; font-size:13px; background:#0a0e14; z-index:10; }
|
||||
#panel { position:absolute; right:12px; top:12px; width:220px; color:#b8d4ea; font-size:11px;
|
||||
line-height:1.45; background:rgba(8,12,18,0.72); border:1px solid #1e3348; border-radius:8px;
|
||||
padding:10px 12px; pointer-events:auto; backdrop-filter:blur(6px); }
|
||||
#panel h1 { margin:0 0 8px; font-size:11px; letter-spacing:2px; color:#6ea8dc; font-weight:600; }
|
||||
#panel label { display:block; margin:6px 0 2px; color:#6a8aa8; }
|
||||
#panel select, #panel button {
|
||||
width:100%; box-sizing:border-box; background:#0f1822; color:#d4e8f8;
|
||||
border:1px solid #2a4a66; border-radius:4px; padding:5px 7px; font:inherit; margin-bottom:4px;
|
||||
}
|
||||
#panel button { cursor:pointer; }
|
||||
#panel button:hover { border-color:#4a8ab8; }
|
||||
#panel .row { display:flex; gap:6px; }
|
||||
#panel .row button { flex:1; }
|
||||
#panel kbd { color:#8fb4d4; }
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<canvas id="stage"></canvas>
|
||||
<div id="hud"></div>
|
||||
<div id="panel">
|
||||
<h1>IMG2MESH</h1>
|
||||
<label>subject</label>
|
||||
<select id="subject">
|
||||
<option value="player">player</option>
|
||||
<option value="goalie">goalie</option>
|
||||
<option value="both">both</option>
|
||||
</select>
|
||||
<label>pose</label>
|
||||
<select id="pose"></select>
|
||||
<label>view</label>
|
||||
<select id="view">
|
||||
<option value="front">front</option>
|
||||
<option value="threequarter">3/4</option>
|
||||
<option value="side">side</option>
|
||||
<option value="back">back</option>
|
||||
<option value="top">top</option>
|
||||
<option value="closeup">closeup</option>
|
||||
<option value="gear">gear detail</option>
|
||||
</select>
|
||||
<div class="row" style="margin-top:8px">
|
||||
<button id="prevPose" type="button">◀ pose</button>
|
||||
<button id="nextPose" type="button">pose ▶</button>
|
||||
</div>
|
||||
<div class="row">
|
||||
<button id="prevView" type="button">◀ view</button>
|
||||
<button id="nextView" type="button">view ▶</button>
|
||||
</div>
|
||||
<button id="cycle" type="button" style="margin-top:6px">cycle all shots</button>
|
||||
<div style="margin-top:10px;color:#6a8aa8">
|
||||
drag orbit · wheel zoom<br>
|
||||
<kbd>1</kbd> player <kbd>2</kbd> goalie <kbd>3</kbd> both<br>
|
||||
<kbd>[</kbd><kbd>]</kbd> pose · <kbd>,</kbd><kbd>.</kbd> view<br>
|
||||
<kbd>g</kbd> gear bones · <kbd>b</kbd> bones
|
||||
</div>
|
||||
</div>
|
||||
<div id="boot">IMG2MESH…</div>
|
||||
<script type="module" src="/src/studio/img2mesh.js"></script>
|
||||
</body>
|
||||
</html>
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no,viewport-fit=cover">
|
||||
<title>tilt — spike 1</title>
|
||||
<link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'><text y='13' font-size='13'>🏒</text></svg>">
|
||||
<style>
|
||||
html, body { margin:0; padding:0; height:100%; overflow:hidden; background:#0a0e14;
|
||||
font-family:'SF Mono', ui-monospace, Menlo, monospace;
|
||||
/* A thumb on the canvas orbits the camera — it must never scroll or zoom
|
||||
the page, or fire pull-to-refresh instead. */
|
||||
touch-action:none; overscroll-behavior:none; -webkit-user-select:none; user-select:none;
|
||||
-webkit-tap-highlight-color:transparent; }
|
||||
/* width/height are not redundant with inset:0. A canvas is a replaced
|
||||
element, so `width:auto` resolves to its intrinsic (drawing buffer) size
|
||||
rather than stretching between left and right — which at DPR 2 makes the
|
||||
element twice the window. three.js sets these inline too; this is the
|
||||
safety net if that ever regresses. */
|
||||
#stage { position:absolute; inset:0; width:100%; height:100%; display:block; touch-action:none; }
|
||||
#hud { position:absolute; left:14px; top:12px; color:#8fb4d4; font-size:12px;
|
||||
line-height:1.5; white-space:pre; pointer-events:none; text-shadow:0 1px 2px #000; }
|
||||
#boot { position:absolute; inset:0; display:flex; align-items:center; justify-content:center;
|
||||
color:#6ea8dc; letter-spacing:5px; font-size:13px; background:#0a0e14; z-index:10; }
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<canvas id="stage"></canvas>
|
||||
<div id="hud"></div>
|
||||
<div id="boot">TILT…</div>
|
||||
<script type="module" src="/src/main.js"></script>
|
||||
</body>
|
||||
</html>
|
||||
Generated
+1259
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,25 @@
|
||||
{
|
||||
"name": "tilt",
|
||||
"version": "0.0.1",
|
||||
"private": true,
|
||||
"type": "module",
|
||||
"description": "Physics-driven hockey. Spike 1: three agents skating on ice.",
|
||||
"scripts": {
|
||||
"dev": "vite",
|
||||
"build": "vite build",
|
||||
"preview": "vite preview",
|
||||
"test": "node test/skaterSim.mjs && node test/rink.mjs && node test/ai.mjs && node test/pose.mjs && node test/input.mjs && node test/physics.mjs && node test/hits.mjs && node test/puck.mjs && node test/goalie.mjs && node test/shootout.mjs",
|
||||
"capture": "node tools/capture.mjs",
|
||||
"img2mesh": "node tools/img2mesh.mjs",
|
||||
"img2mesh:player": "node tools/img2mesh.mjs --subject player",
|
||||
"img2mesh:goalie": "node tools/img2mesh.mjs --subject goalie"
|
||||
},
|
||||
"dependencies": {
|
||||
"box3d.js": "^0.0.2",
|
||||
"three": "^0.185.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
"puppeteer-core": "^25.4.0",
|
||||
"vite": "^8.1.5"
|
||||
}
|
||||
}
|
||||
+199
@@ -0,0 +1,199 @@
|
||||
import { RINK, randomIcePoint, rinkPenetration } from './rink.js';
|
||||
import { SKATE, speedOf } from './skaterSim.js';
|
||||
import { clamp } from './scalar.js';
|
||||
|
||||
/**
|
||||
* Waypoint AI.
|
||||
*
|
||||
* Deliberately dumb: pick a spot, steer at it, get out of everyone's way.
|
||||
* It exists to exercise the locomotion — the interesting question for this
|
||||
* spike is whether the *skating* reads, and a bot that just holds a direction
|
||||
* answers that better than one making tactical decisions.
|
||||
*
|
||||
* Everything is produced as a steering *intent*, never as a position fix, so
|
||||
* when a real controller or a puck-chasing brain replaces this the movement
|
||||
* layer underneath does not change at all.
|
||||
*/
|
||||
|
||||
const AI = {
|
||||
/** Considered arrived inside this radius. */
|
||||
arriveR: 2.6,
|
||||
/** New waypoints are at least this far away, so bots commit to a line. */
|
||||
minTravel: 9,
|
||||
/** Repath anyway after this long, in case a waypoint became unreachable. */
|
||||
patience: 9,
|
||||
/** Start avoiding another skater inside this range. */
|
||||
personalSpace: 3.4,
|
||||
/** Weight of the avoidance push relative to the waypoint pull. */
|
||||
avoidGain: 1.5,
|
||||
/** Much weaker while racing for a puck — you contest it, you don't yield. */
|
||||
avoidChasing: 0.25,
|
||||
/** Seconds of velocity looked ahead when checking for boards. */
|
||||
boardLookahead: 0.9,
|
||||
/** Steer away once the lookahead point is within this of the boards. */
|
||||
boardMargin: 2.2,
|
||||
boardGain: 2.2,
|
||||
/** Slow down for the last stretch so they don't overshoot every waypoint. */
|
||||
easeR: 6,
|
||||
};
|
||||
|
||||
export function createBrain(rand, opts = {}) {
|
||||
return {
|
||||
rand,
|
||||
target: null,
|
||||
age: 0,
|
||||
/** Personality: some bots cruise, some chase every waypoint flat out. */
|
||||
eagerness: opts.eagerness ?? (0.35 + rand() * 0.6),
|
||||
/** Small heading wobble so three bots on the same errand don't lockstep. */
|
||||
wobblePhase: rand() * Math.PI * 2,
|
||||
wobbleRate: 0.5 + rand() * 0.7,
|
||||
};
|
||||
}
|
||||
|
||||
function pickWaypoint(brain, from) {
|
||||
for (let i = 0; i < 12; i++) {
|
||||
const p = randomIcePoint(brain.rand, 3.5);
|
||||
if (Math.hypot(p.x - from.x, p.z - from.z) >= AI.minTravel) return p;
|
||||
}
|
||||
return randomIcePoint(brain.rand, 3.5);
|
||||
}
|
||||
|
||||
/**
|
||||
* Produce this frame's intent for one skater.
|
||||
*
|
||||
* @param {object} brain from createBrain
|
||||
* @param {object} s skater state (mutated: ix, iz, sprint)
|
||||
* @param {object[]} others other skater states to keep clear of
|
||||
* @param {number} dt
|
||||
*/
|
||||
export function steer(brain, s, others, dt, play = null) {
|
||||
brain.age += dt;
|
||||
|
||||
// ---- what am I doing --------------------------------------------------
|
||||
// With a puck on the ice there is something to want. Without one this falls
|
||||
// back to wandering, which is what spike 1 did and is still what happens
|
||||
// between whistles.
|
||||
if (play?.puck) {
|
||||
const mine = play.carrier === s.id;
|
||||
const teammateHas = play.carrier != null && play.carrierTeam === s.team && !mine;
|
||||
// Only the closest skater on each side actually goes for it. Letting all
|
||||
// six chase does produce contact, but it also produces a single moving
|
||||
// scrum with nobody anywhere else on the ice, which reads as a bug rather
|
||||
// than as hockey.
|
||||
const chaser = play.chaser?.[s.team] === s.id;
|
||||
if (mine) {
|
||||
// Carrying: head for open ice up the attacking end.
|
||||
const attackX = s.team === 0 ? RINK.halfX * 0.7 : -RINK.halfX * 0.7;
|
||||
brain.target = { x: attackX, z: clamp(play.puck.z * 0.6, -RINK.halfZ * 0.6, RINK.halfZ * 0.6) };
|
||||
brain.age = 0;
|
||||
} else if (chaser) {
|
||||
// Go and get it. This is what makes contact happen on its own.
|
||||
brain.target = { x: play.puck.x, z: play.puck.z };
|
||||
brain.age = 0;
|
||||
} else {
|
||||
// Everyone else finds space: ahead of the puck when their side has it,
|
||||
// between the puck and their own end when it does not.
|
||||
const dir = s.team === 0 ? 1 : -1;
|
||||
const depth = teammateHas ? RINK.halfX * 0.42 : -RINK.halfX * 0.18;
|
||||
const side = s.id % 2 === 0 ? 1 : -1;
|
||||
brain.target = {
|
||||
x: clamp(play.puck.x + dir * depth, -RINK.halfX * 0.85, RINK.halfX * 0.85),
|
||||
z: clamp(play.puck.z + side * RINK.halfZ * 0.55, -RINK.halfZ * 0.8, RINK.halfZ * 0.8),
|
||||
};
|
||||
brain.age = 0;
|
||||
}
|
||||
}
|
||||
|
||||
const reached = brain.target
|
||||
&& Math.hypot(brain.target.x - s.x, brain.target.z - s.z) < AI.arriveR;
|
||||
if (!brain.target || (reached && !play?.puck) || brain.age > AI.patience) {
|
||||
brain.target = pickWaypoint(brain, s);
|
||||
brain.age = 0;
|
||||
}
|
||||
|
||||
// ---- pull toward the waypoint ------------------------------------------
|
||||
let dx = brain.target.x - s.x;
|
||||
let dz = brain.target.z - s.z;
|
||||
const dist = Math.hypot(dx, dz) || 1e-6;
|
||||
dx /= dist;
|
||||
dz /= dist;
|
||||
|
||||
// ---- push away from other skaters --------------------------------------
|
||||
// Box3D resolves the actual bump; this only stops the bots from queueing up
|
||||
// to walk through each other, which looks like a bug even when it isn't.
|
||||
//
|
||||
// Chasing a loose puck is the exception, and an important one: at full
|
||||
// avoidance six skaters converging on the same puck politely peel off before
|
||||
// they ever touch, and the entire hit system never fires in normal play.
|
||||
// Competing for a puck means being willing to skate into somebody.
|
||||
const avoid = play?.puck && play.chaser?.[s.team] === s.id ? AI.avoidChasing : AI.avoidGain;
|
||||
for (const o of others) {
|
||||
if (o === s) continue;
|
||||
const ox = s.x - o.x;
|
||||
const oz = s.z - o.z;
|
||||
const d = Math.hypot(ox, oz);
|
||||
if (d >= AI.personalSpace || d < 1e-4) continue;
|
||||
const w = (1 - d / AI.personalSpace) * avoid;
|
||||
dx += (ox / d) * w;
|
||||
dz += (oz / d) * w;
|
||||
}
|
||||
|
||||
// ---- push away from the boards -----------------------------------------
|
||||
// Checked against where they will be, not where they are: on ice, noticing
|
||||
// the boards at arm's length is already too late.
|
||||
const ahead = AI.boardLookahead;
|
||||
const pen = rinkPenetration(s.x + s.vx * ahead, s.z + s.vz * ahead, SKATE.radius);
|
||||
if (pen.dist > -AI.boardMargin) {
|
||||
const w = clamp((pen.dist + AI.boardMargin) / AI.boardMargin, 0, 1) * AI.boardGain;
|
||||
dx += pen.nx * w;
|
||||
dz += pen.nz * w;
|
||||
}
|
||||
|
||||
// ---- wobble + normalise -------------------------------------------------
|
||||
brain.wobblePhase += brain.wobbleRate * dt;
|
||||
const wob = Math.sin(brain.wobblePhase) * 0.12;
|
||||
const len = Math.hypot(dx, dz) || 1e-6;
|
||||
const yaw = Math.atan2(dx / len, dz / len) + wob;
|
||||
s.ix = Math.sin(yaw);
|
||||
s.iz = Math.cos(yaw);
|
||||
|
||||
// Ease off approaching the waypoint, and only sprint on the long straights.
|
||||
// Chasing a puck is the exception: you do not coast in on a loose puck, you
|
||||
// get there first, so the ease and the arrival brake are both dropped.
|
||||
const chasing = !!play?.puck && play.chaser?.[s.team] === s.id;
|
||||
const ease = chasing ? 1 : clamp(dist / AI.easeR, 0.25, 1);
|
||||
s.ix *= ease;
|
||||
s.iz *= ease;
|
||||
s.sprint = chasing ? dist > 2 : (dist > AI.easeR * 1.5 && brain.eagerness > 0.5);
|
||||
// Hard stop rather than a lazy drift when arriving hot.
|
||||
s.brake = !chasing && dist < AI.arriveR * 1.4 && speedOf(s) > 4.5;
|
||||
}
|
||||
|
||||
/**
|
||||
* Starting lineup: each team in its own half, everyone facing centre ice.
|
||||
*
|
||||
* Laid out like a faceoff rather than scattered at random, because that is the
|
||||
* arrangement every later spike starts from — drop a puck at centre and this is
|
||||
* already the right picture. Ordered team by team, so index `i` belongs to
|
||||
* team `Math.floor(i / perTeam)` and the returned `team` field agrees.
|
||||
*
|
||||
* The depth pattern is one skater up, the rest spread behind: with three a side
|
||||
* that reads as a forward and two defenders without encoding any positional
|
||||
* rules the game does not have yet.
|
||||
*/
|
||||
export function spawnLineup(perTeam = 3, teams = 2) {
|
||||
const out = [];
|
||||
for (let t = 0; t < teams; t++) {
|
||||
// Team 0 defends the -X end, team 1 the +X end.
|
||||
const sign = t === 0 ? -1 : 1;
|
||||
for (let i = 0; i < perTeam; i++) {
|
||||
const lead = i === 0;
|
||||
const x = sign * (lead ? RINK.halfX * 0.18 : RINK.halfX * 0.42);
|
||||
// Fan the back line across the width; a single one sits on the centre.
|
||||
const back = perTeam > 1 ? (i - 1) / Math.max(1, perTeam - 2) : 0.5;
|
||||
const z = lead ? 0 : (back * 2 - 1) * RINK.halfZ * 0.55;
|
||||
out.push({ x, z, yaw: Math.atan2(-x, -z), team: t });
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
@@ -0,0 +1,165 @@
|
||||
/**
|
||||
* Body style — three appearance sliders inspired by dreamfall simhuman
|
||||
* global morphs (mass / muscle / fat).
|
||||
*
|
||||
* Plain numbers only: Party, C path, and client mesh build all share this.
|
||||
* Ranges match vibe-human MODELING_CONTROLS for body.global.*:
|
||||
* mass −1 lean … +1 heavy
|
||||
* muscle −1 soft … +1 muscular
|
||||
* fat 0 base … +1 fat (no negative target in the reference)
|
||||
*/
|
||||
|
||||
export const BODY_STYLE_DEFAULTS = Object.freeze({
|
||||
mass: 0,
|
||||
muscle: 0,
|
||||
fat: 0,
|
||||
});
|
||||
|
||||
/** Slider metadata for the kit chest UI. */
|
||||
export const BODY_STYLE_SLIDERS = Object.freeze([
|
||||
{
|
||||
id: 'mass',
|
||||
label: 'Mass',
|
||||
min: -1,
|
||||
max: 1,
|
||||
step: 0.01,
|
||||
left: 'Lean',
|
||||
right: 'Heavy',
|
||||
},
|
||||
{
|
||||
id: 'muscle',
|
||||
label: 'Muscle',
|
||||
min: -1,
|
||||
max: 1,
|
||||
step: 0.01,
|
||||
left: 'Soft',
|
||||
right: 'Muscular',
|
||||
},
|
||||
{
|
||||
id: 'fat',
|
||||
label: 'Fat',
|
||||
min: 0,
|
||||
max: 1,
|
||||
step: 0.01,
|
||||
left: 'Base',
|
||||
right: 'Heavy',
|
||||
},
|
||||
]);
|
||||
|
||||
function clamp(v, lo, hi) {
|
||||
const n = Number(v);
|
||||
if (!Number.isFinite(n)) return lo;
|
||||
return Math.max(lo, Math.min(hi, n));
|
||||
}
|
||||
|
||||
/**
|
||||
* Normalize a partial body bag. Missing keys become 0 (average build).
|
||||
* @param {unknown} raw
|
||||
* @returns {{ mass: number, muscle: number, fat: number }}
|
||||
*/
|
||||
export function normalizeBodyStyle(raw) {
|
||||
if (!raw || typeof raw !== 'object') {
|
||||
return { ...BODY_STYLE_DEFAULTS };
|
||||
}
|
||||
return {
|
||||
mass: clamp(raw.mass, -1, 1),
|
||||
muscle: clamp(raw.muscle, -1, 1),
|
||||
fat: clamp(raw.fat, 0, 1),
|
||||
};
|
||||
}
|
||||
|
||||
/** True when every channel is at the neutral default. */
|
||||
export function isDefaultBodyStyle(style) {
|
||||
const s = normalizeBodyStyle(style);
|
||||
return s.mass === 0 && s.muscle === 0 && s.fat === 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compact wire form for full-roster snapshots (two decimals).
|
||||
* @returns {{ m: number, u: number, f: number }}
|
||||
*/
|
||||
export function packBodyStyle(style) {
|
||||
const s = normalizeBodyStyle(style);
|
||||
return {
|
||||
m: Math.round(s.mass * 100) / 100,
|
||||
u: Math.round(s.muscle * 100) / 100,
|
||||
f: Math.round(s.fat * 100) / 100,
|
||||
};
|
||||
}
|
||||
|
||||
/** Inverse of packBodyStyle — also accepts full { mass, muscle, fat }. */
|
||||
export function unpackBodyStyle(raw) {
|
||||
if (!raw || typeof raw !== 'object') return normalizeBodyStyle(null);
|
||||
if ('mass' in raw || 'muscle' in raw || 'fat' in raw) {
|
||||
return normalizeBodyStyle(raw);
|
||||
}
|
||||
return normalizeBodyStyle({
|
||||
mass: raw.m,
|
||||
muscle: raw.u,
|
||||
fat: raw.f,
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Ease unit strength so mid-slider stays mild and the last third punches
|
||||
* harder into caricature (leaner / bulkier / more cut / fatter).
|
||||
* @param {number} t 0..1
|
||||
* @returns {number} 0..1
|
||||
*/
|
||||
function easeExtreme(t) {
|
||||
const a = clamp(t, 0, 1);
|
||||
// ~0.35 at half travel, 1.0 at the end — more of the gain sits near the stop.
|
||||
return a * 0.35 + a * a * 0.25 + a * a * a * 0.4;
|
||||
}
|
||||
|
||||
/** Signed ease: preserves direction, applies easeExtreme on |v|. */
|
||||
function shapedSigned(v) {
|
||||
if (v === 0) return 0;
|
||||
return Math.sign(v) * easeExtreme(Math.abs(v));
|
||||
}
|
||||
|
||||
/**
|
||||
* Map mass/muscle/fat onto the loft physique scalars used by buildBodyGeometry.
|
||||
*
|
||||
* Ends of each slider push hard (ease-in + large peak gains). Mid values stay
|
||||
* readable so average builds do not jump. Seeded rng still adds a small natural
|
||||
* variation so two fighters with the same sliders are not voxel-identical.
|
||||
*
|
||||
* @param {{ mass: number, muscle: number, fat: number }} style
|
||||
* @param {{ range: (a: number, b: number) => number }} rng
|
||||
*/
|
||||
export function physiqueFromBodyStyle(style, rng) {
|
||||
const s = normalizeBodyStyle(style);
|
||||
// Shaped channels: mild near 0, extreme at ±1 / 1.
|
||||
const mass = shapedSigned(s.mass);
|
||||
const muscle = shapedSigned(s.muscle);
|
||||
const fat = easeExtreme(s.fat);
|
||||
|
||||
// Peak gains (at shaped = ±1 / 1) — roughly 2× the first-pass response so
|
||||
// full lean / tank / soft / cut / fat reads clearly under armor.
|
||||
// Overall girth: mass + fat dominate; muscle adds a little.
|
||||
const bulkBase = 1 + mass * 0.32 + fat * 0.26 + muscle * 0.1;
|
||||
// Waist: fat fills hard, muscle nips, mass thickens.
|
||||
const waistBase = 1 + fat * 0.48 + mass * 0.2 - muscle * 0.18;
|
||||
// Shoulders / chest: muscle primary.
|
||||
const shoulderBase = 1 + muscle * 0.42 + mass * 0.16 + fat * 0.1;
|
||||
// Arms: muscle, with a little mass/fat.
|
||||
const armBase = 1 + muscle * 0.48 + mass * 0.14 + fat * 0.12;
|
||||
// Legs: fat + mass, muscle secondary.
|
||||
const legBase = 1 + fat * 0.36 + mass * 0.2 + muscle * 0.16;
|
||||
// Head: slight only — keeps helm fit.
|
||||
const headBase = 1 + mass * 0.06 + fat * 0.05;
|
||||
|
||||
const jitter = (base, lo = 0.97, hi = 1.03) => base * (rng?.range?.(lo, hi) ?? 1);
|
||||
|
||||
return {
|
||||
bulk: jitter(bulkBase),
|
||||
// Lower floors so full lean/soft can actually go thin.
|
||||
waistF: Math.max(0.52, jitter(waistBase, 0.98, 1.02)),
|
||||
shoulderF: Math.max(0.62, jitter(shoulderBase, 0.98, 1.02)),
|
||||
armF: Math.max(0.58, jitter(armBase, 0.97, 1.03)),
|
||||
legF: Math.max(0.6, jitter(legBase, 0.97, 1.03)),
|
||||
headF: Math.max(0.85, jitter(headBase, 0.98, 1.02)),
|
||||
style: s,
|
||||
};
|
||||
}
|
||||
+102
@@ -0,0 +1,102 @@
|
||||
import { MARKINGS, RINK } from './rink.js';
|
||||
|
||||
/**
|
||||
* The net, and what counts as a goal.
|
||||
*
|
||||
* Pure numbers and pure predicates, so the shootout logic and the tests can
|
||||
* agree about scoring without a physics world in the room.
|
||||
*/
|
||||
|
||||
/** Regulation: 6ft wide, 4ft tall, 44in deep. */
|
||||
export const NET = Object.freeze({
|
||||
width: 1.83,
|
||||
height: 1.22,
|
||||
depth: 1.12,
|
||||
postRadius: 0.048,
|
||||
/** Crease: 6ft radius arc off the goal line. */
|
||||
creaseRadius: 1.83,
|
||||
});
|
||||
|
||||
/**
|
||||
* Goal line X for an end. `end` is +1 for the +X end, −1 for −X.
|
||||
* The net's mouth sits *on* this line, opening back toward centre ice.
|
||||
*/
|
||||
export const goalLineX = (end) => end * MARKINGS.goalLine;
|
||||
|
||||
/**
|
||||
* Has the puck fully crossed the line, between the posts and under the bar?
|
||||
*
|
||||
* "Fully" is the rule and it matters: a puck resting on the line is not a goal.
|
||||
* The whole puck has to be past, so the test is against the puck's leading edge
|
||||
* — its centre plus its radius.
|
||||
*/
|
||||
export function isGoal(puck, end, puckRadius = 0.0381) {
|
||||
const line = goalLineX(end);
|
||||
// Leading edge past the line, travelling into the net.
|
||||
const past = end > 0 ? puck.x - puckRadius > line : puck.x + puckRadius < line;
|
||||
if (!past) return false;
|
||||
// ...but not out the back of it.
|
||||
if (Math.abs(puck.x - line) > NET.depth) return false;
|
||||
if (Math.abs(puck.z) > NET.width / 2 - puckRadius) return false;
|
||||
return (puck.y ?? 0) < NET.height;
|
||||
}
|
||||
|
||||
/** True once the puck is behind the goal line but wide or high — a miss. */
|
||||
export function isWide(puck, end, puckRadius = 0.0381) {
|
||||
const line = goalLineX(end);
|
||||
const past = end > 0 ? puck.x - puckRadius > line : puck.x + puckRadius < line;
|
||||
return past && !isGoal(puck, end, puckRadius);
|
||||
}
|
||||
|
||||
/**
|
||||
* Where a goalie should stand, given where the puck is.
|
||||
*
|
||||
* Angle play, which is the whole of goaltending positioning: stand on the line
|
||||
* between the puck and the middle of the net, `depth` metres out from the goal
|
||||
* line. Cover the angle and the shooter has nothing to shoot at; the rest is
|
||||
* reflexes.
|
||||
*
|
||||
* Returns a point, clamped so the goalie never wanders past the posts by more
|
||||
* than a pad's width — a goalie who chases the puck to the corner has left an
|
||||
* open net, which reads as broken rather than as aggressive.
|
||||
*/
|
||||
export function goalieSpot(puck, end, depth = 0.55, out = { x: 0, z: 0 }) {
|
||||
const line = goalLineX(end);
|
||||
// Aim from the middle of the goal mouth toward the puck.
|
||||
const dx = puck.x - line;
|
||||
const dz = puck.z - 0;
|
||||
const len = Math.hypot(dx, dz);
|
||||
if (len < 1e-4) {
|
||||
out.x = line - end * 0.1;
|
||||
out.z = 0;
|
||||
return out;
|
||||
}
|
||||
out.x = line + (dx / len) * depth;
|
||||
out.z = (dz / len) * depth;
|
||||
|
||||
// Two clamps, and *both* were originally the wrong way round — between them
|
||||
// they teleported the goalie onto the puck and then pinned them to the goal
|
||||
// line, which threw away every bit of angle the depth was there to buy.
|
||||
//
|
||||
// "Out" means toward centre ice, which is decreasing x at the +X end. So
|
||||
// coming out past the puck is `out.x < puck.x` there, and going behind the
|
||||
// line is `out.x > line`.
|
||||
if (end > 0 ? out.x < puck.x : out.x > puck.x) out.x = puck.x;
|
||||
if (end > 0 ? out.x > line : out.x < line) out.x = line;
|
||||
// Stay within the posts, plus a little for a pad sticking out.
|
||||
const limit = NET.width / 2 + 0.22;
|
||||
out.z = Math.max(-limit, Math.min(limit, out.z));
|
||||
return out;
|
||||
}
|
||||
|
||||
/** Centre ice, facing the end being shot at — where a shootout attempt starts. */
|
||||
export function shootoutStart(end) {
|
||||
return { x: 0, z: 0, yaw: end > 0 ? Math.PI / 2 : -Math.PI / 2 };
|
||||
}
|
||||
|
||||
/** Is the puck still in a sensible place for a live attempt? */
|
||||
export function attemptLive(puck, end) {
|
||||
if (Math.abs(puck.z) > RINK.halfZ) return false;
|
||||
// Past the goal line at that end, one way or another, ends it.
|
||||
return end > 0 ? puck.x < goalLineX(end) + NET.depth : puck.x > goalLineX(end) - NET.depth;
|
||||
}
|
||||
+159
@@ -0,0 +1,159 @@
|
||||
/**
|
||||
* Rink geometry.
|
||||
*
|
||||
* NHL dimensions in metres, kept as plain numbers with no three.js import so
|
||||
* the sim, the tests and (later) a server can all agree on where the boards
|
||||
* are without pulling in a renderer.
|
||||
*
|
||||
* The surface is a rounded rectangle: a `halfX` by `halfZ` box with the four
|
||||
* corners replaced by quarter circles of radius `cornerR`. Every containment
|
||||
* query in the game reduces to "how far outside that shape are you", so it
|
||||
* lives here once as `rinkPenetration`.
|
||||
*/
|
||||
|
||||
/** 200ft x 85ft, 28ft corner radius, 42in boards. */
|
||||
export const RINK = Object.freeze({
|
||||
halfX: 30.48, // length/2 — the long axis runs along X
|
||||
halfZ: 12.95, // width/2
|
||||
cornerR: 8.53,
|
||||
boardHeight: 1.07,
|
||||
/** Glass above the boards is visual only in this spike. */
|
||||
glassHeight: 1.8,
|
||||
});
|
||||
|
||||
/** Blue lines / centre line, as distances from centre ice along X. */
|
||||
export const MARKINGS = Object.freeze({
|
||||
blueLine: 7.77,
|
||||
goalLine: 25.6,
|
||||
faceoffCircleR: 4.57,
|
||||
centreCircleR: 4.57,
|
||||
faceoffDotX: 6.7,
|
||||
faceoffDotZ: 6.7,
|
||||
zoneDotX: 20.2,
|
||||
});
|
||||
|
||||
/**
|
||||
* Centre of the corner arc nearest (x, z), and the sign of the quadrant.
|
||||
* Points outside the straight sections belong to exactly one corner.
|
||||
*/
|
||||
function cornerCentre(x, z, out) {
|
||||
const sx = x >= 0 ? 1 : -1;
|
||||
const sz = z >= 0 ? 1 : -1;
|
||||
out.x = sx * (RINK.halfX - RINK.cornerR);
|
||||
out.z = sz * (RINK.halfZ - RINK.cornerR);
|
||||
return out;
|
||||
}
|
||||
|
||||
const _c = { x: 0, z: 0 };
|
||||
|
||||
/**
|
||||
* Signed distance from the rink's inner surface, plus the inward normal.
|
||||
*
|
||||
* Positive `dist` means the point is outside the playing surface by that much;
|
||||
* `nx`/`nz` point back toward the ice. Returns the same object every call, so
|
||||
* copy anything you need to keep.
|
||||
*/
|
||||
const _pen = { dist: 0, nx: 0, nz: 0 };
|
||||
export function rinkPenetration(x, z, radius = 0) {
|
||||
const ax = Math.abs(x);
|
||||
const az = Math.abs(z);
|
||||
const straightX = RINK.halfX - RINK.cornerR;
|
||||
const straightZ = RINK.halfZ - RINK.cornerR;
|
||||
|
||||
if (ax <= straightX || az <= straightZ) {
|
||||
// Straight section: whichever wall is closer wins. A point can only be
|
||||
// outside one of them here, since the corners are handled below.
|
||||
const overX = ax + radius - RINK.halfX;
|
||||
const overZ = az + radius - RINK.halfZ;
|
||||
if (overX >= overZ) {
|
||||
_pen.dist = overX;
|
||||
_pen.nx = x >= 0 ? -1 : 1;
|
||||
_pen.nz = 0;
|
||||
} else {
|
||||
_pen.dist = overZ;
|
||||
_pen.nx = 0;
|
||||
_pen.nz = z >= 0 ? -1 : 1;
|
||||
}
|
||||
return _pen;
|
||||
}
|
||||
|
||||
cornerCentre(x, z, _c);
|
||||
const dx = x - _c.x;
|
||||
const dz = z - _c.z;
|
||||
const d = Math.hypot(dx, dz) || 1e-6;
|
||||
_pen.dist = d + radius - RINK.cornerR;
|
||||
_pen.nx = -dx / d;
|
||||
_pen.nz = -dz / d;
|
||||
return _pen;
|
||||
}
|
||||
|
||||
/** True when a circle of `radius` at (x, z) is fully on the ice. */
|
||||
export function insideRink(x, z, radius = 0) {
|
||||
return rinkPenetration(x, z, radius).dist <= 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Push a body back inside the boards and kill the velocity going into them.
|
||||
*
|
||||
* Box3D owns board contact for anything with a proxy capsule; this is the
|
||||
* headless fallback (tests, and any future server tick without a physics
|
||||
* world) and a cheap safety net against a body escaping the world.
|
||||
*
|
||||
* `restitution` 0 is a dead thud, 1 a perfect bounce. Boards eat most of it.
|
||||
*/
|
||||
export function clampToRink(state, radius = 0.36, restitution = 0.18) {
|
||||
const pen = rinkPenetration(state.x, state.z, radius);
|
||||
if (pen.dist <= 0) return false;
|
||||
state.x += pen.nx * pen.dist;
|
||||
state.z += pen.nz * pen.dist;
|
||||
const into = state.vx * pen.nx + state.vz * pen.nz;
|
||||
if (into < 0) {
|
||||
// Remove the inward-normal component, then add back a fraction reversed.
|
||||
state.vx -= into * pen.nx * (1 + restitution);
|
||||
state.vz -= into * pen.nz * (1 + restitution);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* The board line as a closed polyline, counter-clockwise from the +X end.
|
||||
*
|
||||
* The physics boards and the rendered boards are both built from this, so the
|
||||
* wall a skater bounces off is the wall they can see. `cornerSteps` is the
|
||||
* number of segments each of the four corner arcs is cut into.
|
||||
*/
|
||||
export function rinkOutline(cornerSteps = 8) {
|
||||
const sx = RINK.halfX - RINK.cornerR;
|
||||
const sz = RINK.halfZ - RINK.cornerR;
|
||||
const pts = [];
|
||||
// Four corners, each an arc swept from its own quadrant, with the straight
|
||||
// sections falling out as the gaps between consecutive arcs.
|
||||
const corners = [
|
||||
{ cx: sx, cz: sz, a0: 0 }, // +X +Z
|
||||
{ cx: -sx, cz: sz, a0: Math.PI / 2 }, // -X +Z
|
||||
{ cx: -sx, cz: -sz, a0: Math.PI }, // -X -Z
|
||||
{ cx: sx, cz: -sz, a0: -Math.PI / 2 }, // +X -Z
|
||||
];
|
||||
for (const c of corners) {
|
||||
for (let i = 0; i <= cornerSteps; i++) {
|
||||
const a = c.a0 + (i / cornerSteps) * (Math.PI / 2);
|
||||
pts.push({ x: c.cx + Math.cos(a) * RINK.cornerR, z: c.cz + Math.sin(a) * RINK.cornerR });
|
||||
}
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
|
||||
/**
|
||||
* A random point on the ice, inset from the boards.
|
||||
* `rand` is any () => [0,1) so callers can keep it seeded.
|
||||
*/
|
||||
export function randomIcePoint(rand, inset = 3) {
|
||||
for (let i = 0; i < 24; i++) {
|
||||
const x = (rand() * 2 - 1) * (RINK.halfX - inset);
|
||||
const z = (rand() * 2 - 1) * (RINK.halfZ - inset);
|
||||
if (insideRink(x, z, inset)) return { x, z };
|
||||
}
|
||||
// Rejection sampling in a rounded rect basically never fails, but never
|
||||
// hand back an off-ice waypoint if it does.
|
||||
return { x: 0, z: 0 };
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
/** Scalar helpers shared by the sim and the renderer. No three.js here. */
|
||||
|
||||
export const clamp = (x, a, b) => (x < a ? a : x > b ? b : x);
|
||||
export const lerp = (a, b, t) => a + (b - a) * t;
|
||||
export const smooth = (t) => t * t * (3 - 2 * t);
|
||||
|
||||
/** Wrap to (-PI, PI]. */
|
||||
export function wrapAngle(a) {
|
||||
let x = a;
|
||||
while (x > Math.PI) x -= Math.PI * 2;
|
||||
while (x <= -Math.PI) x += Math.PI * 2;
|
||||
return x;
|
||||
}
|
||||
|
||||
/** Shortest-arc interpolation between two headings. */
|
||||
export function lerpAngle(a, b, t) {
|
||||
return a + wrapAngle(b - a) * t;
|
||||
}
|
||||
|
||||
/** Move `from` toward `to` by at most `step`, without overshooting. */
|
||||
export function approach(from, to, step) {
|
||||
return Math.abs(to - from) <= step ? to : from + Math.sign(to - from) * step;
|
||||
}
|
||||
|
||||
/** Same, on the circle. */
|
||||
export function approachAngle(from, to, step) {
|
||||
const d = wrapAngle(to - from);
|
||||
return Math.abs(d) <= step ? wrapAngle(to) : wrapAngle(from + Math.sign(d) * step);
|
||||
}
|
||||
@@ -0,0 +1,215 @@
|
||||
import { clamp, lerpAngle, wrapAngle } from './scalar.js';
|
||||
import { clampToRink } from './rink.js';
|
||||
|
||||
/**
|
||||
* Skating locomotion.
|
||||
*
|
||||
* This is Ludus's `fighterSim` pattern — intent in, velocity out, integrated on
|
||||
* a fixed step so client and (eventual) server cannot drift — with the walking
|
||||
* model swapped for a blade.
|
||||
*
|
||||
* The difference that matters: a runner's velocity points where they are
|
||||
* pushing, so friction is isotropic and stopping is instant-ish. A skate glides
|
||||
* almost freely along its own length and bites hard across it. Movement is
|
||||
* therefore modelled as two separate things:
|
||||
*
|
||||
* 1. the *blade line*, which the momentum vector is continuously dragged onto
|
||||
* (`edgeGrip`) — this is the carve, and it is why a hockey player leans
|
||||
* into a turn and arrives somewhere they were not pointing a moment ago;
|
||||
* 2. speed *along* that line, which a stride adds to and a very small drag
|
||||
* removes.
|
||||
*
|
||||
* Modelling the carve as a rotation of the velocity vector rather than as
|
||||
* lateral friction is what keeps momentum: turning redirects speed instead of
|
||||
* destroying it, so a hard change of direction costs a little (`carveScrub`)
|
||||
* and coasts out wide, which is the whole feel we are after.
|
||||
*/
|
||||
|
||||
export const SKATE = Object.freeze({
|
||||
/** Flat-out forward speed, m/s. ~8 m/s is a fast NHL skater. */
|
||||
sprintSpeed: 8.4,
|
||||
/** Speed the stride settles at without pushing hard. */
|
||||
cruiseSpeed: 5.6,
|
||||
/** Stride acceleration from a standstill, m/s². */
|
||||
accel: 7.2,
|
||||
/** Extra push while sprinting. */
|
||||
sprintAccel: 9.0,
|
||||
/** Constant scrub from blade friction, m/s². Small — this is ice. */
|
||||
glideDrag: 0.42,
|
||||
/** Quadratic term so top speed is reached asymptotically, per (m/s)². */
|
||||
dragQuad: 0.011,
|
||||
/** Rate the momentum vector swings onto the blade line, 1/s. */
|
||||
edgeGrip: 6.2,
|
||||
/** Speed lost per radian of redirect. A hard carve costs; a lazy one doesn't. */
|
||||
carveScrub: 0.55,
|
||||
/** Snowplow / hockey stop deceleration, m/s². */
|
||||
brakeDecel: 12.5,
|
||||
/** Body yaw rate at a standstill, rad/s. */
|
||||
turnRate: 5.2,
|
||||
/** Body yaw rate at top speed — you cannot pivot on a rail. */
|
||||
turnRateFast: 1.9,
|
||||
/** Proxy capsule radius, also used for board clamping. */
|
||||
radius: 0.36,
|
||||
/** Never let a collision fling anyone faster than this. */
|
||||
speedCeiling: 11,
|
||||
});
|
||||
|
||||
export function createSkaterState(id, spawn = {}, opts = {}) {
|
||||
return {
|
||||
id,
|
||||
name: opts.name ?? `Skater ${id}`,
|
||||
/** Seed for appearance; the sim itself is deterministic without it. */
|
||||
seed: opts.seed ?? 1337,
|
||||
team: opts.team ?? 0,
|
||||
|
||||
x: spawn.x ?? 0,
|
||||
y: 0,
|
||||
z: spawn.z ?? 0,
|
||||
vx: 0,
|
||||
vz: 0,
|
||||
yaw: spawn.yaw ?? 0,
|
||||
|
||||
/** Intent: world-space XZ direction, length 0..1 (a left stick). */
|
||||
ix: 0,
|
||||
iz: 0,
|
||||
sprint: false,
|
||||
/** Held brake — a hockey stop, independent of which way the stick points. */
|
||||
brake: false,
|
||||
|
||||
// ---- read-only outputs the animator and the AI read -------------------
|
||||
/** Signed speed along the blade. Negative means gliding backwards. */
|
||||
bladeSpeed: 0,
|
||||
/** Last frame's redirect, rad. Sign tells the animator which edge is loaded. */
|
||||
carve: 0,
|
||||
/** How hard the skater is pushing, 0..1. Drives stride amplitude. */
|
||||
effort: 0,
|
||||
};
|
||||
}
|
||||
|
||||
/** Clamp an input bag into something the sim can trust. */
|
||||
export function applyIntent(s, msg) {
|
||||
const n = (v) => (Number.isFinite(v) ? v : 0);
|
||||
let ix = clamp(n(msg.ix), -1, 1);
|
||||
let iz = clamp(n(msg.iz), -1, 1);
|
||||
const len = Math.hypot(ix, iz);
|
||||
if (len > 1) {
|
||||
ix /= len;
|
||||
iz /= len;
|
||||
}
|
||||
s.ix = ix;
|
||||
s.iz = iz;
|
||||
s.sprint = !!msg.sprint;
|
||||
s.brake = !!msg.brake;
|
||||
}
|
||||
|
||||
/** Unit forward for a yaw, in three.js's convention (+Z is forward at yaw 0). */
|
||||
export const forwardX = (yaw) => Math.sin(yaw);
|
||||
export const forwardZ = (yaw) => Math.cos(yaw);
|
||||
|
||||
/**
|
||||
* Advance one skater by `dt`.
|
||||
*
|
||||
* `clampBoards` is on for the headless path. In the browser the Box3D proxy
|
||||
* capsule owns board contact — running both would double the push-out.
|
||||
*/
|
||||
export function stepSkater(s, dt, { clampBoards = true } = {}) {
|
||||
const intentLen = Math.min(1, Math.hypot(s.ix, s.iz));
|
||||
const speed0 = Math.hypot(s.vx, s.vz);
|
||||
|
||||
// ---- 1. body yaw --------------------------------------------------------
|
||||
// The skater turns their body toward the stick. How fast falls off with
|
||||
// speed: at a standstill you can spin on the spot, at full flight you have
|
||||
// to carve the turn.
|
||||
if (intentLen > 0.05) {
|
||||
const intentYaw = Math.atan2(s.ix, s.iz);
|
||||
const t = clamp(speed0 / SKATE.sprintSpeed, 0, 1);
|
||||
const rate = SKATE.turnRate + (SKATE.turnRateFast - SKATE.turnRate) * t;
|
||||
s.yaw = lerpAngle(s.yaw, intentYaw, Math.min(1, rate * dt));
|
||||
}
|
||||
s.yaw = wrapAngle(s.yaw);
|
||||
|
||||
// ---- 2. the carve -------------------------------------------------------
|
||||
// Drag the momentum vector onto the blade line. The blade is a line, not a
|
||||
// ray, so a skater gliding backwards keeps gliding backwards instead of
|
||||
// being snapped through 180°.
|
||||
s.carve = 0;
|
||||
if (speed0 > 1e-4) {
|
||||
const velYaw = Math.atan2(s.vx, s.vz);
|
||||
const off = wrapAngle(s.yaw - velYaw);
|
||||
const bladeOff = Math.abs(off) > Math.PI / 2 ? wrapAngle(off - Math.sign(off) * Math.PI) : off;
|
||||
const grip = 1 - Math.exp(-SKATE.edgeGrip * dt);
|
||||
const turnBy = bladeOff * grip;
|
||||
const newVelYaw = velYaw + turnBy;
|
||||
// Redirect preserves magnitude; the scrub below is the only speed cost, so
|
||||
// a wide turn is nearly free and a hard one bleeds.
|
||||
const kept = 1 - clamp(SKATE.carveScrub * Math.abs(turnBy), 0, 0.6);
|
||||
const speed = speed0 * kept;
|
||||
s.vx = Math.sin(newVelYaw) * speed;
|
||||
s.vz = Math.cos(newVelYaw) * speed;
|
||||
s.carve = turnBy;
|
||||
}
|
||||
|
||||
// ---- 3. speed along the blade -------------------------------------------
|
||||
const fx = forwardX(s.yaw);
|
||||
const fz = forwardZ(s.yaw);
|
||||
let vf = s.vx * fx + s.vz * fz;
|
||||
const rx = Math.cos(s.yaw);
|
||||
const rz = -Math.sin(s.yaw);
|
||||
let vr = s.vx * rx + s.vz * rz;
|
||||
|
||||
const maxSpeed = s.sprint ? SKATE.sprintSpeed : SKATE.cruiseSpeed;
|
||||
// How much of the stick points where the skater is facing. A stick pulled
|
||||
// behind them is a request to turn (handled above) and, until the body comes
|
||||
// round, a request to stop.
|
||||
const align = intentLen > 0.05 ? (s.ix * fx + s.iz * fz) / intentLen : 0;
|
||||
|
||||
let effort = 0;
|
||||
if (s.brake || (intentLen > 0.05 && align < -0.35 && vf > 0.4)) {
|
||||
// Hockey stop: both blades across the momentum.
|
||||
const decel = SKATE.brakeDecel * dt;
|
||||
vf = Math.abs(vf) <= decel ? 0 : vf - Math.sign(vf) * decel;
|
||||
effort = 1;
|
||||
} else if (intentLen > 0.05 && align > 0.15) {
|
||||
// Stride. The push weakens as the blade approaches the speed the legs can
|
||||
// deliver, so top speed is a property of the stride rather than a clamp.
|
||||
const base = s.sprint ? SKATE.sprintAccel : SKATE.accel;
|
||||
const headroom = clamp(1 - vf / maxSpeed, 0, 1);
|
||||
vf += base * align * intentLen * headroom * dt;
|
||||
// Effort is leg work, not acceleration. A skater holding top speed is
|
||||
// still throwing full strides — they just stop gaining from them — so
|
||||
// folding `headroom` in here would quietly freeze the legs of anyone at
|
||||
// cruise, which is most of the time.
|
||||
effort = clamp(align * intentLen, 0, 1);
|
||||
}
|
||||
|
||||
// Glide drag: tiny linear term plus a quadratic one that sets the ceiling.
|
||||
if (Math.abs(vf) > 1e-4) {
|
||||
const drag = (SKATE.glideDrag + SKATE.dragQuad * vf * vf) * dt;
|
||||
vf = Math.abs(vf) <= drag ? 0 : vf - Math.sign(vf) * drag;
|
||||
}
|
||||
// Whatever lateral slip survived the carve dies here — it is only ever a
|
||||
// rounding remnant, but leaving it in lets a skater drift sideways forever.
|
||||
vr *= Math.exp(-SKATE.edgeGrip * 2 * dt);
|
||||
|
||||
s.vx = fx * vf + rx * vr;
|
||||
s.vz = fz * vf + rz * vr;
|
||||
s.bladeSpeed = vf;
|
||||
s.effort = effort;
|
||||
|
||||
// A board hit or a body check can hand back more speed than a skater can
|
||||
// generate; cap it so nothing launches.
|
||||
const speed = Math.hypot(s.vx, s.vz);
|
||||
if (speed > SKATE.speedCeiling) {
|
||||
const k = SKATE.speedCeiling / speed;
|
||||
s.vx *= k;
|
||||
s.vz *= k;
|
||||
}
|
||||
|
||||
// ---- 4. integrate -------------------------------------------------------
|
||||
s.x += s.vx * dt;
|
||||
s.z += s.vz * dt;
|
||||
if (clampBoards) clampToRink(s, SKATE.radius);
|
||||
}
|
||||
|
||||
/** Planar speed, m/s. */
|
||||
export const speedOf = (s) => Math.hypot(s.vx, s.vz);
|
||||
@@ -0,0 +1,292 @@
|
||||
import * as THREE from 'three';
|
||||
import { E, clamp, smooth } from '../core/math.js';
|
||||
import {
|
||||
FOOT_Y,
|
||||
GOALIE_BONES,
|
||||
GOALIE_LEGS,
|
||||
GOALIE_UPPER,
|
||||
poseButterfly,
|
||||
poseReach,
|
||||
poseReady,
|
||||
poseShuffle,
|
||||
} from './poses/goalie.js';
|
||||
|
||||
/**
|
||||
* Goalie animator.
|
||||
*
|
||||
* Upper body is pose-authored; legs are two-bone IK onto mover-local foot
|
||||
* targets so the pads stay on the ice. The paddle stick keeps its authored
|
||||
* grip rotation (re-aiming it every frame is what made it thrash).
|
||||
*/
|
||||
|
||||
export function buildGoalieAnimator(skelData, mover) {
|
||||
const B = skelData.bones;
|
||||
const LEN = {
|
||||
thigh: B.shinL.position.length(),
|
||||
shin: B.footL.position.length(),
|
||||
};
|
||||
const restThighDir = {
|
||||
L: B.shinL.position.clone().normalize(),
|
||||
R: B.shinR.position.clone().normalize(),
|
||||
};
|
||||
const restShinDir = {
|
||||
L: B.footL.position.clone().normalize(),
|
||||
R: B.footR.position.clone().normalize(),
|
||||
};
|
||||
|
||||
function newPose() {
|
||||
const p = {
|
||||
q: {},
|
||||
rootOffset: new THREE.Vector3(),
|
||||
rootQuat: new THREE.Quaternion(),
|
||||
feet: {
|
||||
L: { x: 0.28, z: 0.05, yaw: 0.15 },
|
||||
R: { x: -0.28, z: 0.05, yaw: -0.15 },
|
||||
},
|
||||
};
|
||||
for (const n of GOALIE_BONES) p.q[n] = new THREE.Quaternion();
|
||||
return p;
|
||||
}
|
||||
|
||||
const cur = newPose();
|
||||
const frozen = newPose();
|
||||
|
||||
const anim = {
|
||||
state: 'ready',
|
||||
blend: 1,
|
||||
BLEND_TIME: 0.16,
|
||||
transitionTime: 0.16,
|
||||
time: 0,
|
||||
stateTime: 0,
|
||||
speed: 1,
|
||||
|
||||
origin: new THREE.Vector3(),
|
||||
originYaw: 0,
|
||||
|
||||
moveSpeed: 0,
|
||||
lateralVel: 0,
|
||||
puckHeight: 0.05,
|
||||
puckDist: 8,
|
||||
threatened: 0,
|
||||
|
||||
/** Goalie paddle group, parented to handR. Grip is adjusted per stance. */
|
||||
stick: null,
|
||||
};
|
||||
|
||||
// Hand-local stick grips, tuned against the equipment reference:
|
||||
// ready = paddle on ice in the five-hole, shaft up into the blocker hand;
|
||||
// butterfly = same idea, flatter, so it does not spear the surface.
|
||||
// Searched: nearly down-forward puts the paddle on the ice in the five-hole
|
||||
// (minY ≈ 0.02–0.05) without spearing through.
|
||||
const STICK_READY_E = new THREE.Euler(1.55, 0.3, 0.05, 'XYZ');
|
||||
const STICK_FLY_E = new THREE.Euler(1.65, 0.2, 0.0, 'XYZ');
|
||||
const STICK_READY_POS = new THREE.Vector3(0.04, -0.02, 0.04);
|
||||
const STICK_FLY_POS = new THREE.Vector3(0.05, 0.02, 0.05);
|
||||
const _stickEuler = new THREE.Euler();
|
||||
const _stickPos = new THREE.Vector3();
|
||||
|
||||
function applyMover() {
|
||||
mover.position.copy(anim.origin);
|
||||
mover.rotation.set(0, anim.originYaw, 0);
|
||||
}
|
||||
|
||||
anim.setTransform = function setTransform(position, yaw) {
|
||||
anim.origin.copy(position);
|
||||
anim.originYaw = yaw;
|
||||
};
|
||||
|
||||
function snapshot() {
|
||||
for (const n of GOALIE_BONES) frozen.q[n].copy(B[n].quaternion);
|
||||
frozen.rootOffset.copy(B.root.position);
|
||||
frozen.rootQuat.copy(B.root.quaternion);
|
||||
if (cur.feet) {
|
||||
frozen.feet.L = { ...cur.feet.L };
|
||||
frozen.feet.R = { ...cur.feet.R };
|
||||
}
|
||||
}
|
||||
|
||||
anim.setState = function setState(name, blendTime = null) {
|
||||
if (name === anim.state) return;
|
||||
snapshot();
|
||||
anim.state = name;
|
||||
anim.stateTime = 0;
|
||||
anim.blend = 0;
|
||||
anim.transitionTime = blendTime ?? anim.BLEND_TIME;
|
||||
};
|
||||
|
||||
function chooseState() {
|
||||
const low = anim.puckHeight < 0.38;
|
||||
const high = anim.puckHeight > 0.75;
|
||||
const close = anim.puckDist < 8;
|
||||
const veryClose = anim.puckDist < 3.5;
|
||||
const sliding = Math.abs(anim.lateralVel) > 1.2 || anim.moveSpeed > 1.6;
|
||||
|
||||
if (low && (veryClose || (close && anim.threatened > 0.3))) return 'butterfly';
|
||||
if (high && close && anim.threatened > 0.25) return 'reach';
|
||||
if (sliding) return 'shuffle';
|
||||
return 'ready';
|
||||
}
|
||||
|
||||
// ---- two-bone leg IK (same pattern as the skater) ------------------------
|
||||
const _H = new THREE.Vector3();
|
||||
const _d = new THREE.Vector3();
|
||||
const _pole = new THREE.Vector3();
|
||||
const _e2 = new THREE.Vector3();
|
||||
const _knee = new THREE.Vector3();
|
||||
const _dir = new THREE.Vector3();
|
||||
const _f = new THREE.Vector3();
|
||||
const _r = new THREE.Vector3();
|
||||
const _qP = new THREE.Quaternion();
|
||||
const _q1 = new THREE.Quaternion();
|
||||
const _q2 = new THREE.Quaternion();
|
||||
const _qF = new THREE.Quaternion();
|
||||
const _qInv = new THREE.Quaternion();
|
||||
const _worldFoot = new THREE.Vector3();
|
||||
|
||||
const fwdOf = (yaw, out) => out.set(Math.sin(yaw), 0, Math.cos(yaw));
|
||||
const rightOf = (yaw, out) => out.set(Math.cos(yaw), 0, -Math.sin(yaw));
|
||||
|
||||
function solveLeg(side, localX, localZ, toeYaw) {
|
||||
const thigh = B['thigh' + side];
|
||||
const shin = B['shin' + side];
|
||||
const foot = B['foot' + side];
|
||||
|
||||
// Local foot → world via the mover (already at originYaw).
|
||||
_worldFoot.set(localX, FOOT_Y, localZ).applyMatrix4(mover.matrixWorld);
|
||||
_worldFoot.y = FOOT_Y;
|
||||
|
||||
thigh.getWorldPosition(_H);
|
||||
_d.subVectors(_worldFoot, _H);
|
||||
let d = _d.length();
|
||||
const a = LEN.thigh;
|
||||
const b = LEN.shin;
|
||||
d = clamp(d, 0.12, a + b - 0.003);
|
||||
_d.normalize();
|
||||
const cosA = clamp((a * a + d * d - b * b) / (2 * a * d), -1, 1);
|
||||
const sinA = Math.sqrt(Math.max(0, 1 - cosA * cosA));
|
||||
|
||||
fwdOf(anim.originYaw, _f);
|
||||
rightOf(anim.originYaw, _r);
|
||||
// Knee pole: forward and outward so butterfly pads open, not knock-knees.
|
||||
_pole.copy(_f).addScaledVector(_r, side === 'L' ? 0.55 : -0.55);
|
||||
_pole.y -= 0.15;
|
||||
_e2.copy(_pole).addScaledVector(_d, -_pole.dot(_d));
|
||||
if (_e2.lengthSq() < 1e-8) _e2.copy(_f);
|
||||
_e2.normalize();
|
||||
_knee.copy(_H).addScaledVector(_d, a * cosA).addScaledVector(_e2, a * sinA);
|
||||
|
||||
_dir.subVectors(_knee, _H).normalize();
|
||||
_q1.setFromUnitVectors(restThighDir[side], _dir);
|
||||
thigh.parent.getWorldQuaternion(_qP);
|
||||
_qInv.copy(_qP).invert();
|
||||
thigh.quaternion.copy(_qInv).multiply(_q1);
|
||||
|
||||
_dir.subVectors(_worldFoot, _knee).normalize();
|
||||
_q2.setFromUnitVectors(restShinDir[side], _dir);
|
||||
_qInv.copy(_q1).invert();
|
||||
shin.quaternion.copy(_qInv).multiply(_q2);
|
||||
|
||||
const worldYaw = anim.originYaw + toeYaw;
|
||||
E(_qF, 0, worldYaw, 0, 'YXZ');
|
||||
_qInv.copy(_q2).invert();
|
||||
foot.quaternion.copy(_qInv).multiply(_qF);
|
||||
B['toe' + side].quaternion.identity();
|
||||
}
|
||||
|
||||
anim.update = function update(dt) {
|
||||
dt *= anim.speed;
|
||||
anim.time += dt;
|
||||
anim.stateTime += dt;
|
||||
anim.blend = Math.min(1, anim.blend + dt / anim.transitionTime);
|
||||
|
||||
anim.setState(chooseState());
|
||||
applyMover();
|
||||
mover.updateMatrixWorld(true);
|
||||
|
||||
const lean = clamp(anim.lateralVel / 3.5, -1, 1);
|
||||
const t = anim.time;
|
||||
|
||||
for (const n of GOALIE_BONES) cur.q[n].identity();
|
||||
cur.rootOffset.set(0, 0, 0);
|
||||
cur.rootQuat.identity();
|
||||
|
||||
if (anim.state === 'butterfly') {
|
||||
poseButterfly(cur, { lean, t });
|
||||
} else if (anim.state === 'shuffle') {
|
||||
poseShuffle(cur, {
|
||||
dir: anim.lateralVel >= 0 ? 1 : -1,
|
||||
effort: clamp(anim.moveSpeed / 3.5, 0.3, 1),
|
||||
t,
|
||||
});
|
||||
} else if (anim.state === 'reach') {
|
||||
const side = lean > 0.25 ? 1 : -1;
|
||||
poseReach(cur, {
|
||||
side,
|
||||
up: clamp((anim.puckHeight - 0.6) / 0.8, 0.4, 1),
|
||||
lean,
|
||||
t,
|
||||
});
|
||||
} else {
|
||||
poseReady(cur, { lean: lean * 0.5, t });
|
||||
}
|
||||
|
||||
const w = smooth(anim.blend);
|
||||
for (const n of GOALIE_UPPER) {
|
||||
B[n].quaternion.slerpQuaternions(frozen.q[n], cur.q[n], w);
|
||||
}
|
||||
// Legs identity mid-blend then IK — slerping free leg eulers fights the IK.
|
||||
for (const n of GOALIE_LEGS) B[n].quaternion.identity();
|
||||
B.root.position.lerpVectors(frozen.rootOffset, cur.rootOffset, w);
|
||||
B.root.quaternion.slerpQuaternions(frozen.rootQuat, cur.rootQuat, w);
|
||||
|
||||
mover.updateMatrixWorld(true);
|
||||
|
||||
// Blend foot targets in mover-local space, then IK.
|
||||
const fL = {
|
||||
x: lerp(frozen.feet.L.x, cur.feet.L.x, w),
|
||||
z: lerp(frozen.feet.L.z, cur.feet.L.z, w),
|
||||
yaw: lerp(frozen.feet.L.yaw, cur.feet.L.yaw, w),
|
||||
};
|
||||
const fR = {
|
||||
x: lerp(frozen.feet.R.x, cur.feet.R.x, w),
|
||||
z: lerp(frozen.feet.R.z, cur.feet.R.z, w),
|
||||
yaw: lerp(frozen.feet.R.yaw, cur.feet.R.yaw, w),
|
||||
};
|
||||
solveLeg('L', fL.x, fL.z, fL.yaw);
|
||||
solveLeg('R', fR.x, fR.z, fR.yaw);
|
||||
|
||||
// Stick grip: blend ready → butterfly so the paddle stays near the ice.
|
||||
if (anim.stick) {
|
||||
const k = anim.state === 'butterfly' ? Math.min(1, anim.stateTime / 0.14) : 0;
|
||||
_stickEuler.set(
|
||||
STICK_READY_E.x + (STICK_FLY_E.x - STICK_READY_E.x) * k,
|
||||
STICK_READY_E.y + (STICK_FLY_E.y - STICK_READY_E.y) * k,
|
||||
STICK_READY_E.z + (STICK_FLY_E.z - STICK_READY_E.z) * k,
|
||||
'XYZ',
|
||||
);
|
||||
anim.stick.quaternion.setFromEuler(_stickEuler);
|
||||
_stickPos.lerpVectors(STICK_READY_POS, STICK_FLY_POS, k);
|
||||
anim.stick.position.copy(_stickPos);
|
||||
}
|
||||
|
||||
mover.updateMatrixWorld(true);
|
||||
};
|
||||
|
||||
function lerp(a, b, t) {
|
||||
return a + (b - a) * t;
|
||||
}
|
||||
|
||||
// Seed frozen from a ready pose so the first frame has real foot targets.
|
||||
poseReady(frozen, { lean: 0, t: 0 });
|
||||
poseReady(cur, { lean: 0, t: 0 });
|
||||
for (const n of GOALIE_UPPER) B[n].quaternion.copy(frozen.q[n]);
|
||||
for (const n of GOALIE_LEGS) B[n].quaternion.identity();
|
||||
B.root.position.copy(frozen.rootOffset);
|
||||
B.root.quaternion.copy(frozen.rootQuat);
|
||||
applyMover();
|
||||
mover.updateMatrixWorld(true);
|
||||
solveLeg('L', frozen.feet.L.x, frozen.feet.L.z, frozen.feet.L.yaw);
|
||||
solveLeg('R', frozen.feet.R.x, frozen.feet.R.z, frozen.feet.R.yaw);
|
||||
|
||||
return anim;
|
||||
}
|
||||
@@ -0,0 +1,173 @@
|
||||
import { E } from '../../core/math.js';
|
||||
import { clamp } from '../../../shared/scalar.js';
|
||||
|
||||
/**
|
||||
* Goalie pose authoring.
|
||||
*
|
||||
* Upper body + root only. Feet are world targets the animator solves with the
|
||||
* same two-bone IK the skater uses — free eulers on the legs put the pads in
|
||||
* the air or through the ice the moment the root drops. Measured rest feet sit
|
||||
* at y ≈ 0.07; every stance keeps them there.
|
||||
*/
|
||||
|
||||
/** Bones written by the pose layer (legs are IK'd after). */
|
||||
export const GOALIE_UPPER = [
|
||||
'pelvis', 'spine1', 'spine2', 'spine3', 'neck', 'head',
|
||||
'clavicleL', 'upperArmL', 'forearmL', 'handL',
|
||||
'clavicleR', 'upperArmR', 'forearmR', 'handR',
|
||||
];
|
||||
|
||||
export const GOALIE_LEGS = [
|
||||
'thighL', 'shinL', 'footL', 'toeL',
|
||||
'thighR', 'shinR', 'footR', 'toeR',
|
||||
];
|
||||
|
||||
export const GOALIE_BONES = GOALIE_UPPER.concat(GOALIE_LEGS);
|
||||
|
||||
/** Foot sole height, metres. */
|
||||
export const FOOT_Y = 0.085;
|
||||
|
||||
/**
|
||||
* Ready stance foot targets in mover-local space.
|
||||
* Open base like the equipment ref (half-butterfly ready), not a narrow crouch.
|
||||
*/
|
||||
export const FEET_READY = {
|
||||
L: { x: 0.42, z: 0.02, yaw: 0.35 },
|
||||
R: { x: -0.42, z: 0.02, yaw: -0.35 },
|
||||
};
|
||||
|
||||
/**
|
||||
* Butterfly foot targets: pads flared, feet out to the sides, still on ice.
|
||||
* Width ~1.2 m so the pad faces cover the five-hole like the ref.
|
||||
*/
|
||||
export const FEET_BUTTERFLY = {
|
||||
L: { x: 0.62, z: -0.06, yaw: 0.65 },
|
||||
R: { x: -0.62, z: -0.06, yaw: -0.65 },
|
||||
};
|
||||
|
||||
/**
|
||||
* Ready: deep knee bend, chest up enough to track the puck, trapper open at
|
||||
* the side, blocker + paddle down over the five-hole.
|
||||
*/
|
||||
export function poseReady(P, { lean = 0, t = 0 } = {}) {
|
||||
const breath = Math.sin(t * 1.5) * 0.01;
|
||||
const s = clamp(lean, -1, 1);
|
||||
|
||||
// Soft forward crouch; head counters so eyes stay on the play.
|
||||
E(P.q.pelvis, 0.16 + breath, s * 0.06, -s * 0.1);
|
||||
E(P.q.spine1, 0.14, -s * 0.05, -s * 0.06);
|
||||
E(P.q.spine2, 0.1, -s * 0.04, -s * 0.05);
|
||||
E(P.q.spine3, 0.06, -s * 0.03, -s * 0.03);
|
||||
E(P.q.neck, -0.18, s * 0.08, 0);
|
||||
E(P.q.head, -0.12, s * 0.1, 0);
|
||||
|
||||
// Trapper: out beside the hip, pocket toward the shooter (ref photo).
|
||||
E(P.q.clavicleL, 0.06, 0.14, -0.12);
|
||||
E(P.q.upperArmL, -0.35, 0.85, -0.55);
|
||||
E(P.q.forearmL, -1.0, -0.1, 0.3);
|
||||
E(P.q.handL, -0.1, 0.4, 0.55);
|
||||
|
||||
// Blocker + stick: low over the five-hole so the paddle can sit on the ice.
|
||||
E(P.q.clavicleR, 0.04, -0.1, 0.1);
|
||||
E(P.q.upperArmR, -0.95, -0.45, 0.45);
|
||||
E(P.q.forearmR, -0.55, 0.15, 0.1);
|
||||
E(P.q.handR, -0.2, 0.05, -0.2);
|
||||
|
||||
// Seed legs (IK overwrites thighs/shins/feet).
|
||||
for (const n of GOALIE_LEGS) P.q[n].identity();
|
||||
|
||||
// Hips low enough that the pad faces fill the lower net (ref ready).
|
||||
P.rootOffset.set(s * 0.03, -0.28 + breath * 0.25, 0.02);
|
||||
E(P.rootQuat, 0.06, 0, -s * 0.08);
|
||||
|
||||
P.feet = {
|
||||
L: { ...FEET_READY.L, x: FEET_READY.L.x + s * 0.04 },
|
||||
R: { ...FEET_READY.R, x: FEET_READY.R.x + s * 0.04 },
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Butterfly: torso stays tracking; feet flare wide on the ice via IK.
|
||||
*/
|
||||
export function poseButterfly(P, { lean = 0, t = 0 } = {}) {
|
||||
const s = clamp(lean, -1, 1);
|
||||
|
||||
E(P.q.pelvis, 0.1, s * 0.08, -s * 0.14);
|
||||
E(P.q.spine1, 0.22, -s * 0.06, -s * 0.08);
|
||||
E(P.q.spine2, 0.16, -s * 0.05, -s * 0.06);
|
||||
E(P.q.spine3, 0.1, -s * 0.04, -s * 0.04);
|
||||
E(P.q.neck, -0.22, s * 0.1, 0);
|
||||
E(P.q.head, -0.14, s * 0.12, 0);
|
||||
|
||||
// Arms stay active above the pads.
|
||||
E(P.q.clavicleL, 0.08, 0.12, -0.1);
|
||||
E(P.q.upperArmL, -0.25, 0.75, -0.75);
|
||||
E(P.q.forearmL, -0.95, -0.1, 0.3);
|
||||
E(P.q.handL, -0.1, 0.4, 0.5);
|
||||
|
||||
E(P.q.clavicleR, 0.06, -0.1, 0.08);
|
||||
E(P.q.upperArmR, -0.35, -0.55, 0.55);
|
||||
E(P.q.forearmR, -0.85, 0.15, 0.12);
|
||||
E(P.q.handR, -0.12, 0.12, -0.18);
|
||||
|
||||
for (const n of GOALIE_LEGS) P.q[n].identity();
|
||||
|
||||
// Drop the hips so the pad faces can meet the ice when feet are wide.
|
||||
P.rootOffset.set(s * 0.04, -0.48, 0.0);
|
||||
E(P.rootQuat, 0.04, 0, -s * 0.1);
|
||||
|
||||
P.feet = {
|
||||
L: { ...FEET_BUTTERFLY.L, x: FEET_BUTTERFLY.L.x + s * 0.05 },
|
||||
R: { ...FEET_BUTTERFLY.R, x: FEET_BUTTERFLY.R.x + s * 0.05 },
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Lateral shuffle: ready upper body, feet shift toward the push side.
|
||||
*/
|
||||
export function poseShuffle(P, { dir = 1, effort = 0.6, t = 0 } = {}) {
|
||||
const d = dir >= 0 ? 1 : -1;
|
||||
const e = clamp(effort, 0, 1);
|
||||
poseReady(P, { lean: d * 0.45 * e, t });
|
||||
|
||||
E(P.q.pelvis, 0.14, d * 0.12 * e, -d * 0.18 * e);
|
||||
E(P.q.spine1, 0.12, -d * 0.08 * e, -d * 0.1 * e);
|
||||
|
||||
// Lead foot steps out; trail foot loads under the hip.
|
||||
const lead = d > 0 ? 'R' : 'L'; // dir +1 = toward −X = right foot leads
|
||||
const trail = lead === 'L' ? 'R' : 'L';
|
||||
P.feet = {
|
||||
L: { ...FEET_READY.L },
|
||||
R: { ...FEET_READY.R },
|
||||
};
|
||||
P.feet[lead].x += d > 0 ? -0.12 * e : 0.12 * e;
|
||||
P.feet[lead].z += 0.04 * e;
|
||||
P.feet[trail].x += d > 0 ? 0.06 * e : -0.06 * e;
|
||||
|
||||
P.rootOffset.set(d * 0.06 * e, -0.22, 0.03);
|
||||
E(P.rootQuat, 0.08, 0, -d * 0.12 * e);
|
||||
}
|
||||
|
||||
/**
|
||||
* High save reach. Feet stay in ready; one arm drives up.
|
||||
*/
|
||||
export function poseReach(P, { side = -1, up = 0.7, lean = 0, t = 0 } = {}) {
|
||||
poseReady(P, { lean, t });
|
||||
const u = clamp(up, 0, 1);
|
||||
|
||||
if (side < 0) {
|
||||
E(P.q.clavicleL, -0.1 * u, 0.18 * u, -0.14 * u);
|
||||
E(P.q.upperArmL, -0.4 + 1.15 * u, 0.65 + 0.25 * u, -0.65 - 0.35 * u);
|
||||
E(P.q.forearmL, -1.05 + 0.65 * u, -0.15, 0.25);
|
||||
E(P.q.handL, -0.1, 0.4, 0.5);
|
||||
E(P.q.spine2, 0.1 - 0.06 * u, 0.1 * u, 0.05 * u);
|
||||
} else {
|
||||
E(P.q.clavicleR, -0.1 * u, -0.18 * u, 0.14 * u);
|
||||
E(P.q.upperArmR, -0.85 + 1.25 * u, -0.3 - 0.3 * u, 0.4 + 0.3 * u);
|
||||
E(P.q.forearmR, -0.7 + 0.5 * u, 0.12, 0.08);
|
||||
E(P.q.handR, -0.15, 0.12, -0.12);
|
||||
E(P.q.spine2, 0.1 - 0.06 * u, -0.1 * u, -0.05 * u);
|
||||
}
|
||||
|
||||
P.rootOffset.y = -0.22 - 0.03 * u;
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
import { E } from '../../core/math.js';
|
||||
import { clamp, lerp } from '../../../shared/scalar.js';
|
||||
|
||||
/**
|
||||
* Upper-body authoring for skating.
|
||||
*
|
||||
* Split out from the animator for the same reason Ludus splits its stance
|
||||
* poses: the runtime concerns (foot path, IK, blending) are fiddly and stable,
|
||||
* while these numbers are pure feel and get tuned constantly.
|
||||
*
|
||||
* Everything keys off four scalars the sim already produces:
|
||||
* gait 0..1 how much of a stride is being thrown (from effort + speed)
|
||||
* speed m/s planar
|
||||
* bank rad lean into the current turn, signed (+ = turning right)
|
||||
* phase 0..1 stride cycle position
|
||||
*/
|
||||
|
||||
export const SKATE_POSE = {
|
||||
/** Knee bend at a standstill and at a full stride, in metres of root drop. */
|
||||
crouchIdle: 0.1,
|
||||
crouchStride: 0.26,
|
||||
/**
|
||||
* Forward pitch, radians, at a standstill and at speed.
|
||||
*
|
||||
* This is the *root* pitch; the spine adds roughly another half of it on top
|
||||
* as it stacks up the chain, so the finished torso angle is around 1.5x these
|
||||
* numbers. Authoring the final angle here instead would mean re-tuning every
|
||||
* time a spine joint changed.
|
||||
*/
|
||||
leanIdle: 0.08,
|
||||
leanFast: 0.3,
|
||||
/** How much of the bank the torso takes; the rest is absorbed by the legs. */
|
||||
bankTorso: 0.7,
|
||||
/** Head stays closer to level than the body — a skater looks up the ice. */
|
||||
bankHeadCounter: 0.55,
|
||||
/** Arm swing amplitude, radians, at a full stride. */
|
||||
armSwing: 0.72,
|
||||
/** Elbow bend: skaters carry their hands, they don't run with straight arms. */
|
||||
elbow: -0.62,
|
||||
/** Roll that pulls the arms in from the skeleton's rest A-pose. */
|
||||
armTuck: 0.34,
|
||||
/** Hip / shoulder counter-rotation with the stride. */
|
||||
hipTwist: 0.2,
|
||||
shoulderTwist: 0.26,
|
||||
};
|
||||
|
||||
/**
|
||||
* The moving pose: crouched, pitched forward, twisting against the stride.
|
||||
*
|
||||
* `P` is the animator's pose buffer — quaternions per bone plus a root offset.
|
||||
* Foot targets are not written here; they are world-space and belong to the
|
||||
* stepper.
|
||||
*/
|
||||
export function poseSkate(P, { gait, speed, bank, phase, t }) {
|
||||
const K = SKATE_POSE;
|
||||
const fast = clamp(speed / 7, 0, 1);
|
||||
const s1 = Math.sin(phase * Math.PI * 2);
|
||||
const s2 = Math.sin(phase * Math.PI * 4);
|
||||
// Idle breathing, so a stopped skater is not a statue.
|
||||
const idle = (1 - gait) * Math.sin(t * 1.6) * 0.02;
|
||||
|
||||
const crouch = lerp(K.crouchIdle, K.crouchStride, gait) + idle;
|
||||
const pitch = lerp(K.leanIdle, K.leanFast, fast);
|
||||
const twist = K.hipTwist * gait;
|
||||
|
||||
// Pelvis rocks with the push — the hip on the pushing side drops and rotates
|
||||
// open, which is most of what makes a stride read as a stride and not a run.
|
||||
E(P.q.pelvis, pitch * 0.18, twist * s1, -bank * 0.25 + gait * 0.05 * s1);
|
||||
E(P.q.spine1, pitch * 0.3, -twist * 0.35 * s1, -bank * K.bankTorso * 0.3);
|
||||
E(P.q.spine2, pitch * 0.3, -twist * 0.45 * s1, -bank * K.bankTorso * 0.35);
|
||||
E(P.q.spine3, pitch * 0.22 + idle, -K.shoulderTwist * gait * s1, -bank * K.bankTorso * 0.25);
|
||||
// Neck and head pull back up: the torso is folded forward, the eyes are not.
|
||||
E(P.q.neck, -pitch * 0.5, 0, bank * K.bankHeadCounter * 0.4);
|
||||
E(P.q.head, -pitch * 0.42, K.shoulderTwist * 0.3 * gait * s1, bank * K.bankHeadCounter * 0.6);
|
||||
|
||||
// Arms swing opposite the legs and slightly across the chest. Amplitude is
|
||||
// pure gait: a gliding skater's hands barely move.
|
||||
// The rest skeleton is an A-pose, so the arms already sit ~30° off the body.
|
||||
// Roll about local Z is what brings them in, and its sign is mirrored: the
|
||||
// left arm tucks on negative Z, the right on positive. Getting that backwards
|
||||
// is what turns a skater into a scarecrow, so it is written as `-m` once here
|
||||
// rather than as a per-side constant.
|
||||
const swing = K.armSwing * gait;
|
||||
for (const side of ['L', 'R']) {
|
||||
const m = side === 'L' ? 1 : -1;
|
||||
const armPhase = side === 'L' ? s1 : -s1;
|
||||
E(P.q[`clavicle${side}`], 0.04, 0, -m * (0.04 + 0.05 * gait));
|
||||
E(
|
||||
P.q[`upperArm${side}`],
|
||||
// Shoulders sit forward of the ribs at speed, hands ahead of the chest.
|
||||
-0.45 - 0.35 * fast + swing * armPhase,
|
||||
m * (0.1 + 0.12 * gait),
|
||||
-m * K.armTuck,
|
||||
);
|
||||
E(P.q[`forearm${side}`], K.elbow - 0.25 * gait - Math.abs(armPhase) * 0.12 * gait, 0, -m * 0.1);
|
||||
E(P.q[`hand${side}`], -0.1, 0, -m * 0.06);
|
||||
}
|
||||
|
||||
// Vertical bob is small and at twice the stride rate: the body rises over
|
||||
// each push, not once per cycle.
|
||||
P.rootOffset.set(-bank * 0.06, -crouch + gait * 0.018 * s2, gait * 0.02);
|
||||
E(P.rootQuat, pitch, 0, -bank);
|
||||
}
|
||||
|
||||
/**
|
||||
* Hockey stop: both blades thrown across the direction of travel, weight
|
||||
* dropped hard onto them, shoulders squared back up the ice.
|
||||
*
|
||||
* `dir` is +1 or -1 for which shoulder leads, so a stop has a side to it.
|
||||
*/
|
||||
export function poseStop(P, { speed, dir, t }) {
|
||||
const bite = clamp(speed / 6, 0.25, 1);
|
||||
const shake = Math.sin(t * 22) * 0.012 * bite;
|
||||
|
||||
E(P.q.pelvis, 0.12, dir * 0.55 * bite, dir * 0.18 * bite);
|
||||
E(P.q.spine1, 0.16 + shake, -dir * 0.18 * bite, -dir * 0.12 * bite);
|
||||
E(P.q.spine2, 0.16 + shake, -dir * 0.2 * bite, -dir * 0.14 * bite);
|
||||
E(P.q.spine3, 0.1, -dir * 0.16 * bite, -dir * 0.1 * bite);
|
||||
E(P.q.neck, -0.24, -dir * 0.2 * bite, 0);
|
||||
E(P.q.head, -0.18, -dir * 0.24 * bite, 0);
|
||||
|
||||
for (const side of ['L', 'R']) {
|
||||
const m = side === 'L' ? 1 : -1;
|
||||
// Hands come out for balance against the deceleration — the one pose where
|
||||
// the arms should leave the body, so the tuck roll relaxes toward zero.
|
||||
E(P.q[`clavicle${side}`], 0, 0, -m * 0.04);
|
||||
E(P.q[`upperArm${side}`], -0.72 * bite, m * 0.16, -m * (0.3 - 0.28 * bite));
|
||||
E(P.q[`forearm${side}`], -0.5 - 0.3 * bite, 0, -m * 0.12);
|
||||
E(P.q[`hand${side}`], -0.12, 0, 0);
|
||||
}
|
||||
|
||||
// Deep sit into the stop, hips back over the heels.
|
||||
P.rootOffset.set(dir * 0.05 * bite, -(0.2 + 0.12 * bite), -0.06 * bite);
|
||||
E(P.rootQuat, 0.12, 0, dir * 0.28 * bite);
|
||||
}
|
||||
@@ -0,0 +1,223 @@
|
||||
import { E } from '../../core/math.js';
|
||||
import { clamp, lerp } from '../../../shared/scalar.js';
|
||||
|
||||
/**
|
||||
* Upper-body authoring for everything done with the stick.
|
||||
*
|
||||
* These are *override* poses, not whole-body states. They write the arms and
|
||||
* some spine, and the animator blends them over the skating pose by a weight —
|
||||
* because you keep skating while you shoot, and a shot that stopped the legs
|
||||
* would read as a cutscene.
|
||||
*
|
||||
* Each one is a function of a single phase 0..1 so the animator can drive it
|
||||
* from a timer, hold it (wind-up), or run it once and blend out (shoot, pass,
|
||||
* poke). The right arm carries the stick; the left joins it for two-handed
|
||||
* work and is pinned onto the shaft by IK afterwards, so what is authored here
|
||||
* for the left side is only a starting guess that the IK refines.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Bones the stickwork layer *replaces*. The arms belong to the stick whenever
|
||||
* it is being used — there is no meaningful blend between "swinging with the
|
||||
* stride" and "holding a stick", they are different arms.
|
||||
*/
|
||||
export const STICK_ARMS = [
|
||||
'clavicleR', 'upperArmR', 'forearmR', 'handR',
|
||||
'clavicleL', 'upperArmL', 'forearmL', 'handL',
|
||||
];
|
||||
|
||||
/**
|
||||
* Bones the layer *adds to*. The spine is already carrying the skating lean and
|
||||
* the bank; a shot's coil is a twist on top of that, not instead of it.
|
||||
* Replacing these was what flattened the forward lean the moment a stick
|
||||
* appeared, and stood everybody up.
|
||||
*/
|
||||
export const STICK_SPINE = ['spine1', 'spine2', 'spine3', 'neck', 'head'];
|
||||
|
||||
export const STICK_BONES = STICK_ARMS.concat(STICK_SPINE);
|
||||
|
||||
/**
|
||||
* The neutral carry, and the hustle variant.
|
||||
*
|
||||
* `hustle` 0..1 slides between two-hands-ready and the one-handed dangle a
|
||||
* skater falls into when they are just trying to move: the stick goes out in
|
||||
* front, the left arm leaves it and swings with the stride.
|
||||
*
|
||||
* Carry is authored from the motion-reference sheet (ready stance / puck carry):
|
||||
* both hands in front of the torso, shaft angled down to the ice, blade a
|
||||
* little to the forehand side — not parked out on the hip with the off-hand
|
||||
* floating. The right arm has to sit close enough that the left can actually
|
||||
* reach the shaft: the arm is only ~0.54 m long, so a top hand 40 cm off
|
||||
* centre puts the stick out of reach no matter what the IK does.
|
||||
*/
|
||||
export function poseCarry(P, { hustle = 0, reach = 0, lateral = 0 }) {
|
||||
const h = clamp(hustle, 0, 1);
|
||||
// Skill Stick +X is "push right"; bone +X is the skater's left. Negate so
|
||||
// the arms lean the same way the blade goes.
|
||||
const side = -lateral;
|
||||
|
||||
// Right arm: top hand. Across the body and out in front at about waist /
|
||||
// lower-chest height. Hustle extends it forward and frees the left side.
|
||||
// Roll signs are mirrored: right arm tucks on *positive* Z, left on negative.
|
||||
E(P.q.clavicleR, 0.03, lerp(-0.04, -0.1, h), 0.06);
|
||||
E(
|
||||
P.q.upperArmR,
|
||||
lerp(-0.42, -0.7, h) + reach * 0.2,
|
||||
lerp(0.42, 0.05, h) + side * 0.28,
|
||||
lerp(0.68, 0.38, h),
|
||||
);
|
||||
E(
|
||||
P.q.forearmR,
|
||||
lerp(-1.35, -0.75, h) - reach * 0.15,
|
||||
lerp(0.02, 0.12, h),
|
||||
lerp(0.32, 0.16, h),
|
||||
);
|
||||
E(P.q.handR, lerp(-0.12, -0.08, h), lerp(0.12, 0.04, h), lerp(0.04, -0.12, h));
|
||||
|
||||
// Left arm: lower hand on the shaft when settled. Seeded near the stick so
|
||||
// the IK only has to finish the last few centimetres, not haul it across the
|
||||
// body. At full hustle it leaves the stick and opens for the stride swing.
|
||||
E(P.q.clavicleL, 0.03, lerp(0.06, 0.02, h), lerp(-0.06, -0.02, h));
|
||||
E(
|
||||
P.q.upperArmL,
|
||||
lerp(-0.38, -0.66, h) + reach * 0.12,
|
||||
lerp(0.1, 0.16, h) + side * 0.18,
|
||||
lerp(-0.48, -0.2, h),
|
||||
);
|
||||
E(
|
||||
P.q.forearmL,
|
||||
lerp(-1.32, -0.72, h),
|
||||
lerp(-0.08, 0, h),
|
||||
lerp(0.18, 0.08, h),
|
||||
);
|
||||
E(P.q.handL, -0.1, 0, 0.08 * (1 - h));
|
||||
|
||||
// Soft coil over the stick when both hands are on it; opens up when hustling.
|
||||
E(P.q.spine1, 0.02 * h, lerp(-0.04, 0.02, h) + side * 0.05, 0);
|
||||
E(P.q.spine2, 0.02 * h, lerp(-0.05, 0.02, h) + side * 0.05, 0);
|
||||
E(P.q.spine3, 0.02, lerp(-0.04, 0, h), 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Wind-up. `phase` 0..1 is how loaded the shot is, and it is *held* — the
|
||||
* animator parks here for as long as the Skill Stick is pulled back.
|
||||
*
|
||||
* Hands high and back, stick raised behind the head — not hanging blade-down
|
||||
* from waist height. The torso coils open so the follow-through has something
|
||||
* to spend.
|
||||
*/
|
||||
export function poseWindup(P, { phase = 0, aim = 0 }) {
|
||||
const w = clamp(phase, 0, 1);
|
||||
// Aim on the Skill Stick is "push right"; bone +Y twist toward the skater's
|
||||
// left is the opposite sign.
|
||||
const side = -aim;
|
||||
|
||||
// Torso coils open, loading the shot side.
|
||||
E(P.q.spine1, -0.06 - 0.08 * w, -0.18 - 0.42 * w + side * 0.08, -0.05 * w);
|
||||
E(P.q.spine2, -0.07 - 0.1 * w, -0.22 - 0.48 * w + side * 0.1, -0.06 * w);
|
||||
E(P.q.spine3, -0.04 - 0.07 * w, -0.18 - 0.38 * w + side * 0.08, -0.04 * w);
|
||||
// Eyes stay on the target while the body turns away from it.
|
||||
E(P.q.neck, 0.04, 0.28 + 0.42 * w - side * 0.2, 0);
|
||||
E(P.q.head, 0.04, 0.22 + 0.32 * w - side * 0.25, 0);
|
||||
|
||||
// Top hand: high and back, roughly shoulder/head height, so the aimed stick
|
||||
// can sit up behind the head instead of dangling at the hip.
|
||||
E(P.q.clavicleR, -0.1 * w, -0.22 * w, -0.1);
|
||||
E(P.q.upperArmR, 0.15 + 0.65 * w, -0.55 - 0.35 * w + side * 0.15, -0.55 - 0.35 * w);
|
||||
E(P.q.forearmR, -0.45 - 0.25 * w, 0.22, -0.12);
|
||||
E(P.q.handR, -0.05, 0.2, 0.22);
|
||||
|
||||
// Lower hand comes up with it; IK pins it to the shaft.
|
||||
E(P.q.clavicleL, 0.04, 0.12 * w, 0.08);
|
||||
E(P.q.upperArmL, -0.35 - 0.1 * w, 0.45 + 0.2 * w, 0.4 + 0.15 * w);
|
||||
E(P.q.forearmL, -0.85 - 0.15 * w, -0.18, -0.12);
|
||||
E(P.q.handL, -0.08, 0, -0.1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Follow-through. `phase` 0..1 runs once, fast.
|
||||
*
|
||||
* The coil released: the torso whips through the shot, the stick sweeps across
|
||||
* and finishes high. Front-loaded easing, so the contact reads at the start of
|
||||
* the animation rather than in the middle of it.
|
||||
*/
|
||||
export function poseShot(P, { phase = 0, power = 1, aim = 0 }) {
|
||||
const t = clamp(phase, 0, 1);
|
||||
// Fast out of the coil, then settle.
|
||||
const s = 1 - (1 - t) * (1 - t);
|
||||
const p = clamp(power, 0.2, 1);
|
||||
|
||||
const twist = lerp(-0.42 * p, 0.44 * p, s);
|
||||
E(P.q.spine1, -0.06 + 0.12 * s, twist * 0.9, 0.04 * s);
|
||||
E(P.q.spine2, -0.07 + 0.14 * s, twist, 0.05 * s);
|
||||
E(P.q.spine3, -0.05 + 0.1 * s, twist * 0.8, 0.03 * s);
|
||||
E(P.q.neck, 0.02, -twist * 0.5 + aim * 0.2, 0);
|
||||
E(P.q.head, 0.02, -twist * 0.4 + aim * 0.25, 0);
|
||||
|
||||
// Top hand drives through and finishes high across the body.
|
||||
E(P.q.clavicleR, lerp(-0.05, 0.04, s), lerp(-0.14, 0.1, s), -0.06);
|
||||
E(P.q.upperArmR, lerp(0.3, -1.05 * p, s), lerp(-0.94, 0.3, s), lerp(-0.72, -0.1, s));
|
||||
E(P.q.forearmR, lerp(-1.12, -0.42, s), 0.16, -0.1);
|
||||
E(P.q.handR, -0.1, 0.1, 0.16);
|
||||
|
||||
E(P.q.clavicleL, 0.03, lerp(0.1, -0.04, s), 0.06);
|
||||
E(P.q.upperArmL, lerp(-0.86, -0.3, s), lerp(0.66, 0.12, s), lerp(0.4, 0.5, s));
|
||||
E(P.q.forearmL, lerp(-1.36, -0.6, s), -0.28, -0.2);
|
||||
E(P.q.handL, -0.08, 0, -0.14);
|
||||
}
|
||||
|
||||
/**
|
||||
* Pass: a flat sweep, no coil and no lift. Shorter and lower than a shot,
|
||||
* because a pass that looks like a shot makes the two impossible to read apart
|
||||
* at a glance — which matters more for a teammate watching than for the passer.
|
||||
*/
|
||||
export function posePass(P, { phase = 0, aim = 0 }) {
|
||||
const t = clamp(phase, 0, 1);
|
||||
const s = Math.sin(t * Math.PI); // out and back
|
||||
const sweep = lerp(-0.18, 0.34, 1 - (1 - t) * (1 - t));
|
||||
|
||||
E(P.q.spine1, 0.03 * s, sweep * 0.6, 0);
|
||||
E(P.q.spine2, 0.04 * s, sweep * 0.7, 0);
|
||||
E(P.q.spine3, 0.03 * s, sweep * 0.5, 0);
|
||||
E(P.q.neck, 0, -sweep * 0.4 + aim * 0.2, 0);
|
||||
E(P.q.head, 0, -sweep * 0.3 + aim * 0.2, 0);
|
||||
|
||||
E(P.q.clavicleR, 0.02, -0.04, -0.05);
|
||||
E(P.q.upperArmR, -0.34 - 0.3 * s, -0.34 + sweep * 0.5, -0.4 - 0.12 * s);
|
||||
E(P.q.forearmR, -0.72 - 0.24 * s, 0.12, -0.12);
|
||||
E(P.q.handR, -0.12, 0.06, 0.18);
|
||||
|
||||
E(P.q.clavicleL, 0.02, 0.05, 0.05);
|
||||
E(P.q.upperArmL, -0.58 - 0.18 * s, 0.36 + sweep * 0.3, 0.3);
|
||||
E(P.q.forearmL, -1.06 - 0.16 * s, -0.24, -0.18);
|
||||
E(P.q.handL, -0.1, 0, -0.12);
|
||||
}
|
||||
|
||||
/**
|
||||
* Poke check: a stab. One hand, the whole arm extending forward with the body
|
||||
* reaching after it, back almost as fast as it went out.
|
||||
*/
|
||||
export function posePoke(P, { phase = 0 }) {
|
||||
const t = clamp(phase, 0, 1);
|
||||
// Out fast, back slower.
|
||||
const s = t < 0.35 ? t / 0.35 : 1 - (t - 0.35) / 0.65;
|
||||
const jab = clamp(s, 0, 1);
|
||||
|
||||
E(P.q.spine1, 0.06 * jab, -0.14 * jab, 0);
|
||||
E(P.q.spine2, 0.07 * jab, -0.18 * jab, 0);
|
||||
E(P.q.spine3, 0.05 * jab, -0.14 * jab, 0);
|
||||
E(P.q.neck, -0.04 * jab, 0.1 * jab, 0);
|
||||
E(P.q.head, -0.04 * jab, 0.1 * jab, 0);
|
||||
|
||||
// Right arm thrusts out and down toward the ice.
|
||||
E(P.q.clavicleR, 0.02 + 0.06 * jab, -0.06 - 0.16 * jab, -0.05);
|
||||
E(P.q.upperArmR, -0.34 - 0.5 * jab, -0.28 - 0.12 * jab, -0.36 + 0.14 * jab);
|
||||
E(P.q.forearmR, -0.78 + 0.66 * jab, 0.1, -0.12);
|
||||
E(P.q.handR, -0.12, 0.06, 0.18);
|
||||
|
||||
// Left arm comes off the stick and back for balance.
|
||||
E(P.q.clavicleL, 0.02, 0.04, 0.04);
|
||||
E(P.q.upperArmL, -0.5 + 0.2 * jab, 0.28 - 0.2 * jab, 0.34 + 0.16 * jab);
|
||||
E(P.q.forearmL, -0.9 + 0.3 * jab, -0.16, -0.14);
|
||||
E(P.q.handL, -0.1, 0, -0.1);
|
||||
}
|
||||
@@ -0,0 +1,674 @@
|
||||
import * as THREE from 'three';
|
||||
import { E, clamp, segDist, smooth } from '../core/math.js';
|
||||
import { lerp, lerpAngle } from '../../shared/scalar.js';
|
||||
import { poseSkate, poseStop } from './poses/skate.js';
|
||||
import {
|
||||
STICK_ARMS, STICK_BONES, STICK_SPINE,
|
||||
poseCarry, posePass, posePoke, poseShot, poseWindup,
|
||||
} from './poses/stickwork.js';
|
||||
import { STICK } from '../character/stick.js';
|
||||
|
||||
/**
|
||||
* Skating animator.
|
||||
*
|
||||
* Same architecture as the Ludus fighter animator — a pose buffer that states
|
||||
* write into, crossfaded on state changes, with two-bone analytic leg IK
|
||||
* resolving world-space foot targets — with two deliberate differences.
|
||||
*
|
||||
* 1. It does not integrate movement. In Ludus the animator owned the fighter's
|
||||
* position; here the sim plus the Box3D proxy own it, and the animator is
|
||||
* told where the body ended up (`setTransform`). Anything else would have
|
||||
* the pose fighting the collision response.
|
||||
*
|
||||
* 2. The feet are authored in *mover-local* space rather than planted in world
|
||||
* space. That is not a shortcut: a walking foot is stationary while it bears
|
||||
* weight, but a skate is gliding the entire time, including through the
|
||||
* push. Planting it would be the thing that made this read as running on
|
||||
* ice, which is exactly the failure mode we are trying to avoid.
|
||||
*
|
||||
* States exist so the next spike can add `shoot` / `stickhandle` and get the
|
||||
* crossfade for free. Today there are two: `skate` and `stop`.
|
||||
*/
|
||||
|
||||
/** How far the Skill Stick can push the blade around the carrier, metres. */
|
||||
const STICK_REACH = { side: 0.5, fwd: 0.34 };
|
||||
|
||||
/** Foot joint height above the ice — boot plus blade. */
|
||||
const FOOT_SOLE = 0.085;
|
||||
|
||||
const STRIDE = {
|
||||
/** Fraction of the cycle the leg spends pushing rather than recovering. */
|
||||
pushFrac: 0.55,
|
||||
/** Half the width of a neutral glide stance, metres. */
|
||||
narrow: 0.105,
|
||||
/** How far out to the side a full push extends the blade. */
|
||||
reachSide: 0.3,
|
||||
/** Fore/aft travel of the blade through a push. */
|
||||
reachFwd: 0.16,
|
||||
reachAft: 0.26,
|
||||
/** Blade clearance on the recovery. Skates barely leave the ice. */
|
||||
lift: 0.07,
|
||||
/** Toe flare — the V a skater's blades make as the leg extends. */
|
||||
toeOut: 0.55,
|
||||
toeGlide: 0.12,
|
||||
/** Stride cycle at a standstill and at top speed, seconds. */
|
||||
cycleSlow: 1.15,
|
||||
cycleFast: 0.6,
|
||||
};
|
||||
|
||||
export function buildAnimator(skelData, mover) {
|
||||
const B = skelData.bones;
|
||||
const LEN = { thigh: B.shinL.position.length(), shin: B.footL.position.length() };
|
||||
const restThighDir = { L: B.shinL.position.clone().normalize(), R: B.shinR.position.clone().normalize() };
|
||||
const restShinDir = { L: B.footL.position.clone().normalize(), R: B.footR.position.clone().normalize() };
|
||||
|
||||
const UPPER = [
|
||||
'pelvis', 'spine1', 'spine2', 'spine3', 'neck', 'head',
|
||||
'clavicleL', 'upperArmL', 'forearmL', 'handL',
|
||||
'clavicleR', 'upperArmR', 'forearmR', 'handR',
|
||||
];
|
||||
const LEGS = ['thighL', 'shinL', 'footL', 'toeL', 'thighR', 'shinR', 'footR', 'toeR'];
|
||||
|
||||
function newPose() {
|
||||
const p = {
|
||||
q: {},
|
||||
rootOffset: new THREE.Vector3(),
|
||||
rootQuat: new THREE.Quaternion(),
|
||||
foot: { L: { pos: new THREE.Vector3(), yaw: 0 }, R: { pos: new THREE.Vector3(), yaw: 0 } },
|
||||
};
|
||||
for (const n of UPPER.concat(LEGS)) p.q[n] = new THREE.Quaternion();
|
||||
return p;
|
||||
}
|
||||
const cur = newPose();
|
||||
const frozen = newPose();
|
||||
|
||||
const anim = {
|
||||
state: 'skate',
|
||||
blend: 1,
|
||||
BLEND_TIME: 0.22,
|
||||
transitionTime: 0.22,
|
||||
time: 0,
|
||||
stateTime: 0,
|
||||
/** Playback rate, for slow motion later. */
|
||||
speed: 1,
|
||||
|
||||
// ---- written by the rig each frame, read by the poses -----------------
|
||||
origin: new THREE.Vector3(),
|
||||
originYaw: 0,
|
||||
/** Planar speed, m/s. */
|
||||
moveSpeed: 0,
|
||||
/** Signed speed along the blade — negative means gliding backwards. */
|
||||
bladeSpeed: 0,
|
||||
/** How hard the skater is pushing, 0..1, straight off the sim. */
|
||||
effort: 0,
|
||||
/** Rate the velocity vector is turning, rad/s. Drives the bank. */
|
||||
yawRate: 0,
|
||||
braking: false,
|
||||
|
||||
// ---- derived, smoothed --------------------------------------------------
|
||||
/** Stride amplitude, 0 (pure glide) .. 1 (digging in). */
|
||||
gait: 0,
|
||||
/** Lean into the turn, radians. Signed: positive is turning right. */
|
||||
bank: 0,
|
||||
stridePhase: 0,
|
||||
/** Which shoulder leads a hockey stop; latched when the stop starts. */
|
||||
stopDir: 1,
|
||||
/** Called on each blade bite, for ice spray and audio later. */
|
||||
onStride: null,
|
||||
|
||||
// ---- stickwork ---------------------------------------------------------
|
||||
/** True while this skater has the puck. Decides the resting grip. */
|
||||
hasPuck: false,
|
||||
/** Skill Stick, -1..1. Moves the hands, which moves the blade. */
|
||||
handling: { x: 0, y: 0 },
|
||||
/** Held wind-up charge from the Skill Stick, 0..1. */
|
||||
charge: 0,
|
||||
/** The stick, so the animator can drive its socket and IK onto its shaft. */
|
||||
stick: null,
|
||||
/**
|
||||
* Current stick action: null, 'windup', 'shoot', 'pass' or 'poke'.
|
||||
* Wind-up is held; the other three run once and blend out.
|
||||
*/
|
||||
action: null,
|
||||
actionTime: 0,
|
||||
actionPower: 1,
|
||||
actionAim: 0,
|
||||
/** Eased 0..1 between the settled grip and the one-handed dangle. */
|
||||
hustleGrip: 0,
|
||||
};
|
||||
|
||||
/** How long each one-shot action runs, seconds. */
|
||||
const ACTION_TIME = { shoot: 0.42, pass: 0.3, poke: 0.34 };
|
||||
/** Seconds to blend the override in and out over the skating pose. */
|
||||
const ACTION_BLEND = 0.09;
|
||||
|
||||
/** Scratch pose the action layer writes into before being blended over. */
|
||||
const overlay = newPose();
|
||||
const _actionSpine = new THREE.Quaternion();
|
||||
|
||||
const _localFoot = new THREE.Vector3();
|
||||
|
||||
function applyMover() {
|
||||
mover.position.copy(anim.origin);
|
||||
mover.rotation.set(0, anim.originYaw, 0);
|
||||
}
|
||||
|
||||
/** Place the skater. Position and yaw come from the sim, never from here. */
|
||||
anim.setTransform = function setTransform(position, yaw) {
|
||||
anim.origin.copy(position);
|
||||
anim.originYaw = yaw;
|
||||
};
|
||||
|
||||
/**
|
||||
* Mover-local foot target for one leg at cycle position `p`.
|
||||
*
|
||||
* The path is a flattened loop: out and back through the push, then in and
|
||||
* forward through the recovery. Scaling the whole thing by `amp` means a
|
||||
* glide collapses it to a pair of feet sitting under the hips, with no
|
||||
* separate "glide" authoring to keep in sync.
|
||||
*/
|
||||
function strideLocal(side, p, amp, out) {
|
||||
const sign = side === 'L' ? 1 : -1;
|
||||
const S = STRIDE;
|
||||
let x;
|
||||
let z;
|
||||
let y;
|
||||
let toe;
|
||||
if (p < S.pushFrac) {
|
||||
const u = smooth(p / S.pushFrac);
|
||||
x = sign * (S.narrow + S.reachSide * amp * u);
|
||||
z = lerp(S.reachFwd * amp, -S.reachAft * amp, u);
|
||||
y = 0;
|
||||
toe = sign * (S.toeGlide + S.toeOut * amp * u);
|
||||
} else {
|
||||
const u = smooth((p - S.pushFrac) / (1 - S.pushFrac));
|
||||
x = sign * lerp(S.narrow + S.reachSide * amp, S.narrow * 0.8, u);
|
||||
z = lerp(-S.reachAft * amp, S.reachFwd * amp, u);
|
||||
y = S.lift * amp * Math.sin(Math.PI * u);
|
||||
toe = sign * lerp(S.toeGlide + S.toeOut * amp, S.toeGlide, u);
|
||||
}
|
||||
out.set(x, FOOT_SOLE + y, z);
|
||||
return toe;
|
||||
}
|
||||
|
||||
/** Local foot placement for a hockey stop: blades thrown across the travel. */
|
||||
function stopLocal(side, dir, bite, out) {
|
||||
const lead = side === 'L' ? 1 : -1;
|
||||
out.set(
|
||||
dir * (0.06 + 0.12 * bite) * (side === 'L' ? 1 : 0.4),
|
||||
FOOT_SOLE,
|
||||
lead * (0.19 + 0.06 * bite),
|
||||
);
|
||||
return dir * (0.3 + 0.9 * bite);
|
||||
}
|
||||
|
||||
const _worldFoot = new THREE.Vector3();
|
||||
/** Write a local foot target into the pose buffer as a world-space target. */
|
||||
function writeFoot(P, side, local, toeYaw) {
|
||||
_worldFoot.copy(local).applyMatrix4(mover.matrixWorld);
|
||||
// The ice is flat, so the sole height authored locally is the world height;
|
||||
// re-pin anyway so a future heightfield only has to change this line.
|
||||
_worldFoot.y = local.y;
|
||||
P.foot[side].pos.copy(_worldFoot);
|
||||
P.foot[side].yaw = anim.originYaw + toeYaw;
|
||||
}
|
||||
|
||||
/**
|
||||
* Advance the derived, smoothed values every state shares.
|
||||
*
|
||||
* Smoothing lives here rather than in the sim because these are presentation
|
||||
* quantities: the sim's `effort` is allowed to change instantly when the AI
|
||||
* changes its mind, but a skater's legs cannot.
|
||||
*/
|
||||
function advanceCommon(dt) {
|
||||
// Gait chases effort quickly on the way up (a push starts now) and decays
|
||||
// slowly (the leg finishes its stroke).
|
||||
const target = clamp(anim.effort, 0, 1);
|
||||
const rate = target > anim.gait ? 5.5 : 2.2;
|
||||
anim.gait = lerp(anim.gait, target, Math.min(1, rate * dt));
|
||||
|
||||
// Bank: the lean that balances the centripetal force of the current turn.
|
||||
// atan(v·ω / g) is the real thing, and it behaves correctly at low speed —
|
||||
// spinning on the spot produces no lean, which is what you want.
|
||||
const bankTarget = clamp(
|
||||
Math.atan2(anim.moveSpeed * anim.yawRate, 9.81),
|
||||
-0.45,
|
||||
0.45,
|
||||
);
|
||||
anim.bank = lerp(anim.bank, bankTarget, Math.min(1, 6 * dt));
|
||||
|
||||
// Stride rate rises with speed; a standing skater shuffles slowly.
|
||||
const fast = clamp(anim.moveSpeed / 7.5, 0, 1);
|
||||
const cycle = lerp(STRIDE.cycleSlow, STRIDE.cycleFast, fast);
|
||||
const before = anim.stridePhase;
|
||||
// Only advance while there is a stride to throw, so a long glide holds the
|
||||
// legs where the last push left them instead of pedalling in mid-air.
|
||||
anim.stridePhase = (anim.stridePhase + (dt / cycle) * Math.max(anim.gait, 0.06)) % 1;
|
||||
// Blade bite: each leg starts its push half a cycle apart.
|
||||
if (anim.onStride) {
|
||||
if (before > anim.stridePhase) anim.onStride('L', anim.moveSpeed);
|
||||
else if (before < 0.5 && anim.stridePhase >= 0.5) anim.onStride('R', anim.moveSpeed);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Fire a one-shot stick action. Wind-up is started and stopped explicitly
|
||||
* instead, because it is held for as long as the stick is pulled back.
|
||||
*/
|
||||
anim.playAction = function playAction(name, { power = 1, aim = 0 } = {}) {
|
||||
anim.action = name;
|
||||
anim.actionTime = 0;
|
||||
anim.actionPower = power;
|
||||
anim.actionAim = aim;
|
||||
};
|
||||
|
||||
/**
|
||||
* Advance the stick action clock and write the override pose.
|
||||
*
|
||||
* Returns the blend weight, 0 when nothing is happening. Kept separate from
|
||||
* the states because these are *layers*: a skater keeps striding through a
|
||||
* shot, so the action owns the arms and some spine and nothing else.
|
||||
*/
|
||||
function advanceAction(dt) {
|
||||
if (!anim.action) return 0;
|
||||
anim.actionTime += dt;
|
||||
|
||||
if (anim.action === 'windup') {
|
||||
// Held. Blends in over ACTION_BLEND and then stays until released.
|
||||
const w = Math.min(1, anim.actionTime / ACTION_BLEND);
|
||||
poseWindup(overlay, { phase: anim.charge, aim: anim.actionAim });
|
||||
return w;
|
||||
}
|
||||
|
||||
const duration = ACTION_TIME[anim.action] ?? 0.3;
|
||||
const t = anim.actionTime / duration;
|
||||
if (t >= 1) {
|
||||
anim.action = null;
|
||||
return 0;
|
||||
}
|
||||
// Snap in, ease out — a shot should look like it started the instant the
|
||||
// button did, and a slow blend in front of it steals that.
|
||||
const w = t > 1 - ACTION_BLEND / duration
|
||||
? Math.max(0, (1 - t) * duration / ACTION_BLEND)
|
||||
: Math.min(1, anim.actionTime / (ACTION_BLEND * 0.5));
|
||||
|
||||
const args = { phase: t, power: anim.actionPower, aim: anim.actionAim };
|
||||
if (anim.action === 'shoot') poseShot(overlay, args);
|
||||
else if (anim.action === 'pass') posePass(overlay, args);
|
||||
else posePoke(overlay, args);
|
||||
return w;
|
||||
}
|
||||
|
||||
/** Which socket grip the stick should be using right now, and the blend. */
|
||||
function gripFor() {
|
||||
if (anim.action === 'windup') return ['carry', 'windup', Math.min(1, anim.actionTime / 0.16)];
|
||||
if (anim.action === 'shoot') {
|
||||
const t = anim.actionTime / (ACTION_TIME.shoot);
|
||||
return ['windup', 'follow', Math.min(1, t / 0.45)];
|
||||
}
|
||||
if (anim.action === 'poke') return ['carry', 'poke', Math.min(1, anim.actionTime / 0.1)];
|
||||
if (anim.action === 'pass') return ['carry', 'follow', Math.min(1, anim.actionTime / 0.2) * 0.5];
|
||||
// Resting: hustling pushes the stick out in front on one hand.
|
||||
return ['carry', 'hustle', anim.hustleGrip];
|
||||
}
|
||||
|
||||
const states = {
|
||||
skate: {
|
||||
pre(dt) {
|
||||
advanceCommon(dt);
|
||||
applyMover();
|
||||
mover.updateMatrixWorld(true);
|
||||
},
|
||||
pose(P, t) {
|
||||
poseSkate(P, {
|
||||
gait: anim.gait,
|
||||
speed: anim.moveSpeed,
|
||||
bank: anim.bank,
|
||||
phase: anim.stridePhase,
|
||||
t,
|
||||
});
|
||||
for (const side of ['L', 'R']) {
|
||||
const p = (anim.stridePhase + (side === 'R' ? 0.5 : 0)) % 1;
|
||||
const toe = strideLocal(side, p, anim.gait, _localFoot);
|
||||
writeFoot(P, side, _localFoot, toe);
|
||||
}
|
||||
},
|
||||
},
|
||||
|
||||
stop: {
|
||||
blendTime: 0.12,
|
||||
enter() {
|
||||
// Which way the skater turns to plant depends on which edge is already
|
||||
// loaded, so a stop out of a right-hand turn continues that rotation.
|
||||
anim.stopDir = anim.bank >= 0 ? 1 : -1;
|
||||
},
|
||||
pre(dt) {
|
||||
advanceCommon(dt);
|
||||
applyMover();
|
||||
mover.updateMatrixWorld(true);
|
||||
},
|
||||
pose(P, t) {
|
||||
poseStop(P, { speed: anim.moveSpeed, dir: anim.stopDir, t });
|
||||
const bite = clamp(anim.moveSpeed / 6, 0.25, 1);
|
||||
for (const side of ['L', 'R']) {
|
||||
const toe = stopLocal(side, anim.stopDir, bite, _localFoot);
|
||||
writeFoot(P, side, _localFoot, toe);
|
||||
}
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
function snapshot() {
|
||||
for (const n of UPPER.concat(LEGS)) frozen.q[n].copy(B[n].quaternion);
|
||||
frozen.rootOffset.copy(B.root.position);
|
||||
frozen.rootQuat.copy(B.root.quaternion);
|
||||
frozen.foot.L.pos.copy(cur.foot.L.pos);
|
||||
frozen.foot.L.yaw = cur.foot.L.yaw;
|
||||
frozen.foot.R.pos.copy(cur.foot.R.pos);
|
||||
frozen.foot.R.yaw = cur.foot.R.yaw;
|
||||
}
|
||||
|
||||
const _footWorld = new THREE.Vector3();
|
||||
|
||||
/**
|
||||
* Restart the crossfade from whatever pose the skeleton is currently in.
|
||||
*
|
||||
* Used when physics hands the skeleton back after a knockdown: the bones are
|
||||
* wherever the ragdoll left them, and the animator would otherwise snap to a
|
||||
* skating pose on the next frame. Snapshotting the collapsed pose and easing
|
||||
* out of it is the get-up.
|
||||
*/
|
||||
anim.rebase = function rebase(blendTime = 0.6) {
|
||||
snapshot();
|
||||
// `snapshot` takes the foot targets from `cur`, which for a skater who has
|
||||
// been lying on the ice still holds wherever their blades were before the
|
||||
// hit. Blending the IK out of a stale target drags the legs across the rink
|
||||
// to catch up. Read the feet where they actually are instead.
|
||||
mover.updateMatrixWorld(true);
|
||||
for (const side of ['L', 'R']) {
|
||||
B[`foot${side}`].getWorldPosition(_footWorld);
|
||||
frozen.foot[side].pos.copy(_footWorld);
|
||||
frozen.foot[side].yaw = anim.originYaw;
|
||||
}
|
||||
anim.blend = 0;
|
||||
anim.transitionTime = Math.max(0.05, blendTime);
|
||||
// The feet are wherever the body fell, not where the last stride put them,
|
||||
// so start the stride cycle from a planted stance rather than mid-push.
|
||||
anim.stridePhase = 0;
|
||||
anim.gait = 0;
|
||||
anim.bank = 0;
|
||||
};
|
||||
|
||||
anim.setState = function setState(name, blendTime = null) {
|
||||
if (name === anim.state || !states[name]) return;
|
||||
snapshot();
|
||||
anim.state = name;
|
||||
anim.stateTime = 0;
|
||||
anim.blend = 0;
|
||||
anim.transitionTime = blendTime ?? states[name].blendTime ?? anim.BLEND_TIME;
|
||||
if (states[name].enter) states[name].enter();
|
||||
};
|
||||
|
||||
// ---- two-bone analytic IK ------------------------------------------------
|
||||
// Lifted from Ludus unchanged. The knee pole is the one skating-specific
|
||||
// detail: it points forward and *outward*, because a skater's knees track
|
||||
// over the outside of the blade rather than straight ahead.
|
||||
const _H = new THREE.Vector3();
|
||||
const _d = new THREE.Vector3();
|
||||
const _pole = new THREE.Vector3();
|
||||
const _e2 = new THREE.Vector3();
|
||||
const _knee = new THREE.Vector3();
|
||||
const _dir = new THREE.Vector3();
|
||||
const _f = new THREE.Vector3();
|
||||
const _r = new THREE.Vector3();
|
||||
const _qP = new THREE.Quaternion();
|
||||
const _q1 = new THREE.Quaternion();
|
||||
const _q2 = new THREE.Quaternion();
|
||||
const _qF = new THREE.Quaternion();
|
||||
const _qInv = new THREE.Quaternion();
|
||||
|
||||
const fwdOf = (yaw, out) => out.set(Math.sin(yaw), 0, Math.cos(yaw));
|
||||
const rightOf = (yaw, out) => out.set(Math.cos(yaw), 0, -Math.sin(yaw));
|
||||
|
||||
function solveLeg(side, targetPos, targetYaw) {
|
||||
const thigh = B['thigh' + side];
|
||||
const shin = B['shin' + side];
|
||||
const foot = B['foot' + side];
|
||||
thigh.getWorldPosition(_H);
|
||||
_d.subVectors(targetPos, _H);
|
||||
let d = _d.length();
|
||||
const a = LEN.thigh;
|
||||
const b = LEN.shin;
|
||||
d = clamp(d, 0.12, a + b - 0.003);
|
||||
_d.normalize();
|
||||
// Cosine rule for the angle between the thigh axis and the hip->target line.
|
||||
const cosA = clamp((a * a + d * d - b * b) / (2 * a * d), -1, 1);
|
||||
const sinA = Math.sqrt(Math.max(0, 1 - cosA * cosA));
|
||||
fwdOf(anim.originYaw, _f);
|
||||
rightOf(anim.originYaw, _r);
|
||||
_pole.copy(_f).addScaledVector(_r, side === 'L' ? 0.34 : -0.34);
|
||||
_pole.y -= 0.2;
|
||||
_e2.copy(_pole).addScaledVector(_d, -_pole.dot(_d));
|
||||
if (_e2.lengthSq() < 1e-8) _e2.copy(_f);
|
||||
_e2.normalize();
|
||||
_knee.copy(_H).addScaledVector(_d, a * cosA).addScaledVector(_e2, a * sinA);
|
||||
|
||||
_dir.subVectors(_knee, _H).normalize();
|
||||
_q1.setFromUnitVectors(restThighDir[side], _dir);
|
||||
thigh.parent.getWorldQuaternion(_qP);
|
||||
_qInv.copy(_qP).invert();
|
||||
thigh.quaternion.copy(_qInv).multiply(_q1);
|
||||
|
||||
_dir.subVectors(targetPos, _knee).normalize();
|
||||
_q2.setFromUnitVectors(restShinDir[side], _dir);
|
||||
_qInv.copy(_q1).invert();
|
||||
shin.quaternion.copy(_qInv).multiply(_q2);
|
||||
|
||||
E(_qF, 0, targetYaw, 0, 'YXZ');
|
||||
_qInv.copy(_q2).invert();
|
||||
foot.quaternion.copy(_qInv).multiply(_qF);
|
||||
B['toe' + side].quaternion.identity();
|
||||
}
|
||||
|
||||
// ---- two-bone arm IK ----------------------------------------------------
|
||||
// Same solver as the legs, different pole. Used only to pin the lower hand
|
||||
// onto the shaft: a two-handed grip where the second hand merely hovers near
|
||||
// the stick is worse than not showing it at all, and no amount of authored
|
||||
// shoulder angle keeps a hand on a pole that the other arm is swinging.
|
||||
const ARM = {
|
||||
upper: B.forearmL.position.length(),
|
||||
fore: B.handL.position.length(),
|
||||
};
|
||||
const restUpperArmDir = {
|
||||
L: B.forearmL.position.clone().normalize(),
|
||||
R: B.forearmR.position.clone().normalize(),
|
||||
};
|
||||
const restForearmDir = {
|
||||
L: B.handL.position.clone().normalize(),
|
||||
R: B.handR.position.clone().normalize(),
|
||||
};
|
||||
|
||||
function solveArm(side, targetPos) {
|
||||
const upper = B[`upperArm${side}`];
|
||||
const fore = B[`forearm${side}`];
|
||||
upper.getWorldPosition(_H);
|
||||
_d.subVectors(targetPos, _H);
|
||||
let d = _d.length();
|
||||
const a = ARM.upper;
|
||||
const b = ARM.fore;
|
||||
// Never fully lock the elbow — a straight arm reads as a mannequin.
|
||||
d = clamp(d, 0.12, a + b - 0.02);
|
||||
_d.normalize();
|
||||
const cosA = clamp((a * a + d * d - b * b) / (2 * a * d), -1, 1);
|
||||
const sinA = Math.sqrt(Math.max(0, 1 - cosA * cosA));
|
||||
|
||||
// Elbow hangs below the shoulder and a little outside the ribs.
|
||||
rightOf(anim.originYaw, _r);
|
||||
_pole.set(0, -1, 0).addScaledVector(_r, side === 'L' ? 0.34 : -0.34);
|
||||
_e2.copy(_pole).addScaledVector(_d, -_pole.dot(_d));
|
||||
if (_e2.lengthSq() < 1e-8) _e2.set(0, -1, 0);
|
||||
_e2.normalize();
|
||||
_knee.copy(_H).addScaledVector(_d, a * cosA).addScaledVector(_e2, a * sinA);
|
||||
|
||||
_dir.subVectors(_knee, _H).normalize();
|
||||
_q1.setFromUnitVectors(restUpperArmDir[side], _dir);
|
||||
upper.parent.getWorldQuaternion(_qP);
|
||||
_qInv.copy(_qP).invert();
|
||||
upper.quaternion.copy(_qInv).multiply(_q1);
|
||||
|
||||
_dir.subVectors(targetPos, _knee).normalize();
|
||||
_q2.setFromUnitVectors(restForearmDir[side], _dir);
|
||||
_qInv.copy(_q1).invert();
|
||||
fore.quaternion.copy(_qInv).multiply(_q2);
|
||||
}
|
||||
|
||||
// ---- per-frame update ---------------------------------------------------
|
||||
const _blendFoot = new THREE.Vector3();
|
||||
const _shaftPoint = new THREE.Vector3();
|
||||
const _stickTarget = new THREE.Vector3();
|
||||
const _shaftA = new THREE.Vector3();
|
||||
const _shaftB = new THREE.Vector3();
|
||||
const _shaftDir = new THREE.Vector3();
|
||||
const _handPos = new THREE.Vector3();
|
||||
const _handQuat = new THREE.Quaternion();
|
||||
|
||||
anim.update = function update(dt) {
|
||||
dt *= anim.speed;
|
||||
anim.time += dt;
|
||||
anim.stateTime += dt;
|
||||
anim.blend = Math.min(1, anim.blend + dt / anim.transitionTime);
|
||||
|
||||
// A hockey stop is worth its own state; everything else is one pose driven
|
||||
// by continuous parameters.
|
||||
anim.setState(anim.braking && anim.moveSpeed > 1.2 ? 'stop' : 'skate');
|
||||
|
||||
const st = states[anim.state];
|
||||
if (st.pre) st.pre(dt);
|
||||
for (const n of UPPER) cur.q[n].identity();
|
||||
cur.rootOffset.set(0, 0, 0);
|
||||
cur.rootQuat.identity();
|
||||
st.pose(cur, anim.stateTime);
|
||||
|
||||
// ---- stickwork layer ---------------------------------------------------
|
||||
// The resting grip: hustling pushes the stick out in front on one hand,
|
||||
// and it eases rather than switching, so half-throttle is half-dangled.
|
||||
// With the puck, both hands stay on — the reference carry is two-handed
|
||||
// even at speed; only a real one-handed dangle (no puck) opens the grip.
|
||||
const hustleTarget = anim.state === 'skate' && !anim.hasPuck
|
||||
? clamp(anim.effort * 0.6 + clamp(anim.moveSpeed / 7, 0, 1) * 0.6, 0, 1)
|
||||
: anim.hasPuck
|
||||
? clamp(anim.effort * 0.08, 0, 0.2)
|
||||
: clamp(anim.effort * 0.25, 0, 1);
|
||||
anim.hustleGrip = lerp(anim.hustleGrip, hustleTarget, Math.min(1, 4 * dt));
|
||||
|
||||
// Carry pose first — the arms holding the stick at all — then any action
|
||||
// over the top of it.
|
||||
//
|
||||
// Arms are replaced and spine is *multiplied*. The spine already carries
|
||||
// the skating lean and the bank; a shot's coil is a twist on top of that.
|
||||
// Overwriting it was what stood everybody upright the moment they picked up
|
||||
// a stick.
|
||||
for (const n of STICK_BONES) overlay.q[n].identity();
|
||||
poseCarry(overlay, {
|
||||
hustle: anim.hustleGrip,
|
||||
reach: anim.handling.y,
|
||||
lateral: anim.handling.x,
|
||||
});
|
||||
for (const n of STICK_ARMS) cur.q[n].copy(overlay.q[n]);
|
||||
for (const n of STICK_SPINE) cur.q[n].multiply(overlay.q[n]);
|
||||
|
||||
for (const n of STICK_BONES) overlay.q[n].identity();
|
||||
const actionWeight = advanceAction(dt);
|
||||
if (actionWeight > 0.001) {
|
||||
for (const n of STICK_ARMS) cur.q[n].slerp(overlay.q[n], actionWeight);
|
||||
for (const n of STICK_SPINE) {
|
||||
_actionSpine.identity().slerp(overlay.q[n], actionWeight);
|
||||
cur.q[n].multiply(_actionSpine);
|
||||
}
|
||||
}
|
||||
|
||||
const w = smooth(anim.blend);
|
||||
for (const n of UPPER) B[n].quaternion.slerpQuaternions(frozen.q[n], cur.q[n], w);
|
||||
B.root.position.lerpVectors(frozen.rootOffset, cur.rootOffset, w);
|
||||
B.root.quaternion.slerpQuaternions(frozen.rootQuat, cur.rootQuat, w);
|
||||
|
||||
// Feet are solved after the spine is posed and the matrices refreshed, or
|
||||
// the hip the IK measures from is a frame stale and the legs trail.
|
||||
mover.updateMatrixWorld(true);
|
||||
_blendFoot.lerpVectors(frozen.foot.L.pos, cur.foot.L.pos, w);
|
||||
solveLeg('L', _blendFoot, lerpAngle(frozen.foot.L.yaw, cur.foot.L.yaw, w));
|
||||
_blendFoot.lerpVectors(frozen.foot.R.pos, cur.foot.R.pos, w);
|
||||
solveLeg('R', _blendFoot, lerpAngle(frozen.foot.R.yaw, cur.foot.R.yaw, w));
|
||||
mover.updateMatrixWorld(true);
|
||||
|
||||
// ---- the stick, last ---------------------------------------------------
|
||||
// Socket first, because it hangs off the right hand and the arm has only
|
||||
// just been posed. Then the lower hand is pulled onto the shaft, which
|
||||
// needs the stick already placed — hence the second matrix refresh.
|
||||
if (anim.stick) {
|
||||
const [from, to, t] = gripFor();
|
||||
const roll = anim.stick.stanceTarget(from, to, t, _stickTarget);
|
||||
// Stickhandling moves the *target*, not just the arm pose. Nudging only
|
||||
// the shoulders moved the blade by centimetres; the puck follows the
|
||||
// blade now, so the Skill Stick has to move the blade to mean anything.
|
||||
//
|
||||
// Lateral is *subtracted*: skater local +X is the left side, but the Skill
|
||||
// Stick's +X is "push right". Adding them lined the deke up mirrored —
|
||||
// stick right sent the puck to the skater's left.
|
||||
if (anim.hasPuck) {
|
||||
_stickTarget.x -= anim.handling.x * STICK_REACH.side;
|
||||
_stickTarget.z += anim.handling.y * STICK_REACH.fwd;
|
||||
}
|
||||
_stickTarget.applyMatrix4(mover.matrixWorld);
|
||||
B.handR.getWorldPosition(_handPos);
|
||||
B.handR.getWorldQuaternion(_handQuat);
|
||||
_handQuat.invert();
|
||||
anim.stick.aimAt(_stickTarget, _handPos, _handQuat, roll);
|
||||
mover.updateMatrixWorld(true);
|
||||
|
||||
// Two hands on it whenever the stick is being used for something, and
|
||||
// not while it is being dangled out on one.
|
||||
const twoHanded = (1 - anim.hustleGrip) * (anim.action === 'poke' ? 0.15 : 1);
|
||||
if (twoHanded > 0.05) {
|
||||
// Preferred lower-hand grip is a bit down the shaft (hands apart, the
|
||||
// way the reference draws a carry). If that point is past the arm's
|
||||
// reach, slide up toward the butt until it is — never leave the hand
|
||||
// waving short of the stick, and never stack both hands on the butt.
|
||||
anim.stick.shaftSegment(_shaftA, _shaftB);
|
||||
B.upperArmL.getWorldPosition(_H);
|
||||
_shaftDir.subVectors(_shaftB, _shaftA);
|
||||
const len = _shaftDir.length() || 1;
|
||||
const armReach = ARM.upper + ARM.fore - 0.03;
|
||||
// ~quarter of the way down when we can; closer when we must.
|
||||
let gripT = 0.28;
|
||||
_shaftPoint.copy(_shaftA).addScaledVector(_shaftDir, gripT);
|
||||
if (_H.distanceTo(_shaftPoint) > armReach) {
|
||||
gripT = 0.28;
|
||||
while (gripT > 0.12) {
|
||||
_shaftPoint.copy(_shaftA).addScaledVector(_shaftDir, gripT);
|
||||
if (_H.distanceTo(_shaftPoint) <= armReach) break;
|
||||
gripT -= 0.02;
|
||||
}
|
||||
// Last resort: nearest point on the reachable band of the shaft.
|
||||
if (_H.distanceTo(_shaftPoint) > armReach) {
|
||||
segDist(_H, _shaftA, _shaftB, _shaftPoint);
|
||||
const tNear = clamp(
|
||||
_shaftPoint.clone().sub(_shaftA).dot(_shaftDir) / (len * len),
|
||||
0.12,
|
||||
0.55,
|
||||
);
|
||||
gripT = tNear;
|
||||
_shaftPoint.copy(_shaftA).addScaledVector(_shaftDir, gripT);
|
||||
}
|
||||
}
|
||||
solveArm('L', _shaftPoint);
|
||||
mover.updateMatrixWorld(true);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
anim.states = states;
|
||||
anim.stateNames = Object.keys(states);
|
||||
applyMover();
|
||||
return anim;
|
||||
}
|
||||
@@ -0,0 +1,245 @@
|
||||
import * as THREE from 'three';
|
||||
import { physiqueFromBodyStyle } from '../../shared/bodyStyle.js';
|
||||
import { FWD, V3, clamp, lerp, mergeGeoms, smooth } from '../core/math.js';
|
||||
|
||||
export const PART = { TORSO: 0, HEAD: 1, ARM_L: 2, ARM_R: 3, LEG_L: 4, LEG_R: 5 };
|
||||
|
||||
const _t1 = new THREE.Vector3();
|
||||
const _t2 = new THREE.Vector3();
|
||||
const _t3 = new THREE.Vector3();
|
||||
|
||||
/**
|
||||
* Loft a tube along keyframed rings.
|
||||
* keys: [{ t, c: Vector3, rx, rz }] — cross-section radii along the ring basis
|
||||
* u/w, which is derived from the path tangent. `shape` harmonics deform the
|
||||
* silhouette so no two seeds share a profile.
|
||||
*/
|
||||
export function loftPart(keys, ringCount, radial, partId, shape) {
|
||||
const rings = [];
|
||||
for (let i = 0; i < ringCount; i++) {
|
||||
const t = i / (ringCount - 1);
|
||||
let k = 0;
|
||||
while (k < keys.length - 2 && keys[k + 1].t < t) k++;
|
||||
const a = keys[k];
|
||||
const b = keys[k + 1];
|
||||
const ft = smooth(clamp((t - a.t) / Math.max(1e-6, b.t - a.t), 0, 1));
|
||||
rings.push({ t, c: a.c.clone().lerp(b.c, ft), rx: lerp(a.rx, b.rx, ft), rz: lerp(a.rz, b.rz, ft) });
|
||||
}
|
||||
for (let i = 0; i < ringCount; i++) {
|
||||
const p0 = rings[Math.max(0, i - 1)].c;
|
||||
const p1 = rings[Math.min(ringCount - 1, i + 1)].c;
|
||||
const tan = _t1.subVectors(p1, p0).normalize();
|
||||
let u = _t2.crossVectors(tan, FWD);
|
||||
if (u.lengthSq() < 1e-6) u = _t2.set(1, 0, 0);
|
||||
else u.normalize();
|
||||
const w = _t3.crossVectors(tan, u).normalize();
|
||||
rings[i].u = u.clone();
|
||||
rings[i].w = w.clone();
|
||||
}
|
||||
|
||||
const pos = [], uv = [], aPart = [], aT = [], idx = [];
|
||||
const cols = radial + 1;
|
||||
for (let i = 0; i < ringCount; i++) {
|
||||
const r = rings[i];
|
||||
for (let j = 0; j <= radial; j++) {
|
||||
const th = (j / radial) * Math.PI * 2;
|
||||
const ct = Math.cos(th);
|
||||
const st = Math.sin(th);
|
||||
let sh = 1;
|
||||
if (shape) sh += shape.a1 * Math.cos(2 * th + shape.p1) + shape.a2 * Math.cos(3 * th + shape.p2);
|
||||
const px = r.rx * ct * sh;
|
||||
const pz = r.rz * st * sh;
|
||||
pos.push(
|
||||
r.c.x + r.u.x * px + r.w.x * pz,
|
||||
r.c.y + r.u.y * px + r.w.y * pz,
|
||||
r.c.z + r.u.z * px + r.w.z * pz,
|
||||
);
|
||||
uv.push(j / radial, r.t);
|
||||
aPart.push(partId);
|
||||
aT.push(r.t);
|
||||
}
|
||||
}
|
||||
for (let i = 0; i < ringCount - 1; i++) {
|
||||
for (let j = 0; j < radial; j++) {
|
||||
const a = i * cols + j;
|
||||
const b = a + cols;
|
||||
idx.push(a, a + 1, b, b, a + 1, b + 1);
|
||||
}
|
||||
}
|
||||
const cap = (ringIdx, flip) => {
|
||||
const r = rings[ringIdx];
|
||||
const ci = pos.length / 3;
|
||||
pos.push(r.c.x, r.c.y, r.c.z);
|
||||
uv.push(0.5, r.t);
|
||||
aPart.push(partId);
|
||||
aT.push(r.t);
|
||||
for (let j = 0; j < radial; j++) {
|
||||
const a = ringIdx * cols + j;
|
||||
const b = ringIdx * cols + j + 1;
|
||||
if (flip) idx.push(ci, b, a);
|
||||
else idx.push(ci, a, b);
|
||||
}
|
||||
};
|
||||
cap(0, true);
|
||||
cap(ringCount - 1, false);
|
||||
|
||||
const g = new THREE.BufferGeometry();
|
||||
g.setAttribute('position', new THREE.Float32BufferAttribute(pos, 3));
|
||||
g.setAttribute('uv', new THREE.Float32BufferAttribute(uv, 2));
|
||||
g.setAttribute('aPart', new THREE.Float32BufferAttribute(aPart, 1));
|
||||
g.setAttribute('aT', new THREE.Float32BufferAttribute(aT, 1));
|
||||
g.setIndex(idx);
|
||||
g.computeVertexNormals();
|
||||
return g;
|
||||
}
|
||||
|
||||
/**
|
||||
* Full body geometry for one fighter. `build` carries the physique parameters
|
||||
* so they can be reported to the physics layer: reach, centre of mass and limb
|
||||
* mass all follow from the same numbers that shaped the mesh (GDD 8).
|
||||
*
|
||||
* @param {*} rng seeded RNG (small natural jitter)
|
||||
* @param {{ mass?: number, muscle?: number, fat?: number } | null} [bodyStyle]
|
||||
* loadout body sliders (dreamfall-style mass / muscle / fat)
|
||||
*/
|
||||
export function buildBodyGeometry(rng, bodyStyle = null) {
|
||||
const phy = physiqueFromBodyStyle(bodyStyle, rng);
|
||||
const { bulk, waistF, shoulderF, headF, armF, legF } = phy;
|
||||
const parts = [];
|
||||
|
||||
// Girdle half-width: follows physique, but floors so extreme lean never
|
||||
// collapses the clavicle to a point the deltoid cannot meet.
|
||||
const girdleRx = Math.max(0.105, 0.176 * bulk * shoulderF);
|
||||
const collarRx = Math.max(0.092, 0.15 * bulk * shoulderF);
|
||||
|
||||
const tKeys = [
|
||||
{ t: 0.0, c: V3(0, 0.885, 0.002), rx: 0.15 * bulk, rz: 0.1 * bulk },
|
||||
{ t: 0.08, c: V3(0, 0.935, 0.004), rx: 0.172 * bulk, rz: 0.118 * bulk },
|
||||
{ t: 0.18, c: V3(0, 1.0, 0.005), rx: 0.164 * bulk, rz: 0.108 * bulk },
|
||||
{ t: 0.32, c: V3(0, 1.075, 0.004), rx: 0.15 * bulk * waistF, rz: 0.1 * bulk * waistF },
|
||||
{ t: 0.48, c: V3(0, 1.165, 0.006), rx: 0.156 * bulk, rz: 0.104 * bulk },
|
||||
{ t: 0.62, c: V3(0, 1.255, 0.008), rx: 0.168 * bulk, rz: 0.116 * bulk },
|
||||
{ t: 0.76, c: V3(0, 1.335, 0.009), rx: girdleRx, rz: 0.12 * bulk },
|
||||
{ t: 0.88, c: V3(0, 1.405, 0.01), rx: collarRx, rz: 0.105 * bulk },
|
||||
{ t: 0.95, c: V3(0, 1.445, 0.012), rx: 0.078 * bulk, rz: 0.072 * bulk },
|
||||
{ t: 1.0, c: V3(0, 1.475, 0.013), rx: 0.058 * bulk, rz: 0.056 * bulk },
|
||||
];
|
||||
parts.push(
|
||||
loftPart(tKeys, 36, 24, PART.TORSO, {
|
||||
a1: rng.range(-0.03, 0.03), p1: rng.range(0, 6.28),
|
||||
a2: rng.range(-0.02, 0.02), p2: rng.range(0, 6.28),
|
||||
}),
|
||||
);
|
||||
|
||||
const hKeys = [
|
||||
{ t: 0.0, c: V3(0, 1.425, 0.012), rx: 0.056, rz: 0.058 },
|
||||
{ t: 0.14, c: V3(0, 1.47, 0.014), rx: 0.06 * headF, rz: 0.064 * headF },
|
||||
{ t: 0.3, c: V3(0, 1.52, 0.02), rx: 0.074 * headF, rz: 0.08 * headF },
|
||||
{ t: 0.48, c: V3(0, 1.575, 0.026), rx: 0.088 * headF, rz: 0.094 * headF },
|
||||
{ t: 0.64, c: V3(0, 1.625, 0.024), rx: 0.094 * headF, rz: 0.1 * headF },
|
||||
{ t: 0.8, c: V3(0, 1.668, 0.016), rx: 0.084 * headF, rz: 0.088 * headF },
|
||||
{ t: 0.92, c: V3(0, 1.7, 0.01), rx: 0.052 * headF, rz: 0.054 * headF },
|
||||
{ t: 1.0, c: V3(0, 1.716, 0.008), rx: 0.012, rz: 0.012 },
|
||||
];
|
||||
parts.push(loftPart(hKeys, 24, 20, PART.HEAD, { a1: rng.range(-0.02, 0.02), p1: rng.range(0, 6.28), a2: 0, p2: 0 }));
|
||||
|
||||
// ---- Arms + spherical shoulder sockets ---------------------------------
|
||||
//
|
||||
// Extreme skinny (mass/muscle floors) used to leave a hole between a thin
|
||||
// torso and a fixed arm root at x=0.15 — the "spike" sockets in the kit
|
||||
// preview. Rebuild the deltoid as a sphere that always spans from the
|
||||
// clavicle root (inside the torso half-width) out to the upper-arm shaft.
|
||||
//
|
||||
// shoulderHalf matches the torso girdle ring (same floor as girdleRx).
|
||||
const shoulderHalf = girdleRx;
|
||||
// Deltoid boulder radius: floors hard so lean builds still have a round
|
||||
// joint; grows with bulk/arm muscle for heavy / cut.
|
||||
const deltoidR = Math.max(
|
||||
0.064,
|
||||
0.072 * Math.sqrt(Math.max(bulk, 0.55)) * (0.72 + 0.38 * Math.min(armF, 1.45)),
|
||||
);
|
||||
// Clavicle / socket layout in the coronal plane (absolute X later mirrored).
|
||||
const clavY = 1.402;
|
||||
const clavZ = 0.008;
|
||||
// Root sits inside the torso so the sphere always meets clavicle + neck.
|
||||
const clavRootX = Math.max(0.038, shoulderHalf * 0.42);
|
||||
// Sphere centre sits on the torso shoulder edge.
|
||||
const socketX = Math.max(shoulderHalf * 0.92, clavRootX + deltoidR * 0.55);
|
||||
// Outer deltoid / upper-arm takeoff — past the boulder equator.
|
||||
const armRootX = socketX + deltoidR * 0.72;
|
||||
|
||||
for (const s of [1, -1]) {
|
||||
const partId = s > 0 ? PART.ARM_L : PART.ARM_R;
|
||||
const P = (x, y, z) => V3(s * x, y, z);
|
||||
// Near-equal rx/rz + short arc through one centre ⇒ spherical deltoid.
|
||||
// Mild shape harmonics only on the shaft so the boulder stays round.
|
||||
const aKeys = [
|
||||
// Clavicle root — buried in the torso, always connected.
|
||||
{ t: 0.0, c: P(clavRootX, clavY + 0.012, clavZ + 0.004), rx: deltoidR * 0.92, rz: deltoidR * 0.88 },
|
||||
// Inner hemisphere (toward neck / traps).
|
||||
{ t: 0.05, c: P(socketX * 0.78, clavY + 0.006, clavZ), rx: deltoidR * 1.02, rz: deltoidR * 0.98 },
|
||||
// Deltoid equator — the shoulder boulder.
|
||||
{ t: 0.11, c: P(socketX, clavY, clavZ), rx: deltoidR, rz: deltoidR },
|
||||
// Outer hemisphere → upper-arm takeoff.
|
||||
{ t: 0.18, c: P(armRootX, clavY - 0.012, clavZ + 0.002), rx: deltoidR * 0.86, rz: deltoidR * 0.82 },
|
||||
// Upper arm shaft (path kept close to the original A-pose reach).
|
||||
{ t: 0.28, c: P(Math.max(0.28, armRootX + 0.06), 1.30, 0.008), rx: 0.056 * armF, rz: 0.052 * armF },
|
||||
{ t: 0.40, c: P(0.355, 1.16, 0.01), rx: 0.048 * armF, rz: 0.044 * armF },
|
||||
{ t: 0.50, c: P(0.392, 1.098, 0.011), rx: 0.041 * armF, rz: 0.039 * armF },
|
||||
{ t: 0.66, c: P(0.445, 0.985, 0.014), rx: 0.045 * armF, rz: 0.042 * armF },
|
||||
{ t: 0.78, c: P(0.48, 0.905, 0.017), rx: 0.035 * armF, rz: 0.032 * armF },
|
||||
{ t: 0.86, c: P(0.5, 0.855, 0.02), rx: 0.038, rz: 0.026 },
|
||||
{ t: 0.95, c: P(0.52, 0.805, 0.024), rx: 0.034, rz: 0.02 },
|
||||
{ t: 1.0, c: P(0.53, 0.778, 0.026), rx: 0.012, rz: 0.01 },
|
||||
];
|
||||
parts.push(
|
||||
// Extra rings through the deltoid so the sphere reads smooth, not faceted.
|
||||
loftPart(aKeys, 32, 20, partId, {
|
||||
a1: rng.range(-0.02, 0.02), p1: rng.range(0, 6.28),
|
||||
a2: rng.range(-0.01, 0.01), p2: rng.range(0, 6.28),
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
for (const s of [1, -1]) {
|
||||
const partId = s > 0 ? PART.LEG_L : PART.LEG_R;
|
||||
const P = (x, y, z) => V3(s * x, y, z);
|
||||
const lKeys = [
|
||||
{ t: 0.0, c: P(0.088, 1.02, 0.004), rx: 0.108 * bulk, rz: 0.102 * bulk },
|
||||
{ t: 0.1, c: P(0.112, 0.93, 0.006), rx: 0.104 * legF, rz: 0.098 * legF },
|
||||
{ t: 0.28, c: P(0.125, 0.76, 0.008), rx: 0.088 * legF, rz: 0.084 * legF },
|
||||
{ t: 0.44, c: P(0.13, 0.6, 0.009), rx: 0.068 * legF, rz: 0.064 * legF },
|
||||
{ t: 0.52, c: P(0.13, 0.512, 0.008), rx: 0.058 * legF, rz: 0.056 * legF },
|
||||
{ t: 0.64, c: P(0.132, 0.38, 0.006), rx: 0.064 * legF, rz: 0.06 * legF },
|
||||
{ t: 0.78, c: P(0.133, 0.22, 0.002), rx: 0.05 * legF, rz: 0.046 * legF },
|
||||
{ t: 0.86, c: P(0.132, 0.11, -0.004), rx: 0.042, rz: 0.038 },
|
||||
{ t: 0.92, c: P(0.13, 0.062, 0.03), rx: 0.044, rz: 0.034 },
|
||||
{ t: 0.97, c: P(0.128, 0.04, 0.095), rx: 0.042, rz: 0.028 },
|
||||
{ t: 1.0, c: P(0.126, 0.032, 0.155), rx: 0.02, rz: 0.014 },
|
||||
];
|
||||
parts.push(
|
||||
loftPart(lKeys, 30, 18, partId, {
|
||||
a1: rng.range(-0.03, 0.03), p1: rng.range(0, 6.28),
|
||||
a2: rng.range(-0.015, 0.015), p2: rng.range(0, 6.28),
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
const merged = mergeGeoms(parts);
|
||||
merged.computeVertexNormals();
|
||||
merged.userData.physique = { bulk, waistF, shoulderF, headF, armF, legF, style: phy.style };
|
||||
return merged;
|
||||
}
|
||||
|
||||
export function buildBodyMesh(geo, skelData, materials) {
|
||||
const mesh = new THREE.SkinnedMesh(geo, materials.skin);
|
||||
mesh.castShadow = true;
|
||||
mesh.receiveShadow = true;
|
||||
mesh.frustumCulled = false;
|
||||
mesh.add(skelData.bones.root);
|
||||
mesh.updateMatrixWorld(true);
|
||||
mesh.bind(skelData.skeleton, mesh.matrixWorld.clone());
|
||||
mesh.userData.heatMat = new THREE.MeshBasicMaterial({ vertexColors: true });
|
||||
mesh.userData.origMat = materials.skin;
|
||||
return mesh;
|
||||
}
|
||||
@@ -0,0 +1,382 @@
|
||||
import * as THREE from 'three';
|
||||
import { clamp, lerp, mergeGeoms, smooth, stripAttrs } from '../core/math.js';
|
||||
|
||||
/**
|
||||
* Geometry toolkit for equipment.
|
||||
*
|
||||
* Gear used to be stacks of BoxGeometry, which reads as a pile of crates the
|
||||
* moment the camera gets close. Three builders replace that:
|
||||
*
|
||||
* loft() — one continuous skinned-looking tube through keyed
|
||||
* cross-sections. Pads, gloves, chest, paddle.
|
||||
* carvedShell() — a hand-indexed lat/long shell with real wall thickness and
|
||||
* a hole cut through it. The goalie mask.
|
||||
* tube() — a swept bar along a curve. Cage bars, rims, straps.
|
||||
*
|
||||
* Everything comes back as a plain indexed BufferGeometry in the local space of
|
||||
* whatever bone it will hang off, so the caller only ever sets a position.
|
||||
*/
|
||||
|
||||
const _u = new THREE.Vector3();
|
||||
const _w = new THREE.Vector3();
|
||||
const _tan = new THREE.Vector3();
|
||||
const _a = new THREE.Vector3();
|
||||
const _b = new THREE.Vector3();
|
||||
const _n = new THREE.Vector3();
|
||||
const _d = new THREE.Vector3();
|
||||
const REF_X = new THREE.Vector3(1, 0, 0);
|
||||
const WHITE = new THREE.Color(1, 1, 1);
|
||||
|
||||
/**
|
||||
* Superellipse profile point on the unit section.
|
||||
*
|
||||
* `e` = 2 is an ellipse; larger values square it off. Pads and blocker boards
|
||||
* are rounded rectangles in cross-section, not ovals — that edge is most of
|
||||
* what makes a pad read as a pad.
|
||||
*/
|
||||
function profile(theta, e) {
|
||||
const c = Math.cos(theta);
|
||||
const s = Math.sin(theta);
|
||||
if (e === 2) return [c, s];
|
||||
const k = 2 / e;
|
||||
return [Math.sign(c) * Math.abs(c) ** k, Math.sign(s) * Math.abs(s) ** k];
|
||||
}
|
||||
|
||||
/**
|
||||
* Loft a closed tube through keyed cross-sections.
|
||||
*
|
||||
* Sections are `{ c: Vector3, rx, rz, e?, col? }`:
|
||||
* c — centre of the ring on the path
|
||||
* rx — half-width along the ring's `u` axis (world X for a straight run)
|
||||
* rz — half-depth along `w` (the path's forward side)
|
||||
* e — superellipse exponent, 2 = oval … 8 = nearly a box
|
||||
* col — vertex colour from this ring on; interpolates to the next
|
||||
*
|
||||
* The path is a Catmull-Rom through the section centres so a bend (a pad's toe
|
||||
* kick, a thumb) curves instead of creasing. Radii ease with smoothstep, which
|
||||
* means two sections at the same centre give a hard step — that is how the
|
||||
* stripes and the boot break are cut.
|
||||
*
|
||||
* `part` / `t0` / `t1` write the `aPart` and `aT` attributes the skinning solver
|
||||
* reads. Cloth — a jersey, a pant leg, a sock — has to bend at the joints it
|
||||
* crosses, so it is skinned to the skeleton rather than bolted to one bone, and
|
||||
* those two attributes are what keep the left sleeve off the right arm.
|
||||
*/
|
||||
export function loft(sections, {
|
||||
radial = 20,
|
||||
sub = 5,
|
||||
ref = REF_X,
|
||||
capStart = true,
|
||||
capEnd = true,
|
||||
tension = 0.5,
|
||||
part = null,
|
||||
t0 = 0,
|
||||
t1 = 1,
|
||||
} = {}) {
|
||||
const n = sections.length;
|
||||
if (n < 2) throw new Error('loft needs at least two sections');
|
||||
|
||||
// Fill colours forward then backward so a single tinted section paints the
|
||||
// whole run up to the next one.
|
||||
const cols = sections.map((s) => s.col ?? null);
|
||||
const painted = cols.some(Boolean);
|
||||
if (painted) {
|
||||
for (let i = 1; i < n; i++) if (!cols[i]) cols[i] = cols[i - 1];
|
||||
for (let i = n - 2; i >= 0; i--) if (!cols[i]) cols[i] = cols[i + 1];
|
||||
}
|
||||
|
||||
const curve = new THREE.CatmullRomCurve3(
|
||||
sections.map((s) => s.c.clone()),
|
||||
false,
|
||||
'catmullrom',
|
||||
tension,
|
||||
);
|
||||
|
||||
const rings = Math.max(2, (n - 1) * sub);
|
||||
const pos = [];
|
||||
const uv = [];
|
||||
const col = [];
|
||||
const aPart = [];
|
||||
const aT = [];
|
||||
const idx = [];
|
||||
const stride = radial + 1; // seam column duplicated so UVs stay sane
|
||||
const centres = [];
|
||||
|
||||
for (let r = 0; r <= rings; r++) {
|
||||
const t = r / rings;
|
||||
const p = (n - 1) * t;
|
||||
const i0 = Math.min(n - 2, Math.floor(p));
|
||||
const f = smooth(clamp(p - i0, 0, 1));
|
||||
const s0 = sections[i0];
|
||||
const s1 = sections[i0 + 1];
|
||||
|
||||
const c = curve.getPoint(t);
|
||||
_tan.copy(curve.getTangent(t)).normalize();
|
||||
_w.crossVectors(_tan, ref);
|
||||
if (_w.lengthSq() < 1e-10) _w.set(0, 0, 1);
|
||||
_w.normalize();
|
||||
_u.crossVectors(_w, _tan).normalize();
|
||||
|
||||
const rx = lerp(s0.rx, s1.rx, f);
|
||||
const rz = lerp(s0.rz, s1.rz, f);
|
||||
const e = lerp(s0.e ?? 2, s1.e ?? 2, f);
|
||||
const tint = painted ? new THREE.Color().lerpColors(cols[i0], cols[i0 + 1], f) : null;
|
||||
centres.push({ c: c.clone(), t });
|
||||
|
||||
for (let j = 0; j <= radial; j++) {
|
||||
const [px, pz] = profile((j / radial) * Math.PI * 2, e);
|
||||
pos.push(
|
||||
c.x + _u.x * px * rx + _w.x * pz * rz,
|
||||
c.y + _u.y * px * rx + _w.y * pz * rz,
|
||||
c.z + _u.z * px * rx + _w.z * pz * rz,
|
||||
);
|
||||
uv.push(j / radial, t);
|
||||
if (painted) col.push(tint.r, tint.g, tint.b);
|
||||
if (part != null) {
|
||||
aPart.push(part);
|
||||
aT.push(t0 + (t1 - t0) * t);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (let i = 0; i < rings; i++) {
|
||||
for (let j = 0; j < radial; j++) {
|
||||
const a = i * stride + j;
|
||||
const b = a + stride;
|
||||
idx.push(a, a + 1, b, b, a + 1, b + 1);
|
||||
}
|
||||
}
|
||||
|
||||
const cap = (ring, flip) => {
|
||||
const { c, t } = centres[ring];
|
||||
const ci = pos.length / 3;
|
||||
pos.push(c.x, c.y, c.z);
|
||||
uv.push(0.5, t);
|
||||
if (painted) {
|
||||
const base = (ring * stride) * 3;
|
||||
col.push(col[base], col[base + 1], col[base + 2]);
|
||||
}
|
||||
if (part != null) {
|
||||
aPart.push(part);
|
||||
aT.push(t0 + (t1 - t0) * t);
|
||||
}
|
||||
for (let j = 0; j < radial; j++) {
|
||||
const a = ring * stride + j;
|
||||
const b = a + 1;
|
||||
if (flip) idx.push(ci, b, a);
|
||||
else idx.push(ci, a, b);
|
||||
}
|
||||
};
|
||||
if (capStart) cap(0, true);
|
||||
if (capEnd) cap(rings, false);
|
||||
|
||||
const g = new THREE.BufferGeometry();
|
||||
g.setAttribute('position', new THREE.Float32BufferAttribute(pos, 3));
|
||||
g.setAttribute('uv', new THREE.Float32BufferAttribute(uv, 2));
|
||||
if (painted) g.setAttribute('color', new THREE.Float32BufferAttribute(col, 3));
|
||||
if (part != null) {
|
||||
g.setAttribute('aPart', new THREE.Float32BufferAttribute(aPart, 1));
|
||||
g.setAttribute('aT', new THREE.Float32BufferAttribute(aT, 1));
|
||||
}
|
||||
g.setIndex(idx);
|
||||
g.computeVertexNormals();
|
||||
return g;
|
||||
}
|
||||
|
||||
/** Sweep a bar of `radius` along a Catmull-Rom through `points`. */
|
||||
export function tube(points, radius, {
|
||||
closed = false,
|
||||
radial = 7,
|
||||
segments = null,
|
||||
tension = 0.4,
|
||||
} = {}) {
|
||||
const curve = new THREE.CatmullRomCurve3(
|
||||
points.map((p) => p.clone()),
|
||||
closed,
|
||||
'catmullrom',
|
||||
tension,
|
||||
);
|
||||
const seg = segments ?? Math.max(10, points.length * 4);
|
||||
return new THREE.TubeGeometry(curve, seg, radius, radial, closed);
|
||||
}
|
||||
|
||||
/** Fold a pile of bars into one geometry (one draw call, one material). */
|
||||
export function mergeBars(list) {
|
||||
const merged = mergeGeoms(list.map(stripAttrs));
|
||||
for (const g of list) g.dispose();
|
||||
merged.computeVertexNormals();
|
||||
return merged;
|
||||
}
|
||||
|
||||
/**
|
||||
* Push a quad as two triangles, wound so its face points along `dir`.
|
||||
*
|
||||
* Winding on a hand-built grid depends on which way the parametrisation runs,
|
||||
* and getting it backwards means the surface renders inside-out. Deciding per
|
||||
* quad from the geometry is cheap and removes the guesswork.
|
||||
*/
|
||||
function pushQuad(idx, pos, a, b, c, d, dir) {
|
||||
_a.set(pos[b * 3] - pos[a * 3], pos[b * 3 + 1] - pos[a * 3 + 1], pos[b * 3 + 2] - pos[a * 3 + 2]);
|
||||
_b.set(pos[c * 3] - pos[a * 3], pos[c * 3 + 1] - pos[a * 3 + 1], pos[c * 3 + 2] - pos[a * 3 + 2]);
|
||||
_n.crossVectors(_a, _b);
|
||||
if (_n.lengthSq() < 1e-16) return;
|
||||
if (_n.dot(dir) >= 0) idx.push(a, b, c, a, c, d);
|
||||
else idx.push(a, c, b, a, d, c);
|
||||
}
|
||||
|
||||
/**
|
||||
* A shell with thickness and an optional hole cut through it.
|
||||
*
|
||||
* `surface(theta, v, out)` writes the outer skin for the lat/long parameter
|
||||
* pair — theta wraps, v runs 0 (open bottom edge) → 1 (closed crown). Vertex
|
||||
* normals come from the parametric tangents, and the inner skin is the outer
|
||||
* one pushed back along them, so the wall has an honest thickness you can see
|
||||
* through the hole.
|
||||
*
|
||||
* `port(p, theta, v)` marks outer vertices that fall inside a hole; every quad
|
||||
* touching one is dropped and the exposed border is walled with a rim. That is
|
||||
* what turns a lump into a mask you can see a face through. The surface
|
||||
* parameters come through alongside the position because holes that follow the
|
||||
* shell — vent slots, an ear port — are far easier to place in (theta, v) than
|
||||
* in metres.
|
||||
*/
|
||||
export function carvedShell({
|
||||
rows = 40,
|
||||
cols = 48,
|
||||
thickness = 0.012,
|
||||
surface,
|
||||
port = null,
|
||||
color = null,
|
||||
center = new THREE.Vector3(),
|
||||
bottomRim = true,
|
||||
}) {
|
||||
const outer = [];
|
||||
const param = [];
|
||||
for (let i = 0; i <= rows; i++) {
|
||||
const v = i / rows;
|
||||
for (let j = 0; j < cols; j++) {
|
||||
const theta = (j / cols) * Math.PI * 2;
|
||||
outer.push(surface(theta, v, new THREE.Vector3()));
|
||||
param.push(theta, v);
|
||||
}
|
||||
}
|
||||
const at = (i, j) => outer[i * cols + (((j % cols) + cols) % cols)];
|
||||
|
||||
// Parametric normals: dV × dTheta, flipped to face away from the centre.
|
||||
const normals = [];
|
||||
for (let i = 0; i <= rows; i++) {
|
||||
for (let j = 0; j < cols; j++) {
|
||||
_a.subVectors(at(i, j + 1), at(i, j - 1));
|
||||
_b.subVectors(at(Math.min(rows, i + 1), j), at(Math.max(0, i - 1), j));
|
||||
_n.crossVectors(_b, _a);
|
||||
_d.subVectors(at(i, j), center);
|
||||
if (_n.lengthSq() < 1e-14) _n.copy(_d);
|
||||
_n.normalize();
|
||||
if (_n.dot(_d) < 0) _n.negate();
|
||||
normals.push(_n.clone());
|
||||
}
|
||||
}
|
||||
|
||||
const nOuter = outer.length;
|
||||
const pos = new Array(nOuter * 6);
|
||||
const nor = new Array(nOuter * 6);
|
||||
const uvs = new Array(nOuter * 4);
|
||||
const cols3 = color ? new Array(nOuter * 6) : null;
|
||||
|
||||
for (let k = 0; k < nOuter; k++) {
|
||||
const p = outer[k];
|
||||
const n = normals[k];
|
||||
const i = Math.floor(k / cols);
|
||||
const j = k % cols;
|
||||
const inner = _d.copy(p).addScaledVector(n, -thickness);
|
||||
pos[k * 3] = p.x; pos[k * 3 + 1] = p.y; pos[k * 3 + 2] = p.z;
|
||||
pos[(nOuter + k) * 3] = inner.x;
|
||||
pos[(nOuter + k) * 3 + 1] = inner.y;
|
||||
pos[(nOuter + k) * 3 + 2] = inner.z;
|
||||
nor[k * 3] = n.x; nor[k * 3 + 1] = n.y; nor[k * 3 + 2] = n.z;
|
||||
nor[(nOuter + k) * 3] = -n.x;
|
||||
nor[(nOuter + k) * 3 + 1] = -n.y;
|
||||
nor[(nOuter + k) * 3 + 2] = -n.z;
|
||||
uvs[k * 2] = j / cols; uvs[k * 2 + 1] = i / rows;
|
||||
uvs[(nOuter + k) * 2] = j / cols;
|
||||
uvs[(nOuter + k) * 2 + 1] = i / rows;
|
||||
if (cols3) {
|
||||
const co = color(p, 'outer', param[k * 2], param[k * 2 + 1]);
|
||||
const ci = color(p, 'inner', param[k * 2], param[k * 2 + 1]);
|
||||
cols3[k * 3] = co.r; cols3[k * 3 + 1] = co.g; cols3[k * 3 + 2] = co.b;
|
||||
cols3[(nOuter + k) * 3] = ci.r;
|
||||
cols3[(nOuter + k) * 3 + 1] = ci.g;
|
||||
cols3[(nOuter + k) * 3 + 2] = ci.b;
|
||||
}
|
||||
}
|
||||
|
||||
const holed = port ? outer.map((p, k) => port(p, param[k * 2], param[k * 2 + 1])) : null;
|
||||
const O = (i, j) => i * cols + (((j % cols) + cols) % cols);
|
||||
const I = (i, j) => nOuter + O(i, j);
|
||||
const dropped = (i, j) => {
|
||||
if (!holed) return false;
|
||||
return holed[O(i, j)] || holed[O(i, j + 1)] || holed[O(i + 1, j)] || holed[O(i + 1, j + 1)];
|
||||
};
|
||||
|
||||
const idx = [];
|
||||
const mid = new THREE.Vector3();
|
||||
const midOf = (i, j, out) => out
|
||||
.copy(at(i, j)).add(at(i, j + 1)).add(at(i + 1, j)).add(at(i + 1, j + 1)).multiplyScalar(0.25);
|
||||
|
||||
for (let i = 0; i < rows; i++) {
|
||||
for (let j = 0; j < cols; j++) {
|
||||
if (dropped(i, j)) continue;
|
||||
midOf(i, j, mid);
|
||||
_d.copy(normals[O(i, j)]);
|
||||
pushQuad(idx, pos, O(i, j), O(i, j + 1), O(i + 1, j + 1), O(i + 1, j), _d);
|
||||
_d.negate();
|
||||
pushQuad(idx, pos, I(i, j), I(i, j + 1), I(i + 1, j + 1), I(i + 1, j), _d);
|
||||
}
|
||||
}
|
||||
|
||||
// Wall the hole: every dropped quad that borders a kept one gets a rim face
|
||||
// on the shared edge, pointing into the opening.
|
||||
const holeMid = new THREE.Vector3();
|
||||
const keptMid = new THREE.Vector3();
|
||||
const rim = (i, j, ni, nj, ea, eb) => {
|
||||
if (ni < 0 || ni >= rows) return;
|
||||
if (!dropped(ni, nj)) {
|
||||
midOf(i, j, holeMid);
|
||||
midOf(ni, nj, keptMid);
|
||||
_d.subVectors(holeMid, keptMid).normalize();
|
||||
pushQuad(idx, pos, ea[0], ea[1], eb[1], eb[0], _d);
|
||||
}
|
||||
};
|
||||
if (holed) {
|
||||
for (let i = 0; i < rows; i++) {
|
||||
for (let j = 0; j < cols; j++) {
|
||||
if (!dropped(i, j)) continue;
|
||||
rim(i, j, i, j - 1, [O(i, j), O(i + 1, j)], [I(i, j), I(i + 1, j)]);
|
||||
rim(i, j, i, j + 1, [O(i, j + 1), O(i + 1, j + 1)], [I(i, j + 1), I(i + 1, j + 1)]);
|
||||
rim(i, j, i - 1, j, [O(i, j), O(i, j + 1)], [I(i, j), I(i, j + 1)]);
|
||||
rim(i, j, i + 1, j, [O(i + 1, j), O(i + 1, j + 1)], [I(i + 1, j), I(i + 1, j + 1)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Open bottom edge gets its own rim so the shell reads as a shell.
|
||||
if (bottomRim) {
|
||||
for (let j = 0; j < cols; j++) {
|
||||
_d.subVectors(at(0, j), at(1, j)).normalize();
|
||||
pushQuad(idx, pos, O(0, j), O(0, j + 1), I(0, j + 1), I(0, j), _d);
|
||||
}
|
||||
}
|
||||
|
||||
const g = new THREE.BufferGeometry();
|
||||
g.setAttribute('position', new THREE.Float32BufferAttribute(pos, 3));
|
||||
g.setAttribute('normal', new THREE.Float32BufferAttribute(nor, 3));
|
||||
g.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
|
||||
if (cols3) g.setAttribute('color', new THREE.Float32BufferAttribute(cols3, 3));
|
||||
g.setIndex(idx);
|
||||
return g;
|
||||
}
|
||||
|
||||
/** Colour helper — a solid tint for a whole loft section. */
|
||||
export function tint(c) {
|
||||
return c instanceof THREE.Color ? c.clone() : new THREE.Color(c ?? WHITE);
|
||||
}
|
||||
@@ -0,0 +1,289 @@
|
||||
import * as THREE from 'three';
|
||||
import { NET, goalLineX, goalieSpot } from '../../shared/net.js';
|
||||
import { CAT, KIND, makeTag, quat, transform, vec3, xyz } from '../physics/bridge.js';
|
||||
import { clamp } from '../../shared/scalar.js';
|
||||
import { makeRng } from '../core/rng.js';
|
||||
import { disposeObject } from '../core/math.js';
|
||||
import { buildMaterials, paintKit } from '../render/materials.js';
|
||||
import { assertNoNaNBones, buildSkeleton } from './skeleton.js';
|
||||
import { buildBodyGeometry, buildBodyMesh } from './body.js';
|
||||
import { computeSkin } from './skinning.js';
|
||||
import { buildGoalieAnimator } from '../anim/goalieAnimator.js';
|
||||
import { buildGoalieGear, buildGoalieMaterials } from './goalieGear.js';
|
||||
|
||||
/**
|
||||
* A goalie.
|
||||
*
|
||||
* Deliberately *not* a skater. The skating sim is a carve model — momentum
|
||||
* dragged onto a blade line — and a goalie almost never carves. They shuffle
|
||||
* along an arc, square to the puck, and their whole job is to be in the right
|
||||
* place rather than to travel.
|
||||
*
|
||||
* Presentation matches the skaters: same skeleton, skinned body, bone-socketed
|
||||
* gear (pads, trapper, blocker, mask, paddle). Locomotion and saves stay
|
||||
* purpose-built — angle tracking with a reaction lag, kinematic pad/body
|
||||
* colliders the puck bounces off. No save-percentage roll anywhere.
|
||||
*/
|
||||
|
||||
export const GOALIE = {
|
||||
/** How far out of the net they play. Deeper is safer, shallower cuts angle. */
|
||||
depth: 0.62,
|
||||
/** Lateral speed, m/s. Real goalies are quick but not instant. */
|
||||
speed: 4.4,
|
||||
/** Seconds of reaction lag on the target. This is the beatable part. */
|
||||
lag: 0.11,
|
||||
/** Pad stack: low and wide — the physics shape, not the visual pad. */
|
||||
padWidth: 0.92,
|
||||
padHeight: 0.46,
|
||||
padDepth: 0.22,
|
||||
/** Upper body plus arms/glove/blocker, as one capsule. */
|
||||
bodyRadius: 0.30,
|
||||
bodyLow: 0.46,
|
||||
bodyHigh: 1.24,
|
||||
/** How far they lunge at a puck that is already past them. */
|
||||
desperation: 0.45,
|
||||
/**
|
||||
* How close / fast a puck has to be before they commit to butterfly/reach.
|
||||
* Tuned so idle crease work stays in ready stance.
|
||||
*/
|
||||
threatDist: 9,
|
||||
threatSpeed: 6,
|
||||
};
|
||||
|
||||
export function createGoalie(physics, scene, {
|
||||
end = 1,
|
||||
index = 40,
|
||||
team = 1,
|
||||
seed = 9000 + Math.abs(end) * 17 + team * 3,
|
||||
} = {}) {
|
||||
const line = goalLineX(end);
|
||||
const rng = makeRng(seed);
|
||||
const materials = buildMaterials(rng, team);
|
||||
// Goalies are bulkier in the pads than skaters are in pants.
|
||||
const bodyStyle = { mass: 0.55, muscle: 0.6, fat: 0.45 };
|
||||
const skelData = buildSkeleton();
|
||||
|
||||
const mover = new THREE.Group();
|
||||
mover.name = 'goalie:' + end;
|
||||
scene.add(mover);
|
||||
|
||||
const bodyGeo = buildBodyGeometry(rng, bodyStyle);
|
||||
computeSkin(bodyGeo, skelData);
|
||||
paintKit(bodyGeo, { jersey: materials.team.jersey, skinColor: materials.skinColor });
|
||||
const bodyMesh = buildBodyMesh(bodyGeo, skelData, materials);
|
||||
mover.add(bodyMesh);
|
||||
|
||||
const gearMats = buildGoalieMaterials(materials.team.jersey, materials.team.accent);
|
||||
const gear = buildGoalieGear(gearMats);
|
||||
gear.attachTo(skelData.bones);
|
||||
|
||||
const animator = buildGoalieAnimator(skelData, mover);
|
||||
animator.stick = gear.stick;
|
||||
|
||||
const spawnX = line - end * GOALIE.depth;
|
||||
const facing = end > 0 ? -Math.PI / 2 : Math.PI / 2;
|
||||
mover.position.set(spawnX, 0, 0);
|
||||
mover.rotation.y = facing;
|
||||
animator.setTransform(mover.position, facing);
|
||||
mover.updateMatrixWorld(true);
|
||||
assertNoNaNBones(skelData);
|
||||
|
||||
// ---- colliders ----------------------------------------------------------
|
||||
// Kinematic: the puck bounces off, the goalie does not get pushed around.
|
||||
// Kept as simple pad+body shapes rather than 18 bone capsules — a goalie's
|
||||
// job is to be a wall the puck can hit, not a ragdoll that falls over.
|
||||
let body = null;
|
||||
const api = physics?.api;
|
||||
if (physics) {
|
||||
const bd = api.b3DefaultBodyDef();
|
||||
bd.type = api.b3BodyType.b3_kinematicBody;
|
||||
bd.position = xyz(spawnX, 0, 0);
|
||||
bd.enableSleep = false;
|
||||
body = api.b3CreateBody(physics.world, bd);
|
||||
|
||||
const sd = api.b3DefaultShapeDef();
|
||||
sd.enableContactEvents = true;
|
||||
sd.baseMaterial.friction = 0.5;
|
||||
// Pads absorb. A puck pinging off a goalie like a wall is the single most
|
||||
// arcade-looking thing a hockey game can do.
|
||||
sd.baseMaterial.restitution = 0.18;
|
||||
sd.baseMaterial.userMaterialId = makeTag(KIND.BODY, index, 0);
|
||||
sd.filter.categoryBits = CAT.skater(index % 12);
|
||||
// Puck and skaters only — never the rink, which a kinematic body ignores.
|
||||
sd.filter.maskBits = CAT.PUCK | CAT.PROXY;
|
||||
|
||||
api.b3CreateBoxShape(body, sd, GOALIE.padDepth / 2, GOALIE.padHeight / 2, GOALIE.padWidth / 2);
|
||||
api.b3CreateCapsuleShape(body, sd, {
|
||||
center1: xyz(0, GOALIE.bodyLow, 0),
|
||||
center2: xyz(0, GOALIE.bodyHigh, 0),
|
||||
radius: GOALIE.bodyRadius,
|
||||
});
|
||||
}
|
||||
|
||||
const target = { x: spawnX, z: 0 };
|
||||
const pos = { x: spawnX, z: 0 };
|
||||
/** Lagged puck position, which is what they actually react to. */
|
||||
const seen = { x: 0, z: 0 };
|
||||
/** Last raw puck sample, for a cheap velocity estimate. */
|
||||
const lastPuck = { x: 0, y: 0.05, z: 0 };
|
||||
let seenInit = false;
|
||||
let placed = false;
|
||||
let hadPuck = false;
|
||||
|
||||
const _p = new THREE.Vector3();
|
||||
const _q = new THREE.Quaternion();
|
||||
const _scale = new THREE.Vector3();
|
||||
const _up = new THREE.Vector3(0, 1, 0);
|
||||
|
||||
return {
|
||||
end,
|
||||
index,
|
||||
team,
|
||||
/** @deprecated use mover — kept so older callers that read .group still work */
|
||||
get group() { return mover; },
|
||||
mover,
|
||||
body,
|
||||
pos,
|
||||
animator,
|
||||
skelData,
|
||||
gear,
|
||||
bodyMesh,
|
||||
|
||||
/** Reset to the middle of the crease. */
|
||||
reset() {
|
||||
pos.x = line - end * GOALIE.depth;
|
||||
pos.z = 0;
|
||||
seenInit = false;
|
||||
hadPuck = false;
|
||||
placed = false;
|
||||
const yaw = end > 0 ? -Math.PI / 2 : Math.PI / 2;
|
||||
mover.position.set(pos.x, 0, pos.z);
|
||||
mover.rotation.y = yaw;
|
||||
animator.setTransform(mover.position, yaw);
|
||||
animator.moveSpeed = 0;
|
||||
animator.lateralVel = 0;
|
||||
animator.threatened = 0;
|
||||
animator.setState('ready', 0.05);
|
||||
},
|
||||
|
||||
/**
|
||||
* Track the puck. `dt` on the frame clock.
|
||||
* `puck` is anything with `{x,y,z}` — the shootout passes a Vector3.
|
||||
* Returns the current position so callers can watch it.
|
||||
*/
|
||||
update(dt, puck) {
|
||||
const px = puck.x;
|
||||
const py = puck.y ?? 0.05;
|
||||
const pz = puck.z;
|
||||
|
||||
// Reaction lag: they play the puck where they saw it, not where it is.
|
||||
if (!seenInit) {
|
||||
seen.x = px;
|
||||
seen.z = pz;
|
||||
seenInit = true;
|
||||
} else {
|
||||
const k = clamp(dt / Math.max(1e-3, GOALIE.lag), 0, 1);
|
||||
seen.x += (px - seen.x) * k;
|
||||
seen.z += (pz - seen.z) * k;
|
||||
}
|
||||
|
||||
// Velocity from samples — the shootout only hands over a position.
|
||||
let pvx = 0;
|
||||
let pvz = 0;
|
||||
if (hadPuck && dt > 1e-6) {
|
||||
pvx = (px - lastPuck.x) / dt;
|
||||
pvz = (pz - lastPuck.z) / dt;
|
||||
}
|
||||
lastPuck.x = px;
|
||||
lastPuck.y = py;
|
||||
lastPuck.z = pz;
|
||||
hadPuck = true;
|
||||
|
||||
goalieSpot(seen, end, GOALIE.depth, target);
|
||||
|
||||
// A puck already behind them gets a desperation push across, which is
|
||||
// why a slow deke beats them and a fast one sometimes does not.
|
||||
const beaten = end > 0 ? px > pos.x : px < pos.x;
|
||||
const speed = GOALIE.speed * (beaten ? 1 + GOALIE.desperation : 1);
|
||||
|
||||
const dx = target.x - pos.x;
|
||||
const dz = target.z - pos.z;
|
||||
const dist = Math.hypot(dx, dz);
|
||||
const step = speed * dt;
|
||||
const z0 = pos.z;
|
||||
if (dist <= step || dist < 1e-6) {
|
||||
pos.x = target.x;
|
||||
pos.z = target.z;
|
||||
} else {
|
||||
pos.x += (dx / dist) * step;
|
||||
pos.z += (dz / dist) * step;
|
||||
}
|
||||
|
||||
// Square up to the puck.
|
||||
const yaw = Math.atan2(px - pos.x, pz - pos.z);
|
||||
mover.position.set(pos.x, 0, pos.z);
|
||||
mover.rotation.y = yaw;
|
||||
|
||||
// Lateral velocity is along world Z in the crease (nets face ±X).
|
||||
const latVel = dt > 1e-6 ? (pos.z - z0) / dt : 0;
|
||||
const puckDist = Math.hypot(px - pos.x, pz - pos.z);
|
||||
const puckSpeed = Math.hypot(pvx, pvz);
|
||||
const closing = end > 0 ? pvx > 0.5 : pvx < -0.5;
|
||||
// Proximity alone is enough to load a stance — a deke at the crease
|
||||
// should draw a butterfly even if the puck is not a rocket. Speed and
|
||||
// closing just push the same signal harder.
|
||||
const near = clamp(1 - puckDist / GOALIE.threatDist, 0, 1);
|
||||
const rush = clamp(puckSpeed / GOALIE.threatSpeed, 0, 1);
|
||||
const threat = clamp(
|
||||
near * 0.55
|
||||
+ near * rush * 0.45
|
||||
+ (closing ? near * 0.25 : 0),
|
||||
0,
|
||||
1,
|
||||
);
|
||||
|
||||
animator.setTransform(mover.position, yaw);
|
||||
animator.moveSpeed = Math.abs(latVel) + (dist > step ? speed * 0.25 : 0);
|
||||
animator.lateralVel = latVel;
|
||||
animator.puckHeight = py;
|
||||
animator.puckDist = puckDist;
|
||||
animator.threatened = threat;
|
||||
animator.update(dt);
|
||||
|
||||
return pos;
|
||||
},
|
||||
|
||||
/** Push the pose into the kinematic collider, once per substep. */
|
||||
syncPhysics(dt) {
|
||||
if (!body) return;
|
||||
mover.updateWorldMatrix(true, false);
|
||||
mover.matrixWorld.decompose(_p, _q, _scale);
|
||||
// Physics body stays upright on the ice; presentation lean is visual only.
|
||||
_q.setFromAxisAngle(_up, animator.originYaw);
|
||||
_p.y = 0;
|
||||
if (!placed) {
|
||||
api.b3Body_SetTransform(body, vec3(_p), quat(_q));
|
||||
placed = true;
|
||||
return;
|
||||
}
|
||||
api.b3Body_SetTargetTransform(body, transform(_p, _q), dt, true);
|
||||
},
|
||||
|
||||
/** True when the puck is inside the goalie's body — a save in progress. */
|
||||
covers(puck) {
|
||||
const dx = puck.x - pos.x;
|
||||
const dz = puck.z - pos.z;
|
||||
return Math.hypot(dx, dz) < GOALIE.bodyRadius + 0.14;
|
||||
},
|
||||
|
||||
destroy() {
|
||||
if (body && api) api.b3DestroyBody(body);
|
||||
gear.destroy();
|
||||
for (const m of Object.values(gearMats)) m.dispose();
|
||||
scene.remove(mover);
|
||||
disposeObject(mover);
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
export { NET };
|
||||
@@ -0,0 +1,678 @@
|
||||
import * as THREE from 'three';
|
||||
import { clamp, smooth } from '../core/math.js';
|
||||
import { carvedShell, loft, mergeBars, tint, tube } from './gearMesh.js';
|
||||
|
||||
/**
|
||||
* Goalie equipment, socketed to skeleton bones.
|
||||
*
|
||||
* Placement is tuned against `shots/img2mesh/ref/goalie-equipment.png`:
|
||||
* - pad faces toward the shooter (front of the shin), boot on the ice
|
||||
* - trapper open on the glove-side hip
|
||||
* - blocker as a flat board on the stick hand
|
||||
* - paddle flat in the five-hole, shaft up into the blocker hand
|
||||
* - mask + cage on the head, chest plate snug on the torso
|
||||
*
|
||||
* The pieces that carry the silhouette — pads, mask, gloves, chest — are single
|
||||
* lofted or shelled meshes rather than stacks of boxes. A pad is one surface
|
||||
* from the thigh rise through the knee break to the toe; the mask is a shell
|
||||
* with a hole cut for the face and a cage bent over it.
|
||||
*
|
||||
* Bone axes (rest): every rest rotation is identity, so a bone's local axes are
|
||||
* the mover's. The shin runs almost straight down −Y, but the hands and upper
|
||||
* arms run out *and* down (A-pose), so glove and floater groups are rotated
|
||||
* onto their bone's real direction instead of being hung off −Y.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Numbers the builders read. Pads, gloves and the chest are described by their
|
||||
* section tables further down rather than by scalars — a loft's shape lives in
|
||||
* its keys — so only the mask, whose surface is a formula, needs constants.
|
||||
*/
|
||||
export const GEAR = {
|
||||
mask: {
|
||||
/** Skull centre in head-bone-local space (head bone sits at the jaw hinge). */
|
||||
riseY: 0.094,
|
||||
pushZ: -0.006,
|
||||
rx: 0.118,
|
||||
ry: 0.156,
|
||||
rz: 0.128,
|
||||
/** Polar angle the shell starts at — below the chin, open at the neck. */
|
||||
phi0: 0.52,
|
||||
wall: 0.011,
|
||||
/** Face opening, relative to the skull centre. */
|
||||
portW: 0.076,
|
||||
portH: 0.054,
|
||||
portY: -0.004,
|
||||
/** Cage: an ellipse bowed out in front of the opening. */
|
||||
cageW: 0.092,
|
||||
cageH: 0.070,
|
||||
cageBase: 0.088,
|
||||
cageBulge: 0.052,
|
||||
barR: 0.0045,
|
||||
},
|
||||
};
|
||||
|
||||
/** Rest direction a bone's limb actually points, in that bone's local space. */
|
||||
const ARM_DIR = {
|
||||
L: new THREE.Vector3(0.15, -0.252, 0.01).normalize(),
|
||||
R: new THREE.Vector3(-0.15, -0.252, 0.01).normalize(),
|
||||
};
|
||||
const DOWN = new THREE.Vector3(0, -1, 0);
|
||||
|
||||
/** Rest direction the fingers point, from the hand bone. */
|
||||
const HAND_DIR = {
|
||||
L: new THREE.Vector3(0.045, -0.095, 0.008).normalize(),
|
||||
R: new THREE.Vector3(-0.045, -0.095, 0.008).normalize(),
|
||||
};
|
||||
|
||||
/**
|
||||
* Glove grips, in hand-bone-local space.
|
||||
*
|
||||
* Both gloves are modelled facing +Z with the body running down −Y, and both
|
||||
* are put on the hand the same way: −Y is aligned to the hand's own axis, so
|
||||
* the glove carries on out of the wrist the way a hand does, and the *only*
|
||||
* free variable left is the roll about that axis.
|
||||
*
|
||||
* That constraint matters. Solving for a free orientation — "pocket at the
|
||||
* shooter, fingers up" — squares the glove to the puck but stands it off the
|
||||
* wrist at an angle no arm makes. Rolling around the hand keeps the join
|
||||
* honest and still gets the pocket and the board most of the way round.
|
||||
*
|
||||
* The two angles below were solved against the ready stance: for each, the
|
||||
* roll whose pocket normal lands closest to the shooter.
|
||||
*/
|
||||
const GRIP_ROLL = { trapper: 1.499, blocker: 5.369 };
|
||||
|
||||
function handGrip(side, roll) {
|
||||
const dir = HAND_DIR[side];
|
||||
const align = new THREE.Quaternion().setFromUnitVectors(DOWN, dir);
|
||||
return new THREE.Quaternion().setFromAxisAngle(dir, roll).multiply(align);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {{
|
||||
* kit: THREE.Material, pad: THREE.Material, painted: THREE.Material,
|
||||
* accent: THREE.Material, leather: THREE.Material, web: THREE.Material,
|
||||
* cage: THREE.Material, dark: THREE.Material,
|
||||
* }} mats
|
||||
*/
|
||||
export function buildGoalieGear(mats) {
|
||||
const pieces = [];
|
||||
const disposables = [];
|
||||
|
||||
const PAL = {
|
||||
base: tint(mats.pad.color),
|
||||
accent: tint(mats.accent.color),
|
||||
jersey: tint(mats.kit.color),
|
||||
trim: tint(mats.dark.color),
|
||||
};
|
||||
|
||||
function mesh(geo, mat, name) {
|
||||
const m = new THREE.Mesh(geo, mat);
|
||||
m.name = name;
|
||||
m.castShadow = true;
|
||||
m.receiveShadow = true;
|
||||
disposables.push(geo);
|
||||
return m;
|
||||
}
|
||||
|
||||
const V = (x, y, z) => new THREE.Vector3(x, y, z);
|
||||
/** Loft section shorthand. */
|
||||
const S = (c, rx, rz, e, col) => ({ c, rx, rz, e, col });
|
||||
|
||||
/** Point a group's −Y down a bone's real limb direction. */
|
||||
function alignTo(group, dir) {
|
||||
group.quaternion.setFromUnitVectors(DOWN, dir);
|
||||
return group;
|
||||
}
|
||||
|
||||
// ---- leg pads ------------------------------------------------------------
|
||||
// One continuous surface: thigh rise → knee break → shin → boot → toe kick.
|
||||
// The shin bone runs down −Y, so the loft path only has to bend forward at
|
||||
// the ankle for the toe. Bands are cut by doubling sections at the same
|
||||
// height — smoothstep between two rings a centimetre apart is a hard edge.
|
||||
function makePad(side) {
|
||||
const s = side === 'L' ? 1 : -1;
|
||||
const g = new THREE.Group();
|
||||
g.name = `pad${side}`;
|
||||
|
||||
const W = 0.152; // half face width
|
||||
const D = 0.066; // half depth
|
||||
const z0 = 0.052; // pad centre stands proud of the shin front
|
||||
|
||||
// Bands are cut by pairing sections a centimetre apart: smoothstep over
|
||||
// that gap is an edge, over ten centimetres it is a gradient.
|
||||
const face = loft([
|
||||
S(V(0, 0.295, z0 - 0.012), W * 0.74, D * 0.72, 4, PAL.base),
|
||||
S(V(0, 0.225, z0 + 0.008), W * 0.94, D * 0.86, 5),
|
||||
// Knee break — the widest point, with a team band across it.
|
||||
S(V(0, 0.175, z0 + 0.02), W * 1.03, D * 0.97, 6),
|
||||
S(V(0, 0.165, z0 + 0.022), W * 1.04, D * 0.98, 6, PAL.accent),
|
||||
S(V(0, 0.10, z0 + 0.026), W * 1.06, D * 1.0, 6),
|
||||
S(V(0, 0.09, z0 + 0.025), W * 1.03, D * 0.99, 6, PAL.base),
|
||||
S(V(0, -0.02, z0 + 0.012), W, D * 0.94, 6),
|
||||
// Mid-shin stripe pair.
|
||||
S(V(0, -0.135, z0 + 0.007), W, D * 0.92, 6),
|
||||
S(V(0, -0.145, z0 + 0.006), W, D * 0.92, 6, PAL.accent),
|
||||
S(V(0, -0.20, z0 + 0.004), W, D * 0.92, 6),
|
||||
S(V(0, -0.21, z0 + 0.004), W, D * 0.92, 6, PAL.base),
|
||||
S(V(0, -0.37, z0 + 0.008), W * 1.01, D * 0.96, 6),
|
||||
// Boot channel: wider, deeper, and dark like the ref's landing gear.
|
||||
S(V(0, -0.425, z0 + 0.014), W * 1.03, D * 1.02, 6),
|
||||
S(V(0, -0.44, z0 + 0.018), W * 1.05, D * 1.06, 6, PAL.trim),
|
||||
S(V(0, -0.485, z0 + 0.045), W * 0.98, D * 0.86, 5),
|
||||
// Toe kicks forward over the skate, and no further.
|
||||
S(V(0, -0.505, z0 + 0.09), W * 0.84, D * 0.6, 4),
|
||||
S(V(0, -0.512, z0 + 0.128), W * 0.58, D * 0.36, 3),
|
||||
], { radial: 22, sub: 5 });
|
||||
g.add(mesh(face, mats.painted, `pad${side}Face`));
|
||||
|
||||
// Outer roll — the thick rolled edge that gives a pad its profile.
|
||||
const rail = loft([
|
||||
S(V(s * W * 0.94, 0.21, z0 + 0.01), 0.022, 0.028, 3, PAL.accent),
|
||||
S(V(s * W * 1.0, 0.11, z0 + 0.026), 0.028, 0.036, 3),
|
||||
S(V(s * W * 0.96, -0.05, z0 + 0.014), 0.026, 0.034, 3),
|
||||
S(V(s * W * 0.96, -0.24, z0 + 0.006), 0.026, 0.034, 3),
|
||||
S(V(s * W * 1.0, -0.41, z0 + 0.01), 0.028, 0.036, 3),
|
||||
S(V(s * W * 0.98, -0.48, z0 + 0.038), 0.024, 0.028, 3),
|
||||
], { radial: 12, sub: 4 });
|
||||
g.add(mesh(rail, mats.painted, `pad${side}Rail`));
|
||||
|
||||
// Knee stack — the block that lands on the ice in a butterfly.
|
||||
const knee = loft([
|
||||
S(V(-s * 0.02, 0.165, z0 - 0.03), W * 0.6, 0.042, 4, PAL.base),
|
||||
S(V(-s * 0.042, 0.105, z0 - 0.048), W * 0.64, 0.05, 4),
|
||||
S(V(-s * 0.055, 0.045, z0 - 0.052), W * 0.54, 0.044, 4),
|
||||
], { radial: 14, sub: 4 });
|
||||
g.add(mesh(knee, mats.painted, `pad${side}Knee`));
|
||||
|
||||
// Calf wrap so the back of the leg is not naked from the side.
|
||||
const calf = loft([
|
||||
S(V(0, 0.05, -0.028), W * 0.64, 0.048, 4, PAL.trim),
|
||||
S(V(0, -0.14, -0.032), W * 0.68, 0.052, 4),
|
||||
S(V(0, -0.31, -0.028), W * 0.66, 0.048, 4),
|
||||
S(V(0, -0.40, -0.008), W * 0.58, 0.042, 4),
|
||||
], { radial: 14, sub: 4 });
|
||||
g.add(mesh(calf, mats.painted, `pad${side}Calf`));
|
||||
|
||||
// Toe / boot straps.
|
||||
const strapPts = [
|
||||
V(-W * 1.08, -0.465, z0 + 0.015),
|
||||
V(0, -0.47, z0 + 0.06),
|
||||
V(W * 1.08, -0.465, z0 + 0.015),
|
||||
];
|
||||
g.add(mesh(tube(strapPts, 0.008, { radial: 6 }), mats.leather, `pad${side}Strap`));
|
||||
|
||||
// Pads sit slightly toed-out on the leg.
|
||||
g.rotation.z = -s * 0.05;
|
||||
pieces.push(g);
|
||||
return g;
|
||||
}
|
||||
|
||||
const padL = makePad('L');
|
||||
const padR = makePad('R');
|
||||
|
||||
// ---- mask ----------------------------------------------------------------
|
||||
// A shell, not a helmet-shaped blob: the surface function carries the jaw
|
||||
// taper, cheekbones, brow ridge and occipital shelf, the face opening is cut
|
||||
// straight out of the mesh (with a walled rim you can see the thickness of),
|
||||
// and the cage is bent over the hole on its own bowed ellipse.
|
||||
const M = GEAR.mask;
|
||||
const skull = new THREE.Vector3(0, M.riseY, M.pushZ);
|
||||
|
||||
function maskSurface(theta, v, out) {
|
||||
const phi = M.phi0 + (Math.PI - M.phi0) * v;
|
||||
const sp = Math.sin(phi);
|
||||
const cp = Math.cos(phi);
|
||||
const f = Math.cos(theta); // +1 dead ahead
|
||||
const sx = Math.sin(theta); // ±1 at the ears
|
||||
const front = Math.max(0, f);
|
||||
const back = Math.max(0, -f);
|
||||
// 1 down at the chin, 0 by the cheekbones.
|
||||
const low = smooth(clamp((0.40 - v) / 0.34, 0, 1));
|
||||
|
||||
let rx = M.rx;
|
||||
let rz = M.rz;
|
||||
// Jaw narrows off the cheekbones; cheeks themselves flare.
|
||||
rx *= 1 - 0.26 * low;
|
||||
rx *= 1 + 0.07 * Math.exp(-(((v - 0.40) / 0.17) ** 2)) * Math.abs(sx);
|
||||
// Back of the head carries the shell out over the occiput.
|
||||
rz *= 1 + 0.13 * back * smooth(clamp((v - 0.10) / 0.5, 0, 1));
|
||||
// Face is a plate, not a dome — flatten the front through the eye band.
|
||||
rz *= 1 - 0.13 * front * front * Math.exp(-(((v - 0.52) / 0.30) ** 2));
|
||||
|
||||
let x = rx * sp * sx;
|
||||
let y = -M.ry * cp;
|
||||
let z = rz * sp * f;
|
||||
|
||||
// Chin cup pushes forward and tucks up under the face.
|
||||
z += 0.032 * low * front;
|
||||
y += 0.016 * low * front;
|
||||
// Brow ridge over the port.
|
||||
const brow = Math.exp(-(((v - 0.60) / 0.085) ** 2)) * front ** 1.5;
|
||||
z += 0.011 * brow;
|
||||
y += 0.004 * brow;
|
||||
// Crown keel — the raised centre spine of a goalie shell.
|
||||
const keel = Math.exp(-((sx / 0.30) ** 2)) * smooth(clamp((v - 0.45) / 0.4, 0, 1));
|
||||
y += 0.006 * keel;
|
||||
|
||||
return out.set(skull.x + x, skull.y + y, skull.z + z);
|
||||
}
|
||||
|
||||
/** Squared-off ellipse over the eyes — the hole the cage covers. */
|
||||
function portField(p) {
|
||||
const dx = Math.abs(p.x) / M.portW;
|
||||
const dy = Math.abs(p.y - skull.y - M.portY) / M.portH;
|
||||
return dx ** 2.3 + dy ** 2.3;
|
||||
}
|
||||
const inPort = (p) => p.z - skull.z > 0.03 && portField(p) < 1;
|
||||
|
||||
const maskColor = (p, kind) => {
|
||||
if (kind === 'inner') return PAL.trim;
|
||||
const dy = p.y - skull.y;
|
||||
const dz = p.z - skull.z;
|
||||
// Dark trim ringing the face opening.
|
||||
if (dz > 0.0 && portField(p) < 1.4) return PAL.trim;
|
||||
// Chin cup and the neck edge below it.
|
||||
if (dy < -0.095) return PAL.trim;
|
||||
// Keel stripe over the crown, front to back — the one graphic on the shell.
|
||||
if (Math.abs(p.x) < 0.024 && dy > 0.0) return PAL.accent;
|
||||
return PAL.base;
|
||||
};
|
||||
|
||||
const mask = new THREE.Group();
|
||||
mask.name = 'mask';
|
||||
const shell = carvedShell({
|
||||
// Dense enough that the brow and jaw read in a goal-cam closeup, no denser
|
||||
// — this is the one piece with a two-sided wall, so rows × cols doubles.
|
||||
rows: 36,
|
||||
cols: 48,
|
||||
thickness: M.wall,
|
||||
center: skull,
|
||||
surface: maskSurface,
|
||||
port: inPort,
|
||||
color: maskColor,
|
||||
});
|
||||
mask.add(mesh(shell, mats.painted, 'maskShell'));
|
||||
|
||||
// Cage: bars ride a forward-bowed ellipse so they stand off the face.
|
||||
const cageAt = (x, dy) => {
|
||||
const k = 1 - (x / M.cageW) ** 2 - (dy / M.cageH) ** 2;
|
||||
const z = skull.z + M.cageBase + M.cageBulge * Math.sqrt(Math.max(0, k));
|
||||
return V(x, skull.y + M.portY + dy, z);
|
||||
};
|
||||
const bars = [];
|
||||
// Horizontal bars, densest across the eyes.
|
||||
for (const dy of [-0.050, -0.028, -0.008, 0.014, 0.038, 0.058]) {
|
||||
const span = M.cageW * Math.sqrt(Math.max(0, 1 - (dy / M.cageH) ** 2));
|
||||
if (span < 0.022) continue;
|
||||
const pts = [];
|
||||
for (let i = 0; i <= 8; i++) {
|
||||
const x = -span + (2 * span * i) / 8;
|
||||
pts.push(cageAt(clamp(x, -span * 0.995, span * 0.995), dy));
|
||||
}
|
||||
bars.push(tube(pts, M.barR, { radial: 6 }));
|
||||
}
|
||||
// Vertical bars.
|
||||
for (const x of [-0.050, -0.018, 0.018, 0.050]) {
|
||||
const span = M.cageH * Math.sqrt(Math.max(0, 1 - (x / M.cageW) ** 2));
|
||||
if (span < 0.02) continue;
|
||||
const pts = [];
|
||||
for (let i = 0; i <= 8; i++) {
|
||||
const dy = -span + (2 * span * i) / 8;
|
||||
pts.push(cageAt(x, clamp(dy, -span * 0.995, span * 0.995)));
|
||||
}
|
||||
bars.push(tube(pts, M.barR, { radial: 6 }));
|
||||
}
|
||||
// Perimeter frame, sunk onto the shell so the cage anchors into it.
|
||||
{
|
||||
const ring = [];
|
||||
for (let i = 0; i < 24; i++) {
|
||||
const a = (i / 24) * Math.PI * 2;
|
||||
const x = M.cageW * 1.02 * Math.cos(a);
|
||||
const dy = M.cageH * 1.02 * Math.sin(a);
|
||||
const p = cageAt(x, dy);
|
||||
p.z -= 0.004;
|
||||
ring.push(p);
|
||||
}
|
||||
bars.push(tube(ring, M.barR * 1.3, { radial: 6, closed: true, segments: 72 }));
|
||||
}
|
||||
mask.add(mesh(mergeBars(bars), mats.cage, 'maskCage'));
|
||||
|
||||
// Throat dangler on its own strap, like the ref photo.
|
||||
const bib = loft([
|
||||
S(V(0, skull.y - 0.155, skull.z + 0.055), 0.055, 0.012, 4, PAL.accent),
|
||||
S(V(0, skull.y - 0.20, skull.z + 0.058), 0.062, 0.013, 4),
|
||||
S(V(0, skull.y - 0.245, skull.z + 0.05), 0.05, 0.012, 4),
|
||||
], { radial: 12, sub: 4 });
|
||||
mask.add(mesh(bib, mats.painted, 'maskBib'));
|
||||
mask.add(mesh(
|
||||
tube([
|
||||
V(-0.048, skull.y - 0.115, skull.z + 0.04),
|
||||
V(0, skull.y - 0.135, skull.z + 0.06),
|
||||
V(0.048, skull.y - 0.115, skull.z + 0.04),
|
||||
], 0.005, { radial: 5 }),
|
||||
mats.leather,
|
||||
'maskBibStrap',
|
||||
));
|
||||
pieces.push(mask);
|
||||
|
||||
// ---- trapper (catch glove) — left hand ----------------------------------
|
||||
// Built in glove space (fingers down −Y, back of the hand +Z) then rotated
|
||||
// onto the hand bone's real axis. Cuff and pillow are one lofted body; the
|
||||
// pocket is a rim tube with the web recessed inside it.
|
||||
const trapper = new THREE.Group();
|
||||
trapper.name = 'trapper';
|
||||
{
|
||||
const body = loft([
|
||||
S(V(0, 0.045, 0.005), 0.05, 0.048, 3),
|
||||
S(V(0, -0.03, 0.012), 0.058, 0.055, 3),
|
||||
S(V(0, -0.09, 0.022), 0.07, 0.062, 3),
|
||||
S(V(0.008, -0.15, 0.035), 0.076, 0.066, 3),
|
||||
S(V(0.01, -0.20, 0.042), 0.062, 0.054, 3),
|
||||
], { radial: 16, sub: 5 });
|
||||
trapper.add(mesh(body, mats.leather, 'trapperBody'));
|
||||
|
||||
// Pocket assembly is canted off the hand axis. A catching face built square
|
||||
// to the wrist can only ever aim wherever the forearm happens to point;
|
||||
// real gear is angled across it, which is what lets the pocket face the
|
||||
// shooter while the glove still runs out of the hand.
|
||||
const pocket = new THREE.Group();
|
||||
pocket.name = 'trapperPocket';
|
||||
pocket.rotation.x = -0.32;
|
||||
|
||||
// The catching face is a dish swept forward off the palm: solid leather
|
||||
// backing, squared off like a real mitt rather than a circle.
|
||||
const cup = loft([
|
||||
S(V(0.008, -0.115, 0.01), 0.062, 0.072, 3),
|
||||
S(V(0.01, -0.12, 0.05), 0.09, 0.108, 4),
|
||||
S(V(0.012, -0.125, 0.082), 0.098, 0.118, 4.5),
|
||||
S(V(0.012, -0.125, 0.095), 0.09, 0.108, 4),
|
||||
], { radial: 20, sub: 5 });
|
||||
pocket.add(mesh(cup, mats.leather, 'trapperCup'));
|
||||
|
||||
// Web pillow proud of the cup mouth — the light face a shooter sees. Sunk
|
||||
// behind the rim it just reads as a black frying pan.
|
||||
const web = loft([
|
||||
S(V(0.012, -0.125, 0.088), 0.078, 0.094, 4),
|
||||
S(V(0.012, -0.125, 0.112), 0.082, 0.098, 4),
|
||||
S(V(0.012, -0.125, 0.124), 0.068, 0.082, 3.5),
|
||||
], { radial: 18, sub: 4 });
|
||||
pocket.add(mesh(web, mats.web, 'trapperWeb'));
|
||||
|
||||
// Rim binding around the pocket mouth.
|
||||
const rimPts = [];
|
||||
for (let i = 0; i < 24; i++) {
|
||||
const a = (i / 24) * Math.PI * 2;
|
||||
const [cx, cy] = [Math.cos(a), Math.sin(a)];
|
||||
rimPts.push(V(
|
||||
0.012 + 0.094 * Math.sign(cx) * Math.abs(cx) ** 0.55,
|
||||
-0.125 + 0.112 * Math.sign(cy) * Math.abs(cy) ** 0.55,
|
||||
0.104,
|
||||
));
|
||||
}
|
||||
pocket.add(mesh(
|
||||
tube(rimPts, 0.012, { radial: 7, closed: true, segments: 72 }),
|
||||
mats.accent,
|
||||
'trapperRim',
|
||||
));
|
||||
trapper.add(pocket);
|
||||
|
||||
// Thumb stall curls off the inside edge.
|
||||
const thumb = loft([
|
||||
S(V(0.07, -0.04, 0.03), 0.028, 0.026, 3),
|
||||
S(V(0.105, -0.075, 0.06), 0.03, 0.028, 3),
|
||||
S(V(0.115, -0.13, 0.085), 0.026, 0.024, 3),
|
||||
], { radial: 12, sub: 4 });
|
||||
trapper.add(mesh(thumb, mats.leather, 'trapperThumb'));
|
||||
|
||||
// Cuff.
|
||||
const cuff = loft([
|
||||
S(V(0, 0.10, -0.005), 0.055, 0.052, 4, PAL.base),
|
||||
S(V(0, 0.035, 0.0), 0.062, 0.058, 4),
|
||||
], { radial: 14, sub: 4 });
|
||||
trapper.add(mesh(cuff, mats.painted, 'trapperCuff'));
|
||||
}
|
||||
trapper.quaternion.copy(handGrip('L', GRIP_ROLL.trapper));
|
||||
pieces.push(trapper);
|
||||
|
||||
// ---- blocker — right hand -----------------------------------------------
|
||||
// The board is one lofted slab: rounded rectangle in section, swept forward
|
||||
// off the back of the hand so the face squares to the shooter.
|
||||
const blocker = new THREE.Group();
|
||||
blocker.name = 'blocker';
|
||||
{
|
||||
// Board is canted off the hand for the same reason the trapper pocket is:
|
||||
// square to the wrist, it lies flat whenever the arm reaches forward.
|
||||
const face = new THREE.Group();
|
||||
face.name = 'blockerFace';
|
||||
face.rotation.x = 0.66;
|
||||
|
||||
const board = loft([
|
||||
S(V(-0.005, -0.10, 0.018), 0.082, 0.125, 5, PAL.trim),
|
||||
S(V(-0.005, -0.10, 0.045), 0.098, 0.145, 6, PAL.base),
|
||||
S(V(-0.005, -0.10, 0.078), 0.098, 0.145, 6),
|
||||
S(V(-0.005, -0.10, 0.098), 0.084, 0.128, 5, PAL.accent),
|
||||
], { radial: 20, sub: 5 });
|
||||
face.add(mesh(board, mats.painted, 'blockerBoard'));
|
||||
|
||||
// Sidewall down the outside edge of the board.
|
||||
const wall = loft([
|
||||
S(V(-0.09, 0.02, 0.055), 0.016, 0.03, 4, PAL.trim),
|
||||
S(V(-0.098, -0.10, 0.058), 0.018, 0.034, 4),
|
||||
S(V(-0.09, -0.215, 0.052), 0.016, 0.03, 4),
|
||||
], { radial: 10, sub: 4 });
|
||||
face.add(mesh(wall, mats.painted, 'blockerWall'));
|
||||
blocker.add(face);
|
||||
|
||||
// Glove hand behind the board — the part that holds the stick.
|
||||
const palm = loft([
|
||||
S(V(0, 0.05, 0.0), 0.05, 0.048, 3),
|
||||
S(V(0, -0.035, 0.008), 0.058, 0.055, 3),
|
||||
S(V(0, -0.13, 0.014), 0.055, 0.052, 3),
|
||||
S(V(0, -0.19, 0.012), 0.042, 0.04, 3),
|
||||
], { radial: 14, sub: 4 });
|
||||
blocker.add(mesh(palm, mats.leather, 'blockerPalm'));
|
||||
|
||||
const cuff = loft([
|
||||
S(V(0, 0.105, -0.006), 0.05, 0.048, 4, PAL.base),
|
||||
S(V(0, 0.04, 0.0), 0.058, 0.055, 4),
|
||||
], { radial: 12, sub: 4 });
|
||||
blocker.add(mesh(cuff, mats.painted, 'blockerCuff'));
|
||||
}
|
||||
blocker.quaternion.copy(handGrip('R', GRIP_ROLL.blocker));
|
||||
pieces.push(blocker);
|
||||
|
||||
// ---- chest protector -----------------------------------------------------
|
||||
// One shell from the collar down over the belly, wrapping the torso instead
|
||||
// of floating in front of it.
|
||||
const chest = new THREE.Group();
|
||||
chest.name = 'chest';
|
||||
{
|
||||
const body = loft([
|
||||
S(V(0, 0.15, 0.008), 0.066, 0.062, 3, PAL.trim),
|
||||
S(V(0, 0.10, 0.012), 0.095, 0.082, 4, PAL.jersey),
|
||||
S(V(0, 0.055, 0.014), 0.185, 0.115, 5),
|
||||
S(V(0, -0.03, 0.018), 0.196, 0.126, 5),
|
||||
S(V(0, -0.10, 0.02), 0.19, 0.126, 5, PAL.base),
|
||||
S(V(0, -0.175, 0.018), 0.182, 0.122, 5),
|
||||
S(V(0, -0.235, 0.014), 0.176, 0.116, 5, PAL.jersey),
|
||||
S(V(0, -0.32, 0.01), 0.162, 0.108, 5),
|
||||
S(V(0, -0.38, 0.004), 0.138, 0.095, 4, PAL.trim),
|
||||
], { radial: 24, sub: 5 });
|
||||
chest.add(mesh(body, mats.painted, 'chestBody'));
|
||||
|
||||
// Sternum plate, standing proud like a real chest-and-arm unit.
|
||||
const plate = loft([
|
||||
S(V(0, 0.05, 0.10), 0.088, 0.024, 4, PAL.base),
|
||||
S(V(0, -0.04, 0.115), 0.10, 0.026, 4),
|
||||
S(V(0, -0.14, 0.112), 0.096, 0.024, 4, PAL.accent),
|
||||
S(V(0, -0.22, 0.10), 0.078, 0.02, 4),
|
||||
], { radial: 14, sub: 4 });
|
||||
chest.add(mesh(plate, mats.painted, 'chestPlate'));
|
||||
}
|
||||
pieces.push(chest);
|
||||
|
||||
// Shoulder floaters — parented to the upper arms, aligned to the A-pose axis
|
||||
// so they actually sit on the arm instead of hovering beside it.
|
||||
function makeFloater(side) {
|
||||
const g = new THREE.Group();
|
||||
g.name = `floater${side}`;
|
||||
const cap = loft([
|
||||
S(V(0, 0.055, 0.01), 0.075, 0.072, 3, PAL.base),
|
||||
S(V(0, -0.015, 0.012), 0.094, 0.086, 4),
|
||||
S(V(0, -0.075, 0.01), 0.088, 0.08, 4, PAL.jersey),
|
||||
S(V(0, -0.145, 0.008), 0.076, 0.068, 3),
|
||||
], { radial: 16, sub: 4 });
|
||||
g.add(mesh(cap, mats.painted, `floater${side}Cap`));
|
||||
const arm = loft([
|
||||
S(V(0, -0.16, 0.006), 0.072, 0.066, 3, PAL.jersey),
|
||||
S(V(0, -0.26, 0.004), 0.066, 0.06, 3),
|
||||
S(V(0, -0.315, 0.002), 0.052, 0.048, 3, PAL.trim),
|
||||
], { radial: 14, sub: 4 });
|
||||
g.add(mesh(arm, mats.painted, `floater${side}Arm`));
|
||||
alignTo(g, ARM_DIR[side]);
|
||||
pieces.push(g);
|
||||
return g;
|
||||
}
|
||||
const floaterL = makeFloater('L');
|
||||
const floaterR = makeFloater('R');
|
||||
|
||||
// ---- goalie stick -------------------------------------------------------
|
||||
// Shaft down −Y from the blocker hand into a wide paddle, then a blade that
|
||||
// sits flat on the ice across the five-hole.
|
||||
const stick = new THREE.Group();
|
||||
stick.name = 'goalieStick';
|
||||
let paddleMesh = null;
|
||||
{
|
||||
const shaft = loft([
|
||||
S(V(0, 0.02, 0), 0.014, 0.011, 5, PAL.trim),
|
||||
S(V(0, -0.16, 0.004), 0.014, 0.012, 5),
|
||||
S(V(0, -0.34, 0.008), 0.016, 0.014, 5),
|
||||
S(V(0, -0.46, 0.012), 0.019, 0.018, 5),
|
||||
], { radial: 10, sub: 4 });
|
||||
stick.add(mesh(shaft, mats.painted, 'stickShaft'));
|
||||
|
||||
// Paddle: the wide flat section between shaft and blade. This is the part
|
||||
// that reads as "goalie stick" from twenty metres away, so it is generous.
|
||||
const paddleGeo = loft([
|
||||
S(V(0, -0.46, 0.01), 0.02, 0.03, 5, PAL.trim),
|
||||
S(V(0.004, -0.50, 0.022), 0.019, 0.055, 6),
|
||||
S(V(0.005, -0.515, 0.026), 0.019, 0.07, 6, PAL.base),
|
||||
S(V(0.008, -0.60, 0.055), 0.018, 0.078, 6),
|
||||
S(V(0.01, -0.65, 0.072), 0.017, 0.072, 6),
|
||||
S(V(0.011, -0.665, 0.078), 0.017, 0.06, 6, PAL.trim),
|
||||
], { radial: 14, sub: 5 });
|
||||
const paddle = mesh(paddleGeo, mats.painted, 'paddle');
|
||||
stick.add(paddle);
|
||||
|
||||
// Blade, running across the crease with a curled toe.
|
||||
const blade = loft([
|
||||
S(V(0.012, -0.685, 0.02), 0.016, 0.03, 5, PAL.trim),
|
||||
S(V(0.012, -0.695, 0.12), 0.015, 0.032, 5),
|
||||
S(V(0.014, -0.695, 0.22), 0.014, 0.03, 5),
|
||||
S(V(0.02, -0.688, 0.30), 0.012, 0.024, 4),
|
||||
], { radial: 12, sub: 5 });
|
||||
stick.add(mesh(blade, mats.painted, 'stickBlade'));
|
||||
|
||||
// Knob at the top of the shaft.
|
||||
stick.add(mesh(
|
||||
loft([
|
||||
S(V(0, 0.055, -0.002), 0.017, 0.015, 4, PAL.base),
|
||||
S(V(0, 0.02, 0), 0.016, 0.014, 4),
|
||||
], { radial: 10, sub: 3 }),
|
||||
mats.painted,
|
||||
'stickKnob',
|
||||
));
|
||||
|
||||
// Default grip: overwritten by the animator each frame, but a sane editor
|
||||
// default (paddle toward the ice, slightly in front).
|
||||
stick.position.set(0.03, -0.02, 0.04);
|
||||
stick.rotation.set(0.9, 0.35, 0.55);
|
||||
pieces.push(stick);
|
||||
paddleMesh = paddle;
|
||||
}
|
||||
|
||||
return {
|
||||
padL,
|
||||
padR,
|
||||
trapper,
|
||||
blocker,
|
||||
mask,
|
||||
chest,
|
||||
floaterL,
|
||||
floaterR,
|
||||
stick,
|
||||
paddle: paddleMesh,
|
||||
pieces,
|
||||
|
||||
attachTo(bones) {
|
||||
bones.shinL.add(padL);
|
||||
bones.shinR.add(padR);
|
||||
bones.handL.add(trapper);
|
||||
bones.handR.add(blocker);
|
||||
bones.handR.add(stick);
|
||||
bones.head.add(mask);
|
||||
bones.spine3.add(chest);
|
||||
bones.upperArmL.add(floaterL);
|
||||
bones.upperArmR.add(floaterR);
|
||||
},
|
||||
|
||||
destroy() {
|
||||
for (const p of pieces) p.removeFromParent();
|
||||
for (const g of disposables) g.dispose();
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
export function buildGoalieMaterials(teamJersey, teamAccent = 0xf0e6d2) {
|
||||
return {
|
||||
kit: new THREE.MeshStandardMaterial({
|
||||
color: teamJersey,
|
||||
roughness: 0.72,
|
||||
metalness: 0.04,
|
||||
}),
|
||||
/** Vertex-coloured gear: pads, mask shell, chest, paddle all share it. */
|
||||
painted: new THREE.MeshStandardMaterial({
|
||||
color: 0xffffff,
|
||||
vertexColors: true,
|
||||
roughness: 0.46,
|
||||
metalness: 0.04,
|
||||
}),
|
||||
pad: new THREE.MeshStandardMaterial({
|
||||
color: 0xf7f4ec,
|
||||
roughness: 0.8,
|
||||
metalness: 0.02,
|
||||
}),
|
||||
accent: new THREE.MeshStandardMaterial({
|
||||
color: teamJersey,
|
||||
roughness: 0.6,
|
||||
metalness: 0.03,
|
||||
}),
|
||||
trimAccent: new THREE.MeshStandardMaterial({
|
||||
color: teamAccent,
|
||||
roughness: 0.7,
|
||||
metalness: 0.02,
|
||||
}),
|
||||
leather: new THREE.MeshStandardMaterial({
|
||||
color: 0x1a1a20,
|
||||
roughness: 0.88,
|
||||
metalness: 0.04,
|
||||
}),
|
||||
web: new THREE.MeshStandardMaterial({
|
||||
color: 0xcfc3a8,
|
||||
roughness: 0.92,
|
||||
metalness: 0.0,
|
||||
}),
|
||||
cage: new THREE.MeshStandardMaterial({
|
||||
color: 0x2a2e35,
|
||||
roughness: 0.32,
|
||||
metalness: 0.8,
|
||||
}),
|
||||
dark: new THREE.MeshStandardMaterial({
|
||||
color: 0x121218,
|
||||
roughness: 0.5,
|
||||
metalness: 0.22,
|
||||
}),
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,334 @@
|
||||
import * as THREE from 'three';
|
||||
import { makeRng } from '../core/rng.js';
|
||||
import { disposeObject } from '../core/math.js';
|
||||
import { buildMaterials, paintUnderLayer } from '../render/materials.js';
|
||||
import { assertNoNaNBones, buildSkeleton } from './skeleton.js';
|
||||
import { buildBodyGeometry, buildBodyMesh } from './body.js';
|
||||
import { computeSkin } from './skinning.js';
|
||||
import { buildSkaterGear, buildSkaterGearMaterials, hideCoveredBody } from './skaterGear.js';
|
||||
import { buildAnimator } from '../anim/skateAnimator.js';
|
||||
import { REACTION_ATTACK, createRagdoll } from '../physics/ragdoll.js';
|
||||
import { createBodyProxy } from '../physics/bodyProxy.js';
|
||||
import { buildStick } from './stick.js';
|
||||
import { HIT } from '../game/hits.js';
|
||||
|
||||
const clamp01 = (x) => (x < 0 ? 0 : x > 1 ? 1 : x);
|
||||
|
||||
/**
|
||||
* One skater: mesh, skeleton, ragdoll, proxy capsule, animator.
|
||||
*
|
||||
* This is Ludus's `createFighter` with the loadout, armor, cloth and weapon
|
||||
* systems removed — everything that remains is the part the hockey game needs.
|
||||
* Rebuilding one is a full teardown: geometry and skin weights are derived from
|
||||
* the seed, so there is no partial-update path worth the complexity.
|
||||
*
|
||||
* What it does *not* own: position, velocity, or any decision. Those live in
|
||||
* the sim state and the brain, and arrive here through `applyState`.
|
||||
*/
|
||||
export function createSkater({
|
||||
seed,
|
||||
scene,
|
||||
physics,
|
||||
index = 0,
|
||||
team = 0,
|
||||
position = { x: 0, z: 0 },
|
||||
facing = 0,
|
||||
bodyStyle = null,
|
||||
}) {
|
||||
const rng = makeRng(seed);
|
||||
const materials = buildMaterials(rng, team);
|
||||
const skelData = buildSkeleton();
|
||||
|
||||
const mover = new THREE.Group();
|
||||
mover.name = 'skater:' + index;
|
||||
mover.position.set(position.x, 0, position.z);
|
||||
mover.rotation.y = facing;
|
||||
scene.add(mover);
|
||||
|
||||
const bodyGeo = buildBodyGeometry(rng, bodyStyle);
|
||||
computeSkin(bodyGeo, skelData);
|
||||
paintUnderLayer(bodyGeo, { skinColor: materials.skinColor });
|
||||
const bodyMesh = buildBodyMesh(bodyGeo, skelData, materials);
|
||||
mover.add(bodyMesh);
|
||||
|
||||
// Kit over the top: cloth skinned to the same skeleton, hard shells socketed
|
||||
// to the bones they never bend away from. Sized off the physique the body
|
||||
// loft was built from, so a heavy build gets a bigger jersey.
|
||||
const gearMats = buildSkaterGearMaterials(materials.team.jersey, materials.team.accent);
|
||||
const gear = buildSkaterGear(gearMats, skelData, bodyGeo.userData.physique);
|
||||
gear.attachTo(skelData.bones, mover);
|
||||
// Everything the kit encloses stops being drawn — no body poking through a
|
||||
// seam when a shoulder rolls, and a good chunk of the body's triangles saved.
|
||||
hideCoveredBody(bodyGeo);
|
||||
|
||||
const animator = buildAnimator(skelData, mover);
|
||||
animator.setTransform(mover.position, facing);
|
||||
|
||||
// Socketed to the right hand, not to the mover: the arm pose decides where
|
||||
// the stick is, which is the correct dependency order and the only way the
|
||||
// hands can actually be on it.
|
||||
const stick = buildStick(materials, physics, index);
|
||||
stick.attachTo(skelData.bones.handR);
|
||||
stick.setGrip('carry');
|
||||
animator.stick = stick;
|
||||
|
||||
mover.updateMatrixWorld(true);
|
||||
assertNoNaNBones(skelData);
|
||||
|
||||
// The 18-capsule rig, kinematic and chasing the animation. Nothing pushes it
|
||||
// yet; it is here so that when hits land in a later spike the bodies, joints
|
||||
// and limits already exist and are already in the right place.
|
||||
const ragdoll = physics ? createRagdoll(physics, skelData, { skaterIndex: index }) : null;
|
||||
// The one dynamic body. This is what the boards and other skaters actually
|
||||
// collide with.
|
||||
const proxy = physics ? createBodyProxy(physics, { index, position }) : null;
|
||||
|
||||
const _look = new THREE.Vector3();
|
||||
const _moverInv = new THREE.Matrix4();
|
||||
const _pelvis = new THREE.Vector3();
|
||||
const _chest = new THREE.Vector3();
|
||||
const _flat = new THREE.Vector3();
|
||||
const _scale = new THREE.Vector3();
|
||||
const _rootWorld = new THREE.Matrix4();
|
||||
const _correction = new THREE.Matrix4();
|
||||
|
||||
/**
|
||||
* Stagger envelope: how much of the rendered pose physics owns, over time.
|
||||
* Bites almost instantly, then decays back to the animation — anything
|
||||
* slower on the attack reads as the skater choosing to flinch rather than
|
||||
* being moved by the hit.
|
||||
*/
|
||||
const reaction = { active: false, t: 0, duration: 0, weight: 0, peak: 0 };
|
||||
|
||||
function advanceReaction(dt) {
|
||||
if (!reaction.active) return;
|
||||
reaction.t += dt;
|
||||
if (reaction.t >= reaction.duration) {
|
||||
reaction.active = false;
|
||||
reaction.weight = 0;
|
||||
if (ragdoll && ragdoll.mode === 'reacting') {
|
||||
ragdoll.setJointStiffness(0);
|
||||
ragdoll.setMode('driven');
|
||||
}
|
||||
return;
|
||||
}
|
||||
reaction.weight = reaction.t < REACTION_ATTACK
|
||||
? reaction.peak * (reaction.t / REACTION_ATTACK)
|
||||
: reaction.peak
|
||||
* Math.pow(1 - (reaction.t - REACTION_ATTACK) / Math.max(1e-4, reaction.duration - REACTION_ATTACK), 1.6);
|
||||
}
|
||||
|
||||
const skater = {
|
||||
index,
|
||||
seed,
|
||||
team,
|
||||
rng,
|
||||
materials,
|
||||
skelData,
|
||||
mover,
|
||||
bodyGeo,
|
||||
bodyMesh,
|
||||
gear,
|
||||
animator,
|
||||
ragdoll,
|
||||
proxy,
|
||||
stick,
|
||||
reaction,
|
||||
|
||||
/** True while the ragdoll owns the skeleton and the proxy is switched off. */
|
||||
limp: false,
|
||||
/** Seconds left before a downed skater starts getting up. Null when up. */
|
||||
downFor: null,
|
||||
/** Seconds left of the get-up. Intent is damped while it runs. */
|
||||
rising: 0,
|
||||
/** The hit that put them here, for the HUD and for debugging. */
|
||||
lastHit: null,
|
||||
|
||||
/**
|
||||
* Push one frame of sim state into the presentation layer.
|
||||
*
|
||||
* `yawRate` is the turn rate of the *velocity* vector, not of the body:
|
||||
* the animator banks the skater into the arc they are actually carving,
|
||||
* which is not the same as the way they are pointing.
|
||||
*/
|
||||
applyState(s, yawRate) {
|
||||
_look.set(s.x, 0, s.z);
|
||||
animator.setTransform(_look, s.yaw);
|
||||
animator.moveSpeed = Math.hypot(s.vx, s.vz);
|
||||
animator.bladeSpeed = s.bladeSpeed;
|
||||
animator.effort = s.effort;
|
||||
animator.yawRate = yawRate;
|
||||
animator.braking = !!s.brake;
|
||||
},
|
||||
|
||||
/** Advance animation, the reaction envelope, and the get-up timer. */
|
||||
update(dt) {
|
||||
if (!skater.limp) {
|
||||
if (skater.rising > 0) skater.rising = Math.max(0, skater.rising - dt);
|
||||
animator.update(dt);
|
||||
advanceReaction(dt);
|
||||
}
|
||||
// Bone velocities are measured on the frame clock, continuously, even
|
||||
// though they are only read at the moment a rig goes dynamic — they have
|
||||
// to already be there when that moment arrives.
|
||||
if (ragdoll && !skater.limp) ragdoll.sampleVelocities(dt);
|
||||
},
|
||||
|
||||
/** Countdown while down; returns true on the frame they should get up. */
|
||||
tickDown(dt) {
|
||||
if (!skater.limp || skater.downFor == null) return false;
|
||||
skater.downFor -= dt;
|
||||
return skater.downFor <= 0;
|
||||
},
|
||||
|
||||
/**
|
||||
* Read the physics pose back onto the skeleton.
|
||||
*
|
||||
* Fully while limp; blended against the animated pose during a stagger, so
|
||||
* a flinch deflects the body without erasing the skating underneath it.
|
||||
*/
|
||||
syncFromPhysics() {
|
||||
if (!ragdoll) return;
|
||||
if (skater.limp) {
|
||||
_moverInv.copy(mover.matrixWorld).invert();
|
||||
ragdoll.syncToSkeleton(_moverInv);
|
||||
mover.updateMatrixWorld(true);
|
||||
} else if (reaction.active && reaction.weight > 0) {
|
||||
_moverInv.copy(mover.matrixWorld).invert();
|
||||
// Root excluded: displacing it slides the skater across the ice, which
|
||||
// reads as teleporting rather than as being hit. The proxy owns
|
||||
// position and has already taken the momentum from the collision.
|
||||
ragdoll.blendToSkeleton(_moverInv, reaction.weight, { includeRoot: false });
|
||||
mover.updateMatrixWorld(true);
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* Take a hit without going down: the rig goes dynamic with stiff joints for
|
||||
* a moment, then is blended back onto the animation.
|
||||
*/
|
||||
stagger(hit) {
|
||||
if (!ragdoll || skater.limp) return;
|
||||
skater.lastHit = hit;
|
||||
const s = clamp01((hit.severity - HIT.bump) / (HIT.knockdown - HIT.bump));
|
||||
reaction.active = true;
|
||||
reaction.t = 0;
|
||||
reaction.peak = 0.38 + 0.5 * s;
|
||||
reaction.duration = 0.3 + 0.5 * s;
|
||||
ragdoll.setJointStiffness(HIT.staggerStiffness);
|
||||
ragdoll.setMode('reacting');
|
||||
},
|
||||
|
||||
/**
|
||||
* Go down.
|
||||
*
|
||||
* The handoff: the ragdoll goes dynamic and becomes the body, and the proxy
|
||||
* capsule is switched off. Leaving the proxy enabled would have two bodies
|
||||
* claiming the same skater — the sim would keep driving a capsule around
|
||||
* the rink while the visible ragdoll lay on the ice behind it.
|
||||
*/
|
||||
goDown(hit) {
|
||||
if (!ragdoll || skater.limp) return;
|
||||
skater.lastHit = hit ?? null;
|
||||
skater.limp = true;
|
||||
skater.downFor = HIT.downTime;
|
||||
skater.rising = 0;
|
||||
reaction.active = false;
|
||||
reaction.weight = 0;
|
||||
ragdoll.setJointStiffness(0);
|
||||
ragdoll.setMode('limp');
|
||||
proxy?.disable();
|
||||
},
|
||||
|
||||
/**
|
||||
* Get back up.
|
||||
*
|
||||
* The reverse handoff, and the fiddly half of it. The naive version — read
|
||||
* the pelvis, move the sim there, crossfade — makes the skater visibly fly
|
||||
* out and snap back, for a reason worth writing down:
|
||||
*
|
||||
* While limp, the ragdoll writes the body's displacement into the *root
|
||||
* bone*, because the mover has been parked where they fell for the whole
|
||||
* knockdown. So the world pose is `moverAtFallPosition × bigRootOffset`.
|
||||
* Teleporting the mover onto the pelvis without touching that offset applies
|
||||
* the displacement a second time — the body jumps by however far it slid —
|
||||
* and the crossfade then drags it back as the root offset decays to its
|
||||
* skating value.
|
||||
*
|
||||
* The fix is to re-express the root in the *new* mover frame so the world
|
||||
* pose across the handoff is bit-for-bit identical. Then the crossfade has
|
||||
* no position to undo and only has to interpolate lying → skating, which is
|
||||
* the movement we actually want to see.
|
||||
*/
|
||||
getUp(state) {
|
||||
if (!ragdoll || !skater.limp) return;
|
||||
|
||||
mover.updateMatrixWorld(true);
|
||||
const root = skelData.bones.root;
|
||||
const pelvisBone = ragdoll.parts.pelvis.bone;
|
||||
pelvisBone.getWorldPosition(_pelvis);
|
||||
|
||||
// Which way is this body pointing? The pelvis' own forward axis is no use
|
||||
// — on someone lying face-down it points at the ice. The pelvis→chest
|
||||
// line flattened onto the ice is the body's long axis and survives any
|
||||
// orientation, so a skater stands up facing the way they were sprawled
|
||||
// rather than spinning on the spot to recover a stale yaw.
|
||||
ragdoll.parts.spine3.bone.getWorldPosition(_chest);
|
||||
_flat.set(_chest.x - _pelvis.x, 0, _chest.z - _pelvis.z);
|
||||
const yaw = _flat.lengthSq() > 1e-4
|
||||
? Math.atan2(_flat.x, _flat.z)
|
||||
: (state?.yaw ?? animator.originYaw);
|
||||
|
||||
// Remember the root's exact world transform before anything moves.
|
||||
root.updateWorldMatrix(true, false);
|
||||
_rootWorld.copy(root.matrixWorld);
|
||||
|
||||
// Move the mover onto the body, now, rather than letting the animator do
|
||||
// it next frame — the correction below has to be computed against the
|
||||
// frame the pose will actually be drawn in.
|
||||
mover.position.set(_pelvis.x, 0, _pelvis.z);
|
||||
mover.rotation.set(0, yaw, 0);
|
||||
mover.updateMatrixWorld(true);
|
||||
animator.setTransform(mover.position, yaw);
|
||||
|
||||
// Re-express the root so the skeleton lands in exactly the same world
|
||||
// pose it was already in.
|
||||
_moverInv.copy(mover.matrixWorld).invert();
|
||||
_correction.multiplyMatrices(_moverInv, _rootWorld);
|
||||
_correction.decompose(root.position, root.quaternion, _scale);
|
||||
mover.updateMatrixWorld(true);
|
||||
|
||||
skater.limp = false;
|
||||
skater.downFor = null;
|
||||
// Counted down in update(); the match damps intent while it runs so they
|
||||
// stand up where they fell instead of skating off mid-rise.
|
||||
skater.rising = HIT.riseTime;
|
||||
ragdoll.setJointStiffness(0);
|
||||
// Snaps the bodies onto the skeleton — which has not moved in world
|
||||
// space, so this costs nothing and cannot fling anything.
|
||||
ragdoll.setMode('driven');
|
||||
|
||||
if (state) {
|
||||
state.x = _pelvis.x;
|
||||
state.z = _pelvis.z;
|
||||
state.yaw = yaw;
|
||||
state.vx = 0;
|
||||
state.vz = 0;
|
||||
}
|
||||
proxy?.enable(_pelvis.x, _pelvis.z);
|
||||
animator.rebase(HIT.riseTime);
|
||||
},
|
||||
|
||||
dispose() {
|
||||
stick.destroy(physics?.api);
|
||||
gear.destroy();
|
||||
for (const m of Object.values(gearMats)) m.dispose();
|
||||
if (ragdoll) ragdoll.destroy();
|
||||
if (proxy) proxy.destroy();
|
||||
scene.remove(mover);
|
||||
disposeObject(mover);
|
||||
},
|
||||
};
|
||||
|
||||
return skater;
|
||||
}
|
||||
@@ -0,0 +1,693 @@
|
||||
import * as THREE from 'three';
|
||||
import { mergeGeoms } from '../core/math.js';
|
||||
import { PART } from './body.js';
|
||||
import { computeSkin } from './skinning.js';
|
||||
import { carvedShell, loft, mergeBars, tint, tube } from './gearMesh.js';
|
||||
|
||||
/**
|
||||
* Skater equipment, in layers.
|
||||
*
|
||||
* A hockey player is dressed, not painted, and the order is the order it goes
|
||||
* on in a dressing room:
|
||||
*
|
||||
* 1. shoulder pads and elbow caps — the under layer that gives the torso its
|
||||
* shape. Mostly hidden, which is the point: the jersey drapes over it.
|
||||
* 2. jersey — long sleeves, hem past the waist, cut wide enough to clear the
|
||||
* pads underneath.
|
||||
* 3. pants — waist-high padded shorts down to just above the knee.
|
||||
* 4. socks over shin guards, taped at the top and bottom of the wrap.
|
||||
* 5. skates, gloves, helmet.
|
||||
*
|
||||
* ### Skinned vs socketed
|
||||
*
|
||||
* Anything that crosses a joint is skinned to the same skeleton the body uses
|
||||
* (`computeSkin`, then bound as a second SkinnedMesh sharing `skelData`). A
|
||||
* jersey bolted to the chest bone tears open at the shoulder the first time an
|
||||
* arm swings; a pant leg bolted to the pelvis passes through the thigh on a
|
||||
* knee bend. Cloth is authored in rest space, exactly like the body geometry.
|
||||
*
|
||||
* Boots, gloves and the helmet are rigid shells that genuinely do not bend, so
|
||||
* they are socketed to the foot, hand and head bones and cost nothing to skin.
|
||||
*
|
||||
* ### Fit
|
||||
*
|
||||
* Every radius scales off the physique factors the body loft was built from
|
||||
* (`bodyGeo.userData.physique`), so a heavy build gets a bigger jersey instead
|
||||
* of wearing its chest through the front of it.
|
||||
*/
|
||||
|
||||
/** Rest direction the upper arm points, in its own bone space (A-pose). */
|
||||
const ARM_DIR = {
|
||||
L: new THREE.Vector3(0.15, -0.252, 0.01).normalize(),
|
||||
R: new THREE.Vector3(-0.15, -0.252, 0.01).normalize(),
|
||||
};
|
||||
/** Rest direction the fingers point, from the hand bone. */
|
||||
const HAND_DIR = {
|
||||
L: new THREE.Vector3(0.045, -0.095, 0.008).normalize(),
|
||||
R: new THREE.Vector3(-0.045, -0.095, 0.008).normalize(),
|
||||
};
|
||||
const DOWN = new THREE.Vector3(0, -1, 0);
|
||||
|
||||
export const KIT = {
|
||||
helmet: {
|
||||
/** Skull centre in head-bone-local space. */
|
||||
riseY: 0.094,
|
||||
pushZ: -0.004,
|
||||
rx: 0.114,
|
||||
ry: 0.148,
|
||||
rz: 0.125,
|
||||
/**
|
||||
* Polar angle the shell starts at. This is the number that decides whether
|
||||
* you get a helmet or a beanie: the bottom ring sits at
|
||||
* riseY − ry·cos(phi0), so it has to come out *below* the ear line.
|
||||
*/
|
||||
phi0: 0.36,
|
||||
wall: 0.009,
|
||||
/** Brow line: everything in front of and below this is open face. */
|
||||
browY: 0.03,
|
||||
earY: -0.022,
|
||||
},
|
||||
/** Blade bottom, in foot-bone-local metres. Feet plant at y ≈ 0.09. */
|
||||
bladeY: -0.09,
|
||||
};
|
||||
|
||||
/**
|
||||
* What the kit covers, as `aT` ranges per body part.
|
||||
*
|
||||
* The body underneath a dressed skater is wasted work and a source of
|
||||
* poke-through: a shoulder rolls, a hip flexes, and a sliver of the layer below
|
||||
* pushes through a seam. Ludus solved it by dropping the covered body faces
|
||||
* once the clothing went on, and the same applies here.
|
||||
*
|
||||
* Ranges are deliberately short of the seams. A triangle is only dropped when
|
||||
* *all three* of its vertices are covered, which leaves a one-triangle fringe
|
||||
* under every edge of the gear — cheap insurance against a gap opening up at
|
||||
* the collar or the cuff when the pose moves.
|
||||
*/
|
||||
export const COVERAGE = {
|
||||
// Jersey and pants, up to the collar. The neck and above stay.
|
||||
[PART.TORSO]: [0.0, 0.9],
|
||||
// Sleeve and glove, deltoid to fingertips. The shoulder ball has to be in
|
||||
// here: it is the widest thing on the arm and it sits exactly where the
|
||||
// sleeve meets the yoke, so leaving it visible shows it through the seam.
|
||||
[PART.ARM_L]: [0.0, 1.0],
|
||||
[PART.ARM_R]: [0.0, 1.0],
|
||||
// Pants, socks and boots enclose the leg end to end.
|
||||
[PART.LEG_L]: [0.0, 1.0],
|
||||
[PART.LEG_R]: [0.0, 1.0],
|
||||
};
|
||||
|
||||
/**
|
||||
* Drop the body faces the kit covers. Call after `computeSkin` and after the
|
||||
* body has been painted — it only rewrites the index.
|
||||
*/
|
||||
export function hideCoveredBody(geo, coverage = COVERAGE) {
|
||||
const partAttr = geo.attributes.aPart;
|
||||
const tAttr = geo.attributes.aT;
|
||||
if (!partAttr || !tAttr || !geo.index) return geo;
|
||||
|
||||
const covered = (v) => {
|
||||
const range = coverage[partAttr.getX(v)];
|
||||
if (!range) return false;
|
||||
const t = tAttr.getX(v);
|
||||
return t >= range[0] && t <= range[1];
|
||||
};
|
||||
|
||||
const idx = geo.index.array;
|
||||
const keep = [];
|
||||
for (let f = 0; f < idx.length; f += 3) {
|
||||
const a = idx[f];
|
||||
const b = idx[f + 1];
|
||||
const c = idx[f + 2];
|
||||
if (covered(a) && covered(b) && covered(c)) continue;
|
||||
keep.push(a, b, c);
|
||||
}
|
||||
geo.setIndex(keep);
|
||||
return geo;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {*} mats from `buildSkaterGearMaterials`
|
||||
* @param {*} skelData the skeleton the cloth binds to
|
||||
* @param {{bulk:number,waistF:number,shoulderF:number,armF:number,legF:number,headF:number}} phys
|
||||
*/
|
||||
export function buildSkaterGear(mats, skelData, phys) {
|
||||
const pieces = [];
|
||||
const skinned = [];
|
||||
const disposables = [];
|
||||
|
||||
const bulk = phys?.bulk ?? 1;
|
||||
const shoulder = (phys?.shoulderF ?? 1) * bulk;
|
||||
const waist = (phys?.waistF ?? 1) * bulk;
|
||||
const armF = phys?.armF ?? 1;
|
||||
const legF = phys?.legF ?? 1;
|
||||
const headF = phys?.headF ?? 1;
|
||||
|
||||
const PAL = {
|
||||
jersey: tint(mats.jersey.color),
|
||||
accent: tint(mats.accent.color),
|
||||
trim: tint(mats.trim.color),
|
||||
pad: tint(mats.pad.color),
|
||||
tape: tint(mats.tape.color),
|
||||
};
|
||||
|
||||
const V = (x, y, z = 0) => new THREE.Vector3(x, y, z);
|
||||
const S = (c, rx, rz, e, col) => ({ c, rx, rz, e, col });
|
||||
|
||||
function mesh(geo, mat, name) {
|
||||
const m = new THREE.Mesh(geo, mat);
|
||||
m.name = name;
|
||||
m.castShadow = true;
|
||||
m.receiveShadow = true;
|
||||
disposables.push(geo);
|
||||
return m;
|
||||
}
|
||||
|
||||
/** Point a group's −Y down a bone's real limb direction. */
|
||||
function alignTo(group, dir) {
|
||||
group.quaternion.setFromUnitVectors(DOWN, dir);
|
||||
return group;
|
||||
}
|
||||
|
||||
/**
|
||||
* Merge rest-space pieces, solve skin weights, and bind to the body's
|
||||
* skeleton. `computeSkin` overwrites the colour attribute with its debug
|
||||
* heatmap, so the kit colours are stashed and put back afterwards — same
|
||||
* dance `paintKit` does for the body.
|
||||
*/
|
||||
function skin(parts, mat, name) {
|
||||
const geo = mergeGeoms(parts);
|
||||
for (const p of parts) p.dispose();
|
||||
const colors = geo.attributes.color.array.slice();
|
||||
computeSkin(geo, skelData);
|
||||
geo.userData.heatColors = geo.attributes.color.array.slice();
|
||||
geo.setAttribute('color', new THREE.BufferAttribute(colors, 3));
|
||||
geo.computeVertexNormals();
|
||||
|
||||
const m = new THREE.SkinnedMesh(geo, mat);
|
||||
m.name = name;
|
||||
m.castShadow = true;
|
||||
m.receiveShadow = true;
|
||||
m.frustumCulled = false;
|
||||
// Bound before parenting, so the bind matrix is identity — matching the
|
||||
// body mesh. The root bone stays parented to the body; a second mesh only
|
||||
// borrows the skeleton.
|
||||
m.updateMatrixWorld(true);
|
||||
m.bind(skelData.skeleton, m.matrixWorld.clone());
|
||||
disposables.push(geo);
|
||||
skinned.push(m);
|
||||
pieces.push(m);
|
||||
return m;
|
||||
}
|
||||
|
||||
// ---- 1. under layer: shoulder pads -------------------------------------
|
||||
// Sits between skin and jersey. Barely seen, but it is what makes the jersey
|
||||
// sit square across the shoulders instead of shrink-wrapping the deltoids.
|
||||
// Kept a clear centimetre inside the jersey at every ring. Two skinned
|
||||
// meshes never deform identically — their vertices sit in different places,
|
||||
// so the distance-field solve hands them different weights — and a pad that
|
||||
// merely *touches* the inside of a sweater will tear through it on a shoulder
|
||||
// roll. What actually shows is the collar, standing above the neckline.
|
||||
const padChest = loft([
|
||||
S(V(0, 1.18, 0.006), 0.156 * bulk, 0.108 * bulk, 4, PAL.pad),
|
||||
S(V(0, 1.26, 0.008), 0.17 * shoulder, 0.116 * bulk, 4),
|
||||
S(V(0, 1.335, 0.008), 0.186 * shoulder, 0.12 * bulk, 4),
|
||||
S(V(0, 1.392, 0.01), 0.16 * shoulder, 0.106 * bulk, 4),
|
||||
S(V(0, 1.428, 0.012), 0.1 * bulk, 0.09 * bulk, 3),
|
||||
S(V(0, 1.452, 0.013), 0.094 * bulk, 0.085 * bulk, 3),
|
||||
], { radial: 16, sub: 3, part: PART.TORSO, t0: 0.5, t1: 0.96 });
|
||||
skin([padChest], mats.padded, 'shoulderPads');
|
||||
|
||||
// Deltoid caps ride the upper arms so they follow the shoulder, not the ribs.
|
||||
function makeCap(side) {
|
||||
const g = new THREE.Group();
|
||||
g.name = `shoulderCap${side}`;
|
||||
// Kept under the sleeve radius at every ring: the cap is rigid on the bone
|
||||
// and the sleeve is skinned, so anything close to the same size pushes
|
||||
// through the cloth the moment the arm swings.
|
||||
const cap = loft([
|
||||
S(V(0, 0.04, 0.008), 0.062 * armF, 0.058 * armF, 3, PAL.pad),
|
||||
S(V(0, -0.025, 0.01), 0.074 * armF, 0.07 * armF, 4),
|
||||
S(V(0, -0.09, 0.008), 0.068 * armF, 0.064 * armF, 4),
|
||||
S(V(0, -0.14, 0.006), 0.054 * armF, 0.05 * armF, 3),
|
||||
], { radial: 14, sub: 3 });
|
||||
g.add(mesh(cap, mats.padded, `shoulderCap${side}Shell`));
|
||||
alignTo(g, ARM_DIR[side]);
|
||||
pieces.push(g);
|
||||
return g;
|
||||
}
|
||||
const capL = makeCap('L');
|
||||
const capR = makeCap('R');
|
||||
|
||||
// ---- 2. jersey ----------------------------------------------------------
|
||||
// Torso plus two long sleeves, merged into one skinned mesh. Waist stripes
|
||||
// and cuff bands are cut the same way the goalie's pad bands are: two
|
||||
// sections a centimetre apart.
|
||||
const jerseyParts = [];
|
||||
jerseyParts.push(loft([
|
||||
// Hem hangs over the pants, so it has to clear the widest part of them.
|
||||
S(V(0, 0.878, 0.004), 0.226 * bulk, 0.17 * bulk, 4, PAL.jersey),
|
||||
S(V(0, 0.905, 0.004), 0.232 * bulk, 0.174 * bulk, 4, PAL.accent),
|
||||
S(V(0, 0.94, 0.004), 0.233 * bulk, 0.175 * bulk, 4),
|
||||
S(V(0, 0.95, 0.004), 0.232 * bulk, 0.174 * bulk, 4, PAL.trim),
|
||||
S(V(0, 0.98, 0.005), 0.229 * bulk, 0.171 * bulk, 4),
|
||||
S(V(0, 0.99, 0.005), 0.228 * bulk, 0.17 * bulk, 4, PAL.jersey),
|
||||
S(V(0, 1.075, 0.005), 0.207 * waist, 0.152 * waist, 4),
|
||||
S(V(0, 1.165, 0.007), 0.202 * bulk, 0.148 * bulk, 4),
|
||||
S(V(0, 1.255, 0.009), 0.212 * bulk, 0.155 * bulk, 4),
|
||||
// Over the shoulder pads — the widest point of a dressed player.
|
||||
S(V(0, 1.335, 0.01), 0.242 * shoulder, 0.16 * bulk, 5),
|
||||
S(V(0, 1.395, 0.012), 0.222 * shoulder, 0.142 * bulk, 4),
|
||||
S(V(0, 1.418, 0.013), 0.17 * shoulder, 0.12 * bulk, 4),
|
||||
S(V(0, 1.432, 0.013), 0.108 * bulk, 0.098 * bulk, 3, PAL.trim),
|
||||
S(V(0, 1.462, 0.014), 0.098 * bulk, 0.09 * bulk, 3),
|
||||
], { radial: 20, sub: 3, part: PART.TORSO, t0: 0.0, t1: 0.98 }));
|
||||
|
||||
for (const side of ['L', 'R']) {
|
||||
const s = side === 'L' ? 1 : -1;
|
||||
const P = (x, y, z = 0) => V(s * x, y, z);
|
||||
jerseyParts.push(loft([
|
||||
// Wide enough at the top to swallow the deltoid ball, and buried in the
|
||||
// torso shell so the shoulder seam never opens.
|
||||
S(P(0.10, 1.415, 0.008), 0.108 * armF, 0.10 * armF, 3, PAL.jersey),
|
||||
S(P(0.175, 1.385, 0.01), 0.118 * armF, 0.112 * armF, 3),
|
||||
S(P(0.245, 1.325, 0.01), 0.105 * armF, 0.10 * armF, 3),
|
||||
S(P(0.30, 1.27, 0.01), 0.09 * armF, 0.086 * armF, 3),
|
||||
S(P(0.355, 1.16, 0.012), 0.072 * armF, 0.068 * armF, 3),
|
||||
// Elbow cap under the sleeve.
|
||||
S(P(0.397, 1.095, 0.013), 0.076 * armF, 0.072 * armF, 3),
|
||||
S(P(0.447, 0.985, 0.016), 0.064 * armF, 0.06 * armF, 3),
|
||||
S(P(0.472, 0.93, 0.018), 0.058 * armF, 0.055 * armF, 3, PAL.accent),
|
||||
S(P(0.487, 0.898, 0.02), 0.057 * armF, 0.054 * armF, 3),
|
||||
S(P(0.497, 0.876, 0.022), 0.056 * armF, 0.053 * armF, 3, PAL.trim),
|
||||
S(P(0.512, 0.844, 0.024), 0.053 * armF, 0.05 * armF, 3),
|
||||
], {
|
||||
radial: 14,
|
||||
sub: 3,
|
||||
part: side === 'L' ? PART.ARM_L : PART.ARM_R,
|
||||
t0: 0.1,
|
||||
t1: 0.94,
|
||||
}));
|
||||
}
|
||||
skin(jerseyParts, mats.cloth, 'jersey');
|
||||
|
||||
// ---- 3. pants -----------------------------------------------------------
|
||||
// Waist-high padded shorts: a hip shell plus two thigh tubes that stop above
|
||||
// the knee. Stiff, so they are wide and barely taper.
|
||||
const pantParts = [];
|
||||
pantParts.push(loft([
|
||||
S(V(0, 1.115, 0.004), 0.178 * waist, 0.132 * waist, 4, PAL.trim),
|
||||
S(V(0, 1.09, 0.004), 0.186 * waist, 0.138 * waist, 4),
|
||||
S(V(0, 1.08, 0.004), 0.19 * waist, 0.142 * waist, 4, PAL.accent),
|
||||
S(V(0, 1.055, 0.005), 0.196 * waist, 0.146 * waist, 4),
|
||||
S(V(0, 1.045, 0.005), 0.198 * waist, 0.148 * waist, 4, PAL.trim),
|
||||
S(V(0, 0.99, 0.005), 0.205 * bulk, 0.152 * bulk, 5),
|
||||
S(V(0, 0.94, 0.005), 0.207 * bulk, 0.154 * bulk, 5),
|
||||
S(V(0, 0.90, 0.004), 0.198 * bulk, 0.146 * bulk, 5),
|
||||
], { radial: 18, sub: 3, part: PART.TORSO, t0: 0.02, t1: 0.34 }));
|
||||
|
||||
for (const side of ['L', 'R']) {
|
||||
const s = side === 'L' ? 1 : -1;
|
||||
const P = (x, y, z = 0) => V(s * x, y, z);
|
||||
pantParts.push(loft([
|
||||
S(P(0.098, 0.97, 0.004), 0.142 * legF, 0.132 * legF, 4, PAL.trim),
|
||||
S(P(0.112, 0.90, 0.006), 0.138 * legF, 0.13 * legF, 4),
|
||||
S(P(0.12, 0.80, 0.008), 0.13 * legF, 0.122 * legF, 4),
|
||||
S(P(0.126, 0.71, 0.008), 0.122 * legF, 0.114 * legF, 4),
|
||||
S(P(0.127, 0.688, 0.008), 0.119 * legF, 0.111 * legF, 4, PAL.accent),
|
||||
S(P(0.128, 0.668, 0.008), 0.116 * legF, 0.108 * legF, 4),
|
||||
S(P(0.1285, 0.658, 0.008), 0.114 * legF, 0.106 * legF, 4, PAL.trim),
|
||||
S(P(0.129, 0.645, 0.008), 0.112 * legF, 0.104 * legF, 4),
|
||||
], {
|
||||
radial: 14,
|
||||
sub: 3,
|
||||
part: side === 'L' ? PART.LEG_L : PART.LEG_R,
|
||||
t0: 0.02,
|
||||
t1: 0.34,
|
||||
}));
|
||||
}
|
||||
skin(pantParts, mats.padded, 'pants');
|
||||
|
||||
// ---- 4. socks over shin guards -----------------------------------------
|
||||
// The sock is the visible layer; the guard underneath is read as the bulge at
|
||||
// the knee and the flat down the front of the shin. Tape bands at the top and
|
||||
// bottom of the wrap, where a player actually tapes.
|
||||
const sockParts = [];
|
||||
for (const side of ['L', 'R']) {
|
||||
const s = side === 'L' ? 1 : -1;
|
||||
const part = side === 'L' ? PART.LEG_L : PART.LEG_R;
|
||||
const P = (x, y, z = 0) => V(s * x, y, z);
|
||||
sockParts.push(loft([
|
||||
S(P(0.124, 0.735, 0.008), 0.098 * legF, 0.094 * legF, 3, PAL.jersey),
|
||||
S(P(0.128, 0.66, 0.01), 0.094 * legF, 0.09 * legF, 3),
|
||||
// Tape at the top of the wrap.
|
||||
S(P(0.129, 0.638, 0.01), 0.093 * legF, 0.089 * legF, 3, PAL.tape),
|
||||
S(P(0.13, 0.60, 0.012), 0.092 * legF, 0.088 * legF, 3),
|
||||
S(P(0.13, 0.578, 0.012), 0.092 * legF, 0.088 * legF, 3, PAL.jersey),
|
||||
// Knee.
|
||||
S(P(0.131, 0.53, 0.016), 0.096 * legF, 0.094 * legF, 3),
|
||||
S(P(0.132, 0.45, 0.014), 0.086 * legF, 0.082 * legF, 3),
|
||||
S(P(0.133, 0.35, 0.01), 0.079 * legF, 0.074 * legF, 3),
|
||||
S(P(0.133, 0.26, 0.006), 0.072 * legF, 0.066 * legF, 3),
|
||||
// Tape at the bottom of the wrap.
|
||||
S(P(0.133, 0.232, 0.005), 0.07 * legF, 0.064 * legF, 3, PAL.tape),
|
||||
S(P(0.132, 0.20, 0.004), 0.068 * legF, 0.062 * legF, 3),
|
||||
S(P(0.132, 0.18, 0.003), 0.066 * legF, 0.06 * legF, 3, PAL.jersey),
|
||||
S(P(0.131, 0.135, 0.002), 0.06 * legF, 0.056 * legF, 3),
|
||||
S(P(0.131, 0.105, 0.004), 0.056 * legF, 0.052 * legF, 3, PAL.trim),
|
||||
], { radial: 14, sub: 3, part, t0: 0.30, t1: 0.87 }));
|
||||
|
||||
// Knee cap: a dome off the front of the wrap.
|
||||
sockParts.push(loft([
|
||||
S(P(0.131, 0.545, 0.02), 0.062 * legF, 0.058 * legF, 3, PAL.jersey),
|
||||
S(P(0.131, 0.542, 0.058), 0.07 * legF, 0.066 * legF, 3),
|
||||
S(P(0.131, 0.538, 0.088), 0.058 * legF, 0.054 * legF, 3),
|
||||
S(P(0.131, 0.534, 0.104), 0.03 * legF, 0.028 * legF, 3),
|
||||
], { radial: 14, sub: 3, part, t0: 0.48, t1: 0.54 }));
|
||||
}
|
||||
skin(sockParts, mats.cloth, 'socks');
|
||||
|
||||
// ---- 5. skates ----------------------------------------------------------
|
||||
// Foot-bone local: +Z is forward past the toe, the sole sits a little under
|
||||
// the bone, the blade hangs where the ice is.
|
||||
function makeSkate(side) {
|
||||
const g = new THREE.Group();
|
||||
g.name = `skate${side}`;
|
||||
|
||||
const boot = loft([
|
||||
S(V(0, -0.014, -0.088), 0.036, 0.042, 4, PAL.trim),
|
||||
S(V(0, -0.02, -0.05), 0.046, 0.05, 4),
|
||||
S(V(0, -0.026, 0.01), 0.05, 0.048, 4),
|
||||
S(V(0, -0.03, 0.07), 0.048, 0.042, 4),
|
||||
S(V(0, -0.034, 0.125), 0.04, 0.032, 4),
|
||||
S(V(0, -0.038, 0.162), 0.022, 0.018, 3),
|
||||
], { radial: 16, sub: 4 });
|
||||
g.add(mesh(boot, mats.hard, `skate${side}Boot`));
|
||||
|
||||
// Ankle cuff — the kit stops at the ankle, as asked.
|
||||
const cuff = loft([
|
||||
S(V(0, -0.012, -0.05), 0.048, 0.05, 4, PAL.trim),
|
||||
S(V(0, 0.03, -0.045), 0.05, 0.048, 4),
|
||||
S(V(0, 0.062, -0.038), 0.047, 0.044, 4, PAL.pad),
|
||||
S(V(0, 0.078, -0.032), 0.041, 0.038, 3),
|
||||
], { radial: 14, sub: 3 });
|
||||
g.add(mesh(cuff, mats.hard, `skate${side}Cuff`));
|
||||
|
||||
// Tongue up the front of the ankle.
|
||||
const tongue = loft([
|
||||
S(V(0, -0.01, 0.03), 0.03, 0.014, 3, PAL.trim),
|
||||
S(V(0, 0.03, 0.012), 0.033, 0.015, 3),
|
||||
S(V(0, 0.07, 0.0), 0.031, 0.014, 3, PAL.accent),
|
||||
], { radial: 10, sub: 3 });
|
||||
g.add(mesh(tongue, mats.hard, `skate${side}Tongue`));
|
||||
|
||||
// Holder: two posts off the sole down to the runner.
|
||||
const holder = [];
|
||||
for (const z of [-0.045, 0.085]) {
|
||||
holder.push(tube([
|
||||
V(0, -0.05, z),
|
||||
V(0, -0.062, z + (z < 0 ? 0.008 : -0.008)),
|
||||
V(0, -0.072, z + (z < 0 ? 0.012 : -0.012)),
|
||||
], 0.011, { radial: 6 }));
|
||||
}
|
||||
holder.push(tube([
|
||||
V(0, -0.073, -0.075), V(0, -0.076, 0), V(0, -0.073, 0.13),
|
||||
], 0.008, { radial: 6 }));
|
||||
g.add(mesh(mergeBars(holder), mats.holder, `skate${side}Holder`));
|
||||
|
||||
// Runner: a thin steel blade with the toe and heel curling up off the ice.
|
||||
const blade = loft([
|
||||
S(V(0, KIT.bladeY + 0.028, -0.108), 0.0035, 0.012, 3, PAL.trim),
|
||||
S(V(0, KIT.bladeY + 0.012, -0.088), 0.0035, 0.013, 3),
|
||||
S(V(0, KIT.bladeY + 0.012, 0.12), 0.0035, 0.013, 3),
|
||||
S(V(0, KIT.bladeY + 0.03, 0.145), 0.0035, 0.012, 3),
|
||||
], { radial: 6, sub: 4 });
|
||||
g.add(mesh(blade, mats.steel, `skate${side}Blade`));
|
||||
|
||||
// Laces.
|
||||
const laces = [];
|
||||
for (const y of [0.0, 0.022, 0.044]) {
|
||||
laces.push(tube([
|
||||
V(-0.03, y - 0.005, 0.03 - y * 0.4),
|
||||
V(0, y + 0.004, 0.022 - y * 0.4),
|
||||
V(0.03, y - 0.005, 0.03 - y * 0.4),
|
||||
], 0.004, { radial: 5 }));
|
||||
}
|
||||
g.add(mesh(mergeBars(laces), mats.lace, `skate${side}Laces`));
|
||||
|
||||
pieces.push(g);
|
||||
return g;
|
||||
}
|
||||
const skateL = makeSkate('L');
|
||||
const skateR = makeSkate('R');
|
||||
|
||||
// ---- 6. gloves ----------------------------------------------------------
|
||||
// Glove space: fingers down −Y, back of the hand +Z, then rotated onto the
|
||||
// hand bone's real axis. The stick is aimed from the same bone, so the glove
|
||||
// has to stay a shell around the hand and not swallow the shaft.
|
||||
function makeGlove(side) {
|
||||
const s = side === 'L' ? 1 : -1;
|
||||
const g = new THREE.Group();
|
||||
g.name = `glove${side}`;
|
||||
|
||||
const body = loft([
|
||||
// Flared cuff roll at the wrist.
|
||||
S(V(0, 0.085, -0.004), 0.056, 0.054, 3, PAL.trim),
|
||||
S(V(0, 0.062, -0.002), 0.068, 0.064, 3, PAL.accent),
|
||||
S(V(0, 0.03, 0.002), 0.074, 0.068, 3),
|
||||
S(V(0, 0.012, 0.004), 0.076, 0.07, 3, PAL.jersey),
|
||||
S(V(0, -0.04, 0.01), 0.08, 0.068, 4),
|
||||
S(V(0, -0.105, 0.014), 0.082, 0.066, 4),
|
||||
S(V(0, -0.16, 0.014), 0.076, 0.06, 4),
|
||||
S(V(0, -0.19, 0.012), 0.062, 0.05, 4, PAL.trim),
|
||||
S(V(0, -0.215, 0.008), 0.042, 0.034, 3),
|
||||
], { radial: 16, sub: 4 });
|
||||
g.add(mesh(body, mats.hard, `glove${side}Body`));
|
||||
|
||||
// Backhand rolls — the padded ridges across the knuckles.
|
||||
for (const [y, r] of [[-0.06, 0.026], [-0.115, 0.024]]) {
|
||||
const roll = loft([
|
||||
S(V(-s * 0.058, y + 0.012, 0.05), r * 0.8, r * 0.7, 3, PAL.accent),
|
||||
S(V(0, y, 0.062), r, r * 0.9, 3),
|
||||
S(V(s * 0.058, y + 0.012, 0.05), r * 0.8, r * 0.7, 3),
|
||||
], { radial: 10, sub: 4 });
|
||||
g.add(mesh(roll, mats.hard, `glove${side}Roll`));
|
||||
}
|
||||
|
||||
// Thumb, curling toward the shaft.
|
||||
const thumb = loft([
|
||||
S(V(s * 0.058, -0.005, 0.03), 0.03, 0.028, 3, PAL.jersey),
|
||||
S(V(s * 0.09, -0.065, 0.052), 0.028, 0.026, 3),
|
||||
S(V(s * 0.092, -0.12, 0.066), 0.023, 0.022, 3, PAL.trim),
|
||||
], { radial: 10, sub: 4 });
|
||||
g.add(mesh(thumb, mats.hard, `glove${side}Thumb`));
|
||||
|
||||
alignTo(g, HAND_DIR[side]);
|
||||
g.rotateY(s * 0.25);
|
||||
pieces.push(g);
|
||||
return g;
|
||||
}
|
||||
const gloveL = makeGlove('L');
|
||||
const gloveR = makeGlove('R');
|
||||
|
||||
// ---- 7. helmet ----------------------------------------------------------
|
||||
// Same carved-shell builder as the goalie mask, cut differently: the whole
|
||||
// lower front is open face, with ear ports at the sides.
|
||||
const H = KIT.helmet;
|
||||
const skull = new THREE.Vector3(0, H.riseY, H.pushZ);
|
||||
|
||||
function helmetSurface(theta, v, out) {
|
||||
const phi = H.phi0 + (Math.PI - H.phi0) * v;
|
||||
const sp = Math.sin(phi);
|
||||
const cp = Math.cos(phi);
|
||||
const f = Math.cos(theta);
|
||||
const sx = Math.sin(theta);
|
||||
const front = Math.max(0, f);
|
||||
const back = Math.max(0, -f);
|
||||
|
||||
let rx = H.rx * headF;
|
||||
let rz = H.rz * headF;
|
||||
// Occipital shell carries out over the back of the skull.
|
||||
rz *= 1 + 0.10 * back * v;
|
||||
// Slight flat across the forehead.
|
||||
rz *= 1 - 0.06 * front * front * v;
|
||||
|
||||
const x = rx * sp * sx;
|
||||
const y = -H.ry * headF * cp;
|
||||
let z = rz * sp * f;
|
||||
// Brow lip juts forward over the eyes.
|
||||
const lip = Math.exp(-(((v - 0.08) / 0.12) ** 2)) * front ** 2;
|
||||
z += 0.008 * lip;
|
||||
|
||||
return out.set(skull.x + x, skull.y + y, skull.z + z);
|
||||
}
|
||||
|
||||
/** Open face below the brow, plus a port over each ear. */
|
||||
const helmetPort = (p) => {
|
||||
const dy = p.y - skull.y;
|
||||
const dz = p.z - skull.z;
|
||||
const ax = Math.abs(p.x);
|
||||
// The face: front-centre below the brow. Narrow, so the shell keeps its
|
||||
// cheek coverage instead of turning into a cap.
|
||||
if (dz > 0.028 && dy < H.browY && ax < 0.072) return true;
|
||||
// Ear ports, covered by the cups.
|
||||
if (ax > 0.088 && dy < H.earY + 0.026 && dy > H.earY - 0.042 && Math.abs(dz + 0.014) < 0.038) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
};
|
||||
|
||||
const helmetColor = (p, kind) => {
|
||||
if (kind === 'inner') return PAL.pad;
|
||||
const dy = p.y - skull.y;
|
||||
// Dark brim around the bottom edge of the shell.
|
||||
if (dy < -0.028) return PAL.trim;
|
||||
// Centre stripe over the crown.
|
||||
if (Math.abs(p.x) < 0.019 && dy > 0.03) return PAL.accent;
|
||||
return PAL.jersey;
|
||||
};
|
||||
|
||||
const helmet = new THREE.Group();
|
||||
helmet.name = 'helmet';
|
||||
helmet.add(mesh(
|
||||
carvedShell({
|
||||
rows: 26,
|
||||
cols: 36,
|
||||
thickness: H.wall,
|
||||
center: skull,
|
||||
surface: helmetSurface,
|
||||
port: helmetPort,
|
||||
color: helmetColor,
|
||||
}),
|
||||
mats.hard,
|
||||
'helmetShell',
|
||||
));
|
||||
|
||||
// Ear cups over the ports, on their own straps.
|
||||
for (const s of [1, -1]) {
|
||||
const cup = loft([
|
||||
S(V(s * 0.09, skull.y + H.earY, skull.z - 0.014), 0.028, 0.026, 3, PAL.trim),
|
||||
S(V(s * 0.104, skull.y + H.earY, skull.z - 0.014), 0.03, 0.028, 3),
|
||||
S(V(s * 0.111, skull.y + H.earY, skull.z - 0.014), 0.023, 0.021, 3),
|
||||
], { radial: 12, sub: 3, ref: new THREE.Vector3(0, 1, 0) });
|
||||
helmet.add(mesh(cup, mats.hard, 'helmetEar'));
|
||||
}
|
||||
|
||||
// Chin strap under the jaw.
|
||||
helmet.add(mesh(
|
||||
tube([
|
||||
V(-0.105, skull.y + H.earY - 0.012, skull.z - 0.01),
|
||||
V(-0.07, skull.y - 0.12, skull.z + 0.03),
|
||||
V(0, skull.y - 0.145, skull.z + 0.05),
|
||||
V(0.07, skull.y - 0.12, skull.z + 0.03),
|
||||
V(0.105, skull.y + H.earY - 0.012, skull.z - 0.01),
|
||||
], 0.006, { radial: 6 }),
|
||||
mats.strap,
|
||||
'helmetStrap',
|
||||
));
|
||||
|
||||
// Half visor: eye level only. Run it down over the whole face and the player
|
||||
// reads as a welder.
|
||||
{
|
||||
const arc = [];
|
||||
for (let i = 0; i <= 10; i++) {
|
||||
const a = -0.82 + (1.64 * i) / 10;
|
||||
arc.push(V(
|
||||
Math.sin(a) * 0.106 * headF,
|
||||
skull.y + 0.004,
|
||||
skull.z + Math.cos(a) * 0.116 * headF,
|
||||
));
|
||||
}
|
||||
// The ring axes here are u = up, w = front-to-back, so `rx` is the shield's
|
||||
// height and `rz` is its thickness. Swap those two and you get a shelf
|
||||
// sticking out of the face instead of a shield hanging over the eyes.
|
||||
const visor = loft(
|
||||
arc.map((c, i) => S(c, i === 0 || i === arc.length - 1 ? 0.026 : 0.038, 0.003, 3)),
|
||||
{ radial: 8, sub: 2, ref: new THREE.Vector3(0, 1, 0) },
|
||||
);
|
||||
helmet.add(mesh(visor, mats.visor, 'helmetVisor'));
|
||||
}
|
||||
pieces.push(helmet);
|
||||
|
||||
return {
|
||||
padChest,
|
||||
capL,
|
||||
capR,
|
||||
skateL,
|
||||
skateR,
|
||||
gloveL,
|
||||
gloveR,
|
||||
helmet,
|
||||
/** Skinned cloth meshes — these go on the mover, not on a bone. */
|
||||
skinned,
|
||||
pieces,
|
||||
|
||||
attachTo(bones, mover) {
|
||||
for (const m of skinned) mover.add(m);
|
||||
bones.upperArmL.add(capL);
|
||||
bones.upperArmR.add(capR);
|
||||
bones.footL.add(skateL);
|
||||
bones.footR.add(skateR);
|
||||
bones.handL.add(gloveL);
|
||||
bones.handR.add(gloveR);
|
||||
bones.head.add(helmet);
|
||||
},
|
||||
|
||||
destroy() {
|
||||
for (const p of pieces) p.removeFromParent();
|
||||
for (const g of disposables) g.dispose();
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
export function buildSkaterGearMaterials(teamJersey, teamAccent = 0xf0e6d2) {
|
||||
return {
|
||||
/** Cloth: jersey, socks. Vertex-coloured, matte. */
|
||||
cloth: new THREE.MeshStandardMaterial({
|
||||
color: 0xffffff,
|
||||
vertexColors: true,
|
||||
roughness: 0.88,
|
||||
metalness: 0.0,
|
||||
}),
|
||||
/** Padded shells: pants, shoulder pads. */
|
||||
padded: new THREE.MeshStandardMaterial({
|
||||
color: 0xffffff,
|
||||
vertexColors: true,
|
||||
roughness: 0.72,
|
||||
metalness: 0.02,
|
||||
}),
|
||||
/** Hard shells: helmet, skate boots, gloves. */
|
||||
hard: new THREE.MeshStandardMaterial({
|
||||
color: 0xffffff,
|
||||
vertexColors: true,
|
||||
roughness: 0.38,
|
||||
metalness: 0.06,
|
||||
}),
|
||||
steel: new THREE.MeshStandardMaterial({
|
||||
color: 0xc8ccd4,
|
||||
roughness: 0.22,
|
||||
metalness: 0.85,
|
||||
}),
|
||||
holder: new THREE.MeshStandardMaterial({
|
||||
color: 0x16181d,
|
||||
roughness: 0.45,
|
||||
metalness: 0.1,
|
||||
}),
|
||||
lace: new THREE.MeshStandardMaterial({ color: 0xdad6cc, roughness: 0.9 }),
|
||||
strap: new THREE.MeshStandardMaterial({ color: 0x14141a, roughness: 0.85 }),
|
||||
visor: new THREE.MeshPhysicalMaterial({
|
||||
color: 0x9fb8c8,
|
||||
roughness: 0.08,
|
||||
metalness: 0.0,
|
||||
transparent: true,
|
||||
opacity: 0.32,
|
||||
side: THREE.DoubleSide,
|
||||
}),
|
||||
// Colour sources for the vertex-painted pieces.
|
||||
jersey: new THREE.MeshStandardMaterial({ color: teamJersey }),
|
||||
accent: new THREE.MeshStandardMaterial({ color: teamAccent }),
|
||||
trim: new THREE.MeshStandardMaterial({ color: 0x16181d }),
|
||||
pad: new THREE.MeshStandardMaterial({ color: 0x3a3f4a }),
|
||||
tape: new THREE.MeshStandardMaterial({ color: 0xe8e4d8 }),
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,114 @@
|
||||
import * as THREE from 'three';
|
||||
import { V3, assert } from '../core/math.js';
|
||||
|
||||
// [name, parent, local offset] — rest local rotations are all identity, so the
|
||||
// rest pose is an A-pose and every rest world position falls out of the offsets.
|
||||
export const BONEDEF = [
|
||||
['root', null, [0, 0, 0]],
|
||||
['pelvis', 'root', [0, 1.0, 0]],
|
||||
['spine1', 'pelvis', [0, 0.09, 0.004]],
|
||||
['spine2', 'spine1', [0, 0.12, 0.005]],
|
||||
['spine3', 'spine2', [0, 0.13, 0.005]],
|
||||
['neck', 'spine3', [0, 0.1, 0.012]],
|
||||
['head', 'neck', [0, 0.075, 0.008]],
|
||||
['clavicleL', 'spine3', [0.075, 0.048, 0]],
|
||||
['upperArmL', 'clavicleL', [0.135, -0.022, 0]],
|
||||
['forearmL', 'upperArmL', [0.15, -0.252, 0.01]],
|
||||
['handL', 'forearmL', [0.105, -0.227, 0.016]],
|
||||
['clavicleR', 'spine3', [-0.075, 0.048, 0]],
|
||||
['upperArmR', 'clavicleR', [-0.135, -0.022, 0]],
|
||||
['forearmR', 'upperArmR', [-0.15, -0.252, 0.01]],
|
||||
['handR', 'forearmR', [-0.105, -0.227, 0.016]],
|
||||
['thighL', 'pelvis', [0.105, -0.05, 0.005]],
|
||||
['shinL', 'thighL', [0.02, -0.44, 0.006]],
|
||||
['footL', 'shinL', [0.005, -0.437, -0.012]],
|
||||
['toeL', 'footL', [-0.004, -0.055, 0.112]],
|
||||
['thighR', 'pelvis', [-0.105, -0.05, 0.005]],
|
||||
['shinR', 'thighR', [-0.02, -0.44, 0.006]],
|
||||
['footR', 'shinR', [-0.005, -0.437, -0.012]],
|
||||
['toeR', 'footR', [0.004, -0.055, 0.112]],
|
||||
];
|
||||
|
||||
/** Child bone that defines each bone's capsule segment axis. */
|
||||
export const SEG_CHILD = {
|
||||
pelvis: 'spine1', spine1: 'spine2', spine2: 'spine3', spine3: 'neck', neck: 'head',
|
||||
clavicleL: 'upperArmL', upperArmL: 'forearmL', forearmL: 'handL',
|
||||
clavicleR: 'upperArmR', upperArmR: 'forearmR', forearmR: 'handR',
|
||||
thighL: 'shinL', shinL: 'footL', footL: 'toeL',
|
||||
thighR: 'shinR', shinR: 'footR', footR: 'toeR',
|
||||
root: null, head: null, handL: null, handR: null, toeL: null, toeR: null,
|
||||
};
|
||||
|
||||
/** Per-bone skin influence radius for the capsule falloff. */
|
||||
export const BONE_RADIUS = {
|
||||
root: 0.2, pelvis: 0.175, spine1: 0.165, spine2: 0.17, spine3: 0.175, neck: 0.08, head: 0.125,
|
||||
clavicleL: 0.07, upperArmL: 0.078, forearmL: 0.068, handL: 0.06,
|
||||
clavicleR: 0.07, upperArmR: 0.078, forearmR: 0.068, handR: 0.06,
|
||||
thighL: 0.125, shinL: 0.098, footL: 0.075, toeL: 0.055,
|
||||
thighR: 0.125, shinR: 0.098, footR: 0.075, toeR: 0.055,
|
||||
};
|
||||
|
||||
/**
|
||||
* Body regions from GDD 5.3. Every bone belongs to exactly one region, and
|
||||
* damage, armor coverage and ragdoll limb-disable all key off these.
|
||||
*/
|
||||
export const REGION = {
|
||||
HEAD: 'head',
|
||||
TORSO: 'torso',
|
||||
UPPER_ARM_L: 'upperArmL', LOWER_ARM_L: 'lowerArmL',
|
||||
UPPER_ARM_R: 'upperArmR', LOWER_ARM_R: 'lowerArmR',
|
||||
UPPER_LEG_L: 'upperLegL', LOWER_LEG_L: 'lowerLegL',
|
||||
UPPER_LEG_R: 'upperLegR', LOWER_LEG_R: 'lowerLegR',
|
||||
};
|
||||
|
||||
export const BONE_REGION = {
|
||||
head: REGION.HEAD, neck: REGION.HEAD,
|
||||
pelvis: REGION.TORSO, spine1: REGION.TORSO, spine2: REGION.TORSO, spine3: REGION.TORSO,
|
||||
clavicleL: REGION.TORSO, clavicleR: REGION.TORSO,
|
||||
upperArmL: REGION.UPPER_ARM_L, forearmL: REGION.LOWER_ARM_L, handL: REGION.LOWER_ARM_L,
|
||||
upperArmR: REGION.UPPER_ARM_R, forearmR: REGION.LOWER_ARM_R, handR: REGION.LOWER_ARM_R,
|
||||
thighL: REGION.UPPER_LEG_L, shinL: REGION.LOWER_LEG_L, footL: REGION.LOWER_LEG_L, toeL: REGION.LOWER_LEG_L,
|
||||
thighR: REGION.UPPER_LEG_R, shinR: REGION.LOWER_LEG_R, footR: REGION.LOWER_LEG_R, toeR: REGION.LOWER_LEG_R,
|
||||
};
|
||||
|
||||
export function buildSkeleton() {
|
||||
const bones = {};
|
||||
const list = [];
|
||||
for (const [name, parentName, off] of BONEDEF) {
|
||||
const b = new THREE.Bone();
|
||||
b.name = name;
|
||||
b.position.set(off[0], off[1], off[2]);
|
||||
if (parentName) bones[parentName].add(b);
|
||||
bones[name] = b;
|
||||
list.push(b);
|
||||
}
|
||||
const root = bones.root;
|
||||
root.updateMatrixWorld(true);
|
||||
const restWorld = {};
|
||||
for (const b of list) restWorld[b.name] = b.getWorldPosition(new THREE.Vector3());
|
||||
const skeleton = new THREE.Skeleton(list);
|
||||
const index = {};
|
||||
list.forEach((b, i) => { index[b.name] = i; });
|
||||
return { bones, list, index, skeleton, restWorld, rootBone: root };
|
||||
}
|
||||
|
||||
/** The capsule segment a bone deforms, in rest world space. */
|
||||
export function boneSegment(name, restWorld) {
|
||||
const a = restWorld[name];
|
||||
const child = SEG_CHILD[name];
|
||||
let b;
|
||||
if (child) b = restWorld[child];
|
||||
else if (name === 'head') b = a.clone().add(V3(0, 0.15, 0.012));
|
||||
else if (name.startsWith('hand')) {
|
||||
const s = name.endsWith('L') ? 1 : -1;
|
||||
b = a.clone().add(V3(s * 0.045, -0.095, 0.008));
|
||||
} else b = a.clone().add(V3(0, -0.012, 0.085)); // toes
|
||||
return { a, b, r: BONE_RADIUS[name] };
|
||||
}
|
||||
|
||||
export function assertNoNaNBones(skelData) {
|
||||
for (const b of skelData.list) {
|
||||
const e = b.matrixWorld.elements;
|
||||
for (let i = 0; i < 16; i++) assert(Number.isFinite(e[i]), 'NaN in bone matrix ' + b.name);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,213 @@
|
||||
import * as THREE from 'three';
|
||||
import { assert, clamp, segDist } from '../core/math.js';
|
||||
import { PART } from './body.js';
|
||||
import { boneSegment } from './skeleton.js';
|
||||
|
||||
const TORSO_BONES = new Set([
|
||||
'pelvis', 'spine1', 'spine2', 'spine3', 'neck', 'clavicleL', 'clavicleR',
|
||||
]);
|
||||
const HEAD_BONES = new Set(['spine3', 'neck', 'head']);
|
||||
const ARM_L_BONES = new Set(['spine3', 'clavicleL', 'upperArmL', 'forearmL', 'handL']);
|
||||
const ARM_R_BONES = new Set(['spine3', 'clavicleR', 'upperArmR', 'forearmR', 'handR']);
|
||||
const LEG_L_BONES = new Set(['pelvis', 'thighL', 'shinL', 'footL', 'toeL']);
|
||||
const LEG_R_BONES = new Set(['pelvis', 'thighR', 'shinR', 'footR', 'toeR']);
|
||||
const PART_BONES = {
|
||||
[PART.TORSO]: TORSO_BONES,
|
||||
[PART.HEAD]: HEAD_BONES,
|
||||
[PART.ARM_L]: ARM_L_BONES,
|
||||
[PART.ARM_R]: ARM_R_BONES,
|
||||
[PART.LEG_L]: LEG_L_BONES,
|
||||
[PART.LEG_R]: LEG_R_BONES,
|
||||
};
|
||||
|
||||
/**
|
||||
* Keep the distance field inside the authored body region.
|
||||
*
|
||||
* The body lofts overlap at the shoulders and hips. Distance alone therefore
|
||||
* gives some chest vertices almost entirely to an upper-arm bone and lets one
|
||||
* thigh influence the other leg. Those weights look plausible in the rest
|
||||
* pose, but pull the armpit into a spike and shear the legs as the pelvis turns.
|
||||
*
|
||||
* The top of each leg is an authored pelvis/thigh blend. Leg IK cancels pelvis
|
||||
* rotation in the thigh's local transform, so letting the pelvis own that whole
|
||||
* band would leave the skin behind even after opposite-side bleed is removed.
|
||||
*/
|
||||
function constrainPartWeights(wAll, vertex, segs, part, t, point, closestPoint) {
|
||||
const allowed = PART_BONES[part];
|
||||
if (!allowed) return;
|
||||
|
||||
const base = vertex * segs.length;
|
||||
let allowedTotal = 0;
|
||||
for (let s = 0; s < segs.length; s++) {
|
||||
if (!allowed.has(segs[s].name)) wAll[base + s] = 0;
|
||||
else allowedTotal += wAll[base + s];
|
||||
}
|
||||
|
||||
// A wide generated silhouette can sit outside every same-region capsule
|
||||
// even though an overlapping limb capsule reached it. Never let semantic
|
||||
// filtering turn that valid distance-field result into an unbound vertex.
|
||||
if (allowedTotal <= 1e-6) {
|
||||
let nearest = -1;
|
||||
let nearestDistance = Infinity;
|
||||
for (let s = 0; s < segs.length; s++) {
|
||||
if (!allowed.has(segs[s].name)) continue;
|
||||
const distance = segDist(point, segs[s].a, segs[s].b, closestPoint);
|
||||
if (distance < nearestDistance) {
|
||||
nearest = s;
|
||||
nearestDistance = distance;
|
||||
}
|
||||
}
|
||||
assert(nearest >= 0, `part ${part} has no valid skin bones`);
|
||||
wAll[base + nearest] = 1;
|
||||
}
|
||||
|
||||
const side = part === PART.LEG_L ? 'L' : part === PART.LEG_R ? 'R' : null;
|
||||
if (!side || t > 0.2) return;
|
||||
|
||||
// Pelvis-led at the groin cap, easing to full thigh ownership below the
|
||||
// crease. The thigh share is enough to follow IK without opening a hip seam.
|
||||
const u = clamp(t / 0.2, 0, 1);
|
||||
const eased = u * u * (3 - 2 * u);
|
||||
const thighWeight = 0.25 + 0.75 * eased;
|
||||
for (let s = 0; s < segs.length; s++) wAll[base + s] = 0;
|
||||
wAll[base + segs.findIndex((seg) => seg.name === 'pelvis')] = 1 - thighWeight;
|
||||
wAll[base + segs.findIndex((seg) => seg.name === `thigh${side}`)] = thighWeight;
|
||||
}
|
||||
|
||||
/**
|
||||
* Capsule-segment distance falloff with a Laplacian smoothing pass.
|
||||
*
|
||||
* The raw falloff alone produces candy-wrapper collapse at the joints, because
|
||||
* neighbouring vertices can land on very different influence sets. Smoothing
|
||||
* over mesh adjacency before the top-4 reduction fixes that without needing
|
||||
* hand-painted weights.
|
||||
*/
|
||||
export function computeSkin(geo, skelData) {
|
||||
const pos = geo.attributes.position;
|
||||
const partAttr = geo.attributes.aPart;
|
||||
const tAttr = geo.attributes.aT;
|
||||
const n = pos.count;
|
||||
const bones = skelData.list;
|
||||
const boneIndex = skelData.index;
|
||||
|
||||
const segs = [];
|
||||
for (const b of bones) {
|
||||
if (b.name === 'root') continue;
|
||||
const s = boneSegment(b.name, skelData.restWorld);
|
||||
segs.push({ name: b.name, idx: boneIndex[b.name], a: s.a, b: s.b, r: s.r });
|
||||
}
|
||||
const S = segs.length;
|
||||
const wAll = new Float32Array(n * S);
|
||||
const p = new THREE.Vector3();
|
||||
const cp = new THREE.Vector3();
|
||||
|
||||
for (let i = 0; i < n; i++) {
|
||||
p.fromBufferAttribute(pos, i);
|
||||
let maxW = 0;
|
||||
for (let s = 0; s < S; s++) {
|
||||
const seg = segs[s];
|
||||
const d = segDist(p, seg.a, seg.b, cp);
|
||||
const x = clamp(1 - (d / seg.r) * (d / seg.r), 0, 1);
|
||||
const w = x * x; // smooth compact support inside the influence radius
|
||||
wAll[i * S + s] = w;
|
||||
if (w > maxW) maxW = w;
|
||||
}
|
||||
if (maxW <= 1e-6) {
|
||||
// Outside every capsule: hard-bind to the nearest segment.
|
||||
let bd = 1e9;
|
||||
let bs = 0;
|
||||
for (let s = 0; s < S; s++) {
|
||||
const d = segDist(p, segs[s].a, segs[s].b, cp);
|
||||
if (d < bd) { bd = d; bs = s; }
|
||||
}
|
||||
wAll[i * S + bs] = 1;
|
||||
}
|
||||
if (partAttr && tAttr) {
|
||||
constrainPartWeights(wAll, i, segs, partAttr.getX(i), tAttr.getX(i), p, cp);
|
||||
}
|
||||
}
|
||||
|
||||
const adj = new Array(n);
|
||||
for (let i = 0; i < n; i++) adj[i] = [];
|
||||
const idx = geo.index.array;
|
||||
for (let f = 0; f < idx.length; f += 3) {
|
||||
const a = idx[f];
|
||||
const b = idx[f + 1];
|
||||
const c = idx[f + 2];
|
||||
adj[a].push(b, c);
|
||||
adj[b].push(a, c);
|
||||
adj[c].push(a, b);
|
||||
}
|
||||
const tmp = new Float32Array(S);
|
||||
for (let iter = 0; iter < 3; iter++) {
|
||||
const prev = wAll.slice();
|
||||
for (let i = 0; i < n; i++) {
|
||||
const nb = adj[i];
|
||||
if (!nb.length) continue;
|
||||
tmp.fill(0);
|
||||
for (const j of nb) {
|
||||
for (let s = 0; s < S; s++) tmp[s] += prev[j * S + s];
|
||||
}
|
||||
const inv = 1 / nb.length;
|
||||
for (let s = 0; s < S; s++) wAll[i * S + s] = prev[i * S + s] * 0.55 + tmp[s] * inv * 0.45;
|
||||
}
|
||||
}
|
||||
|
||||
const skinIndex = new Uint16Array(n * 4);
|
||||
const skinWeight = new Float32Array(n * 4);
|
||||
for (let i = 0; i < n; i++) {
|
||||
const tops = [];
|
||||
for (let s = 0; s < S; s++) {
|
||||
const w = wAll[i * S + s];
|
||||
if (w <= 1e-5) continue;
|
||||
tops.push([w, s]);
|
||||
}
|
||||
tops.sort((a, b) => b[0] - a[0]);
|
||||
let total = 0;
|
||||
for (let k = 0; k < 4; k++) {
|
||||
if (k < tops.length) {
|
||||
skinIndex[i * 4 + k] = segs[tops[k][1]].idx;
|
||||
skinWeight[i * 4 + k] = tops[k][0];
|
||||
total += tops[k][0];
|
||||
}
|
||||
}
|
||||
assert(total > 0, 'vertex ' + i + ' has zero total skin weight');
|
||||
for (let k = 0; k < 4; k++) skinWeight[i * 4 + k] /= total;
|
||||
}
|
||||
geo.setAttribute('skinIndex', new THREE.BufferAttribute(skinIndex, 4));
|
||||
geo.setAttribute('skinWeight', new THREE.BufferAttribute(skinWeight, 4));
|
||||
|
||||
// Debug heatmap: dominant bone hue, brightness by weight.
|
||||
const colors = new Float32Array(n * 3);
|
||||
const col = new THREE.Color();
|
||||
for (let i = 0; i < n; i++) {
|
||||
let bw = 0;
|
||||
let bi = 0;
|
||||
for (let k = 0; k < 4; k++) {
|
||||
if (skinWeight[i * 4 + k] > bw) { bw = skinWeight[i * 4 + k]; bi = skinIndex[i * 4 + k]; }
|
||||
}
|
||||
col.setHSL((bi * 0.61803) % 1, 0.85, 0.25 + 0.45 * bw);
|
||||
colors[i * 3] = col.r;
|
||||
colors[i * 3 + 1] = col.g;
|
||||
colors[i * 3 + 2] = col.b;
|
||||
}
|
||||
geo.setAttribute('color', new THREE.BufferAttribute(colors, 3));
|
||||
}
|
||||
|
||||
/**
|
||||
* CPU skinning of one vertex, matching the GPU path exactly:
|
||||
* out = bindInverse * (sum_k w_k * boneMatrix_k) * bind * v
|
||||
* Used by the skirt push-out guard and by armor debris baking, both of which
|
||||
* need posed world positions on the JS side.
|
||||
*/
|
||||
export function skinVertex(out, base, i, siAttr, swAttr, boneMats, bind, bindInv, scratchMat) {
|
||||
const te = scratchMat.elements;
|
||||
te.fill(0);
|
||||
for (let k = 0; k < 4; k++) {
|
||||
const w = swAttr.getComponent(i, k);
|
||||
if (w === 0) continue;
|
||||
const ae = boneMats[siAttr.getComponent(i, k)].elements;
|
||||
for (let e = 0; e < 16; e++) te[e] += ae[e] * w;
|
||||
}
|
||||
return out.fromArray(base, i * 3).applyMatrix4(bind).applyMatrix4(scratchMat).applyMatrix4(bindInv);
|
||||
}
|
||||
@@ -0,0 +1,296 @@
|
||||
import * as THREE from 'three';
|
||||
import { KIND, makeTag, quat, stickFilter, transform, vec3 } from '../physics/bridge.js';
|
||||
|
||||
/**
|
||||
* A hockey stick, socketed to the hand.
|
||||
*
|
||||
* ### What changed, and why it matters
|
||||
*
|
||||
* The first version hung the stick off the mover and positioned it so the blade
|
||||
* sat wherever the puck was being carried. That put the blade in the right
|
||||
* place and the hands nowhere near it — the stick floated.
|
||||
*
|
||||
* Now it is parented to a socket on the right hand bone, the way Ludus sockets
|
||||
* a weapon, and the geometry is authored in *grip space*: the origin is the top
|
||||
* hand, the shaft runs down −Y, the blade is at the far end. The hand carries
|
||||
* the stick, which is the correct dependency order — a player's hands decide
|
||||
* where their stick is, not the other way round.
|
||||
*
|
||||
* That inverts the puck relationship too. `possession` no longer picks a carry
|
||||
* point and drags the stick to it; it reads where the blade actually is and
|
||||
* carries the puck there. Stickhandling is an arm pose, which is what it is in
|
||||
* real life.
|
||||
*
|
||||
* ### Aimed, not bolted
|
||||
*
|
||||
* The stick is *aimed* from the hand at a per-stance target rather than bolted
|
||||
* on at a per-stance rotation. See the note on `GRIP` — a fixed rotation
|
||||
* composes with whatever the arm is doing and the blade ends up in the air.
|
||||
*/
|
||||
|
||||
export const STICK = {
|
||||
/** Butt (top hand) to heel of the blade. */
|
||||
shaftLength: 1.10,
|
||||
shaftRadius: 0.016,
|
||||
bladeLength: 0.31,
|
||||
bladeHeight: 0.075,
|
||||
bladeThickness: 0.022,
|
||||
/** How far down the shaft the lower hand grips, 0 = butt, 1 = heel. */
|
||||
lowerHandAt: 0.28,
|
||||
};
|
||||
|
||||
/**
|
||||
* Stances, as a blade *target* in the skater's local frame plus a roll about
|
||||
* the shaft.
|
||||
*
|
||||
* The obvious authoring — a fixed rotation in the hand's bone space — does not
|
||||
* survive contact with an animated arm. That rotation composes with the hand's
|
||||
* own world rotation, so a socket tuned to put the blade on the ice for one arm
|
||||
* pose swings it into the air the moment the arm moves, and every stride is a
|
||||
* different arm pose. Measured: the blade sat between 0.55 m and 0.97 m off the
|
||||
* ice depending on gait.
|
||||
*
|
||||
* Aiming at a target instead makes the constraint the thing we actually care
|
||||
* about — "the blade is on the ice, this far ahead" — and leaves the wrist
|
||||
* angle as the free variable, which is what a wrist is for. `roll` is the blade
|
||||
* face angle about the shaft, which is the part that genuinely is authored.
|
||||
*
|
||||
* +X is the skater's left, +Z is forward, so a right-hander carries at −X.
|
||||
*/
|
||||
export const GRIP = {
|
||||
/**
|
||||
* Normal carry: blade on the ice, in front and a little to the forehand
|
||||
* side — the "puck carry while skating" frame on the reference sheet, not
|
||||
* parked on the hip. Kept close enough that the off-hand can reach the shaft.
|
||||
*/
|
||||
carry: { target: [-0.16, 0.03, 0.70], roll: 0.08 },
|
||||
/** Hustling: stick dangles out in front on one hand. */
|
||||
hustle: { target: [-0.14, 0.03, 1.05], roll: 0.14 },
|
||||
/**
|
||||
* Wind-up: blade high and back behind the head, not hanging down from the
|
||||
* hands. y well above the shoulders, z behind the body.
|
||||
*/
|
||||
windup: { target: [-0.28, 1.55, -0.48], roll: -0.2 },
|
||||
/** Follow-through: swept across the body and finishing high. */
|
||||
follow: { target: [0.34, 0.95, 0.85], roll: 0.55 },
|
||||
/** Poke: thrust out flat, as far ahead as the arm reaches. */
|
||||
poke: { target: [-0.18, 0.03, 1.42], roll: 0.05 },
|
||||
};
|
||||
|
||||
/** Small fixed offset of the butt from the hand bone. */
|
||||
const GRIP_OFFSET = [0.015, -0.02, 0.03];
|
||||
|
||||
const _euler = new THREE.Euler();
|
||||
const clampUnit = (v) => (v < -1 ? -1 : v > 1 ? 1 : v);
|
||||
|
||||
export function buildStick(materials, physics, index) {
|
||||
const group = new THREE.Group();
|
||||
group.name = 'stick';
|
||||
|
||||
const wood = new THREE.MeshStandardMaterial({ color: 0x1a1a1e, roughness: 0.5, metalness: 0.05 });
|
||||
const tape = new THREE.MeshStandardMaterial({ color: 0x111114, roughness: 0.85 });
|
||||
|
||||
// Grip space: origin at the butt, shaft straight down −Y, blade at the end.
|
||||
// Everything that aims the stick is a rotation of this group, which keeps the
|
||||
// geometry itself trivially correct.
|
||||
const shaft = new THREE.Mesh(
|
||||
new THREE.CylinderGeometry(STICK.shaftRadius, STICK.shaftRadius * 1.08, STICK.shaftLength, 8),
|
||||
wood,
|
||||
);
|
||||
shaft.position.y = -STICK.shaftLength / 2;
|
||||
shaft.castShadow = true;
|
||||
group.add(shaft);
|
||||
|
||||
const blade = new THREE.Mesh(
|
||||
new THREE.BoxGeometry(STICK.bladeThickness, STICK.bladeHeight, STICK.bladeLength),
|
||||
tape,
|
||||
);
|
||||
// Heel at the bottom of the shaft, toe forward, with a little lie angle so it
|
||||
// sits flat on the ice rather than on its edge.
|
||||
blade.position.set(0, -STICK.shaftLength - STICK.bladeHeight * 0.35, STICK.bladeLength * 0.4);
|
||||
blade.rotation.x = 0.34;
|
||||
blade.castShadow = true;
|
||||
group.add(blade);
|
||||
|
||||
// ---- blade collider ----------------------------------------------------
|
||||
// Kinematic, driven to the blade's world transform each substep. It knocks a
|
||||
// loose puck around; a carried puck is the possession model's business.
|
||||
let body = null;
|
||||
let shape = null;
|
||||
/** False until the collider has been put where the blade actually is. */
|
||||
let placed = false;
|
||||
if (physics) {
|
||||
const { api, world } = physics;
|
||||
const bd = api.b3DefaultBodyDef();
|
||||
bd.type = api.b3BodyType.b3_kinematicBody;
|
||||
bd.enableSleep = false;
|
||||
body = api.b3CreateBody(world, bd);
|
||||
const sd = api.b3DefaultShapeDef();
|
||||
sd.density = 700;
|
||||
sd.enableContactEvents = true;
|
||||
sd.baseMaterial.friction = 0.3;
|
||||
sd.baseMaterial.restitution = 0.25;
|
||||
sd.baseMaterial.userMaterialId = makeTag(KIND.STICK, index, 0);
|
||||
const filter = stickFilter();
|
||||
sd.filter.categoryBits = filter.category;
|
||||
sd.filter.maskBits = filter.mask;
|
||||
shape = api.b3CreateBoxShape(
|
||||
body,
|
||||
sd,
|
||||
STICK.bladeThickness / 2,
|
||||
STICK.bladeHeight / 2,
|
||||
STICK.bladeLength / 2,
|
||||
);
|
||||
}
|
||||
|
||||
const _bladeWorld = new THREE.Vector3();
|
||||
const _bladeQuat = new THREE.Quaternion();
|
||||
const _scratch = new THREE.Vector3();
|
||||
const _fromPos = new THREE.Vector3();
|
||||
const _toPos = new THREE.Vector3();
|
||||
const _aimDir = new THREE.Vector3();
|
||||
/** Aim direction brought into the hand's bone space. */
|
||||
const _aimLocal = new THREE.Vector3();
|
||||
const _aimQuat = new THREE.Quaternion();
|
||||
const _rollQuat = new THREE.Quaternion();
|
||||
// The axis that must end up pointing at the target is the grip-to-*blade*
|
||||
// direction, not the shaft's −Y. The blade sits forward of the shaft end by
|
||||
// the toe offset, which puts it ~6° off axis — aiming −Y instead left the
|
||||
// blade 10 cm above where the height solve said it would be.
|
||||
const _bladeAxis = blade.position.clone().normalize();
|
||||
/** Grip origin to blade centre: the stick's effective reach. */
|
||||
const reach = blade.position.length();
|
||||
|
||||
return {
|
||||
group,
|
||||
blade,
|
||||
shaft,
|
||||
body,
|
||||
shape,
|
||||
/** Parent bone once the skeleton exists. */
|
||||
attachTo(bone) {
|
||||
bone.add(group);
|
||||
return group;
|
||||
},
|
||||
|
||||
/**
|
||||
* Blade target and roll for a blend between two named stances, in the
|
||||
* skater's local frame. The animator turns this into an aim.
|
||||
*/
|
||||
stanceTarget(from, to = from, t = 0, outTarget) {
|
||||
const a = GRIP[from] ?? GRIP.carry;
|
||||
const b = GRIP[to] ?? a;
|
||||
const k = t < 0 ? 0 : t > 1 ? 1 : t;
|
||||
_fromPos.fromArray(a.target);
|
||||
_toPos.fromArray(b.target);
|
||||
outTarget.lerpVectors(_fromPos, _toPos, k);
|
||||
return a.roll + (b.roll - a.roll) * k;
|
||||
},
|
||||
|
||||
/**
|
||||
* Point the stick from the hand at a world-space target.
|
||||
*
|
||||
* The group lives in the hand's bone space, so the aim rotation has to be
|
||||
* solved there — not in world space. `setFromUnitVectors` picks the
|
||||
* shortest rotation, which leaves a free twist around the shaft; doing that
|
||||
* in world and then left-multiplying by `handQuatInverse` does *not*
|
||||
* cancel the parent's yaw. Measured: the stick's local quaternion spun as
|
||||
* the skater turned, even when the blade target was fixed in the skater's
|
||||
* frame — the stick rotated with the body instead of staying put in the
|
||||
* socket. Solving the same aim entirely in hand space keeps the local pose
|
||||
* stable under body rotation; only a real change of target moves it.
|
||||
*
|
||||
* Height is solved exactly, direction is aimed. Pointing straight at the
|
||||
* target and hoping the length works out puts the blade wherever the stick
|
||||
* happens to end — short of an on-ice target means *above* it, so the blade
|
||||
* floats again the moment the arm pose changes the distance. Solving `dy`
|
||||
* from the height difference makes blade height exact for any arm pose and
|
||||
* any stick length; the horizontal aim is then whatever is left of the
|
||||
* unit vector. The blade lands on that ray at one stick length, so targets
|
||||
* are authored at about that distance — the aim is what has to be right,
|
||||
* not the reach.
|
||||
*/
|
||||
aimAt(worldTarget, handWorldPos, handQuatInverse, roll = 0) {
|
||||
group.position.fromArray(GRIP_OFFSET);
|
||||
|
||||
const dy = clampUnit((worldTarget.y - handWorldPos.y) / reach);
|
||||
const horiz = Math.sqrt(Math.max(0, 1 - dy * dy));
|
||||
_aimDir.set(worldTarget.x - handWorldPos.x, 0, worldTarget.z - handWorldPos.z);
|
||||
if (_aimDir.lengthSq() < 1e-8) _aimDir.set(0, 0, 1);
|
||||
_aimDir.normalize().multiplyScalar(horiz);
|
||||
_aimDir.y = dy;
|
||||
|
||||
// World aim → hand bone space, then rotate the blade axis onto it.
|
||||
_aimLocal.copy(_aimDir).applyQuaternion(handQuatInverse);
|
||||
if (_aimLocal.lengthSq() < 1e-12) _aimLocal.set(0, -1, 0);
|
||||
else _aimLocal.normalize();
|
||||
|
||||
_aimQuat.setFromUnitVectors(_bladeAxis, _aimLocal);
|
||||
if (roll) {
|
||||
_rollQuat.setFromAxisAngle(_aimLocal, roll);
|
||||
_aimQuat.premultiply(_rollQuat);
|
||||
}
|
||||
group.quaternion.copy(_aimQuat);
|
||||
},
|
||||
|
||||
/** Static placement, for a rig with no animator driving it. */
|
||||
setGrip(name = 'carry') {
|
||||
const g = GRIP[name] ?? GRIP.carry;
|
||||
group.position.fromArray(GRIP_OFFSET);
|
||||
group.quaternion.setFromEuler(_euler.set(-0.9, 0, g.roll, 'XYZ'));
|
||||
},
|
||||
|
||||
/**
|
||||
* A point on the shaft in world space, `t` down from the butt.
|
||||
*/
|
||||
shaftPoint(t, out) {
|
||||
group.updateWorldMatrix(true, false);
|
||||
out.set(0, -STICK.shaftLength * t, 0).applyMatrix4(group.matrixWorld);
|
||||
return out;
|
||||
},
|
||||
|
||||
/** The shaft as a world-space segment, butt to heel. */
|
||||
shaftSegment(outButt, outHeel) {
|
||||
group.updateWorldMatrix(true, false);
|
||||
outButt.set(0, 0, 0).applyMatrix4(group.matrixWorld);
|
||||
outHeel.set(0, -STICK.shaftLength, 0).applyMatrix4(group.matrixWorld);
|
||||
return outButt;
|
||||
},
|
||||
|
||||
/** Blade position in world space. */
|
||||
bladeWorld(out) {
|
||||
blade.updateWorldMatrix(true, false);
|
||||
return out.setFromMatrixPosition(blade.matrixWorld);
|
||||
},
|
||||
|
||||
/**
|
||||
* Push the blade's world transform into the kinematic collider.
|
||||
*
|
||||
* The first call *teleports*. `SetTargetTransform` derives the velocity
|
||||
* needed to reach the target over `dt`, so a body still sitting at the
|
||||
* world origin on frame one derives a velocity of several hundred metres a
|
||||
* second — and a stick moving at 270 m/s launches the puck off the map. It
|
||||
* happened; the puck was 1.7 km away inside ten seconds.
|
||||
*/
|
||||
syncPhysics(api, dt) {
|
||||
if (!body) return;
|
||||
blade.updateWorldMatrix(true, false);
|
||||
blade.matrixWorld.decompose(_bladeWorld, _bladeQuat, _scratch);
|
||||
if (!placed) {
|
||||
api.b3Body_SetTransform(body, vec3(_bladeWorld), quat(_bladeQuat));
|
||||
placed = true;
|
||||
return;
|
||||
}
|
||||
api.b3Body_SetTargetTransform(body, transform(_bladeWorld, _bladeQuat), dt, true);
|
||||
},
|
||||
|
||||
destroy(api) {
|
||||
if (body && api) api.b3DestroyBody(body);
|
||||
group.removeFromParent();
|
||||
shaft.geometry.dispose();
|
||||
blade.geometry.dispose();
|
||||
wood.dispose();
|
||||
tape.dispose();
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,179 @@
|
||||
import * as THREE from 'three';
|
||||
|
||||
export const V3 = (x = 0, y = 0, z = 0) => new THREE.Vector3(x, y, z);
|
||||
export const UP = V3(0, 1, 0);
|
||||
export const FWD = V3(0, 0, 1);
|
||||
|
||||
export const clamp = (x, a, b) => (x < a ? a : x > b ? b : x);
|
||||
export const lerp = (a, b, t) => a + (b - a) * t;
|
||||
export const smooth = (t) => t * t * (3 - 2 * t);
|
||||
|
||||
export function assert(cond, msg) {
|
||||
if (!cond) throw new Error('ASSERT FAILED: ' + msg);
|
||||
}
|
||||
|
||||
export function lerpAngle(a, b, t) {
|
||||
let d = b - a;
|
||||
while (d > Math.PI) d -= Math.PI * 2;
|
||||
while (d < -Math.PI) d += Math.PI * 2;
|
||||
return a + d * t;
|
||||
}
|
||||
|
||||
const _sd1 = new THREE.Vector3();
|
||||
const _sd2 = new THREE.Vector3();
|
||||
|
||||
/** Distance from point `p` to segment a-b; writes the closest point into `out`. */
|
||||
export function segDist(p, a, b, out) {
|
||||
_sd1.subVectors(b, a);
|
||||
_sd2.subVectors(p, a);
|
||||
const t = clamp(_sd2.dot(_sd1) / Math.max(1e-9, _sd1.lengthSq()), 0, 1);
|
||||
out.copy(a).addScaledVector(_sd1, t);
|
||||
return p.distanceTo(out);
|
||||
}
|
||||
|
||||
const _u = new THREE.Vector3();
|
||||
const _v = new THREE.Vector3();
|
||||
const _w = new THREE.Vector3();
|
||||
|
||||
/**
|
||||
* Closest distance between two segments, writing the closest point on each
|
||||
* into `outA` / `outB`.
|
||||
*
|
||||
* Used to work out which limb hit which limb: both ragdolls are 18 capsules,
|
||||
* and a capsule is a segment plus a radius, so the nearest pair of segments is
|
||||
* the nearest pair of body parts. Standard Ericson clamped-parameter solve —
|
||||
* the degenerate cases (either segment a point, or the two parallel) all fall
|
||||
* out of the denominator guards rather than needing separate branches.
|
||||
*/
|
||||
export function segSegDistance(p1, q1, p2, q2, outA, outB) {
|
||||
_u.subVectors(q1, p1);
|
||||
_v.subVectors(q2, p2);
|
||||
_w.subVectors(p1, p2);
|
||||
const a = _u.dot(_u);
|
||||
const b = _u.dot(_v);
|
||||
const c = _v.dot(_v);
|
||||
const d = _u.dot(_w);
|
||||
const e = _v.dot(_w);
|
||||
const D = a * c - b * b;
|
||||
let sN;
|
||||
let sD = D;
|
||||
let tN;
|
||||
let tD = D;
|
||||
|
||||
if (D < 1e-9) {
|
||||
// Parallel or degenerate: pin the first parameter and solve the second.
|
||||
sN = 0;
|
||||
sD = 1;
|
||||
tN = e;
|
||||
tD = c;
|
||||
} else {
|
||||
sN = b * e - c * d;
|
||||
tN = a * e - b * d;
|
||||
if (sN < 0) {
|
||||
sN = 0;
|
||||
tN = e;
|
||||
tD = c;
|
||||
} else if (sN > sD) {
|
||||
sN = sD;
|
||||
tN = e + b;
|
||||
tD = c;
|
||||
}
|
||||
}
|
||||
|
||||
if (tN < 0) {
|
||||
tN = 0;
|
||||
if (-d < 0) sN = 0;
|
||||
else if (-d > a) sN = sD;
|
||||
else {
|
||||
sN = -d;
|
||||
sD = a;
|
||||
}
|
||||
} else if (tN > tD) {
|
||||
tN = tD;
|
||||
if (-d + b < 0) sN = 0;
|
||||
else if (-d + b > a) sN = sD;
|
||||
else {
|
||||
sN = -d + b;
|
||||
sD = a;
|
||||
}
|
||||
}
|
||||
|
||||
const s = Math.abs(sD) < 1e-9 ? 0 : sN / sD;
|
||||
const t = Math.abs(tD) < 1e-9 ? 0 : tN / tD;
|
||||
outA.copy(p1).addScaledVector(_u, s);
|
||||
outB.copy(p2).addScaledVector(_v, t);
|
||||
return outA.distanceTo(outB);
|
||||
}
|
||||
|
||||
const _euler = new THREE.Euler();
|
||||
/** Write XYZ euler angles into an existing quaternion without allocating. */
|
||||
export function E(out, x, y, z, order) {
|
||||
_euler.set(x, y, z, order || 'XYZ');
|
||||
return out.setFromEuler(_euler);
|
||||
}
|
||||
export { _euler };
|
||||
|
||||
/** Merge indexed BufferGeometries that share an attribute set. */
|
||||
export function mergeGeoms(list) {
|
||||
let vTotal = 0;
|
||||
let iTotal = 0;
|
||||
const attrNames = Object.keys(list[0].attributes);
|
||||
for (const g of list) {
|
||||
vTotal += g.attributes.position.count;
|
||||
iTotal += g.index.count;
|
||||
}
|
||||
const out = new THREE.BufferGeometry();
|
||||
const arrays = {};
|
||||
for (const name of attrNames) {
|
||||
const itemSize = list[0].attributes[name].itemSize;
|
||||
const Ctor = list[0].attributes[name].array.constructor;
|
||||
arrays[name] = new Ctor(vTotal * itemSize);
|
||||
}
|
||||
const index = new (vTotal > 65535 ? Uint32Array : Uint16Array)(iTotal);
|
||||
let vOff = 0;
|
||||
let iOff = 0;
|
||||
for (const g of list) {
|
||||
const n = g.attributes.position.count;
|
||||
for (const name of attrNames) {
|
||||
arrays[name].set(g.attributes[name].array, vOff * g.attributes[name].itemSize);
|
||||
}
|
||||
const gi = g.index.array;
|
||||
for (let i = 0; i < gi.length; i++) index[iOff + i] = gi[i] + vOff;
|
||||
vOff += n;
|
||||
iOff += gi.length;
|
||||
}
|
||||
for (const name of attrNames) {
|
||||
out.setAttribute(name, new THREE.BufferAttribute(arrays[name], list[0].attributes[name].itemSize));
|
||||
}
|
||||
out.setIndex(new THREE.BufferAttribute(index, 1));
|
||||
return out;
|
||||
}
|
||||
|
||||
/** Normalize an arbitrary geometry to position/normal/uv + index so it can merge. */
|
||||
export function stripAttrs(g) {
|
||||
const out = new THREE.BufferGeometry();
|
||||
out.setAttribute('position', g.attributes.position);
|
||||
out.setAttribute('normal', g.attributes.normal);
|
||||
const n = g.attributes.position.count;
|
||||
out.setAttribute('uv', g.attributes.uv || new THREE.Float32BufferAttribute(new Float32Array(n * 2), 2));
|
||||
if (g.index) out.setIndex(g.index);
|
||||
else {
|
||||
const idx = [];
|
||||
for (let i = 0; i < n; i++) idx.push(i);
|
||||
out.setIndex(idx);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
export function disposeObject(root) {
|
||||
root.traverse((o) => {
|
||||
if (o.geometry) o.geometry.dispose();
|
||||
if (o.material) {
|
||||
const mats = Array.isArray(o.material) ? o.material : [o.material];
|
||||
for (const m of mats) {
|
||||
for (const k of Object.keys(m)) if (m[k] && m[k].isTexture) m[k].dispose();
|
||||
m.dispose();
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
// Seeded PRNG. One integer seed drives every generated detail of a fighter.
|
||||
//
|
||||
// The showcase this grew out of used a module-level generator, which is fine
|
||||
// for one character on screen. A match has at least two, and they have to be
|
||||
// independently reproducible from their own seeds, so the generator is an
|
||||
// object that gets threaded through the builders instead.
|
||||
|
||||
export function makeRng(seed) {
|
||||
let a = seed | 0;
|
||||
const f = () => {
|
||||
a |= 0;
|
||||
a = (a + 0x6d2b79f5) | 0;
|
||||
let t = Math.imul(a ^ (a >>> 15), 1 | a);
|
||||
t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
|
||||
return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
|
||||
};
|
||||
return {
|
||||
seed,
|
||||
f,
|
||||
range: (lo, hi) => lo + (hi - lo) * f(),
|
||||
int: (lo, hi) => Math.floor(lo + (hi + 0.9999 - lo) * f()),
|
||||
pick: (arr) => arr[Math.floor(f() * arr.length) % arr.length],
|
||||
// Independent sub-stream, so adding a generator in one place doesn't shift
|
||||
// every value drawn after it.
|
||||
fork: (salt) => makeRng((Math.imul(seed ^ salt, 0x9e3779b1) ^ (seed >>> 3)) | 0),
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,281 @@
|
||||
import * as THREE from 'three';
|
||||
import { segSegDistance } from '../core/math.js';
|
||||
import { KIND, readTag } from '../physics/bridge.js';
|
||||
import { REGION } from '../character/skeleton.js';
|
||||
import { clamp } from '../../shared/scalar.js';
|
||||
|
||||
/**
|
||||
* Body checks.
|
||||
*
|
||||
* Two problems have to be solved separately, and conflating them is what makes
|
||||
* hits feel like one canned event:
|
||||
*
|
||||
* *Did* a hit land — a physics question, answered by the proxy capsules,
|
||||
* which are what actually collide. Closing speed and mass give severity.
|
||||
*
|
||||
* *What kind* of hit was it — a pose question, and the proxy cannot answer
|
||||
* it. A capsule contact point tells you two bodies met at roughly hip height;
|
||||
* it cannot tell you a shoulder went through a chest. So on the frame a hit
|
||||
* lands we go back to the two 18-capsule ragdolls, which *are* posed, and
|
||||
* find the closest pair of limbs. That pair is the hit: `upperArmR → spine2`
|
||||
* is a shoulder into the chest, `pelvis → thighL` is a hip check, `spine3 →
|
||||
* head` is the one that should draw a penalty.
|
||||
*
|
||||
* 324 segment-segment tests sounds like a lot until you notice it only runs on
|
||||
* the frame of an actual impact, which is a handful of times a match.
|
||||
*/
|
||||
|
||||
export const HIT = {
|
||||
/**
|
||||
* Closing speed thresholds, m/s. Below `bump` nothing happens beyond the
|
||||
* momentum the solver already exchanged.
|
||||
*/
|
||||
bump: 2.6,
|
||||
stagger: 4.4,
|
||||
knockdown: 7.0,
|
||||
/** Impulse per m/s of closing speed, per kg of effective mass. */
|
||||
impulseScale: 0.55,
|
||||
/**
|
||||
* How much of the impulse goes into the struck limb at the contact point,
|
||||
* versus into the pelvis through its centre.
|
||||
*
|
||||
* All of it at the contact point is what launches people: the point is on
|
||||
* the chest, well above the centre of mass, so a linear impulse there is
|
||||
* mostly torque and the victim cartwheels over the hitter. Driving most of
|
||||
* the mass from the middle and using the limb share only to shape the fall
|
||||
* is what makes a check read as being knocked *down and back*.
|
||||
*/
|
||||
limbShare: 0.35,
|
||||
/**
|
||||
* Upward fraction. A check lifts a skater slightly off their edges; it does
|
||||
* not throw them in the air.
|
||||
*/
|
||||
liftKnockdown: 0.15,
|
||||
liftStagger: 0.08,
|
||||
/** A hit to the head or an unbraced back is worth more than a square one. */
|
||||
blindsideBonus: 1.5,
|
||||
headBonus: 1.4,
|
||||
/** Joint stiffness for a stagger — stiff enough to stay on the feet. */
|
||||
staggerStiffness: 5,
|
||||
/** Seconds a downed skater stays down before getting up. */
|
||||
downTime: 1.5,
|
||||
/** Seconds of get-up blend from the collapsed pose back to skating. */
|
||||
riseTime: 0.7,
|
||||
/** Ignore repeat contacts between the same pair for this long. */
|
||||
refractory: 0.45,
|
||||
};
|
||||
|
||||
/** Which part of the *attacker* delivered it — this is what varies the hit. */
|
||||
const DELIVERED_BY = {
|
||||
upperArmL: 'shoulder', upperArmR: 'shoulder', spine3: 'shoulder',
|
||||
spine1: 'body', spine2: 'body',
|
||||
pelvis: 'hip', thighL: 'hip', thighR: 'hip',
|
||||
forearmL: 'arm', forearmR: 'arm',
|
||||
shinL: 'leg', shinR: 'leg',
|
||||
};
|
||||
|
||||
/**
|
||||
* Parts that can deliver a check.
|
||||
*
|
||||
* Not a fudge — a rule of the game. A skater at speed is pitched ~30° forward,
|
||||
* which makes the *head* the geometrically leading part of the body, so an
|
||||
* unrestricted nearest-pair search credits almost every hit to a headbutt. You
|
||||
* check with a shoulder, a chest, a hip or a thigh.
|
||||
*
|
||||
* The victim side stays unrestricted, deliberately: a shoulder that arrives at
|
||||
* someone's head is exactly the hit that should register as a head shot.
|
||||
*/
|
||||
const CAN_DELIVER = new Set(Object.keys(DELIVERED_BY));
|
||||
|
||||
/** Human-readable label, for the HUD and for tests to assert against. */
|
||||
export function describeHit(hit) {
|
||||
const where = hit.victimRegion === REGION.HEAD ? 'head'
|
||||
: hit.victimRegion === REGION.TORSO ? 'body'
|
||||
: hit.victimRegion.startsWith('upperLeg') || hit.victimRegion.startsWith('lowerLeg') ? 'legs'
|
||||
: 'arm';
|
||||
return `${hit.by} to the ${where}`;
|
||||
}
|
||||
|
||||
const _a1 = new THREE.Vector3();
|
||||
const _b1 = new THREE.Vector3();
|
||||
const _rel = new THREE.Vector3();
|
||||
const _dir = new THREE.Vector3();
|
||||
const _impulse = new THREE.Vector3();
|
||||
const _point = new THREE.Vector3();
|
||||
|
||||
/**
|
||||
* Closest limb pair between two posed ragdolls.
|
||||
* Returns `{ attackerPart, victimPart, point, distance }`, or null if the two
|
||||
* rigs are somehow nowhere near each other.
|
||||
*/
|
||||
export function closestLimbs(attacker, victim, { deliveringOnly = true } = {}) {
|
||||
const A = attacker.worldSegments();
|
||||
// `worldSegments` reuses its scratch array, so the first result has to be
|
||||
// copied out before the second call overwrites it.
|
||||
const aCopy = A
|
||||
.filter((s) => !deliveringOnly || CAN_DELIVER.has(s.part.name))
|
||||
.map((s) => ({ part: s.part, a: s.a.clone(), b: s.b.clone(), radius: s.radius }));
|
||||
const B = victim.worldSegments();
|
||||
|
||||
let best = null;
|
||||
let bestGap = Infinity;
|
||||
for (const sa of aCopy) {
|
||||
for (const sb of B) {
|
||||
const d = segSegDistance(sa.a, sa.b, sb.a, sb.b, _a1, _b1) - sa.radius - sb.radius;
|
||||
if (d < bestGap) {
|
||||
bestGap = d;
|
||||
if (!best) best = { attackerPart: null, victimPart: null, point: new THREE.Vector3(), distance: 0 };
|
||||
best.attackerPart = sa.part;
|
||||
best.victimPart = sb.part;
|
||||
// Midway between the two surfaces is where the impact reads as having
|
||||
// happened, and is where the impulse should be applied.
|
||||
best.point.addVectors(_a1, _b1).multiplyScalar(0.5);
|
||||
best.distance = d;
|
||||
}
|
||||
}
|
||||
}
|
||||
return best;
|
||||
}
|
||||
|
||||
/**
|
||||
* Wire up hit detection for a match.
|
||||
*
|
||||
* `onHit` is called with a description of every landed check, for the HUD,
|
||||
* audio and (later) penalties.
|
||||
*/
|
||||
export function createHitResolver({ physics, skaters, states, onHit = null }) {
|
||||
// Last time each unordered pair traded a hit, so one collision does not fire
|
||||
// every substep it stays in contact.
|
||||
const lastHit = new Map();
|
||||
let clock = 0;
|
||||
|
||||
const pairKey = (i, j) => (i < j ? `${i}|${j}` : `${j}|${i}`);
|
||||
|
||||
function resolve(event) {
|
||||
const a = readTag(event.userMaterialIdA);
|
||||
const b = readTag(event.userMaterialIdB);
|
||||
// Only proxy-on-proxy counts as a check. Limb contacts happen constantly
|
||||
// once someone is down and are not hits.
|
||||
if (a.kind !== KIND.PROXY || b.kind !== KIND.PROXY) return;
|
||||
if (a.skater === b.skater) return;
|
||||
|
||||
const speed = event.approachSpeed;
|
||||
if (speed < HIT.bump) return;
|
||||
|
||||
const key = pairKey(a.skater, b.skater);
|
||||
if (clock - (lastHit.get(key) ?? -Infinity) < HIT.refractory) return;
|
||||
|
||||
// Whoever is carrying more speed into the contact is the one throwing it.
|
||||
const sa = states[a.skater];
|
||||
const sb = states[b.skater];
|
||||
_rel.set(sb.x - sa.x, 0, sb.z - sa.z);
|
||||
const len = _rel.length() || 1;
|
||||
_rel.multiplyScalar(1 / len);
|
||||
const closingA = sa.vx * _rel.x + sa.vz * _rel.z;
|
||||
const closingB = -(sb.vx * _rel.x + sb.vz * _rel.z);
|
||||
const attackerIndex = closingA >= closingB ? a.skater : b.skater;
|
||||
const victimIndex = attackerIndex === a.skater ? b.skater : a.skater;
|
||||
|
||||
const attacker = skaters[attackerIndex];
|
||||
const victim = skaters[victimIndex];
|
||||
// Neither a body already on the ice nor a body being slid into by one is
|
||||
// throwing a check. Those contacts are real and the solver handles them;
|
||||
// they are just not hits, and attributing one to a limp skater's flailing
|
||||
// hand produces nonsense like "arm to the legs" as a headline event.
|
||||
if (!attacker?.ragdoll || !victim?.ragdoll) return;
|
||||
if (attacker.limp || victim.limp) return;
|
||||
|
||||
const pair = closestLimbs(attacker.ragdoll, victim.ragdoll);
|
||||
if (!pair) return;
|
||||
|
||||
// Direction of the blow: attacker's travel, which is what the victim
|
||||
// actually has to absorb.
|
||||
const attackerState = states[attackerIndex];
|
||||
const victimState = states[victimIndex];
|
||||
_dir.set(attackerState.vx - victimState.vx, 0, attackerState.vz - victimState.vz);
|
||||
if (_dir.lengthSq() < 1e-6) _dir.set(_rel.x, 0, _rel.z);
|
||||
_dir.normalize();
|
||||
|
||||
// A hit taken from behind or side-on is worth more than one you can brace
|
||||
// for: `facing` is +1 square on, -1 straight in the back.
|
||||
const victimFacing = Math.sin(victimState.yaw) * -_dir.x + Math.cos(victimState.yaw) * -_dir.z;
|
||||
const blindside = clamp((1 - victimFacing) / 2, 0, 1);
|
||||
|
||||
const by = DELIVERED_BY[pair.attackerPart.name] ?? 'body';
|
||||
const region = pair.victimPart.region;
|
||||
const headshot = region === REGION.HEAD;
|
||||
|
||||
let severity = speed
|
||||
* (1 + blindside * (HIT.blindsideBonus - 1))
|
||||
* (headshot ? HIT.headBonus : 1);
|
||||
// A hit thrown with an arm or a trailing leg is a brush, not a check.
|
||||
if (by === 'arm' || by === 'leg') severity *= 0.55;
|
||||
|
||||
const outcome = severity >= HIT.knockdown ? 'knockdown'
|
||||
: severity >= HIT.stagger ? 'stagger'
|
||||
: 'bump';
|
||||
|
||||
lastHit.set(key, clock);
|
||||
|
||||
const hit = {
|
||||
attacker: attackerIndex,
|
||||
victim: victimIndex,
|
||||
by,
|
||||
attackerPart: pair.attackerPart.name,
|
||||
victimPart: pair.victimPart.name,
|
||||
victimRegion: region,
|
||||
speed,
|
||||
severity,
|
||||
blindside,
|
||||
headshot,
|
||||
outcome,
|
||||
point: pair.point.clone(),
|
||||
direction: _dir.clone(),
|
||||
};
|
||||
|
||||
apply(hit);
|
||||
if (onHit) onHit(hit);
|
||||
}
|
||||
|
||||
/** Turn a resolved hit into forces on the victim's skeleton. */
|
||||
function apply(hit) {
|
||||
if (hit.outcome === 'bump') return;
|
||||
const victim = skaters[hit.victim];
|
||||
const body = victim.ragdoll;
|
||||
|
||||
const knockdown = hit.outcome === 'knockdown';
|
||||
// Impulse scaled by the mass actually being moved, aimed slightly upward —
|
||||
// a purely horizontal shove on a body standing on near-frictionless ice
|
||||
// just slides it along without ever putting it on the floor.
|
||||
const mag = hit.severity * HIT.impulseScale * body.totalMass() * 0.08;
|
||||
const lift = knockdown ? HIT.liftKnockdown : HIT.liftStagger;
|
||||
|
||||
if (knockdown) victim.goDown(hit);
|
||||
else victim.stagger(hit);
|
||||
|
||||
// Most of it through the pelvis centre, which moves the whole body; the
|
||||
// rest at the contact point, which is what tips them over.
|
||||
_impulse.copy(hit.direction).multiplyScalar(mag * (1 - HIT.limbShare));
|
||||
_impulse.y += mag * lift * (1 - HIT.limbShare);
|
||||
body.applyImpulse('pelvis', _impulse, null);
|
||||
|
||||
_impulse.copy(hit.direction).multiplyScalar(mag * HIT.limbShare);
|
||||
_impulse.y += mag * lift * HIT.limbShare;
|
||||
_point.copy(hit.point);
|
||||
body.applyImpulse(hit.victimPart, _impulse, _point);
|
||||
}
|
||||
|
||||
const off = physics.onHit(resolve);
|
||||
|
||||
return {
|
||||
/** Advance the refractory clock. Call once per frame. */
|
||||
tick(dt) {
|
||||
clock += dt;
|
||||
},
|
||||
get time() { return clock; },
|
||||
destroy() {
|
||||
off();
|
||||
lastHit.clear();
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,389 @@
|
||||
import { clamp } from '../../shared/scalar.js';
|
||||
|
||||
/**
|
||||
* Player input: Xbox pad first, keyboard as a fallback.
|
||||
*
|
||||
* Two things this module is careful about.
|
||||
*
|
||||
* **Screen space, not world space.** Sticks come out as `x` right / `y` away
|
||||
* from the camera. Converting to a world direction needs the camera yaw, which
|
||||
* belongs to the match. Keeping input ignorant of the camera means the same
|
||||
* reading works for a follow cam, a broadcast cam or a fixed overhead one.
|
||||
*
|
||||
* **Semantics, not button indices.** Everything downstream asks for `pass` or
|
||||
* `hustle`, never `buttons[7]`. Remapping then happens in one table, and the
|
||||
* game code does not care whether a shot came from the Skill Stick or a key.
|
||||
*
|
||||
* The output object is reused every frame and mutated in place — `match`
|
||||
* holds a reference to it, so handing it over once is enough.
|
||||
*/
|
||||
|
||||
/**
|
||||
* W3C "standard" gamepad layout, which is what an Xbox pad reports.
|
||||
* Named for what they do in this game rather than for the letter on the pad,
|
||||
* except where the letter *is* the convention players expect.
|
||||
*/
|
||||
export const PAD = {
|
||||
A: 0, B: 1, X: 2, Y: 3,
|
||||
LB: 4, RB: 5, LT: 6, RT: 7,
|
||||
BACK: 8, START: 9, LS: 10, RS: 11,
|
||||
DPAD_UP: 12, DPAD_DOWN: 13, DPAD_LEFT: 14, DPAD_RIGHT: 15,
|
||||
};
|
||||
|
||||
/** Action → pad button. One table, so remapping is a one-line change. */
|
||||
const BINDING = {
|
||||
pass: PAD.A,
|
||||
shoot: PAD.X,
|
||||
poke: PAD.B,
|
||||
dump: PAD.Y,
|
||||
switchPlayer: PAD.LB,
|
||||
deke: PAD.RB,
|
||||
start: PAD.START,
|
||||
camera: PAD.BACK,
|
||||
};
|
||||
|
||||
/** Action → keyboard codes. Arrows drive the Skill Stick, WASD skates. */
|
||||
const KEYS = {
|
||||
up: ['KeyW'],
|
||||
down: ['KeyS'],
|
||||
left: ['KeyA'],
|
||||
right: ['KeyD'],
|
||||
hustle: ['ShiftLeft', 'ShiftRight'],
|
||||
protect: ['Space'],
|
||||
skillUp: ['ArrowUp'],
|
||||
skillDown: ['ArrowDown'],
|
||||
skillLeft: ['ArrowLeft'],
|
||||
skillRight: ['ArrowRight'],
|
||||
pass: ['KeyJ'],
|
||||
shoot: ['KeyK'],
|
||||
poke: ['KeyL'],
|
||||
dump: ['KeyU'],
|
||||
switchPlayer: ['KeyQ'],
|
||||
deke: ['KeyE'],
|
||||
};
|
||||
|
||||
/** Sticks rest off-centre when worn; triggers rest slightly pressed. */
|
||||
const STICK_DEADZONE = 0.18;
|
||||
const TRIGGER_DEADZONE = 0.06;
|
||||
|
||||
/**
|
||||
* Skill Stick shot gesture, as the NHL games do it: pull the right stick back,
|
||||
* then push it forward. How long and how far you pulled sets the power, so a
|
||||
* flick is a wrist shot and a full wind-up is a slapshot.
|
||||
*/
|
||||
const SHOT = {
|
||||
/** Right stick Y below this counts as winding up. */
|
||||
windAt: -0.5,
|
||||
/** ...and above this, having wound up, releases. */
|
||||
releaseAt: 0.35,
|
||||
/** Wind-up time for full power, seconds. */
|
||||
fullWind: 0.55,
|
||||
/** A wind-up abandoned for this long is forgotten rather than fired. */
|
||||
timeout: 1.6,
|
||||
/** Floor so a quick snap still does something. */
|
||||
minPower: 0.25,
|
||||
};
|
||||
|
||||
const rising = () => ({
|
||||
pass: false, shoot: false, poke: false, dump: false,
|
||||
switchPlayer: false, deke: false, start: false, camera: false,
|
||||
});
|
||||
|
||||
export function createInput(target = window) {
|
||||
const held = new Set();
|
||||
|
||||
const onDown = (e) => {
|
||||
if (Object.values(KEYS).some((list) => list.includes(e.code))) e.preventDefault();
|
||||
held.add(e.code);
|
||||
};
|
||||
const onUp = (e) => held.delete(e.code);
|
||||
// A keyup that lands while the tab is unfocused never arrives, which leaves a
|
||||
// skater sprinting into the boards forever. Clear everything on blur.
|
||||
const onBlur = () => held.clear();
|
||||
|
||||
target.addEventListener('keydown', onDown);
|
||||
target.addEventListener('keyup', onUp);
|
||||
window.addEventListener('blur', onBlur);
|
||||
|
||||
let padIndex = null;
|
||||
const onConnect = (e) => { padIndex = e.gamepad.index; };
|
||||
const onDisconnect = (e) => { if (padIndex === e.gamepad.index) padIndex = null; };
|
||||
window.addEventListener('gamepadconnected', onConnect);
|
||||
window.addEventListener('gamepaddisconnected', onDisconnect);
|
||||
|
||||
const any = (codes) => codes.some((c) => held.has(c));
|
||||
|
||||
// Previous frame's button state, for edge detection.
|
||||
const wasDown = rising();
|
||||
|
||||
/** Wind-up state for the Skill Stick. */
|
||||
const wind = { active: false, t: 0, depth: 0, aim: 0, idle: 0 };
|
||||
|
||||
const state = {
|
||||
// ---- the movement contract the match consumes --------------------------
|
||||
x: 0,
|
||||
y: 0,
|
||||
sprint: false,
|
||||
brake: false,
|
||||
cameraYaw: 0,
|
||||
|
||||
// ---- richer view for everything else -----------------------------------
|
||||
/** Left stick, screen space. Same numbers as x/y. */
|
||||
move: { x: 0, y: 0 },
|
||||
/** Right stick — the Skill Stick. */
|
||||
skill: { x: 0, y: 0 },
|
||||
/** Analog triggers, 0..1. */
|
||||
hustle: 0,
|
||||
protect: 0,
|
||||
/** Held this frame. */
|
||||
held: rising(),
|
||||
/** True only on the frame the button went down. */
|
||||
pressed: rising(),
|
||||
/**
|
||||
* Set on the frame a Skill Stick wind-up is released, then cleared.
|
||||
* `{ power: 0..1, aim: -1..1 }` — aim is the stick's lateral position at
|
||||
* release, which is where the shot is being placed.
|
||||
*/
|
||||
shot: null,
|
||||
/** How wound up the shot is right now, 0..1. Drives the wind-up pose. */
|
||||
charge: 0,
|
||||
source: 'none',
|
||||
padId: null,
|
||||
};
|
||||
|
||||
function readPad() {
|
||||
const pads = navigator.getGamepads?.() ?? [];
|
||||
if (padIndex != null && pads[padIndex]) return pads[padIndex];
|
||||
// The connect event does not fire if the pad was already held when the page
|
||||
// loaded, so fall back to scanning.
|
||||
for (const p of pads) if (p?.connected) return p;
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Radial deadzone, rescaled so the first movement past it is slow.
|
||||
*
|
||||
* Direction comes from the raw axes and magnitude is rescaled and capped
|
||||
* separately. Clamping the two components instead would let a pad that
|
||||
* reports a square range rather than a circular one hand back a diagonal of
|
||||
* length 1.41 — a stick that is 41% faster on the diagonals.
|
||||
*/
|
||||
function stick(rawX, rawY, out) {
|
||||
const mag = Math.hypot(rawX, rawY);
|
||||
if (mag <= STICK_DEADZONE) {
|
||||
out.x = 0;
|
||||
out.y = 0;
|
||||
return false;
|
||||
}
|
||||
const scaled = clamp((mag - STICK_DEADZONE) / (1 - STICK_DEADZONE), 0, 1);
|
||||
out.x = (rawX / mag) * scaled;
|
||||
out.y = (-rawY / mag) * scaled; // pad Y is positive downward
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Advance the shot gesture. Returns a shot on the frame of release.
|
||||
*
|
||||
* Kept here rather than in the game because it is a property of the input
|
||||
* device — the same pull-back-and-push has to mean the same thing whatever
|
||||
* is holding the puck.
|
||||
*/
|
||||
function advanceShot(dt) {
|
||||
const y = state.skill.y;
|
||||
if (!wind.active) {
|
||||
if (y < SHOT.windAt) {
|
||||
wind.active = true;
|
||||
wind.t = 0;
|
||||
wind.depth = Math.abs(y);
|
||||
wind.aim = state.skill.x;
|
||||
}
|
||||
state.charge = 0;
|
||||
return null;
|
||||
}
|
||||
|
||||
wind.t += dt;
|
||||
wind.depth = Math.max(wind.depth, Math.abs(Math.min(0, y)));
|
||||
wind.aim = state.skill.x;
|
||||
state.charge = clamp(wind.t / SHOT.fullWind, 0, 1) * wind.depth;
|
||||
|
||||
if (y > SHOT.releaseAt) {
|
||||
const power = clamp(
|
||||
SHOT.minPower + (1 - SHOT.minPower) * clamp(wind.t / SHOT.fullWind, 0, 1) * wind.depth,
|
||||
0,
|
||||
1,
|
||||
);
|
||||
wind.active = false;
|
||||
state.charge = 0;
|
||||
return { power, aim: clamp(state.skill.x, -1, 1) };
|
||||
}
|
||||
// Held back forever without releasing: drop it rather than firing later.
|
||||
if (wind.t > SHOT.timeout) {
|
||||
wind.active = false;
|
||||
state.charge = 0;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
return {
|
||||
state,
|
||||
|
||||
/** Which pad we are reading, or null. */
|
||||
get padIndex() { return padIndex; },
|
||||
get connected() { return readPad() != null; },
|
||||
|
||||
/**
|
||||
* Sample this frame's input.
|
||||
* @param {number} dt seconds, for the shot gesture timing
|
||||
*/
|
||||
read(dt = 1 / 60) {
|
||||
const pad = readPad();
|
||||
let source = 'none';
|
||||
|
||||
// ---- sticks ------------------------------------------------------------
|
||||
let moved = false;
|
||||
let skilled = false;
|
||||
if (pad) {
|
||||
moved = stick(pad.axes[0] ?? 0, pad.axes[1] ?? 0, state.move);
|
||||
skilled = stick(pad.axes[2] ?? 0, pad.axes[3] ?? 0, state.skill);
|
||||
state.padId = pad.id;
|
||||
} else {
|
||||
state.move.x = 0;
|
||||
state.move.y = 0;
|
||||
state.skill.x = 0;
|
||||
state.skill.y = 0;
|
||||
state.padId = null;
|
||||
}
|
||||
|
||||
if (!moved) {
|
||||
// Keyboard only fills in when the stick is centred, so a pad in hand
|
||||
// always wins and a stuck key cannot fight it.
|
||||
let kx = 0;
|
||||
let ky = 0;
|
||||
if (any(KEYS.right)) kx += 1;
|
||||
if (any(KEYS.left)) kx -= 1;
|
||||
if (any(KEYS.up)) ky += 1;
|
||||
if (any(KEYS.down)) ky -= 1;
|
||||
const len = Math.hypot(kx, ky);
|
||||
if (len > 0) {
|
||||
state.move.x = kx / Math.max(1, len);
|
||||
state.move.y = ky / Math.max(1, len);
|
||||
source = 'keyboard';
|
||||
}
|
||||
} else {
|
||||
source = 'gamepad';
|
||||
}
|
||||
|
||||
if (!skilled) {
|
||||
let sx = 0;
|
||||
let sy = 0;
|
||||
if (any(KEYS.skillRight)) sx += 1;
|
||||
if (any(KEYS.skillLeft)) sx -= 1;
|
||||
if (any(KEYS.skillUp)) sy += 1;
|
||||
if (any(KEYS.skillDown)) sy -= 1;
|
||||
const len = Math.hypot(sx, sy);
|
||||
if (len > 0) {
|
||||
state.skill.x = sx / Math.max(1, len);
|
||||
state.skill.y = sy / Math.max(1, len);
|
||||
if (source === 'none') source = 'keyboard';
|
||||
}
|
||||
} else if (source === 'none') {
|
||||
source = 'gamepad';
|
||||
}
|
||||
|
||||
// ---- triggers ----------------------------------------------------------
|
||||
// Analog, not boolean: hustle is a throttle, and half-pressing it is how
|
||||
// you keep speed without over-committing.
|
||||
const trigger = (i) => {
|
||||
const b = pad?.buttons?.[i];
|
||||
if (!b) return 0;
|
||||
const v = typeof b.value === 'number' ? b.value : (b.pressed ? 1 : 0);
|
||||
return v <= TRIGGER_DEADZONE ? 0 : (v - TRIGGER_DEADZONE) / (1 - TRIGGER_DEADZONE);
|
||||
};
|
||||
state.hustle = trigger(PAD.RT);
|
||||
state.protect = trigger(PAD.LT);
|
||||
if (state.hustle > 0 || state.protect > 0) source = 'gamepad';
|
||||
if (any(KEYS.hustle)) state.hustle = 1;
|
||||
if (any(KEYS.protect)) state.protect = 1;
|
||||
if ((any(KEYS.hustle) || any(KEYS.protect)) && source === 'none') source = 'keyboard';
|
||||
|
||||
// ---- buttons -----------------------------------------------------------
|
||||
for (const action of Object.keys(BINDING)) {
|
||||
const padDown = !!pad?.buttons?.[BINDING[action]]?.pressed;
|
||||
const keyDown = KEYS[action] ? any(KEYS[action]) : false;
|
||||
const down = padDown || keyDown;
|
||||
state.pressed[action] = down && !wasDown[action];
|
||||
state.held[action] = down;
|
||||
wasDown[action] = down;
|
||||
if (down) source = padDown ? 'gamepad' : 'keyboard';
|
||||
}
|
||||
|
||||
// ---- derived contract --------------------------------------------------
|
||||
state.x = state.move.x;
|
||||
state.y = state.move.y;
|
||||
// Above half-throttle counts as the sprint stride. The sim takes a
|
||||
// boolean today; when it takes a throttle this is the line that changes.
|
||||
state.sprint = state.hustle > 0.5;
|
||||
state.brake = state.protect > 0.5;
|
||||
state.source = source;
|
||||
|
||||
// ---- Skill Stick -------------------------------------------------------
|
||||
state.shot = advanceShot(dt);
|
||||
// Pressing the shoot button is the same event as a stick release, so a
|
||||
// player who never learns the Skill Stick can still shoot.
|
||||
if (!state.shot && state.pressed.shoot) {
|
||||
state.shot = { power: 0.6, aim: clamp(state.skill.x, -1, 1) };
|
||||
}
|
||||
|
||||
return state;
|
||||
},
|
||||
|
||||
/**
|
||||
* Rumble. Silently does nothing on a pad or browser without haptics, which
|
||||
* is most of them — never let feedback become a hard dependency.
|
||||
*/
|
||||
rumble(strong = 0.5, weak = 0.3, ms = 120) {
|
||||
const pad = readPad();
|
||||
const actuator = pad?.vibrationActuator;
|
||||
if (!actuator?.playEffect) return false;
|
||||
try {
|
||||
actuator.playEffect('dual-rumble', {
|
||||
duration: ms,
|
||||
strongMagnitude: clamp(strong, 0, 1),
|
||||
weakMagnitude: clamp(weak, 0, 1),
|
||||
});
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
},
|
||||
|
||||
destroy() {
|
||||
target.removeEventListener('keydown', onDown);
|
||||
target.removeEventListener('keyup', onUp);
|
||||
window.removeEventListener('blur', onBlur);
|
||||
window.removeEventListener('gamepadconnected', onConnect);
|
||||
window.removeEventListener('gamepaddisconnected', onDisconnect);
|
||||
held.clear();
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Turn a screen-space stick into a world-space intent, given where the camera
|
||||
* is looking.
|
||||
*
|
||||
* The camera orbits at `cameraYaw`, sitting at `+(sin, cos)` from its target,
|
||||
* so it looks along `-(sin, cos)` and its right is `(cos, -sin)`. Pushing the
|
||||
* stick away from yourself has to mean "away from the camera" regardless of
|
||||
* which way the skater currently faces, or steering becomes unusable the moment
|
||||
* the camera swings round behind them.
|
||||
*/
|
||||
export function stickToWorld(stick, cameraYaw, out = { ix: 0, iz: 0 }) {
|
||||
const s = Math.sin(cameraYaw);
|
||||
const c = Math.cos(cameraYaw);
|
||||
out.ix = c * stick.x - s * stick.y;
|
||||
out.iz = -s * stick.x - c * stick.y;
|
||||
return out;
|
||||
}
|
||||
|
||||
export { SHOT };
|
||||
@@ -0,0 +1,508 @@
|
||||
import * as THREE from 'three';
|
||||
import { createSkater } from '../character/skater.js';
|
||||
import { createBrain, spawnLineup, steer } from '../../shared/ai.js';
|
||||
import { applyIntent, createSkaterState, stepSkater } from '../../shared/skaterSim.js';
|
||||
import { stickToWorld } from './input.js';
|
||||
import { createHitResolver } from './hits.js';
|
||||
import { PUCK, createPuck } from '../physics/puck.js';
|
||||
import { NET, goalLineX } from '../../shared/net.js';
|
||||
import { createPossession } from './possession.js';
|
||||
import { makeRng } from '../core/rng.js';
|
||||
import { clamp, wrapAngle } from '../../shared/scalar.js';
|
||||
|
||||
/**
|
||||
* The match loop.
|
||||
*
|
||||
* Order per frame is the whole design in six lines, so it is worth being
|
||||
* explicit about why it is this order:
|
||||
*
|
||||
* 1. brains produce intent — decisions, once per frame
|
||||
* 2. physics substeps, and inside each one:
|
||||
* a. read position/velocity out of the proxy capsules
|
||||
* b. step the skating sim, which edits that velocity
|
||||
* c. write it back, then let Box3D solve boards and body contact
|
||||
* 3. animation runs on the frame clock from the resolved state
|
||||
* 4. the kinematic ragdolls chase the animated skeleton
|
||||
*
|
||||
* The sim living *inside* the substep loop is the part that matters. Skating
|
||||
* is momentum, and momentum only survives a collision if the thing that
|
||||
* resolved the collision and the thing that integrates the motion agree about
|
||||
* the timestep. Running the sim once per frame and Box3D six times would mean
|
||||
* a board hit gets partly overwritten by a stale velocity.
|
||||
*/
|
||||
|
||||
export function createMatch({ scene, physics, perTeam = 3, teams = 2, seed = 20260802 }) {
|
||||
const rng = makeRng(seed);
|
||||
const spawns = spawnLineup(perTeam, teams);
|
||||
const count = spawns.length;
|
||||
|
||||
const states = [];
|
||||
const brains = [];
|
||||
const skaters = [];
|
||||
/** Previous velocity heading per skater, for the animator's bank. */
|
||||
const prevVelYaw = [];
|
||||
|
||||
for (let i = 0; i < count; i++) {
|
||||
const spawn = spawns[i];
|
||||
const team = spawn.team;
|
||||
const s = createSkaterState(i, spawn, {
|
||||
seed: seed + i * 977,
|
||||
team,
|
||||
name: `${team === 0 ? 'Home' : 'Away'} ${(i % perTeam) + 1}`,
|
||||
});
|
||||
states.push(s);
|
||||
brains.push(createBrain(rng.f, {}));
|
||||
prevVelYaw.push(spawn.yaw);
|
||||
skaters.push(createSkater({
|
||||
seed: seed + i * 977,
|
||||
scene,
|
||||
physics,
|
||||
index: i,
|
||||
team,
|
||||
position: { x: spawn.x, z: spawn.z },
|
||||
facing: spawn.yaw,
|
||||
// A little variety in build so three placeholder bodies are not clones.
|
||||
bodyStyle: {
|
||||
mass: rng.range(-0.35, 0.5),
|
||||
muscle: rng.range(0.1, 0.75),
|
||||
fat: rng.range(0, 0.25),
|
||||
},
|
||||
}));
|
||||
skaters[i].proxy?.teleport(spawn.x, spawn.z);
|
||||
}
|
||||
|
||||
/**
|
||||
* Skaters being driven by something other than their brain, by index.
|
||||
*
|
||||
* A map rather than a single index because there is no reason for there to be
|
||||
* only one: local versus is two entries, and a test driving both sides of a
|
||||
* collision is a third case. The value is a live object that is *read* each
|
||||
* frame — `input.read()` returns the same object every call, so handing it
|
||||
* over once is enough.
|
||||
*/
|
||||
const controls = new Map();
|
||||
const _worldIntent = { ix: 0, iz: 0 };
|
||||
|
||||
// ---- puck ---------------------------------------------------------------
|
||||
const puck = createPuck(physics, { position: { x: 0, y: 0.05, z: 0 } });
|
||||
/** Puck events, newest first, for the HUD. */
|
||||
const recentPlays = [];
|
||||
const possession = createPossession({
|
||||
puck,
|
||||
skaters,
|
||||
states,
|
||||
onEvent(e) {
|
||||
recentPlays.unshift({ ...e, at: performance.now?.() ?? 0 });
|
||||
if (recentPlays.length > 8) recentPlays.pop();
|
||||
},
|
||||
});
|
||||
|
||||
/** Landed checks, newest first, for the HUD. */
|
||||
const recentHits = [];
|
||||
const hits = createHitResolver({
|
||||
physics,
|
||||
skaters,
|
||||
states,
|
||||
onHit(hit) {
|
||||
recentHits.unshift({ ...hit, at: hits.time });
|
||||
if (recentHits.length > 8) recentHits.pop();
|
||||
// Getting hit costs you the puck. A stagger is enough — needing a full
|
||||
// knockdown to force a turnover made the carrier effectively untouchable.
|
||||
if (hit.outcome !== 'bump' && possession.carrier === hit.victim) {
|
||||
possession.jar(hit.severity / 8);
|
||||
}
|
||||
},
|
||||
});
|
||||
|
||||
|
||||
/**
|
||||
* Turn a controller's shot and pass buttons into puck events.
|
||||
*
|
||||
* Aim comes from where the skater is facing plus the Skill Stick's lateral
|
||||
* position, so you place a shot by holding the stick off to one side as you
|
||||
* release. A pass looks for the nearest teammate ahead instead.
|
||||
*/
|
||||
function handleShooting(i, control) {
|
||||
if (possession.carrier !== i) return;
|
||||
const state = states[i];
|
||||
|
||||
if (control.shot) {
|
||||
// Up to ~35° of placement either side of where they are pointing.
|
||||
// Skill Stick +X is "push right"; positive yaw is a left turn in this
|
||||
// frame, so aim subtracts — otherwise every placed shot went the wrong way.
|
||||
const stickAim = control.shot.aim ?? 0;
|
||||
const aimYaw = state.yaw - stickAim * 0.6;
|
||||
possession.shoot(control.shot.power, aimYaw);
|
||||
skaters[i].animator.playAction('shoot', {
|
||||
power: control.shot.power,
|
||||
aim: stickAim,
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
if (control.pressed?.pass) {
|
||||
const mate = nearestTeammate(i);
|
||||
if (mate !== null) {
|
||||
const dx = states[mate].x - state.x;
|
||||
const dz = states[mate].z - state.z;
|
||||
// Lead the target a little; a pass to where someone was is a turnover.
|
||||
const lead = 0.35;
|
||||
const aimYaw = Math.atan2(dx + states[mate].vx * lead, dz + states[mate].vz * lead);
|
||||
const range = Math.hypot(dx, dz);
|
||||
possession.shoot(clamp(range / 18, 0.3, 1), aimYaw, { pass: true });
|
||||
skaters[i].animator.playAction('pass', {
|
||||
aim: clamp(wrapAngle(aimYaw - state.yaw), -1, 1),
|
||||
});
|
||||
} else {
|
||||
// Nobody to hit — dump it forward rather than eating the input.
|
||||
possession.shoot(0.7, state.yaw, { pass: true });
|
||||
skaters[i].animator.playAction('pass');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Bot shooting and passing.
|
||||
*
|
||||
* Previously `handleShooting` sat behind `if (control)`, so only a human
|
||||
* could ever shoot — a bot picked the puck up and carried it until somebody
|
||||
* poked it away. A minute of play produced zero shots.
|
||||
*
|
||||
* The decision is deliberately simple: inside range of the net, shoot; a
|
||||
* teammate much better placed, pass; otherwise keep skating. Accuracy falls
|
||||
* off with distance so bots miss, which is the difference between a goalie
|
||||
* being tested and a goalie being beaten every time.
|
||||
*/
|
||||
// Deliberately short. Bots used to fire from 14 m at full spread and miss
|
||||
// wide; a shootout is about getting in close, not about point shots.
|
||||
const SHOT_RANGE = 8;
|
||||
function botShoot(i, dt) {
|
||||
const b = brains[i];
|
||||
b.shotCool = (b.shotCool ?? 0) - dt;
|
||||
if (b.shotCool > 0) return;
|
||||
|
||||
const s = states[i];
|
||||
const goalX = goalLineX(s.team === 0 ? 1 : -1);
|
||||
|
||||
// Pick a corner, not the middle. Aiming at the centre of the net means
|
||||
// aiming at the goalie, who is standing on exactly that line by
|
||||
// construction — thirty attempts produced thirty saves and no goals.
|
||||
// Alternating sides also stops a bot grooving the same shot every time.
|
||||
b.shotSide = b.shotSide === 1 ? -1 : 1;
|
||||
const targetZ = b.shotSide * (NET.width / 2 - 0.22);
|
||||
|
||||
const dx = goalX - s.x;
|
||||
const dz = targetZ - s.z;
|
||||
const range = Math.hypot(goalX - s.x, -s.z);
|
||||
|
||||
// Only shoot when actually facing the net; a bot firing over its shoulder
|
||||
// reads as a bug rather than as a highlight.
|
||||
const toGoal = Math.atan2(dx, dz);
|
||||
const facing = Math.abs(wrapAngle(toGoal - s.yaw));
|
||||
if (range > SHOT_RANGE || facing > 0.7) {
|
||||
// Look for a teammate in a better spot before giving up on the play.
|
||||
const mate = nearestTeammate(i);
|
||||
if (mate !== null && b.passCool == null) b.passCool = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
// Aim, with a spread that grows with range. The scale matters more than it
|
||||
// looks: 0.22 rad at 8 m is ±1.76 m of scatter against a net that is 1.83 m
|
||||
// *wide*, so bots were missing the target more often than hitting it. A
|
||||
// shot has to land inside the posts often enough for the goalie to be the
|
||||
// thing that stops it.
|
||||
const spread = clamp(range / SHOT_RANGE, 0, 1) * 0.055;
|
||||
const aimYaw = toGoal + (rng.f() * 2 - 1) * spread;
|
||||
const power = clamp(0.45 + range / SHOT_RANGE * 0.55, 0.4, 1);
|
||||
possession.shoot(power, aimYaw);
|
||||
skaters[i].animator.playAction('shoot', { power });
|
||||
b.shotCool = 1.2;
|
||||
}
|
||||
|
||||
function nearestTeammate(i) {
|
||||
let best = null;
|
||||
let bestD = Infinity;
|
||||
for (let j = 0; j < count; j++) {
|
||||
if (j === i || states[j].team !== states[i].team || skaters[j].limp) continue;
|
||||
const d = Math.hypot(states[j].x - states[i].x, states[j].z - states[i].z);
|
||||
if (d < bestD) {
|
||||
bestD = d;
|
||||
best = j;
|
||||
}
|
||||
}
|
||||
return best;
|
||||
}
|
||||
|
||||
/**
|
||||
* Extra work to run inside each physics substep, before the solve.
|
||||
* Modes register kinematic bodies of their own here — the goalie, today.
|
||||
*/
|
||||
const substepSyncs = new Set();
|
||||
|
||||
/** What the brains are told about the puck, rebuilt each frame. */
|
||||
const play = {
|
||||
puck: { x: 0, z: 0 },
|
||||
carrier: null,
|
||||
carrierTeam: null,
|
||||
/** Index of the one skater per team who is going for the puck. */
|
||||
chaser: new Array(teams).fill(null),
|
||||
};
|
||||
|
||||
/** @param {number} dt */
|
||||
function update(dt) {
|
||||
const pp = puck.position();
|
||||
play.puck.x = pp.x;
|
||||
play.puck.z = pp.z;
|
||||
play.carrier = possession.carrier;
|
||||
play.carrierTeam = possession.carrier === null ? null : states[possession.carrier].team;
|
||||
|
||||
// Nearest upright skater per side goes for the puck; everyone else finds
|
||||
// space. Recomputed every frame, which means the job passes between
|
||||
// teammates as the play moves rather than being assigned once.
|
||||
play.chaser.fill(null);
|
||||
const bestGap = new Array(teams).fill(Infinity);
|
||||
for (let i = 0; i < count; i++) {
|
||||
if (skaters[i].limp) continue;
|
||||
const t = states[i].team;
|
||||
const d = Math.hypot(states[i].x - pp.x, states[i].z - pp.z);
|
||||
if (d < bestGap[t]) {
|
||||
bestGap[t] = d;
|
||||
play.chaser[t] = i;
|
||||
}
|
||||
}
|
||||
|
||||
// ---- 1. decisions ------------------------------------------------------
|
||||
// `steer` writes intent straight onto the state. The player's skater goes
|
||||
// through `applyIntent` instead, which clamps and normalises — the same
|
||||
// path a network message would take, so the sim never has to trust input.
|
||||
for (let i = 0; i < count; i++) {
|
||||
// A downed skater makes no decisions. Their state is frozen where they
|
||||
// fell; the ragdoll is doing the moving.
|
||||
//
|
||||
// Someone still getting up makes none either. Letting intent through
|
||||
// mid-rise means they skate away while the pose is still interpolating
|
||||
// out of a body on the ice, which reads as the corpse sliding off — the
|
||||
// whole point of the get-up is that almost nothing moves but the pose.
|
||||
if (skaters[i].limp || skaters[i].rising > 0) {
|
||||
states[i].ix = 0;
|
||||
states[i].iz = 0;
|
||||
states[i].sprint = false;
|
||||
states[i].brake = true;
|
||||
continue;
|
||||
}
|
||||
const control = controls.get(i);
|
||||
if (control) {
|
||||
// The Skill Stick moves the puck, and only for whoever is carrying it.
|
||||
if (possession.carrier === i && control.skill) {
|
||||
possession.handling.x = control.skill.x;
|
||||
possession.handling.y = control.skill.y;
|
||||
}
|
||||
handleShooting(i, control);
|
||||
stickToWorld(control, control.cameraYaw ?? 0, _worldIntent);
|
||||
applyIntent(states[i], {
|
||||
ix: _worldIntent.ix,
|
||||
iz: _worldIntent.iz,
|
||||
sprint: control.sprint,
|
||||
brake: control.brake,
|
||||
});
|
||||
// Keep the brain's waypoint fresh so handing control back does not
|
||||
// send them skating off to somewhere chosen a minute ago.
|
||||
brains[i].target = null;
|
||||
if (control.pressed?.poke) {
|
||||
// The reach always animates, whether or not it connects — a poke
|
||||
// that only shows when it works gives the player no feedback on the
|
||||
// ones that miss, which is most of them.
|
||||
skaters[i].animator.playAction('poke');
|
||||
possession.poke(i);
|
||||
}
|
||||
} else {
|
||||
steer(brains[i], states[i], states, dt, play);
|
||||
if (possession.carrier === i) botShoot(i, dt);
|
||||
// Bots reach in when they get close enough, on a cooldown so they are
|
||||
// not spamming it every frame they are in range.
|
||||
if (possession.carrier !== null
|
||||
&& states[possession.carrier].team !== states[i].team) {
|
||||
brains[i].pokeCool = (brains[i].pokeCool ?? 0) - dt;
|
||||
if (brains[i].pokeCool <= 0) {
|
||||
skaters[i].animator.playAction('poke');
|
||||
if (possession.poke(i)) brains[i].pokeCool = 0.9;
|
||||
else brains[i].pokeCool = 0.45;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---- 2. sim + physics, on the fixed step ------------------------------
|
||||
physics.step(dt, (fixedDt) => {
|
||||
for (let i = 0; i < count; i++) {
|
||||
// While down, the ragdoll is the body and the proxy is switched off.
|
||||
// Stepping the sim would drive a disabled capsule around the rink and
|
||||
// then teleport the skater to it on the way up.
|
||||
if (skaters[i].limp) continue;
|
||||
const s = states[i];
|
||||
const proxy = skaters[i].proxy;
|
||||
if (proxy) proxy.read(s);
|
||||
// Box3D owns board contact via the proxy, so the sim's own clamp
|
||||
// would fight it — but keep it on when there is no proxy at all.
|
||||
stepSkater(s, fixedDt, { clampBoards: !proxy });
|
||||
if (proxy) proxy.write(s);
|
||||
}
|
||||
// The ragdolls chase wherever the animation left the skeleton. This has
|
||||
// to happen *before* the solve, not after: SetTargetTransform derives the
|
||||
// velocity that carries a kinematic body to its target over the coming
|
||||
// step, so setting it afterwards would apply it a step late.
|
||||
for (const sk of skaters) {
|
||||
if (sk.ragdoll && !sk.limp && sk.ragdoll.mode === 'driven') {
|
||||
sk.ragdoll.syncFromSkeleton(fixedDt);
|
||||
}
|
||||
// The blade collider follows the stick the same way, and for the same
|
||||
// reason: SetTargetTransform derives the velocity that carries it over
|
||||
// the coming step, so it has to be set before the solve or a blade
|
||||
// sweeping through a loose puck arrives a step late and misses.
|
||||
sk.stick.syncPhysics(physics.api, fixedDt);
|
||||
}
|
||||
for (const fn of substepSyncs) fn(fixedDt);
|
||||
});
|
||||
|
||||
// A collision can hand the puck more speed than any shot ever should —
|
||||
// `setVelocity` caps what *we* apply, but the solver is not bound by it.
|
||||
// Cheap insurance against one bad contact putting the puck in orbit.
|
||||
if (puck.speed() > PUCK.maxSpeed) {
|
||||
const v = puck.velocity();
|
||||
const k = PUCK.maxSpeed / puck.speed();
|
||||
puck.setVelocity(v.x * k, v.y * k, v.z * k);
|
||||
}
|
||||
|
||||
// ---- 3. hits, knockdowns and getting up --------------------------------
|
||||
hits.tick(dt);
|
||||
for (let i = 0; i < count; i++) {
|
||||
if (skaters[i].tickDown(dt)) skaters[i].getUp(states[i]);
|
||||
}
|
||||
|
||||
// ---- 3b. possession ----------------------------------------------------
|
||||
// Once per frame, not per substep: capture and release are gameplay
|
||||
// decisions, and running them at 120 Hz only makes the cooldowns fiddly.
|
||||
// The carrier's stick decays back to neutral so a released Skill Stick
|
||||
// brings the puck back in front rather than leaving it stranded wide.
|
||||
if (possession.carrier === null || !controls.has(possession.carrier)) {
|
||||
possession.handling.x *= Math.max(0, 1 - 6 * dt);
|
||||
possession.handling.y *= Math.max(0, 1 - 6 * dt);
|
||||
}
|
||||
possession.update(dt);
|
||||
|
||||
// ---- 4. animation ------------------------------------------------------
|
||||
for (let i = 0; i < count; i++) {
|
||||
const s = states[i];
|
||||
// Turn rate of the velocity vector, not of the body. Only meaningful
|
||||
// while actually moving; a standing skater has no heading to turn.
|
||||
const speed = Math.hypot(s.vx, s.vz);
|
||||
let yawRate = 0;
|
||||
if (speed > 0.4) {
|
||||
const velYaw = Math.atan2(s.vx, s.vz);
|
||||
yawRate = wrapAngle(velYaw - prevVelYaw[i]) / Math.max(1e-4, dt);
|
||||
prevVelYaw[i] = velYaw;
|
||||
}
|
||||
// Stickwork inputs. The animator owns where the stick *is*; this only
|
||||
// tells it what the skater is trying to do with it.
|
||||
const anim = skaters[i].animator;
|
||||
anim.hasPuck = possession.carrier === i;
|
||||
const ctrl = controls.get(i);
|
||||
anim.charge = anim.hasPuck ? (ctrl?.charge ?? 0) : 0;
|
||||
if (anim.hasPuck) {
|
||||
anim.handling.x = possession.handling.x;
|
||||
anim.handling.y = possession.handling.y;
|
||||
} else {
|
||||
anim.handling.x *= Math.max(0, 1 - 8 * dt);
|
||||
anim.handling.y *= Math.max(0, 1 - 8 * dt);
|
||||
}
|
||||
// Holding the Skill Stick back is a wind-up; letting it go ends one.
|
||||
if (anim.hasPuck && anim.charge > 0.05 && anim.action === null) {
|
||||
anim.action = 'windup';
|
||||
anim.actionTime = 0;
|
||||
} else if (anim.action === 'windup' && (!anim.hasPuck || anim.charge <= 0.05)) {
|
||||
anim.action = null;
|
||||
}
|
||||
|
||||
skaters[i].applyState(s, yawRate);
|
||||
skaters[i].update(dt);
|
||||
skaters[i].syncFromPhysics();
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
states,
|
||||
brains,
|
||||
skaters,
|
||||
perTeam,
|
||||
teams,
|
||||
update,
|
||||
hits,
|
||||
recentHits,
|
||||
puck,
|
||||
/** Register a callback to run inside every physics substep. */
|
||||
addSubstepSync(fn) {
|
||||
substepSyncs.add(fn);
|
||||
return () => substepSyncs.delete(fn);
|
||||
},
|
||||
possession,
|
||||
recentPlays,
|
||||
|
||||
controls,
|
||||
/** The first externally driven skater — what the HUD and camera care about. */
|
||||
get playerIndex() {
|
||||
for (const i of controls.keys()) return i;
|
||||
return null;
|
||||
},
|
||||
|
||||
/**
|
||||
* Drive a skater from something other than its brain. Pass `null` to hand
|
||||
* it back. `control` is read every frame, so a live input object works.
|
||||
*/
|
||||
setControl(index, control) {
|
||||
if (index == null || index < 0 || index >= count) return null;
|
||||
if (!control) {
|
||||
controls.delete(index);
|
||||
return null;
|
||||
}
|
||||
controls.set(index, control);
|
||||
// Drop any intent the brain had queued so control starts from neutral
|
||||
// rather than from whatever the bot was mid-way through doing.
|
||||
states[index].ix = 0;
|
||||
states[index].iz = 0;
|
||||
states[index].sprint = false;
|
||||
states[index].brake = false;
|
||||
return index;
|
||||
},
|
||||
|
||||
/** Skater states belonging to one team. */
|
||||
team(index) {
|
||||
return states.filter((s) => s.team === index);
|
||||
},
|
||||
|
||||
/** Drop everyone back on their spawn, momentum cleared. */
|
||||
reset() {
|
||||
for (let i = 0; i < count; i++) {
|
||||
const spawn = spawns[i];
|
||||
// Anyone lying on the ice has to be stood up before being placed, or
|
||||
// their proxy stays disabled and they spawn as a corpse.
|
||||
if (skaters[i].limp) skaters[i].getUp(states[i]);
|
||||
Object.assign(states[i], { x: spawn.x, z: spawn.z, vx: 0, vz: 0, yaw: spawn.yaw });
|
||||
skaters[i].proxy?.teleport(spawn.x, spawn.z);
|
||||
brains[i].target = null;
|
||||
}
|
||||
recentHits.length = 0;
|
||||
recentPlays.length = 0;
|
||||
// Faceoff: puck at centre ice, dead.
|
||||
possession.reset();
|
||||
puck.place(0, 0.05, 0);
|
||||
},
|
||||
|
||||
destroy() {
|
||||
hits.destroy();
|
||||
puck.destroy();
|
||||
for (const sk of skaters) sk.dispose();
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,313 @@
|
||||
import * as THREE from 'three';
|
||||
import { PUCK } from '../physics/puck.js';
|
||||
import { clamp, lerp } from '../../shared/scalar.js';
|
||||
|
||||
/**
|
||||
* Who has the puck, and what "having it" means.
|
||||
*
|
||||
* This is the one genuinely undecided piece of the game, so it is built as a
|
||||
* dial rather than as an answer. `magnetism` runs 0..1 between the two models:
|
||||
*
|
||||
* 0 Pure physics. The puck is always a free rigid body and the only thing
|
||||
* that moves it is the blade collider pushing it. Authentic, and skittery
|
||||
* to the point of being unplayable — you lose it to contacts you never
|
||||
* intended and can never quite line up a shot.
|
||||
*
|
||||
* 1 Hard attach. The puck is placed at the carry point every frame. Totally
|
||||
* controllable, looks glued, and kills the scrambles that are the reason
|
||||
* to build a physics-driven hockey game at all.
|
||||
*
|
||||
* In between, the puck's velocity is blended toward whatever would carry it to
|
||||
* the stick, so it *mostly* follows but can be jostled off the blade by a hit,
|
||||
* a poke or a body in the way. Where that dial should sit is a feel question,
|
||||
* so it is tunable at runtime (`[` and `]` in the browser) rather than baked.
|
||||
*
|
||||
* Everything else here follows from that: capture is a proximity test, release
|
||||
* is either deliberate (shot, pass) or forced (hit, poke, the puck getting too
|
||||
* far from the blade).
|
||||
*/
|
||||
|
||||
export const CARRY = {
|
||||
/** Default dial position. Tuned by hand; see the note above. */
|
||||
magnetism: 0.72,
|
||||
/** A loose puck this close to the blade gets picked up. */
|
||||
captureRadius: 0.55,
|
||||
/**
|
||||
* Possession breaks if the puck gets this far from the blade.
|
||||
*
|
||||
* Has to be generous relative to how far the blade sits in front of the body
|
||||
* (~1.35 m). At 1.15 m a shooter accelerating from a standstill outran their
|
||||
* own puck every time — twelve of nineteen shootout attempts ended with the
|
||||
* puck sitting on the ice at centre and nobody ever taking a shot.
|
||||
*/
|
||||
breakRadius: 2.0,
|
||||
/** How hard the puck is pulled onto the carry point, 1/s. */
|
||||
stiffness: 20,
|
||||
/** Seconds after losing it before the same skater can re-capture. */
|
||||
reclaimDelay: 0.35,
|
||||
/** Seconds after a shot or pass before anyone can capture. */
|
||||
looseDelay: 0.18,
|
||||
/** How far the Skill Stick can push the puck fore/aft and side to side. */
|
||||
reachFwd: 0.34,
|
||||
reachSide: 0.42,
|
||||
/** Shot speed at full power, m/s. ~45 is a real slapshot. */
|
||||
shotSpeed: 45,
|
||||
/** Passes are firm but not shots. */
|
||||
passSpeed: 18,
|
||||
/** A shot lifts slightly; a pass stays flat. */
|
||||
shotLift: 0.1,
|
||||
/** How far a poke check reaches, blade to puck. */
|
||||
pokeRadius: 1.25,
|
||||
/** How hard a poke or a check knocks the puck away, m/s. */
|
||||
pokeSpeed: 5.5,
|
||||
/** How far the puck is stepped clear of the blade on release, metres. */
|
||||
releaseGap: 0.4,
|
||||
};
|
||||
|
||||
const _carryWorld = new THREE.Vector3();
|
||||
const _toTarget = new THREE.Vector3();
|
||||
const _desired = new THREE.Vector3();
|
||||
const _puckPos = new THREE.Vector3();
|
||||
const _puckVel = new THREE.Vector3();
|
||||
const _dir = new THREE.Vector3();
|
||||
|
||||
/**
|
||||
* @param {object} opts
|
||||
* @param {object} opts.puck from createPuck
|
||||
* @param {object[]} opts.skaters
|
||||
* @param {object[]} opts.states
|
||||
*/
|
||||
export function createPossession({ puck, skaters, states, onEvent = null }) {
|
||||
/** Index of the carrier, or null. */
|
||||
let carrier = null;
|
||||
/** Per-skater cooldown before they may capture again. */
|
||||
const cooldown = new Array(skaters.length).fill(0);
|
||||
/** Global cooldown after a deliberate release. */
|
||||
let looseFor = 0;
|
||||
const tuning = { ...CARRY };
|
||||
|
||||
/** Skill Stick offset applied to the carry point, -1..1 each. */
|
||||
const handling = { x: 0, y: 0 };
|
||||
|
||||
/**
|
||||
* Where the puck should sit for skater `i`, in world space.
|
||||
*
|
||||
* Read off the actual blade rather than computed from a fixed offset. That
|
||||
* inversion is the point of socketing the stick to the hand: the arms decide
|
||||
* where the blade is, and the puck goes where the blade is. Stickhandling is
|
||||
* then an arm pose rather than a number added to a carry point, and the puck
|
||||
* cannot end up somewhere the stick is not.
|
||||
*/
|
||||
function bladePoint(i, out) {
|
||||
const sk = skaters[i];
|
||||
if (!sk?.stick) return out.set(0, 0, 0);
|
||||
sk.stick.bladeWorld(out);
|
||||
// The puck rides on the ice at the blade's XZ, not at the blade's centre —
|
||||
// the blade has height and a lie angle, and a puck floating at its middle
|
||||
// reads as hovering.
|
||||
out.y = PUCK.thickness / 2;
|
||||
return out;
|
||||
}
|
||||
|
||||
function emit(type, payload) {
|
||||
if (onEvent) onEvent({ type, ...payload });
|
||||
}
|
||||
|
||||
/** Hand the puck to nobody, optionally locking capture for a moment. */
|
||||
function release(reason, delay = tuning.reclaimDelay) {
|
||||
if (carrier === null) return;
|
||||
const was = carrier;
|
||||
cooldown[was] = delay;
|
||||
carrier = null;
|
||||
looseFor = Math.max(looseFor, tuning.looseDelay);
|
||||
emit('lost', { skater: was, reason });
|
||||
}
|
||||
|
||||
function capture(index) {
|
||||
if (carrier === index) return;
|
||||
if (carrier !== null) {
|
||||
const was = carrier;
|
||||
cooldown[was] = tuning.reclaimDelay;
|
||||
emit('stolen', { skater: index, from: was });
|
||||
} else {
|
||||
emit('gained', { skater: index });
|
||||
}
|
||||
carrier = index;
|
||||
cooldown[index] = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Poke check: reach in and knock the puck off whoever has it.
|
||||
*
|
||||
* Range is measured blade-to-puck, so it depends on where the poker's stick
|
||||
* actually is. Without this — and without contact dislodging the puck — a
|
||||
* carrier is untouchable, and a minute of play is one skater holding the puck
|
||||
* for the entire minute while five others follow them around.
|
||||
*/
|
||||
function poke(byIndex) {
|
||||
if (carrier === null || carrier === byIndex) return false;
|
||||
if (skaters[byIndex]?.limp) return false;
|
||||
bladePoint(byIndex, _carryWorld);
|
||||
_puckPos.copy(puck.position());
|
||||
if (_puckPos.distanceTo(_carryWorld) > tuning.pokeRadius) return false;
|
||||
|
||||
// Knock it away from the carrier, roughly along the poke.
|
||||
_dir.subVectors(_puckPos, _carryWorld).setY(0);
|
||||
if (_dir.lengthSq() < 1e-6) _dir.set(1, 0, 0);
|
||||
_dir.normalize().multiplyScalar(tuning.pokeSpeed);
|
||||
puck.setVelocity(_dir.x, 0, _dir.z);
|
||||
release('poked', tuning.reclaimDelay);
|
||||
emit('poke', { skater: byIndex, from: carrier });
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Contact dislodges the puck. Called when a check lands on the carrier —
|
||||
* a stagger is enough, it does not need a knockdown.
|
||||
*/
|
||||
function jar(severity = 1) {
|
||||
if (carrier === null) return false;
|
||||
_puckPos.copy(puck.position());
|
||||
_dir.set(Math.random() - 0.5, 0, Math.random() - 0.5);
|
||||
if (_dir.lengthSq() < 1e-6) _dir.set(1, 0, 0);
|
||||
_dir.normalize().multiplyScalar(tuning.pokeSpeed * clamp(severity, 0.4, 1.6));
|
||||
puck.setVelocity(_dir.x, 0, _dir.z);
|
||||
release('jarred loose', tuning.reclaimDelay);
|
||||
return true;
|
||||
}
|
||||
|
||||
/** Fire the puck. `power` 0..1, `aimYaw` world radians. */
|
||||
function shoot(power, aimYaw, { pass = false } = {}) {
|
||||
if (carrier === null) return null;
|
||||
const from = carrier;
|
||||
const speed = (pass ? tuning.passSpeed : tuning.shotSpeed) * clamp(power, 0.15, 1);
|
||||
_dir.set(Math.sin(aimYaw), 0, Math.cos(aimYaw));
|
||||
const state = states[from];
|
||||
|
||||
// Step the puck off the blade before releasing it.
|
||||
//
|
||||
// It is sitting *exactly* on the blade — that is what carrying it means —
|
||||
// and the follow-through animation immediately sweeps that kinematic
|
||||
// collider through the same point at speed. Shots were being smashed
|
||||
// sideways by the shooter's own stick: measured, they stopped six metres
|
||||
// short of the net or flew twelve metres wide, and nothing ever scored.
|
||||
_puckPos.copy(puck.position());
|
||||
puck.place(
|
||||
_puckPos.x + _dir.x * tuning.releaseGap,
|
||||
PUCK.thickness / 2,
|
||||
_puckPos.z + _dir.z * tuning.releaseGap,
|
||||
{ keepMotion: true },
|
||||
);
|
||||
// A shot inherits the shooter's momentum. Skating into it is worth speed,
|
||||
// which is the whole reason a one-timer off the rush is dangerous.
|
||||
puck.setVelocity(
|
||||
_dir.x * speed + state.vx * 0.4,
|
||||
pass ? 0 : speed * tuning.shotLift,
|
||||
_dir.z * speed + state.vz * 0.4,
|
||||
);
|
||||
release(pass ? 'pass' : 'shot', tuning.reclaimDelay);
|
||||
emit(pass ? 'pass' : 'shot', { skater: from, power, speed, aimYaw });
|
||||
return { from, speed, power };
|
||||
}
|
||||
|
||||
return {
|
||||
tuning,
|
||||
handling,
|
||||
get carrier() { return carrier; },
|
||||
get loose() { return carrier === null; },
|
||||
shoot,
|
||||
poke,
|
||||
jar,
|
||||
release,
|
||||
capture,
|
||||
bladePoint,
|
||||
|
||||
/** Where the puck is being carried, in world space. Null if loose. */
|
||||
carryPoint(out) {
|
||||
if (carrier === null) return null;
|
||||
return bladePoint(carrier, out);
|
||||
},
|
||||
|
||||
/**
|
||||
* Advance possession by `dt`.
|
||||
*
|
||||
* Called once per rendered frame rather than per physics substep: capture
|
||||
* and release are gameplay decisions, and running them at 120 Hz just makes
|
||||
* the cooldowns six times as fiddly for no gain in fidelity.
|
||||
*/
|
||||
update(dt) {
|
||||
for (let i = 0; i < cooldown.length; i++) cooldown[i] = Math.max(0, cooldown[i] - dt);
|
||||
looseFor = Math.max(0, looseFor - dt);
|
||||
|
||||
puck.position(); // refresh the cached vector
|
||||
_puckPos.copy(puck.position());
|
||||
_puckVel.copy(puck.velocity());
|
||||
|
||||
// ---- forced release ---------------------------------------------------
|
||||
if (carrier !== null) {
|
||||
const holder = skaters[carrier];
|
||||
if (holder.limp) {
|
||||
release('knocked down', 0.8);
|
||||
} else {
|
||||
this.carryPoint(_carryWorld);
|
||||
const gap = _puckPos.distanceTo(_carryWorld);
|
||||
if (gap > tuning.breakRadius) release('lost the handle');
|
||||
}
|
||||
}
|
||||
|
||||
// ---- capture ----------------------------------------------------------
|
||||
if (carrier === null && looseFor <= 0) {
|
||||
let best = null;
|
||||
let bestGap = tuning.captureRadius;
|
||||
for (let i = 0; i < skaters.length; i++) {
|
||||
if (skaters[i].limp || cooldown[i] > 0) continue;
|
||||
bladePoint(i, _carryWorld);
|
||||
const gap = _puckPos.distanceTo(_carryWorld);
|
||||
if (gap < bestGap) {
|
||||
bestGap = gap;
|
||||
best = i;
|
||||
}
|
||||
}
|
||||
if (best !== null) capture(best);
|
||||
}
|
||||
|
||||
// ---- carry ------------------------------------------------------------
|
||||
if (carrier === null) return;
|
||||
this.carryPoint(_carryWorld);
|
||||
_toTarget.subVectors(_carryWorld, _puckPos);
|
||||
|
||||
const state = states[carrier];
|
||||
// The velocity that would put the puck on the carry point, given that the
|
||||
// carry point is itself moving with the skater.
|
||||
_desired.set(
|
||||
state.vx + _toTarget.x * tuning.stiffness,
|
||||
_toTarget.y * tuning.stiffness,
|
||||
state.vz + _toTarget.z * tuning.stiffness,
|
||||
);
|
||||
|
||||
const m = clamp(tuning.magnetism, 0, 1);
|
||||
puck.setVelocity(
|
||||
lerp(_puckVel.x, _desired.x, m),
|
||||
lerp(_puckVel.y, _desired.y, m),
|
||||
lerp(_puckVel.z, _desired.z, m),
|
||||
);
|
||||
|
||||
// There was a second "fumble" test here, a function of stiffness and
|
||||
// magnetism, meant to catch a puck the magnetism was papering over. It
|
||||
// was redundant with `breakRadius` and, after stiffness went up, fired
|
||||
// *tighter* than it — at 1.16 m against a 1.7 m break — so it silently
|
||||
// stripped the puck off every shooter accelerating out of centre ice.
|
||||
// Twenty of twenty-four shootout attempts ended with nobody shooting.
|
||||
// One distance test is enough, and it is the one above.
|
||||
},
|
||||
|
||||
/** Clear everything — faceoffs and resets. */
|
||||
reset() {
|
||||
carrier = null;
|
||||
looseFor = 0;
|
||||
cooldown.fill(0);
|
||||
handling.x = 0;
|
||||
handling.y = 0;
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,237 @@
|
||||
import * as THREE from 'three';
|
||||
import { createGoalie } from '../character/goalie.js';
|
||||
import { buildNetMesh, createNet } from '../physics/net.js';
|
||||
import { NET, attemptLive, goalLineX, isGoal, shootoutStart } from '../../shared/net.js';
|
||||
import { RINK } from '../../shared/rink.js';
|
||||
import { PUCK } from '../physics/puck.js';
|
||||
|
||||
/**
|
||||
* A shootout.
|
||||
*
|
||||
* The smallest thing that is actually hockey: one shooter, one goalie, one
|
||||
* puck, and a result. No lines, no rules, no positional play — all of which
|
||||
* makes it the right MVP, because everything it does need is the part that has
|
||||
* to feel good anyway.
|
||||
*
|
||||
* Flow is a small state machine over one attempt:
|
||||
*
|
||||
* ready → the puck is on the dot, the shooter waits a few metres back
|
||||
* live → they skate onto the puck and in on the goalie. Losing the handle
|
||||
* is not the end of it — go and get it back.
|
||||
* result → goal or save, held long enough to read
|
||||
* ...then the other team shoots.
|
||||
*
|
||||
* Attempts alternate, so "1-on-1" is two players trading chances rather than a
|
||||
* single endless drill.
|
||||
*/
|
||||
|
||||
export const SHOOTOUT = {
|
||||
/** Seconds on the clock for one attempt before it is called a miss. */
|
||||
attemptTime: 15,
|
||||
/** How long a goal or save is held on screen before the next shooter. */
|
||||
resultTime: 2.2,
|
||||
/** Countdown before the shooter is released. */
|
||||
readyTime: 1.1,
|
||||
/**
|
||||
* How far behind the puck the shooter starts, metres.
|
||||
*
|
||||
* They skate onto it rather than spawning holding it — picking the puck up is
|
||||
* part of the attempt, and starting glued to it skipped the only moment where
|
||||
* the carry model has to prove it can *gain* possession rather than keep it.
|
||||
*/
|
||||
startBack: 4.5,
|
||||
/** Rounds each side gets before it goes to sudden death. */
|
||||
rounds: 5,
|
||||
};
|
||||
|
||||
export function createShootout({ scene, physics, match }) {
|
||||
const { puck, possession, states, skaters } = match;
|
||||
|
||||
// Nets and goalies at both ends, because the sides alternate.
|
||||
const nets = [createNet(physics, 1), createNet(physics, -1)];
|
||||
const netMeshes = [buildNetMesh(scene, 1), buildNetMesh(scene, -1)];
|
||||
const goalies = {
|
||||
1: createGoalie(physics, scene, { end: 1, index: 40, team: 1 }),
|
||||
'-1': createGoalie(physics, scene, { end: -1, index: 41, team: 0 }),
|
||||
};
|
||||
|
||||
const state = {
|
||||
phase: 'ready',
|
||||
/** Which team is shooting: 0 shoots at the +X end, 1 at −X. */
|
||||
shootingTeam: 0,
|
||||
/** Index of the shooter, and which end they are attacking. */
|
||||
shooter: 0,
|
||||
end: 1,
|
||||
round: 1,
|
||||
score: [0, 0],
|
||||
attempts: [0, 0],
|
||||
/** Last result, for the HUD. */
|
||||
last: null,
|
||||
clock: 0,
|
||||
};
|
||||
|
||||
const _puckPos = new THREE.Vector3();
|
||||
|
||||
/** Everyone who is not shooting gets parked out of the way. */
|
||||
function parkBystanders() {
|
||||
let n = 0;
|
||||
for (let i = 0; i < states.length; i++) {
|
||||
if (i === state.shooter) continue;
|
||||
const s = states[i];
|
||||
const side = n % 2 === 0 ? 1 : -1;
|
||||
s.x = -state.end * (RINK.halfX * 0.55);
|
||||
s.z = side * (RINK.halfZ * 0.78) + Math.floor(n / 2) * side * 1.4;
|
||||
s.vx = 0;
|
||||
s.vz = 0;
|
||||
s.yaw = state.end > 0 ? Math.PI / 2 : -Math.PI / 2;
|
||||
if (skaters[i].limp) skaters[i].getUp(s);
|
||||
skaters[i].proxy?.teleport(s.x, s.z);
|
||||
match.setControl(i, { x: 0, y: 0, sprint: false, brake: false, cameraYaw: 0 });
|
||||
n++;
|
||||
}
|
||||
}
|
||||
|
||||
/** Set up the next attempt. */
|
||||
function nextAttempt() {
|
||||
// Alternate ends so each team shoots at the other's goalie.
|
||||
state.shootingTeam = state.attempts[0] <= state.attempts[1] ? 0 : 1;
|
||||
state.end = state.shootingTeam === 0 ? 1 : -1;
|
||||
// The shooter is the first upright skater on that team.
|
||||
const perTeam = match.perTeam;
|
||||
state.shooter = state.shootingTeam * perTeam + (state.round - 1) % perTeam;
|
||||
|
||||
const start = shootoutStart(state.end);
|
||||
const s = states[state.shooter];
|
||||
if (skaters[state.shooter].limp) skaters[state.shooter].getUp(s);
|
||||
// Behind the puck, facing the net they are attacking.
|
||||
s.x = start.x - state.end * SHOOTOUT.startBack;
|
||||
s.z = start.z;
|
||||
s.yaw = start.yaw;
|
||||
s.vx = 0;
|
||||
s.vz = 0;
|
||||
skaters[state.shooter].proxy?.teleport(s.x, s.z);
|
||||
match.setControl(state.shooter, null);
|
||||
|
||||
parkBystanders();
|
||||
|
||||
possession.reset();
|
||||
// Puck on the dot at centre ice. Nobody starts holding it.
|
||||
puck.place(start.x, PUCK.thickness / 2, start.z);
|
||||
|
||||
goalies[1].reset();
|
||||
goalies[-1].reset();
|
||||
|
||||
state.phase = 'ready';
|
||||
state.clock = SHOOTOUT.readyTime;
|
||||
}
|
||||
|
||||
function finish(result, detail = '') {
|
||||
state.phase = 'result';
|
||||
state.clock = SHOOTOUT.resultTime;
|
||||
state.attempts[state.shootingTeam]++;
|
||||
if (result === 'goal') state.score[state.shootingTeam]++;
|
||||
state.last = {
|
||||
result,
|
||||
detail,
|
||||
team: state.shootingTeam,
|
||||
shooter: state.shooter,
|
||||
round: state.round,
|
||||
score: [...state.score],
|
||||
};
|
||||
// A round is complete once both sides have had the same number of goes.
|
||||
if (state.attempts[0] === state.attempts[1]) state.round++;
|
||||
}
|
||||
|
||||
/** The goalie defending the end currently being shot at. */
|
||||
const activeGoalie = () => goalies[state.end];
|
||||
|
||||
function update(dt) {
|
||||
_puckPos.copy(puck.position());
|
||||
|
||||
// Both goalies track, so the idle one still looks alive; only the active
|
||||
// one can be scored on.
|
||||
goalies[1].update(dt, _puckPos);
|
||||
goalies[-1].update(dt, _puckPos);
|
||||
|
||||
state.clock -= dt;
|
||||
|
||||
if (state.phase === 'ready') {
|
||||
// Hold the shooter still while the countdown runs. The puck sits on the
|
||||
// dot untouched; picking it up is the first thing they do when released.
|
||||
const s = states[state.shooter];
|
||||
s.ix = 0;
|
||||
s.iz = 0;
|
||||
s.sprint = false;
|
||||
if (state.clock <= 0) {
|
||||
state.phase = 'live';
|
||||
state.clock = SHOOTOUT.attemptTime;
|
||||
// Hand control back to whoever is driving, or let the brain take it.
|
||||
if (pendingControl) match.setControl(state.shooter, pendingControl);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (state.phase === 'result') {
|
||||
if (state.clock <= 0) nextAttempt();
|
||||
return;
|
||||
}
|
||||
|
||||
// ---- live --------------------------------------------------------------
|
||||
if (isGoal(_puckPos, state.end, PUCK.radius)) {
|
||||
finish('goal');
|
||||
return;
|
||||
}
|
||||
|
||||
if (activeGoalie().covers(_puckPos) && puck.speed() < 3) {
|
||||
finish('save', 'covered');
|
||||
return;
|
||||
}
|
||||
|
||||
// Losing the handle does *not* end the attempt. In a one-on-one the puck
|
||||
// getting away from you is part of the attempt, not the end of it — go and
|
||||
// get it back. Only the clock, the goalie, or the puck leaving the picture
|
||||
// finishes an attempt.
|
||||
if (!attemptLive(_puckPos, state.end)) {
|
||||
finish('save', 'wide');
|
||||
return;
|
||||
}
|
||||
|
||||
if (state.clock <= 0) finish('save', 'time');
|
||||
}
|
||||
|
||||
/** Control object handed to whoever is shooting, or null for AI. */
|
||||
let pendingControl = null;
|
||||
|
||||
return {
|
||||
state,
|
||||
goalies,
|
||||
nets,
|
||||
netMeshes,
|
||||
update,
|
||||
nextAttempt,
|
||||
|
||||
/** Drive every shooter with this control object. Null hands them to the AI. */
|
||||
setShooterControl(control) {
|
||||
pendingControl = control;
|
||||
if (state.phase === 'live') match.setControl(state.shooter, control);
|
||||
},
|
||||
|
||||
/** Restart the whole shootout. */
|
||||
reset() {
|
||||
state.score = [0, 0];
|
||||
state.attempts = [0, 0];
|
||||
state.round = 1;
|
||||
state.last = null;
|
||||
nextAttempt();
|
||||
},
|
||||
|
||||
destroy() {
|
||||
for (const n of nets) n.destroy();
|
||||
for (const m of netMeshes) scene.remove(m);
|
||||
goalies[1].destroy();
|
||||
goalies[-1].destroy();
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
export { NET, goalLineX };
|
||||
+275
@@ -0,0 +1,275 @@
|
||||
import * as THREE from 'three';
|
||||
import { createPhysicsWorld, initPhysics } from './physics/world.js';
|
||||
import { buildPuckMesh, buildRink } from './render/rink.js';
|
||||
import { PUCK } from './physics/puck.js';
|
||||
import { createCamera } from './render/camera.js';
|
||||
import { createMatch } from './game/match.js';
|
||||
import { createInput } from './game/input.js';
|
||||
import { describeHit } from './game/hits.js';
|
||||
import { createShootout } from './game/shootout.js';
|
||||
import { RINK } from '../shared/rink.js';
|
||||
|
||||
/**
|
||||
* Spike 1 boot: three AI skaters on a rink.
|
||||
*
|
||||
* Everything gameplay-shaped lives in `game/match.js`; this file is the shell —
|
||||
* renderer, lights, resize, the frame loop and a small debug HUD.
|
||||
*/
|
||||
|
||||
const canvas = document.getElementById('stage');
|
||||
const boot = document.getElementById('boot');
|
||||
const hud = document.getElementById('hud');
|
||||
|
||||
const renderer = new THREE.WebGLRenderer({ canvas, antialias: true, powerPreference: 'high-performance' });
|
||||
renderer.shadowMap.enabled = true;
|
||||
// PCFSoft is deprecated as of three r185 and silently falls back to PCF anyway.
|
||||
renderer.shadowMap.type = THREE.PCFShadowMap;
|
||||
renderer.toneMapping = THREE.ACESFilmicToneMapping;
|
||||
renderer.toneMappingExposure = 1.05;
|
||||
|
||||
const scene = new THREE.Scene();
|
||||
scene.background = new THREE.Color(0x0a0e14);
|
||||
scene.fog = new THREE.Fog(0x0a0e14, 70, 150);
|
||||
|
||||
// Arena lighting: a broad soft fill so the ice reads as lit from a roof rather
|
||||
// than from a single sun, plus one shadow-casting key over centre ice.
|
||||
scene.add(new THREE.HemisphereLight(0xdce8f5, 0x20242c, 1.5));
|
||||
const key = new THREE.DirectionalLight(0xffffff, 1.6);
|
||||
key.position.set(14, 30, 10);
|
||||
key.castShadow = true;
|
||||
key.shadow.mapSize.set(2048, 2048);
|
||||
key.shadow.camera.near = 5;
|
||||
key.shadow.camera.far = 110;
|
||||
// The ortho box has to contain the whole rink as seen from the light, or the
|
||||
// depth texture clamps at its border and everything outside renders fully
|
||||
// shadowed — a hard black wedge across the far ice, not a subtle artefact.
|
||||
// Half the rink diagonal is the worst case, whatever angle the light is at.
|
||||
const shadowSpan = Math.hypot(RINK.halfX, RINK.halfZ) + 6;
|
||||
key.shadow.camera.left = -shadowSpan;
|
||||
key.shadow.camera.right = shadowSpan;
|
||||
key.shadow.camera.top = shadowSpan;
|
||||
key.shadow.camera.bottom = -shadowSpan;
|
||||
key.shadow.bias = -0.0006;
|
||||
scene.add(key);
|
||||
const rim = new THREE.DirectionalLight(0x9fc4e8, 0.5);
|
||||
rim.position.set(-20, 14, -18);
|
||||
scene.add(rim);
|
||||
|
||||
const cam = createCamera(canvas, window.innerWidth / window.innerHeight);
|
||||
|
||||
/**
|
||||
* Match the drawing buffer and the CSS box to the window.
|
||||
*
|
||||
* `setSize(w, h)` must set the CSS size too — passing `false` for `updateStyle`
|
||||
* only works if the stylesheet already sizes the canvas, and an absolutely
|
||||
* positioned canvas with `width: auto` falls back to its *intrinsic* size
|
||||
* instead. At DPR 2 that made the element twice the window and showed the
|
||||
* top-left quarter of the render.
|
||||
*
|
||||
* The pixel ratio is re-applied here rather than once at startup so that
|
||||
* dragging the window between a retina and a non-retina display re-resolves it.
|
||||
*/
|
||||
function resize() {
|
||||
const w = window.innerWidth;
|
||||
const h = window.innerHeight;
|
||||
renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
|
||||
renderer.setSize(w, h);
|
||||
cam.resize(w, h);
|
||||
}
|
||||
window.addEventListener('resize', resize);
|
||||
resize();
|
||||
|
||||
const stats = { fps: 0, steps: 0, top: 0 };
|
||||
const clamp01 = (v) => (v < 0 ? 0 : v > 1 ? 1 : v);
|
||||
|
||||
async function boot3() {
|
||||
await initPhysics();
|
||||
const physics = createPhysicsWorld();
|
||||
buildRink(scene);
|
||||
const match = createMatch({ scene, physics, perTeam: 3, teams: 2 });
|
||||
const puckView = buildPuckMesh(scene, PUCK);
|
||||
|
||||
// The shootout owns the nets and the goalies, and drives its own kinematic
|
||||
// bodies inside the physics substep.
|
||||
const shootout = createShootout({ scene, physics, match });
|
||||
match.addSubstepSync((fixedDt) => {
|
||||
shootout.goalies[1].syncPhysics(fixedDt);
|
||||
shootout.goalies[-1].syncPhysics(fixedDt);
|
||||
});
|
||||
shootout.reset();
|
||||
|
||||
const input = createInput(window);
|
||||
// One live input object, refreshed each frame and read by the match.
|
||||
const stick = input.state;
|
||||
|
||||
// Rumble on contact the player is part of. Strength tracks the outcome, so
|
||||
// the pad tells you whether you laid someone out or just brushed them, and
|
||||
// taking one buzzes harder than giving one.
|
||||
const RUMBLE = {
|
||||
knockdown: [1.0, 0.7, 260],
|
||||
stagger: [0.55, 0.35, 150],
|
||||
bump: [0.22, 0.12, 70],
|
||||
};
|
||||
let lastHitSeen = -1;
|
||||
|
||||
/**
|
||||
* Take control of a skater, or give them back.
|
||||
*
|
||||
* Taking control snaps the camera onto whoever you just grabbed — driving a
|
||||
* skater you cannot see is the kind of thing that reads as a broken build.
|
||||
*/
|
||||
let playerShooting = false;
|
||||
/**
|
||||
* Take the shooter, or hand them back. In a shootout there is only one
|
||||
* skater worth driving, and which one it is changes every attempt — so
|
||||
* control follows the shooter rather than being pinned to an index.
|
||||
*/
|
||||
function toggleControl() {
|
||||
playerShooting = !playerShooting;
|
||||
shootout.setShooterControl(playerShooting ? stick : null);
|
||||
if (playerShooting) {
|
||||
cam.state.mode = 'follow';
|
||||
cam.state.followIndex = shootout.state.shooter;
|
||||
cam.state.distance = 9;
|
||||
cam.state.pitch = 0.3;
|
||||
}
|
||||
}
|
||||
|
||||
window.addEventListener('keydown', (e) => {
|
||||
if (e.key === 'c' || e.key === 'C') cam.cycleMode(match.skaters.length);
|
||||
if (e.key === 'r' || e.key === 'R') shootout.reset();
|
||||
if (e.key === 'p' || e.key === 'P' || e.code === 'Tab') {
|
||||
e.preventDefault();
|
||||
toggleControl();
|
||||
}
|
||||
// The possession dial, live. This is the undecided design question, so it
|
||||
// is adjustable while playing rather than a constant to recompile — the
|
||||
// answer is a feel judgement and has to be made with hands on the pad.
|
||||
const t = match.possession.tuning;
|
||||
if (e.key === '[') t.magnetism = Math.max(0, +(t.magnetism - 0.05).toFixed(2));
|
||||
if (e.key === ']') t.magnetism = Math.min(1, +(t.magnetism + 0.05).toFixed(2));
|
||||
});
|
||||
|
||||
// Debug handle. The capture tool drives the camera through this to frame
|
||||
// repeatable shots, and it is the fastest way to poke at a skater from the
|
||||
// console while tuning.
|
||||
window.tilt = { match, shootout, cam, physics, scene, renderer, stats, input, toggleControl };
|
||||
|
||||
boot.remove();
|
||||
|
||||
let last = performance.now();
|
||||
let fpsAccum = 0;
|
||||
let fpsFrames = 0;
|
||||
|
||||
function frame(now) {
|
||||
// Clamped so a background tab does not come back and teleport everyone
|
||||
// across the rink in one step.
|
||||
const dt = Math.min(0.05, (now - last) / 1000);
|
||||
last = now;
|
||||
|
||||
// The camera yaw rides along with the stick so the match can turn a
|
||||
// screen-space push into a world direction. Sampled before the update so
|
||||
// input and simulation are one frame consistent.
|
||||
input.read(dt);
|
||||
stick.cameraYaw = cam.state.yaw;
|
||||
match.update(dt);
|
||||
shootout.update(dt);
|
||||
|
||||
// Follow whoever is shooting, so the camera never has to be told.
|
||||
if (cam.state.mode === 'follow') cam.state.followIndex = shootout.state.shooter;
|
||||
|
||||
// Haptics for anything the player was part of.
|
||||
const newest = match.recentHits[0];
|
||||
if (newest && newest.at !== lastHitSeen) {
|
||||
lastHitSeen = newest.at;
|
||||
const me = match.playerIndex;
|
||||
if (me !== null && (newest.attacker === me || newest.victim === me)) {
|
||||
const [strong, weak, ms] = RUMBLE[newest.outcome] ?? RUMBLE.bump;
|
||||
// Taking a hit shakes harder than landing one.
|
||||
const k = newest.victim === me ? 1 : 0.7;
|
||||
input.rumble(strong * k, weak * k, ms);
|
||||
}
|
||||
}
|
||||
|
||||
puckView.mesh.position.copy(match.puck.position());
|
||||
puckView.mesh.quaternion.copy(match.puck.rotation());
|
||||
puckView.ring.visible = match.possession.loose;
|
||||
|
||||
cam.update(dt, match.states);
|
||||
renderer.render(scene, cam.camera);
|
||||
|
||||
fpsAccum += dt;
|
||||
fpsFrames++;
|
||||
if (fpsAccum >= 0.5) {
|
||||
stats.fps = Math.round(fpsFrames / fpsAccum);
|
||||
stats.steps = physics.stepCount;
|
||||
stats.top = match.states.reduce((m, s) => Math.max(m, Math.hypot(s.vx, s.vz)), 0);
|
||||
fpsAccum = 0;
|
||||
fpsFrames = 0;
|
||||
}
|
||||
// Drawn every frame, not on the half-second tick: the hustle and shot
|
||||
// meters are feedback, and feedback at 2 Hz is worse than none.
|
||||
drawHud();
|
||||
|
||||
requestAnimationFrame(frame);
|
||||
}
|
||||
|
||||
const bar = (v) => '▮'.repeat(Math.round(clamp01(v) * 8)).padEnd(8, '▯');
|
||||
|
||||
function drawHud() {
|
||||
const watching = cam.state.mode === 'follow'
|
||||
? match.states[cam.state.followIndex]?.name ?? 'broadcast'
|
||||
: 'broadcast';
|
||||
const player = match.playerIndex !== null ? match.states[match.playerIndex] : null;
|
||||
const down = match.skaters.filter((s) => s.limp).length;
|
||||
const feed = match.recentHits
|
||||
.filter((h) => h.outcome !== 'bump')
|
||||
.slice(0, 3)
|
||||
.map((h) => ` ${match.states[h.attacker].name} — ${describeHit(h)}`
|
||||
+ `${h.outcome === 'knockdown' ? ' DOWN' : ''}${h.headshot ? ' (head)' : ''}`)
|
||||
.join('\n');
|
||||
const pad = input.connected
|
||||
? `pad: ${(stick.padId ?? '').slice(0, 30) || 'connected'}`
|
||||
: 'pad: none — keyboard';
|
||||
|
||||
const so = shootout.state;
|
||||
const teamName = (t) => (t === 0 ? 'HOME' : 'AWAY');
|
||||
const scoreLine = `${teamName(0)} ${so.score[0]} — ${so.score[1]} ${teamName(1)}`
|
||||
+ ` round ${so.round}`;
|
||||
const phaseLine = so.phase === 'ready'
|
||||
? `${teamName(so.shootingTeam)} to shoot…`
|
||||
: so.phase === 'result'
|
||||
? (so.last?.result === 'goal'
|
||||
? `GOAL — ${teamName(so.last.team)}`
|
||||
: `SAVE${so.last?.detail ? ` (${so.last.detail})` : ''}`)
|
||||
: `${teamName(so.shootingTeam)} shooting · ${Math.max(0, so.clock).toFixed(1)}s`;
|
||||
|
||||
const carrier = match.possession.carrier;
|
||||
const puckLine = carrier === null
|
||||
? `puck: loose ${match.puck.speed().toFixed(1)} m/s`
|
||||
: `puck: ${match.states[carrier].name}${carrier === match.playerIndex ? ' ← YOU' : ''}`;
|
||||
const mag = match.possession.tuning.magnetism;
|
||||
|
||||
hud.textContent = `${scoreLine}`
|
||||
+ `\n${phaseLine}`
|
||||
+ `\n`
|
||||
+ `\n${stats.fps} fps · ${puckLine}`
|
||||
+ `\n${pad}`
|
||||
+ `\n[P] ${playerShooting ? 'let the AI shoot' : 'take the shooter'} [C] camera [R] restart`
|
||||
+ `\nmagnetism ${bar(mag)} ${mag.toFixed(2)} [ ] to tune`
|
||||
+ (player
|
||||
? (input.connected
|
||||
? '\nL-stick skate · RT hustle · LT stop · R-stick Skill Stick\nA pass · X shoot · B poke'
|
||||
: '\nWASD skate · Shift hustle · Space stop · arrows Skill Stick\nJ pass · K shoot · L poke')
|
||||
+ `\nhustle ${bar(stick.hustle)} wind-up ${bar(stick.charge)}`
|
||||
: '')
|
||||
+ (feed ? `\n\nhits:\n${feed}` : '');
|
||||
}
|
||||
|
||||
requestAnimationFrame(frame);
|
||||
}
|
||||
|
||||
boot3().catch((err) => {
|
||||
console.error(err);
|
||||
boot.textContent = 'FAILED TO START — ' + (err?.message ?? err);
|
||||
});
|
||||
@@ -0,0 +1,143 @@
|
||||
import { KIND, makeTag, proxyFilter, xyz } from './bridge.js';
|
||||
import { SKATE } from '../../shared/skaterSim.js';
|
||||
|
||||
/**
|
||||
* One dynamic capsule per skater — the body that Box3D actually solves.
|
||||
*
|
||||
* The 18-capsule ragdoll is kinematic while a skater is on their feet, and
|
||||
* kinematic bodies do not respond to each other: two rigs driven through one
|
||||
* another would generate contacts and resolve none of them. So physical
|
||||
* presence lives in a single dynamic capsule instead, and the ragdoll rides
|
||||
* along on top purely as the visible, hittable skeleton.
|
||||
*
|
||||
* The loop is:
|
||||
*
|
||||
* read — pull position and velocity out of Box3D into the sim state
|
||||
* step — the skating sim edits that velocity (stride, carve, drag)
|
||||
* write — put the edited velocity back on the body, then let Box3D solve
|
||||
*
|
||||
* Reading velocity back rather than only writing it is the whole point: a
|
||||
* board hit or a shoulder from another skater arrives as a change to `vx/vz`
|
||||
* that the sim then carries forward as momentum, so contact costs speed and
|
||||
* knocks a skater off their line instead of being overwritten next frame.
|
||||
*
|
||||
* Rotation and vertical motion are locked. Upright-ness is an animation
|
||||
* concern here, not a physics one — and an unlocked capsule on near-frictionless
|
||||
* ice will happily lie down and roll to the far boards.
|
||||
*/
|
||||
|
||||
/** Capsule spans knee to shoulder; below that is legs, above is head. */
|
||||
const LOW = 0.5;
|
||||
const HIGH = 1.28;
|
||||
|
||||
/** Skater plus pads, kg. Sets how much of a shove a check transfers. */
|
||||
const MASS = 88;
|
||||
|
||||
const capsuleVolume = (r, len) => Math.PI * r * r * len + (4 / 3) * Math.PI * r * r * r;
|
||||
|
||||
export function createBodyProxy(physics, { index = 0, position = { x: 0, z: 0 } } = {}) {
|
||||
const { api, world } = physics;
|
||||
const filter = proxyFilter();
|
||||
|
||||
const bd = api.b3DefaultBodyDef();
|
||||
bd.type = api.b3BodyType.b3_dynamicBody;
|
||||
bd.position = xyz(position.x, 0, position.z);
|
||||
// Never sleep: a skater standing still still has to be shoved when hit, and
|
||||
// a sleeping body ignores the velocity we write to it.
|
||||
bd.enableSleep = false;
|
||||
bd.motionLocks = {
|
||||
linearX: false,
|
||||
linearY: true,
|
||||
linearZ: false,
|
||||
angularX: true,
|
||||
angularY: true,
|
||||
angularZ: true,
|
||||
};
|
||||
const body = api.b3CreateBody(world, bd);
|
||||
|
||||
const sd = api.b3DefaultShapeDef();
|
||||
sd.density = MASS / capsuleVolume(SKATE.radius, HIGH - LOW);
|
||||
sd.enableContactEvents = true;
|
||||
sd.enableHitEvents = true;
|
||||
// Skater-on-skater should shove, not stick. Friction between two bodies on
|
||||
// ice is what would make a brush past turn into a drag along.
|
||||
sd.baseMaterial.friction = 0.1;
|
||||
sd.baseMaterial.restitution = 0.05;
|
||||
sd.baseMaterial.userMaterialId = makeTag(KIND.PROXY, index, 0);
|
||||
sd.filter.categoryBits = filter.category;
|
||||
sd.filter.maskBits = filter.mask;
|
||||
const shape = api.b3CreateCapsuleShape(body, sd, {
|
||||
center1: xyz(0, LOW, 0),
|
||||
center2: xyz(0, HIGH, 0),
|
||||
radius: SKATE.radius,
|
||||
});
|
||||
|
||||
// Gravity is pointless with linearY locked, and leaving it on means the
|
||||
// solver spends every step fighting the lock.
|
||||
api.b3Body_SetGravityScale(body, 0);
|
||||
// No damping: the skating sim is the only thing allowed to remove speed,
|
||||
// otherwise top speed and glide length quietly depend on solver settings.
|
||||
api.b3Body_SetLinearDamping(body, 0);
|
||||
|
||||
return {
|
||||
body,
|
||||
shape,
|
||||
index,
|
||||
mass: api.b3Body_GetMass(body),
|
||||
|
||||
/** Box3D → sim. Call before stepping the sim. */
|
||||
read(state) {
|
||||
const p = api.b3Body_GetPosition(body);
|
||||
const v = api.b3Body_GetLinearVelocity(body);
|
||||
state.x = p.x;
|
||||
state.z = p.z;
|
||||
state.vx = v.x;
|
||||
state.vz = v.z;
|
||||
},
|
||||
|
||||
/** Sim → Box3D. Call after stepping the sim, before the world step. */
|
||||
write(state) {
|
||||
api.b3Body_SetLinearVelocity(body, xyz(state.vx, 0, state.vz));
|
||||
api.b3Body_SetAwake(body, true);
|
||||
},
|
||||
|
||||
/**
|
||||
* Hard placement, for spawning and respawns. Clears momentum so a skater
|
||||
* dropped onto the ice does not inherit whatever the last body was doing.
|
||||
*/
|
||||
teleport(x, z) {
|
||||
api.b3Body_SetTransform(body, xyz(x, 0, z), { v: { x: 0, y: 0, z: 0 }, s: 1 });
|
||||
api.b3Body_SetLinearVelocity(body, xyz(0, 0, 0));
|
||||
},
|
||||
|
||||
/** True while this capsule is taking part in the simulation. */
|
||||
enabled: true,
|
||||
|
||||
/**
|
||||
* Switch the capsule off while the ragdoll is the body.
|
||||
*
|
||||
* Not just "stop writing velocity to it": a body left enabled still
|
||||
* occupies space, so a downed skater would leave an invisible upright
|
||||
* bollard on the ice for everyone else to skate into.
|
||||
*/
|
||||
disable() {
|
||||
if (!this.enabled) return;
|
||||
api.b3Body_Disable(body);
|
||||
this.enabled = false;
|
||||
},
|
||||
|
||||
/** Put the capsule back, wherever the body actually ended up. */
|
||||
enable(x, z) {
|
||||
if (this.enabled) return;
|
||||
api.b3Body_Enable(body);
|
||||
api.b3Body_SetTransform(body, xyz(x, 0, z), { v: { x: 0, y: 0, z: 0 }, s: 1 });
|
||||
api.b3Body_SetLinearVelocity(body, xyz(0, 0, 0));
|
||||
api.b3Body_SetAwake(body, true);
|
||||
this.enabled = true;
|
||||
},
|
||||
|
||||
destroy() {
|
||||
api.b3DestroyBody(body);
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,129 @@
|
||||
/**
|
||||
* three.js <-> Box3D type conversion.
|
||||
*
|
||||
* The one real trap: Box3D's embind structs use the vector/scalar quaternion
|
||||
* form `{ v: {x,y,z}, s }`, while three.js uses `{x,y,z,w}`. Passing a three
|
||||
* quaternion straight into a joint or transform throws `Missing field: "v"`
|
||||
* from embind, so everything crossing the boundary goes through here.
|
||||
*/
|
||||
|
||||
export const IDENTITY_QUAT = Object.freeze({ v: { x: 0, y: 0, z: 0 }, s: 1 });
|
||||
|
||||
export const vec3 = (v) => ({ x: v.x, y: v.y, z: v.z });
|
||||
export const xyz = (x, y, z) => ({ x, y, z });
|
||||
|
||||
/** three.Quaternion -> b3Quat */
|
||||
export const quat = (q) => ({ v: { x: q.x, y: q.y, z: q.z }, s: q.w });
|
||||
|
||||
/** b3Quat -> three.Quaternion (in place) */
|
||||
export const toThreeQuat = (out, bq) => out.set(bq.v.x, bq.v.y, bq.v.z, bq.s);
|
||||
|
||||
/** b3Vec3 -> three.Vector3 (in place) */
|
||||
export const toThreeVec = (out, bv) => out.set(bv.x, bv.y, bv.z);
|
||||
|
||||
/** three position + quaternion -> b3Transform */
|
||||
export const transform = (p, q) => ({ p: vec3(p), q: quat(q) });
|
||||
|
||||
/** Copy a body's pose onto an Object3D that lives in world space. */
|
||||
export function applyBodyToObject(b3, bodyId, obj) {
|
||||
const t = b3.b3Body_GetTransform(bodyId);
|
||||
obj.position.set(t.p.x, t.p.y, t.p.z);
|
||||
obj.quaternion.set(t.q.v.x, t.q.v.y, t.q.v.z, t.q.s);
|
||||
}
|
||||
|
||||
/**
|
||||
* Shape tags.
|
||||
*
|
||||
* Box3D has no per-body user data, but hit events carry the `userMaterialId`
|
||||
* of both shapes, so identity is packed into that 64-bit field:
|
||||
*
|
||||
* bits 0..7 kind (KIND.*)
|
||||
* bits 8..15 skater index of the owning skater, 0xff for none
|
||||
* bits 16..31 slot region or piece index within that skater
|
||||
*
|
||||
* A hit event therefore tells us who was struck, where, and by what, without
|
||||
* any side lookup in the hot path.
|
||||
*/
|
||||
export const KIND = {
|
||||
NONE: 0,
|
||||
BODY: 1, // ragdoll limb
|
||||
PROXY: 2, // the skater's single dynamic capsule
|
||||
STICK: 3, // reserved — spike 2
|
||||
PUCK: 4, // reserved — spike 2
|
||||
RINK: 5, // ice / boards
|
||||
};
|
||||
|
||||
export function makeTag(kind, skater, slot) {
|
||||
return (BigInt(kind & 0xff)) | (BigInt((skater ?? 0xff) & 0xff) << 8n) | (BigInt(slot & 0xffff) << 16n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Collision layers.
|
||||
*
|
||||
* Bit 0 is the rink (ice + boards). Bit 15 is the proxy layer: the one dynamic
|
||||
* capsule per skater that Box3D actually solves — board contact, and skater
|
||||
* against skater, both happen there.
|
||||
*
|
||||
* Each skater also owns one bit from bit 1 up for their 18 ragdoll capsules.
|
||||
* Those are kinematic in this spike and exist so the rig is already wired for
|
||||
* impulses later; they deliberately do *not* collide with any proxy, because a
|
||||
* kinematic limb driving through the dynamic capsule that carries the same
|
||||
* body would fight it every frame.
|
||||
*
|
||||
* Getting this wrong is silent: a body whose mask excludes bit 0 simply falls
|
||||
* through the world with no error anywhere.
|
||||
*/
|
||||
export const CAT = {
|
||||
RINK: 1n,
|
||||
PROXY: 1n << 15n,
|
||||
PUCK: 1n << 16n,
|
||||
STICK: 1n << 17n,
|
||||
skater: (index) => 1n << BigInt(1 + index),
|
||||
};
|
||||
|
||||
const ALL_BITS = 0xffffffffffffffffn;
|
||||
|
||||
/**
|
||||
* The dynamic body capsule: hits the boards, every other skater's proxy, and
|
||||
* the puck. Not sticks — a stick is a kinematic collider and would shove
|
||||
* skaters around without ever being pushed back.
|
||||
*/
|
||||
export function proxyFilter() {
|
||||
return { category: CAT.PROXY, mask: CAT.RINK | CAT.PROXY | CAT.PUCK };
|
||||
}
|
||||
|
||||
/**
|
||||
* The stick blade: touches the puck and nothing else.
|
||||
*
|
||||
* Kinematic bodies push dynamic ones without being pushed back, which is
|
||||
* exactly right for a stick batting a puck and exactly wrong for a stick
|
||||
* batting a person. Same trap as the ragdoll limbs, resolved the same way —
|
||||
* by keeping the mask narrow rather than by hoping.
|
||||
*/
|
||||
export function stickFilter() {
|
||||
return { category: CAT.STICK, mask: CAT.PUCK };
|
||||
}
|
||||
|
||||
/**
|
||||
* Ragdoll limbs: include the self bit so distant parts collide (hand vs
|
||||
* torso, thigh vs thigh) once the rig goes dynamic. Adjacent pairs are
|
||||
* rejected by the world custom filter using the userMaterialId slot indices.
|
||||
* Proxies are masked out — see the note above.
|
||||
*/
|
||||
export function ragdollFilter(index) {
|
||||
const self = CAT.skater(index);
|
||||
return { category: self, mask: ALL_BITS & ~CAT.PROXY };
|
||||
}
|
||||
|
||||
export function rinkFilter() {
|
||||
return { category: CAT.RINK, mask: ALL_BITS };
|
||||
}
|
||||
|
||||
export function readTag(tag) {
|
||||
const t = BigInt(tag);
|
||||
return {
|
||||
kind: Number(t & 0xffn),
|
||||
skater: Number((t >> 8n) & 0xffn),
|
||||
slot: Number((t >> 16n) & 0xffffn),
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,124 @@
|
||||
import * as THREE from 'three';
|
||||
import { NET, goalLineX } from '../../shared/net.js';
|
||||
import { CAT, KIND, makeTag, xyz } from './bridge.js';
|
||||
|
||||
/**
|
||||
* The goal frame: posts, crossbar, and a mesh back that stops the puck.
|
||||
*
|
||||
* Static bodies, because a net that moves is a rule (it comes off its moorings)
|
||||
* rather than a feature, and not one worth having before there is a game.
|
||||
*
|
||||
* The back and sides are solid boxes rather than a real mesh. A puck that goes
|
||||
* in should stay in and settle, and modelling twine is a lot of work to make a
|
||||
* puck stop moving.
|
||||
*/
|
||||
export function createNet(physics, end) {
|
||||
const { api, world } = physics;
|
||||
const line = goalLineX(end);
|
||||
const halfW = NET.width / 2;
|
||||
const r = NET.postRadius;
|
||||
|
||||
const sd = api.b3DefaultShapeDef();
|
||||
sd.baseMaterial.friction = 0.4;
|
||||
// Posts ring; the back eats everything so the puck settles in the net.
|
||||
sd.baseMaterial.restitution = 0.35;
|
||||
sd.baseMaterial.userMaterialId = makeTag(KIND.RINK, 0xff, end > 0 ? 10 : 11);
|
||||
sd.filter.categoryBits = CAT.RINK;
|
||||
sd.filter.maskBits = 0xffffffffffffffffn;
|
||||
|
||||
const bodies = [];
|
||||
const box = (x, y, z, hx, hy, hz, restitution = null) => {
|
||||
const bd = api.b3DefaultBodyDef();
|
||||
bd.position = xyz(x, y, z);
|
||||
const b = api.b3CreateBody(world, bd);
|
||||
if (restitution !== null) sd.baseMaterial.restitution = restitution;
|
||||
api.b3CreateBoxShape(b, sd, hx, hy, hz);
|
||||
sd.baseMaterial.restitution = 0.35;
|
||||
bodies.push(b);
|
||||
return b;
|
||||
};
|
||||
|
||||
// Posts, on the line.
|
||||
box(line, NET.height / 2, halfW, r, NET.height / 2, r);
|
||||
box(line, NET.height / 2, -halfW, r, NET.height / 2, r);
|
||||
// Crossbar.
|
||||
box(line, NET.height, 0, r, r, halfW);
|
||||
// Back and sides, deadened so the puck does not fire back out.
|
||||
//
|
||||
// The net extends *away* from centre ice, `line + end * depth`. Getting this
|
||||
// sign backwards put the back panel a metre in front of the goal line — a
|
||||
// solid wall across the mouth — and every shot in the game bounced off it
|
||||
// before it could cross. Nothing ever scored, and the symptom looked like a
|
||||
// goalie problem.
|
||||
box(line + end * NET.depth, NET.height / 2, 0, 0.04, NET.height / 2, halfW, 0.02);
|
||||
box(line + end * NET.depth * 0.5, NET.height / 2, halfW, NET.depth / 2, NET.height / 2, 0.03, 0.05);
|
||||
box(line + end * NET.depth * 0.5, NET.height / 2, -halfW, NET.depth / 2, NET.height / 2, 0.03, 0.05);
|
||||
|
||||
return {
|
||||
end,
|
||||
bodies,
|
||||
destroy() {
|
||||
for (const b of bodies) api.b3DestroyBody(b);
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
/** The rendered net: frame tubes plus a translucent mesh bag. */
|
||||
export function buildNetMesh(scene, end) {
|
||||
const line = goalLineX(end);
|
||||
const halfW = NET.width / 2;
|
||||
const group = new THREE.Group();
|
||||
group.name = 'net:' + end;
|
||||
|
||||
const frame = new THREE.MeshStandardMaterial({ color: 0xc0332c, roughness: 0.45, metalness: 0.25 });
|
||||
const mesh = new THREE.MeshStandardMaterial({
|
||||
color: 0xf2f4f8,
|
||||
roughness: 0.9,
|
||||
transparent: true,
|
||||
opacity: 0.28,
|
||||
side: THREE.DoubleSide,
|
||||
depthWrite: false,
|
||||
});
|
||||
|
||||
const tube = (len, x, y, z, axis) => {
|
||||
const g = new THREE.CylinderGeometry(NET.postRadius, NET.postRadius, len, 10);
|
||||
const m = new THREE.Mesh(g, frame);
|
||||
if (axis === 'z') m.rotation.x = Math.PI / 2;
|
||||
if (axis === 'x') m.rotation.z = Math.PI / 2;
|
||||
m.position.set(x, y, z);
|
||||
m.castShadow = true;
|
||||
group.add(m);
|
||||
};
|
||||
tube(NET.height, line, NET.height / 2, halfW, 'y');
|
||||
tube(NET.height, line, NET.height / 2, -halfW, 'y');
|
||||
tube(NET.width, line, NET.height, 0, 'z');
|
||||
// Back frame, so the net reads as a box rather than as a doorway.
|
||||
tube(NET.depth, line + end * NET.depth / 2, 0.06, halfW, 'x');
|
||||
tube(NET.depth, line + end * NET.depth / 2, 0.06, -halfW, 'x');
|
||||
|
||||
const back = new THREE.Mesh(new THREE.PlaneGeometry(NET.width, NET.height), mesh);
|
||||
back.position.set(line + end * NET.depth, NET.height / 2, 0);
|
||||
back.rotation.y = Math.PI / 2;
|
||||
group.add(back);
|
||||
for (const s of [1, -1]) {
|
||||
const side = new THREE.Mesh(new THREE.PlaneGeometry(NET.depth, NET.height), mesh);
|
||||
side.position.set(line + end * NET.depth / 2, NET.height / 2, s * halfW);
|
||||
group.add(side);
|
||||
}
|
||||
const top = new THREE.Mesh(new THREE.PlaneGeometry(NET.depth, NET.width), mesh);
|
||||
top.rotation.x = -Math.PI / 2;
|
||||
top.position.set(line + end * NET.depth / 2, NET.height, 0);
|
||||
group.add(top);
|
||||
|
||||
// Crease paint.
|
||||
const crease = new THREE.Mesh(
|
||||
new THREE.CircleGeometry(NET.creaseRadius, 24, end > 0 ? -Math.PI / 2 : Math.PI / 2, Math.PI),
|
||||
new THREE.MeshBasicMaterial({ color: 0x77b3e0, transparent: true, opacity: 0.45, depthWrite: false }),
|
||||
);
|
||||
crease.rotation.x = -Math.PI / 2;
|
||||
crease.position.set(line, 0.004, 0);
|
||||
group.add(crease);
|
||||
|
||||
scene.add(group);
|
||||
return group;
|
||||
}
|
||||
@@ -0,0 +1,146 @@
|
||||
import * as THREE from 'three';
|
||||
import { CAT, KIND, makeTag, xyz } from './bridge.js';
|
||||
|
||||
/**
|
||||
* The puck.
|
||||
*
|
||||
* Regulation: 76 mm across, 25.4 mm thick, 170 g. Those are not decoration —
|
||||
* the size is what makes this the one body in the world that genuinely needs
|
||||
* continuous collision, and the mass is what makes a 45 m/s shot carry about
|
||||
* the same momentum as a slow-walking person.
|
||||
*
|
||||
* ### Why it is a bullet
|
||||
*
|
||||
* A hard shot travels ~45 m/s. At the 1/120 s fixed step that is 0.37 m per
|
||||
* step — nearly ten times the puck's own radius — and even at Box3D's internal
|
||||
* 1/480 substep it is still 2.4× radius. Without continuous collision it goes
|
||||
* straight through the boards, the net and anybody standing in the way, and the
|
||||
* symptom (a puck that vanishes on hard shots only) is miserable to chase.
|
||||
*
|
||||
* ### Why it is a cylinder, and why it cannot tip over
|
||||
*
|
||||
* A sphere would roll, and a box would catch its corners. Box3D can build a
|
||||
* cylinder hull directly. Angular X and Z are then locked so the puck stays
|
||||
* flat on the ice and only ever spins about its own axis — a puck rolling
|
||||
* around the rink on its edge is technically possible and always reads as a
|
||||
* bug. Vertical motion stays free, because a shot lifting off the ice is real
|
||||
* hockey.
|
||||
*/
|
||||
|
||||
export const PUCK = {
|
||||
radius: 0.0381,
|
||||
thickness: 0.0254,
|
||||
mass: 0.170,
|
||||
/** Ice is slippery; a dumped puck should travel the length of the rink. */
|
||||
iceFriction: 0.05,
|
||||
/** Boards are lively for something this light. */
|
||||
boardRestitution: 0.35,
|
||||
/** Terminal sanity: nothing in hockey exceeds this. */
|
||||
maxSpeed: 55,
|
||||
};
|
||||
|
||||
const HULL_SIDES = 16;
|
||||
|
||||
export function createPuck(physics, { position = { x: 0, y: 0.02, z: 0 } } = {}) {
|
||||
const { api, world } = physics;
|
||||
|
||||
const bd = api.b3DefaultBodyDef();
|
||||
bd.type = api.b3BodyType.b3_dynamicBody;
|
||||
bd.position = xyz(position.x, position.y, position.z);
|
||||
bd.isBullet = true;
|
||||
// Never sleep. A puck sitting still in a corner still has to react the
|
||||
// instant a skate touches it.
|
||||
bd.enableSleep = false;
|
||||
bd.motionLocks = {
|
||||
linearX: false,
|
||||
linearY: false,
|
||||
linearZ: false,
|
||||
angularX: true,
|
||||
angularY: false,
|
||||
angularZ: true,
|
||||
};
|
||||
const body = api.b3CreateBody(world, bd);
|
||||
api.b3Body_SetBullet(body, true);
|
||||
|
||||
// `b3CreateCylinder` builds *upward from* `yOffset` rather than centring on
|
||||
// it, so the offset has to be half the thickness or the body origin sits on
|
||||
// the puck's bottom face — the puck then rests with its origin at y=0 and the
|
||||
// rendered mesh, which is centred, is drawn half-sunk into the ice.
|
||||
const hull = api.b3CreateCylinder(PUCK.thickness, PUCK.radius, -PUCK.thickness / 2, HULL_SIDES);
|
||||
const sd = api.b3DefaultShapeDef();
|
||||
sd.density = PUCK.mass / (Math.PI * PUCK.radius * PUCK.radius * PUCK.thickness);
|
||||
sd.enableContactEvents = true;
|
||||
sd.enableHitEvents = true;
|
||||
sd.baseMaterial.friction = PUCK.iceFriction;
|
||||
sd.baseMaterial.restitution = PUCK.boardRestitution;
|
||||
sd.baseMaterial.userMaterialId = makeTag(KIND.PUCK, 0xff, 0);
|
||||
sd.filter.categoryBits = CAT.PUCK;
|
||||
// Everything solid: the rink, skater bodies, downed ragdolls and sticks.
|
||||
sd.filter.maskBits = 0xffffffffffffffffn;
|
||||
const shape = api.b3CreateHullShape(body, sd, hull);
|
||||
// Damping stands in for air resistance and blade scrape; without it a puck
|
||||
// dumped down the ice never slows at all on a 0.05 friction surface.
|
||||
api.b3Body_SetLinearDamping(body, 0.22);
|
||||
api.b3Body_SetAngularDamping(body, 0.4);
|
||||
|
||||
const _pos = new THREE.Vector3();
|
||||
const _vel = new THREE.Vector3();
|
||||
const _quat = new THREE.Quaternion();
|
||||
|
||||
return {
|
||||
body,
|
||||
shape,
|
||||
mass: api.b3Body_GetMass(body),
|
||||
|
||||
/** World position, into a reused vector. */
|
||||
position() {
|
||||
const p = api.b3Body_GetPosition(body);
|
||||
return _pos.set(p.x, p.y, p.z);
|
||||
},
|
||||
|
||||
velocity() {
|
||||
const v = api.b3Body_GetLinearVelocity(body);
|
||||
return _vel.set(v.x, v.y, v.z);
|
||||
},
|
||||
|
||||
rotation() {
|
||||
const t = api.b3Body_GetTransform(body);
|
||||
return _quat.set(t.q.v.x, t.q.v.y, t.q.v.z, t.q.s);
|
||||
},
|
||||
|
||||
speed() {
|
||||
const v = api.b3Body_GetLinearVelocity(body);
|
||||
return Math.hypot(v.x, v.y, v.z);
|
||||
},
|
||||
|
||||
setVelocity(x, y, z) {
|
||||
const speed = Math.hypot(x, y, z);
|
||||
if (speed > PUCK.maxSpeed) {
|
||||
const k = PUCK.maxSpeed / speed;
|
||||
api.b3Body_SetLinearVelocity(body, xyz(x * k, y * k, z * k));
|
||||
} else {
|
||||
api.b3Body_SetLinearVelocity(body, xyz(x, y, z));
|
||||
}
|
||||
api.b3Body_SetAwake(body, true);
|
||||
},
|
||||
|
||||
applyImpulse(x, y, z) {
|
||||
api.b3Body_ApplyLinearImpulseToCenter(body, xyz(x, y, z), true);
|
||||
},
|
||||
|
||||
/** Hard placement — faceoffs, resets, and the carry when fully magnetised. */
|
||||
place(x, y, z, { keepMotion = false } = {}) {
|
||||
api.b3Body_SetTransform(body, xyz(x, y, z), { v: { x: 0, y: 0, z: 0 }, s: 1 });
|
||||
if (!keepMotion) {
|
||||
api.b3Body_SetLinearVelocity(body, xyz(0, 0, 0));
|
||||
api.b3Body_SetAngularVelocity(body, xyz(0, 0, 0));
|
||||
}
|
||||
api.b3Body_SetAwake(body, true);
|
||||
},
|
||||
|
||||
destroy() {
|
||||
api.b3DestroyBody(body);
|
||||
api.b3DestroyHull(hull);
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,676 @@
|
||||
import * as THREE from 'three';
|
||||
import { BONE_RADIUS, BONE_REGION, SEG_CHILD } from '../character/skeleton.js';
|
||||
import { CAT, IDENTITY_QUAT, KIND, makeTag, quat, ragdollFilter, transform, vec3 } from './bridge.js';
|
||||
// Reaction curve: a blow bites almost instantly, then bleeds off over the
|
||||
// recovery window. Anything slower on the attack reads as the skater choosing
|
||||
// to flinch rather than being moved by the hit.
|
||||
// Reach full physics weight fast so the flinch is visible on the first frames
|
||||
// after the impulse (was 55 ms — most of a light hit was over before peak).
|
||||
export const REACTION_ATTACK = 0.04;
|
||||
|
||||
/**
|
||||
* Physical body built from the animation skeleton.
|
||||
*
|
||||
* Each part's collider is authored in *bone-local* space — capsule from the
|
||||
* bone origin to its child's local offset — and the rigid body is placed at
|
||||
* the bone's world transform. That sidesteps any axis-alignment math: the
|
||||
* capsule matches the bone exactly by construction, whatever direction the
|
||||
* bone happens to point.
|
||||
*
|
||||
* Two modes:
|
||||
* 'driven' bodies are kinematic and chase the animated skeleton. This is
|
||||
* everything spike 1 uses — the rig is here so that hits later have
|
||||
* something to push, not because anything pushes it yet.
|
||||
* 'limp' bodies go dynamic and the joints take over. Bone velocity at the
|
||||
* moment of transition is carried across, so a skater taken off
|
||||
* their feet mid-stride keeps the momentum of that stride.
|
||||
*
|
||||
* Carried over from Ludus with the collision filters retargeted (see
|
||||
* bridge.js) and nothing else changed: it is the same 18 capsules and 17
|
||||
* joints, and the reaction/limp paths are known-good.
|
||||
*/
|
||||
|
||||
const HINGE_FRAME = { v: { x: 0, y: Math.SQRT1_2, z: 0 }, s: Math.SQRT1_2 }; // local Z -> local X
|
||||
|
||||
// Body density by tissue type. Box3D derives mass and inertia from the shapes,
|
||||
// so these are the only mass numbers we author — but see CALIBRATION below.
|
||||
const DENSITY = { bone: 1350, limb: 1050, torso: 1010, head: 1090 };
|
||||
|
||||
// Adjacent bone capsules deliberately overlap so the rig has no gaps at the
|
||||
// joints, which means summing their volumes counts the overlaps twice and lands
|
||||
// around 175 kg of "flesh" for a normal build. Rather than fudge the densities
|
||||
// (and lose the physical relationship between tissue types), the whole rig is
|
||||
// scaled once at build time to hit a plausible total. Re-setting the shape
|
||||
// density and letting Box3D recompute keeps each body's inertia tensor
|
||||
// consistent with its new mass; scaling the tensor by hand would not.
|
||||
const TARGET_BODY_MASS = 86; // kg, before pads and stick
|
||||
|
||||
/**
|
||||
* Parts, parent-first. `hinge` marks a joint that should only bend one way
|
||||
* (elbows, knees); everything else is a cone-limited ball joint.
|
||||
*/
|
||||
const PARTS = [
|
||||
{ name: 'pelvis', bone: 'pelvis', parent: null, density: DENSITY.torso, radiusScale: 1.15 },
|
||||
{ name: 'spine1', bone: 'spine1', parent: 'pelvis', density: DENSITY.torso, cone: 0.34, twist: 0.5 },
|
||||
{ name: 'spine2', bone: 'spine2', parent: 'spine1', density: DENSITY.torso, cone: 0.34, twist: 0.5 },
|
||||
{ name: 'spine3', bone: 'spine3', parent: 'spine2', density: DENSITY.torso, cone: 0.3, twist: 0.4 },
|
||||
{ name: 'neck', bone: 'neck', parent: 'spine3', density: DENSITY.head, cone: 0.5, twist: 0.7 },
|
||||
{ name: 'head', bone: 'head', parent: 'neck', density: DENSITY.head, cone: 0.55, twist: 0.8, radiusScale: 1.0 },
|
||||
|
||||
{ name: 'upperArmL', bone: 'upperArmL', parent: 'spine3', density: DENSITY.limb, cone: 1.5, twist: 1.1 },
|
||||
{ name: 'forearmL', bone: 'forearmL', parent: 'upperArmL', density: DENSITY.limb, hinge: [-0.12, 2.5] },
|
||||
{ name: 'handL', bone: 'handL', parent: 'forearmL', density: DENSITY.limb, cone: 0.7, twist: 0.6 },
|
||||
{ name: 'upperArmR', bone: 'upperArmR', parent: 'spine3', density: DENSITY.limb, cone: 1.5, twist: 1.1 },
|
||||
{ name: 'forearmR', bone: 'forearmR', parent: 'upperArmR', density: DENSITY.limb, hinge: [-0.12, 2.5] },
|
||||
{ name: 'handR', bone: 'handR', parent: 'forearmR', density: DENSITY.limb, cone: 0.7, twist: 0.6 },
|
||||
|
||||
// Knee hinge is about bone-local +X (HINGE_FRAME maps joint Z → X). With the
|
||||
// rest limb along −Y, *positive* angle swings the foot back (−Z) — flexion.
|
||||
// Negative angle is hyperextension (foot forward). The old limits were
|
||||
// inverted ([-2.4, -0.12]), so limp legs only bent the wrong way.
|
||||
// Residual +0.12 rad of flex stops a perfectly straight column from standing
|
||||
// forever under gravity, and blocks reverse bend.
|
||||
{ name: 'thighL', bone: 'thighL', parent: 'pelvis', density: DENSITY.limb, cone: 1.15, twist: 0.5 },
|
||||
{ name: 'shinL', bone: 'shinL', parent: 'thighL', density: DENSITY.limb, hinge: [0.12, 2.4] },
|
||||
{ name: 'footL', bone: 'footL', parent: 'shinL', density: DENSITY.bone, cone: 0.5, twist: 0.3 },
|
||||
{ name: 'thighR', bone: 'thighR', parent: 'pelvis', density: DENSITY.limb, cone: 1.15, twist: 0.5 },
|
||||
{ name: 'shinR', bone: 'shinR', parent: 'thighR', density: DENSITY.limb, hinge: [0.12, 2.4] },
|
||||
{ name: 'footR', bone: 'footR', parent: 'shinR', density: DENSITY.bone, cone: 0.5, twist: 0.3 },
|
||||
];
|
||||
|
||||
const _wp = new THREE.Vector3();
|
||||
const _wq = new THREE.Quaternion();
|
||||
const _ws = new THREE.Vector3();
|
||||
const _prevP = new THREE.Vector3();
|
||||
const _prevQ = new THREE.Quaternion();
|
||||
const _pq = new THREE.Quaternion();
|
||||
const _pqi = new THREE.Quaternion();
|
||||
const _dq = new THREE.Quaternion();
|
||||
const _axis = new THREE.Vector3();
|
||||
const _zAxis = new THREE.Vector3(0, 0, 1);
|
||||
|
||||
/**
|
||||
* Adjacency (by part name) for self-collision filtering.
|
||||
* Adjacent capsules deliberately overlap at joints; they must never generate
|
||||
* contacts. Parts two links away still often rest inside each other in bind
|
||||
* pose (spine1↔spine3), so we cull graph distance ≤ 2 as well.
|
||||
*/
|
||||
function partDistance(a, b) {
|
||||
if (a === b) return 0;
|
||||
// BFS on the undirected tree. PARTS is small (18), so this is free.
|
||||
const adj = new Map();
|
||||
for (const p of PARTS) {
|
||||
if (!adj.has(p.name)) adj.set(p.name, []);
|
||||
if (p.parent) {
|
||||
adj.get(p.name).push(p.parent);
|
||||
if (!adj.has(p.parent)) adj.set(p.parent, []);
|
||||
adj.get(p.parent).push(p.name);
|
||||
}
|
||||
}
|
||||
const q = [[a, 0]];
|
||||
const seen = new Set([a]);
|
||||
while (q.length) {
|
||||
const [n, d] = q.shift();
|
||||
if (n === b) return d;
|
||||
for (const m of adj.get(n) ?? []) {
|
||||
if (seen.has(m)) continue;
|
||||
seen.add(m);
|
||||
q.push([m, d + 1]);
|
||||
}
|
||||
}
|
||||
return 99;
|
||||
}
|
||||
|
||||
/**
|
||||
* Precomputed "too close to collide" pairs keyed by part name.
|
||||
* Distance ≤ 1 = joint neighbours (capsules deliberately overlap).
|
||||
* Distance 2 on the *spine* only — limb forks (thighL↔thighR = 2 via pelvis)
|
||||
* must still collide so a limp body can tangle.
|
||||
*/
|
||||
const NO_COLLIDE = new Set();
|
||||
{
|
||||
const names = PARTS.map((p) => p.name);
|
||||
const spine = new Set(['pelvis', 'spine1', 'spine2', 'spine3', 'neck', 'head']);
|
||||
for (let i = 0; i < names.length; i++) {
|
||||
for (let j = i + 1; j < names.length; j++) {
|
||||
const d = partDistance(names[i], names[j]);
|
||||
const bothSpine = spine.has(names[i]) && spine.has(names[j]);
|
||||
if (d <= 1 || (d <= 2 && bothSpine)) {
|
||||
NO_COLLIDE.add(`${names[i]}|${names[j]}`);
|
||||
NO_COLLIDE.add(`${names[j]}|${names[i]}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** True when two body part *names* on the same rig may generate contacts. */
|
||||
export function ragdollPartsCollide(nameA, nameB) {
|
||||
if (nameA === nameB) return false;
|
||||
return !NO_COLLIDE.has(`${nameA}|${nameB}`);
|
||||
}
|
||||
|
||||
/** Slot indices match the order PARTS is walked when building the ragdoll. */
|
||||
const SLOT_NAMES = PARTS.map((p) => p.name);
|
||||
|
||||
/** True when two body *slots* on the same rig may generate contacts. */
|
||||
export function slotsShouldCollide(slotA, slotB) {
|
||||
const a = SLOT_NAMES[slotA];
|
||||
const b = SLOT_NAMES[slotB];
|
||||
if (a == null || b == null) return true;
|
||||
return ragdollPartsCollide(a, b);
|
||||
}
|
||||
|
||||
export function createRagdoll(physics, skelData, { skaterIndex = 0 } = {}) {
|
||||
const { api, world } = physics;
|
||||
const bones = skelData.bones;
|
||||
skelData.rootBone.updateMatrixWorld(true);
|
||||
|
||||
const filter = ragdollFilter(skaterIndex);
|
||||
// Two masks, swapped by setMode. `driven` keeps limbs out of the proxy layer
|
||||
// so an animated arm cannot shove anybody; `limp` lets a falling body hit
|
||||
// people. The rig's own proxy is disabled while it is down, so nothing here
|
||||
// has to special-case self.
|
||||
const drivenMask = filter.mask & ~CAT.PROXY;
|
||||
const limpMask = filter.mask | CAT.PROXY;
|
||||
const _filter = { categoryBits: filter.category, maskBits: drivenMask, groupIndex: 0 };
|
||||
const parts = {};
|
||||
const order = [];
|
||||
|
||||
for (const def of PARTS) {
|
||||
const bone = bones[def.bone];
|
||||
if (!bone) continue;
|
||||
const childName = SEG_CHILD[def.bone];
|
||||
const child = childName ? bones[childName] : null;
|
||||
|
||||
// Capsule endpoints in bone-local space.
|
||||
const c1 = new THREE.Vector3(0, 0, 0);
|
||||
const c2 = child
|
||||
? child.position.clone()
|
||||
: def.bone === 'head'
|
||||
? new THREE.Vector3(0, 0.15, 0.012)
|
||||
: def.bone.startsWith('hand')
|
||||
? new THREE.Vector3(def.bone.endsWith('L') ? 0.045 : -0.045, -0.095, 0.008)
|
||||
: new THREE.Vector3(0, -0.012, 0.085);
|
||||
|
||||
const radius = BONE_RADIUS[def.bone] * (def.radiusScale ?? 0.72);
|
||||
// A degenerate capsule (endpoints closer than the radius) is just a sphere
|
||||
// and confuses the solver; nudge it out along its own axis instead.
|
||||
if (c2.length() < radius * 0.5) c2.setLength(radius * 0.5 + 1e-3);
|
||||
|
||||
bone.matrixWorld.decompose(_wp, _wq, _ws);
|
||||
|
||||
const bd = api.b3DefaultBodyDef();
|
||||
// Created dynamic so Box3D computes mass and inertia from the shapes, then
|
||||
// switched to kinematic below. A kinematic body reports zero mass, so this
|
||||
// is the only moment the real figure is available.
|
||||
bd.type = api.b3BodyType.b3_dynamicBody;
|
||||
bd.position = vec3(_wp);
|
||||
bd.rotation = quat(_wq);
|
||||
bd.enableSleep = false;
|
||||
const body = api.b3CreateBody(world, bd);
|
||||
|
||||
const sd = api.b3DefaultShapeDef();
|
||||
sd.density = def.density;
|
||||
sd.enableHitEvents = true;
|
||||
sd.enableContactEvents = true;
|
||||
// Custom filter rejects adjacent limbs of the same skater (see world.js).
|
||||
sd.enableCustomFiltering = true;
|
||||
sd.baseMaterial.friction = 0.75;
|
||||
sd.baseMaterial.restitution = 0.05;
|
||||
sd.baseMaterial.userMaterialId = makeTag(KIND.BODY, skaterIndex, order.length);
|
||||
// Self bit is included: distant limbs collide when limp. Adjacent pairs
|
||||
// are culled by the world custom filter (and joints keep collideConnected off).
|
||||
sd.filter.categoryBits = filter.category;
|
||||
sd.filter.maskBits = drivenMask;
|
||||
sd.filter.groupIndex = 0;
|
||||
const shape = api.b3CreateCapsuleShape(body, sd, {
|
||||
center1: vec3(c1),
|
||||
center2: vec3(c2),
|
||||
radius,
|
||||
});
|
||||
api.b3Body_EnableHitEvents(body, true);
|
||||
const mass = api.b3Body_GetMass(body);
|
||||
|
||||
const part = {
|
||||
name: def.name,
|
||||
def,
|
||||
bone,
|
||||
body,
|
||||
shape,
|
||||
radius,
|
||||
mass,
|
||||
// Capsule endpoints in bone-local space, kept so the segment can be
|
||||
// rebuilt in world space for limb-level hit queries without asking
|
||||
// Box3D to hand the shape back every frame.
|
||||
localA: c1.clone(),
|
||||
localB: c2.clone(),
|
||||
region: BONE_REGION[def.bone],
|
||||
index: order.length,
|
||||
prevPos: _wp.clone(),
|
||||
prevQuat: _wq.clone(),
|
||||
linVel: new THREE.Vector3(),
|
||||
angVel: new THREE.Vector3(),
|
||||
disabled: false,
|
||||
};
|
||||
parts[def.name] = part;
|
||||
order.push(part);
|
||||
}
|
||||
|
||||
// ---- mass calibration ---------------------------------------------------
|
||||
// Runs while the bodies are still dynamic: a kinematic body has no mass to
|
||||
// recompute, so calibrating after the switch would silently do nothing.
|
||||
{
|
||||
let raw = 0;
|
||||
for (const part of order) raw += part.mass;
|
||||
if (raw > 1e-6) {
|
||||
const k = TARGET_BODY_MASS / raw;
|
||||
for (const part of order) {
|
||||
api.b3Shape_SetDensity(part.shape, part.def.density * k, false);
|
||||
api.b3Body_ApplyMassFromShapes(part.body);
|
||||
part.mass = api.b3Body_GetMass(part.body);
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const part of order) api.b3Body_SetType(part.body, api.b3BodyType.b3_kinematicBody);
|
||||
|
||||
// ---- joints -------------------------------------------------------------
|
||||
const joints = [];
|
||||
for (const def of PARTS) {
|
||||
if (!def.parent) continue;
|
||||
const a = parts[def.parent];
|
||||
const b = parts[def.name];
|
||||
if (!a || !b) continue;
|
||||
|
||||
// The anchor is the child bone's origin: (0,0,0) in the child's frame, and
|
||||
// the child's local offset in the parent's frame.
|
||||
const localA = b.bone.position.clone();
|
||||
const localB = new THREE.Vector3(0, 0, 0);
|
||||
|
||||
let jointId;
|
||||
if (def.hinge) {
|
||||
const jd = api.b3DefaultRevoluteJointDef();
|
||||
jd.base.bodyIdA = a.body;
|
||||
jd.base.bodyIdB = b.body;
|
||||
jd.base.localFrameA = { p: vec3(localA), q: HINGE_FRAME };
|
||||
jd.base.localFrameB = { p: vec3(localB), q: HINGE_FRAME };
|
||||
// Stiffer limit solver on hinges so a heavy impact cannot soft-blow past
|
||||
// the hyperextension stop (knees) or the elbow lock.
|
||||
jd.base.constraintHertz = 90;
|
||||
jd.base.constraintDampingRatio = 3;
|
||||
jd.enableLimit = true;
|
||||
jd.lowerAngle = def.hinge[0];
|
||||
jd.upperAngle = def.hinge[1];
|
||||
// Springs start off — see setJointStiffness.
|
||||
jd.enableSpring = false;
|
||||
jd.hertz = 0;
|
||||
jd.dampingRatio = 0.7;
|
||||
jointId = api.b3CreateRevoluteJoint(world, jd);
|
||||
} else {
|
||||
// Cone axis is frame Z, so point Z down the limb.
|
||||
_axis.copy(localA).normalize();
|
||||
const frameQ = localA.lengthSq() > 1e-9
|
||||
? quat(_dq.setFromUnitVectors(_zAxis, _axis))
|
||||
: IDENTITY_QUAT;
|
||||
const jd = api.b3DefaultSphericalJointDef();
|
||||
jd.base.bodyIdA = a.body;
|
||||
jd.base.bodyIdB = b.body;
|
||||
jd.base.localFrameA = { p: vec3(localA), q: frameQ };
|
||||
jd.base.localFrameB = { p: vec3(localB), q: frameQ };
|
||||
jd.enableConeLimit = true;
|
||||
jd.coneAngle = def.cone ?? 0.6;
|
||||
jd.enableTwistLimit = true;
|
||||
jd.lowerTwistAngle = -(def.twist ?? 0.5);
|
||||
jd.upperTwistAngle = def.twist ?? 0.5;
|
||||
// Springs start off. A spring pulls each joint toward its neutral (bind
|
||||
// pose) rotation, and at any usable stiffness that turns the rig into a
|
||||
// self-supporting mannequin: it balances on straight legs and never
|
||||
// collapses. Stiffness is applied deliberately via setJointStiffness for
|
||||
// the partial "spring-damper blend" reaction, and left at zero for a real
|
||||
// collapse.
|
||||
jd.enableSpring = false;
|
||||
jd.hertz = 0;
|
||||
jd.dampingRatio = 0.65;
|
||||
jointId = api.b3CreateSphericalJoint(world, jd);
|
||||
}
|
||||
joints.push({ id: jointId, a: a.name, b: b.name, def, hinge: !!def.hinge });
|
||||
}
|
||||
|
||||
let mode = 'driven';
|
||||
let stiffness = 0;
|
||||
|
||||
/**
|
||||
* Joint stiffness — the spring-damper blend.
|
||||
*
|
||||
* `hertz` 0 gives a fully limp rig that collapses under its own weight; the
|
||||
* useful range for a reaction that recovers its pose is roughly 2–6 Hz. High
|
||||
* values make the rig self-supporting, which is right for a stumble and wrong
|
||||
* for a death.
|
||||
*/
|
||||
function setJointStiffness(hertz, dampingRatio = 0.65) {
|
||||
stiffness = hertz;
|
||||
const on = hertz > 0.01;
|
||||
for (const j of joints) {
|
||||
if (j.severed) continue;
|
||||
if (j.hinge) {
|
||||
api.b3RevoluteJoint_EnableSpring(j.id, on);
|
||||
if (on) {
|
||||
api.b3RevoluteJoint_SetSpringHertz(j.id, hertz);
|
||||
api.b3RevoluteJoint_SetSpringDampingRatio(j.id, dampingRatio);
|
||||
}
|
||||
} else {
|
||||
api.b3SphericalJoint_EnableSpring(j.id, on);
|
||||
if (on) {
|
||||
api.b3SphericalJoint_SetSpringHertz(j.id, hertz);
|
||||
api.b3SphericalJoint_SetSpringDampingRatio(j.id, dampingRatio);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Push the animated skeleton into the physics bodies (driven mode). */
|
||||
function syncFromSkeleton(dt) {
|
||||
for (const part of order) {
|
||||
part.bone.matrixWorld.decompose(_wp, _wq, _ws);
|
||||
api.b3Body_SetTargetTransform(part.body, transform(_wp, _wq), dt, true);
|
||||
}
|
||||
}
|
||||
|
||||
// Sanity ceilings for the handoff. A limb tip in a hard stride runs well under
|
||||
// these; anything above is a sampling artefact, and letting it through
|
||||
// launches the whole rig into the air the instant it goes limp.
|
||||
const MAX_LIN = 12; // m/s
|
||||
const MAX_ANG = 30; // rad/s
|
||||
|
||||
/**
|
||||
* Sample bone velocities, once per rendered frame.
|
||||
*
|
||||
* This deliberately does *not* live in syncFromSkeleton. That runs once per
|
||||
* fixed substep while the skeleton only moves once per rendered frame, so a
|
||||
* delta measured there gets divided by the substep duration rather than the
|
||||
* frame duration — inflating velocity by the substep count and leaving the
|
||||
* stored value dependent on which substep happened to run last.
|
||||
*/
|
||||
function sampleVelocities(frameDt) {
|
||||
const inv = frameDt > 1e-5 ? 1 / frameDt : 0;
|
||||
for (const part of order) {
|
||||
part.bone.matrixWorld.decompose(_wp, _wq, _ws);
|
||||
|
||||
part.linVel.subVectors(_wp, part.prevPos).multiplyScalar(inv);
|
||||
if (part.linVel.lengthSq() > MAX_LIN * MAX_LIN) part.linVel.setLength(MAX_LIN);
|
||||
|
||||
_prevQ.copy(part.prevQuat).invert();
|
||||
_dq.copy(_wq).multiply(_prevQ);
|
||||
if (_dq.w < 0) _dq.set(-_dq.x, -_dq.y, -_dq.z, -_dq.w); // shortest arc
|
||||
const angle = 2 * Math.acos(Math.min(1, _dq.w));
|
||||
if (angle > 1e-5) {
|
||||
const s = Math.sqrt(Math.max(1e-12, 1 - _dq.w * _dq.w));
|
||||
part.angVel.set(_dq.x / s, _dq.y / s, _dq.z / s).multiplyScalar(angle * inv);
|
||||
if (part.angVel.lengthSq() > MAX_ANG * MAX_ANG) part.angVel.setLength(MAX_ANG);
|
||||
} else part.angVel.set(0, 0, 0);
|
||||
|
||||
part.prevPos.copy(_wp);
|
||||
part.prevQuat.copy(_wq);
|
||||
}
|
||||
}
|
||||
|
||||
// Bone name -> the world quaternion its body currently reports.
|
||||
const bodyWorldQ = new Map();
|
||||
// Accumulated world quaternion per bone during the write-back walk.
|
||||
const accumQ = new Map();
|
||||
const _mq = new THREE.Quaternion();
|
||||
|
||||
/**
|
||||
* Read the physics bodies back onto the skeleton (limp mode).
|
||||
*
|
||||
* Two passes, because a bone's local rotation depends on its parent's *new*
|
||||
* world rotation. Reading `parent.matrixWorld` mid-walk would use last
|
||||
* frame's value and skew every limb down the chain.
|
||||
*
|
||||
* The walk also has to handle bones with no body of their own (root,
|
||||
* clavicles, toes): they keep their current local rotation and simply pass
|
||||
* the accumulated world rotation through. That matters because upperArm's
|
||||
* *bone* parent is the clavicle while its *joint* parent is spine3.
|
||||
*/
|
||||
const _moverQinv = new THREE.Quaternion();
|
||||
const _physWorld = new THREE.Quaternion();
|
||||
const _animWorld = new THREE.Quaternion();
|
||||
const _localTarget = new THREE.Quaternion();
|
||||
const _rootTarget = new THREE.Vector3();
|
||||
|
||||
/**
|
||||
* Write the physics pose onto the skeleton, blended against the pose the
|
||||
* animator just produced.
|
||||
*
|
||||
* `weight` 1 is a full ragdoll; anything between is the spring-damper
|
||||
* blend — the body is deflected by the blow but the animation still shows
|
||||
* through, and as the weight decays the skater recovers their stance.
|
||||
*
|
||||
* Blending happens in *world* space per bone and is converted back to a local
|
||||
* rotation afterwards. Slerping local rotations instead would compound down
|
||||
* the chain: a half-weight shoulder followed by a half-weight elbow does not
|
||||
* put the hand halfway between the two poses.
|
||||
*/
|
||||
function blendToSkeleton(moverMatrixInverse, weight = 1, { includeRoot = true } = {}) {
|
||||
if (weight <= 0.0005) return;
|
||||
const w = Math.min(1, weight);
|
||||
|
||||
bodyWorldQ.clear();
|
||||
accumQ.clear();
|
||||
for (const part of order) {
|
||||
const t = api.b3Body_GetTransform(part.body);
|
||||
bodyWorldQ.set(part.bone.name, _mq.set(t.q.v.x, t.q.v.y, t.q.v.z, t.q.s).clone());
|
||||
}
|
||||
|
||||
// The mover may be rotated, so body world rotations have to be brought into
|
||||
// the mover's frame before they become bone locals.
|
||||
_moverQinv.identity();
|
||||
if (moverMatrixInverse) _moverQinv.setFromRotationMatrix(moverMatrixInverse);
|
||||
|
||||
const walk = (bone, parentWorld) => {
|
||||
const phys = bodyWorldQ.get(bone.name);
|
||||
// The animated world rotation this bone would have had, given the already
|
||||
// blended parent above it.
|
||||
_animWorld.copy(parentWorld).multiply(bone.quaternion);
|
||||
let world;
|
||||
if (phys) {
|
||||
_physWorld.copy(_moverQinv).multiply(phys);
|
||||
world = _animWorld.clone().slerp(_physWorld, w);
|
||||
_pqi.copy(parentWorld).invert();
|
||||
_localTarget.copy(_pqi).multiply(world);
|
||||
bone.quaternion.copy(_localTarget);
|
||||
} else {
|
||||
world = _animWorld.clone();
|
||||
}
|
||||
accumQ.set(bone.name, world);
|
||||
for (const child of bone.children) if (child.isBone) walk(child, world);
|
||||
};
|
||||
|
||||
const rootBone = skelData.bones.root;
|
||||
const animRootQ = rootBone.quaternion.clone();
|
||||
rootBone.quaternion.identity();
|
||||
walk(rootBone, new THREE.Quaternion());
|
||||
if (w < 1) rootBone.quaternion.slerpQuaternions(animRootQ, rootBone.quaternion, w);
|
||||
|
||||
// The pelvis carries the rig's position; every other bone is rotation-only,
|
||||
// so the hierarchy keeps the limbs attached to it. Partial reactions leave
|
||||
// the root alone — displacing it slides the skater across the ice, which
|
||||
// reads as teleporting rather than as being hit.
|
||||
const pelvis = parts.pelvis;
|
||||
if (includeRoot && pelvis) {
|
||||
const t = api.b3Body_GetTransform(pelvis.body);
|
||||
_wp.set(t.p.x, t.p.y, t.p.z);
|
||||
if (moverMatrixInverse) _wp.applyMatrix4(moverMatrixInverse);
|
||||
_rootTarget.copy(_wp).sub(pelvis.bone.position);
|
||||
rootBone.position.lerp(_rootTarget, w);
|
||||
}
|
||||
}
|
||||
|
||||
/** Full ragdoll write-back. */
|
||||
function syncToSkeleton(moverMatrixInverse) {
|
||||
blendToSkeleton(moverMatrixInverse, 1, { includeRoot: true });
|
||||
}
|
||||
|
||||
/**
|
||||
* Snap the physics bodies onto the current skeleton pose.
|
||||
*
|
||||
* Needed when handing control back to animation: the bodies are wherever the
|
||||
* simulation left them, and driving a kinematic body toward a distant target
|
||||
* makes Box3D derive a huge velocity, which would fling anything it touches.
|
||||
*/
|
||||
function snapToSkeleton() {
|
||||
for (const part of order) {
|
||||
part.bone.matrixWorld.decompose(_wp, _wq, _ws);
|
||||
api.b3Body_SetTransform(part.body, vec3(_wp), quat(_wq));
|
||||
api.b3Body_SetLinearVelocity(part.body, { x: 0, y: 0, z: 0 });
|
||||
api.b3Body_SetAngularVelocity(part.body, { x: 0, y: 0, z: 0 });
|
||||
part.prevPos.copy(_wp);
|
||||
part.prevQuat.copy(_wq);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Modes:
|
||||
* 'driven' kinematic, chases the animation exactly
|
||||
* 'reacting' dynamic with stiff joints — deflects under a blow and is
|
||||
* expected to be blended back toward the animated pose
|
||||
* 'limp' dynamic and slack; gravity wins
|
||||
*/
|
||||
function setMode(next) {
|
||||
if (next === mode) return;
|
||||
const dynamic = next === 'limp' || next === 'reacting';
|
||||
if (!dynamic) snapToSkeleton();
|
||||
// Limbs only join the collision world while the rig is dynamic.
|
||||
//
|
||||
// A kinematic limb cannot be pushed, but it *can* push: a driven skater's
|
||||
// arm swinging through its stride would shove other skaters' proxy capsules
|
||||
// around, so an idle bystander could be checked by someone's elbow. Once
|
||||
// the rig goes dynamic that is exactly what we want — a falling body should
|
||||
// take people's legs out — so the mask is widened here rather than being
|
||||
// fixed once at build time.
|
||||
const mask = dynamic ? limpMask : drivenMask;
|
||||
for (const part of order) {
|
||||
if (part.filterMask !== mask) {
|
||||
_filter.categoryBits = filter.category;
|
||||
_filter.maskBits = mask;
|
||||
_filter.groupIndex = 0;
|
||||
api.b3Shape_SetFilter(part.shape, _filter, true);
|
||||
part.filterMask = mask;
|
||||
}
|
||||
api.b3Body_SetType(part.body, dynamic ? api.b3BodyType.b3_dynamicBody : api.b3BodyType.b3_kinematicBody);
|
||||
if (dynamic) {
|
||||
// Carry the animated motion across so the reaction continues the motion.
|
||||
api.b3Body_SetLinearVelocity(part.body, vec3(part.linVel));
|
||||
api.b3Body_SetAngularVelocity(part.body, vec3(part.angVel));
|
||||
if (next === 'reacting') {
|
||||
// Damping holds the flinch together without killing the impulse.
|
||||
// (1.6/2.2 made light hits die in place; recover via blend weight instead.)
|
||||
api.b3Body_SetLinearDamping(part.body, 0.85);
|
||||
api.b3Body_SetAngularDamping(part.body, 1.15);
|
||||
} else {
|
||||
api.b3Body_SetLinearDamping(part.body, 0.1);
|
||||
api.b3Body_SetAngularDamping(part.body, 0.25);
|
||||
}
|
||||
}
|
||||
api.b3Body_SetAwake(part.body, true);
|
||||
}
|
||||
mode = next;
|
||||
}
|
||||
|
||||
/** Apply a world-space impulse at a world point to one part. */
|
||||
function applyImpulse(partName, impulse, worldPoint) {
|
||||
const part = parts[partName];
|
||||
if (!part) return;
|
||||
api.b3Body_ApplyLinearImpulse(
|
||||
part.body,
|
||||
vec3(impulse),
|
||||
worldPoint ? vec3(worldPoint) : api.b3Body_GetPosition(part.body),
|
||||
true,
|
||||
);
|
||||
}
|
||||
|
||||
function applyTorqueImpulse(partName, torque) {
|
||||
const part = parts[partName];
|
||||
if (!part) return;
|
||||
api.b3Body_ApplyAngularImpulse(part.body, vec3(torque), true);
|
||||
}
|
||||
|
||||
/**
|
||||
* Total mass of the rig, for stagger thresholds. Uses the figures captured at
|
||||
* build time rather than querying the bodies, which report zero while kinematic.
|
||||
*/
|
||||
function totalMass() {
|
||||
let m = 0;
|
||||
for (const part of order) m += part.mass;
|
||||
return m;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sever a joint: the limb below it becomes independent debris still made of
|
||||
* the same bodies, so it keeps colliding and can be sent flying.
|
||||
*/
|
||||
function severJoint(childPartName) {
|
||||
const j = joints.find((x) => x.b === childPartName);
|
||||
if (!j || j.severed) return false;
|
||||
api.b3DestroyJoint(j.id, true);
|
||||
j.severed = true;
|
||||
const part = parts[childPartName];
|
||||
if (part) part.disabled = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
function partForRegion(region) {
|
||||
return order.filter((p) => p.region === region);
|
||||
}
|
||||
|
||||
/**
|
||||
* Write each capsule's segment into world space.
|
||||
*
|
||||
* Read off the bone matrices rather than off the Box3D bodies, so the answer
|
||||
* is correct in both modes: while driven the bodies chase the bones a substep
|
||||
* behind, and a hit resolved against last substep's pose picks the wrong limb
|
||||
* at speed. Reuses one array of scratch vectors — the caller must not hold on
|
||||
* to what it gets back.
|
||||
*/
|
||||
const _segments = order.map(() => ({
|
||||
part: null, a: new THREE.Vector3(), b: new THREE.Vector3(), radius: 0,
|
||||
}));
|
||||
function worldSegments() {
|
||||
for (let i = 0; i < order.length; i++) {
|
||||
const part = order[i];
|
||||
const seg = _segments[i];
|
||||
part.bone.updateWorldMatrix(true, false);
|
||||
seg.part = part;
|
||||
seg.a.copy(part.localA).applyMatrix4(part.bone.matrixWorld);
|
||||
seg.b.copy(part.localB).applyMatrix4(part.bone.matrixWorld);
|
||||
seg.radius = part.radius;
|
||||
}
|
||||
return _segments;
|
||||
}
|
||||
|
||||
function destroy() {
|
||||
for (const j of joints) if (!j.severed) api.b3DestroyJoint(j.id, false);
|
||||
for (const part of order) api.b3DestroyBody(part.body);
|
||||
}
|
||||
|
||||
return {
|
||||
parts,
|
||||
order,
|
||||
joints,
|
||||
get mode() { return mode; },
|
||||
get stiffness() { return stiffness; },
|
||||
setMode,
|
||||
setJointStiffness,
|
||||
sampleVelocities,
|
||||
syncFromSkeleton,
|
||||
syncToSkeleton,
|
||||
blendToSkeleton,
|
||||
snapToSkeleton,
|
||||
applyImpulse,
|
||||
applyTorqueImpulse,
|
||||
severJoint,
|
||||
partForRegion,
|
||||
worldSegments,
|
||||
totalMass,
|
||||
destroy,
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,189 @@
|
||||
import Box3DFactory from 'box3d.js';
|
||||
import { KIND, makeTag, readTag, rinkFilter, xyz } from './bridge.js';
|
||||
import { slotsShouldCollide } from './ragdoll.js';
|
||||
import { RINK, rinkOutline } from '../../shared/rink.js';
|
||||
|
||||
/**
|
||||
* Box3D world wrapper.
|
||||
*
|
||||
* Runs on a fixed timestep with an accumulator so the simulation stays
|
||||
* reproducible regardless of frame rate. That matters more here than it looks:
|
||||
* the skating sim reads its velocity back out of Box3D every substep, so a
|
||||
* variable step would make how hard you can carve depend on your frame rate.
|
||||
*/
|
||||
|
||||
export const FIXED_DT = 1 / 120;
|
||||
const MAX_SUBSTEPS = 6;
|
||||
|
||||
let b3 = null;
|
||||
|
||||
/** Load and initialise the wasm module. Safe to call more than once. */
|
||||
export async function initPhysics() {
|
||||
if (!b3) b3 = await Box3DFactory();
|
||||
return b3;
|
||||
}
|
||||
|
||||
export function getB3() {
|
||||
if (!b3) throw new Error('physics not initialised — await initPhysics() first');
|
||||
return b3;
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the rink: an ice slab and a ring of boards, both static.
|
||||
*
|
||||
* The boards are a ring of boxes rather than a mesh because a body slammed
|
||||
* into one should bounce off a flat face the way it would off real dasher
|
||||
* boards, and because a box ring is cheap enough that we can afford enough
|
||||
* segments for the corners to read as round.
|
||||
*/
|
||||
export function createPhysicsWorld({ gravity = -16 } = {}) {
|
||||
const api = getB3();
|
||||
|
||||
const wd = api.b3DefaultWorldDef();
|
||||
wd.gravity = xyz(0, gravity, 0);
|
||||
// Two skaters closing at 14 m/s combined will visibly interpenetrate at the
|
||||
// default contact stiffness — a fifth of a metre, which on bodies this size
|
||||
// reads as one skating through the other's shoulder. Stiffer contacts and a
|
||||
// faster push-out cost nothing at this body count.
|
||||
wd.contactHertz = 60;
|
||||
wd.contactDampingRatio = 8;
|
||||
wd.contactSpeed = 6;
|
||||
wd.enableContinuous = true;
|
||||
const world = api.b3CreateWorld(wd);
|
||||
api.b3World_SetHitEventThreshold(world, 1.2);
|
||||
|
||||
// Self-collision: ragdoll limbs enable custom filtering. Adjacent capsules
|
||||
// (and one skip) would fight the joints if they contacted; distant pairs
|
||||
// (hand vs torso, crossed legs) must still collide when limp.
|
||||
// Called only for awake dynamic pairs — exactly the limp case.
|
||||
api.b3World_SetCustomFilterCallback(world, (shapeA, shapeB) => {
|
||||
try {
|
||||
const matA = api.b3Shape_GetSurfaceMaterial(shapeA);
|
||||
const matB = api.b3Shape_GetSurfaceMaterial(shapeB);
|
||||
const a = readTag(matA.userMaterialId);
|
||||
const b = readTag(matB.userMaterialId);
|
||||
if (
|
||||
a.kind === KIND.BODY && b.kind === KIND.BODY
|
||||
&& a.skater === b.skater && a.skater !== 0xff
|
||||
) {
|
||||
return slotsShouldCollide(a.slot, b.slot);
|
||||
}
|
||||
} catch {
|
||||
// Embind can throw if a shape was destroyed mid-step; default to collide.
|
||||
}
|
||||
return true;
|
||||
});
|
||||
|
||||
const rink = rinkFilter();
|
||||
|
||||
// ---- ice ---------------------------------------------------------------
|
||||
const iceDef = api.b3DefaultBodyDef();
|
||||
iceDef.position = xyz(0, -0.5, 0);
|
||||
const ice = api.b3CreateBody(world, iceDef);
|
||||
const iceShape = api.b3DefaultShapeDef();
|
||||
// Ice, not sand. The skating sim owns blade friction entirely; anything the
|
||||
// solver adds here on top of that is a second, invisible drag term.
|
||||
iceShape.baseMaterial.friction = 0.04;
|
||||
iceShape.baseMaterial.restitution = 0.0;
|
||||
iceShape.baseMaterial.userMaterialId = makeTag(KIND.RINK, 0xff, 0);
|
||||
iceShape.filter.categoryBits = rink.category;
|
||||
iceShape.filter.maskBits = rink.mask;
|
||||
api.b3CreateBoxShape(ice, iceShape, RINK.halfX + 4, 0.5, RINK.halfZ + 4);
|
||||
|
||||
// ---- boards ------------------------------------------------------------
|
||||
const boardShape = api.b3DefaultShapeDef();
|
||||
boardShape.baseMaterial.friction = 0.28;
|
||||
// Dasher boards flex and eat most of the impact. A lively wall would ping
|
||||
// skaters back into open ice and read as rubber.
|
||||
boardShape.baseMaterial.restitution = 0.1;
|
||||
boardShape.baseMaterial.userMaterialId = makeTag(KIND.RINK, 0xff, 1);
|
||||
boardShape.filter.categoryBits = rink.category;
|
||||
boardShape.filter.maskBits = rink.mask;
|
||||
|
||||
const outline = rinkOutline(10);
|
||||
const boardBodies = [];
|
||||
const halfH = RINK.boardHeight / 2;
|
||||
for (let i = 0; i < outline.length; i++) {
|
||||
const a = outline[i];
|
||||
const b = outline[(i + 1) % outline.length];
|
||||
const dx = b.x - a.x;
|
||||
const dz = b.z - a.z;
|
||||
const len = Math.hypot(dx, dz);
|
||||
if (len < 1e-4) continue;
|
||||
// Each segment is a thin box centred on the chord, its local +Z along the
|
||||
// wall. Overlapping the ends slightly (len/2 + thickness) keeps a skater
|
||||
// from catching the seam between two corner segments.
|
||||
const yaw = Math.atan2(dx, dz);
|
||||
const bd = api.b3DefaultBodyDef();
|
||||
// Pushed half a thickness outward so the *inner* face sits on the outline.
|
||||
const nx = dz / len;
|
||||
const nz = -dx / len;
|
||||
const thickness = 0.2;
|
||||
bd.position = xyz(
|
||||
(a.x + b.x) / 2 - nx * thickness,
|
||||
halfH,
|
||||
(a.z + b.z) / 2 - nz * thickness,
|
||||
);
|
||||
bd.rotation = { v: { x: 0, y: Math.sin(yaw / 2), z: 0 }, s: Math.cos(yaw / 2) };
|
||||
const seg = api.b3CreateBody(world, bd);
|
||||
api.b3CreateBoxShape(seg, boardShape, thickness, halfH, len / 2 + thickness);
|
||||
boardBodies.push(seg);
|
||||
}
|
||||
|
||||
// ---- event plumbing ----------------------------------------------------
|
||||
const eventsBuffer = api.createEventsBuffer();
|
||||
const hitOut = api.createContactHitEvent();
|
||||
const beginOut = api.createContactTouchEvent();
|
||||
|
||||
let accumulator = 0;
|
||||
let stepCount = 0;
|
||||
const hitListeners = new Set();
|
||||
const beginListeners = new Set();
|
||||
|
||||
function pumpEvents() {
|
||||
api.getEvents(eventsBuffer, world);
|
||||
const nHits = api.getNumContactHitEvents(eventsBuffer);
|
||||
for (let i = 0; i < nHits; i++) {
|
||||
api.getContactHitEventAt(hitOut, eventsBuffer, i);
|
||||
for (const fn of hitListeners) fn(hitOut);
|
||||
}
|
||||
const nBegin = api.getNumContactBeginEvents(eventsBuffer);
|
||||
for (let i = 0; i < nBegin; i++) {
|
||||
api.getContactBeginEventAt(beginOut, eventsBuffer, i);
|
||||
for (const fn of beginListeners) fn(beginOut);
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
api,
|
||||
world,
|
||||
ice,
|
||||
boardBodies,
|
||||
get stepCount() { return stepCount; },
|
||||
|
||||
/** Advance by real elapsed time, stepping the fixed simulation as needed. */
|
||||
step(dt, onPreStep) {
|
||||
accumulator += Math.min(dt, 0.25);
|
||||
let steps = 0;
|
||||
while (accumulator >= FIXED_DT && steps < MAX_SUBSTEPS) {
|
||||
if (onPreStep) onPreStep(FIXED_DT);
|
||||
api.b3World_Step(world, FIXED_DT, 4);
|
||||
pumpEvents();
|
||||
accumulator -= FIXED_DT;
|
||||
steps++;
|
||||
stepCount++;
|
||||
}
|
||||
// Bail out rather than spiral if we ever fall badly behind.
|
||||
if (steps === MAX_SUBSTEPS) accumulator = 0;
|
||||
return steps;
|
||||
},
|
||||
|
||||
onHit(fn) { hitListeners.add(fn); return () => hitListeners.delete(fn); },
|
||||
onBeginTouch(fn) { beginListeners.add(fn); return () => beginListeners.delete(fn); },
|
||||
|
||||
destroy() {
|
||||
api.destroyEventsBuffer(eventsBuffer);
|
||||
api.b3DestroyWorld(world);
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,140 @@
|
||||
import * as THREE from 'three';
|
||||
import { RINK } from '../../shared/rink.js';
|
||||
import { clamp, wrapAngle } from '../../shared/scalar.js';
|
||||
|
||||
/**
|
||||
* Broadcast camera.
|
||||
*
|
||||
* Two modes, because they answer different questions about the spike:
|
||||
* 'broadcast' sits off the side boards and pans with the action — the view
|
||||
* you judge whether the skating reads from.
|
||||
* 'follow' rides behind one skater, which is the only way to tell whether
|
||||
* the stride and the carve actually line up with the motion.
|
||||
*
|
||||
* Drag orbits, wheel zooms, and the target is smoothed rather than snapped so
|
||||
* a bot changing direction does not whip the camera.
|
||||
*/
|
||||
export function createCamera(canvas, aspect) {
|
||||
const camera = new THREE.PerspectiveCamera(52, aspect, 0.1, 400);
|
||||
|
||||
const state = {
|
||||
mode: 'broadcast',
|
||||
/** Orbit angles, radians. */
|
||||
yaw: 0,
|
||||
pitch: 0.62,
|
||||
distance: 34,
|
||||
target: new THREE.Vector3(),
|
||||
/** Index of the skater 'follow' rides, or null. */
|
||||
followIndex: null,
|
||||
};
|
||||
|
||||
const _want = new THREE.Vector3();
|
||||
const _offset = new THREE.Vector3();
|
||||
|
||||
let dragging = false;
|
||||
let lastX = 0;
|
||||
let lastY = 0;
|
||||
|
||||
canvas.addEventListener('pointerdown', (e) => {
|
||||
dragging = true;
|
||||
lastX = e.clientX;
|
||||
lastY = e.clientY;
|
||||
canvas.setPointerCapture(e.pointerId);
|
||||
});
|
||||
canvas.addEventListener('pointermove', (e) => {
|
||||
if (!dragging) return;
|
||||
// Keep yaw on the circle. Unbounded accumulation is what broke the follow
|
||||
// chase after a few spins: JS `%` on a large negative offset is not a
|
||||
// positive modulo, so the "shortest turn" picked the long way round and
|
||||
// the orbit fought the stick until the skater felt stuck.
|
||||
state.yaw = wrapAngle(state.yaw - (e.clientX - lastX) * 0.005);
|
||||
state.pitch = clamp(state.pitch - (e.clientY - lastY) * 0.004, 0.08, 1.45);
|
||||
lastX = e.clientX;
|
||||
lastY = e.clientY;
|
||||
});
|
||||
const endDrag = (e) => {
|
||||
dragging = false;
|
||||
if (e.pointerId != null && canvas.hasPointerCapture?.(e.pointerId)) {
|
||||
canvas.releasePointerCapture(e.pointerId);
|
||||
}
|
||||
};
|
||||
canvas.addEventListener('pointerup', endDrag);
|
||||
canvas.addEventListener('pointercancel', endDrag);
|
||||
canvas.addEventListener('wheel', (e) => {
|
||||
e.preventDefault();
|
||||
state.distance = clamp(state.distance * (1 + e.deltaY * 0.0012), 6, 90);
|
||||
}, { passive: false });
|
||||
|
||||
return {
|
||||
camera,
|
||||
state,
|
||||
|
||||
resize(w, h) {
|
||||
camera.aspect = w / h;
|
||||
camera.updateProjectionMatrix();
|
||||
},
|
||||
|
||||
/** Cycle broadcast → follow each skater → broadcast. */
|
||||
cycleMode(count) {
|
||||
if (state.mode === 'broadcast') {
|
||||
state.mode = 'follow';
|
||||
state.followIndex = 0;
|
||||
} else if (state.followIndex + 1 < count) {
|
||||
state.followIndex += 1;
|
||||
} else {
|
||||
state.mode = 'broadcast';
|
||||
state.followIndex = null;
|
||||
}
|
||||
state.distance = state.mode === 'follow' ? 9 : 34;
|
||||
state.pitch = state.mode === 'follow' ? 0.3 : 0.62;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {number} dt
|
||||
* @param {{x:number,z:number,yaw:number}[]} skaters
|
||||
*/
|
||||
update(dt, skaters) {
|
||||
// How hard the camera chases its target. Broadcast wants to be lazy;
|
||||
// follow cannot be, because a skater doing 7 m/s outruns a soft lerp and
|
||||
// ends up drifting to the edge of frame while the camera trails behind.
|
||||
let chase = 2.4;
|
||||
if (state.mode === 'follow' && skaters[state.followIndex]) {
|
||||
const s = skaters[state.followIndex];
|
||||
chase = 11;
|
||||
_want.set(s.x, 1.1, s.z);
|
||||
// Ease the orbit around behind whoever we are following, but let a
|
||||
// drag override it — the yaw chases only while the pointer is idle.
|
||||
if (!dragging) {
|
||||
const behind = s.yaw + Math.PI;
|
||||
// wrapAngle, not `%`: see the pointermove note. The old
|
||||
// `((d + 3π) % 2π) - π` form only works while yaw stays near zero.
|
||||
state.yaw = wrapAngle(state.yaw + wrapAngle(behind - state.yaw) * Math.min(1, 1.6 * dt));
|
||||
}
|
||||
} else {
|
||||
// Centroid of everyone, clamped so the camera never leaves the barn.
|
||||
_want.set(0, 0.8, 0);
|
||||
if (skaters.length) {
|
||||
let x = 0;
|
||||
let z = 0;
|
||||
for (const s of skaters) {
|
||||
x += s.x;
|
||||
z += s.z;
|
||||
}
|
||||
_want.set(x / skaters.length, 0.8, z / skaters.length);
|
||||
}
|
||||
_want.x = clamp(_want.x, -RINK.halfX * 0.6, RINK.halfX * 0.6);
|
||||
_want.z = clamp(_want.z, -RINK.halfZ * 0.6, RINK.halfZ * 0.6);
|
||||
}
|
||||
state.target.lerp(_want, Math.min(1, chase * dt));
|
||||
|
||||
const cp = Math.cos(state.pitch);
|
||||
_offset.set(
|
||||
Math.sin(state.yaw) * cp,
|
||||
Math.sin(state.pitch),
|
||||
Math.cos(state.yaw) * cp,
|
||||
).multiplyScalar(state.distance);
|
||||
camera.position.copy(state.target).add(_offset);
|
||||
camera.lookAt(state.target);
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
import * as THREE from 'three';
|
||||
import { PART } from '../character/body.js';
|
||||
|
||||
/**
|
||||
* Materials for one skater.
|
||||
*
|
||||
* Placeholder by design: spike 1 renders the bare procedural body from Ludus,
|
||||
* team-tinted so three agents can be told apart at a glance. Real gear is a
|
||||
* later swap onto the same meshes. The only thing that has to hold now is that
|
||||
* every skater owns its own material instances, so recolouring one never
|
||||
* touches another.
|
||||
*/
|
||||
|
||||
export const TEAMS = [
|
||||
{ name: 'home', jersey: 0xb8342c, accent: 0xf0e6d2 },
|
||||
{ name: 'away', jersey: 0x2b5d8f, accent: 0xf0e6d2 },
|
||||
{ name: 'third', jersey: 0x3d8c5a, accent: 0xf0e6d2 },
|
||||
];
|
||||
|
||||
const SKIN_TONES = [0xd8a07a, 0xc98d63, 0xa86b45, 0x8a5334, 0xe8bd9a];
|
||||
const PANTS = 0x1c1f26;
|
||||
|
||||
export function buildMaterials(rng, teamIndex = 0) {
|
||||
const team = TEAMS[teamIndex % TEAMS.length];
|
||||
const skinColor = rng.pick(SKIN_TONES);
|
||||
|
||||
// One material, vertex-coloured. `paintKit` writes the colours; keeping it to
|
||||
// a single material means the skinned body is still one draw call.
|
||||
const skin = new THREE.MeshStandardMaterial({
|
||||
color: 0xffffff,
|
||||
vertexColors: true,
|
||||
roughness: 0.68,
|
||||
metalness: 0.03,
|
||||
});
|
||||
skin.userData.skinColor = new THREE.Color(skinColor);
|
||||
|
||||
return { skin, team, teamIndex: teamIndex % TEAMS.length, skinColor };
|
||||
}
|
||||
|
||||
/**
|
||||
* Write the placeholder kit into the geometry's vertex colours.
|
||||
*
|
||||
* The loft carries `aPart` (which limb) and `aT` (0..1 along it), so the kit
|
||||
* can be blocked in without any texture work: sweater over the torso and arms,
|
||||
* pants over the hips and thighs, socks in the team colour down the shin.
|
||||
*
|
||||
* Overwrites the skin-weight heatmap `computeSkin` leaves behind; that array is
|
||||
* kept on `userData` so the debug view can still be switched back on.
|
||||
*/
|
||||
export function paintKit(geo, { jersey, skinColor }) {
|
||||
const partAttr = geo.attributes.aPart;
|
||||
const tAttr = geo.attributes.aT;
|
||||
const existing = geo.attributes.color;
|
||||
if (existing && !geo.userData.heatColors) geo.userData.heatColors = existing.array.slice();
|
||||
|
||||
const n = geo.attributes.position.count;
|
||||
const colors = new Float32Array(n * 3);
|
||||
const c = new THREE.Color();
|
||||
const flesh = new THREE.Color(skinColor);
|
||||
const sweater = new THREE.Color(jersey);
|
||||
const pants = new THREE.Color(PANTS);
|
||||
|
||||
for (let i = 0; i < n; i++) {
|
||||
const part = partAttr ? partAttr.getX(i) : PART.TORSO;
|
||||
const t = tAttr ? tAttr.getX(i) : 0.5;
|
||||
if (part === PART.HEAD) {
|
||||
// Helmet from the crown down to the brow; face left bare.
|
||||
c.copy(t > 0.62 ? sweater : flesh);
|
||||
} else if (part === PART.TORSO) {
|
||||
c.copy(t < 0.16 ? pants : sweater);
|
||||
} else if (part === PART.ARM_L || part === PART.ARM_R) {
|
||||
// Sleeve, then a dark glove at the cuff.
|
||||
c.copy(t > 0.88 ? pants : sweater);
|
||||
} else {
|
||||
// Leg: pants to mid-thigh, team sock below, black skate at the ankle.
|
||||
c.copy(t < 0.36 ? pants : t > 0.87 ? pants : sweater);
|
||||
}
|
||||
colors[i * 3] = c.r;
|
||||
colors[i * 3 + 1] = c.g;
|
||||
colors[i * 3 + 2] = c.b;
|
||||
}
|
||||
geo.setAttribute('color', new THREE.BufferAttribute(colors, 3));
|
||||
}
|
||||
|
||||
/**
|
||||
* Base layer for a skater who is actually wearing gear.
|
||||
*
|
||||
* `paintKit` draws the kit *onto* the body, which is the right answer while the
|
||||
* body is all there is. Once a jersey, pants and socks are real meshes over the
|
||||
* top, painting a second jersey underneath only shows up as the wrong colour
|
||||
* peeking out at a collar or a cuff. So: face and neck bare, everything else
|
||||
* the dark under layer a player has on beneath the pads.
|
||||
*/
|
||||
export function paintUnderLayer(geo, { skinColor, under = 0x24262c }) {
|
||||
const partAttr = geo.attributes.aPart;
|
||||
const existing = geo.attributes.color;
|
||||
if (existing && !geo.userData.heatColors) geo.userData.heatColors = existing.array.slice();
|
||||
|
||||
const n = geo.attributes.position.count;
|
||||
const colors = new Float32Array(n * 3);
|
||||
const flesh = new THREE.Color(skinColor);
|
||||
const base = new THREE.Color(under);
|
||||
|
||||
for (let i = 0; i < n; i++) {
|
||||
const part = partAttr ? partAttr.getX(i) : PART.TORSO;
|
||||
const c = part === PART.HEAD ? flesh : base;
|
||||
colors[i * 3] = c.r;
|
||||
colors[i * 3 + 1] = c.g;
|
||||
colors[i * 3 + 2] = c.b;
|
||||
}
|
||||
geo.setAttribute('color', new THREE.BufferAttribute(colors, 3));
|
||||
}
|
||||
|
||||
/** Shared rink materials — one set for the whole scene, not per skater. */
|
||||
export function buildRinkMaterials() {
|
||||
return {
|
||||
ice: new THREE.MeshStandardMaterial({
|
||||
color: 0xeaf2fa,
|
||||
roughness: 0.16,
|
||||
metalness: 0.0,
|
||||
}),
|
||||
lines: new THREE.MeshBasicMaterial({ color: 0xffffff }),
|
||||
boards: new THREE.MeshStandardMaterial({
|
||||
color: 0xf2f2f0,
|
||||
roughness: 0.5,
|
||||
metalness: 0.02,
|
||||
side: THREE.DoubleSide,
|
||||
}),
|
||||
kickplate: new THREE.MeshStandardMaterial({
|
||||
color: 0xd6c33c,
|
||||
roughness: 0.6,
|
||||
side: THREE.DoubleSide,
|
||||
}),
|
||||
glass: new THREE.MeshStandardMaterial({
|
||||
color: 0xc4dcea,
|
||||
roughness: 0.06,
|
||||
metalness: 0,
|
||||
transparent: true,
|
||||
opacity: 0.1,
|
||||
side: THREE.DoubleSide,
|
||||
depthWrite: false,
|
||||
}),
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,216 @@
|
||||
import * as THREE from 'three';
|
||||
import { MARKINGS, RINK, rinkOutline } from '../../shared/rink.js';
|
||||
import { buildRinkMaterials } from './materials.js';
|
||||
|
||||
/**
|
||||
* The rendered rink.
|
||||
*
|
||||
* Geometry comes from the same `rinkOutline` the physics boards are built
|
||||
* from, so the wall a skater bounces off is the wall they can see — the single
|
||||
* most annoying class of bug to chase in a game like this, and free to avoid.
|
||||
*
|
||||
* Markings are drawn into a canvas texture rather than as meshes. Blue lines,
|
||||
* circles and dots as geometry means a dozen extra draw calls and z-fighting
|
||||
* against the ice; one texture is faster and easier to iterate on.
|
||||
*/
|
||||
|
||||
const PIXELS_PER_METRE = 22;
|
||||
|
||||
function markingsTexture() {
|
||||
const w = Math.round(RINK.halfX * 2 * PIXELS_PER_METRE);
|
||||
const h = Math.round(RINK.halfZ * 2 * PIXELS_PER_METRE);
|
||||
const canvas = document.createElement('canvas');
|
||||
canvas.width = w;
|
||||
canvas.height = h;
|
||||
const ctx = canvas.getContext('2d');
|
||||
|
||||
// Canvas space: +x right is rink +X, +y down is rink +Z.
|
||||
const tx = (x) => (x + RINK.halfX) * PIXELS_PER_METRE;
|
||||
const tz = (z) => (z + RINK.halfZ) * PIXELS_PER_METRE;
|
||||
const m = (v) => v * PIXELS_PER_METRE;
|
||||
|
||||
ctx.fillStyle = '#f2f7fc';
|
||||
ctx.fillRect(0, 0, w, h);
|
||||
|
||||
const vline = (x, colour, widthM) => {
|
||||
ctx.strokeStyle = colour;
|
||||
ctx.lineWidth = m(widthM);
|
||||
ctx.beginPath();
|
||||
ctx.moveTo(tx(x), 0);
|
||||
ctx.lineTo(tx(x), h);
|
||||
ctx.stroke();
|
||||
};
|
||||
const circle = (x, z, r, colour, widthM, fill = false) => {
|
||||
ctx.beginPath();
|
||||
ctx.arc(tx(x), tz(z), m(r), 0, Math.PI * 2);
|
||||
if (fill) {
|
||||
ctx.fillStyle = colour;
|
||||
ctx.fill();
|
||||
} else {
|
||||
ctx.strokeStyle = colour;
|
||||
ctx.lineWidth = m(widthM);
|
||||
ctx.stroke();
|
||||
}
|
||||
};
|
||||
|
||||
const RED = '#c8322c';
|
||||
const BLUE = '#2f5fa8';
|
||||
|
||||
vline(0, RED, 0.3);
|
||||
vline(-MARKINGS.blueLine, BLUE, 0.3);
|
||||
vline(MARKINGS.blueLine, BLUE, 0.3);
|
||||
vline(-MARKINGS.goalLine, RED, 0.06);
|
||||
vline(MARKINGS.goalLine, RED, 0.06);
|
||||
|
||||
circle(0, 0, MARKINGS.centreCircleR, BLUE, 0.06);
|
||||
circle(0, 0, 0.3, BLUE, 0, true);
|
||||
|
||||
// Four end-zone faceoff circles plus the two neutral-zone dots.
|
||||
for (const sx of [-1, 1]) {
|
||||
for (const sz of [-1, 1]) {
|
||||
circle(sx * MARKINGS.zoneDotX, sz * MARKINGS.faceoffDotZ, MARKINGS.faceoffCircleR, RED, 0.06);
|
||||
circle(sx * MARKINGS.zoneDotX, sz * MARKINGS.faceoffDotZ, 0.3, RED, 0, true);
|
||||
circle(sx * MARKINGS.faceoffDotX, sz * MARKINGS.faceoffDotZ, 0.3, RED, 0, true);
|
||||
}
|
||||
}
|
||||
|
||||
// Goal creases, as filled arcs facing centre ice.
|
||||
for (const sx of [-1, 1]) {
|
||||
ctx.beginPath();
|
||||
ctx.arc(tx(sx * MARKINGS.goalLine), tz(0), m(1.83), sx > 0 ? Math.PI / 2 : -Math.PI / 2, sx > 0 ? Math.PI * 1.5 : Math.PI / 2);
|
||||
ctx.closePath();
|
||||
ctx.fillStyle = 'rgba(120, 175, 225, 0.5)';
|
||||
ctx.fill();
|
||||
ctx.strokeStyle = RED;
|
||||
ctx.lineWidth = m(0.06);
|
||||
ctx.stroke();
|
||||
}
|
||||
|
||||
const tex = new THREE.CanvasTexture(canvas);
|
||||
tex.colorSpace = THREE.SRGBColorSpace;
|
||||
tex.anisotropy = 8;
|
||||
return tex;
|
||||
}
|
||||
|
||||
/**
|
||||
* Extrude the board outline into a wall.
|
||||
*
|
||||
* Built as one non-indexed strip: the outline is a closed loop, so a wall is
|
||||
* two triangles per segment and there is no reason to pay for a Shape/Extrude
|
||||
* pass or for the corner mitring it would do.
|
||||
*/
|
||||
function boardBand(outline, y0, y1, inset = 0) {
|
||||
const pos = [];
|
||||
const uv = [];
|
||||
const n = outline.length;
|
||||
for (let i = 0; i < n; i++) {
|
||||
const a = outline[i];
|
||||
const b = outline[(i + 1) % n];
|
||||
// Inset pushes the band outward along the local normal, so the glass can
|
||||
// sit flush on top of the boards rather than intersecting them.
|
||||
const dx = b.x - a.x;
|
||||
const dz = b.z - a.z;
|
||||
const len = Math.hypot(dx, dz) || 1;
|
||||
const nx = (dz / len) * inset;
|
||||
const nz = (-dx / len) * inset;
|
||||
const ax = a.x - nx;
|
||||
const az = a.z - nz;
|
||||
const bx = b.x - nx;
|
||||
const bz = b.z - nz;
|
||||
const u0 = i / n;
|
||||
const u1 = (i + 1) / n;
|
||||
pos.push(ax, y0, az, bx, y0, bz, bx, y1, bz);
|
||||
pos.push(ax, y0, az, bx, y1, bz, ax, y1, az);
|
||||
uv.push(u0, 0, u1, 0, u1, 1, u0, 0, u1, 1, u0, 1);
|
||||
}
|
||||
const g = new THREE.BufferGeometry();
|
||||
g.setAttribute('position', new THREE.Float32BufferAttribute(pos, 3));
|
||||
g.setAttribute('uv', new THREE.Float32BufferAttribute(uv, 2));
|
||||
g.computeVertexNormals();
|
||||
return g;
|
||||
}
|
||||
|
||||
/** The puck mesh — a black disc, driven from the Box3D body each frame. */
|
||||
export function buildPuckMesh(scene, { radius, thickness }) {
|
||||
const mesh = new THREE.Mesh(
|
||||
new THREE.CylinderGeometry(radius, radius, thickness, 20),
|
||||
new THREE.MeshStandardMaterial({ color: 0x0b0b0d, roughness: 0.72, metalness: 0.02 }),
|
||||
);
|
||||
mesh.castShadow = true;
|
||||
mesh.receiveShadow = true;
|
||||
// A regulation puck is 76 mm across, which is a handful of pixels from the
|
||||
// broadcast camera. The ring is a readability aid, not decoration — without
|
||||
// something to catch the eye the puck is genuinely impossible to follow.
|
||||
const ring = new THREE.Mesh(
|
||||
new THREE.RingGeometry(radius * 1.6, radius * 2.4, 24),
|
||||
new THREE.MeshBasicMaterial({
|
||||
color: 0xffd166, transparent: true, opacity: 0.45, depthWrite: false,
|
||||
}),
|
||||
);
|
||||
ring.rotation.x = -Math.PI / 2;
|
||||
ring.position.y = -thickness / 2 + 0.002;
|
||||
ring.renderOrder = 1;
|
||||
mesh.add(ring);
|
||||
scene.add(mesh);
|
||||
return { mesh, ring };
|
||||
}
|
||||
|
||||
export function buildRink(scene) {
|
||||
const mats = buildRinkMaterials();
|
||||
const group = new THREE.Group();
|
||||
group.name = 'rink';
|
||||
|
||||
// ---- ice ---------------------------------------------------------------
|
||||
// A plane clipped to the rounded rectangle, so the surface ends at the
|
||||
// boards instead of running under them.
|
||||
const shape = new THREE.Shape();
|
||||
const outline = rinkOutline(16);
|
||||
shape.moveTo(outline[0].x, outline[0].z);
|
||||
for (let i = 1; i < outline.length; i++) shape.lineTo(outline[i].x, outline[i].z);
|
||||
shape.closePath();
|
||||
const iceGeo = new THREE.ShapeGeometry(shape, 24);
|
||||
// ShapeGeometry lives in XY; lay it flat, then rebuild UVs so the markings
|
||||
// texture maps to rink coordinates rather than to the shape's bounding box.
|
||||
iceGeo.rotateX(-Math.PI / 2);
|
||||
const p = iceGeo.attributes.position;
|
||||
const uv = new Float32Array(p.count * 2);
|
||||
for (let i = 0; i < p.count; i++) {
|
||||
uv[i * 2] = (p.getX(i) + RINK.halfX) / (RINK.halfX * 2);
|
||||
uv[i * 2 + 1] = 1 - (p.getZ(i) + RINK.halfZ) / (RINK.halfZ * 2);
|
||||
}
|
||||
iceGeo.setAttribute('uv', new THREE.BufferAttribute(uv, 2));
|
||||
mats.ice.map = markingsTexture();
|
||||
const ice = new THREE.Mesh(iceGeo, mats.ice);
|
||||
ice.receiveShadow = true;
|
||||
group.add(ice);
|
||||
|
||||
// ---- boards, kickplate, glass ------------------------------------------
|
||||
const boards = new THREE.Mesh(boardBand(outline, 0.22, RINK.boardHeight), mats.boards);
|
||||
boards.receiveShadow = true;
|
||||
group.add(boards);
|
||||
|
||||
const kick = new THREE.Mesh(boardBand(outline, 0, 0.22), mats.kickplate);
|
||||
group.add(kick);
|
||||
|
||||
const glass = new THREE.Mesh(
|
||||
boardBand(outline, RINK.boardHeight, RINK.boardHeight + RINK.glassHeight, 0.02),
|
||||
mats.glass,
|
||||
);
|
||||
glass.renderOrder = 2;
|
||||
group.add(glass);
|
||||
|
||||
// ---- surround ----------------------------------------------------------
|
||||
// A dark apron so the rink does not float in the void when the camera swings
|
||||
// low. Cheap, and it stops the horizon from reading as a bug.
|
||||
const apron = new THREE.Mesh(
|
||||
new THREE.PlaneGeometry(RINK.halfX * 4, RINK.halfZ * 6),
|
||||
new THREE.MeshStandardMaterial({ color: 0x14181f, roughness: 0.95 }),
|
||||
);
|
||||
apron.rotation.x = -Math.PI / 2;
|
||||
apron.position.y = -0.05;
|
||||
apron.receiveShadow = true;
|
||||
group.add(apron);
|
||||
|
||||
scene.add(group);
|
||||
return { group, materials: mats };
|
||||
}
|
||||
@@ -0,0 +1,760 @@
|
||||
import * as THREE from 'three';
|
||||
import { createSkater } from '../character/skater.js';
|
||||
import { createGoalie } from '../character/goalie.js';
|
||||
import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
|
||||
|
||||
/**
|
||||
* img2mesh — isolated character studio for equipment + animation iteration.
|
||||
*
|
||||
* No match, no physics, no AI. Just a skater and a goalie on a ground plane,
|
||||
* pose presets, fixed camera views, and a `window.img2mesh` API the headless
|
||||
* capture tool drives to dump a shot sheet.
|
||||
*
|
||||
* Open: http://localhost:5174/character.html
|
||||
* CLI: npm run img2mesh
|
||||
*/
|
||||
|
||||
const canvas = document.getElementById('stage');
|
||||
const boot = document.getElementById('boot');
|
||||
const hud = document.getElementById('hud');
|
||||
const subjectSel = document.getElementById('subject');
|
||||
const poseSel = document.getElementById('pose');
|
||||
const viewSel = document.getElementById('view');
|
||||
|
||||
// ---- renderer / scene -----------------------------------------------------
|
||||
const renderer = new THREE.WebGLRenderer({ canvas, antialias: true, powerPreference: 'high-performance' });
|
||||
renderer.shadowMap.enabled = true;
|
||||
renderer.shadowMap.type = THREE.PCFShadowMap;
|
||||
renderer.toneMapping = THREE.ACESFilmicToneMapping;
|
||||
renderer.toneMappingExposure = 1.1;
|
||||
|
||||
const scene = new THREE.Scene();
|
||||
scene.background = new THREE.Color(0x0c1018);
|
||||
scene.fog = new THREE.Fog(0x0c1018, 18, 40);
|
||||
|
||||
scene.add(new THREE.HemisphereLight(0xe8f0fa, 0x1a2030, 1.35));
|
||||
const key = new THREE.DirectionalLight(0xffffff, 1.7);
|
||||
key.position.set(4, 10, 6);
|
||||
key.castShadow = true;
|
||||
key.shadow.mapSize.set(2048, 2048);
|
||||
key.shadow.camera.near = 1;
|
||||
key.shadow.camera.far = 30;
|
||||
key.shadow.camera.left = -6;
|
||||
key.shadow.camera.right = 6;
|
||||
key.shadow.camera.top = 6;
|
||||
key.shadow.camera.bottom = -6;
|
||||
key.shadow.bias = -0.0004;
|
||||
scene.add(key);
|
||||
const fill = new THREE.DirectionalLight(0xa8c8e8, 0.55);
|
||||
fill.position.set(-6, 5, -4);
|
||||
scene.add(fill);
|
||||
const rim = new THREE.DirectionalLight(0xffe0c0, 0.35);
|
||||
rim.position.set(2, 3, -8);
|
||||
scene.add(rim);
|
||||
|
||||
// Ground grid — reads scale and foot contact without a full rink.
|
||||
const ground = new THREE.Mesh(
|
||||
new THREE.CircleGeometry(8, 48),
|
||||
new THREE.MeshStandardMaterial({ color: 0x1a2430, roughness: 0.92, metalness: 0.05 }),
|
||||
);
|
||||
ground.rotation.x = -Math.PI / 2;
|
||||
ground.receiveShadow = true;
|
||||
scene.add(ground);
|
||||
const grid = new THREE.GridHelper(10, 20, 0x3a5a78, 0x1e3044);
|
||||
grid.position.y = 0.002;
|
||||
scene.add(grid);
|
||||
|
||||
// Height markers so pad/hand/head heights are obvious.
|
||||
for (const h of [0.5, 1.0, 1.5, 2.0]) {
|
||||
const ring = new THREE.Mesh(
|
||||
new THREE.RingGeometry(0.35, 0.38, 32),
|
||||
new THREE.MeshBasicMaterial({ color: 0x2a4058, side: THREE.DoubleSide, transparent: true, opacity: 0.5 }),
|
||||
);
|
||||
ring.rotation.x = -Math.PI / 2;
|
||||
ring.position.y = h;
|
||||
scene.add(ring);
|
||||
}
|
||||
|
||||
const camera = new THREE.PerspectiveCamera(40, 1, 0.05, 80);
|
||||
const controls = new OrbitControls(camera, canvas);
|
||||
controls.enableDamping = true;
|
||||
controls.dampingFactor = 0.08;
|
||||
controls.target.set(0, 0.9, 0);
|
||||
controls.minDistance = 1.2;
|
||||
controls.maxDistance = 14;
|
||||
controls.maxPolarAngle = Math.PI * 0.49;
|
||||
|
||||
function resize() {
|
||||
const w = window.innerWidth;
|
||||
const h = window.innerHeight;
|
||||
renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
|
||||
renderer.setSize(w, h);
|
||||
camera.aspect = w / h;
|
||||
camera.updateProjectionMatrix();
|
||||
}
|
||||
window.addEventListener('resize', resize);
|
||||
resize();
|
||||
|
||||
// ---- subjects -------------------------------------------------------------
|
||||
/** @type {ReturnType<typeof createSkater> | null} */
|
||||
let player = null;
|
||||
/** @type {ReturnType<typeof createGoalie> | null} */
|
||||
let goalie = null;
|
||||
|
||||
const state = {
|
||||
subject: 'player', // player | goalie | both
|
||||
pose: 'carry',
|
||||
view: 'threequarter',
|
||||
showBones: false,
|
||||
showGear: false,
|
||||
time: 0,
|
||||
};
|
||||
|
||||
// ---- pose catalogs --------------------------------------------------------
|
||||
const PLAYER_POSES = {
|
||||
stand: {
|
||||
label: 'stand / glide',
|
||||
apply(sk, t) {
|
||||
const a = sk.animator;
|
||||
a.moveSpeed = 0.4;
|
||||
a.bladeSpeed = 0.4;
|
||||
a.effort = 0;
|
||||
a.yawRate = 0;
|
||||
a.braking = false;
|
||||
a.hasPuck = false;
|
||||
a.charge = 0;
|
||||
a.action = null;
|
||||
a.handling.x = 0;
|
||||
a.handling.y = 0;
|
||||
a.setTransform(sk.mover.position, 0);
|
||||
a.update(1 / 60);
|
||||
},
|
||||
},
|
||||
stride: {
|
||||
label: 'full stride',
|
||||
apply(sk) {
|
||||
const a = sk.animator;
|
||||
a.moveSpeed = 7;
|
||||
a.bladeSpeed = 7;
|
||||
a.effort = 1;
|
||||
a.yawRate = 0;
|
||||
a.braking = false;
|
||||
a.hasPuck = true;
|
||||
a.charge = 0;
|
||||
a.action = null;
|
||||
a.handling.x = 0;
|
||||
a.handling.y = 0;
|
||||
a.setTransform(sk.mover.position, 0);
|
||||
a.update(1 / 60);
|
||||
},
|
||||
},
|
||||
carve: {
|
||||
label: 'carve right',
|
||||
apply(sk) {
|
||||
const a = sk.animator;
|
||||
a.moveSpeed = 6.5;
|
||||
a.bladeSpeed = 6.5;
|
||||
a.effort = 0.7;
|
||||
a.yawRate = 1.4;
|
||||
a.braking = false;
|
||||
a.hasPuck = true;
|
||||
a.action = null;
|
||||
a.handling.x = 0;
|
||||
a.handling.y = 0;
|
||||
a.setTransform(sk.mover.position, 0);
|
||||
a.update(1 / 60);
|
||||
},
|
||||
},
|
||||
carry: {
|
||||
label: 'puck carry',
|
||||
apply(sk) {
|
||||
const a = sk.animator;
|
||||
a.moveSpeed = 4;
|
||||
a.bladeSpeed = 4;
|
||||
a.effort = 0.25;
|
||||
a.yawRate = 0;
|
||||
a.braking = false;
|
||||
a.hasPuck = true;
|
||||
a.charge = 0;
|
||||
a.action = null;
|
||||
a.handling.x = 0;
|
||||
a.handling.y = 0;
|
||||
a.setTransform(sk.mover.position, 0);
|
||||
a.update(1 / 60);
|
||||
},
|
||||
},
|
||||
handleRight: {
|
||||
label: 'stickhandle right',
|
||||
apply(sk) {
|
||||
const a = sk.animator;
|
||||
a.moveSpeed = 3;
|
||||
a.bladeSpeed = 3;
|
||||
a.effort = 0.2;
|
||||
a.hasPuck = true;
|
||||
a.action = null;
|
||||
a.handling.x = 1;
|
||||
a.handling.y = 0;
|
||||
a.setTransform(sk.mover.position, 0);
|
||||
a.update(1 / 60);
|
||||
},
|
||||
},
|
||||
handleLeft: {
|
||||
label: 'stickhandle left',
|
||||
apply(sk) {
|
||||
const a = sk.animator;
|
||||
a.moveSpeed = 3;
|
||||
a.bladeSpeed = 3;
|
||||
a.effort = 0.2;
|
||||
a.hasPuck = true;
|
||||
a.action = null;
|
||||
a.handling.x = -1;
|
||||
a.handling.y = 0;
|
||||
a.setTransform(sk.mover.position, 0);
|
||||
a.update(1 / 60);
|
||||
},
|
||||
},
|
||||
windup: {
|
||||
label: 'shot wind-up',
|
||||
apply(sk) {
|
||||
const a = sk.animator;
|
||||
a.moveSpeed = 2;
|
||||
a.bladeSpeed = 2;
|
||||
a.effort = 0.3;
|
||||
a.hasPuck = true;
|
||||
a.charge = 1;
|
||||
a.action = 'windup';
|
||||
a.actionTime = 1;
|
||||
a.handling.x = 0;
|
||||
a.handling.y = -1;
|
||||
a.setTransform(sk.mover.position, 0);
|
||||
a.update(1 / 60);
|
||||
},
|
||||
},
|
||||
shoot: {
|
||||
label: 'shot follow-through',
|
||||
apply(sk) {
|
||||
const a = sk.animator;
|
||||
a.moveSpeed = 2;
|
||||
a.bladeSpeed = 2;
|
||||
a.effort = 0.3;
|
||||
a.hasPuck = true;
|
||||
a.charge = 0;
|
||||
if (a.action !== 'shoot') a.playAction('shoot', { power: 1 });
|
||||
a.actionTime = 0.18;
|
||||
a.setTransform(sk.mover.position, 0);
|
||||
a.update(1 / 60);
|
||||
},
|
||||
},
|
||||
stop: {
|
||||
label: 'hockey stop',
|
||||
apply(sk) {
|
||||
const a = sk.animator;
|
||||
a.moveSpeed = 5;
|
||||
a.bladeSpeed = 5;
|
||||
a.effort = 1;
|
||||
a.braking = true;
|
||||
a.hasPuck = true;
|
||||
a.action = null;
|
||||
a.setTransform(sk.mover.position, 0);
|
||||
a.update(1 / 60);
|
||||
},
|
||||
},
|
||||
poke: {
|
||||
label: 'poke check',
|
||||
apply(sk) {
|
||||
const a = sk.animator;
|
||||
a.moveSpeed = 4;
|
||||
a.bladeSpeed = 4;
|
||||
a.effort = 0.5;
|
||||
a.hasPuck = false;
|
||||
if (a.action !== 'poke') a.playAction('poke');
|
||||
a.actionTime = 0.12;
|
||||
a.setTransform(sk.mover.position, 0);
|
||||
a.update(1 / 60);
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
const GOALIE_POSES = {
|
||||
ready: {
|
||||
label: 'ready stance',
|
||||
apply(g) {
|
||||
// Far puck, mid height — stays in ready.
|
||||
g.animator.threatened = 0.1;
|
||||
g.animator.puckHeight = 0.5;
|
||||
g.animator.puckDist = 12;
|
||||
g.animator.moveSpeed = 0;
|
||||
g.animator.lateralVel = 0;
|
||||
g.animator.setState('ready', 0.05);
|
||||
g.animator.setTransform(g.mover.position, 0);
|
||||
g.animator.update(1 / 60);
|
||||
},
|
||||
},
|
||||
shuffle: {
|
||||
label: 'lateral shuffle',
|
||||
apply(g) {
|
||||
g.animator.threatened = 0.2;
|
||||
g.animator.puckHeight = 0.4;
|
||||
g.animator.puckDist = 8;
|
||||
g.animator.moveSpeed = 3.2;
|
||||
g.animator.lateralVel = 2.4;
|
||||
g.animator.setState('shuffle', 0.05);
|
||||
g.animator.setTransform(g.mover.position, 0);
|
||||
g.animator.update(1 / 60);
|
||||
},
|
||||
},
|
||||
butterfly: {
|
||||
label: 'butterfly',
|
||||
apply(g) {
|
||||
g.animator.threatened = 0.9;
|
||||
g.animator.puckHeight = 0.1;
|
||||
g.animator.puckDist = 2;
|
||||
g.animator.moveSpeed = 0;
|
||||
g.animator.lateralVel = 0;
|
||||
g.animator.setState('butterfly', 0.05);
|
||||
g.animator.setTransform(g.mover.position, 0);
|
||||
g.animator.update(1 / 60);
|
||||
},
|
||||
},
|
||||
reachGlove: {
|
||||
label: 'glove reach',
|
||||
apply(g) {
|
||||
g.animator.threatened = 0.8;
|
||||
g.animator.puckHeight = 1.3;
|
||||
g.animator.puckDist = 2.5;
|
||||
g.animator.moveSpeed = 0;
|
||||
g.animator.lateralVel = -0.5;
|
||||
g.animator.setState('reach', 0.05);
|
||||
g.animator.setTransform(g.mover.position, 0);
|
||||
g.animator.update(1 / 60);
|
||||
},
|
||||
},
|
||||
reachBlocker: {
|
||||
label: 'blocker reach',
|
||||
apply(g) {
|
||||
g.animator.threatened = 0.8;
|
||||
g.animator.puckHeight = 1.25;
|
||||
g.animator.puckDist = 2.5;
|
||||
g.animator.moveSpeed = 0;
|
||||
g.animator.lateralVel = 0.8;
|
||||
g.animator.setState('reach', 0.05);
|
||||
g.animator.setTransform(g.mover.position, 0);
|
||||
g.animator.update(1 / 60);
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
// ---- views ----------------------------------------------------------------
|
||||
const VIEWS = {
|
||||
front: { pos: [0, 1.15, 4.2], target: [0, 0.9, 0] },
|
||||
threequarter: { pos: [2.6, 1.35, 3.4], target: [0, 0.9, 0] },
|
||||
side: { pos: [4.4, 1.1, 0.15], target: [0, 0.85, 0] },
|
||||
back: { pos: [0.2, 1.2, -4.0], target: [0, 0.9, 0] },
|
||||
top: { pos: [0.1, 6.5, 0.2], target: [0, 0.2, 0] },
|
||||
closeup: { pos: [1.1, 1.35, 1.7], target: [0, 1.15, 0.15] },
|
||||
gear: { pos: [1.6, 0.55, 2.0], target: [0, 0.45, 0.1] },
|
||||
};
|
||||
|
||||
function applyView(name) {
|
||||
const v = VIEWS[name] ?? VIEWS.threequarter;
|
||||
camera.position.set(...v.pos);
|
||||
controls.target.set(...v.target);
|
||||
controls.update();
|
||||
state.view = name;
|
||||
viewSel.value = name;
|
||||
}
|
||||
|
||||
// ---- bone / gear debug ----------------------------------------------------
|
||||
const boneHelpers = new THREE.Group();
|
||||
boneHelpers.visible = false;
|
||||
scene.add(boneHelpers);
|
||||
const gearHelpers = new THREE.Group();
|
||||
gearHelpers.visible = false;
|
||||
scene.add(gearHelpers);
|
||||
|
||||
function rebuildHelpers() {
|
||||
while (boneHelpers.children.length) boneHelpers.remove(boneHelpers.children[0]);
|
||||
while (gearHelpers.children.length) gearHelpers.remove(gearHelpers.children[0]);
|
||||
|
||||
const subjects = [];
|
||||
if (player && (state.subject === 'player' || state.subject === 'both')) subjects.push(player);
|
||||
if (goalie && (state.subject === 'goalie' || state.subject === 'both')) subjects.push(goalie);
|
||||
|
||||
for (const sub of subjects) {
|
||||
const bones = sub.skelData?.bones;
|
||||
if (!bones) continue;
|
||||
for (const b of Object.values(bones)) {
|
||||
const axes = new THREE.AxesHelper(0.08);
|
||||
axes.name = `bone:${b.name}`;
|
||||
b.add(axes);
|
||||
boneHelpers.userData[b.uuid] = axes;
|
||||
}
|
||||
if (sub.gear) {
|
||||
for (const p of sub.gear.pieces ?? []) {
|
||||
const box = new THREE.BoxHelper(p, 0x66ccff);
|
||||
box.name = `gear:${p.name}`;
|
||||
gearHelpers.add(box);
|
||||
}
|
||||
}
|
||||
if (sub.stick?.group) {
|
||||
gearHelpers.add(new THREE.BoxHelper(sub.stick.group, 0xffaa44));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function clearBoneAxes() {
|
||||
// Axes were parented onto bones; remove them.
|
||||
const strip = (root) => {
|
||||
if (!root) return;
|
||||
const kill = [];
|
||||
root.traverse((o) => {
|
||||
if (o.isAxesHelper) kill.push(o);
|
||||
});
|
||||
for (const o of kill) o.removeFromParent();
|
||||
};
|
||||
strip(player?.mover);
|
||||
strip(goalie?.mover);
|
||||
}
|
||||
|
||||
// ---- build subjects -------------------------------------------------------
|
||||
function buildPlayer() {
|
||||
if (player) {
|
||||
player.dispose();
|
||||
player = null;
|
||||
}
|
||||
player = createSkater({
|
||||
seed: 42,
|
||||
scene,
|
||||
physics: null,
|
||||
index: 0,
|
||||
team: 0,
|
||||
position: { x: state.subject === 'both' ? -0.85 : 0, z: 0 },
|
||||
facing: 0,
|
||||
});
|
||||
// Settle a few frames so blend weights and stick aim land.
|
||||
for (let i = 0; i < 30; i++) {
|
||||
player.animator.moveSpeed = 0;
|
||||
player.animator.effort = 0;
|
||||
player.animator.hasPuck = true;
|
||||
player.animator.setTransform(player.mover.position, 0);
|
||||
player.animator.update(1 / 60);
|
||||
}
|
||||
}
|
||||
|
||||
function buildGoalie() {
|
||||
if (goalie) {
|
||||
goalie.destroy();
|
||||
goalie = null;
|
||||
}
|
||||
goalie = createGoalie(null, scene, {
|
||||
end: 1,
|
||||
team: 1,
|
||||
seed: 77,
|
||||
index: 40,
|
||||
});
|
||||
// Park in studio space facing +Z (camera front), not the net frame.
|
||||
const x = state.subject === 'both' ? 0.85 : 0;
|
||||
goalie.mover.position.set(x, 0, 0);
|
||||
goalie.mover.rotation.y = 0;
|
||||
goalie.pos.x = x;
|
||||
goalie.pos.z = 0;
|
||||
goalie.animator.setTransform(goalie.mover.position, 0);
|
||||
for (let i = 0; i < 30; i++) {
|
||||
goalie.animator.threatened = 0.1;
|
||||
goalie.animator.puckHeight = 0.5;
|
||||
goalie.animator.puckDist = 12;
|
||||
goalie.animator.setState('ready', 0.02);
|
||||
goalie.animator.update(1 / 60);
|
||||
}
|
||||
}
|
||||
|
||||
function layoutSubjects() {
|
||||
if (player) {
|
||||
const x = state.subject === 'both' ? -0.85 : 0;
|
||||
player.mover.position.set(x, 0, 0);
|
||||
player.animator.setTransform(player.mover.position, 0);
|
||||
}
|
||||
if (goalie) {
|
||||
const x = state.subject === 'both' ? 0.85 : 0;
|
||||
goalie.mover.position.set(x, 0, 0);
|
||||
goalie.pos.x = x;
|
||||
goalie.pos.z = 0;
|
||||
goalie.animator.setTransform(goalie.mover.position, 0);
|
||||
}
|
||||
if (player) player.mover.visible = state.subject !== 'goalie';
|
||||
if (goalie) goalie.mover.visible = state.subject !== 'player';
|
||||
}
|
||||
|
||||
// ---- pose application -----------------------------------------------------
|
||||
function poseList() {
|
||||
if (state.subject === 'goalie') return Object.keys(GOALIE_POSES);
|
||||
if (state.subject === 'player') return Object.keys(PLAYER_POSES);
|
||||
// both: union with player first
|
||||
return [...Object.keys(PLAYER_POSES), ...Object.keys(GOALIE_POSES).map((k) => `g:${k}`)];
|
||||
}
|
||||
|
||||
function fillPoseSelect() {
|
||||
const list = poseList();
|
||||
poseSel.innerHTML = '';
|
||||
for (const id of list) {
|
||||
const opt = document.createElement('option');
|
||||
opt.value = id;
|
||||
if (id.startsWith('g:')) {
|
||||
opt.textContent = `G · ${GOALIE_POSES[id.slice(2)].label}`;
|
||||
} else if (state.subject === 'goalie') {
|
||||
opt.textContent = GOALIE_POSES[id].label;
|
||||
} else {
|
||||
opt.textContent = PLAYER_POSES[id]?.label ?? id;
|
||||
}
|
||||
poseSel.appendChild(opt);
|
||||
}
|
||||
if (!list.includes(state.pose)) state.pose = list[0];
|
||||
poseSel.value = state.pose;
|
||||
}
|
||||
|
||||
/** Hold a pose for several frames so blends settle before capture. */
|
||||
function applyPose(poseId, settleFrames = 45) {
|
||||
state.pose = poseId;
|
||||
poseSel.value = poseId;
|
||||
|
||||
for (let i = 0; i < settleFrames; i++) {
|
||||
state.time += 1 / 60;
|
||||
if (player && player.mover.visible) {
|
||||
const id = poseId.startsWith('g:') ? 'carry' : poseId;
|
||||
const def = PLAYER_POSES[id] ?? PLAYER_POSES.carry;
|
||||
def.apply(player, state.time);
|
||||
}
|
||||
if (goalie && goalie.mover.visible) {
|
||||
const id = poseId.startsWith('g:') ? poseId.slice(2) : (GOALIE_POSES[poseId] ? poseId : 'ready');
|
||||
const def = GOALIE_POSES[id] ?? GOALIE_POSES.ready;
|
||||
// Bypass the live tracking loop; drive the animator directly.
|
||||
def.apply(goalie);
|
||||
}
|
||||
}
|
||||
if (state.showGear) {
|
||||
for (const c of gearHelpers.children) {
|
||||
if (c.isBoxHelper) c.update();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function setSubject(sub) {
|
||||
state.subject = sub;
|
||||
subjectSel.value = sub;
|
||||
if ((sub === 'player' || sub === 'both') && !player) buildPlayer();
|
||||
if ((sub === 'goalie' || sub === 'both') && !goalie) buildGoalie();
|
||||
layoutSubjects();
|
||||
fillPoseSelect();
|
||||
// Default pose per subject.
|
||||
if (sub === 'goalie' && !GOALIE_POSES[state.pose] && !state.pose.startsWith('g:')) {
|
||||
state.pose = 'ready';
|
||||
}
|
||||
if (sub === 'player' && !PLAYER_POSES[state.pose]) state.pose = 'carry';
|
||||
applyPose(state.pose);
|
||||
clearBoneAxes();
|
||||
if (state.showBones) rebuildHelpers();
|
||||
}
|
||||
|
||||
// ---- measurements HUD -----------------------------------------------------
|
||||
const _v = new THREE.Vector3();
|
||||
function measure(sub) {
|
||||
if (!sub) return null;
|
||||
const bones = sub.skelData.bones;
|
||||
const inv = new THREE.Matrix4().copy(sub.mover.matrixWorld).invert();
|
||||
// Clone each result — a shared scratch vector would make every field the
|
||||
// last bone written (everything looked like foot height).
|
||||
const local = (bone) => {
|
||||
bone.getWorldPosition(_v);
|
||||
return _v.clone().applyMatrix4(inv);
|
||||
};
|
||||
const head = local(bones.head);
|
||||
const handL = local(bones.handL);
|
||||
const handR = local(bones.handR);
|
||||
const footL = local(bones.footL);
|
||||
const footR = local(bones.footR);
|
||||
return {
|
||||
headY: head.y,
|
||||
handLY: handL.y,
|
||||
handRY: handR.y,
|
||||
footLY: footL.y,
|
||||
footRY: footR.y,
|
||||
stanceW: Math.abs(footL.x - footR.x),
|
||||
anim: sub.animator?.state ?? sub.animator?.action ?? '—',
|
||||
};
|
||||
}
|
||||
|
||||
function refreshHud() {
|
||||
const lines = [
|
||||
`img2mesh subject=${state.subject} pose=${state.pose} view=${state.view}`,
|
||||
];
|
||||
if (player?.mover.visible) {
|
||||
const m = measure(player);
|
||||
lines.push(
|
||||
`player anim=${m.anim} headY=${m.headY.toFixed(2)} hands=${m.handLY.toFixed(2)}/${m.handRY.toFixed(2)} feetY=${m.footLY.toFixed(2)} width=${m.stanceW.toFixed(2)}`,
|
||||
);
|
||||
}
|
||||
if (goalie?.mover.visible) {
|
||||
const m = measure(goalie);
|
||||
lines.push(
|
||||
`goalie anim=${m.anim} headY=${m.headY.toFixed(2)} hands=${m.handLY.toFixed(2)}/${m.handRY.toFixed(2)} feetY=${m.footLY.toFixed(2)} width=${m.stanceW.toFixed(2)}`,
|
||||
);
|
||||
}
|
||||
hud.textContent = lines.join('\n');
|
||||
}
|
||||
|
||||
// ---- public API for the CLI harness ---------------------------------------
|
||||
/**
|
||||
* Shot sheet the headless tool walks. Keep names filesystem-safe.
|
||||
* @returns {{ subject: string, pose: string, view: string, file: string }[]}
|
||||
*/
|
||||
function shotSheet({ subjects = ['player', 'goalie'], views = null, poses = null } = {}) {
|
||||
const viewIds = views ?? ['front', 'threequarter', 'side', 'closeup', 'gear'];
|
||||
const out = [];
|
||||
for (const sub of subjects) {
|
||||
const poseIds = poses
|
||||
?? (sub === 'goalie' ? Object.keys(GOALIE_POSES) : Object.keys(PLAYER_POSES));
|
||||
for (const pose of poseIds) {
|
||||
for (const view of viewIds) {
|
||||
out.push({
|
||||
subject: sub,
|
||||
pose,
|
||||
view,
|
||||
file: `${sub}_${pose}_${view}.png`,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
async function captureShot({ subject, pose, view, settleMs = 80 }) {
|
||||
setSubject(subject);
|
||||
applyView(view);
|
||||
applyPose(pose, 50);
|
||||
// One render so WebGL presents the settled pose.
|
||||
controls.update();
|
||||
renderer.render(scene, camera);
|
||||
await new Promise((r) => setTimeout(r, settleMs));
|
||||
renderer.render(scene, camera);
|
||||
return {
|
||||
subject,
|
||||
pose,
|
||||
view,
|
||||
measures: {
|
||||
player: player?.mover.visible ? measure(player) : null,
|
||||
goalie: goalie?.mover.visible ? measure(goalie) : null,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
window.img2mesh = {
|
||||
state,
|
||||
shotSheet,
|
||||
captureShot,
|
||||
setSubject,
|
||||
applyPose,
|
||||
applyView,
|
||||
get player() { return player; },
|
||||
get goalie() { return goalie; },
|
||||
/** Data URL of the current canvas (png). */
|
||||
async screenshotDataURL() {
|
||||
controls.update();
|
||||
renderer.render(scene, camera);
|
||||
return canvas.toDataURL('image/png');
|
||||
},
|
||||
/** Pose / view catalogs for external tools. */
|
||||
catalogs: {
|
||||
playerPoses: () => Object.fromEntries(Object.entries(PLAYER_POSES).map(([k, v]) => [k, v.label])),
|
||||
goaliePoses: () => Object.fromEntries(Object.entries(GOALIE_POSES).map(([k, v]) => [k, v.label])),
|
||||
views: () => Object.keys(VIEWS),
|
||||
},
|
||||
};
|
||||
|
||||
// ---- UI wiring ------------------------------------------------------------
|
||||
function cycle(list, cur, dir) {
|
||||
const i = list.indexOf(cur);
|
||||
return list[(i + dir + list.length) % list.length];
|
||||
}
|
||||
|
||||
subjectSel.addEventListener('change', () => setSubject(subjectSel.value));
|
||||
poseSel.addEventListener('change', () => applyPose(poseSel.value));
|
||||
viewSel.addEventListener('change', () => applyView(viewSel.value));
|
||||
|
||||
document.getElementById('prevPose').onclick = () => {
|
||||
applyPose(cycle(poseList(), state.pose, -1));
|
||||
};
|
||||
document.getElementById('nextPose').onclick = () => {
|
||||
applyPose(cycle(poseList(), state.pose, 1));
|
||||
};
|
||||
document.getElementById('prevView').onclick = () => {
|
||||
applyView(cycle(Object.keys(VIEWS), state.view, -1));
|
||||
};
|
||||
document.getElementById('nextView').onclick = () => {
|
||||
applyView(cycle(Object.keys(VIEWS), state.view, 1));
|
||||
};
|
||||
document.getElementById('cycle').onclick = async () => {
|
||||
const sheet = shotSheet({ subjects: [state.subject === 'both' ? 'player' : state.subject] });
|
||||
for (const s of sheet.slice(0, 12)) {
|
||||
await captureShot(s);
|
||||
refreshHud();
|
||||
await new Promise((r) => setTimeout(r, 120));
|
||||
}
|
||||
};
|
||||
|
||||
window.addEventListener('keydown', (e) => {
|
||||
if (e.target.matches?.('select,input,textarea')) return;
|
||||
if (e.key === '1') setSubject('player');
|
||||
if (e.key === '2') setSubject('goalie');
|
||||
if (e.key === '3') setSubject('both');
|
||||
if (e.key === '[') applyPose(cycle(poseList(), state.pose, -1));
|
||||
if (e.key === ']') applyPose(cycle(poseList(), state.pose, 1));
|
||||
if (e.key === ',') applyView(cycle(Object.keys(VIEWS), state.view, -1));
|
||||
if (e.key === '.') applyView(cycle(Object.keys(VIEWS), state.view, 1));
|
||||
if (e.key === 'b' || e.key === 'B') {
|
||||
state.showBones = !state.showBones;
|
||||
if (state.showBones) rebuildHelpers();
|
||||
else clearBoneAxes();
|
||||
boneHelpers.visible = state.showBones;
|
||||
}
|
||||
if (e.key === 'g' || e.key === 'G') {
|
||||
state.showGear = !state.showGear;
|
||||
if (state.showGear) rebuildHelpers();
|
||||
gearHelpers.visible = state.showGear;
|
||||
}
|
||||
});
|
||||
|
||||
// ---- boot -----------------------------------------------------------------
|
||||
buildPlayer();
|
||||
buildGoalie();
|
||||
setSubject('player');
|
||||
applyView('threequarter');
|
||||
applyPose('carry');
|
||||
boot.remove();
|
||||
|
||||
let last = performance.now();
|
||||
function frame(now) {
|
||||
const dt = Math.min(0.05, (now - last) / 1000);
|
||||
last = now;
|
||||
state.time += dt;
|
||||
// Live-update the current pose so stride cycles and breath read while idle.
|
||||
if (player?.mover.visible) {
|
||||
const id = state.pose.startsWith('g:') ? 'carry' : state.pose;
|
||||
(PLAYER_POSES[id] ?? PLAYER_POSES.carry).apply(player, state.time);
|
||||
}
|
||||
if (goalie?.mover.visible) {
|
||||
const id = state.pose.startsWith('g:')
|
||||
? state.pose.slice(2)
|
||||
: (GOALIE_POSES[state.pose] ? state.pose : 'ready');
|
||||
(GOALIE_POSES[id] ?? GOALIE_POSES.ready).apply(goalie);
|
||||
}
|
||||
if (state.showGear) {
|
||||
for (const c of gearHelpers.children) {
|
||||
if (c.isBoxHelper) c.update();
|
||||
}
|
||||
}
|
||||
controls.update();
|
||||
renderer.render(scene, camera);
|
||||
refreshHud();
|
||||
requestAnimationFrame(frame);
|
||||
}
|
||||
requestAnimationFrame(frame);
|
||||
+162
@@ -0,0 +1,162 @@
|
||||
import { createBrain, spawnLineup, steer } from '../shared/ai.js';
|
||||
import { SKATE, createSkaterState, speedOf, stepSkater } from '../shared/skaterSim.js';
|
||||
import { RINK, insideRink } from '../shared/rink.js';
|
||||
import { done, near, ok, section } from './harness.mjs';
|
||||
|
||||
const DT = 1 / 120;
|
||||
|
||||
/** Deterministic PRNG so a failure here is reproducible. */
|
||||
function rng(seed) {
|
||||
let a = seed | 0;
|
||||
return () => {
|
||||
a = (a + 0x6d2b79f5) | 0;
|
||||
let t = Math.imul(a ^ (a >>> 15), 1 | a);
|
||||
t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
|
||||
return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* A whole match's worth of skaters and brains, stepped headlessly.
|
||||
* Board contact is the sim's clamp here rather than Box3D's, which is the
|
||||
* point: the AI must not need the physics world to behave.
|
||||
*/
|
||||
function simulate(perTeam, seconds, seed = 7, teams = 2) {
|
||||
const rand = rng(seed);
|
||||
const spawns = spawnLineup(perTeam, teams);
|
||||
const count = spawns.length;
|
||||
const states = spawns.map((sp, i) => createSkaterState(i, sp, { team: sp.team }));
|
||||
const brains = spawns.map(() => createBrain(rand));
|
||||
const trace = states.map(() => ({ minSpeed: Infinity, maxSpeed: 0, offIce: 0, touches: 0, distance: 0 }));
|
||||
|
||||
const steps = Math.round(seconds / DT);
|
||||
for (let n = 0; n < steps; n++) {
|
||||
for (let i = 0; i < count; i++) {
|
||||
steer(brains[i], states[i], states, DT);
|
||||
const x0 = states[i].x;
|
||||
const z0 = states[i].z;
|
||||
stepSkater(states[i], DT);
|
||||
const t = trace[i];
|
||||
t.distance += Math.hypot(states[i].x - x0, states[i].z - z0);
|
||||
const v = speedOf(states[i]);
|
||||
if (v < t.minSpeed) t.minSpeed = v;
|
||||
if (v > t.maxSpeed) t.maxSpeed = v;
|
||||
if (!insideRink(states[i].x, states[i].z, SKATE.radius)) t.offIce++;
|
||||
}
|
||||
// Count how often two bodies are actually overlapping. The proxies resolve
|
||||
// this in the browser; here it measures whether the *steering* alone keeps
|
||||
// them roughly apart.
|
||||
for (let i = 0; i < count; i++) {
|
||||
for (let j = i + 1; j < count; j++) {
|
||||
const d = Math.hypot(states[i].x - states[j].x, states[i].z - states[j].z);
|
||||
if (d < SKATE.radius * 2) {
|
||||
trace[i].touches++;
|
||||
trace[j].touches++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return { states, brains, trace, steps, count };
|
||||
}
|
||||
|
||||
section('the 3-on-3 lineup is legal, split by half, and faces centre ice');
|
||||
{
|
||||
const spawns = spawnLineup(3, 2);
|
||||
ok(spawns.length === 6, `six skaters on the ice (${spawns.length})`);
|
||||
ok(spawns.filter((s) => s.team === 0).length === 3, 'three a side, home');
|
||||
ok(spawns.filter((s) => s.team === 1).length === 3, 'three a side, away');
|
||||
|
||||
for (const sp of spawns) {
|
||||
ok(insideRink(sp.x, sp.z, SKATE.radius + 1), `spawn (${sp.x.toFixed(1)}, ${sp.z.toFixed(1)}) is on the ice`);
|
||||
// Facing should point back toward the middle of the rink.
|
||||
near(sp.yaw, Math.atan2(-sp.x, -sp.z), 1e-9, 'spawn faces centre ice');
|
||||
// Each team starts in its own half, the way a lineup does.
|
||||
const ownHalf = sp.team === 0 ? sp.x < 0 : sp.x > 0;
|
||||
ok(ownHalf, `team ${sp.team} lines up in its own half (x=${sp.x.toFixed(1)})`);
|
||||
}
|
||||
|
||||
// Index order has to agree with the team field, because the match builds
|
||||
// skaters and materials off the index.
|
||||
for (let i = 0; i < spawns.length; i++) {
|
||||
ok(spawns[i].team === Math.floor(i / 3), `index ${i} belongs to team ${Math.floor(i / 3)}`);
|
||||
}
|
||||
|
||||
for (let i = 0; i < spawns.length; i++) {
|
||||
for (let j = i + 1; j < spawns.length; j++) {
|
||||
const d = Math.hypot(spawns[i].x - spawns[j].x, spawns[i].z - spawns[j].z);
|
||||
ok(d > 2, `spawns ${i} and ${j} are not on top of each other (${d.toFixed(1)}m)`);
|
||||
}
|
||||
}
|
||||
|
||||
// Nobody starts inside the far team, and nobody starts in a corner.
|
||||
for (const sp of spawns) {
|
||||
ok(Math.abs(sp.x) < RINK.halfX - 4, `spawn is clear of the end boards (x=${sp.x.toFixed(1)})`);
|
||||
}
|
||||
}
|
||||
|
||||
section('a 3-on-3 skates a full minute without leaving the ice');
|
||||
{
|
||||
const { trace, states, count } = simulate(3, 60);
|
||||
ok(count === 6, 'six skaters simulated');
|
||||
for (let i = 0; i < count; i++) {
|
||||
ok(trace[i].offIce === 0, `skater ${i} never went through the boards`);
|
||||
ok(Number.isFinite(states[i].x) && Number.isFinite(states[i].z), `skater ${i} stayed finite`);
|
||||
ok(trace[i].distance > 120, `skater ${i} actually covered ground (${trace[i].distance.toFixed(0)}m in 60s)`);
|
||||
ok(trace[i].maxSpeed > 4, `skater ${i} got up to a real speed (${trace[i].maxSpeed.toFixed(1)} m/s)`);
|
||||
ok(trace[i].maxSpeed <= SKATE.speedCeiling, `skater ${i} never exceeded the ceiling`);
|
||||
}
|
||||
}
|
||||
|
||||
section('bots keep out of each other\'s way on their own');
|
||||
{
|
||||
const { trace, steps, count } = simulate(3, 60);
|
||||
for (let i = 0; i < count; i++) {
|
||||
const overlapFraction = trace[i].touches / steps;
|
||||
ok(
|
||||
overlapFraction < 0.06,
|
||||
`skater ${i} spends almost no time inside another body (${(overlapFraction * 100).toFixed(1)}%)`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
section('bots reach their waypoints rather than circling forever');
|
||||
{
|
||||
const rand = rng(19);
|
||||
const s = createSkaterState(0, { x: 0, z: 0, yaw: 0 });
|
||||
const brain = createBrain(rand);
|
||||
let arrivals = 0;
|
||||
let last = null;
|
||||
for (let n = 0; n < 60 * 120; n++) {
|
||||
steer(brain, s, [s], DT);
|
||||
if (brain.target !== last) {
|
||||
if (last !== null) arrivals++;
|
||||
last = brain.target;
|
||||
}
|
||||
stepSkater(s, DT);
|
||||
}
|
||||
ok(arrivals >= 5, `a lone bot got through several waypoints in a minute (${arrivals})`);
|
||||
}
|
||||
|
||||
section('a full 5-on-5 still behaves');
|
||||
{
|
||||
// Not a spike-1 requirement, but the cheapest possible check that the
|
||||
// steering does not fall over the moment there is a full side on the ice.
|
||||
const { trace, states, count } = simulate(5, 30, 3);
|
||||
ok(count === 10, 'ten skaters simulated');
|
||||
for (let i = 0; i < count; i++) {
|
||||
ok(trace[i].offIce === 0, `skater ${i} of ten stayed on the ice`);
|
||||
ok(Number.isFinite(states[i].x), `skater ${i} of ten stayed finite`);
|
||||
}
|
||||
}
|
||||
|
||||
section('the whole match is deterministic');
|
||||
{
|
||||
const a = simulate(3, 20, 42);
|
||||
const b = simulate(3, 20, 42);
|
||||
for (let i = 0; i < a.count; i++) {
|
||||
near(a.states[i].x, b.states[i].x, 0, `skater ${i} replays to the same x`);
|
||||
near(a.states[i].z, b.states[i].z, 0, `skater ${i} replays to the same z`);
|
||||
}
|
||||
}
|
||||
|
||||
done('ai');
|
||||
+103
@@ -0,0 +1,103 @@
|
||||
import * as THREE from 'three';
|
||||
import { createGoalie } from '../src/character/goalie.js';
|
||||
import { done, ok, section } from './harness.mjs';
|
||||
|
||||
/**
|
||||
* Goalie presentation: skeleton, gear, and stance selection.
|
||||
*
|
||||
* Save logic and angle play are covered by shootout.mjs — this file pins the
|
||||
* things that used to be a capsule-and-box placeholder.
|
||||
*/
|
||||
|
||||
const DT = 1 / 60;
|
||||
|
||||
function make() {
|
||||
const scene = new THREE.Group();
|
||||
const goalie = createGoalie(null, scene, { end: 1, team: 1, seed: 42 });
|
||||
return { scene, goalie };
|
||||
}
|
||||
|
||||
section('goalie is a skinned skeleton, not a capsule');
|
||||
{
|
||||
const { goalie } = make();
|
||||
ok(goalie.skelData.list.length >= 20, `has a full bone list (${goalie.skelData.list.length})`);
|
||||
ok(goalie.bodyMesh?.isSkinnedMesh, 'body is a SkinnedMesh');
|
||||
ok(goalie.gear.padL.parent === goalie.skelData.bones.shinL, 'left pad is on the left shin');
|
||||
ok(goalie.gear.padR.parent === goalie.skelData.bones.shinR, 'right pad is on the right shin');
|
||||
ok(goalie.gear.trapper.parent === goalie.skelData.bones.handL, 'trapper is on the left hand');
|
||||
ok(goalie.gear.blocker.parent === goalie.skelData.bones.handR, 'blocker is on the right hand');
|
||||
ok(goalie.gear.mask.parent === goalie.skelData.bones.head, 'mask is on the head');
|
||||
ok(goalie.gear.stick.parent === goalie.skelData.bones.handR, 'paddle is in the blocker hand');
|
||||
goalie.destroy();
|
||||
}
|
||||
|
||||
section('nothing produces NaN while tracking');
|
||||
{
|
||||
const { goalie } = make();
|
||||
let bad = false;
|
||||
for (let i = 0; i < 180; i++) {
|
||||
goalie.update(DT, {
|
||||
x: 15 + i * 0.08,
|
||||
y: 0.1 + 0.5 * Math.sin(i * 0.1),
|
||||
z: Math.sin(i * 0.07) * 2,
|
||||
});
|
||||
for (const b of goalie.skelData.list) {
|
||||
for (const e of b.matrixWorld.elements) {
|
||||
if (!Number.isFinite(e)) bad = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
ok(!bad, 'bone matrices stay finite');
|
||||
goalie.destroy();
|
||||
}
|
||||
|
||||
section('stances respond to the puck');
|
||||
{
|
||||
const { goalie } = make();
|
||||
// Far out: ready.
|
||||
for (let i = 0; i < 60; i++) goalie.update(DT, { x: 10, y: 0.5, z: 0 });
|
||||
ok(goalie.animator.state === 'ready', `idle crease is ready (${goalie.animator.state})`);
|
||||
|
||||
// Low and closing: butterfly.
|
||||
for (let i = 0; i < 90; i++) {
|
||||
goalie.update(DT, { x: 12 + i * 0.15, y: 0.1, z: 0.2 });
|
||||
}
|
||||
ok(
|
||||
goalie.animator.state === 'butterfly',
|
||||
`low attack draws a butterfly (${goalie.animator.state})`,
|
||||
);
|
||||
|
||||
// High and close: reach.
|
||||
for (let i = 0; i < 45; i++) {
|
||||
goalie.update(DT, { x: goalie.pos.x + 2, y: 1.25, z: goalie.pos.z });
|
||||
}
|
||||
ok(goalie.animator.state === 'reach', `high puck draws a reach (${goalie.animator.state})`);
|
||||
goalie.destroy();
|
||||
}
|
||||
|
||||
section('goalie drops low in the butterfly');
|
||||
{
|
||||
const { goalie } = make();
|
||||
for (let i = 0; i < 40; i++) goalie.update(DT, { x: 18, y: 0.5, z: 0 });
|
||||
const readyY = goalie.skelData.bones.root.position.y;
|
||||
const foot = new THREE.Vector3();
|
||||
goalie.skelData.bones.footL.getWorldPosition(foot);
|
||||
ok(Math.abs(foot.y - 0.085) < 0.04, `ready feet are on the ice (y=${foot.y.toFixed(3)})`);
|
||||
|
||||
for (let i = 0; i < 80; i++) {
|
||||
goalie.update(DT, { x: goalie.pos.x + 1.2, y: 0.08, z: 0 });
|
||||
}
|
||||
const flyY = goalie.skelData.bones.root.position.y;
|
||||
ok(flyY < readyY - 0.1, `butterfly drops the hips (${readyY.toFixed(2)} → ${flyY.toFixed(2)})`);
|
||||
goalie.skelData.bones.footL.getWorldPosition(foot);
|
||||
ok(Math.abs(foot.y - 0.085) < 0.04, `butterfly feet stay on the ice (y=${foot.y.toFixed(3)})`);
|
||||
// Pads flare wider than the ready stance.
|
||||
const inv = new THREE.Matrix4().copy(goalie.mover.matrixWorld).invert();
|
||||
const fL = foot.clone().applyMatrix4(inv);
|
||||
goalie.skelData.bones.footR.getWorldPosition(foot);
|
||||
const fR = foot.clone().applyMatrix4(inv);
|
||||
ok(Math.abs(fL.x - fR.x) > 0.9, `butterfly opens the stance (width ${(fL.x - fR.x).toFixed(2)})`);
|
||||
goalie.destroy();
|
||||
}
|
||||
|
||||
done('goalie');
|
||||
@@ -0,0 +1,28 @@
|
||||
/** The smallest test harness that gives a useful failure message. */
|
||||
|
||||
let failures = 0;
|
||||
let checks = 0;
|
||||
|
||||
export function ok(cond, msg) {
|
||||
checks++;
|
||||
if (!cond) {
|
||||
failures++;
|
||||
console.error(' FAIL ' + msg);
|
||||
}
|
||||
}
|
||||
|
||||
export function near(actual, expected, tol, msg) {
|
||||
ok(Math.abs(actual - expected) <= tol, `${msg} (got ${actual}, want ${expected} ±${tol})`);
|
||||
}
|
||||
|
||||
export function section(name) {
|
||||
console.log('· ' + name);
|
||||
}
|
||||
|
||||
export function done(name) {
|
||||
if (failures) {
|
||||
console.error(`\n${name}: ${failures} of ${checks} checks failed`);
|
||||
process.exit(1);
|
||||
}
|
||||
console.log(`${name}: ${checks} checks passed`);
|
||||
}
|
||||
+449
@@ -0,0 +1,449 @@
|
||||
import * as THREE from 'three';
|
||||
import { createPhysicsWorld, initPhysics } from '../src/physics/world.js';
|
||||
import { createMatch } from '../src/game/match.js';
|
||||
import { closestLimbs, describeHit } from '../src/game/hits.js';
|
||||
import { REGION } from '../src/character/skeleton.js';
|
||||
import { segSegDistance } from '../src/core/math.js';
|
||||
import { insideRink } from '../shared/rink.js';
|
||||
import { done, near, ok, section } from './harness.mjs';
|
||||
|
||||
/**
|
||||
* Body checks, end to end and headless.
|
||||
*
|
||||
* The thing under test is the handoff: while upright the proxy capsule owns
|
||||
* position and the ragdoll is a kinematic passenger; a knockdown inverts that,
|
||||
* and getting up inverts it back. That round trip is the part of the design
|
||||
* with nowhere to hide, so most of this file is about proving it does not leak
|
||||
* a disabled proxy, a stranded sim position, or a skater who never gets up.
|
||||
*/
|
||||
|
||||
const DT = 1 / 60;
|
||||
|
||||
await initPhysics();
|
||||
|
||||
/** A match with everyone parked, so only the skaters under test move. */
|
||||
function arena(perTeam = 1) {
|
||||
const physics = createPhysicsWorld();
|
||||
const match = createMatch({ scene: new THREE.Group(), physics, perTeam, teams: 2 });
|
||||
return { physics, match };
|
||||
}
|
||||
|
||||
/**
|
||||
* Drive skater 0 into skater 1 head on and run until something happens.
|
||||
* Returns the hits that landed.
|
||||
*/
|
||||
function collide({ closing = 'full', seconds = 6, gap = 16 } = {}) {
|
||||
const { physics, match } = arena(1);
|
||||
const [a, b] = match.states;
|
||||
const landed = [];
|
||||
const seen = new Set();
|
||||
|
||||
a.x = -gap / 2; a.z = 0; a.yaw = Math.PI / 2; a.vx = 0; a.vz = 0;
|
||||
b.x = gap / 2; b.z = 0; b.yaw = -Math.PI / 2; b.vx = 0; b.vz = 0;
|
||||
match.skaters[0].proxy.teleport(a.x, a.z);
|
||||
match.skaters[1].proxy.teleport(b.x, b.z);
|
||||
|
||||
// Drive both directly, so the AI's avoidance steering cannot politely
|
||||
// sidestep the collision this test exists to cause. With cameraYaw 0 the
|
||||
// stick's x maps straight to world +X.
|
||||
match.setControl(0, { x: 1, y: 0, sprint: true, brake: false, cameraYaw: 0 });
|
||||
match.setControl(1, closing === 'full'
|
||||
? { x: -1, y: 0, sprint: true, brake: false, cameraYaw: 0 }
|
||||
: { x: 0, y: 0, sprint: false, brake: false, cameraYaw: 0 });
|
||||
|
||||
const steps = Math.round(seconds / DT);
|
||||
for (let n = 0; n < steps; n++) {
|
||||
match.update(DT);
|
||||
for (const h of match.recentHits) {
|
||||
const id = `${h.at}|${h.attacker}|${h.victim}`;
|
||||
if (!seen.has(id)) {
|
||||
seen.add(id);
|
||||
landed.push(h);
|
||||
}
|
||||
}
|
||||
}
|
||||
return { physics, match, landed };
|
||||
}
|
||||
|
||||
section('segment distance is correct');
|
||||
{
|
||||
const A = new THREE.Vector3();
|
||||
const B = new THREE.Vector3();
|
||||
// Two parallel segments one metre apart.
|
||||
let d = segSegDistance(
|
||||
new THREE.Vector3(0, 0, 0), new THREE.Vector3(1, 0, 0),
|
||||
new THREE.Vector3(0, 1, 0), new THREE.Vector3(1, 1, 0), A, B,
|
||||
);
|
||||
near(d, 1, 1e-9, 'parallel segments');
|
||||
|
||||
// Crossing segments touch.
|
||||
d = segSegDistance(
|
||||
new THREE.Vector3(-1, 0, 0), new THREE.Vector3(1, 0, 0),
|
||||
new THREE.Vector3(0, -1, 0), new THREE.Vector3(0, 1, 0), A, B,
|
||||
);
|
||||
near(d, 0, 1e-9, 'crossing segments');
|
||||
|
||||
// Endpoint to endpoint, no overlap in parameter space.
|
||||
d = segSegDistance(
|
||||
new THREE.Vector3(0, 0, 0), new THREE.Vector3(1, 0, 0),
|
||||
new THREE.Vector3(3, 0, 0), new THREE.Vector3(4, 0, 0), A, B,
|
||||
);
|
||||
near(d, 2, 1e-9, 'collinear, disjoint');
|
||||
near(A.x, 1, 1e-9, 'closest point on the first segment is its end');
|
||||
near(B.x, 3, 1e-9, 'closest point on the second is its start');
|
||||
|
||||
// Degenerate: both segments are points.
|
||||
d = segSegDistance(
|
||||
new THREE.Vector3(0, 0, 0), new THREE.Vector3(0, 0, 0),
|
||||
new THREE.Vector3(3, 4, 0), new THREE.Vector3(3, 4, 0), A, B,
|
||||
);
|
||||
near(d, 5, 1e-9, 'two points');
|
||||
}
|
||||
|
||||
section('the closest limb pair is found between two posed rigs');
|
||||
{
|
||||
const { physics, match } = arena(1);
|
||||
const [a, b] = match.skaters;
|
||||
// Stand them shoulder to shoulder.
|
||||
match.states[0].x = 0; match.states[0].z = 0;
|
||||
match.states[1].x = 0.75; match.states[1].z = 0;
|
||||
a.applyState(match.states[0], 0);
|
||||
b.applyState(match.states[1], 0);
|
||||
a.update(DT);
|
||||
b.update(DT);
|
||||
|
||||
const pair = closestLimbs(a.ragdoll, b.ragdoll);
|
||||
ok(pair, 'a pair was found');
|
||||
ok(pair.attackerPart && pair.victimPart, 'both sides identified');
|
||||
ok(pair.distance < 0.6, `and they are genuinely close (${pair.distance.toFixed(3)}m)`);
|
||||
// Side by side, the nearest parts must be on the facing sides, i.e. arms or
|
||||
// torso — never a foot to a head.
|
||||
ok(
|
||||
pair.attackerPart.name !== 'footL' && pair.attackerPart.name !== 'footR',
|
||||
`a shoulder-to-shoulder stance does not resolve to a foot (${pair.attackerPart.name})`,
|
||||
);
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('a full-speed head-on check lands and knocks someone down');
|
||||
{
|
||||
const { physics, match, landed } = collide({ closing: 'full' });
|
||||
ok(landed.length > 0, `a hit was registered (${landed.length})`);
|
||||
const hit = landed[0];
|
||||
ok(hit.speed > 4, `with real closing speed (${hit.speed.toFixed(1)} m/s)`);
|
||||
ok(hit.outcome !== 'bump', `and it was more than a bump (${hit.outcome})`);
|
||||
ok(hit.attacker !== hit.victim, 'attacker and victim are different skaters');
|
||||
ok(typeof hit.by === 'string' && hit.by.length > 0, `it was delivered by something (${hit.by})`);
|
||||
ok(typeof describeHit(hit) === 'string', `and describes itself: "${describeHit(hit)}"`);
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('a skater who is run over goes down, then gets back up');
|
||||
{
|
||||
const { physics, match } = collide({ closing: 'stationary', seconds: 5 });
|
||||
const downed = match.skaters.filter((s) => s.limp);
|
||||
// Either someone is still down, or they already got up — both mean the path
|
||||
// ran. Keep simulating until nobody is down, and check it terminates.
|
||||
let steps = 0;
|
||||
while (match.skaters.some((s) => s.limp) && steps < 60 / DT) {
|
||||
match.update(DT);
|
||||
steps++;
|
||||
}
|
||||
ok(steps < 60 / DT, `everyone got back up (took ${(steps * DT).toFixed(1)}s)`);
|
||||
for (let i = 0; i < match.skaters.length; i++) {
|
||||
const sk = match.skaters[i];
|
||||
ok(!sk.limp, `skater ${i} is upright`);
|
||||
ok(sk.proxy.enabled, `skater ${i}'s proxy is switched back on`);
|
||||
ok(sk.ragdoll.mode === 'driven', `skater ${i}'s rig is back under animation`);
|
||||
ok(insideRink(match.states[i].x, match.states[i].z, 0.3), `skater ${i} is on the ice`);
|
||||
ok(Number.isFinite(match.states[i].x), `skater ${i}'s position is finite`);
|
||||
}
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('a knockdown puts a skater on the ice, not in the air');
|
||||
{
|
||||
// The failure this catches is specific and very visible: applying the whole
|
||||
// impulse at the contact point, which sits well above the centre of mass,
|
||||
// cartwheels the victim up over the hitter's head instead of driving them
|
||||
// down and back.
|
||||
const { physics, match } = collide({ closing: 'full', gap: 24, seconds: 3 });
|
||||
const victim = match.skaters.find((s) => s.limp);
|
||||
ok(victim, 'somebody went down');
|
||||
|
||||
const pelvis = new THREE.Vector3();
|
||||
const head = new THREE.Vector3();
|
||||
let peakPelvis = 0;
|
||||
let peakHead = 0;
|
||||
for (let n = 0; n < 2.5 / DT; n++) {
|
||||
match.update(DT);
|
||||
victim.ragdoll.parts.pelvis.bone.getWorldPosition(pelvis);
|
||||
victim.ragdoll.parts.head.bone.getWorldPosition(head);
|
||||
peakPelvis = Math.max(peakPelvis, pelvis.y);
|
||||
peakHead = Math.max(peakHead, head.y);
|
||||
}
|
||||
// Standing hip height is ~1.0m and standing head height ~1.6m. Going above
|
||||
// those while being knocked over means they were launched.
|
||||
ok(peakPelvis < 1.35, `the hips never went above standing height (peak ${peakPelvis.toFixed(2)}m)`);
|
||||
ok(peakHead < 2.0, `and neither did the head (peak ${peakHead.toFixed(2)}m)`);
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('a knockdown drives the victim away from the hit, not back into it');
|
||||
{
|
||||
// Run until contact rather than for a fixed time: how long the run-up takes
|
||||
// depends on the acceleration curve, and a test that silently ends before
|
||||
// the collision proves nothing.
|
||||
const { physics, match } = collide({ closing: 'stationary', gap: 22, seconds: 3 });
|
||||
let waited = 0;
|
||||
while (!match.skaters.some((s) => s.limp) && waited < 6) {
|
||||
match.update(DT);
|
||||
waited += DT;
|
||||
}
|
||||
const victimIndex = match.skaters.findIndex((s) => s.limp);
|
||||
ok(victimIndex >= 0, `somebody went down (after ${waited.toFixed(1)}s of extra run-up)`);
|
||||
const pelvis = new THREE.Vector3();
|
||||
match.skaters[victimIndex].ragdoll.parts.pelvis.bone.getWorldPosition(pelvis);
|
||||
const startX = pelvis.x;
|
||||
for (let n = 0; n < 1.2 / DT; n++) match.update(DT);
|
||||
match.skaters[victimIndex].ragdoll.parts.pelvis.bone.getWorldPosition(pelvis);
|
||||
// The attacker was travelling +X, so the victim has to end up further +X.
|
||||
ok(pelvis.x > startX, `the body carried on down the ice (${startX.toFixed(2)} → ${pelvis.x.toFixed(2)})`);
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('getting up does not teleport the body');
|
||||
{
|
||||
// The bug this pins down: while limp the ragdoll writes the body's
|
||||
// displacement into the *root bone*, because the mover stays parked where
|
||||
// they fell. Moving the mover onto the pelvis without re-expressing that
|
||||
// offset applies the displacement twice — the skater visibly flies out by
|
||||
// however far they slid and the crossfade then drags them back.
|
||||
//
|
||||
// Measured on the rendered bones, not on the sim state, because the sim
|
||||
// state was always right; it was the drawn pose that jumped.
|
||||
const { physics, match } = arena(1);
|
||||
const sk = match.skaters[0];
|
||||
const st = match.states[0];
|
||||
st.x = -4;
|
||||
st.z = 3;
|
||||
sk.proxy.teleport(st.x, st.z);
|
||||
for (let n = 0; n < 20; n++) match.update(DT);
|
||||
|
||||
sk.goDown({ severity: 9, direction: new THREE.Vector3(1, 0, 0), victimPart: 'spine2' });
|
||||
// Send them sliding so the fall position and the resting position differ by
|
||||
// a long way — with them equal the bug cannot show.
|
||||
sk.ragdoll.applyImpulse('spine2', new THREE.Vector3(300, 30, 90), null);
|
||||
|
||||
const sample = new THREE.Vector3();
|
||||
const bones = ['pelvis', 'head', 'footL', 'handR'];
|
||||
const before = new Map();
|
||||
let slid = 0;
|
||||
|
||||
while (sk.limp) {
|
||||
// Remember the last frame before the handoff.
|
||||
for (const b of bones) {
|
||||
sk.ragdoll.parts[b].bone.getWorldPosition(sample);
|
||||
before.set(b, sample.clone());
|
||||
}
|
||||
sk.ragdoll.parts.pelvis.bone.getWorldPosition(sample);
|
||||
slid = Math.hypot(sample.x - st.x, sample.z - st.z);
|
||||
match.update(DT);
|
||||
}
|
||||
|
||||
ok(slid > 0.5, `the body really did slide away from where it fell (${slid.toFixed(2)}m)`);
|
||||
|
||||
// First frame back under animation: every bone must be where it just was.
|
||||
let worst = 0;
|
||||
let worstBone = '';
|
||||
for (const b of bones) {
|
||||
sk.ragdoll.parts[b].bone.getWorldPosition(sample);
|
||||
const moved = sample.distanceTo(before.get(b));
|
||||
if (moved > worst) {
|
||||
worst = moved;
|
||||
worstBone = b;
|
||||
}
|
||||
}
|
||||
ok(worst < 0.12, `no bone jumped across the handoff (worst ${worstBone} ${worst.toFixed(3)}m)`);
|
||||
|
||||
// And the whole get-up should be a pose change, not a journey.
|
||||
sk.ragdoll.parts.pelvis.bone.getWorldPosition(sample);
|
||||
const riseStart = sample.clone();
|
||||
let drift = 0;
|
||||
while (sk.rising > 0) {
|
||||
match.update(DT);
|
||||
sk.ragdoll.parts.pelvis.bone.getWorldPosition(sample);
|
||||
drift = Math.max(drift, Math.hypot(sample.x - riseStart.x, sample.z - riseStart.z));
|
||||
}
|
||||
ok(drift < 0.6, `they stood up roughly where they lay (drifted ${drift.toFixed(2)}m)`);
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('a skater who gets up faces the way they were lying');
|
||||
{
|
||||
const { physics, match } = arena(1);
|
||||
const sk = match.skaters[0];
|
||||
const st = match.states[0];
|
||||
st.x = 0;
|
||||
st.z = 0;
|
||||
st.yaw = 0;
|
||||
sk.proxy.teleport(0, 0);
|
||||
for (let n = 0; n < 20; n++) match.update(DT);
|
||||
sk.goDown(null);
|
||||
sk.ragdoll.applyImpulse('spine2', new THREE.Vector3(0, 20, 260), null);
|
||||
while (sk.limp) match.update(DT);
|
||||
|
||||
const pelvis = new THREE.Vector3();
|
||||
const chest = new THREE.Vector3();
|
||||
sk.ragdoll.parts.pelvis.bone.getWorldPosition(pelvis);
|
||||
sk.ragdoll.parts.spine3.bone.getWorldPosition(chest);
|
||||
const bodyYaw = Math.atan2(chest.x - pelvis.x, chest.z - pelvis.z);
|
||||
const off = Math.abs(Math.atan2(Math.sin(st.yaw - bodyYaw), Math.cos(st.yaw - bodyYaw)));
|
||||
ok(off < 0.9, `facing follows the sprawled body rather than a stale yaw (${off.toFixed(2)} rad off)`);
|
||||
ok(Number.isFinite(st.yaw), 'and is a real number');
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('the sim follows the body across a knockdown');
|
||||
{
|
||||
const { physics, match } = arena(1);
|
||||
const sk = match.skaters[0];
|
||||
const st = match.states[0];
|
||||
st.x = -5; st.z = 2; st.vx = 0; st.vz = 0;
|
||||
sk.proxy.teleport(st.x, st.z);
|
||||
for (let n = 0; n < 20; n++) match.update(DT);
|
||||
|
||||
sk.goDown({ severity: 9, direction: new THREE.Vector3(1, 0, 0), victimPart: 'spine2' });
|
||||
ok(sk.limp, 'they are down');
|
||||
ok(!sk.proxy.enabled, 'the proxy switched off — no invisible bollard left behind');
|
||||
|
||||
// Shove the rig so it ends up somewhere other than where it fell.
|
||||
sk.ragdoll.applyImpulse('spine2', new THREE.Vector3(260, 40, 0), null);
|
||||
for (let n = 0; n < 90; n++) match.update(DT);
|
||||
|
||||
const pelvis = new THREE.Vector3();
|
||||
sk.ragdoll.parts.pelvis.bone.getWorldPosition(pelvis);
|
||||
while (sk.limp) match.update(DT);
|
||||
|
||||
ok(sk.proxy.enabled, 'the proxy came back');
|
||||
const gap = Math.hypot(st.x - pelvis.x, st.z - pelvis.z);
|
||||
ok(gap < 1.2, `the sim was moved to where the body actually ended up (${gap.toFixed(2)}m off)`);
|
||||
ok(Math.hypot(st.vx, st.vz) < 2, 'and starts from rest rather than inheriting the slide');
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('a downed skater is not driven around by the sim');
|
||||
{
|
||||
const { physics, match } = arena(1);
|
||||
const sk = match.skaters[0];
|
||||
const st = match.states[0];
|
||||
st.x = 0; st.z = 0;
|
||||
sk.proxy.teleport(0, 0);
|
||||
for (let n = 0; n < 10; n++) match.update(DT);
|
||||
sk.goDown(null);
|
||||
const at = { x: st.x, z: st.z };
|
||||
// Hold full sprint intent for a second while down.
|
||||
for (let n = 0; n < 60; n++) {
|
||||
st.ix = 1;
|
||||
st.iz = 0;
|
||||
st.sprint = true;
|
||||
match.update(DT);
|
||||
}
|
||||
const moved = Math.hypot(st.x - at.x, st.z - at.z);
|
||||
near(moved, 0, 1e-6, 'the frozen sim position did not skate off without the body');
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('ragdoll limbs join the collision world only while dynamic');
|
||||
{
|
||||
const { physics, match } = arena(1);
|
||||
const sk = match.skaters[0];
|
||||
const api = physics.api;
|
||||
const shape = sk.ragdoll.parts.spine2.shape;
|
||||
|
||||
const drivenMask = api.b3Shape_GetFilter(shape).maskBits;
|
||||
sk.goDown(null);
|
||||
const limpMask = api.b3Shape_GetFilter(shape).maskBits;
|
||||
ok(limpMask !== drivenMask, 'the filter changed when the rig went dynamic');
|
||||
ok(limpMask > drivenMask, 'and it got wider, not narrower');
|
||||
|
||||
while (sk.limp) match.update(DT);
|
||||
const backMask = api.b3Shape_GetFilter(shape).maskBits;
|
||||
near(Number(backMask), Number(drivenMask), 0, 'and went back on standing up');
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('a 3-on-3 with hits enabled stays sane');
|
||||
{
|
||||
const { physics, match } = arena(3);
|
||||
for (let n = 0; n < 90 / DT; n++) match.update(DT);
|
||||
for (let i = 0; i < match.states.length; i++) {
|
||||
const s = match.states[i];
|
||||
ok(Number.isFinite(s.x) && Number.isFinite(s.z), `skater ${i} finite after 90s`);
|
||||
ok(insideRink(s.x, s.z, 0.3), `skater ${i} still on the ice`);
|
||||
}
|
||||
ok(match.recentHits.length >= 0, 'the hit list did not blow up');
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('hit severity is graded, not binary');
|
||||
{
|
||||
// Different run-ups must produce different outcomes, or "varied hits" is a
|
||||
// lie. A short approach is a shove; a long one puts someone on the ice.
|
||||
const outcomes = new Set();
|
||||
const byShortRun = [];
|
||||
const byLongRun = [];
|
||||
for (const [gap, into] of [[2.5, byShortRun], [22, byLongRun]]) {
|
||||
const { physics, landed } = collide({ closing: 'stationary', gap, seconds: 6 });
|
||||
for (const h of landed) {
|
||||
outcomes.add(h.outcome);
|
||||
into.push(h);
|
||||
}
|
||||
physics.destroy();
|
||||
}
|
||||
ok(outcomes.size >= 2, `run-up length changes the outcome (${[...outcomes].join(', ')})`);
|
||||
ok(byShortRun.length > 0 && byLongRun.length > 0, 'both approaches landed something');
|
||||
ok(
|
||||
byLongRun[0].severity > byShortRun[0].severity,
|
||||
`a longer run-up hits harder (${byLongRun[0].severity.toFixed(1)} vs ${byShortRun[0].severity.toFixed(1)})`,
|
||||
);
|
||||
}
|
||||
|
||||
section('the kind of hit follows the pose, not a coin flip');
|
||||
{
|
||||
// Two geometries that should produce genuinely different checks: running
|
||||
// down a stationary skater leads with the shoulder, while a head-on between
|
||||
// two skaters both crouched low at speed is a hip check.
|
||||
const kinds = new Set();
|
||||
const seen = [];
|
||||
for (const closing of ['stationary', 'full']) {
|
||||
const { physics, landed } = collide({ closing, gap: 22, seconds: 6 });
|
||||
for (const h of landed) {
|
||||
kinds.add(h.by);
|
||||
seen.push(`${closing}: ${describeHit(h)}`);
|
||||
}
|
||||
physics.destroy();
|
||||
}
|
||||
ok(kinds.size >= 2, `more than one kind of hit is reachable (${[...kinds].join(', ')})`);
|
||||
ok(kinds.has('shoulder') || kinds.has('hip'), `and they are real checks (${seen.join(' | ')})`);
|
||||
}
|
||||
|
||||
section('nobody delivers a check with their head');
|
||||
{
|
||||
// A skater at speed is pitched forward, which makes the head the leading
|
||||
// part of the body geometrically. Without the delivering-part restriction
|
||||
// almost every hit resolves to a headbutt.
|
||||
const delivered = new Set();
|
||||
for (const closing of ['stationary', 'full']) {
|
||||
for (const gap of [5, 14, 22]) {
|
||||
const { physics, landed } = collide({ closing, gap, seconds: 6 });
|
||||
for (const h of landed) delivered.add(h.attackerPart);
|
||||
physics.destroy();
|
||||
}
|
||||
}
|
||||
ok(!delivered.has('head'), `no hit was credited to a head (${[...delivered].join(', ')})`);
|
||||
ok(!delivered.has('neck'), 'nor to a neck');
|
||||
ok(delivered.size > 0, 'and hits did land');
|
||||
}
|
||||
|
||||
done('hits');
|
||||
+361
@@ -0,0 +1,361 @@
|
||||
import { PAD, createInput, stickToWorld } from '../src/game/input.js';
|
||||
import { createSkaterState, stepSkater } from '../shared/skaterSim.js';
|
||||
import { done, near, ok, section } from './harness.mjs';
|
||||
|
||||
/**
|
||||
* A fake window and a fake gamepad, so the pad layer can be tested without a
|
||||
* browser or a pad. The Gamepad API is polled, not evented, which makes it
|
||||
* unusually easy to stand in for.
|
||||
*/
|
||||
function fakePad(overrides = {}) {
|
||||
const buttons = Array.from({ length: 17 }, () => ({ pressed: false, value: 0 }));
|
||||
return {
|
||||
index: 0,
|
||||
id: 'Xbox Wireless Controller (STANDARD GAMEPAD)',
|
||||
connected: true,
|
||||
mapping: 'standard',
|
||||
axes: [0, 0, 0, 0],
|
||||
buttons,
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Node exposes `navigator` as a getter-only global, so it has to be replaced
|
||||
* with defineProperty rather than assigned. Both globals are restored after
|
||||
* each case so one test cannot leak a fake pad into the next.
|
||||
*/
|
||||
function stubGlobal(name, value) {
|
||||
const had = Object.getOwnPropertyDescriptor(globalThis, name);
|
||||
Object.defineProperty(globalThis, name, { value, configurable: true, writable: true });
|
||||
return () => {
|
||||
if (had) Object.defineProperty(globalThis, name, had);
|
||||
else delete globalThis[name];
|
||||
};
|
||||
}
|
||||
|
||||
function harness() {
|
||||
const listeners = new Map();
|
||||
const fakeWindow = {
|
||||
addEventListener: (t, fn) => listeners.set(t, fn),
|
||||
removeEventListener: () => {},
|
||||
};
|
||||
const pad = fakePad();
|
||||
const restoreNav = stubGlobal('navigator', { getGamepads: () => [pad] });
|
||||
const restoreWin = stubGlobal('window', fakeWindow);
|
||||
const input = createInput(fakeWindow);
|
||||
return {
|
||||
input,
|
||||
pad,
|
||||
listeners,
|
||||
press: (i, value = 1) => { pad.buttons[i] = { pressed: value > 0.5, value }; },
|
||||
release: (i) => { pad.buttons[i] = { pressed: false, value: 0 }; },
|
||||
restore: () => {
|
||||
restoreWin();
|
||||
restoreNav();
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Camera-relative steering.
|
||||
*
|
||||
* Worth its own file because the failure mode is silent and infuriating:
|
||||
* a sign flip here means pushing the stick forward sends the skater backwards
|
||||
* only when the camera happens to be on a particular side, which is very easy
|
||||
* to mistake for a physics bug.
|
||||
*
|
||||
* The convention under test: the camera orbits at `cameraYaw`, sitting at
|
||||
* +(sin, cos) from its target, so "away from the camera" is -(sin, cos).
|
||||
*/
|
||||
|
||||
const DT = 1 / 120;
|
||||
|
||||
/** Angle between two XZ directions, radians. */
|
||||
function angleBetween(ax, az, bx, bz) {
|
||||
const dot = (ax * bx + az * bz) / (Math.hypot(ax, az) * Math.hypot(bx, bz));
|
||||
return Math.acos(Math.max(-1, Math.min(1, dot)));
|
||||
}
|
||||
|
||||
section('pushing forward always means away from the camera');
|
||||
{
|
||||
for (const yaw of [0, 0.7, Math.PI / 2, 2.5, Math.PI, -1.2, -Math.PI / 2]) {
|
||||
const w = stickToWorld({ x: 0, y: 1 }, yaw);
|
||||
// The camera sits at +(sin, cos) * distance from its target, so away from
|
||||
// it is the negative of that.
|
||||
near(w.ix, -Math.sin(yaw), 1e-12, `yaw ${yaw.toFixed(2)}: forward is away from the camera (x)`);
|
||||
near(w.iz, -Math.cos(yaw), 1e-12, `yaw ${yaw.toFixed(2)}: forward is away from the camera (z)`);
|
||||
}
|
||||
}
|
||||
|
||||
section('the four directions are square to each other');
|
||||
{
|
||||
for (const yaw of [0, 1.1, -2.2, Math.PI]) {
|
||||
const f = stickToWorld({ x: 0, y: 1 }, yaw);
|
||||
const b = stickToWorld({ x: 0, y: -1 }, yaw);
|
||||
const r = stickToWorld({ x: 1, y: 0 }, yaw);
|
||||
const l = stickToWorld({ x: -1, y: 0 }, yaw);
|
||||
|
||||
near(angleBetween(f.ix, f.iz, r.ix, r.iz), Math.PI / 2, 1e-9, `yaw ${yaw.toFixed(1)}: right is 90° from forward`);
|
||||
near(angleBetween(f.ix, f.iz, b.ix, b.iz), Math.PI, 1e-9, `yaw ${yaw.toFixed(1)}: back is opposite forward`);
|
||||
near(angleBetween(r.ix, r.iz, l.ix, l.iz), Math.PI, 1e-9, `yaw ${yaw.toFixed(1)}: left is opposite right`);
|
||||
|
||||
// Right must be to the camera's right, not its left. Cross product of
|
||||
// forward x right about +Y is negative for a correct right-handed frame.
|
||||
const cross = f.ix * r.iz - f.iz * r.ix;
|
||||
ok(cross > 0, `yaw ${yaw.toFixed(1)}: "right" is on the camera's right, not its left`);
|
||||
}
|
||||
}
|
||||
|
||||
section('magnitude survives the transform');
|
||||
{
|
||||
for (const yaw of [0, 0.9, -1.7]) {
|
||||
for (const stick of [{ x: 1, y: 0 }, { x: 0, y: 1 }, { x: 0.6, y: 0.8 }, { x: 0.3, y: -0.2 }]) {
|
||||
const w = stickToWorld(stick, yaw);
|
||||
near(
|
||||
Math.hypot(w.ix, w.iz),
|
||||
Math.hypot(stick.x, stick.y),
|
||||
1e-12,
|
||||
`yaw ${yaw.toFixed(1)}: a rotation does not change stick magnitude`,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
section('a centred stick produces no intent');
|
||||
{
|
||||
for (const yaw of [0, 1.4, -2.9]) {
|
||||
const w = stickToWorld({ x: 0, y: 0 }, yaw);
|
||||
near(w.ix, 0, 1e-12, 'centred stick, no x');
|
||||
near(w.iz, 0, 1e-12, 'centred stick, no z');
|
||||
}
|
||||
}
|
||||
|
||||
section('holding forward drives the skater away from the camera');
|
||||
{
|
||||
// The end-to-end claim: stick + sim together move the body where the player
|
||||
// expects, from any camera angle and any starting facing.
|
||||
for (const cameraYaw of [0, 1.0, -2.0, Math.PI]) {
|
||||
const s = createSkaterState(0, { x: 0, z: 0, yaw: 2.3 }); // facing anywhere
|
||||
const w = stickToWorld({ x: 0, y: 1 }, cameraYaw);
|
||||
for (let n = 0; n < 3 / DT; n++) {
|
||||
s.ix = w.ix;
|
||||
s.iz = w.iz;
|
||||
s.sprint = true;
|
||||
stepSkater(s, DT, { clampBoards: false });
|
||||
}
|
||||
const travelled = angleBetween(s.x, s.z, w.ix, w.iz);
|
||||
ok(
|
||||
travelled < 0.2,
|
||||
`camera ${cameraYaw.toFixed(1)}: skater ended up where the stick pointed (${travelled.toFixed(3)} rad off)`,
|
||||
);
|
||||
ok(Math.hypot(s.x, s.z) > 8, 'and actually covered ground');
|
||||
}
|
||||
}
|
||||
|
||||
section('the skater turns to face the stick regardless of where they started');
|
||||
{
|
||||
for (const startYaw of [0, 2.0, -2.0, Math.PI]) {
|
||||
const s = createSkaterState(0, { x: 0, z: 0, yaw: startYaw });
|
||||
const w = stickToWorld({ x: 0, y: 1 }, 0); // away from a camera at yaw 0
|
||||
for (let n = 0; n < 2 / DT; n++) {
|
||||
s.ix = w.ix;
|
||||
s.iz = w.iz;
|
||||
stepSkater(s, DT, { clampBoards: false });
|
||||
}
|
||||
const want = Math.atan2(w.ix, w.iz);
|
||||
const off = Math.abs(Math.atan2(Math.sin(s.yaw - want), Math.cos(s.yaw - want)));
|
||||
ok(off < 0.25, `from yaw ${startYaw.toFixed(1)}: came round to face the stick (${off.toFixed(3)} rad off)`);
|
||||
}
|
||||
}
|
||||
|
||||
section('the pad reads as an Xbox controller');
|
||||
{
|
||||
const h = harness();
|
||||
const s = h.input.read(1 / 60);
|
||||
ok(h.input.connected, 'a connected pad is found even without a connect event');
|
||||
ok(s.padId.includes('Xbox'), `and identifies itself (${s.padId})`);
|
||||
near(s.x, 0, 1e-9, 'a resting stick is centred (x)');
|
||||
near(s.y, 0, 1e-9, 'a resting stick is centred (y)');
|
||||
ok(!s.sprint && !s.brake, 'and nothing is pressed');
|
||||
h.restore();
|
||||
}
|
||||
|
||||
section('sticks have a radial deadzone and correct signs');
|
||||
{
|
||||
const h = harness();
|
||||
|
||||
h.pad.axes = [0.1, -0.1, 0, 0];
|
||||
let s = h.input.read(1 / 60);
|
||||
near(s.x, 0, 1e-9, 'a small drift is inside the deadzone');
|
||||
near(s.y, 0, 1e-9, 'on both axes');
|
||||
|
||||
// Pad Y is positive *downward*, so pushing up must come out positive.
|
||||
h.pad.axes = [0, -1, 0, 0];
|
||||
s = h.input.read(1 / 60);
|
||||
ok(s.y > 0.9, `pushing the stick up is positive y (${s.y.toFixed(2)})`);
|
||||
near(s.x, 0, 1e-9, 'and no x');
|
||||
|
||||
h.pad.axes = [1, 0, 0, 0];
|
||||
s = h.input.read(1 / 60);
|
||||
ok(s.x > 0.9, `pushing right is positive x (${s.x.toFixed(2)})`);
|
||||
|
||||
// Full diagonal must not exceed unit length, or diagonals are faster.
|
||||
h.pad.axes = [1, -1, 0, 0];
|
||||
s = h.input.read(1 / 60);
|
||||
ok(Math.hypot(s.x, s.y) <= 1.0001, `a full diagonal stays on the unit circle (${Math.hypot(s.x, s.y).toFixed(3)})`);
|
||||
|
||||
// The right stick is axes 2/3 and must not be confused with the left.
|
||||
h.pad.axes = [0, 0, 0, -1];
|
||||
s = h.input.read(1 / 60);
|
||||
near(s.x, 0, 1e-9, 'the right stick does not move the skater');
|
||||
ok(s.skill.y > 0.9, `and lands on the Skill Stick (${s.skill.y.toFixed(2)})`);
|
||||
h.restore();
|
||||
}
|
||||
|
||||
section('triggers are analog, not boolean');
|
||||
{
|
||||
const h = harness();
|
||||
h.press(PAD.RT, 0.3);
|
||||
let s = h.input.read(1 / 60);
|
||||
ok(s.hustle > 0.2 && s.hustle < 0.4, `a light pull is a light hustle (${s.hustle.toFixed(2)})`);
|
||||
ok(!s.sprint, 'and does not trip the sprint stride');
|
||||
|
||||
h.press(PAD.RT, 1);
|
||||
s = h.input.read(1 / 60);
|
||||
near(s.hustle, 1, 1e-9, 'a full pull is full hustle');
|
||||
ok(s.sprint, 'and does trip the sprint stride');
|
||||
|
||||
h.press(PAD.LT, 1);
|
||||
s = h.input.read(1 / 60);
|
||||
ok(s.brake, 'the left trigger stops');
|
||||
ok(s.protect > 0.9, `and reports analog (${s.protect.toFixed(2)})`);
|
||||
h.restore();
|
||||
}
|
||||
|
||||
section('buttons report as actions, and only on the edge');
|
||||
{
|
||||
const h = harness();
|
||||
h.input.read(1 / 60);
|
||||
|
||||
h.press(PAD.A);
|
||||
let s = h.input.read(1 / 60);
|
||||
ok(s.pressed.pass, 'A is a pass');
|
||||
ok(s.held.pass, 'and is held');
|
||||
|
||||
s = h.input.read(1 / 60);
|
||||
ok(!s.pressed.pass, 'holding it does not re-fire the press');
|
||||
ok(s.held.pass, 'but it is still held');
|
||||
|
||||
h.release(PAD.A);
|
||||
h.press(PAD.B);
|
||||
s = h.input.read(1 / 60);
|
||||
ok(!s.held.pass, 'releasing clears held');
|
||||
ok(s.pressed.poke, 'B is a poke check');
|
||||
|
||||
h.release(PAD.B);
|
||||
h.press(PAD.LB);
|
||||
s = h.input.read(1 / 60);
|
||||
ok(s.pressed.switchPlayer, 'LB switches player');
|
||||
h.restore();
|
||||
}
|
||||
|
||||
section('the Skill Stick fires a shot on pull-back-and-push');
|
||||
{
|
||||
const h = harness();
|
||||
const dt = 1 / 60;
|
||||
h.input.read(dt);
|
||||
|
||||
// Pull back and hold, which should charge but not fire.
|
||||
h.pad.axes = [0, 0, 0, 1]; // pad Y down = stick pulled back
|
||||
let s;
|
||||
for (let i = 0; i < 20; i++) s = h.input.read(dt);
|
||||
ok(s.shot === null, 'holding the stick back does not fire');
|
||||
ok(s.charge > 0.4, `it winds up instead (${s.charge.toFixed(2)})`);
|
||||
|
||||
// Push forward: release.
|
||||
h.pad.axes = [0, 0, 0, -1];
|
||||
s = h.input.read(dt);
|
||||
ok(s.shot, 'pushing forward releases the shot');
|
||||
ok(s.shot.power > 0.5, `with real power after a long wind-up (${s.shot.power.toFixed(2)})`);
|
||||
near(s.charge, 0, 1e-9, 'and the wind-up is spent');
|
||||
|
||||
s = h.input.read(dt);
|
||||
ok(s.shot === null, 'the shot fires once, not every frame after');
|
||||
h.restore();
|
||||
}
|
||||
|
||||
section('a quick flick is a weaker shot than a full wind-up');
|
||||
{
|
||||
function fire(windFrames) {
|
||||
const h = harness();
|
||||
const dt = 1 / 60;
|
||||
h.input.read(dt);
|
||||
h.pad.axes = [0, 0, 0, 1];
|
||||
for (let i = 0; i < windFrames; i++) h.input.read(dt);
|
||||
h.pad.axes = [0, 0, 0, -1];
|
||||
const s = h.input.read(dt);
|
||||
h.restore();
|
||||
return s.shot;
|
||||
}
|
||||
const flick = fire(2);
|
||||
const loaded = fire(40);
|
||||
ok(flick, 'a flick still fires');
|
||||
ok(loaded, 'and so does a full wind-up');
|
||||
ok(loaded.power > flick.power, `holding longer hits harder (${loaded.power.toFixed(2)} vs ${flick.power.toFixed(2)})`);
|
||||
ok(flick.power >= 0.25, `but a snap shot is never nothing (${flick.power.toFixed(2)})`);
|
||||
}
|
||||
|
||||
section('an abandoned wind-up is forgotten, not banked');
|
||||
{
|
||||
const h = harness();
|
||||
const dt = 1 / 60;
|
||||
h.input.read(dt);
|
||||
h.pad.axes = [0, 0, 0, 1];
|
||||
for (let i = 0; i < 8; i++) h.input.read(dt);
|
||||
// Let go back to centre and wait it out.
|
||||
h.pad.axes = [0, 0, 0, 0];
|
||||
let s;
|
||||
for (let i = 0; i < 150; i++) s = h.input.read(dt);
|
||||
ok(s.shot === null, 'nothing fired from a wind-up left to rot');
|
||||
near(s.charge, 0, 1e-9, 'and the charge decayed away');
|
||||
h.restore();
|
||||
}
|
||||
|
||||
section('the shot carries aim from the stick');
|
||||
{
|
||||
const h = harness();
|
||||
const dt = 1 / 60;
|
||||
h.input.read(dt);
|
||||
h.pad.axes = [0, 0, 0.8, 1]; // wound back, stick held to the right
|
||||
for (let i = 0; i < 20; i++) h.input.read(dt);
|
||||
h.pad.axes = [0, 0, 0.8, -1];
|
||||
const s = h.input.read(dt);
|
||||
ok(s.shot, 'the shot fired');
|
||||
ok(s.shot.aim > 0.5, `and remembers it was aimed right (${s.shot.aim.toFixed(2)})`);
|
||||
h.restore();
|
||||
}
|
||||
|
||||
section('the shoot button works for anyone who never learns the Skill Stick');
|
||||
{
|
||||
const h = harness();
|
||||
h.input.read(1 / 60);
|
||||
h.press(PAD.X);
|
||||
const s = h.input.read(1 / 60);
|
||||
ok(s.shot, 'X shoots');
|
||||
ok(s.shot.power > 0 && s.shot.power <= 1, `at a sensible power (${s.shot.power.toFixed(2)})`);
|
||||
h.restore();
|
||||
}
|
||||
|
||||
section('rumble never throws, whatever the pad supports');
|
||||
{
|
||||
const h = harness();
|
||||
ok(h.input.rumble(1, 1, 100) === false, 'a pad without haptics reports no rumble rather than crashing');
|
||||
h.pad.vibrationActuator = { playEffect: () => Promise.resolve('complete') };
|
||||
ok(h.input.rumble(1, 1, 100) === true, 'and a pad with them reports success');
|
||||
h.pad.vibrationActuator = { playEffect: () => { throw new Error('nope'); } };
|
||||
ok(h.input.rumble(1, 1, 100) === false, 'a throwing actuator is swallowed');
|
||||
h.restore();
|
||||
}
|
||||
|
||||
done('input');
|
||||
@@ -0,0 +1,312 @@
|
||||
import * as THREE from 'three';
|
||||
import { createPhysicsWorld, initPhysics } from '../src/physics/world.js';
|
||||
import { createBodyProxy } from '../src/physics/bodyProxy.js';
|
||||
import { CAT } from '../src/physics/bridge.js';
|
||||
import { createSkater } from '../src/character/skater.js';
|
||||
import { spawnLineup } from '../shared/ai.js';
|
||||
import { SKATE, createSkaterState, speedOf, stepSkater } from '../shared/skaterSim.js';
|
||||
import { RINK, insideRink } from '../shared/rink.js';
|
||||
import { done, near, ok, section } from './harness.mjs';
|
||||
|
||||
/**
|
||||
* Box3D integration.
|
||||
*
|
||||
* The claim these tests exist to check is the one the spike rests on: that
|
||||
* board contact and skater-on-skater contact are solved by the physics engine
|
||||
* and come back into the sim as momentum, rather than being faked by a clamp.
|
||||
* Everything else about the skating is covered headlessly in skaterSim.mjs.
|
||||
*/
|
||||
|
||||
const DT = 1 / 120;
|
||||
|
||||
await initPhysics();
|
||||
|
||||
/** A world plus `n` skaters wired the way the match loop wires them. */
|
||||
function makeWorld(spawns) {
|
||||
const physics = createPhysicsWorld();
|
||||
const states = spawns.map((sp, i) => createSkaterState(i, sp));
|
||||
const proxies = spawns.map((sp, i) => {
|
||||
const p = createBodyProxy(physics, { index: i, position: sp });
|
||||
p.teleport(sp.x, sp.z);
|
||||
return p;
|
||||
});
|
||||
return { physics, states, proxies };
|
||||
}
|
||||
|
||||
/** Step the match loop's inner cycle for `seconds`. */
|
||||
function run(w, seconds, drive) {
|
||||
const steps = Math.round(seconds / DT);
|
||||
for (let n = 0; n < steps; n++) {
|
||||
for (let i = 0; i < w.states.length; i++) {
|
||||
w.proxies[i].read(w.states[i]);
|
||||
if (drive) drive(w.states[i], i, n * DT);
|
||||
stepSkater(w.states[i], DT, { clampBoards: false });
|
||||
w.proxies[i].write(w.states[i]);
|
||||
}
|
||||
w.physics.step(DT);
|
||||
}
|
||||
}
|
||||
|
||||
section('the world builds');
|
||||
{
|
||||
const w = makeWorld([{ x: 0, z: 0, yaw: 0 }]);
|
||||
ok(w.physics.boardBodies.length > 30, `the boards are a real ring (${w.physics.boardBodies.length} segments)`);
|
||||
ok(w.proxies[0].mass > 60 && w.proxies[0].mass < 120, `a skater weighs something plausible (${w.proxies[0].mass.toFixed(0)} kg)`);
|
||||
w.physics.destroy();
|
||||
}
|
||||
|
||||
section('the proxy carries the skater and stays upright');
|
||||
{
|
||||
const w = makeWorld([{ x: -20, z: 0, yaw: Math.PI / 2 }]);
|
||||
run(w, 3, (s) => {
|
||||
s.ix = 1;
|
||||
s.iz = 0;
|
||||
});
|
||||
const t = w.physics.api.b3Body_GetTransform(w.proxies[0].body);
|
||||
ok(t.p.x > -18, `the body actually moved down the ice (x=${t.p.x.toFixed(1)})`);
|
||||
near(t.p.y, 0, 1e-3, 'and never left the ice');
|
||||
near(t.q.v.x, 0, 1e-4, 'and never tipped over (x)');
|
||||
near(t.q.v.z, 0, 1e-4, 'and never tipped over (z)');
|
||||
near(w.states[0].x, t.p.x, 1e-6, 'the sim reads its position straight out of Box3D');
|
||||
w.physics.destroy();
|
||||
}
|
||||
|
||||
section('the boards stop a skater at full speed');
|
||||
{
|
||||
// Straight at the end boards from centre ice, sprinting, for long enough to
|
||||
// be well past them if nothing were there.
|
||||
const w = makeWorld([{ x: 0, z: 0, yaw: Math.PI / 2 }]);
|
||||
run(w, 12, (s) => {
|
||||
s.ix = 1;
|
||||
s.iz = 0;
|
||||
s.sprint = true;
|
||||
});
|
||||
const s = w.states[0];
|
||||
ok(insideRink(s.x, s.z, SKATE.radius * 0.9), `stopped by the end boards (x=${s.x.toFixed(2)} of ${RINK.halfX})`);
|
||||
ok(s.x > RINK.halfX - 2, 'and got all the way to them');
|
||||
w.physics.destroy();
|
||||
}
|
||||
|
||||
section('the corners hold too');
|
||||
{
|
||||
// The corners are the interesting case: they are a chain of short boxes, and
|
||||
// a body driven into the seam between two of them is exactly how a skater
|
||||
// escapes a rink.
|
||||
for (const heading of [0.5, 1.0, 2.2, -0.8, -2.5]) {
|
||||
const w = makeWorld([{ x: 0, z: 0, yaw: heading }]);
|
||||
run(w, 14, (s) => {
|
||||
s.ix = Math.sin(heading);
|
||||
s.iz = Math.cos(heading);
|
||||
s.sprint = true;
|
||||
});
|
||||
const s = w.states[0];
|
||||
ok(
|
||||
insideRink(s.x, s.z, SKATE.radius * 0.9),
|
||||
`heading ${heading.toFixed(1)} stayed inside (${s.x.toFixed(1)}, ${s.z.toFixed(1)})`,
|
||||
);
|
||||
w.physics.destroy();
|
||||
}
|
||||
}
|
||||
|
||||
section('a board hit costs speed');
|
||||
{
|
||||
// Started far enough out that four seconds of sprinting is a run-up, not a
|
||||
// collision — the measurement below is the speed *arriving* at the boards.
|
||||
const w = makeWorld([{ x: -8, z: 0, yaw: Math.PI / 2 }]);
|
||||
run(w, 4, (s) => {
|
||||
s.ix = 1;
|
||||
s.iz = 0;
|
||||
s.sprint = true;
|
||||
});
|
||||
const entry = speedOf(w.states[0]);
|
||||
ok(w.states[0].x < RINK.halfX - 3, `still short of the boards after the run-up (x=${w.states[0].x.toFixed(1)})`);
|
||||
ok(entry > 5, `carrying real speed into them (${entry.toFixed(1)} m/s)`);
|
||||
run(w, 3, (s) => {
|
||||
s.ix = 1;
|
||||
s.iz = 0;
|
||||
s.sprint = true;
|
||||
});
|
||||
// Still pushing into the wall, so speed should be near nothing, not bouncing
|
||||
// around the rink.
|
||||
ok(speedOf(w.states[0]) < 1.5, `pinned against the boards (${speedOf(w.states[0]).toFixed(2)} m/s)`);
|
||||
w.physics.destroy();
|
||||
}
|
||||
|
||||
section('two skaters cannot occupy the same ice');
|
||||
{
|
||||
// The worst case the engine will ever see: both at full sprint, dead head
|
||||
// on, both still pushing after contact for several seconds.
|
||||
//
|
||||
// They settle around 0.53 m apart rather than at two capsule radii (0.72 m).
|
||||
// That is not a solver failure — raising the substep count does not move it
|
||||
// by a millimetre — it is the equilibrium of two bodies whose velocity is
|
||||
// *commanded* by the sim each step leaning on each other. The proxy radius
|
||||
// is deliberately larger than the body it carries (torso half-width is about
|
||||
// 0.22 m), so at that separation the two torsos still have ~10 cm of daylight
|
||||
// between them and nothing visibly intersects.
|
||||
//
|
||||
// What would be a real failure is passing through, so that is checked too.
|
||||
const w = makeWorld([
|
||||
{ x: -8, z: 0, yaw: Math.PI / 2 },
|
||||
{ x: 8, z: 0, yaw: -Math.PI / 2 },
|
||||
]);
|
||||
const TORSO_HALF_WIDTH = 0.22;
|
||||
let minGap = Infinity;
|
||||
let crossed = false;
|
||||
const steps = Math.round(6 / DT);
|
||||
for (let n = 0; n < steps; n++) {
|
||||
for (let i = 0; i < 2; i++) {
|
||||
w.proxies[i].read(w.states[i]);
|
||||
w.states[i].ix = i === 0 ? 1 : -1;
|
||||
w.states[i].iz = 0;
|
||||
w.states[i].sprint = true;
|
||||
stepSkater(w.states[i], DT, { clampBoards: false });
|
||||
w.proxies[i].write(w.states[i]);
|
||||
}
|
||||
w.physics.step(DT);
|
||||
const gap = Math.hypot(w.states[0].x - w.states[1].x, w.states[0].z - w.states[1].z);
|
||||
minGap = Math.min(minGap, gap);
|
||||
if (w.states[0].x > w.states[1].x) crossed = true;
|
||||
}
|
||||
ok(!crossed, 'neither skater ever passed through the other');
|
||||
ok(
|
||||
minGap > TORSO_HALF_WIDTH * 2,
|
||||
`torsos never intersected (closest ${minGap.toFixed(2)}m, two torso widths is ${(TORSO_HALF_WIDTH * 2).toFixed(2)}m)`,
|
||||
);
|
||||
ok(minGap < SKATE.radius * 2, 'and they did genuinely make contact');
|
||||
w.physics.destroy();
|
||||
}
|
||||
|
||||
section('a bump transfers momentum into the sim');
|
||||
{
|
||||
// One skater flying, one standing still directly in the way.
|
||||
const w = makeWorld([
|
||||
{ x: -12, z: 0, yaw: Math.PI / 2 },
|
||||
{ x: 4, z: 0, yaw: Math.PI / 2 },
|
||||
]);
|
||||
run(w, 5, (s, i) => {
|
||||
if (i === 0) {
|
||||
s.ix = 1;
|
||||
s.iz = 0;
|
||||
s.sprint = true;
|
||||
} else {
|
||||
s.ix = 0;
|
||||
s.iz = 0;
|
||||
}
|
||||
});
|
||||
const victim = w.states[1];
|
||||
ok(victim.x > 4.05, `the stationary skater was shoved down the ice (x ${victim.x.toFixed(2)} from 4.00)`);
|
||||
ok(speedOf(victim) > 0.3, `and carried real speed away from it (${speedOf(victim).toFixed(2)} m/s)`);
|
||||
ok(speedOf(victim) < SKATE.speedCeiling, 'without being launched');
|
||||
w.physics.destroy();
|
||||
}
|
||||
|
||||
section('a glancing hit knocks a skater off their line');
|
||||
{
|
||||
// Passing shoulder to shoulder rather than head on.
|
||||
const w = makeWorld([
|
||||
{ x: -10, z: 0.3, yaw: Math.PI / 2 },
|
||||
{ x: 10, z: -0.3, yaw: -Math.PI / 2 },
|
||||
]);
|
||||
run(w, 6, (s, i) => {
|
||||
s.ix = i === 0 ? 1 : -1;
|
||||
s.iz = 0;
|
||||
s.sprint = true;
|
||||
});
|
||||
ok(
|
||||
Math.abs(w.states[0].z) > 0.4 || Math.abs(w.states[1].z) > 0.4,
|
||||
`contact pushed someone off their line (z ${w.states[0].z.toFixed(2)} / ${w.states[1].z.toFixed(2)})`,
|
||||
);
|
||||
w.physics.destroy();
|
||||
}
|
||||
|
||||
section('the ragdoll is built and follows the animated skeleton');
|
||||
{
|
||||
// Nothing in spike 1 pushes the rig, but it has to be there and correct or
|
||||
// the first hit in spike 2 will land on a rig that was never wired up.
|
||||
const physics = createPhysicsWorld();
|
||||
const scene = new THREE.Group();
|
||||
const sk = createSkater({ seed: 5, scene, physics, index: 0, team: 0, position: { x: 3, z: -2 }, facing: 0.4 });
|
||||
|
||||
ok(sk.ragdoll, 'a skater has a ragdoll');
|
||||
ok(sk.ragdoll.order.length === 18, `18 capsules (${sk.ragdoll.order.length})`);
|
||||
ok(sk.ragdoll.joints.length === 17, `17 joints (${sk.ragdoll.joints.length})`);
|
||||
ok(sk.ragdoll.mode === 'driven', 'and starts kinematic, chasing the animation');
|
||||
|
||||
const mass = sk.ragdoll.totalMass();
|
||||
ok(mass > 70 && mass < 100, `the rig weighs a person (${mass.toFixed(0)} kg)`);
|
||||
|
||||
// Drive it the way the match loop does, then check the physics bodies ended
|
||||
// up on the bones rather than at the origin.
|
||||
const state = createSkaterState(0, { x: 3, z: -2, yaw: 0.4 });
|
||||
for (let n = 0; n < 120; n++) {
|
||||
state.ix = 1;
|
||||
state.iz = 0;
|
||||
stepSkater(state, DT, { clampBoards: false });
|
||||
sk.applyState(state, 0);
|
||||
sk.update(DT);
|
||||
physics.step(DT, (fixedDt) => sk.ragdoll.syncFromSkeleton(fixedDt));
|
||||
}
|
||||
|
||||
const api = physics.api;
|
||||
const bone = new THREE.Vector3();
|
||||
let worst = 0;
|
||||
for (const part of sk.ragdoll.order) {
|
||||
part.bone.getWorldPosition(bone);
|
||||
const p = api.b3Body_GetPosition(part.body);
|
||||
worst = Math.max(worst, Math.hypot(p.x - bone.x, p.y - bone.y, p.z - bone.z));
|
||||
}
|
||||
ok(worst < 0.05, `every capsule sits on its bone (worst gap ${worst.toFixed(4)}m)`);
|
||||
|
||||
// And the whole rig travelled with the skater rather than staying at spawn.
|
||||
const pelvis = api.b3Body_GetPosition(sk.ragdoll.parts.pelvis.body);
|
||||
ok(Math.abs(pelvis.x - state.x) < 0.4, `the rig moved with the skater (${pelvis.x.toFixed(2)} vs ${state.x.toFixed(2)})`);
|
||||
ok(pelvis.y > 0.6 && pelvis.y < 1.1, `and its hips are at hip height (${pelvis.y.toFixed(2)}m)`);
|
||||
|
||||
sk.dispose();
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('a full 3-on-3 runs without anything escaping');
|
||||
{
|
||||
// Six bodies, all sprinting at centre ice at once, for twenty-five seconds.
|
||||
// This is the pile-up case: every proxy in contact with several others while
|
||||
// the sim keeps commanding velocity into the middle of the heap.
|
||||
const w = makeWorld(spawnLineup(3, 2));
|
||||
ok(w.states.length === 6, 'six skaters on the ice');
|
||||
run(w, 25, (s, i, t) => {
|
||||
const dx = -s.x;
|
||||
const dz = -s.z;
|
||||
const len = Math.hypot(dx, dz) || 1;
|
||||
s.ix = (dx / len) * Math.sin(t * 0.7 + i);
|
||||
s.iz = (dz / len) * Math.cos(t * 0.5 + i);
|
||||
s.sprint = true;
|
||||
});
|
||||
for (let i = 0; i < w.states.length; i++) {
|
||||
const s = w.states[i];
|
||||
ok(Number.isFinite(s.x) && Number.isFinite(s.z), `skater ${i} stayed finite`);
|
||||
ok(insideRink(s.x, s.z, SKATE.radius * 0.9), `skater ${i} stayed on the ice`);
|
||||
ok(speedOf(s) <= SKATE.speedCeiling, `skater ${i} never exceeded the speed ceiling`);
|
||||
}
|
||||
// Nobody ends up standing inside anybody, even after a sustained pile-up.
|
||||
for (let i = 0; i < w.states.length; i++) {
|
||||
for (let j = i + 1; j < w.states.length; j++) {
|
||||
const d = Math.hypot(w.states[i].x - w.states[j].x, w.states[i].z - w.states[j].z);
|
||||
ok(d > 0.44, `skaters ${i} and ${j} are not inside each other (${d.toFixed(2)}m)`);
|
||||
}
|
||||
}
|
||||
w.physics.destroy();
|
||||
}
|
||||
|
||||
section('every skater in a 3-on-3 gets its own collision layer');
|
||||
{
|
||||
// Ragdoll categories are one bit per skater from bit 1 up, and the proxy
|
||||
// layer sits at bit 15. Six a side would still fit; this checks the two do
|
||||
// not collide at the roster sizes we actually intend to reach.
|
||||
for (let i = 0; i < 10; i++) {
|
||||
ok(CAT.skater(i) !== CAT.PROXY, `skater ${i}'s ragdoll bit is not the proxy bit`);
|
||||
ok((CAT.skater(i) & CAT.RINK) === 0n, `skater ${i}'s ragdoll bit is not the rink bit`);
|
||||
}
|
||||
}
|
||||
|
||||
done('physics');
|
||||
+394
@@ -0,0 +1,394 @@
|
||||
import * as THREE from 'three';
|
||||
import { buildSkeleton } from '../src/character/skeleton.js';
|
||||
import { buildAnimator } from '../src/anim/skateAnimator.js';
|
||||
import { buildStick } from '../src/character/stick.js';
|
||||
import { segDist } from '../src/core/math.js';
|
||||
import { done, ok, section } from './harness.mjs';
|
||||
|
||||
/**
|
||||
* Animator checks, run headlessly.
|
||||
*
|
||||
* Nothing here needs a GPU: the skeleton is three.js Bones and the animator is
|
||||
* maths. That makes the pose the one part of the render path that can be
|
||||
* regression-tested, which is worth doing because "the skater looks wrong" is
|
||||
* otherwise only ever caught by a human squinting at a screenshot.
|
||||
*/
|
||||
|
||||
const DT = 1 / 60;
|
||||
|
||||
function rig() {
|
||||
const skelData = buildSkeleton();
|
||||
const mover = new THREE.Group();
|
||||
// Same hierarchy as createSkater: skeleton rides on the mover so body yaw
|
||||
// carries the bones. Leaving the root unparented made every yaw test a lie —
|
||||
// the stick target orbited in world space while the hand sat still.
|
||||
mover.add(skelData.rootBone);
|
||||
const anim = buildAnimator(skelData, mover);
|
||||
// The stick is part of the pose now — it hangs off the hand and the animator
|
||||
// aims it, so a rig without one is not the rig the game runs.
|
||||
const stick = buildStick(null, null, 0);
|
||||
stick.attachTo(skelData.bones.handR);
|
||||
anim.stick = stick;
|
||||
return { skelData, mover, anim, stick };
|
||||
}
|
||||
|
||||
/** Drive the animator for `seconds` under a fixed set of inputs. */
|
||||
function drive(r, seconds, inputs) {
|
||||
const steps = Math.round(seconds / DT);
|
||||
for (let i = 0; i < steps; i++) {
|
||||
Object.assign(r.anim, inputs);
|
||||
r.anim.update(DT);
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
const _v = new THREE.Vector3();
|
||||
/** World position of a bone, relative to the mover's own frame. */
|
||||
function bonePos(r, name) {
|
||||
r.mover.updateMatrixWorld(true);
|
||||
r.skelData.bones[name].getWorldPosition(_v);
|
||||
return _v.clone().sub(r.mover.position);
|
||||
}
|
||||
|
||||
/** How far a limb sticks out sideways, as an angle from straight down. */
|
||||
function spread(hip, hand) {
|
||||
const dx = Math.abs(hand.x - hip.x);
|
||||
const dy = hip.y - hand.y;
|
||||
return Math.atan2(dx, Math.max(1e-6, dy));
|
||||
}
|
||||
|
||||
const GLIDE = { moveSpeed: 6, bladeSpeed: 6, effort: 0, yawRate: 0, braking: false, originYaw: 0 };
|
||||
const STRIDE = { moveSpeed: 6, bladeSpeed: 6, effort: 1, yawRate: 0, braking: false, originYaw: 0 };
|
||||
const STAND = { moveSpeed: 0, bladeSpeed: 0, effort: 0, yawRate: 0, braking: false, originYaw: 0 };
|
||||
const CARVE = { moveSpeed: 7, bladeSpeed: 7, effort: 0.8, yawRate: 1.2, braking: false, originYaw: 0 };
|
||||
|
||||
section('nothing produces NaN');
|
||||
{
|
||||
for (const [name, inputs] of Object.entries({ GLIDE, STRIDE, STAND, CARVE })) {
|
||||
const r = drive(rig(), 4, inputs);
|
||||
let bad = 0;
|
||||
for (const b of r.skelData.list) {
|
||||
for (const e of b.matrixWorld.elements) if (!Number.isFinite(e)) bad++;
|
||||
}
|
||||
ok(bad === 0, `${name} leaves every bone matrix finite`);
|
||||
}
|
||||
}
|
||||
|
||||
section('the skater stands on the ice, not in it or above it');
|
||||
{
|
||||
for (const [name, inputs] of Object.entries({ GLIDE, STRIDE, STAND, CARVE })) {
|
||||
const r = drive(rig(), 4, inputs);
|
||||
for (const side of ['L', 'R']) {
|
||||
const foot = bonePos(r, `foot${side}`);
|
||||
ok(foot.y > -0.02, `${name}: ${side} foot is not through the ice (y=${foot.y.toFixed(3)})`);
|
||||
ok(foot.y < 0.35, `${name}: ${side} foot is not floating (y=${foot.y.toFixed(3)})`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
section('the skater is crouched, and more so under a stride');
|
||||
{
|
||||
const glide = drive(rig(), 4, GLIDE);
|
||||
const stride = drive(rig(), 4, STRIDE);
|
||||
const hipG = bonePos(glide, 'pelvis').y;
|
||||
const hipS = bonePos(stride, 'pelvis').y;
|
||||
// Rest pelvis height is 1.0; a hockey stance sits well under that.
|
||||
ok(hipG < 0.95, `gliding hips are below rest height (${hipG.toFixed(3)})`);
|
||||
ok(hipS < hipG, `a stride sits deeper than a glide (${hipS.toFixed(3)} vs ${hipG.toFixed(3)})`);
|
||||
ok(hipS > 0.6, `but not folded in half (${hipS.toFixed(3)})`);
|
||||
|
||||
const head = bonePos(stride, 'head');
|
||||
ok(head.y > hipS + 0.35, `the head is still well above the hips (${head.y.toFixed(3)})`);
|
||||
}
|
||||
|
||||
section('the torso is pitched forward, but not folded over');
|
||||
{
|
||||
/** Angle of the pelvis→neck line from vertical, degrees. */
|
||||
function torsoAngle(inputs) {
|
||||
const r = drive(rig(), 4, inputs);
|
||||
const hips = bonePos(r, 'pelvis');
|
||||
const neck = bonePos(r, 'neck');
|
||||
const up = neck.clone().sub(hips);
|
||||
return Math.atan2(Math.hypot(up.x, up.z), up.y) * 57.3;
|
||||
}
|
||||
const stand = torsoAngle(STAND);
|
||||
const stride = torsoAngle(STRIDE);
|
||||
ok(stand > 3 && stand < 22, `a standing skater is slightly forward (${stand.toFixed(0)}°)`);
|
||||
ok(stride > 25, `at speed they are properly over their skates (${stride.toFixed(0)}°)`);
|
||||
ok(stride < 55, `but not bent double (${stride.toFixed(0)}°)`);
|
||||
ok(stride > stand + 8, 'and more folded moving than standing');
|
||||
|
||||
// The head has to come back up, or they are skating looking at their boots.
|
||||
// Measured off the head bone's own forward axis rather than off a bone
|
||||
// offset: the head is a leaf, so there is no child position to read a
|
||||
// direction from.
|
||||
const r = drive(rig(), 4, STRIDE);
|
||||
r.mover.updateMatrixWorld(true);
|
||||
const gazeDir = new THREE.Vector3(0, 0, 1)
|
||||
.applyQuaternion(r.skelData.bones.head.getWorldQuaternion(new THREE.Quaternion()));
|
||||
const gaze = Math.asin(-gazeDir.y) * 57.3;
|
||||
ok(gaze < stride - 8, `the eyes are up the ice, not on the boots (${gaze.toFixed(0)}° down vs a ${stride.toFixed(0)}° torso)`);
|
||||
ok(gaze > -20, 'and not craned back at the roof');
|
||||
}
|
||||
|
||||
section('arms hang by the body, not out in a T-pose');
|
||||
{
|
||||
for (const [name, inputs] of Object.entries({ GLIDE, STRIDE, STAND })) {
|
||||
const r = drive(rig(), 4, inputs);
|
||||
for (const side of ['L', 'R']) {
|
||||
const shoulder = bonePos(r, `upperArm${side}`);
|
||||
const hand = bonePos(r, `hand${side}`);
|
||||
const angle = spread(shoulder, hand);
|
||||
// Wider than the old free-arm limit on purpose: these hands are holding
|
||||
// a stick out in front, which is not the same silhouette as a skater
|
||||
// swinging their arms.
|
||||
ok(
|
||||
angle < 1.15,
|
||||
`${name}: ${side} arm is within 66° of the body (${(angle * 57.3).toFixed(0)}°)`,
|
||||
);
|
||||
ok(hand.y < shoulder.y, `${name}: ${side} hand is below the shoulder`);
|
||||
// Hands carried in front, the way a skater carries them.
|
||||
ok(hand.z > -0.15, `${name}: ${side} hand is not trailing behind the back (z=${hand.z.toFixed(2)})`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
section('the elbows are bent');
|
||||
{
|
||||
const r = drive(rig(), 4, STRIDE);
|
||||
for (const side of ['L', 'R']) {
|
||||
const shoulder = bonePos(r, `upperArm${side}`);
|
||||
const elbow = bonePos(r, `forearm${side}`);
|
||||
const hand = bonePos(r, `hand${side}`);
|
||||
const upper = elbow.clone().sub(shoulder).normalize();
|
||||
const fore = hand.clone().sub(elbow).normalize();
|
||||
const bend = Math.acos(Math.max(-1, Math.min(1, upper.dot(fore))));
|
||||
ok(bend > 0.35, `${side} elbow is bent (${(bend * 57.3).toFixed(0)}°)`);
|
||||
ok(bend < 2.2, `${side} elbow is not folded shut (${(bend * 57.3).toFixed(0)}°)`);
|
||||
}
|
||||
}
|
||||
|
||||
section('a stride moves the legs, a glide does not');
|
||||
{
|
||||
function footTravel(inputs) {
|
||||
const r = rig();
|
||||
let minZ = Infinity;
|
||||
let maxZ = -Infinity;
|
||||
for (let i = 0; i < 240; i++) {
|
||||
Object.assign(r.anim, inputs);
|
||||
r.anim.update(DT);
|
||||
const f = bonePos(r, 'footL');
|
||||
minZ = Math.min(minZ, f.z);
|
||||
maxZ = Math.max(maxZ, f.z);
|
||||
}
|
||||
return maxZ - minZ;
|
||||
}
|
||||
const strideTravel = footTravel(STRIDE);
|
||||
const glideTravel = footTravel(GLIDE);
|
||||
ok(strideTravel > 0.3, `a stride swings the blade fore and aft (${strideTravel.toFixed(2)}m)`);
|
||||
ok(glideTravel < 0.08, `a glide holds it still (${glideTravel.toFixed(2)}m)`);
|
||||
}
|
||||
|
||||
section('the skater banks into a turn');
|
||||
{
|
||||
const straight = drive(rig(), 3, { ...CARVE, yawRate: 0 });
|
||||
const right = drive(rig(), 3, { ...CARVE, yawRate: 1.4 });
|
||||
const left = drive(rig(), 3, { ...CARVE, yawRate: -1.4 });
|
||||
|
||||
ok(Math.abs(straight.anim.bank) < 0.02, 'no bank on a straight line');
|
||||
ok(right.anim.bank > 0.3, `a right-hand turn banks right (${right.anim.bank.toFixed(2)} rad)`);
|
||||
ok(left.anim.bank < -0.3, `a left-hand turn banks left (${left.anim.bank.toFixed(2)} rad)`);
|
||||
|
||||
// The lean has to show up in the body, not just in the number.
|
||||
const headR = bonePos(right, 'head');
|
||||
const headS = bonePos(straight, 'head');
|
||||
ok(headR.x > headS.x + 0.1, `the head leads into the turn (${headR.x.toFixed(2)} vs ${headS.x.toFixed(2)})`);
|
||||
}
|
||||
|
||||
section('a hockey stop is a different pose');
|
||||
{
|
||||
const skate = drive(rig(), 3, { ...STRIDE, braking: false });
|
||||
const stop = drive(rig(), 3, { ...STRIDE, braking: true });
|
||||
ok(stop.anim.state === 'stop', 'braking at speed enters the stop state');
|
||||
ok(skate.anim.state === 'skate', 'and not braking does not');
|
||||
|
||||
// Blades across the travel: the toes should be turned well off the body's
|
||||
// forward axis, which is what actually scrapes the ice.
|
||||
const l = stop.skelData.bones.footL.getWorldQuaternion(new THREE.Quaternion());
|
||||
const fwd = new THREE.Vector3(0, 0, 1).applyQuaternion(l);
|
||||
const off = Math.abs(Math.atan2(fwd.x, fwd.z));
|
||||
ok(off > 0.7, `the blades are thrown across the travel (${(off * 57.3).toFixed(0)}°)`);
|
||||
}
|
||||
|
||||
section('a slow skater does not enter the stop state');
|
||||
{
|
||||
const r = drive(rig(), 3, { ...STAND, braking: true });
|
||||
ok(r.anim.state === 'skate', 'braking from a standstill is not a hockey stop');
|
||||
}
|
||||
|
||||
section('feet stay under the body');
|
||||
{
|
||||
for (const [name, inputs] of Object.entries({ GLIDE, STRIDE, CARVE })) {
|
||||
const r = drive(rig(), 4, inputs);
|
||||
for (const side of ['L', 'R']) {
|
||||
const foot = bonePos(r, `foot${side}`);
|
||||
ok(Math.abs(foot.x) < 0.75, `${name}: ${side} blade is not splayed out (x=${foot.x.toFixed(2)})`);
|
||||
ok(Math.abs(foot.z) < 0.6, `${name}: ${side} blade is not stretched out (z=${foot.z.toFixed(2)})`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
section('the blade is on the ice, ahead of the skater');
|
||||
{
|
||||
// The failure this pins: a socket rotation authored in hand space composes
|
||||
// with whatever the arm is doing, so a grip tuned for one gait floats the
|
||||
// blade half a metre up in another. Checked across every skating stance.
|
||||
for (const [name, inputs] of Object.entries({ GLIDE, STRIDE, STAND, CARVE })) {
|
||||
const r = drive(rig(), 4, { ...inputs, hasPuck: true });
|
||||
const blade = new THREE.Vector3();
|
||||
r.stick.bladeWorld(blade);
|
||||
const inv = new THREE.Matrix4().copy(r.mover.matrixWorld).invert();
|
||||
const local = blade.clone().applyMatrix4(inv);
|
||||
ok(local.y > -0.02 && local.y < 0.16, `${name}: blade is on the ice (y=${local.y.toFixed(3)})`);
|
||||
ok(local.z > 0.5, `${name}: and out in front (z=${local.z.toFixed(2)})`);
|
||||
// Carry keeps the blade near the body midline, slightly forehand — not
|
||||
// parked a metre off the hip.
|
||||
ok(Math.abs(local.x) < 0.75, `${name}: not flung out sideways (x=${local.x.toFixed(2)})`);
|
||||
}
|
||||
}
|
||||
|
||||
section('the stick is held, not floating');
|
||||
{
|
||||
// Puck carry must be two-handed: top hand on the butt, lower hand on the
|
||||
// shaft. The old pose parked the stick on the hip and left the off-hand
|
||||
// ~25 cm short — the failure the motion-reference carry frame calls out.
|
||||
const r = drive(rig(), 4, { ...GLIDE, effort: 0.2, hasPuck: true });
|
||||
r.mover.updateMatrixWorld(true);
|
||||
const butt = new THREE.Vector3();
|
||||
const heel = new THREE.Vector3();
|
||||
r.stick.shaftSegment(butt, heel);
|
||||
const handR = new THREE.Vector3();
|
||||
r.skelData.bones.handR.getWorldPosition(handR);
|
||||
ok(handR.distanceTo(butt) < 0.12, `the top hand is on the butt of the stick (${handR.distanceTo(butt).toFixed(3)}m)`);
|
||||
|
||||
const handL = new THREE.Vector3();
|
||||
const closest = new THREE.Vector3();
|
||||
r.skelData.bones.handL.getWorldPosition(handL);
|
||||
const gap = segDist(handL, butt, heel, closest);
|
||||
ok(gap < 0.08, `the lower hand is on the shaft (${gap.toFixed(3)}m)`);
|
||||
|
||||
// Stick sits in front of the body, not parked out on the hip.
|
||||
const inv = new THREE.Matrix4().copy(r.mover.matrixWorld).invert();
|
||||
const handLocal = handR.clone().applyMatrix4(inv);
|
||||
ok(Math.abs(handLocal.x) < 0.28, `top hand is in front of the torso (x=${handLocal.x.toFixed(2)})`);
|
||||
ok(handLocal.z > 0.25, `top hand is out in front (z=${handLocal.z.toFixed(2)})`);
|
||||
}
|
||||
|
||||
section('the stick stays in the socket when the body turns');
|
||||
{
|
||||
// Failure this pins: aiming with setFromUnitVectors in *world* space leaves a
|
||||
// free twist around the shaft that does not cancel under parent yaw. The stick
|
||||
// then rolls with every body turn instead of holding a fixed grip in the hand.
|
||||
const r = rig();
|
||||
// Settle derived quantities first so the spin only changes yaw.
|
||||
drive(r, 2, { ...GLIDE, hasPuck: true, yawRate: 0 });
|
||||
const local0 = new THREE.Quaternion();
|
||||
const local = new THREE.Quaternion();
|
||||
const handQ = new THREE.Quaternion();
|
||||
const stickQ = new THREE.Quaternion();
|
||||
let maxDelta = 0;
|
||||
|
||||
for (let i = 0; i < 48; i++) {
|
||||
const yaw = (i / 48) * Math.PI * 2;
|
||||
r.anim.setTransform(r.mover.position, yaw);
|
||||
Object.assign(r.anim, { ...GLIDE, hasPuck: true, originYaw: yaw, yawRate: 0 });
|
||||
r.anim.update(DT);
|
||||
r.skelData.bones.handR.getWorldQuaternion(handQ);
|
||||
r.stick.group.getWorldQuaternion(stickQ);
|
||||
local.copy(handQ).invert().multiply(stickQ);
|
||||
if (i === 0) local0.copy(local);
|
||||
// 1 - |dot| is 0 for identical orientations (including double-cover).
|
||||
maxDelta = Math.max(maxDelta, 1 - Math.abs(local0.dot(local)));
|
||||
}
|
||||
ok(maxDelta < 0.02, `stick local pose is stable across a full spin (delta ${maxDelta.toFixed(4)})`);
|
||||
}
|
||||
|
||||
section('stick actions run and finish');
|
||||
{
|
||||
for (const action of ['shoot', 'pass', 'poke']) {
|
||||
const r = rig();
|
||||
drive(r, 1, GLIDE);
|
||||
r.anim.playAction(action, { power: 1 });
|
||||
ok(r.anim.action === action, `${action} started`);
|
||||
// Halfway through it must still be running.
|
||||
for (let i = 0; i < 8; i++) {
|
||||
Object.assign(r.anim, GLIDE);
|
||||
r.anim.update(DT);
|
||||
}
|
||||
ok(r.anim.action === action, `${action} is still running mid-way`);
|
||||
for (let i = 0; i < 60; i++) {
|
||||
Object.assign(r.anim, GLIDE);
|
||||
r.anim.update(DT);
|
||||
}
|
||||
ok(r.anim.action === null, `${action} finished and cleared`);
|
||||
}
|
||||
}
|
||||
|
||||
section('a wind-up lifts the blade off the ice and holds');
|
||||
{
|
||||
const r = rig();
|
||||
drive(r, 1, { ...GLIDE, hasPuck: true });
|
||||
const flat = new THREE.Vector3();
|
||||
r.stick.bladeWorld(flat);
|
||||
const inv = new THREE.Matrix4().copy(r.mover.matrixWorld).invert();
|
||||
const flatLocal = flat.clone().applyMatrix4(inv);
|
||||
|
||||
r.anim.action = 'windup';
|
||||
r.anim.actionTime = 0;
|
||||
for (let i = 0; i < 90; i++) {
|
||||
Object.assign(r.anim, { ...GLIDE, hasPuck: true, charge: 1 });
|
||||
r.anim.action = 'windup';
|
||||
r.anim.update(DT);
|
||||
}
|
||||
const back = new THREE.Vector3();
|
||||
r.stick.bladeWorld(back);
|
||||
const backLocal = back.clone().applyMatrix4(inv);
|
||||
// High and back behind the head — not hanging blade-down at hip height.
|
||||
ok(backLocal.y > 1.1, `the blade is up high (y=${backLocal.y.toFixed(2)})`);
|
||||
ok(backLocal.y > flatLocal.y + 0.8, `well above the carry (${flatLocal.y.toFixed(2)} → ${backLocal.y.toFixed(2)})`);
|
||||
ok(backLocal.z < -0.15, `and back behind the body (z=${backLocal.z.toFixed(2)})`);
|
||||
ok(r.anim.action === 'windup', 'and the wind-up is held, not played once');
|
||||
}
|
||||
|
||||
section('Skill Stick right moves the blade to the skater\'s right');
|
||||
{
|
||||
// Local +X is the skater's *left*. Skill Stick +X is pad-right. Getting the
|
||||
// sign wrong mirrored every deke.
|
||||
const right = drive(rig(), 3, { ...GLIDE, hasPuck: true, handling: { x: 1, y: 0 } });
|
||||
const left = drive(rig(), 3, { ...GLIDE, hasPuck: true, handling: { x: -1, y: 0 } });
|
||||
const inv = new THREE.Matrix4().copy(right.mover.matrixWorld).invert();
|
||||
const br = new THREE.Vector3();
|
||||
const bl = new THREE.Vector3();
|
||||
right.stick.bladeWorld(br);
|
||||
left.stick.bladeWorld(bl);
|
||||
br.applyMatrix4(inv);
|
||||
bl.applyMatrix4(new THREE.Matrix4().copy(left.mover.matrixWorld).invert());
|
||||
// Skater's right is −X: stick-right must land more negative than stick-left.
|
||||
ok(br.x < bl.x - 0.3, `stick-right is on the right (x ${br.x.toFixed(2)} vs ${bl.x.toFixed(2)})`);
|
||||
}
|
||||
|
||||
section('hustling changes the grip');
|
||||
{
|
||||
const settled = drive(rig(), 4, { ...GLIDE, effort: 0, moveSpeed: 1, hasPuck: true });
|
||||
const flatOut = drive(rig(), 4, { ...STRIDE, hasPuck: false });
|
||||
ok(settled.anim.hustleGrip < 0.35, `a settled skater keeps two hands on it (${settled.anim.hustleGrip.toFixed(2)})`);
|
||||
ok(flatOut.anim.hustleGrip > 0.7, `a skater at full stride dangles it (${flatOut.anim.hustleGrip.toFixed(2)})`);
|
||||
|
||||
const a = new THREE.Vector3();
|
||||
const b = new THREE.Vector3();
|
||||
settled.stick.bladeWorld(a);
|
||||
flatOut.stick.bladeWorld(b);
|
||||
ok(b.z > a.z + 0.1, `and pushes the blade further out front (${a.z.toFixed(2)} → ${b.z.toFixed(2)})`);
|
||||
}
|
||||
|
||||
done('pose');
|
||||
+324
@@ -0,0 +1,324 @@
|
||||
import * as THREE from 'three';
|
||||
import { createPhysicsWorld, initPhysics } from '../src/physics/world.js';
|
||||
import { PUCK, createPuck } from '../src/physics/puck.js';
|
||||
import { createMatch } from '../src/game/match.js';
|
||||
import { CARRY } from '../src/game/possession.js';
|
||||
import { RINK, insideRink } from '../shared/rink.js';
|
||||
import { done, near, ok, section } from './harness.mjs';
|
||||
|
||||
/**
|
||||
* Puck, stick and possession.
|
||||
*
|
||||
* The two things worth testing hard are the ones that are hard to see: that a
|
||||
* 45 m/s shot does not tunnel through the boards (it moves ten times its own
|
||||
* radius per step, so it will unless it is a bullet), and that possession
|
||||
* behaves sanely at both ends of the magnetism dial — because that dial is a
|
||||
* feel decision that has not been made yet, and the code has to survive
|
||||
* wherever it lands.
|
||||
*/
|
||||
|
||||
const DT = 1 / 60;
|
||||
await initPhysics();
|
||||
|
||||
function arena(perTeam = 1) {
|
||||
const physics = createPhysicsWorld();
|
||||
const match = createMatch({ scene: new THREE.Group(), physics, perTeam, teams: 2 });
|
||||
return { physics, match };
|
||||
}
|
||||
|
||||
/** Park everyone far from the play so they cannot interfere. */
|
||||
function clearIce(match, keep = []) {
|
||||
for (let i = 0; i < match.states.length; i++) {
|
||||
if (keep.includes(i)) continue;
|
||||
const x = -RINK.halfX * 0.8 + i * 3;
|
||||
match.states[i].x = x;
|
||||
match.states[i].z = -RINK.halfZ * 0.75;
|
||||
match.states[i].vx = 0;
|
||||
match.states[i].vz = 0;
|
||||
match.skaters[i].proxy.teleport(x, -RINK.halfZ * 0.75);
|
||||
match.setControl(i, { x: 0, y: 0, sprint: false, brake: false, cameraYaw: 0 });
|
||||
}
|
||||
}
|
||||
|
||||
section('the puck is a regulation puck');
|
||||
{
|
||||
const physics = createPhysicsWorld();
|
||||
const puck = createPuck(physics);
|
||||
near(PUCK.radius * 2, 0.0762, 1e-4, 'three inches across');
|
||||
near(PUCK.thickness, 0.0254, 1e-4, 'one inch thick');
|
||||
near(puck.mass, 0.170, 0.005, `and 170 grams (got ${puck.mass.toFixed(3)} kg)`);
|
||||
puck.destroy();
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('the puck settles flat on the ice and stays there');
|
||||
{
|
||||
const physics = createPhysicsWorld();
|
||||
const puck = createPuck(physics, { position: { x: 0, y: 1.5, z: 0 } });
|
||||
for (let n = 0; n < 3 / DT; n++) physics.step(DT);
|
||||
const p = puck.position();
|
||||
ok(p.y > 0 && p.y < 0.05, `it lands on the surface (y=${p.y.toFixed(4)})`);
|
||||
// Angular X and Z are locked, so it can never be standing on its edge.
|
||||
const q = puck.rotation();
|
||||
const up = new THREE.Vector3(0, 1, 0).applyQuaternion(q);
|
||||
ok(up.y > 0.999, `and lies flat rather than rolling on its edge (up.y=${up.y.toFixed(4)})`);
|
||||
puck.destroy();
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('a hard shot does not tunnel through the boards');
|
||||
{
|
||||
// The headline risk. At 45 m/s the puck covers 0.37 m per 1/120 s step,
|
||||
// roughly ten times its own radius, so without continuous collision it goes
|
||||
// straight through the wall and is never seen again.
|
||||
for (const speed of [20, 45, 55]) {
|
||||
const physics = createPhysicsWorld();
|
||||
const puck = createPuck(physics, { position: { x: 0, y: 0.02, z: 0 } });
|
||||
puck.setVelocity(speed, 0, 0);
|
||||
for (let n = 0; n < 4 / DT; n++) physics.step(DT);
|
||||
const p = puck.position();
|
||||
ok(
|
||||
insideRink(p.x, p.z, 0),
|
||||
`a ${speed} m/s shot stayed in the rink (ended at x=${p.x.toFixed(2)}, z=${p.z.toFixed(2)})`,
|
||||
);
|
||||
ok(Math.abs(p.y) < 1.5, `and did not go over the glass (y=${p.y.toFixed(2)})`);
|
||||
puck.destroy();
|
||||
physics.destroy();
|
||||
}
|
||||
}
|
||||
|
||||
section('a shot into the corner stays in the corner');
|
||||
{
|
||||
// Corners are a chain of short board segments; the seams between them are
|
||||
// where a fast small body escapes if anything is going to.
|
||||
for (const angle of [0.6, 1.1, -0.7, 2.4]) {
|
||||
const physics = createPhysicsWorld();
|
||||
const puck = createPuck(physics, { position: { x: 0, y: 0.02, z: 0 } });
|
||||
puck.setVelocity(Math.sin(angle) * 48, 0, Math.cos(angle) * 48);
|
||||
for (let n = 0; n < 5 / DT; n++) physics.step(DT);
|
||||
const p = puck.position();
|
||||
ok(insideRink(p.x, p.z, 0), `a shot at ${angle.toFixed(1)} rad stayed inside`);
|
||||
puck.destroy();
|
||||
physics.destroy();
|
||||
}
|
||||
}
|
||||
|
||||
section('a dumped puck slides a long way but does stop');
|
||||
{
|
||||
const physics = createPhysicsWorld();
|
||||
const puck = createPuck(physics, { position: { x: -RINK.halfX * 0.9, y: 0.02, z: 0 } });
|
||||
puck.setVelocity(14, 0, 0);
|
||||
let travelled = 0;
|
||||
const start = puck.position().x;
|
||||
for (let n = 0; n < 6 / DT; n++) physics.step(DT);
|
||||
travelled = Math.abs(puck.position().x - start);
|
||||
ok(travelled > 15, `it carries down the ice (${travelled.toFixed(1)}m in 6s)`);
|
||||
ok(puck.speed() < 14, `and does lose speed (${puck.speed().toFixed(1)} m/s left)`);
|
||||
puck.destroy();
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('a skater picks up a loose puck');
|
||||
{
|
||||
const { physics, match } = arena(1);
|
||||
clearIce(match, [0]);
|
||||
match.states[0].x = 0;
|
||||
match.states[0].z = 0;
|
||||
match.states[0].yaw = Math.PI / 2;
|
||||
match.skaters[0].proxy.teleport(0, 0);
|
||||
// Drop the puck right where skater 0's blade is.
|
||||
match.puck.place(0.8, 0.02, 0.2);
|
||||
for (let n = 0; n < 1 / DT; n++) match.update(DT);
|
||||
ok(match.possession.carrier === 0, `skater 0 picked it up (carrier=${match.possession.carrier})`);
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('a carried puck stays with the skater');
|
||||
{
|
||||
const { physics, match } = arena(1);
|
||||
clearIce(match, [0]);
|
||||
match.states[0].x = -20;
|
||||
match.states[0].z = 0;
|
||||
match.states[0].yaw = Math.PI / 2;
|
||||
match.skaters[0].proxy.teleport(-20, 0);
|
||||
match.puck.place(-20 + 0.8, 0.02, 0);
|
||||
match.setControl(0, { x: 1, y: 0, sprint: true, brake: false, cameraYaw: 0 });
|
||||
for (let n = 0; n < 0.5 / DT; n++) match.update(DT);
|
||||
ok(match.possession.carrier === 0, 'possession established');
|
||||
|
||||
let maxGap = 0;
|
||||
for (let n = 0; n < 2.5 / DT; n++) {
|
||||
match.update(DT);
|
||||
if (match.possession.carrier !== 0) break;
|
||||
const p = match.puck.position();
|
||||
maxGap = Math.max(maxGap, Math.hypot(p.x - match.states[0].x, p.z - match.states[0].z));
|
||||
}
|
||||
ok(match.possession.carrier === 0, 'and survived a full-speed rush');
|
||||
ok(maxGap < CARRY.breakRadius + 1, `the puck stayed with the stick (worst ${maxGap.toFixed(2)}m)`);
|
||||
ok(match.states[0].x > -12, `while actually covering ground (x=${match.states[0].x.toFixed(1)})`);
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('the dial does what it says at both ends');
|
||||
{
|
||||
function carryWander(magnetism) {
|
||||
const { physics, match } = arena(1);
|
||||
clearIce(match, [0]);
|
||||
match.states[0].x = -20;
|
||||
match.states[0].z = 0;
|
||||
match.states[0].yaw = Math.PI / 2;
|
||||
match.skaters[0].proxy.teleport(-20, 0);
|
||||
match.puck.place(-20 + 0.8, 0.02, 0);
|
||||
match.possession.tuning.magnetism = magnetism;
|
||||
match.setControl(0, { x: 1, y: 0, sprint: true, brake: false, cameraYaw: 0 });
|
||||
for (let n = 0; n < 0.5 / DT; n++) match.update(DT);
|
||||
const had = match.possession.carrier === 0;
|
||||
|
||||
let worst = 0;
|
||||
let held = 0;
|
||||
for (let n = 0; n < 2 / DT; n++) {
|
||||
match.update(DT);
|
||||
if (match.possession.carrier === 0) {
|
||||
held++;
|
||||
const p = match.puck.position();
|
||||
const c = match.possession.carryPoint(new THREE.Vector3());
|
||||
if (c) worst = Math.max(worst, p.distanceTo(c));
|
||||
}
|
||||
}
|
||||
physics.destroy();
|
||||
return { had, worst, held: held / (2 / DT) };
|
||||
}
|
||||
|
||||
const glued = carryWander(1);
|
||||
const loose = carryWander(0.15);
|
||||
ok(glued.had && loose.had, 'both settings pick the puck up');
|
||||
ok(
|
||||
glued.worst < loose.worst,
|
||||
`high magnetism keeps the puck tighter to the blade (${glued.worst.toFixed(3)}m vs ${loose.worst.toFixed(3)}m)`,
|
||||
);
|
||||
ok(glued.held > 0.9, `and holds possession through the rush (${(glued.held * 100).toFixed(0)}% of frames)`);
|
||||
}
|
||||
|
||||
section('shooting sends the puck away and gives up possession');
|
||||
{
|
||||
const { physics, match } = arena(1);
|
||||
clearIce(match, [0]);
|
||||
match.states[0].x = -10;
|
||||
match.states[0].z = 0;
|
||||
match.states[0].yaw = Math.PI / 2;
|
||||
match.skaters[0].proxy.teleport(-10, 0);
|
||||
match.puck.place(-10 + 0.8, 0.02, 0);
|
||||
for (let n = 0; n < 0.5 / DT; n++) match.update(DT);
|
||||
ok(match.possession.carrier === 0, 'carrying first');
|
||||
|
||||
const fired = match.possession.shoot(1, Math.PI / 2);
|
||||
ok(fired, 'the shot fired');
|
||||
ok(match.possession.carrier === null, 'and possession was given up');
|
||||
ok(match.puck.speed() > 25, `the puck is moving like a shot (${match.puck.speed().toFixed(1)} m/s)`);
|
||||
|
||||
// And it must not be instantly re-captured by the shooter.
|
||||
for (let n = 0; n < 0.1 / DT; n++) match.update(DT);
|
||||
ok(match.possession.carrier !== 0, 'the shooter cannot immediately vacuum it back up');
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('a harder shot travels faster than a soft one');
|
||||
{
|
||||
function fire(power) {
|
||||
const { physics, match } = arena(1);
|
||||
clearIce(match, [0]);
|
||||
match.states[0].x = -10;
|
||||
match.states[0].z = 0;
|
||||
match.states[0].yaw = Math.PI / 2;
|
||||
match.skaters[0].proxy.teleport(-10, 0);
|
||||
match.puck.place(-10 + 0.8, 0.02, 0);
|
||||
for (let n = 0; n < 0.5 / DT; n++) match.update(DT);
|
||||
match.possession.shoot(power, Math.PI / 2);
|
||||
const speed = match.puck.speed();
|
||||
physics.destroy();
|
||||
return speed;
|
||||
}
|
||||
const soft = fire(0.2);
|
||||
const hard = fire(1);
|
||||
ok(hard > soft * 2, `full power is far harder than a soft one (${hard.toFixed(1)} vs ${soft.toFixed(1)} m/s)`);
|
||||
ok(hard < PUCK.maxSpeed, 'and stays under the ceiling');
|
||||
}
|
||||
|
||||
section('a knockdown loses the puck');
|
||||
{
|
||||
const { physics, match } = arena(1);
|
||||
clearIce(match, [0]);
|
||||
match.states[0].x = 0;
|
||||
match.states[0].z = 0;
|
||||
match.skaters[0].proxy.teleport(0, 0);
|
||||
match.puck.place(0.8, 0.02, 0.2);
|
||||
for (let n = 0; n < 1 / DT; n++) match.update(DT);
|
||||
ok(match.possession.carrier === 0, 'carrying first');
|
||||
match.skaters[0].goDown(null);
|
||||
match.update(DT);
|
||||
ok(match.possession.carrier === null, 'going down gives the puck up');
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('the Skill Stick moves the puck around the carrier');
|
||||
{
|
||||
const { physics, match } = arena(1);
|
||||
clearIce(match, [0]);
|
||||
match.states[0].x = 0;
|
||||
match.states[0].z = 0;
|
||||
match.states[0].yaw = Math.PI / 2;
|
||||
match.skaters[0].proxy.teleport(0, 0);
|
||||
match.puck.place(0.8, 0.02, 0);
|
||||
const control = { x: 0, y: 0, sprint: false, brake: false, cameraYaw: 0, skill: { x: 0, y: 0 }, pressed: {} };
|
||||
match.setControl(0, control);
|
||||
for (let n = 0; n < 1 / DT; n++) match.update(DT);
|
||||
ok(match.possession.carrier === 0, 'carrying first');
|
||||
|
||||
control.skill.x = 1;
|
||||
for (let n = 0; n < 0.6 / DT; n++) match.update(DT);
|
||||
const right = match.puck.position().clone();
|
||||
control.skill.x = -1;
|
||||
for (let n = 0; n < 0.6 / DT; n++) match.update(DT);
|
||||
const left = match.puck.position().clone();
|
||||
|
||||
// Skater faces +X (yaw = π/2). Mesh-right is local −X (handR side), which
|
||||
// is world +Z at that yaw — not the sim's up×forward "right", which is
|
||||
// mirrored from the skeleton. Stick-right must follow the mesh.
|
||||
ok(
|
||||
right.z > left.z + 0.25,
|
||||
`stick-right moves the puck to the skater's right (${right.z.toFixed(2)} vs ${left.z.toFixed(2)})`,
|
||||
);
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
section('a 3-on-3 with a puck stays sane and produces contact');
|
||||
{
|
||||
// This is the payoff: give six skaters one thing to want and they converge,
|
||||
// which is what finally exercises the hit system under normal play instead
|
||||
// of only in staged collisions.
|
||||
const { physics, match } = arena(3);
|
||||
let hits = 0;
|
||||
const seen = new Set();
|
||||
for (let n = 0; n < 60 / DT; n++) {
|
||||
match.update(DT);
|
||||
for (const h of match.recentHits) {
|
||||
const id = `${h.at}|${h.attacker}|${h.victim}`;
|
||||
if (!seen.has(id)) {
|
||||
seen.add(id);
|
||||
hits++;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (let i = 0; i < match.states.length; i++) {
|
||||
const s = match.states[i];
|
||||
ok(Number.isFinite(s.x) && Number.isFinite(s.z), `skater ${i} finite after 60s`);
|
||||
ok(insideRink(s.x, s.z, 0.3), `skater ${i} still on the ice`);
|
||||
}
|
||||
const p = match.puck.position();
|
||||
ok(Number.isFinite(p.x) && Number.isFinite(p.z), 'the puck is finite');
|
||||
ok(insideRink(p.x, p.z, 0), `the puck is still on the ice (${p.x.toFixed(1)}, ${p.z.toFixed(1)})`);
|
||||
ok(hits > 0, `chasing a puck produced contact without staging it (${hits} hits in 60s)`);
|
||||
physics.destroy();
|
||||
}
|
||||
|
||||
done('puck');
|
||||
@@ -0,0 +1,77 @@
|
||||
import { RINK, clampToRink, insideRink, randomIcePoint, rinkOutline, rinkPenetration } from '../shared/rink.js';
|
||||
import { done, near, ok, section } from './harness.mjs';
|
||||
|
||||
section('penetration on the straights');
|
||||
{
|
||||
ok(insideRink(0, 0), 'centre ice is on the ice');
|
||||
ok(!insideRink(RINK.halfX + 1, 0), 'past the end boards is not');
|
||||
ok(!insideRink(0, RINK.halfZ + 1), 'past the side boards is not');
|
||||
|
||||
const p = rinkPenetration(0, RINK.halfZ + 0.5);
|
||||
near(p.dist, 0.5, 1e-9, 'side board penetration');
|
||||
near(p.nz, -1, 1e-9, 'side board normal points back to centre');
|
||||
}
|
||||
|
||||
section('penetration in the corners');
|
||||
{
|
||||
// The corner arc centre, pushed out along the diagonal by exactly the radius,
|
||||
// has to land on the boards.
|
||||
const cx = RINK.halfX - RINK.cornerR;
|
||||
const cz = RINK.halfZ - RINK.cornerR;
|
||||
const d = RINK.cornerR / Math.SQRT2;
|
||||
const p = rinkPenetration(cx + d, cz + d);
|
||||
near(p.dist, 0, 1e-9, 'diagonal from the corner centre lands on the boards');
|
||||
near(Math.hypot(p.nx, p.nz), 1, 1e-9, 'corner normal is unit length');
|
||||
ok(p.nx < 0 && p.nz < 0, 'corner normal points inward');
|
||||
|
||||
// A point in the corner quadrant but inside the arc is on the ice, even
|
||||
// though it is outside neither straight wall — this is the case a plain
|
||||
// rectangle test gets wrong.
|
||||
ok(insideRink(cx + 1, cz + 1), 'inside the corner arc is on the ice');
|
||||
ok(!insideRink(RINK.halfX - 0.5, RINK.halfZ - 0.5), 'the clipped corner is off the ice');
|
||||
}
|
||||
|
||||
section('radius is respected');
|
||||
{
|
||||
ok(!insideRink(0, RINK.halfZ - 0.2, 0.36), 'a body wider than its gap does not fit');
|
||||
ok(insideRink(0, RINK.halfZ - 1, 0.36), 'the same body fits with room to spare');
|
||||
}
|
||||
|
||||
section('clamping kills inward velocity');
|
||||
{
|
||||
const s = { x: 0, z: RINK.halfZ + 0.2, vx: 1, vz: 3 };
|
||||
const hit = clampToRink(s, 0.36, 0);
|
||||
ok(hit, 'a body past the boards reports a hit');
|
||||
ok(insideRink(s.x, s.z, 0.36), 'and is put back on the ice');
|
||||
near(s.vz, 0, 1e-9, 'velocity into the boards is removed');
|
||||
near(s.vx, 1, 1e-9, 'velocity along them is kept');
|
||||
|
||||
const bouncy = { x: 0, z: RINK.halfZ + 0.2, vx: 0, vz: 4 };
|
||||
clampToRink(bouncy, 0.36, 0.5);
|
||||
near(bouncy.vz, -2, 1e-9, 'restitution reverses half the closing speed');
|
||||
|
||||
const clear = { x: 0, z: 0, vx: 5, vz: 0 };
|
||||
ok(!clampToRink(clear, 0.36), 'centre ice is not clamped');
|
||||
near(clear.vx, 5, 1e-9, 'and keeps its speed');
|
||||
}
|
||||
|
||||
section('outline follows the boards');
|
||||
{
|
||||
const outline = rinkOutline(8);
|
||||
ok(outline.length === 36, 'four arcs of nine points');
|
||||
let maxOff = 0;
|
||||
for (const p of outline) maxOff = Math.max(maxOff, Math.abs(rinkPenetration(p.x, p.z).dist));
|
||||
near(maxOff, 0, 1e-9, 'every outline point sits exactly on the boards');
|
||||
}
|
||||
|
||||
section('random points land on the ice');
|
||||
{
|
||||
let n = 0;
|
||||
const rand = () => ((n = (n * 1103515245 + 12345) % 2147483648) / 2147483648);
|
||||
for (let i = 0; i < 500; i++) {
|
||||
const p = randomIcePoint(rand, 3);
|
||||
ok(insideRink(p.x, p.z, 3), `waypoint ${i} is 3m clear of the boards`);
|
||||
}
|
||||
}
|
||||
|
||||
done('rink');
|
||||
@@ -0,0 +1,237 @@
|
||||
import * as THREE from 'three';
|
||||
import { createPhysicsWorld, initPhysics } from '../src/physics/world.js';
|
||||
import { createMatch } from '../src/game/match.js';
|
||||
import { createShootout } from '../src/game/shootout.js';
|
||||
import { NET, goalLineX, goalieSpot, isGoal } from '../shared/net.js';
|
||||
import { PUCK } from '../src/physics/puck.js';
|
||||
import { done, near, ok, section } from './harness.mjs';
|
||||
|
||||
/**
|
||||
* The shootout: net, goalie, and the loop that turns them into a result.
|
||||
*
|
||||
* The thing worth testing hard is that it *terminates*. A shootout that can
|
||||
* hang — a puck asleep in a corner, a goalie who never lets go of it, an
|
||||
* attempt with no way to end — is worse than one that scores wrongly, because
|
||||
* nothing tells you it has happened.
|
||||
*/
|
||||
|
||||
const DT = 1 / 60;
|
||||
await initPhysics();
|
||||
|
||||
function arena() {
|
||||
const physics = createPhysicsWorld();
|
||||
const match = createMatch({ scene: new THREE.Group(), physics, perTeam: 3, teams: 2 });
|
||||
const shootout = createShootout({ scene: new THREE.Group(), physics, match });
|
||||
match.addSubstepSync((dt) => {
|
||||
shootout.goalies[1].syncPhysics(dt);
|
||||
shootout.goalies[-1].syncPhysics(dt);
|
||||
});
|
||||
shootout.reset();
|
||||
return { physics, match, shootout };
|
||||
}
|
||||
|
||||
function run(w, seconds) {
|
||||
for (let n = 0; n < seconds / DT; n++) {
|
||||
w.match.update(DT);
|
||||
w.shootout.update(DT);
|
||||
}
|
||||
}
|
||||
|
||||
section('goal detection follows the rule');
|
||||
{
|
||||
const end = 1;
|
||||
const line = goalLineX(end);
|
||||
const r = PUCK.radius;
|
||||
|
||||
ok(!isGoal({ x: line, y: 0.02, z: 0 }, end, r), 'a puck on the line is not a goal');
|
||||
ok(!isGoal({ x: line + r * 0.5, y: 0.02, z: 0 }, end, r), 'nor one only half across');
|
||||
ok(isGoal({ x: line + r * 2, y: 0.02, z: 0 }, end, r), 'fully across and between the posts is');
|
||||
ok(!isGoal({ x: line + r * 2, y: 0.02, z: NET.width }, end, r), 'wide of the post is not');
|
||||
ok(!isGoal({ x: line + r * 2, y: NET.height + 0.2, z: 0 }, end, r), 'over the bar is not');
|
||||
ok(!isGoal({ x: line + NET.depth + 0.5, y: 0.02, z: 0 }, end, r), 'behind the net is not');
|
||||
// And the same at the other end, where every sign flips.
|
||||
const l2 = goalLineX(-1);
|
||||
ok(isGoal({ x: l2 - r * 2, y: 0.02, z: 0 }, -1, r), 'the far end scores too');
|
||||
ok(!isGoal({ x: l2 + r * 2, y: 0.02, z: 0 }, -1, r), 'and not from in front of it');
|
||||
}
|
||||
|
||||
section('the goalie plays the angle');
|
||||
{
|
||||
const end = 1;
|
||||
const line = goalLineX(end);
|
||||
const spot = { x: 0, z: 0 };
|
||||
|
||||
goalieSpot({ x: 0, z: 0 }, end, 0.6, spot);
|
||||
near(spot.z, 0, 1e-9, 'a puck dead centre puts them dead centre');
|
||||
ok(spot.x < line && spot.x > line - 1, `and out in front of the line (${spot.x.toFixed(2)})`);
|
||||
|
||||
// Puck to one side: the goalie shifts the same way, but less.
|
||||
goalieSpot({ x: line - 8, z: 4 }, end, 0.6, spot);
|
||||
ok(spot.z > 0, 'a puck to the left moves them left');
|
||||
ok(spot.z < 4, 'but they do not chase it out there');
|
||||
ok(Math.abs(spot.z) <= NET.width / 2 + 0.25, `and never past the post (${spot.z.toFixed(2)})`);
|
||||
|
||||
// Extreme angle: still covering the post, never abandoning the net.
|
||||
goalieSpot({ x: line, z: 12 }, end, 0.6, spot);
|
||||
ok(Math.abs(spot.z) <= NET.width / 2 + 0.25, 'even from the goal line corner');
|
||||
}
|
||||
|
||||
section('a shootout sets itself up');
|
||||
{
|
||||
const w = arena();
|
||||
const so = w.shootout.state;
|
||||
ok(so.phase === 'ready', 'it starts in the ready phase');
|
||||
ok(so.score[0] === 0 && so.score[1] === 0, 'nil-nil');
|
||||
ok(w.match.possession.carrier === null, 'nobody starts holding the puck');
|
||||
const s = w.match.states[so.shooter];
|
||||
const puck = w.match.puck.position();
|
||||
near(Math.hypot(puck.x, puck.z), 0, 0.3, 'the puck is on the dot at centre ice');
|
||||
ok(Math.hypot(s.x - puck.x, s.z - puck.z) > 3, `and the shooter starts back from it (${Math.hypot(s.x - puck.x, s.z - puck.z).toFixed(1)}m)`);
|
||||
w.physics.destroy();
|
||||
}
|
||||
|
||||
section('the shooter skates onto the puck rather than spawning on it');
|
||||
{
|
||||
const w = arena();
|
||||
ok(w.match.possession.carrier === null, 'loose at the start');
|
||||
// Give them time to get released and reach it.
|
||||
let gained = false;
|
||||
for (let n = 0; n < 6 / DT; n++) {
|
||||
w.match.update(DT);
|
||||
w.shootout.update(DT);
|
||||
if (w.match.possession.carrier === w.shootout.state.shooter) {
|
||||
gained = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
ok(gained, 'the shooter picked the puck up on the way through');
|
||||
w.physics.destroy();
|
||||
}
|
||||
|
||||
section('losing the handle does not end the attempt');
|
||||
{
|
||||
const w = arena();
|
||||
// Run to live, then knock the puck away from whoever has it.
|
||||
for (let n = 0; n < 5 / DT; n++) {
|
||||
w.match.update(DT);
|
||||
w.shootout.update(DT);
|
||||
if (w.shootout.state.phase === 'live' && w.match.possession.carrier !== null) break;
|
||||
}
|
||||
ok(w.shootout.state.phase === 'live', 'the attempt is live');
|
||||
const before = w.shootout.state.attempts.slice();
|
||||
w.match.possession.release('test', 0.2);
|
||||
w.match.puck.setVelocity(0, 0, 0);
|
||||
// Sit on a dead loose puck for well over the old two-second dead timeout.
|
||||
for (let n = 0; n < 3 / DT; n++) {
|
||||
w.match.update(DT);
|
||||
w.shootout.update(DT);
|
||||
}
|
||||
ok(
|
||||
w.shootout.state.attempts[0] === before[0] && w.shootout.state.attempts[1] === before[1],
|
||||
'a dead loose puck did not end the attempt',
|
||||
);
|
||||
w.physics.destroy();
|
||||
}
|
||||
|
||||
section('the AI takes attempts and they all resolve');
|
||||
{
|
||||
const w = arena();
|
||||
const results = [];
|
||||
let lastRound = null;
|
||||
for (let n = 0; n < 120 / DT; n++) {
|
||||
w.match.update(DT);
|
||||
w.shootout.update(DT);
|
||||
const last = w.shootout.state.last;
|
||||
if (last && last !== lastRound) {
|
||||
results.push(last);
|
||||
lastRound = last;
|
||||
}
|
||||
}
|
||||
ok(results.length >= 4, `several attempts completed in two minutes (${results.length})`);
|
||||
for (const r of results) {
|
||||
ok(r.result === 'goal' || r.result === 'save', `every attempt resolved (${r.result} ${r.detail})`);
|
||||
}
|
||||
const so = w.shootout.state;
|
||||
ok(so.attempts[0] > 0 && so.attempts[1] > 0, 'both teams got to shoot');
|
||||
ok(Math.abs(so.attempts[0] - so.attempts[1]) <= 1, 'and the sides alternate');
|
||||
w.physics.destroy();
|
||||
}
|
||||
|
||||
section('bots actually shoot');
|
||||
{
|
||||
// This is the gap that made the whole shooting layer human-only: a bot with
|
||||
// the puck used to carry it forever.
|
||||
const w = arena();
|
||||
let shots = 0;
|
||||
const seen = new Set();
|
||||
for (let n = 0; n < 90 / DT; n++) {
|
||||
w.match.update(DT);
|
||||
w.shootout.update(DT);
|
||||
for (const p of w.match.recentPlays) {
|
||||
const id = `${p.at}|${p.type}|${p.skater}`;
|
||||
if (!seen.has(id)) {
|
||||
seen.add(id);
|
||||
if (p.type === 'shot') shots++;
|
||||
}
|
||||
}
|
||||
}
|
||||
ok(shots > 0, `bots put shots on net without a human driving (${shots})`);
|
||||
w.physics.destroy();
|
||||
}
|
||||
|
||||
section('the goalie makes saves and the shooter sometimes scores');
|
||||
{
|
||||
// Over enough attempts both outcomes have to be reachable, or the goalie is
|
||||
// either a wall or a turnstile and neither is a game.
|
||||
const w = arena();
|
||||
let goals = 0;
|
||||
let saves = 0;
|
||||
let lastRound = null;
|
||||
for (let n = 0; n < 240 / DT; n++) {
|
||||
w.match.update(DT);
|
||||
w.shootout.update(DT);
|
||||
const last = w.shootout.state.last;
|
||||
if (last && last !== lastRound) {
|
||||
lastRound = last;
|
||||
if (last.result === 'goal') goals++;
|
||||
else saves++;
|
||||
}
|
||||
}
|
||||
ok(goals + saves >= 8, `plenty of attempts to judge on (${goals + saves})`);
|
||||
ok(saves > 0, `the goalie stops some (${saves} saves)`);
|
||||
// Not asserted the other way round: a goalie who is currently unbeatable is
|
||||
// a tuning problem, and the number is reported so it can be tuned.
|
||||
console.log(` ${goals} goals / ${saves} saves`);
|
||||
w.physics.destroy();
|
||||
}
|
||||
|
||||
section('nothing escapes and nothing hangs');
|
||||
{
|
||||
const w = arena();
|
||||
run(w, 120);
|
||||
const p = w.match.puck.position();
|
||||
ok(Number.isFinite(p.x) && Number.isFinite(p.z), 'the puck is finite');
|
||||
ok(Math.abs(p.x) < 40 && Math.abs(p.z) < 20, `and still in the building (${p.x.toFixed(1)}, ${p.z.toFixed(1)})`);
|
||||
for (let i = 0; i < w.match.states.length; i++) {
|
||||
ok(Number.isFinite(w.match.states[i].x), `skater ${i} is finite`);
|
||||
}
|
||||
ok(w.shootout.state.round > 1, `rounds advanced (round ${w.shootout.state.round})`);
|
||||
w.physics.destroy();
|
||||
}
|
||||
|
||||
section('the goalie is not knocked around by the puck');
|
||||
{
|
||||
const w = arena();
|
||||
run(w, 3);
|
||||
const g = w.shootout.goalies[1];
|
||||
const before = { x: g.pos.x, z: g.pos.z };
|
||||
// Fire a puck straight into them at full pace.
|
||||
w.match.puck.place(goalLineX(1) - 4, 0.3, 0);
|
||||
w.match.puck.setVelocity(45, 0, 0);
|
||||
run(w, 0.6);
|
||||
// They may have shuffled to track it, but not been shoved into the net.
|
||||
ok(Math.abs(g.pos.x - before.x) < 1.2, `the goalie held their ground (${(g.pos.x - before.x).toFixed(2)}m)`);
|
||||
w.physics.destroy();
|
||||
}
|
||||
|
||||
done('shootout');
|
||||
@@ -0,0 +1,246 @@
|
||||
import { SKATE, applyIntent, createSkaterState, speedOf, stepSkater } from '../shared/skaterSim.js';
|
||||
import { RINK, insideRink } from '../shared/rink.js';
|
||||
import { done, near, ok, section } from './harness.mjs';
|
||||
|
||||
const DT = 1 / 120;
|
||||
|
||||
/**
|
||||
* Run the sim for `seconds`, optionally editing the state each step.
|
||||
*
|
||||
* Board clamping is off by default so a test about acceleration is not
|
||||
* secretly a test about the end boards. The containment section turns it back
|
||||
* on, which is the only place it is the subject.
|
||||
*/
|
||||
function run(s, seconds, edit = null, opts = { clampBoards: false }) {
|
||||
const steps = Math.round(seconds / DT);
|
||||
for (let i = 0; i < steps; i++) {
|
||||
if (edit) edit(s, i * DT);
|
||||
stepSkater(s, DT, opts);
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
/** Down the ice: the rink's long axis is +X, which is yaw = PI/2. */
|
||||
const START = { x: 0, z: 0, yaw: Math.PI / 2 };
|
||||
const forward = (s) => {
|
||||
s.ix = 1;
|
||||
s.iz = 0;
|
||||
};
|
||||
const coast = (s) => {
|
||||
s.ix = 0;
|
||||
s.iz = 0;
|
||||
};
|
||||
|
||||
section('the stride reaches a speed and holds it');
|
||||
{
|
||||
const s = createSkaterState(0, START);
|
||||
run(s, 8, forward);
|
||||
const cruise = speedOf(s);
|
||||
ok(cruise > 4.5, `cruise settles above 4.5 m/s (got ${cruise.toFixed(2)})`);
|
||||
ok(cruise <= SKATE.cruiseSpeed, `and never exceeds the cruise ceiling (${cruise.toFixed(2)})`);
|
||||
|
||||
// Another four seconds must not keep adding speed.
|
||||
const before = speedOf(s);
|
||||
run(s, 4, forward);
|
||||
near(speedOf(s), before, 0.05, 'top speed is stable, not creeping');
|
||||
}
|
||||
|
||||
section('acceleration takes time — you cannot jump to top speed');
|
||||
{
|
||||
const s = createSkaterState(0, START);
|
||||
run(s, 0.5, forward);
|
||||
const half = speedOf(s);
|
||||
ok(half > 0.8, `half a second of pushing gets you moving (${half.toFixed(2)} m/s)`);
|
||||
ok(half < 4, 'but nowhere near cruise');
|
||||
}
|
||||
|
||||
section('sprinting is meaningfully faster');
|
||||
{
|
||||
const cruiser = createSkaterState(0, START);
|
||||
run(cruiser, 8, forward);
|
||||
const sprinter = createSkaterState(1, START);
|
||||
run(sprinter, 8, (s) => {
|
||||
forward(s);
|
||||
s.sprint = true;
|
||||
});
|
||||
ok(
|
||||
speedOf(sprinter) > speedOf(cruiser) + 1.5,
|
||||
`sprint beats cruise by more than 1.5 m/s (${speedOf(sprinter).toFixed(2)} vs ${speedOf(cruiser).toFixed(2)})`,
|
||||
);
|
||||
ok(speedOf(sprinter) <= SKATE.sprintSpeed, 'and stays under the sprint ceiling');
|
||||
}
|
||||
|
||||
section('a glide keeps its momentum');
|
||||
{
|
||||
const s = createSkaterState(0, START);
|
||||
run(s, 8, forward);
|
||||
const entry = speedOf(s);
|
||||
run(s, 3, coast);
|
||||
const after = speedOf(s);
|
||||
ok(after > entry * 0.6, `three seconds of glide keeps most of the speed (${after.toFixed(2)} of ${entry.toFixed(2)})`);
|
||||
ok(after < entry, 'but not all of it');
|
||||
}
|
||||
|
||||
section('braking is much faster than gliding');
|
||||
{
|
||||
const glide = createSkaterState(0, START);
|
||||
run(glide, 8, forward);
|
||||
const brake = createSkaterState(1, START);
|
||||
run(brake, 8, forward);
|
||||
near(speedOf(glide), speedOf(brake), 0.01, 'both start from the same speed');
|
||||
|
||||
run(glide, 1, coast);
|
||||
run(brake, 1, (s) => {
|
||||
coast(s);
|
||||
s.brake = true;
|
||||
});
|
||||
ok(speedOf(brake) < 0.6, `a hockey stop is done inside a second (${speedOf(brake).toFixed(2)} m/s left)`);
|
||||
ok(speedOf(glide) > speedOf(brake) * 4, 'a glide over the same second is nowhere near stopped');
|
||||
}
|
||||
|
||||
section('the blade kills sideways drift');
|
||||
{
|
||||
const s = createSkaterState(0, START);
|
||||
// Thrown across the blade at 4 m/s: body pointing +X, momentum along +Z.
|
||||
s.vx = 0;
|
||||
s.vz = 4;
|
||||
run(s, 1.5, coast);
|
||||
const velYaw = Math.atan2(s.vx, s.vz);
|
||||
const offBlade = Math.abs(Math.abs(velYaw) - Math.PI / 2);
|
||||
ok(offBlade < 0.25, `momentum ends up along the blade, not across it (${offBlade.toFixed(3)} rad off)`);
|
||||
}
|
||||
|
||||
section('a carve redirects momentum instead of destroying it');
|
||||
{
|
||||
const s = createSkaterState(0, START);
|
||||
run(s, 6, forward);
|
||||
const entry = speedOf(s);
|
||||
ok(Math.abs(Math.atan2(s.vx, s.vz) - Math.PI / 2) < 0.05, 'travelling straight down the ice first');
|
||||
|
||||
// Ninety degrees of turn: the stick swings from +X to -Z.
|
||||
run(s, 1.2, (st) => {
|
||||
st.ix = 0;
|
||||
st.iz = -1;
|
||||
});
|
||||
|
||||
const velYaw = Math.atan2(s.vx, s.vz);
|
||||
ok(velYaw > 2.2, `the velocity vector followed the turn round (${velYaw.toFixed(2)} rad, want ~PI)`);
|
||||
ok(speedOf(s) > entry * 0.4, `and kept real speed through it (${speedOf(s).toFixed(2)} of ${entry.toFixed(2)})`);
|
||||
ok(speedOf(s) < entry, 'a hard carve is not free');
|
||||
}
|
||||
|
||||
section('momentum resists an instant reversal');
|
||||
{
|
||||
const s = createSkaterState(0, START);
|
||||
run(s, 6, forward);
|
||||
const entryX = s.vx;
|
||||
ok(entryX > 3, 'moving down the ice to begin with');
|
||||
|
||||
// A tenth of a second of "go back the other way" must not flip the velocity.
|
||||
run(s, 0.1, (st) => {
|
||||
st.ix = -1;
|
||||
st.iz = 0;
|
||||
});
|
||||
ok(s.vx > 0, 'still travelling the original way a tenth of a second later');
|
||||
ok(s.vx < entryX, 'but already losing speed to the edges');
|
||||
}
|
||||
|
||||
section('a turn on the spot costs nothing');
|
||||
{
|
||||
const s = createSkaterState(0, { x: 0, z: 0, yaw: 0 });
|
||||
run(s, 0.6, (st) => {
|
||||
st.ix = 1;
|
||||
st.iz = 0;
|
||||
});
|
||||
ok(Math.abs(s.yaw - Math.PI / 2) < 0.35, `a standing skater can pivot (yaw ${s.yaw.toFixed(2)})`);
|
||||
}
|
||||
|
||||
section('turning is harder at speed than at rest');
|
||||
{
|
||||
const slow = createSkaterState(0, { x: 0, z: 0, yaw: 0 });
|
||||
run(slow, 0.3, (st) => {
|
||||
st.ix = 1;
|
||||
st.iz = 0;
|
||||
});
|
||||
const fast = createSkaterState(1, { x: 0, z: 0, yaw: 0 });
|
||||
run(fast, 6, (st) => {
|
||||
st.ix = 0;
|
||||
st.iz = 1;
|
||||
st.sprint = true;
|
||||
});
|
||||
const before = fast.yaw;
|
||||
run(fast, 0.3, (st) => {
|
||||
st.ix = 1;
|
||||
st.iz = 0;
|
||||
st.sprint = true;
|
||||
});
|
||||
ok(
|
||||
Math.abs(fast.yaw - before) < Math.abs(slow.yaw),
|
||||
`a flying skater turns slower than a standing one (${(fast.yaw - before).toFixed(3)} vs ${slow.yaw.toFixed(3)} rad)`,
|
||||
);
|
||||
}
|
||||
|
||||
section('nothing leaves the rink');
|
||||
{
|
||||
// Point skaters at the boards from centre ice and hold it for ten seconds.
|
||||
for (let i = 0; i < 16; i++) {
|
||||
const a = (i / 16) * Math.PI * 2;
|
||||
const s = createSkaterState(i, { x: 0, z: 0, yaw: a });
|
||||
run(s, 10, (st) => {
|
||||
st.ix = Math.sin(a);
|
||||
st.iz = Math.cos(a);
|
||||
st.sprint = true;
|
||||
}, { clampBoards: true });
|
||||
ok(insideRink(s.x, s.z, SKATE.radius), `skater driving at heading ${a.toFixed(2)} stayed on the ice`);
|
||||
ok(Number.isFinite(s.x) && Number.isFinite(s.z), 'and its position stayed finite');
|
||||
}
|
||||
}
|
||||
|
||||
section('the sim is deterministic');
|
||||
{
|
||||
const drive = (st, t) => {
|
||||
st.ix = Math.sin(t * 1.3);
|
||||
st.iz = Math.cos(t * 0.7);
|
||||
st.sprint = t > 3;
|
||||
};
|
||||
const a = createSkaterState(0, { x: 4, z: -6, yaw: 1 });
|
||||
const b = createSkaterState(0, { x: 4, z: -6, yaw: 1 });
|
||||
run(a, 12, drive, { clampBoards: true });
|
||||
run(b, 12, drive, { clampBoards: true });
|
||||
near(a.x, b.x, 0, 'same inputs, same x');
|
||||
near(a.z, b.z, 0, 'same inputs, same z');
|
||||
near(a.yaw, b.yaw, 0, 'same inputs, same yaw');
|
||||
}
|
||||
|
||||
section('intent from a controller is clamped before the sim sees it');
|
||||
{
|
||||
// This is the seam a gamepad or a network message will come in through, so
|
||||
// it has to survive garbage without the sim ever seeing it.
|
||||
const s = createSkaterState(0, START);
|
||||
|
||||
applyIntent(s, { ix: 1, iz: 1 });
|
||||
near(Math.hypot(s.ix, s.iz), 1, 1e-9, 'a diagonal stick is normalised, not sqrt(2) fast');
|
||||
|
||||
applyIntent(s, { ix: 0.3, iz: -0.4 });
|
||||
near(s.ix, 0.3, 1e-9, 'a stick inside the deadzone circle is left alone (x)');
|
||||
near(s.iz, -0.4, 1e-9, 'a stick inside the deadzone circle is left alone (z)');
|
||||
|
||||
applyIntent(s, { ix: 40, iz: -40 });
|
||||
ok(Math.hypot(s.ix, s.iz) <= 1 + 1e-9, 'an out-of-range stick is clamped');
|
||||
|
||||
applyIntent(s, { ix: NaN, iz: undefined, sprint: 'yes', brake: 0 });
|
||||
ok(s.ix === 0 && s.iz === 0, 'NaN and undefined become a centred stick');
|
||||
ok(s.sprint === true && s.brake === false, 'and the flags come through as booleans');
|
||||
|
||||
// The clamped state must still step without producing garbage.
|
||||
stepSkater(s, DT);
|
||||
ok(Number.isFinite(s.x) && Number.isFinite(s.vx), 'and the sim steps cleanly afterwards');
|
||||
}
|
||||
|
||||
section('rink dimensions are the ones we think they are');
|
||||
{
|
||||
near(RINK.halfX * 2, 60.96, 0.01, 'the rink is 200 feet long');
|
||||
near(RINK.halfZ * 2, 25.9, 0.02, 'and 85 feet wide');
|
||||
}
|
||||
|
||||
done('skaterSim');
|
||||
@@ -0,0 +1,172 @@
|
||||
import { spawn } from 'node:child_process';
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import process from 'node:process';
|
||||
import puppeteer from 'puppeteer-core';
|
||||
|
||||
/**
|
||||
* Boot the app in a headless browser, let it skate for a while, and report
|
||||
* back what happened: console errors, frame rate, and where everyone ended up.
|
||||
*
|
||||
* The point is not the screenshots — it is that a spike whose whole success
|
||||
* criterion is "does this look and run right" needs an answer that does not
|
||||
* depend on someone having the tab open.
|
||||
*
|
||||
* node tools/capture.mjs [seconds]
|
||||
*/
|
||||
|
||||
const ROOT = path.resolve(import.meta.dirname, '..');
|
||||
const OUT = path.join(ROOT, 'shots');
|
||||
const PORT = 4181;
|
||||
const URL = process.env.TILT_URL ?? `http://127.0.0.1:${PORT}/`;
|
||||
const SECONDS = Number(process.argv[2] ?? 12);
|
||||
|
||||
function findChrome() {
|
||||
const cache = path.join(process.env.HOME, '.cache/puppeteer/chrome');
|
||||
if (fs.existsSync(cache)) {
|
||||
const builds = fs.readdirSync(cache).sort().reverse();
|
||||
for (const b of builds) {
|
||||
const exe = path.join(cache, b, 'chrome-mac-arm64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing');
|
||||
if (fs.existsSync(exe)) return exe;
|
||||
}
|
||||
}
|
||||
const system = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
|
||||
if (fs.existsSync(system)) return system;
|
||||
throw new Error('no Chrome found — set CHROME_PATH');
|
||||
}
|
||||
|
||||
async function waitForServer(url, timeoutMs = 30000) {
|
||||
const deadline = Date.now() + timeoutMs;
|
||||
for (;;) {
|
||||
try {
|
||||
const res = await fetch(url);
|
||||
if (res.ok) return;
|
||||
} catch {
|
||||
// Vite is still starting.
|
||||
}
|
||||
if (Date.now() > deadline) throw new Error('vite did not come up at ' + url);
|
||||
await new Promise((r) => setTimeout(r, 250));
|
||||
}
|
||||
}
|
||||
|
||||
let server = null;
|
||||
let browser = null;
|
||||
|
||||
try {
|
||||
fs.mkdirSync(OUT, { recursive: true });
|
||||
|
||||
if (!process.env.TILT_URL) {
|
||||
server = spawn(
|
||||
path.join(ROOT, 'node_modules/.bin/vite'),
|
||||
['--host', '127.0.0.1', '--port', String(PORT), '--strictPort'],
|
||||
{ cwd: ROOT, stdio: ['ignore', 'pipe', 'pipe'] },
|
||||
);
|
||||
server.stderr.on('data', (d) => process.stderr.write('[vite] ' + d));
|
||||
}
|
||||
await waitForServer(URL);
|
||||
|
||||
browser = await puppeteer.launch({
|
||||
executablePath: process.env.CHROME_PATH ?? findChrome(),
|
||||
headless: true,
|
||||
args: ['--enable-unsafe-swiftshader', '--use-gl=angle', '--use-angle=swiftshader', '--no-sandbox'],
|
||||
});
|
||||
|
||||
const page = await browser.newPage();
|
||||
// deviceScaleFactor 2, not 1: the target is a retina Mac, and running this at
|
||||
// 1 hid a canvas-sizing bug that made the element twice the window on the
|
||||
// machine anyone actually looks at it on.
|
||||
await page.setViewport({ width: 1280, height: 720, deviceScaleFactor: 2 });
|
||||
|
||||
const errors = [];
|
||||
page.on('console', (msg) => {
|
||||
if (msg.type() === 'error') errors.push(msg.text());
|
||||
});
|
||||
page.on('pageerror', (err) => errors.push(String(err?.stack ?? err)));
|
||||
|
||||
await page.goto(URL, { waitUntil: 'domcontentloaded' });
|
||||
|
||||
// The boot overlay is removed once physics is up and the first frame ran.
|
||||
await page.waitForFunction(() => !document.getElementById('boot'), { timeout: 45000 });
|
||||
|
||||
// The canvas must fill the window exactly, at whatever pixel ratio. Checked
|
||||
// at two window sizes so a resize path that only works on first load fails
|
||||
// here rather than in someone's browser.
|
||||
for (const [w, h] of [[1280, 720], [900, 1000]]) {
|
||||
await page.setViewport({ width: w, height: h, deviceScaleFactor: 2 });
|
||||
await new Promise((r) => setTimeout(r, 300));
|
||||
const fit = await page.evaluate(() => {
|
||||
const c = document.getElementById('stage');
|
||||
const r = c.getBoundingClientRect();
|
||||
return {
|
||||
css: [Math.round(r.width), Math.round(r.height)],
|
||||
win: [window.innerWidth, window.innerHeight],
|
||||
buffer: [c.width, c.height],
|
||||
dpr: window.devicePixelRatio,
|
||||
};
|
||||
});
|
||||
const fits = fit.css[0] === fit.win[0] && fit.css[1] === fit.win[1];
|
||||
console.log(`viewport ${w}x${h} @${fit.dpr}x: canvas ${fit.css.join('x')} css, `
|
||||
+ `${fit.buffer.join('x')} buffer — ${fits ? 'fills the window' : 'DOES NOT FIT'}`);
|
||||
if (!fits) {
|
||||
errors.push(`canvas ${fit.css.join('x')} does not fill window ${fit.win.join('x')}`);
|
||||
}
|
||||
}
|
||||
await page.setViewport({ width: 1280, height: 720, deviceScaleFactor: 2 });
|
||||
await new Promise((r) => setTimeout(r, 300));
|
||||
|
||||
// The starting lineup, before anyone has moved: both teams in their own half.
|
||||
await page.evaluate(() => {
|
||||
window.tilt.match.reset();
|
||||
Object.assign(window.tilt.cam.state, { mode: 'broadcast', distance: 46, pitch: 0.85 });
|
||||
});
|
||||
await new Promise((r) => setTimeout(r, 400));
|
||||
await page.screenshot({ path: path.join(OUT, 'lineup.png') });
|
||||
await page.evaluate(() => {
|
||||
window.tilt.match.reset();
|
||||
Object.assign(window.tilt.cam.state, { distance: 34, pitch: 0.62 });
|
||||
});
|
||||
|
||||
// Let them skate. Software rasterisation is slow, so this is wall-clock time
|
||||
// rather than a frame count — the sim is dt-driven and does not care.
|
||||
await new Promise((r) => setTimeout(r, SECONDS * 1000));
|
||||
|
||||
const hud = await page.$eval('#hud', (el) => el.textContent);
|
||||
await page.screenshot({ path: path.join(OUT, 'broadcast.png') });
|
||||
|
||||
/** Frame a shot through the debug handle and wait for the camera to settle. */
|
||||
async function shot(name, camState, settleMs = 2500) {
|
||||
await page.evaluate((s) => Object.assign(window.tilt.cam.state, s), camState);
|
||||
await new Promise((r) => setTimeout(r, settleMs));
|
||||
await page.screenshot({ path: path.join(OUT, name + '.png') });
|
||||
}
|
||||
|
||||
// Follow-cam: the only view that shows whether the stride and the direction
|
||||
// of travel actually agree.
|
||||
await shot('follow', { mode: 'follow', followIndex: 0, distance: 9, pitch: 0.28 });
|
||||
// Close enough to judge the stance, the arm carry and the blade angle.
|
||||
await shot('closeup', { mode: 'follow', followIndex: 0, distance: 3.6, pitch: 0.16 });
|
||||
// From the side, where a lean into a turn actually reads.
|
||||
await shot('side', { mode: 'follow', followIndex: 1, distance: 5.5, pitch: 0.1 });
|
||||
|
||||
// Fastest skater's numbers, so the shot can be read against real motion.
|
||||
const detail = await page.evaluate(() => window.tilt.match.states.map((s) => ({
|
||||
speed: +Math.hypot(s.vx, s.vz).toFixed(2),
|
||||
effort: +s.effort.toFixed(2),
|
||||
gait: +window.tilt.match.skaters[s.id].animator.gait.toFixed(2),
|
||||
bank: +window.tilt.match.skaters[s.id].animator.bank.toFixed(2),
|
||||
state: window.tilt.match.skaters[s.id].animator.state,
|
||||
})));
|
||||
|
||||
console.log('HUD: ' + hud.replace(/\n/g, ' | '));
|
||||
console.log('skaters: ' + JSON.stringify(detail));
|
||||
console.log(`shots → ${path.relative(ROOT, OUT)}/`);
|
||||
if (errors.length) {
|
||||
console.error('\nbrowser errors:\n' + errors.join('\n'));
|
||||
process.exitCode = 1;
|
||||
} else {
|
||||
console.log('no console errors');
|
||||
}
|
||||
} finally {
|
||||
await browser?.close();
|
||||
server?.kill('SIGTERM');
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
import * as THREE from 'three';
|
||||
import { createPhysicsWorld, initPhysics } from '../src/physics/world.js';
|
||||
import { createMatch } from '../src/game/match.js';
|
||||
import { describeHit } from '../src/game/hits.js';
|
||||
|
||||
/**
|
||||
* Fire skaters at each other from various run-ups and angles and print what
|
||||
* comes out. A tuning aid, not a test: the numbers below are the ones you stare
|
||||
* at when deciding what should count as a bump, a stagger and a knockdown.
|
||||
*
|
||||
* node tools/hitprobe.mjs
|
||||
*/
|
||||
|
||||
const DT = 1 / 60;
|
||||
await initPhysics();
|
||||
|
||||
/**
|
||||
* @param {'stationary'|'full'} mode is the victim skating into it too
|
||||
* @param {number} gap metres between them at the start
|
||||
* @param {number} offsetZ lateral offset — 0 is dead centre
|
||||
*/
|
||||
function probe(mode, gap, offsetZ = 0) {
|
||||
const physics = createPhysicsWorld();
|
||||
const match = createMatch({ scene: new THREE.Group(), physics, perTeam: 1, teams: 2 });
|
||||
const [a, b] = match.states;
|
||||
a.x = -gap / 2; a.z = 0; a.yaw = Math.PI / 2;
|
||||
b.x = gap / 2; b.z = offsetZ; b.yaw = mode === 'full' ? -Math.PI / 2 : Math.PI / 2;
|
||||
match.skaters[0].proxy.teleport(a.x, a.z);
|
||||
match.skaters[1].proxy.teleport(b.x, b.z);
|
||||
match.setControl(0, { x: 1, y: 0, sprint: true, brake: false, cameraYaw: 0 });
|
||||
match.setControl(1, mode === 'full'
|
||||
? { x: -1, y: 0, sprint: true, brake: false, cameraYaw: 0 }
|
||||
: { x: 0, y: 0, sprint: false, brake: false, cameraYaw: 0 });
|
||||
|
||||
const seen = new Set();
|
||||
const out = [];
|
||||
for (let n = 0; n < 6 / DT; n++) {
|
||||
match.update(DT);
|
||||
for (const h of match.recentHits) {
|
||||
const id = `${h.at}|${h.attacker}`;
|
||||
if (!seen.has(id)) {
|
||||
seen.add(id);
|
||||
out.push(h);
|
||||
}
|
||||
}
|
||||
}
|
||||
physics.destroy();
|
||||
return out;
|
||||
}
|
||||
|
||||
const rows = [
|
||||
['stationary', 2.5, 0],
|
||||
['stationary', 5, 0],
|
||||
['stationary', 10, 0],
|
||||
['stationary', 22, 0],
|
||||
['stationary', 22, 0.45],
|
||||
['stationary', 22, -0.45],
|
||||
['full', 10, 0],
|
||||
['full', 24, 0],
|
||||
['full', 24, 0.5],
|
||||
];
|
||||
|
||||
console.log('mode gap offZ | outcome m/s sev limbs description');
|
||||
console.log('-'.repeat(96));
|
||||
for (const [mode, gap, off] of rows) {
|
||||
const hits = probe(mode, gap, off);
|
||||
if (!hits.length) {
|
||||
console.log(`${mode.padEnd(11)} ${String(gap).padStart(4)} ${String(off).padStart(5)} | (no hit)`);
|
||||
continue;
|
||||
}
|
||||
for (const h of hits) {
|
||||
console.log(
|
||||
`${mode.padEnd(11)} ${String(gap).padStart(4)} ${String(off).padStart(5)} | `
|
||||
+ `${h.outcome.padEnd(10)} ${h.speed.toFixed(1).padStart(4)} ${h.severity.toFixed(1).padStart(5)} `
|
||||
+ `${(h.attackerPart + '→' + h.victimPart).padEnd(24)} ${describeHit(h)}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,234 @@
|
||||
import { spawn } from 'node:child_process';
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import process from 'node:process';
|
||||
import puppeteer from 'puppeteer-core';
|
||||
|
||||
/**
|
||||
* img2mesh harness — capture a shot sheet of the player and goalie for
|
||||
* equipment / animation iteration.
|
||||
*
|
||||
* npm run img2mesh
|
||||
* npm run img2mesh -- --subject goalie --poses ready,butterfly --views front,side
|
||||
* npm run img2mesh -- --list
|
||||
*
|
||||
* Writes PNGs + manifest.json under shots/img2mesh/. Pair each PNG with a
|
||||
* reference (drop into shots/img2mesh/ref/) and re-run after code changes.
|
||||
*/
|
||||
|
||||
const ROOT = path.resolve(import.meta.dirname, '..');
|
||||
const OUT = path.join(ROOT, 'shots', 'img2mesh');
|
||||
const PORT = 4182;
|
||||
const BASE = process.env.TILT_URL ?? `http://127.0.0.1:${PORT}/`;
|
||||
const STUDIO = new URL('character.html', BASE).href;
|
||||
|
||||
function parseArgs(argv) {
|
||||
const out = {
|
||||
subjects: ['player', 'goalie'],
|
||||
poses: null,
|
||||
views: null,
|
||||
list: false,
|
||||
settle: 50,
|
||||
};
|
||||
for (let i = 0; i < argv.length; i++) {
|
||||
const a = argv[i];
|
||||
if (a === '--list') out.list = true;
|
||||
else if (a === '--subject' || a === '--subjects') {
|
||||
out.subjects = argv[++i].split(',').map((s) => s.trim()).filter(Boolean);
|
||||
} else if (a === '--poses') {
|
||||
out.poses = argv[++i].split(',').map((s) => s.trim()).filter(Boolean);
|
||||
} else if (a === '--views') {
|
||||
out.views = argv[++i].split(',').map((s) => s.trim()).filter(Boolean);
|
||||
} else if (a === '--settle') {
|
||||
out.settle = Number(argv[++i]) || 50;
|
||||
} else if (a === '--help' || a === '-h') {
|
||||
console.log(`img2mesh — character shot sheet
|
||||
|
||||
Usage:
|
||||
node tools/img2mesh.mjs [options]
|
||||
|
||||
Options:
|
||||
--subject player|goalie|player,goalie (default: both)
|
||||
--poses carry,windup,butterfly,... (default: all for subject)
|
||||
--views front,side,threequarter,... (default: front,3/4,side,closeup,gear)
|
||||
--settle N frames of settle before shot (via API)
|
||||
--list print catalogs and exit
|
||||
--help
|
||||
`);
|
||||
process.exit(0);
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
function findChrome() {
|
||||
if (process.env.CHROME_PATH && fs.existsSync(process.env.CHROME_PATH)) {
|
||||
return process.env.CHROME_PATH;
|
||||
}
|
||||
const cache = path.join(process.env.HOME, '.cache/puppeteer/chrome');
|
||||
if (fs.existsSync(cache)) {
|
||||
const builds = fs.readdirSync(cache).sort().reverse();
|
||||
for (const b of builds) {
|
||||
const exe = path.join(
|
||||
cache,
|
||||
b,
|
||||
'chrome-mac-arm64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing',
|
||||
);
|
||||
if (fs.existsSync(exe)) return exe;
|
||||
}
|
||||
}
|
||||
const system = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
|
||||
if (fs.existsSync(system)) return system;
|
||||
throw new Error('no Chrome found — set CHROME_PATH');
|
||||
}
|
||||
|
||||
async function waitForServer(url, timeoutMs = 30000) {
|
||||
const deadline = Date.now() + timeoutMs;
|
||||
for (;;) {
|
||||
try {
|
||||
const res = await fetch(url);
|
||||
if (res.ok || res.status === 404) return; // 404 on / is fine; studio is /character.html
|
||||
} catch {
|
||||
// still booting
|
||||
}
|
||||
if (Date.now() > deadline) throw new Error('vite did not come up at ' + url);
|
||||
await new Promise((r) => setTimeout(r, 200));
|
||||
}
|
||||
}
|
||||
|
||||
const args = parseArgs(process.argv.slice(2));
|
||||
let server = null;
|
||||
let browser = null;
|
||||
|
||||
try {
|
||||
fs.mkdirSync(OUT, { recursive: true });
|
||||
fs.mkdirSync(path.join(OUT, 'ref'), { recursive: true });
|
||||
|
||||
if (!process.env.TILT_URL) {
|
||||
server = spawn(
|
||||
path.join(ROOT, 'node_modules/.bin/vite'),
|
||||
['--host', '127.0.0.1', '--port', String(PORT), '--strictPort'],
|
||||
{ cwd: ROOT, stdio: ['ignore', 'pipe', 'pipe'] },
|
||||
);
|
||||
server.stderr.on('data', (d) => process.stderr.write('[vite] ' + d));
|
||||
}
|
||||
await waitForServer(BASE);
|
||||
|
||||
browser = await puppeteer.launch({
|
||||
executablePath: findChrome(),
|
||||
headless: true,
|
||||
args: [
|
||||
'--enable-unsafe-swiftshader',
|
||||
'--use-gl=angle',
|
||||
'--use-angle=swiftshader',
|
||||
'--no-sandbox',
|
||||
],
|
||||
});
|
||||
|
||||
const page = await browser.newPage();
|
||||
await page.setViewport({ width: 1280, height: 720, deviceScaleFactor: 2 });
|
||||
|
||||
const errors = [];
|
||||
page.on('pageerror', (err) => errors.push(String(err?.stack ?? err)));
|
||||
page.on('console', (msg) => {
|
||||
if (msg.type() === 'error') errors.push(msg.text());
|
||||
});
|
||||
|
||||
await page.goto(STUDIO, { waitUntil: 'domcontentloaded' });
|
||||
await page.waitForFunction(() => window.img2mesh?.captureShot, { timeout: 45000 });
|
||||
// Boot overlay gone.
|
||||
await page.waitForFunction(() => !document.getElementById('boot'), { timeout: 10000 }).catch(() => {});
|
||||
|
||||
if (args.list) {
|
||||
const catalogs = await page.evaluate(() => ({
|
||||
playerPoses: window.img2mesh.catalogs.playerPoses(),
|
||||
goaliePoses: window.img2mesh.catalogs.goaliePoses(),
|
||||
views: window.img2mesh.catalogs.views(),
|
||||
}));
|
||||
console.log(JSON.stringify(catalogs, null, 2));
|
||||
process.exit(0);
|
||||
}
|
||||
|
||||
const sheet = await page.evaluate((opts) => {
|
||||
return window.img2mesh.shotSheet(opts);
|
||||
}, {
|
||||
subjects: args.subjects,
|
||||
poses: args.poses,
|
||||
views: args.views ?? ['front', 'threequarter', 'side', 'closeup', 'gear'],
|
||||
});
|
||||
|
||||
console.log(`img2mesh: ${sheet.length} shots → ${path.relative(ROOT, OUT)}/`);
|
||||
|
||||
const manifest = {
|
||||
createdAt: new Date().toISOString(),
|
||||
subjects: args.subjects,
|
||||
shots: [],
|
||||
};
|
||||
|
||||
for (let i = 0; i < sheet.length; i++) {
|
||||
const spec = sheet[i];
|
||||
const meta = await page.evaluate(async (s) => {
|
||||
return window.img2mesh.captureShot(s);
|
||||
}, { ...spec, settleMs: args.settle });
|
||||
|
||||
const filePath = path.join(OUT, spec.file);
|
||||
await page.screenshot({ path: filePath, type: 'png' });
|
||||
|
||||
const entry = {
|
||||
...spec,
|
||||
path: path.relative(ROOT, filePath),
|
||||
measures: meta.measures,
|
||||
};
|
||||
manifest.shots.push(entry);
|
||||
|
||||
const m = meta.measures.player || meta.measures.goalie;
|
||||
const foot = m ? ` feetY=${m.footLY.toFixed(2)}` : '';
|
||||
console.log(
|
||||
`[${String(i + 1).padStart(3)}/${sheet.length}] ${spec.file}`
|
||||
+ ` anim=${m?.anim ?? '—'}${foot}`,
|
||||
);
|
||||
}
|
||||
|
||||
const manifestPath = path.join(OUT, 'manifest.json');
|
||||
fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
|
||||
console.log(`manifest → ${path.relative(ROOT, manifestPath)}`);
|
||||
|
||||
// Index HTML for quick visual review in a browser.
|
||||
const indexPath = path.join(OUT, 'index.html');
|
||||
const cards = manifest.shots.map((s) => {
|
||||
const m = s.measures.player || s.measures.goalie || {};
|
||||
return `<figure>
|
||||
<a href="${s.file}"><img src="${s.file}" alt="${s.file}" loading="lazy"></a>
|
||||
<figcaption><strong>${s.subject}</strong> · ${s.pose} · ${s.view}<br>
|
||||
anim=${m.anim ?? '—'} feetY=${m.footLY?.toFixed?.(2) ?? '—'} hands=${m.handLY?.toFixed?.(2) ?? '—'}/${m.handRY?.toFixed?.(2) ?? '—'}
|
||||
</figcaption>
|
||||
</figure>`;
|
||||
}).join('\n');
|
||||
fs.writeFileSync(indexPath, `<!DOCTYPE html>
|
||||
<html lang="en"><head><meta charset="utf-8"><title>img2mesh sheet</title>
|
||||
<style>
|
||||
body { margin:0; background:#0a0e14; color:#9ec0dc; font:12px/1.4 ui-monospace, Menlo, monospace; }
|
||||
h1 { margin:16px; font-size:14px; letter-spacing:2px; color:#6ea8dc; }
|
||||
main { display:grid; grid-template-columns:repeat(auto-fill,minmax(280px,1fr)); gap:12px; padding:0 16px 24px; }
|
||||
figure { margin:0; background:#121a24; border:1px solid #1e3348; border-radius:8px; overflow:hidden; }
|
||||
img { display:block; width:100%; height:auto; background:#0c1018; }
|
||||
figcaption { padding:8px 10px; }
|
||||
</style></head>
|
||||
<body>
|
||||
<h1>IMG2MESH · ${manifest.shots.length} shots · ${manifest.createdAt}</h1>
|
||||
<main>
|
||||
${cards}
|
||||
</main>
|
||||
</body></html>`);
|
||||
console.log(`gallery → ${path.relative(ROOT, indexPath)}`);
|
||||
|
||||
if (errors.length) {
|
||||
console.error('\nbrowser errors:\n' + errors.join('\n'));
|
||||
process.exitCode = 1;
|
||||
} else {
|
||||
console.log('no console errors');
|
||||
}
|
||||
} finally {
|
||||
await browser?.close();
|
||||
server?.kill('SIGTERM');
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
import { defineConfig } from 'vite';
|
||||
|
||||
export default defineConfig({
|
||||
server: { port: 5174, open: true },
|
||||
build: {
|
||||
target: 'es2022',
|
||||
// The body/skin generators are one deterministic chunk; splitting them buys
|
||||
// nothing and costs a round trip before anything can render.
|
||||
chunkSizeWarningLimit: 2500,
|
||||
},
|
||||
// box3d.js ships an Emscripten bundle that resolves its .wasm via
|
||||
// import.meta.url. Pre-bundling rewrites that URL and breaks the lookup, so
|
||||
// leave it alone.
|
||||
optimizeDeps: { exclude: ['box3d.js'] },
|
||||
});
|
||||
Reference in New Issue
Block a user