Skip to content

Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.

feat(verse): a hoverboard on B carries the commander across the deck four times faster (#961)

Ruben Lütke94ae75e7b81f
diff --git a/docs/verse/README.md b/docs/verse/README.md
index 34ad9e79a2..288e2b3875 100644
--- a/docs/verse/README.md
+++ b/docs/verse/README.md
@@ -49,6 +49,14 @@ framing at its own size; a low, wide one still shows at least 5 m of floor top
to bottom. The camera never comes closer than the plate is sharp: an older
deck cooked at 96 px/m, or a HiDPI screen, stops a little further out.
+B folds out the **hoverboard** under the commander (the tool rail has the same
+button): the movement keys then glide at 5.5 m/s instead of walking at about
+1.3 (Shift boosts to 8.5), the board coasts to a stop when the keys are let
+go and loses its speed against a wall, and a click on the deck rides the path
+at four times the walking pace. The rider stands on it a hand's breadth off
+the floor, leaning into speed and turns; B folds it away. It never comes into
+a duel. Motion and look live in `actors/hoverboard.ts`.
+
**Duel.** At any of the four consoles on the reactor's control ring (Reactor
Engineering) E offers *Start a duel*; the **Duel** button on the tool rail does
the same from any deck (the turbolift rides down first). Choose normal, hard
diff --git a/dodaios/ui/web/frontend/src/components/society/verse/VerseStage.tsx b/dodaios/ui/web/frontend/src/components/society/verse/VerseStage.tsx
index 9f8568106d..0f467c3010 100644
--- a/dodaios/ui/web/frontend/src/components/society/verse/VerseStage.tsx
+++ b/dodaios/ui/web/frontend/src/components/society/verse/VerseStage.tsx
@@ -398,6 +398,15 @@ export function VerseStage({ onOpenLedger, onSelectAgent, onCreateAgent, onOpenG
else releaseMouseLook(el);
}, [eyeCapable, chooseView, say, t, runtime]);
const cycle = useCallback(() => showView(cycleView(viewRef.current, eyeCapable)), [showView, eyeCapable]);
+ // B: the hoverboard folds out under the commander, or away again.
+ const [boardOn, setBoardOn] = useState(runtime.control.board);
+ const toggleBoard = useCallback(() => {
+ if (runtime.duelActive) return;
+ const on = !runtime.control.board;
+ runtime.control.board = on;
+ setBoardOn(on);
+ say(t(on ? "verse.board.on" : "verse.board.off"));
+ }, [runtime, say, t]);
// The wheel pushed third person into first (or pulled first back out): the switch follows, the mouse stays as it is.
const zoomEye = useCallback((factor: number) => {
const changed: Person | null = runtime.shoulder.zoom(factor);
@@ -619,8 +628,8 @@ export function VerseStage({ onOpenLedger, onSelectAgent, onCreateAgent, onOpenG
useEffect(() => {
if (panel && surfaceRef.current && document.pointerLockElement === surfaceRef.current) document.exitPointerLock();
}, [panel]);
- const keyActions = useRef({ cycle, showView, interact, lockPointer, zoomEye });
- keyActions.current = { cycle, showView, interact, lockPointer, zoomEye };
+ const keyActions = useRef({ cycle, showView, interact, lockPointer, zoomEye, toggleBoard });
+ keyActions.current = { cycle, showView, interact, lockPointer, zoomEye, toggleBoard };
/** What Escape closes first: a selected crew member or an open panel. */
const closable = useRef(false);
closable.current = selected !== null || panel !== null;
@@ -663,6 +672,7 @@ export function VerseStage({ onOpenLedger, onSelectAgent, onCreateAgent, onOpenG
else if (e.code === "KeyE" && !e.repeat) keyActions.current.interact();
else if (e.code === "KeyL" && !e.repeat) keyActions.current.lockPointer();
else if (e.code === "KeyF") { e.preventDefault(); runtime.power = true; }
+ else if (e.code === "KeyB" && !e.repeat) keyActions.current.toggleBoard();
else if (e.code === "F9" && import.meta.env.DEV) setDebug((d) => !d);
};
const up = (e: KeyboardEvent) => {
@@ -941,6 +951,8 @@ export function VerseStage({ onOpenLedger, onSelectAgent, onCreateAgent, onOpenG
firstUnavailable={tooSmall ? fill(t("verse.tools.first_too_small"), COMPACT_EYE_MIN) : undefined}
onView={showView}
onLift={() => setPanel("lift")}
+ board={boardOn}
+ onBoard={toggleBoard}
onCommander={() => { if (runtime.control.mode === "follow") runtime.control.reframe = true; else focusOn(COMMANDER_ID); }}
onSettings={eyeCapable ? () => setPanel("settings") : undefined}
onDuel={compact ? undefined : () => setPanel("duel")}
diff --git a/dodaios/ui/web/frontend/src/components/society/verse/actors/ActorsLayer.tsx b/dodaios/ui/web/frontend/src/components/society/verse/actors/ActorsLayer.tsx
index 23cea5a009..16e71bfeec 100644
--- a/dodaios/ui/web/frontend/src/components/society/verse/actors/ActorsLayer.tsx
+++ b/dodaios/ui/web/frontend/src/components/society/verse/actors/ActorsLayer.tsx
@@ -223,6 +223,8 @@ export function ActorsLayer({ runtime, deck, library, cast, commanderId, reduced
const control = runtime.control;
const lead = actors.current.get(commanderId);
const steer = control.mode !== "follow" || runtime.duelActive ? null : runtime.eye ? control.directionFrom(runtime.shoulder, steering) : control.direction(steering);
+ // B: the hoverboard folds out under the commander (never in a duel).
+ lead?.ride(control.board && !runtime.duelActive);
// At eye level the commander faces the view while walking (shooter strafing); on the plate, the way they walk.
lead?.drive(steer, control.run, steer && runtime.eye ? bodyFacing(runtime.shoulder.yaw, steer, facing) : null);
// A duel ended: the commander stands where they finished it, on the deck's walkable floor.
diff --git a/dodaios/ui/web/frontend/src/components/society/verse/actors/actor.ts b/dodaios/ui/web/frontend/src/components/society/verse/actors/actor.ts
index 3fc8d56077..1574f90c7f 100644
--- a/dodaios/ui/web/frontend/src/components/society/verse/actors/actor.ts
+++ b/dodaios/ui/web/frontend/src/components/society/verse/actors/actor.ts
@@ -12,7 +12,8 @@
* The commander can also be driven directly (third person): while a
* direction is held the body walks that way over the floor, sliding along
* walls and stopping short of other people, whatever its goal says; let go
- * and it stands where it is.
+ * and it stands where it is. On the hoverboard (`ride`) the same keys glide
+ * instead of walk: faster, coasting to a stop, lifted off the floor.
*/
import {
AnimationMixer, Group, LoopOnce, LoopRepeat, Mesh, MeshBasicMaterial, PlaneGeometry, Quaternion, Vector3,
@@ -29,6 +30,7 @@ import { avoidance, BODY_RADIUS, lerpAngle, PathFollower, sidestep, turnPace, tu
import { RoomLight } from "./roomLight";
import { CloakRig } from "./cloak";
import { aimBone, solveElbow } from "../duel/figure";
+import { absorb, BOARD_PATH_FACTOR, boardLean, deployStep, glide, HoverboardMesh, hoverHeight } from "./hoverboard";
import { hash32 } from "../life/crew";
export type Goal =
@@ -147,6 +149,20 @@ export class Actor {
/** Shooter views: the way the body faces while driven (the view, `viewMode.bodyFacing`), and a walk played backwards. */
private steerFace: { yaw: number; reverse: boolean } | null = null;
private readonly clipNames: ReadonlySet<string>;
+ /** The hoverboard, made the first time this body rides one. */
+ private board: HoverboardMesh | null = null;
+ private boardOn = false;
+ /** Fold-out share of the board, 0..1. */
+ private boardShare = 0;
+ /** The board's velocity, m/s (it glides, so it is kept between frames). */
+ private readonly boardV = { x: 0, z: 0 };
+ private lean = { pitch: 0, roll: 0 };
+ private turnRate = 0;
+ private hover = 0;
+ private clock = 0;
+ private lastSync = 0;
+ private lastYaw = 0;
+ private reducedMotion = false;
private readonly shadow: Mesh<PlaneGeometry, MeshBasicMaterial>;
/** The skin's cloak, when its skeleton carries one (it trails the body's motion). */
private readonly cloak: CloakRig | null;
@@ -222,6 +238,24 @@ export class Actor {
this.steerFace = direction ? face : null;
}
+ /** Step onto the hoverboard (true) or fold it away (false). Drones never ride. */
+ ride(on: boolean): void {
+ if (on === this.boardOn) return;
+ if (on && this.isDrone) return;
+ if (on && !this.board) {
+ this.board = new HoverboardMesh();
+ this.light.attach(this.board.materials);
+ this.group.add(this.board.group, this.board.glow);
+ }
+ this.boardOn = on;
+ if (!on) { this.boardV.x = 0; this.boardV.z = 0; }
+ }
+
+ /** On the board (folded out or folding out). */
+ get riding(): boolean {
+ return this.boardOn;
+ }
+
/** Stop whatever walk or settle is in progress and stand where the body is (until the next goal). */
halt(): void {
this.steer = null;
@@ -229,6 +263,8 @@ export class Actor {
this.settle = null;
this.phase = "settled";
this.speed = 0;
+ this.boardV.x = 0;
+ this.boardV.z = 0;
this.play(this.isDrone ? "hover" : "idle");
}
@@ -277,7 +313,11 @@ export class Actor {
}
const goal = this.goal;
this.moving = false;
- if (this.steer) {
+ this.clock = ctx.now / 1000;
+ this.reducedMotion = ctx.reduced;
+ this.boardShare = deployStep(this.boardShare, this.boardOn, dtS, ctx.reduced);
+ const coasting = this.boardOn && (this.boardV.x !== 0 || this.boardV.z !== 0);
+ if (this.steer || coasting) {
this.driven(this.steer, dtS, ctx);
this.light.update(ctx.deck, this.x, this.y, this.z, dtS);
this.sync();
@@ -409,7 +449,7 @@ export class Actor {
this.yaw = turnToward(this.yaw, heading, TURN_RATE, dtS);
const steer = avoidance({ x: this.x, z: this.z, yaw: this.yaw }, ctx.neighbours(this));
// Slow into tight turns so the feet stay under the body.
- this.speed = this.pace * steer.speed * turnPace(this.yaw, heading);
+ this.speed = this.pace * (this.boardOn ? BOARD_PATH_FACTOR : 1) * steer.speed * turnPace(this.yaw, heading);
let pos = f.advance({ x: this.x, z: this.z }, this.speed * dtS);
pos = sidestep(this.grid, pos, this.yaw, steer.side * 0.6 * dtS);
this.x = pos.x;
@@ -417,12 +457,22 @@ export class Actor {
const ground = floorHeight(this.grid, this.x, this.z);
this.y += (ground - this.y) * Math.min(1, dtS * 12);
this.moving = true;
- if (this.action) this.action.timeScale = this.speed / Math.max(0.1, this.instance.walkSpeed);
+ if (this.boardOn) {
+ // On the board the body stands and the board carries it.
+ this.play("idle");
+ if (this.action) this.action.timeScale = 1;
+ } else {
+ this.play("walk");
+ if (this.action) this.action.timeScale = this.speed / Math.max(0.1, this.instance.walkSpeed);
+ }
if (f.done) this.arrive(this.goal, ctx);
}
- /** One frame under direct control: turn toward the held direction and walk it, sliding along walls. */
- private driven(direction: Point, dtS: number, ctx: ActorContext): void {
+ /**
+ * One frame under direct control: turn toward the held direction and walk it, sliding along walls.
+ * On the board: glide toward it (or coast, with no direction).
+ */
+ private driven(direction: Point | null, dtS: number, ctx: ActorContext): void {
if (this.phase !== "driven") {
// The keys take over from any walk or settle in progress.
this.phase = "driven";
@@ -430,6 +480,8 @@ export class Actor {
this.settle = null;
this.oneShotUntil = 0;
}
+ if (this.boardOn) { this.glideStep(direction, dtS, ctx); return; }
+ if (!direction) return;
const face = this.steerFace;
const heading = face ? face.yaw : Math.atan2(direction.x, direction.z);
this.yaw = turnToward(this.yaw, heading, DRIVE_TURN_RATE, dtS);
@@ -465,6 +517,40 @@ export class Actor {
}
}
+ /** One frame on the board: speed toward the held direction, slide along walls, lose speed against them. */
+ private glideStep(direction: Point | null, dtS: number, ctx: ActorContext): void {
+ const v = glide(this.boardV, direction, this.steerRun, dtS);
+ const fast = Math.hypot(v.x, v.z);
+ const face = this.steerFace;
+ const heading = face ? face.yaw : fast > 0.3 ? Math.atan2(v.x, v.z) : direction ? Math.atan2(direction.x, direction.z) : this.yaw;
+ this.yaw = turnToward(this.yaw, heading, DRIVE_TURN_RATE, dtS);
+ const from = { x: this.x, z: this.z };
+ const near = ctx.neighbours(this);
+ // Nobody rides through a person; drones are small enough to pass.
+ const free: FreeAt = (p) => {
+ for (const n of near) {
+ if (n instanceof Actor && n.isDrone) continue;
+ const d = Math.hypot(n.x - p.x, n.z - p.z);
+ if (d < DRIVE_PERSONAL_SPACE && d < Math.hypot(n.x - from.x, n.z - from.z)) return false;
+ }
+ return true;
+ };
+ const wanted = { x: v.x * dtS, z: v.z * dtS };
+ const to = driveStep(this.grid, from, wanted.x, wanted.z, free);
+ const moved = { x: to.x - from.x, z: to.z - from.z };
+ absorb(v, wanted, moved, dtS);
+ this.x = to.x;
+ this.z = to.z;
+ const ground = floorHeight(this.grid, this.x, this.z);
+ this.y += (ground - this.y) * Math.min(1, dtS * 12);
+ const step = Math.hypot(moved.x, moved.z);
+ const speed = dtS > 0 ? step / dtS : 0;
+ this.speed += (speed - this.speed) * Math.min(1, dtS * 14);
+ this.moving = step > 1e-4;
+ this.play("idle");
+ if (this.action) this.action.timeScale = 1;
+ }
+
private arrive(goal: Goal | null, ctx: ActorContext): void {
this.follower = null;
if (!goal) { this.phase = "idle"; this.play("idle"); return; }
@@ -577,8 +663,32 @@ export class Actor {
}
private sync(): void {
- this.instance.root.position.set(this.x, this.y, this.z);
- this.instance.root.rotation.set(0, this.yaw, 0);
+ const board = this.board;
+ if (board && (this.boardShare > 0 || board.group.visible)) {
+ // Lean into speed and turns; the yaw change since the last frame gives the turn rate.
+ const dt = this.clock - this.lastSync;
+ if (dt > 0 && dt < 0.5) {
+ const rate = wrapAngle(this.yaw - this.lastYaw) / dt;
+ this.turnRate += (rate - this.turnRate) * Math.min(1, dt * 6);
+ }
+ const want = boardLean(this.speed, this.turnRate, this.reducedMotion);
+ const k = Math.min(1, Math.max(0, dt) * 6);
+ this.lean.pitch += (want.pitch - this.lean.pitch) * k;
+ this.lean.roll += (want.roll - this.lean.roll) * k;
+ this.hover = hoverHeight(this.boardShare, this.clock, this.speed, this.reducedMotion);
+ const share = Math.min(1, this.boardShare);
+ const pitch = this.lean.pitch * share;
+ const roll = this.lean.roll * share;
+ board.update(this.x, this.y + this.hover, this.y, this.z, this.yaw, this.boardShare, pitch, roll, this.speed, this.clock);
+ this.instance.root.position.set(this.x, this.y + this.hover, this.z);
+ this.instance.root.rotation.set(pitch, this.yaw, roll, "YXZ");
+ } else {
+ this.hover = 0;
+ this.instance.root.position.set(this.x, this.y, this.z);
+ this.instance.root.rotation.set(0, this.yaw, 0);
+ }
+ this.lastYaw = this.yaw;
+ this.lastSync = this.clock;
const lying = this.motion === "sleep";
this.shadow.visible = !lying;
// The root stands on the floor (seated too: the seat height is in the clip), so the shadow goes there.
@@ -590,6 +700,7 @@ export class Actor {
this.mixer.uncacheRoot(this.instance.root);
this.shadow.geometry.dispose();
this.shadow.material.dispose();
+ this.board?.dispose();
disposeInstance(this.instance);
}
}
diff --git a/dodaios/ui/web/frontend/src/components/society/verse/actors/hoverboard.test.ts b/dodaios/ui/web/frontend/src/components/society/verse/actors/hoverboard.test.ts
new file mode 100644
index 0000000000..b734bb769e
--- /dev/null
+++ b/dodaios/ui/web/frontend/src/components/society/verse/actors/hoverboard.test.ts
@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+import {
+ absorb, BOARD_BOOST, BOARD_LIFT, BOARD_SPEED, boardLean, boardSpeed, deployScale, deployStep, glide, hoverHeight,
+} from "./hoverboard";
+import { DEFAULT_WALK_SPEED } from "./characters";
+
+describe("hoverboard motion", () => {
+ it("rides several times faster than a walk, and faster still with Shift", () => {
+ expect(boardSpeed(false)).toBe(BOARD_SPEED);
+ expect(boardSpeed(true)).toBe(BOARD_BOOST);
+ expect(BOARD_SPEED).toBeGreaterThan(DEFAULT_WALK_SPEED * 3.5);
+ expect(BOARD_BOOST).toBeGreaterThan(BOARD_SPEED);
+ });
+
+ it("speeds up toward the held direction and reaches cruising speed within about a second", () => {
+ const v = { x: 0, z: 0 };
+ glide(v, { x: 0, z: -1 }, false, 1 / 60);
+ expect(v.z).toBeLessThan(0);
+ expect(Math.abs(v.z)).toBeLessThan(BOARD_SPEED * 0.1);
+ for (let i = 0; i < 60; i++) glide(v, { x: 0, z: -1 }, false, 1 / 60);
+ expect(Math.abs(v.z)).toBeGreaterThan(BOARD_SPEED * 0.9);
+ expect(v.x).toBe(0);
+ });
+
+ it("coasts to a full stop once the keys are let go", () => {
+ const v = { x: BOARD_SPEED, z: 0 };
+ glide(v, null, false, 0.1);
+ expect(v.x).toBeGreaterThan(0);
+ expect(v.x).toBeLessThan(BOARD_SPEED);
+ for (let i = 0; i < 300; i++) glide(v, null, false, 1 / 60);
+ expect(v).toEqual({ x: 0, z: 0 });
+ });
+
+ it("loses the speed it could not travel against a wall", () => {
+ const v = { x: 5, z: 0 };
+ absorb(v, { x: 0.5, z: 0 }, { x: 0, z: 0 }, 0.1);
+ expect(v).toEqual({ x: 0, z: 0 });
+ const free = { x: 5, z: 0 };
+ absorb(free, { x: 0.5, z: 0 }, { x: 0.5, z: 0 }, 0.1);
+ expect(free).toEqual({ x: 5, z: 0 });
+ // Sliding along a wall keeps the part that moved.
+ const slide = { x: 4, z: 3 };
+ absorb(slide, { x: 0.4, z: 0.3 }, { x: 0.4, z: 0 }, 0.1);
+ expect(slide.x).toBeCloseTo(4);
+ expect(slide.z).toBeCloseTo(0);
+ });
+
+ it("folds out and away over a short beat, at once with reduced motion", () => {
+ let s = 0;
+ s = deployStep(s, true, 0.1, false);
+ expect(s).toBeGreaterThan(0);
+ expect(s).toBeLessThan(1);
+ for (let i = 0; i < 10; i++) s = deployStep(s, true, 0.1, false);
+ expect(s).toBe(1);
+ s = deployStep(s, false, 1, false);
+ expect(s).toBe(0);
+ expect(deployStep(0, true, 0.001, true)).toBe(1);
+ expect(deployScale(0)).toBeCloseTo(0);
+ expect(deployScale(1)).toBeCloseTo(1);
+ });
+
+ it("lifts the rider off the floor and keeps still with reduced motion", () => {
+ expect(hoverHeight(0, 1, 0, false)).toBe(0);
+ const h = hoverHeight(1, 1, 0, false);
+ expect(h).toBeGreaterThan(BOARD_LIFT * 0.8);
+ expect(h).toBeLessThan(BOARD_LIFT * 1.2);
+ expect(hoverHeight(1, 1, 0, true)).toBe(BOARD_LIFT);
+ expect(boardLean(BOARD_BOOST, 2, true)).toEqual({ pitch: 0, roll: 0 });
+ const lean = boardLean(BOARD_SPEED, -2, false);
+ expect(lean.pitch).toBeGreaterThan(0);
+ expect(lean.roll).toBeGreaterThan(0);
+ });
+});
diff --git a/dodaios/ui/web/frontend/src/components/society/verse/actors/hoverboard.ts b/dodaios/ui/web/frontend/src/components/society/verse/actors/hoverboard.ts
new file mode 100644
index 0000000000..dd4a05df6e
--- /dev/null
+++ b/dodaios/ui/web/frontend/src/components/society/verse/actors/hoverboard.ts
@@ -0,0 +1,220 @@
+/**
+ * The commander's hoverboard: a small grav board that folds out under their
+ * feet (B) and carries them across the deck several times faster than a walk.
+ *
+ * The motion is a glide, not a walk: the board speeds up toward the held
+ * direction, coasts to a stop when the keys are let go, and loses its speed
+ * against a wall. The body stands still on it (idle clip), lifted a hand's
+ * breadth off the floor with a slow hover bob, leaning into speed and turns.
+ *
+ * The motion helpers are pure; `HoverboardMesh` is the three.js body.
+ */
+import {
+ AdditiveBlending, BoxGeometry, CanvasTexture, CapsuleGeometry, CylinderGeometry, Group, Mesh,
+ MeshBasicMaterial, MeshStandardMaterial, PlaneGeometry, type Material, type BufferGeometry, type Texture,
+} from "three";
+import { RENDER_ORDER } from "../engine/renderOrder";
+
+/** Cruising speed on the board, m/s (a walk is about 1.3). */
+export const BOARD_SPEED = 5.5;
+/** Shift on the board: boost, m/s. */
+export const BOARD_BOOST = 8.5;
+/** Path walks (a click on the deck) ride at this multiple of the body's walking pace. */
+export const BOARD_PATH_FACTOR = 4;
+/** How fast the board reaches the held velocity, 1/s (higher = snappier). */
+export const BOARD_ACCEL = 3.2;
+/** How fast it coasts down once the keys are let go, 1/s. */
+export const BOARD_COAST = 2.2;
+/** Below this speed a coasting board has stopped, m/s. */
+export const BOARD_STOPPED = 0.05;
+/** The rider's feet stand this high above the floor, metres. */
+export const BOARD_LIFT = 0.16;
+/** Folding out or away takes this long, seconds. */
+export const BOARD_DEPLOY_S = 0.32;
+
+export interface Velocity { x: number; z: number }
+
+/** The speed the board wants for the held keys, m/s. Pure. */
+export function boardSpeed(boost: boolean): number {
+ return boost ? BOARD_BOOST : BOARD_SPEED;
+}
+
+/**
+ * One step of the board's velocity toward the wanted one (`direction` unit
+ * length, or null to coast), written into `v`. Pure apart from `v`.
+ */
+export function glide(v: Velocity, direction: Velocity | null, boost: boolean, dtS: number): Velocity {
+ const target = direction ? boardSpeed(boost) : 0;
+ const tx = direction ? direction.x * target : 0;
+ const tz = direction ? direction.z * target : 0;
+ const k = 1 - Math.exp(-(direction ? BOARD_ACCEL : BOARD_COAST) * Math.max(0, dtS));
+ v.x += (tx - v.x) * k;
+ v.z += (tz - v.z) * k;
+ if (!direction && Math.hypot(v.x, v.z) < BOARD_STOPPED) {
+ v.x = 0;
+ v.z = 0;
+ }
+ return v;
+}
+
+/**
+ * After a step that went only part of the way (a wall, a person), keep just
+ * the velocity the board really travelled with, so it does not push on into
+ * the wall. Pure apart from `v`.
+ */
+export function absorb(v: Velocity, wanted: Velocity, moved: Velocity, dtS: number): Velocity {
+ if (dtS <= 0) return v;
+ const want = Math.hypot(wanted.x, wanted.z);
+ const got = Math.hypot(moved.x, moved.z);
+ if (want < 1e-6 || got >= want * 0.98) return v;
+ v.x = moved.x / dtS;
+ v.z = moved.z / dtS;
+ return v;
+}
+
+/** The fold-out share after a step toward `on` (0 folded away, 1 out). Pure. */
+export function deployStep(share: number, on: boolean, dtS: number, reduced: boolean): number {
+ if (reduced) return on ? 1 : 0;
+ const step = dtS / BOARD_DEPLOY_S;
+ return on ? Math.min(1, share + step) : Math.max(0, share - step);
+}
+
+/** Smooth 0..1 ease of the fold-out share (the board springs out a touch past full size). Pure. */
+export function deployScale(share: number): number {
+ const s = Math.max(0, Math.min(1, share));
+ // easeOutBack, a light overshoot.
+ const c = 1.4;
+ const t = s - 1;
+ return 1 + (c + 1) * t * t * t + c * t * t;
+}
+
+/** The rider's lift and hover bob above the floor, metres. Pure. */
+export function hoverHeight(share: number, timeS: number, speed: number, reduced: boolean): number {
+ const s = Math.max(0, Math.min(1, share));
+ if (reduced) return BOARD_LIFT * s;
+ // A slow float at rest, almost none at speed (the board planes).
+ const calm = 1 - Math.min(1, speed / BOARD_SPEED) * 0.7;
+ return (BOARD_LIFT + Math.sin(timeS * 2.4) * 0.018 * calm) * s;
+}
+
+/** Lean of the rider and board: pitch forward with speed, roll into a turn, radians. Pure. */
+export function boardLean(speed: number, turnRate: number, reduced: boolean): { pitch: number; roll: number } {
+ if (reduced) return { pitch: 0, roll: 0 };
+ const pitch = Math.min(1, speed / BOARD_BOOST) * 0.12;
+ const roll = Math.max(-0.2, Math.min(0.2, -turnRate * Math.min(1, speed / BOARD_SPEED) * 0.06));
+ return { pitch, roll };
+}
+
+function glowTexture(): Texture {
+ const size = 64;
+ const canvas = document.createElement("canvas");
+ canvas.width = canvas.height = size;
+ const ctx = canvas.getContext("2d") as CanvasRenderingContext2D;
+ const g = ctx.createRadialGradient(size / 2, size / 2, 0, size / 2, size / 2, size / 2);
+ g.addColorStop(0, "rgba(255,255,255,1)");
+ g.addColorStop(0.3, "rgba(255,255,255,0.45)");
+ g.addColorStop(1, "rgba(255,255,255,0)");
+ ctx.fillStyle = g;
+ ctx.fillRect(0, 0, size, size);
+ const tex = new CanvasTexture(canvas);
+ tex.needsUpdate = true;
+ return tex;
+}
+
+/** Charcoal deck, gold rim, two amber thrusters and an underglow on the floor. */
+export class HoverboardMesh {
+ /** The board itself; it rides at the rider's feet and turns with them. */
+ readonly group = new Group();
+ /** The light it throws on the floor, kept flat on the floor under the board. */
+ readonly glow: Mesh<PlaneGeometry, MeshBasicMaterial>;
+ private readonly thrusters: MeshBasicMaterial;
+ private readonly geometries: BufferGeometry[] = [];
+ private readonly owned: Material[] = [];
+ private readonly textures: Texture[] = [];
+
+ constructor() {
+ const deckMat = this.keepMat(new MeshStandardMaterial({ color: 0x17191e, metalness: 0.75, roughness: 0.32 }));
+ const goldMat = this.keepMat(new MeshStandardMaterial({ color: 0xc9a24a, metalness: 0.9, roughness: 0.28, emissive: 0x3a2a08, emissiveIntensity: 0.6 }));
+ const gripMat = this.keepMat(new MeshStandardMaterial({ color: 0x0c0d10, metalness: 0.2, roughness: 0.85 }));
+ this.thrusters = this.keepMat(new MeshBasicMaterial({ color: 0xffc65a, transparent: true, opacity: 0.95, blending: AdditiveBlending, depthWrite: false, toneMapped: false }));
+
+ // The deck: a capsule laid along the board's length, flattened.
+ const deckGeo = this.keepGeo(new CapsuleGeometry(0.17, 0.62, 6, 16));
+ const deck = new Mesh(deckGeo, deckMat);
+ deck.rotation.x = Math.PI / 2;
+ deck.scale.set(1, 1, 0.16);
+ deck.position.y = 0;
+ // The gold rim: the same shape a little larger, thinner, just under the deck.
+ const rim = new Mesh(deckGeo, goldMat);
+ rim.rotation.x = Math.PI / 2;
+ rim.scale.set(1.07, 1.04, 0.07);
+ rim.position.y = -0.018;
+ // Grip pad on top, inset.
+ const grip = new Mesh(this.keepGeo(new BoxGeometry(0.24, 0.006, 0.68)), gripMat);
+ grip.position.y = 0.028;
+ // A thin gold spine down the middle of the grip.
+ const spine = new Mesh(this.keepGeo(new BoxGeometry(0.018, 0.008, 0.6)), goldMat);
+ spine.position.y = 0.031;
+ this.group.add(deck, rim, grip, spine);
+
+ // Two thruster pods under nose and tail, glowing nozzles pointing down.
+ const podGeo = this.keepGeo(new CylinderGeometry(0.07, 0.085, 0.05, 18));
+ const nozzleGeo = this.keepGeo(new CylinderGeometry(0.058, 0.03, 0.012, 18));
+ for (const z of [-0.33, 0.33]) {
+ const pod = new Mesh(podGeo, deckMat);
+ pod.position.set(0, -0.045, z);
+ const nozzle = new Mesh(nozzleGeo, this.thrusters);
+ nozzle.position.set(0, -0.074, z);
+ nozzle.renderOrder = RENDER_ORDER.actor + 1;
+ this.group.add(pod, nozzle);
+ }
+ for (const m of this.group.children) {
+ const mesh = m as Mesh;
+ if (mesh.renderOrder === 0) mesh.renderOrder = RENDER_ORDER.actor;
+ mesh.castShadow = false;
+ }
+
+ const tex = glowTexture();
+ this.textures.push(tex);
+ this.glow = new Mesh(this.keepGeo(new PlaneGeometry(1.5, 1.9)), this.keepMat(new MeshBasicMaterial({
+ map: tex, color: 0xffb340, transparent: true, opacity: 0, blending: AdditiveBlending, depthWrite: false, toneMapped: false,
+ })));
+ this.glow.rotation.x = -Math.PI / 2;
+ this.glow.renderOrder = RENDER_ORDER.contactShadow + 1;
+ this.group.visible = false;
+ this.glow.visible = false;
+ }
+
+ /**
+ * Place the board under the rider's feet (`x`, `feetY`, `z`) facing `yaw`,
+ * with the floor at `floorY`, folded out by `share`, leaning by `pitch` and `roll`.
+ */
+ update(x: number, feetY: number, floorY: number, z: number, yaw: number, share: number, pitch: number, roll: number, speed: number, timeS: number): void {
+ const shown = share > 0.001;
+ this.group.visible = shown;
+ this.glow.visible = shown;
+ if (!shown) return;
+ const s = deployScale(share);
+ this.group.position.set(x, feetY - 0.034 * s, z);
+ this.group.rotation.set(pitch, yaw, roll, "YXZ");
+ this.group.scale.set(s, s, s);
+ const flicker = 0.85 + Math.sin(timeS * 31) * 0.08 + Math.sin(timeS * 17.3) * 0.07;
+ const thrust = Math.min(1, 0.55 + speed / BOARD_BOOST);
+ this.thrusters.opacity = Math.min(1, share) * flicker * thrust;
+ this.glow.position.set(x, floorY + 0.008, z);
+ this.glow.rotation.set(-Math.PI / 2, 0, yaw);
+ this.glow.material.opacity = Math.min(1, share) * (0.32 + 0.22 * thrust) * flicker;
+ }
+
+ dispose(): void {
+ for (const g of this.geometries) g.dispose();
+ for (const m of this.owned) m.dispose();
+ for (const t of this.textures) t.dispose();
+ }
+
+ private keepGeo<T extends BufferGeometry>(g: T): T { this.geometries.push(g); return g; }
+ private keepMat<T extends Material>(m: T): T { this.owned.push(m); return m; }
+
+ /** Every material of the board (the rider's room light patches the lit ones). */
+ get materials(): readonly Material[] { return this.owned; }
+}
diff --git a/dodaios/ui/web/frontend/src/components/society/verse/hud/DeckBar.tsx b/dodaios/ui/web/frontend/src/components/society/verse/hud/DeckBar.tsx
index 58edec2a4d..d3493144f4 100644
--- a/dodaios/ui/web/frontend/src/components/society/verse/hud/DeckBar.tsx
+++ b/dodaios/ui/web/frontend/src/components/society/verse/hud/DeckBar.tsx
@@ -61,6 +61,10 @@ interface ToolProps {
firstUnavailable?: string;
onView: (view: VerseView) => void;
onLift: () => void;
+ /** The hoverboard is out (B). */
+ board?: boolean;
+ /** Fold the hoverboard out or away (absent: no board button). */
+ onBoard?: () => void;
onCommander: () => void;
/** The eye-level view's settings; absent where the deck has no eye-level view on this stage. */
onSettings?: () => void;
@@ -79,7 +83,7 @@ const VIEW_LOOKS: Readonly<Record<VerseView, { label: string; path: string }>> =
first: { label: "verse.tools.first", path: "M1 6.5c1.6-2.6 3.4-3.9 5.5-3.9s3.9 1.3 5.5 3.9c-1.6 2.6-3.4 3.9-5.5 3.9S2.6 9.1 1 6.5zM6.5 5a1.5 1.5 0 1 0 0 3a1.5 1.5 0 1 0 0-3" },
};
-export function Toolbar({ t, view, firstAvailable, firstUnavailable, onView, onLift, onCommander, onSettings, onDuel, onHelp }: ToolProps) {
+export function Toolbar({ t, view, firstAvailable, firstUnavailable, onView, onLift, board, onBoard, onCommander, onSettings, onDuel, onHelp }: ToolProps) {
return (
<nav className="verse-tools" aria-label={t("verse.stage.title")}>
{/* The three views side by side, the one on screen pressed; 1, 2 and 3 pick one, V cycles them. */}
@@ -110,6 +114,13 @@ export function Toolbar({ t, view, firstAvailable, firstUnavailable, onView, onL
{icon(LIFT_ICON)}
<span className="verse-tool-text">{t("verse.tools.lift")}</span>
</button>
+ {onBoard && (
+ <button type="button" className="verse-tool" data-tool="board" aria-pressed={!!board} onClick={onBoard} title={`${t("verse.tools.board")} (B)`}>
+ {icon("M1.5 7.5h10a1 1 0 0 1 0 1.6h-10a1 1 0 0 1 0-1.6M3.5 9.1v1.6M9.5 9.1v1.6M5 5.5h3M6.5 2v3.5")}
+ <span className="verse-tool-text">{t("verse.tools.board")}</span>
+ <kbd aria-hidden>B</kbd>
+ </button>
+ )}
<button type="button" className="verse-tool" onClick={onCommander} title={t("verse.tools.commander")}>
{icon("M6.5 1v3M6.5 9v3M1 6.5h3M9 6.5h3M6.5 4.5a2 2 0 1 0 0 4a2 2 0 1 0 0-4")}
<span className="verse-tool-text">{t("verse.tools.commander")}</span>
diff --git a/dodaios/ui/web/frontend/src/components/society/verse/life/control.ts b/dodaios/ui/web/frontend/src/components/society/verse/life/control.ts
index 6fdda20c88..56aa77ea2a 100644
--- a/dodaios/ui/web/frontend/src/components/society/verse/life/control.ts
+++ b/dodaios/ui/web/frontend/src/components/society/verse/life/control.ts
@@ -26,6 +26,8 @@ export class CommanderControl {
mode: ControlMode = "follow";
/** Shift is held: the commander hurries. */
run = false;
+ /** The commander rides the hoverboard (B): the keys glide much faster than a walk. */
+ board = false;
/** The camera should frame the commander at the third-person zoom as soon as they stand on the deck. */
reframe = true;
/** The person dragged the view to look around: the camera leaves the commander until they walk again. */
diff --git a/dodaios/ui/web/frontend/src/components/society/verse/viewmodel/ViewmodelLayer.tsx b/dodaios/ui/web/frontend/src/components/society/verse/viewmodel/ViewmodelLayer.tsx
index e73e3e2e9e..e5a504f868 100644
--- a/dodaios/ui/web/frontend/src/components/society/verse/viewmodel/ViewmodelLayer.tsx
+++ b/dodaios/ui/web/frontend/src/components/society/verse/viewmodel/ViewmodelLayer.tsx
@@ -119,7 +119,8 @@ export function ViewmodelLayer({ runtime, duel, deck, library, commanderId, comm
const l = last.current;
const moved = l.primed ? Math.hypot(pose.x - l.x, pose.z - l.z) : 0;
// A jump (a lift ride, a duel's end) is not a walk.
- const speed = moved > 1 ? 0 : moved / step;
+ // On the hoverboard the body glides: no steps, so no walk bob.
+ const speed = moved > 1 || runtime.control.board ? 0 : moved / step;
frame.speed += (speed - frame.speed) * Math.min(1, step / 0.08);
l.x = pose.x;
l.z = pose.z;
diff --git a/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.de.json b/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.de.json
index 48a8fc47ba..82197f7feb 100644
--- a/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.de.json
+++ b/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.de.json
@@ -5,8 +5,8 @@
"loading": "Deck wird geladen",
"unavailable": "Das Schiff braucht WebGL, das dieses Fenster gerade nicht starten kann.",
"deck_missing": "Dieses Deck ist noch nicht gebaut.",
- "help": "Third Person: WASD oder Pfeiltasten steuern den Kommandanten, Shift läuft schneller, E benutzt die Station in Reichweite. 1, 2 und 3 wählen Vogelperspektive, Third Person oder Ego-Perspektive; V schaltet der Reihe nach durch. Ziehen verschiebt die Ansicht, Scrollen zoomt. Ein Klick auf das Deck schickt dich dorthin, ein Klick auf ein Crewmitglied öffnet seine Akte. F gedrückt halten entfesselt den Bogensturm: Blitze aus beiden Händen.",
- "help_eye": "Third Person und Ego-Perspektive steuern sich wie ein Shooter: Ein Klick in die Ansicht fängt die Maus, Bewegen dreht die Kamera, Esc gibt sie frei. WASD läuft relativ zur Blickrichtung, Shift läuft schneller; die linke Maustaste oder E benutzt, worauf das Fadenkreuz zeigt (ein Crewmitglied, eine Station), sonst benutzt E die Station in Reichweite. Scrollen holt die Kamera näher heran oder weiter weg: ganz heran ist die Ego-Perspektive, wieder herausscrollen kehrt zurück. 1, 2 und 3 wählen Vogelperspektive, Third Person oder Ego-Perspektive; V schaltet der Reihe nach durch. Der Einstellungsknopf in der Werkzeugleiste regelt Mausempfindlichkeit, umgekehrte Achse, Sichtfeld und Qualität. F gedrückt halten entfesselt den Bogensturm: Blitze aus beiden Händen."
+ "help": "Third Person: WASD oder Pfeiltasten steuern den Kommandanten, Shift läuft schneller, E benutzt die Station in Reichweite. 1, 2 und 3 wählen Vogelperspektive, Third Person oder Ego-Perspektive; V schaltet der Reihe nach durch. Ziehen verschiebt die Ansicht, Scrollen zoomt. Ein Klick auf das Deck schickt dich dorthin, ein Klick auf ein Crewmitglied öffnet seine Akte. F gedrückt halten entfesselt den Bogensturm: Blitze aus beiden Händen. B klappt das Hoverboard aus, damit gleitest du viel schneller übers Deck.",
+ "help_eye": "Third Person und Ego-Perspektive steuern sich wie ein Shooter: Ein Klick in die Ansicht fängt die Maus, Bewegen dreht die Kamera, Esc gibt sie frei. WASD läuft relativ zur Blickrichtung, Shift läuft schneller; die linke Maustaste oder E benutzt, worauf das Fadenkreuz zeigt (ein Crewmitglied, eine Station), sonst benutzt E die Station in Reichweite. Scrollen holt die Kamera näher heran oder weiter weg: ganz heran ist die Ego-Perspektive, wieder herausscrollen kehrt zurück. 1, 2 und 3 wählen Vogelperspektive, Third Person oder Ego-Perspektive; V schaltet der Reihe nach durch. Der Einstellungsknopf in der Werkzeugleiste regelt Mausempfindlichkeit, umgekehrte Achse, Sichtfeld und Qualität. F gedrückt halten entfesselt den Bogensturm: Blitze aus beiden Händen. B klappt das Hoverboard aus, damit gleitest du viel schneller übers Deck."
},
"deck": {
"label": "Deck {n}",
@@ -103,7 +103,8 @@
"first_unavailable": "Die Ego-Perspektive braucht die 3D-Szene dieses Decks auf der großen Bühne.",
"click_to_look": "Klicken zum Umsehen",
"first_too_small": "Für Schulter- und Ego-Perspektive braucht dieses Panel mindestens {width} × {height}.",
- "click_for_keys": "Hier klicken, damit die Tasten das Schiff steuern"
+ "click_for_keys": "Hier klicken, damit die Tasten das Schiff steuern",
+ "board": "Hoverboard"
},
"settings": {
"title": "Ansichtseinstellungen",
@@ -255,6 +256,10 @@
"needs_eye": "Duelle brauchen die 3D-Ansicht in der dritten Person.",
"left": "Du hast das Duell verlassen."
}
+ },
+ "board": {
+ "on": "Hoverboard ausgeklappt: WASD gleitet, Shift gibt Schub. B klappt es wieder ein.",
+ "off": "Hoverboard eingeklappt."
}
}
}
diff --git a/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.en.json b/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.en.json
index 241d321986..3a39eba43c 100644
--- a/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.en.json
+++ b/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.en.json
@@ -5,8 +5,8 @@
"loading": "Loading deck",
"unavailable": "The ship needs WebGL, which this window cannot start right now.",
"deck_missing": "This deck has not been built yet.",
- "help": "Third person: WASD or the arrow keys walk the commander, Shift hurries, E works the station within reach. 1, 2 and 3 pick the bird's-eye view, third or first person; V cycles them. Drag to look around, scroll to zoom. Click the deck to walk there, click a crew member for their record. Hold F to unleash Arc Storm, lightning from both hands.",
- "help_eye": "Third and first person play like a shooter: a click on the view takes the mouse, moving it turns the camera, Esc gives it back. WASD walks relative to the view, Shift hurries; the left button or E works what the crosshair is on (a crew member, a station), else E works the station within reach. Scroll to move the camera in or out: all the way in is first person, scrolling out of it comes back. 1, 2 and 3 pick the bird's-eye view, third or first person; V cycles them. The settings button on the tool rail sets mouse sensitivity, inverted look, field of view and quality. Hold F to unleash Arc Storm, lightning from both hands."
+ "help": "Third person: WASD or the arrow keys walk the commander, Shift hurries, E works the station within reach. 1, 2 and 3 pick the bird's-eye view, third or first person; V cycles them. Drag to look around, scroll to zoom. Click the deck to walk there, click a crew member for their record. Hold F to unleash Arc Storm, lightning from both hands. B folds out the hoverboard, which glides across the deck much faster.",
+ "help_eye": "Third and first person play like a shooter: a click on the view takes the mouse, moving it turns the camera, Esc gives it back. WASD walks relative to the view, Shift hurries; the left button or E works what the crosshair is on (a crew member, a station), else E works the station within reach. Scroll to move the camera in or out: all the way in is first person, scrolling out of it comes back. 1, 2 and 3 pick the bird's-eye view, third or first person; V cycles them. The settings button on the tool rail sets mouse sensitivity, inverted look, field of view and quality. Hold F to unleash Arc Storm, lightning from both hands. B folds out the hoverboard, which glides across the deck much faster."
},
"deck": {
"label": "Deck {n}",
@@ -103,7 +103,8 @@
"first_unavailable": "First person needs this deck's eye-level scene on the full-size stage.",
"click_to_look": "Click to look around",
"first_too_small": "Make this panel at least {width} × {height} for third and first person.",
- "click_for_keys": "Click here so the keys reach the ship"
+ "click_for_keys": "Click here so the keys reach the ship",
+ "board": "Hoverboard"
},
"settings": {
"title": "View settings",
@@ -255,6 +256,10 @@
"needs_eye": "Duels need the third-person 3D view.",
"left": "You left the duel."
}
+ },
+ "board": {
+ "on": "Hoverboard out: WASD glides, Shift boosts. B folds it away.",
+ "off": "Hoverboard folded away."
}
}
}
diff --git a/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.es.json b/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.es.json
index 9d525d499d..fd238fbc4f 100644
--- a/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.es.json
+++ b/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.es.json
@@ -5,8 +5,8 @@
"loading": "Cargando cubierta",
"unavailable": "La nave necesita WebGL y esta ventana no puede iniciarlo ahora.",
"deck_missing": "Esta cubierta aún no está construida.",
- "help": "Tercera persona: WASD o las flechas mueven al comandante, Shift acelera, E usa la estación al alcance. 1, 2 y 3 eligen vista de pájaro, tercera o primera persona; V las recorre. Arrastra para mirar, desplaza para hacer zoom. Haz clic en la cubierta para ir allí, en un tripulante para ver su ficha. Mantén F para desatar la Tormenta de Arcos: rayos de ambas manos.",
- "help_eye": "La tercera y la primera persona se juegan como un shooter: un clic en la vista captura el ratón, moverlo gira la cámara, Esc lo libera. WASD camina según la vista, Shift acelera; el botón izquierdo o E usa lo que señala la mira (un tripulante, una estación); si no, E usa la estación al alcance. La rueda acerca o aleja la cámara: del todo cerca es primera persona y alejarse vuelve. 1, 2 y 3 eligen vista de pájaro, tercera o primera persona; V las recorre. El botón de ajustes de la barra regula la sensibilidad del ratón, el eje invertido, el campo de visión y la calidad. Mantén F para desatar la Tormenta de Arcos: rayos de ambas manos."
+ "help": "Tercera persona: WASD o las flechas mueven al comandante, Shift acelera, E usa la estación al alcance. 1, 2 y 3 eligen vista de pájaro, tercera o primera persona; V las recorre. Arrastra para mirar, desplaza para hacer zoom. Haz clic en la cubierta para ir allí, en un tripulante para ver su ficha. Mantén F para desatar la Tormenta de Arcos: rayos de ambas manos. B despliega el hoverboard, que cruza la cubierta mucho más rápido.",
+ "help_eye": "La tercera y la primera persona se juegan como un shooter: un clic en la vista captura el ratón, moverlo gira la cámara, Esc lo libera. WASD camina según la vista, Shift acelera; el botón izquierdo o E usa lo que señala la mira (un tripulante, una estación); si no, E usa la estación al alcance. La rueda acerca o aleja la cámara: del todo cerca es primera persona y alejarse vuelve. 1, 2 y 3 eligen vista de pájaro, tercera o primera persona; V las recorre. El botón de ajustes de la barra regula la sensibilidad del ratón, el eje invertido, el campo de visión y la calidad. Mantén F para desatar la Tormenta de Arcos: rayos de ambas manos. B despliega el hoverboard, que cruza la cubierta mucho más rápido."
},
"deck": {
"label": "Cubierta {n}",
@@ -103,7 +103,8 @@
"first_unavailable": "La primera persona necesita la escena 3D de esta cubierta en el escenario completo.",
"click_to_look": "Haz clic para mirar",
"first_too_small": "Amplía este panel a al menos {width} × {height} para la tercera y la primera persona.",
- "click_for_keys": "Haz clic aquí para que las teclas lleguen a la nave"
+ "click_for_keys": "Haz clic aquí para que las teclas lleguen a la nave",
+ "board": "Hoverboard"
},
"settings": {
"title": "Ajustes de vista",
@@ -255,6 +256,10 @@
"needs_eye": "Los duelos necesitan la vista 3D en tercera persona.",
"left": "Has salido del duelo."
}
+ },
+ "board": {
+ "on": "Hoverboard desplegado: WASD planea, Shift da impulso. B lo pliega.",
+ "off": "Hoverboard plegado."
}
}
}
diff --git a/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.pt.json b/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.pt.json
index aab7d215da..8af1414d0b 100644
--- a/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.pt.json
+++ b/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.pt.json
@@ -5,8 +5,8 @@
"loading": "Carregando o convés",
"unavailable": "A nave precisa de WebGL, que esta janela não consegue iniciar agora.",
"deck_missing": "Este convés ainda não foi construído.",
- "help": "Terceira pessoa: WASD ou as setas movem o comandante, Shift acelera, E usa a estação ao alcance. 1, 2 e 3 escolhem vista aérea, terceira ou primeira pessoa; V alterna entre elas. Arraste para olhar, role para dar zoom. Clique no convés para ir até lá, num tripulante para ver a ficha. Segure F para liberar a Tempestade de Arcos: raios das duas mãos.",
- "help_eye": "A terceira e a primeira pessoa funcionam como um shooter: um clique na vista captura o mouse, movê-lo gira a câmera, Esc o libera. WASD anda conforme a vista, Shift acelera; o botão esquerdo ou E usa o que a mira aponta (um tripulante, uma estação); senão, E usa a estação ao alcance. A roda aproxima ou afasta a câmera: tudo perto é primeira pessoa, e afastar volta. 1, 2 e 3 escolhem vista aérea, terceira ou primeira pessoa; V alterna entre elas. O botão de ajustes da barra define a sensibilidade do mouse, o eixo invertido, o campo de visão e a qualidade. Segure F para liberar a Tempestade de Arcos: raios das duas mãos."
+ "help": "Terceira pessoa: WASD ou as setas movem o comandante, Shift acelera, E usa a estação ao alcance. 1, 2 e 3 escolhem vista aérea, terceira ou primeira pessoa; V alterna entre elas. Arraste para olhar, role para dar zoom. Clique no convés para ir até lá, num tripulante para ver a ficha. Segure F para liberar a Tempestade de Arcos: raios das duas mãos. B abre o hoverboard, que cruza o convés muito mais rápido.",
+ "help_eye": "A terceira e a primeira pessoa funcionam como um shooter: um clique na vista captura o mouse, movê-lo gira a câmera, Esc o libera. WASD anda conforme a vista, Shift acelera; o botão esquerdo ou E usa o que a mira aponta (um tripulante, uma estação); senão, E usa a estação ao alcance. A roda aproxima ou afasta a câmera: tudo perto é primeira pessoa, e afastar volta. 1, 2 e 3 escolhem vista aérea, terceira ou primeira pessoa; V alterna entre elas. O botão de ajustes da barra define a sensibilidade do mouse, o eixo invertido, o campo de visão e a qualidade. Segure F para liberar a Tempestade de Arcos: raios das duas mãos. B abre o hoverboard, que cruza o convés muito mais rápido."
},
"deck": {
"label": "Convés {n}",
@@ -103,7 +103,8 @@
"first_unavailable": "A primeira pessoa precisa da cena 3D deste convés no palco completo.",
"click_to_look": "Clique para olhar",
"first_too_small": "Aumente este painel para pelo menos {width} × {height} para a terceira e a primeira pessoa.",
- "click_for_keys": "Clique aqui para que as teclas cheguem à nave"
+ "click_for_keys": "Clique aqui para que as teclas cheguem à nave",
+ "board": "Hoverboard"
},
"settings": {
"title": "Ajustes de visualização",
@@ -255,6 +256,10 @@
"needs_eye": "Duelos precisam da visão 3D em terceira pessoa.",
"left": "Você saiu do duelo."
}
+ },
+ "board": {
+ "on": "Hoverboard aberto: WASD desliza, Shift dá impulso. B o recolhe.",
+ "off": "Hoverboard recolhido."
}
}
}
diff --git a/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.zh.json b/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.zh.json
index 1f37428f82..175dc4fea0 100644
--- a/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.zh.json
+++ b/dodaios/ui/web/frontend/src/i18n/locales/ship/verse.zh.json
@@ -5,8 +5,8 @@
"loading": "正在载入甲板",
"unavailable": "飞船需要 WebGL,但此窗口目前无法启动它。",
"deck_missing": "这层甲板尚未建成。",
- "help": "第三人称:WASD 或方向键操控指挥官,Shift 加速,E 使用附近的工作站。1、2、3 分别选择鸟瞰、第三人称或第一人称;V 依次切换。拖动环顾四周,滚轮缩放。点击甲板走过去,点击船员查看其档案。 按住 F 释放电弧风暴:双手迸发闪电。",
- "help_eye": "第三人称和第一人称的操作与射击游戏相同:点击画面锁定鼠标,移动鼠标转动镜头,Esc 释放。WASD 按视角方向行走,Shift 加速;鼠标左键或 E 使用准星所指的对象(船员或工作站),否则 E 使用附近的工作站。滚轮拉近或拉远镜头:拉到最近即进入第一人称,向外滚动则返回。1、2、3 分别选择鸟瞰、第三人称或第一人称;V 依次切换。工具栏中的设置按钮可调整鼠标灵敏度、反转视角、视野和画质。 按住 F 释放电弧风暴:双手迸发闪电。"
+ "help": "第三人称:WASD 或方向键操控指挥官,Shift 加速,E 使用附近的工作站。1、2、3 分别选择鸟瞰、第三人称或第一人称;V 依次切换。拖动环顾四周,滚轮缩放。点击甲板走过去,点击船员查看其档案。 按住 F 释放电弧风暴:双手迸发闪电。B 展开悬浮板,在甲板上滑行快得多。",
+ "help_eye": "第三人称和第一人称的操作与射击游戏相同:点击画面锁定鼠标,移动鼠标转动镜头,Esc 释放。WASD 按视角方向行走,Shift 加速;鼠标左键或 E 使用准星所指的对象(船员或工作站),否则 E 使用附近的工作站。滚轮拉近或拉远镜头:拉到最近即进入第一人称,向外滚动则返回。1、2、3 分别选择鸟瞰、第三人称或第一人称;V 依次切换。工具栏中的设置按钮可调整鼠标灵敏度、反转视角、视野和画质。 按住 F 释放电弧风暴:双手迸发闪电。B 展开悬浮板,在甲板上滑行快得多。"
},
"deck": {
"label": "第 {n} 层甲板",
@@ -103,7 +103,8 @@
"first_unavailable": "第一人称需要在完整舞台上加载本甲板的 3D 场景。",
"click_to_look": "点击以环顾",
"first_too_small": "将此面板调整到至少 {width} × {height} 才能使用第三人称和第一人称。",
- "click_for_keys": "点击此处,让按键控制飞船"
+ "click_for_keys": "点击此处,让按键控制飞船",
+ "board": "悬浮板"
},
"settings": {
"title": "视角设置",
@@ -255,6 +256,10 @@
"needs_eye": "决斗需要第三人称 3D 视图。",
"left": "你已退出决斗。"
}
+ },
+ "board": {
+ "on": "悬浮板已展开:WASD 滑行,Shift 加速。按 B 收起。",
+ "off": "悬浮板已收起。"
}
}
}