Improve netcode and simplify (#4)
- Simplify the logic wherever possible to remove overengineering and simplify the netcode - Actually improve the netcode - The new lines are mainly the package locks and tests Reviewed-on: https://home.schmelczer.dev/git/andras/decla-red/pulls/4
This commit is contained in:
parent
5d854440ec
commit
93a7fe01ab
176 changed files with 15073 additions and 4754 deletions
|
|
@ -1,4 +1,3 @@
|
|||
# The server image only needs `shared/` and `backend/`.
|
||||
**/node_modules
|
||||
**/dist
|
||||
**/lib
|
||||
|
|
|
|||
|
|
@ -13,7 +13,6 @@ concurrency:
|
|||
cancel-in-progress: true
|
||||
|
||||
jobs:
|
||||
# ---- Static website -> /pages mount on the runner host --------------------
|
||||
website:
|
||||
name: Build & deploy website
|
||||
runs-on: docker
|
||||
|
|
@ -26,8 +25,11 @@ jobs:
|
|||
node-version-file: .nvmrc
|
||||
|
||||
- name: Install dependencies
|
||||
# No lockfiles are committed (see .gitignore), so use `npm install`.
|
||||
run: npm install && npm run init
|
||||
run: |
|
||||
npm ci
|
||||
npm --prefix shared ci
|
||||
npm --prefix frontend ci
|
||||
npm --prefix backend ci
|
||||
|
||||
- name: Build (shared -> frontend -> backend)
|
||||
run: npm run build
|
||||
|
|
@ -45,11 +47,9 @@ jobs:
|
|||
source: frontend/dist
|
||||
target: declared
|
||||
|
||||
# ---- Server Docker image -> Forgejo container registry --------------------
|
||||
server-image:
|
||||
name: Build & publish server image
|
||||
runs-on: docker
|
||||
# No registry push on PRs; build validation still happens in the website job.
|
||||
if: github.event_name != 'pull_request'
|
||||
steps:
|
||||
- name: Checkout
|
||||
|
|
|
|||
1
.gitignore
vendored
1
.gitignore
vendored
|
|
@ -4,5 +4,4 @@ node_modules
|
|||
.firebase
|
||||
yarm-error.log
|
||||
yarn.lock
|
||||
package-lock.json
|
||||
.DS_Store
|
||||
|
|
|
|||
3
.vscode/launch.json
vendored
3
.vscode/launch.json
vendored
|
|
@ -1,7 +1,4 @@
|
|||
{
|
||||
// Use IntelliSense to learn about possible attributes.
|
||||
// Hover to view descriptions of existing attributes.
|
||||
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
|
||||
"version": "0.2.0",
|
||||
"configurations": [
|
||||
{
|
||||
|
|
|
|||
26
Dockerfile
26
Dockerfile
|
|
@ -1,38 +1,29 @@
|
|||
# syntax=docker/dockerfile:1
|
||||
|
||||
# doppler game server (the `doppler-server` package).
|
||||
# The frontend is a static site and is NOT built here — see .forgejo/workflows.
|
||||
|
||||
# ---- Stage 1: build the shared lib, then bundle the server -------------------
|
||||
# Node 22 (current LTS) matches the project toolchain (webpack 5 / TypeScript 6,
|
||||
# see .devcontainer). The full (non-slim) image carries the build tools that
|
||||
# socket.io's optional native deps (bufferutil/utf-8-validate) compile against.
|
||||
# The full image carries the build tools for socket.io's optional native dependencies.
|
||||
FROM node:22-bookworm AS build
|
||||
WORKDIR /app
|
||||
|
||||
# `shared` is consumed by the backend as `file:../shared` and is bundled into
|
||||
# the server bundle by webpack, so it must be installed and built first.
|
||||
COPY shared/package.json shared/
|
||||
RUN cd shared && npm install
|
||||
COPY shared/package.json shared/package-lock.json shared/
|
||||
RUN npm --prefix shared ci
|
||||
COPY shared/ shared/
|
||||
RUN cd shared && npm run build
|
||||
RUN npm --prefix shared run build
|
||||
|
||||
# Install the backend deps. `file:../shared` now resolves to the built /app/shared.
|
||||
COPY backend/package.json backend/
|
||||
RUN cd backend && npm install
|
||||
COPY backend/package.json backend/package-lock.json backend/
|
||||
RUN npm --prefix backend ci
|
||||
COPY backend/ backend/
|
||||
RUN cd backend && npm run build
|
||||
RUN npm --prefix backend run build
|
||||
|
||||
# Drop devDependencies; the runtime only needs the production deps that webpack
|
||||
# left external (express, socket.io, cors, gl-matrix, minimist, msgpack parser).
|
||||
RUN cd backend && npm prune --production
|
||||
RUN npm --prefix backend prune --production
|
||||
|
||||
# ---- Stage 2: minimal runtime ----------------------------------------------
|
||||
FROM node:22-bookworm-slim
|
||||
WORKDIR /app
|
||||
ENV NODE_ENV=production
|
||||
|
||||
# Run as an unprivileged user.
|
||||
RUN groupadd -r app && useradd -r -g app -d /app app
|
||||
|
||||
COPY --from=build /app/backend/dist ./dist
|
||||
|
|
@ -41,7 +32,6 @@ COPY --from=build /app/backend/node_modules ./node_modules
|
|||
USER app
|
||||
EXPOSE 3000
|
||||
|
||||
# Hits the same /state endpoint the website polls (see serverInformationEndpoint).
|
||||
HEALTHCHECK --interval=30s --timeout=5s --start-period=15s --retries=3 \
|
||||
CMD node -e "require('http').get('http://localhost:3000/state',r=>process.exit(r.statusCode===200?0:1)).on('error',()=>process.exit(1))"
|
||||
|
||||
|
|
|
|||
16
README.md
16
README.md
|
|
@ -9,19 +9,11 @@ A 2-dimensional multiplayer game utilising ray tracing.
|
|||
|
||||
For optimised 2D ray tracing, [SDF-2D](https://github.com/schmelczerandras/sdf-2d) is used.
|
||||
|
||||
## Deployment
|
||||
## Development
|
||||
|
||||
CI/CD runs on Forgejo Actions (`.forgejo/workflows/deploy.yml`). On a push to
|
||||
`main` it:
|
||||
|
||||
- builds the static frontend and rsyncs `frontend/dist/` to the `/pages/declared`
|
||||
mount on the runner host (the mount keeps its pre-rebrand name), and
|
||||
- builds the server image from the root `Dockerfile` and pushes it to the Forgejo
|
||||
container registry as `<registry>/<owner>/<repo>-server`.
|
||||
|
||||
The registry job needs a `FORGEJO_PACKAGE_TOKEN` secret (with package write
|
||||
scope) and, optionally, a `CONTAINER_REGISTRY_HOST` variable to override the
|
||||
registry host.
|
||||
Run `npm install && npm run init` once, then `npm run dev`. Run `npm test` for
|
||||
regressions, `npm run lint:check` for formatting and lint, and `npm run build` for
|
||||
all production bundles. Tests rebuild the shared library before running.
|
||||
|
||||
The website's server list is hardcoded in
|
||||
[`frontend/src/scripts/configuration.ts`](frontend/src/scripts/configuration.ts) —
|
||||
|
|
|
|||
3635
backend/package-lock.json
generated
Normal file
3635
backend/package-lock.json
generated
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -13,7 +13,7 @@
|
|||
},
|
||||
"scripts": {
|
||||
"build": "npx webpack --mode production",
|
||||
"dev": "concurrently --kill-others-on-fail \"webpack --mode development -w\" \"nodemon --legacy-watch dist/main.js\"",
|
||||
"dev": "concurrently --kill-others-on-fail \"webpack --mode development -w\" \"nodemon --legacy-watch --delay 500ms dist/main.js\"",
|
||||
"try-build": "npm run build && cd dist && node main.js && cd -"
|
||||
},
|
||||
"dependencies": {
|
||||
|
|
|
|||
|
|
@ -1,9 +0,0 @@
|
|||
import { Command } from 'shared';
|
||||
|
||||
// Internal request from a game object (e.g. a keystone planet flipping) asking
|
||||
// the GameServer to broadcast a one-off announcement to every connected client.
|
||||
export class AnnounceCommand extends Command {
|
||||
public constructor(public readonly text: string) {
|
||||
super();
|
||||
}
|
||||
}
|
||||
|
|
@ -1,10 +0,0 @@
|
|||
import { Command } from 'shared';
|
||||
|
||||
export class GeneratePointsCommand extends Command {
|
||||
public constructor(
|
||||
public readonly blue: number,
|
||||
public readonly red: number,
|
||||
) {
|
||||
super();
|
||||
}
|
||||
}
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
import { Command, GameObject } from 'shared';
|
||||
|
||||
export class ReactToCollisionCommand extends Command {
|
||||
public constructor(public readonly other: GameObject) {
|
||||
super();
|
||||
}
|
||||
}
|
||||
|
|
@ -1,10 +0,0 @@
|
|||
import { Command, CommandReceiver } from 'shared';
|
||||
|
||||
export class StepCommand extends Command {
|
||||
public constructor(
|
||||
public readonly deltaTimeInSeconds: number,
|
||||
public readonly game: CommandReceiver,
|
||||
) {
|
||||
super();
|
||||
}
|
||||
}
|
||||
|
|
@ -2,16 +2,14 @@ import { vec2 } from 'gl-matrix';
|
|||
import { Random, PlanetBase, hsl, settings, evaluateSdf } from 'shared';
|
||||
import { LampPhysical } from './objects/lamp-physical';
|
||||
import { PlanetPhysical } from './objects/planet-physical';
|
||||
import { PhysicalContainer } from './physics/containers/physical-container';
|
||||
import { Physical } from './physics/physicals/physical';
|
||||
import { PhysicalContainer } from './physics/physical-container';
|
||||
|
||||
export const createWorld = (objectContainer: PhysicalContainer) => {
|
||||
const objects: Array<Physical> = [];
|
||||
const lights: Array<Physical> = [];
|
||||
const planets: Array<PlanetPhysical> = [];
|
||||
const lamps: Array<LampPhysical> = [];
|
||||
|
||||
for (let r = 0; r < settings.worldRadius; r += settings.radiusSteps) {
|
||||
const circumference = 2 * Math.PI * r;
|
||||
const stepCount = circumference * settings.objectsOnCircleLength;
|
||||
const stepCount = 2 * Math.PI * r * settings.objectsOnCircleLength;
|
||||
for (let rad = 0; rad < 2 * Math.PI; rad += (2 * Math.PI) / stepCount) {
|
||||
const position = vec2.rotate(
|
||||
vec2.create(),
|
||||
|
|
@ -20,12 +18,12 @@ export const createWorld = (objectContainer: PhysicalContainer) => {
|
|||
rad,
|
||||
);
|
||||
|
||||
if (objects.length !== 0 && Random.getRandom() > 0.5) {
|
||||
if (planets.length !== 0 && Random.getRandom() > 0.5) {
|
||||
if (
|
||||
evaluateSdf(position, objects) > 200 &&
|
||||
!lights.find((l) => l.distance(position) < 2500)
|
||||
evaluateSdf(position, planets) > 200 &&
|
||||
!lamps.find((l) => l.distance(position) < 2500)
|
||||
) {
|
||||
lights.push(
|
||||
lamps.push(
|
||||
new LampPhysical(
|
||||
position,
|
||||
hsl(
|
||||
|
|
@ -37,61 +35,43 @@ export const createWorld = (objectContainer: PhysicalContainer) => {
|
|||
),
|
||||
);
|
||||
}
|
||||
} else {
|
||||
if (
|
||||
evaluateSdf(position, objects) > 1400 &&
|
||||
!lights.find((l) => l.distance(position) < 1700)
|
||||
) {
|
||||
const planet =
|
||||
objects.length === 0
|
||||
? // The first, central giant is the keystone "Heart": a named,
|
||||
// always-contested focal objective the whole match orbits.
|
||||
new PlanetPhysical(
|
||||
PlanetBase.createPlanetVertices(
|
||||
position,
|
||||
Random.getRandomInRange(1600, 2400),
|
||||
Random.getRandomInRange(1600, 2400),
|
||||
Random.getRandomInRange(80, 300),
|
||||
),
|
||||
true,
|
||||
)
|
||||
: new PlanetPhysical(
|
||||
PlanetBase.createPlanetVertices(
|
||||
position,
|
||||
Random.getRandomInRange(300, 1600),
|
||||
Random.getRandomInRange(300, 1600),
|
||||
Random.getRandomInRange(20, 100),
|
||||
),
|
||||
);
|
||||
|
||||
objects.push(planet);
|
||||
}
|
||||
} else if (
|
||||
evaluateSdf(position, planets) > 1400 &&
|
||||
!lamps.find((l) => l.distance(position) < 1700)
|
||||
) {
|
||||
const isKeystone = planets.length === 0;
|
||||
const [sizeMin, sizeMax, roughMin, roughMax] = isKeystone
|
||||
? [1600, 2400, 80, 300]
|
||||
: [300, 1600, 20, 100];
|
||||
planets.push(
|
||||
new PlanetPhysical(
|
||||
PlanetBase.createPlanetVertices(
|
||||
position,
|
||||
Random.getRandomInRange(sizeMin, sizeMax),
|
||||
Random.getRandomInRange(sizeMin, sizeMax),
|
||||
Random.getRandomInRange(roughMin, roughMax),
|
||||
),
|
||||
isKeystone,
|
||||
objectContainer.game,
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
console.info(`Generated ${objects.length} planets`);
|
||||
console.info(`Generated ${lights.length} light`);
|
||||
console.info(`Generated ${planets.length} planets and ${lamps.length} lamps`);
|
||||
|
||||
// Associate each lamp with its NEAREST planet, so a planet can repaint "its"
|
||||
// lamps to the owning team's colour when it flips. Lamps are already placed by
|
||||
// proximity during world-gen, so the nearest planet is the one whose capture
|
||||
// they should advertise. Distances use the planet SDF (negative inside), which
|
||||
// is exactly the "closest planet" metric we want.
|
||||
const planets = objects.filter((o): o is PlanetPhysical => o instanceof PlanetPhysical);
|
||||
lights
|
||||
.filter((l): l is LampPhysical => l instanceof LampPhysical)
|
||||
.forEach((lamp) => {
|
||||
let nearest: PlanetPhysical | undefined;
|
||||
let nearestDistance = Infinity;
|
||||
planets.forEach((planet) => {
|
||||
const distance = planet.distance(lamp.center);
|
||||
if (distance < nearestDistance) {
|
||||
nearestDistance = distance;
|
||||
nearest = planet;
|
||||
}
|
||||
});
|
||||
nearest?.addLamp(lamp);
|
||||
});
|
||||
for (const lamp of lamps) {
|
||||
let nearest: PlanetPhysical | undefined;
|
||||
let nearestDistance = Infinity;
|
||||
for (const planet of planets) {
|
||||
const distance = planet.distance(lamp.center);
|
||||
if (distance < nearestDistance) {
|
||||
nearestDistance = distance;
|
||||
nearest = planet;
|
||||
}
|
||||
}
|
||||
nearest?.addLamp(lamp);
|
||||
}
|
||||
|
||||
[...objects, ...lights].forEach((o) => objectContainer.addObject(o));
|
||||
[...planets, ...lamps].forEach((o) => objectContainer.addObject(o));
|
||||
};
|
||||
|
|
|
|||
|
|
@ -1,10 +0,0 @@
|
|||
import { Options } from './options';
|
||||
|
||||
export const defaultOptions: Options = {
|
||||
port: 3000,
|
||||
name: 'Test server',
|
||||
playerLimit: 16,
|
||||
npcCount: 8,
|
||||
seed: Math.random(),
|
||||
scoreLimit: 2500,
|
||||
};
|
||||
17
backend/src/game-events.ts
Normal file
17
backend/src/game-events.ts
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
import { CharacterTeam } from 'shared';
|
||||
|
||||
export interface GameEvents {
|
||||
addPoints(blue: number, red: number): void;
|
||||
announce(text: string): void;
|
||||
}
|
||||
|
||||
export const addPointsForTeam = (
|
||||
game: GameEvents,
|
||||
team: CharacterTeam,
|
||||
points: number,
|
||||
): void => {
|
||||
game.addPoints(
|
||||
team === CharacterTeam.blue ? points : 0,
|
||||
team === CharacterTeam.red ? points : 0,
|
||||
);
|
||||
};
|
||||
|
|
@ -1,5 +1,6 @@
|
|||
import { PhysicalContainer } from './physics/containers/physical-container';
|
||||
import { Server, Socket } from 'socket.io';
|
||||
import { randomUUID } from 'node:crypto';
|
||||
import { performance } from 'node:perf_hooks';
|
||||
import {
|
||||
TransportEvents,
|
||||
deserialize,
|
||||
|
|
@ -11,25 +12,36 @@ import {
|
|||
GameEndCommand,
|
||||
GameStartCommand,
|
||||
Command,
|
||||
CommandReceiver,
|
||||
CommandExecutors,
|
||||
ServerAnnouncement,
|
||||
JoinRejectionReason,
|
||||
GameObject,
|
||||
PropertyUpdatesForObject,
|
||||
} from 'shared';
|
||||
import { PhysicalContainer } from './physics/physical-container';
|
||||
import { createWorld } from './create-world';
|
||||
import { DeltaTimeCalculator } from './helper/delta-time-calculator';
|
||||
import { Options } from './options';
|
||||
import { PlayerContainer } from './players/player-container';
|
||||
import { StepCommand } from './commands/step';
|
||||
import { GeneratePointsCommand } from './commands/generate-points';
|
||||
import { AnnounceCommand } from './commands/announce';
|
||||
import { GameEvents } from './game-events';
|
||||
import { CarriedScore, PlayerContainer } from './players/player-container';
|
||||
import { Player } from './players/player';
|
||||
|
||||
const gameStateSubscribedRoom = 'gameStateSubscribedRoom';
|
||||
const endTitleSeconds = 6;
|
||||
|
||||
export class GameServer extends CommandReceiver {
|
||||
const asPlayerInformation = (payload: unknown): PlayerInformation | undefined => {
|
||||
if (!payload || typeof payload !== 'object') {
|
||||
return undefined;
|
||||
}
|
||||
const { name, reconnectToken } = payload as Record<string, unknown>;
|
||||
return {
|
||||
name: name as string,
|
||||
reconnectToken: typeof reconnectToken === 'string' ? reconnectToken : undefined,
|
||||
};
|
||||
};
|
||||
|
||||
export class GameServer implements GameEvents {
|
||||
private objects!: PhysicalContainer;
|
||||
private players!: PlayerContainer;
|
||||
private deltaTimes!: Array<number>;
|
||||
private deltaTimeCalculator!: DeltaTimeCalculator;
|
||||
private lastPhysicsBase = process.hrtime.bigint();
|
||||
|
||||
private bluePoints = 0;
|
||||
private redPoints = 0;
|
||||
|
|
@ -37,92 +49,202 @@ export class GameServer extends CommandReceiver {
|
|||
|
||||
private isInEndGame = false;
|
||||
private timeScaling = 1;
|
||||
private statReportMs = Date.now();
|
||||
private timeSinceLastServerStateUpdate = 0;
|
||||
private timeSinceLastPointUpdate = 0;
|
||||
private physicsAccumulator = 0;
|
||||
private saturatedFrames = 0;
|
||||
private droppedInboundMessages = 0;
|
||||
|
||||
private serverName: string;
|
||||
private playerLimit: number;
|
||||
|
||||
private initialize() {
|
||||
const previousPlayers = this.players;
|
||||
this.objects = new PhysicalContainer();
|
||||
createWorld(this.objects);
|
||||
this.objects.initialize();
|
||||
this.players = new PlayerContainer(
|
||||
this.objects,
|
||||
this.options.playerLimit,
|
||||
this.options.npcCount,
|
||||
);
|
||||
this.deltaTimeCalculator = new DeltaTimeCalculator();
|
||||
this.deltaTimes = [];
|
||||
this.bluePoints = 0;
|
||||
this.redPoints = 0;
|
||||
this.matchPointAnnounced = {};
|
||||
this.isInEndGame = false;
|
||||
this.timeScaling = 1;
|
||||
previousPlayers?.queueCommandForEachClient(new GameStartCommand());
|
||||
previousPlayers?.sendQueuedCommands();
|
||||
}
|
||||
|
||||
protected commandExecutors: CommandExecutors = {
|
||||
[GeneratePointsCommand.type]: this.addPoints.bind(this),
|
||||
[AnnounceCommand.type]: ({ text }: AnnounceCommand) =>
|
||||
this.players.queueCommandForEachClient(new ServerAnnouncement(text)),
|
||||
};
|
||||
private readonly joinedSockets = new Map<
|
||||
Socket,
|
||||
{ player: Player; release: () => void }
|
||||
>();
|
||||
private inboundBudget = new WeakMap<Socket, { tokens: number; lastMs: number }>();
|
||||
|
||||
constructor(
|
||||
private readonly io: Server,
|
||||
private options: Options,
|
||||
) {
|
||||
super();
|
||||
|
||||
this.serverName = options.name;
|
||||
this.playerLimit = options.playerLimit;
|
||||
|
||||
this.initialize();
|
||||
|
||||
io.on('connection', (socket: Socket) => {
|
||||
socket.on(TransportEvents.PlayerJoining, (playerInfo: PlayerInformation) => {
|
||||
socket.on(TransportEvents.PlayerJoining, (payload: unknown) => {
|
||||
if (!this.allowInboundMessage(socket)) {
|
||||
return;
|
||||
}
|
||||
try {
|
||||
const player = this.players.createPlayer(playerInfo, socket);
|
||||
socket.on(TransportEvents.PlayerToServer, (json: string) => {
|
||||
try {
|
||||
const commands: Array<Command> = deserialize(json);
|
||||
commands.forEach((c) => player.handleCommand(c));
|
||||
} catch (e) {
|
||||
console.error('Error while processing command', e);
|
||||
}
|
||||
});
|
||||
|
||||
this.sendServerStateUpdate();
|
||||
|
||||
socket.on('disconnect', () => {
|
||||
player.destroy();
|
||||
this.players.deletePlayer(player);
|
||||
this.sendServerStateUpdate();
|
||||
});
|
||||
this.handleJoin(socket, payload);
|
||||
} catch (e) {
|
||||
console.error('Failed to register joining player; disconnecting socket', e);
|
||||
console.error('Failed to handle a join request', e);
|
||||
socket.emit(TransportEvents.JoinRejected, JoinRejectionReason.InvalidRequest);
|
||||
socket.disconnect();
|
||||
}
|
||||
});
|
||||
|
||||
socket.on(TransportEvents.SubscribeForServerInfoUpdates, () => {
|
||||
socket.join(gameStateSubscribedRoom);
|
||||
if (this.allowInboundMessage(socket)) {
|
||||
socket.join(gameStateSubscribedRoom);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
private timeSinceLastServerStateUpdate = 0;
|
||||
private initialize() {
|
||||
const previousPlayers = this.players;
|
||||
this.joinedSockets.forEach(({ release }) => release());
|
||||
this.joinedSockets.clear();
|
||||
this.inboundBudget = new WeakMap();
|
||||
|
||||
this.objects = new PhysicalContainer(this);
|
||||
createWorld(this.objects);
|
||||
this.players = new PlayerContainer(
|
||||
this.objects,
|
||||
this.options.playerLimit,
|
||||
this.options.npcCount,
|
||||
);
|
||||
this.lastPhysicsBase = process.hrtime.bigint();
|
||||
this.bluePoints = 0;
|
||||
this.redPoints = 0;
|
||||
this.matchPointAnnounced = {};
|
||||
this.isInEndGame = false;
|
||||
this.timeScaling = 1;
|
||||
this.physicsAccumulator = 0;
|
||||
this.timeSinceLastServerStateUpdate = 0;
|
||||
this.timeSinceLastPointUpdate = 0;
|
||||
previousPlayers?.queueCommandForEachClient(new GameStartCommand());
|
||||
previousPlayers?.sendQueuedCommands();
|
||||
}
|
||||
|
||||
private handleJoin(socket: Socket, payload: unknown) {
|
||||
const playerInfo = asPlayerInformation(payload);
|
||||
if (!playerInfo) {
|
||||
socket.emit(TransportEvents.JoinRejected, JoinRejectionReason.InvalidRequest);
|
||||
return;
|
||||
}
|
||||
|
||||
if (this.joinedSockets.has(socket)) {
|
||||
socket.emit(TransportEvents.JoinRejected, JoinRejectionReason.AlreadyJoined);
|
||||
return;
|
||||
}
|
||||
|
||||
if (this.isInEndGame) {
|
||||
socket.emit(TransportEvents.JoinRejected, JoinRejectionReason.RoundEnding);
|
||||
return;
|
||||
}
|
||||
|
||||
const carried = this.retireGhost(playerInfo.reconnectToken);
|
||||
|
||||
if (this.players.isFull) {
|
||||
socket.emit(TransportEvents.JoinRejected, JoinRejectionReason.ServerFull);
|
||||
return;
|
||||
}
|
||||
|
||||
const player = this.players.createPlayer(playerInfo, socket, carried);
|
||||
|
||||
const onPlayerToServer = (json: unknown) => {
|
||||
try {
|
||||
if (typeof json !== 'string' || json.length > settings.maxInboundMessageBytes) {
|
||||
return;
|
||||
}
|
||||
if (!this.allowInboundMessage(socket)) {
|
||||
return;
|
||||
}
|
||||
const commands: Array<Command> = deserialize(json);
|
||||
if (!Array.isArray(commands)) {
|
||||
return;
|
||||
}
|
||||
commands.forEach((c) => player.handleCommand(c));
|
||||
} catch (e) {
|
||||
console.error('Error while processing command', e);
|
||||
}
|
||||
};
|
||||
|
||||
const onDisconnect = () => {
|
||||
this.removeJoined(socket);
|
||||
this.sendServerStateUpdate();
|
||||
};
|
||||
|
||||
socket.on(TransportEvents.PlayerToServer, onPlayerToServer);
|
||||
socket.on('disconnect', onDisconnect);
|
||||
this.joinedSockets.set(socket, {
|
||||
player,
|
||||
release: () => {
|
||||
socket.off(TransportEvents.PlayerToServer, onPlayerToServer);
|
||||
socket.off('disconnect', onDisconnect);
|
||||
player.detachFromSocket();
|
||||
},
|
||||
});
|
||||
|
||||
player.reconnectToken = randomUUID();
|
||||
socket.emit(TransportEvents.PlayerJoined, player.reconnectToken);
|
||||
|
||||
this.sendServerStateUpdate();
|
||||
}
|
||||
|
||||
private allowInboundMessage(socket: Socket): boolean {
|
||||
// performance.now(), not Date.now(): a backwards wall-clock step would lock the client out.
|
||||
const nowMs = performance.now();
|
||||
const burst = settings.maxInboundMessageBurst;
|
||||
const perSecond = settings.maxInboundMessagesPerSecond;
|
||||
|
||||
const budget = this.inboundBudget.get(socket) ?? { tokens: burst, lastMs: nowMs };
|
||||
budget.tokens = Math.min(
|
||||
burst,
|
||||
budget.tokens + (Math.max(0, nowMs - budget.lastMs) / 1000) * perSecond,
|
||||
);
|
||||
budget.lastMs = nowMs;
|
||||
this.inboundBudget.set(socket, budget);
|
||||
|
||||
if (budget.tokens < 1) {
|
||||
this.droppedInboundMessages++;
|
||||
return false;
|
||||
}
|
||||
|
||||
budget.tokens -= 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
private retireGhost(token?: string): CarriedScore | undefined {
|
||||
if (!token) {
|
||||
return undefined;
|
||||
}
|
||||
for (const [socket, { player }] of this.joinedSockets) {
|
||||
if (player.reconnectToken === token) {
|
||||
const carried = { team: player.team, ...player.score };
|
||||
this.removeJoined(socket);
|
||||
return carried;
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
private removeJoined(socket: Socket) {
|
||||
const joined = this.joinedSockets.get(socket);
|
||||
if (!joined) {
|
||||
return;
|
||||
}
|
||||
this.joinedSockets.delete(socket);
|
||||
this.inboundBudget.delete(socket);
|
||||
joined.release();
|
||||
joined.player.destroy();
|
||||
this.players.deletePlayer(joined.player);
|
||||
}
|
||||
|
||||
public sendServerStateUpdate() {
|
||||
this.io
|
||||
.to(gameStateSubscribedRoom)
|
||||
.emit(TransportEvents.ServerInfoUpdate, [this.players.count, this.gameProgress]);
|
||||
.emit(TransportEvents.ServerInfoUpdate, [
|
||||
this.players.count,
|
||||
this.serverInfo.gameStatePercent,
|
||||
]);
|
||||
}
|
||||
|
||||
public start() {
|
||||
this.handlePhysics();
|
||||
}
|
||||
|
||||
private addPoints({ blue, red }: GeneratePointsCommand) {
|
||||
public addPoints(blue: number, red: number) {
|
||||
if (this.isInEndGame) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -139,45 +261,60 @@ export class GameServer extends CommandReceiver {
|
|||
}
|
||||
}
|
||||
|
||||
public announce(text: string) {
|
||||
this.players.queueCommandForEachClient(new ServerAnnouncement(text));
|
||||
}
|
||||
|
||||
private announceMatchPointOnce(team: CharacterTeam, points: number) {
|
||||
if (
|
||||
!this.matchPointAnnounced[team] &&
|
||||
points >= this.options.scoreLimit * settings.matchPointScoreRatio
|
||||
) {
|
||||
this.matchPointAnnounced[team] = true;
|
||||
this.players.queueCommandForEachClient(
|
||||
new ServerAnnouncement(
|
||||
`Match point — team <span class="${team}">${team}</span>!`,
|
||||
),
|
||||
);
|
||||
this.announce(`Match point — team <span class="${team}">${team}</span>!`);
|
||||
}
|
||||
}
|
||||
|
||||
private endGame(winningTeam: CharacterTeam) {
|
||||
this.isInEndGame = true;
|
||||
const endTitleLength = 6;
|
||||
this.players.endGame(winningTeam);
|
||||
this.players.queueCommandForEachClient(
|
||||
new GameEndCommand(winningTeam, endTitleLength, true),
|
||||
);
|
||||
setTimeout(() => this.destroy(), endTitleLength * 1000 * 1.1);
|
||||
this.players.queueCommandForEachClient(new GameEndCommand());
|
||||
setTimeout(() => this.initialize(), endTitleSeconds * 1000 * 1.1);
|
||||
}
|
||||
|
||||
private destroy() {
|
||||
this.initialize();
|
||||
}
|
||||
private reportStats() {
|
||||
const mem = `${(process.memoryUsage().rss / 1024 / 1024).toFixed(2)} MB`;
|
||||
console.info(`Memory: ${mem}, Players: ${this.players.count}`);
|
||||
|
||||
private timeSinceLastPointUpdate = 0;
|
||||
private physicsAccumulator = 0;
|
||||
// Frames since the last stats report where physics ran over budget (more
|
||||
// substeps than the cap). Surfaced by handleStats as a saturation signal.
|
||||
private saturatedFrames = 0;
|
||||
const rtts = this.players.connectedPlayerRttsMs.filter((r) => r > 0);
|
||||
if (rtts.length > 0) {
|
||||
rtts.sort((a, b) => a - b);
|
||||
console.info(
|
||||
`RTT median ${rtts[Math.floor(rtts.length / 2)].toFixed(0)} ms ` +
|
||||
`(min ${rtts[0].toFixed(0)}, max ${rtts[rtts.length - 1].toFixed(0)}, n=${rtts.length})`,
|
||||
);
|
||||
}
|
||||
|
||||
if (this.droppedInboundMessages > 0) {
|
||||
console.warn(`Rate limited ${this.droppedInboundMessages} inbound msg(s)`);
|
||||
this.droppedInboundMessages = 0;
|
||||
}
|
||||
if (this.saturatedFrames > 0) {
|
||||
console.warn(`Physics saturated on ${this.saturatedFrames} frame(s)`);
|
||||
this.saturatedFrames = 0;
|
||||
}
|
||||
}
|
||||
|
||||
private handlePhysics() {
|
||||
const delta = this.deltaTimeCalculator.getNextDeltaTimeInSeconds({ setAsBase: true });
|
||||
this.deltaTimes.push(delta);
|
||||
const frameStart = process.hrtime.bigint();
|
||||
const frameStartMs = performance.now();
|
||||
const delta = Number(frameStart - this.lastPhysicsBase) / 1e9;
|
||||
this.lastPhysicsBase = frameStart;
|
||||
|
||||
this.handleStats();
|
||||
if (Date.now() - this.statReportMs > 30000) {
|
||||
this.statReportMs = Date.now();
|
||||
this.reportStats();
|
||||
}
|
||||
|
||||
if ((this.timeSinceLastServerStateUpdate += delta) > 4) {
|
||||
this.timeSinceLastServerStateUpdate = 0;
|
||||
|
|
@ -193,18 +330,11 @@ export class GameServer extends CommandReceiver {
|
|||
|
||||
const fixedDelta = settings.targetPhysicsDeltaTimeInSeconds;
|
||||
const maxSubstepsPerFrame = 5;
|
||||
// Cap on retained physics backlog when saturated, so a long stall can't
|
||||
// accumulate an unrecoverable catch-up.
|
||||
const maxBacklogSeconds = 0.25;
|
||||
|
||||
this.physicsAccumulator += delta;
|
||||
let substeps = Math.floor(this.physicsAccumulator / fixedDelta);
|
||||
if (substeps > maxSubstepsPerFrame) {
|
||||
// Saturated: run the cap's worth of substeps but KEEP the remaining
|
||||
// backlog (clamped) instead of zeroing it. Dropping it silently slowed
|
||||
// simulated time for everyone — and diverged client prediction, whose
|
||||
// wall-clock keeps running. Clamping bounds the catch-up so a transient
|
||||
// spike recovers without a death spiral.
|
||||
this.saturatedFrames++;
|
||||
this.physicsAccumulator = Math.min(
|
||||
this.physicsAccumulator - maxSubstepsPerFrame * fixedDelta,
|
||||
|
|
@ -221,69 +351,41 @@ export class GameServer extends CommandReceiver {
|
|||
this.timeScaling *= Math.pow(settings.endGameDeltaScaling, fixedDelta);
|
||||
scaledDelta /= this.timeScaling;
|
||||
}
|
||||
this.objects.handleCommand(new StepCommand(scaledDelta, this));
|
||||
this.objects.step(scaledDelta);
|
||||
this.players.step(scaledDelta);
|
||||
}
|
||||
|
||||
this.players.stepCommunication(delta);
|
||||
this.objects.resetRemoteCalls();
|
||||
// Physics has only advanced to the start of this frame less whatever is still in the
|
||||
// accumulator. Timing anything off the send time instead would put up to one physics step
|
||||
// of noise on every interpolated position and on the client's replay anchor.
|
||||
const simulatedThroughMs = frameStartMs - this.physicsAccumulator * 1000;
|
||||
|
||||
const physicsDelta = this.deltaTimeCalculator.getNextDeltaTimeInSeconds();
|
||||
|
||||
setTimeout(
|
||||
this.handlePhysics.bind(this),
|
||||
Math.max(0, fixedDelta - physicsDelta) * 1000,
|
||||
);
|
||||
}
|
||||
|
||||
private handleStats() {
|
||||
const framesBetweenDeltaTimeCalculation = 10000;
|
||||
|
||||
if (this.deltaTimes.length > framesBetweenDeltaTimeCalculation) {
|
||||
this.deltaTimes.sort((a, b) => a - b);
|
||||
console.info(
|
||||
`Median physics time: ${(
|
||||
this.deltaTimes[Math.floor(framesBetweenDeltaTimeCalculation / 2)] * 1000
|
||||
).toFixed(2)} ms`,
|
||||
if (substeps > 0) {
|
||||
const propertyUpdates = new Map<GameObject, PropertyUpdatesForObject | undefined>();
|
||||
this.players.stepCommunication(
|
||||
substeps * fixedDelta,
|
||||
simulatedThroughMs,
|
||||
(object) => {
|
||||
if (!propertyUpdates.has(object)) {
|
||||
propertyUpdates.set(object, object.getPropertyUpdates(1 / this.timeScaling));
|
||||
}
|
||||
return propertyUpdates.get(object);
|
||||
},
|
||||
);
|
||||
console.info(
|
||||
'Tail times: ',
|
||||
this.deltaTimes.slice(-20).map((v) => `${(v * 1000).toFixed(2)} ms`),
|
||||
);
|
||||
console.info(
|
||||
`Memory used: ${(process.memoryUsage().rss / 1024 / 1024).toFixed(2)} MB`,
|
||||
);
|
||||
|
||||
const rtts = this.players.connectedPlayerRttsMs.filter((r) => r > 0);
|
||||
if (rtts.length > 0) {
|
||||
rtts.sort((a, b) => a - b);
|
||||
console.info(
|
||||
`Player RTT median ${rtts[Math.floor(rtts.length / 2)].toFixed(0)} ms ` +
|
||||
`(min ${rtts[0].toFixed(0)}, max ${rtts[rtts.length - 1].toFixed(0)}, n=${rtts.length})`,
|
||||
);
|
||||
}
|
||||
|
||||
if (this.saturatedFrames > 0) {
|
||||
console.warn(
|
||||
`Physics saturated on ${this.saturatedFrames} frame(s) since last report — shedding backlog`,
|
||||
);
|
||||
this.saturatedFrames = 0;
|
||||
}
|
||||
|
||||
this.deltaTimes = [];
|
||||
this.objects.resetRemoteCalls();
|
||||
}
|
||||
}
|
||||
|
||||
private get gameProgress(): number {
|
||||
return (Math.max(this.bluePoints, this.redPoints) / this.options.scoreLimit) * 100;
|
||||
const elapsed = Number(process.hrtime.bigint() - frameStart) / 1e9;
|
||||
setTimeout(() => this.handlePhysics(), Math.max(0, fixedDelta - elapsed) * 1000);
|
||||
}
|
||||
|
||||
public get serverInfo(): ServerInformation {
|
||||
return {
|
||||
serverName: this.serverName,
|
||||
serverName: this.options.name,
|
||||
playerCount: this.players.count,
|
||||
playerLimit: this.playerLimit,
|
||||
gameStatePercent: this.gameProgress,
|
||||
playerLimit: this.options.playerLimit,
|
||||
gameStatePercent:
|
||||
(Math.max(this.bluePoints, this.redPoints) / this.options.scoreLimit) * 100,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,13 +0,0 @@
|
|||
export class DeltaTimeCalculator {
|
||||
private previousTime: [number, number] = process.hrtime();
|
||||
|
||||
public getNextDeltaTimeInSeconds(
|
||||
{ setAsBase = false }: { setAsBase: boolean } = { setAsBase: false },
|
||||
): number {
|
||||
const [seconds, nanoSeconds] = process.hrtime(this.previousTime);
|
||||
if (setAsBase) {
|
||||
this.previousTime = process.hrtime();
|
||||
}
|
||||
return seconds + nanoSeconds / 1e9;
|
||||
}
|
||||
}
|
||||
|
|
@ -2,15 +2,14 @@ import { Server as IoServer } from 'socket.io';
|
|||
import express from 'express';
|
||||
import { Server } from 'http';
|
||||
import cors from 'cors';
|
||||
import { applyArrayPlugins, Random, serverInformationEndpoint } from 'shared';
|
||||
import { Random, serverInformationEndpoint, settings } from 'shared';
|
||||
import minimist from 'minimist';
|
||||
import { glMatrix } from 'gl-matrix';
|
||||
import { GameServer } from './game-server';
|
||||
import { defaultOptions } from './default-options';
|
||||
import { defaultOptions } from './options';
|
||||
import parser from 'socket.io-msgpack-parser';
|
||||
|
||||
glMatrix.setMatrixArrayType(Array);
|
||||
applyArrayPlugins();
|
||||
|
||||
const optionOverrides = minimist(process.argv.slice(2));
|
||||
const options = {
|
||||
|
|
@ -24,6 +23,7 @@ const app = express();
|
|||
const server = new Server(app);
|
||||
const io = new IoServer(server, {
|
||||
parser,
|
||||
maxHttpBufferSize: settings.maxInboundMessageBytes,
|
||||
cors: {
|
||||
origin: true,
|
||||
credentials: true,
|
||||
|
|
@ -32,14 +32,7 @@ const io = new IoServer(server, {
|
|||
|
||||
const gameServer = new GameServer(io, options);
|
||||
|
||||
app.use(
|
||||
cors({
|
||||
origin: (_, callback) => {
|
||||
callback(null, true);
|
||||
},
|
||||
credentials: true,
|
||||
}),
|
||||
);
|
||||
app.use(cors({ origin: true, credentials: true }));
|
||||
|
||||
app.get(serverInformationEndpoint, (_, res) => {
|
||||
res.json(gameServer.serverInfo);
|
||||
|
|
|
|||
|
|
@ -2,22 +2,23 @@ import { vec2 } from 'gl-matrix';
|
|||
import {
|
||||
id,
|
||||
settings,
|
||||
MoveActionCommand,
|
||||
serializesTo,
|
||||
last,
|
||||
Circle,
|
||||
CharacterBase,
|
||||
CharacterTeam,
|
||||
PropertyUpdatesForObject,
|
||||
UpdatePropertyCommand,
|
||||
CommandExecutors,
|
||||
CommandReceiver,
|
||||
CharacterMovementSnapshot,
|
||||
GameObject,
|
||||
mix,
|
||||
clamp01,
|
||||
strengthToCharge,
|
||||
stepCharacterMovement,
|
||||
applyForce,
|
||||
applyLeapImpulse,
|
||||
decayMomentum,
|
||||
CharacterMovementState,
|
||||
tickPlanetDetachment,
|
||||
characterCenter,
|
||||
sumGravity,
|
||||
CharacterWorld,
|
||||
GroundSurface,
|
||||
headRadius,
|
||||
|
|
@ -27,69 +28,45 @@ import {
|
|||
rightFootOffset,
|
||||
boundRadius,
|
||||
} from 'shared';
|
||||
import { DynamicPhysical } from '../physics/physicals/dynamic-physical';
|
||||
import { addPointsForTeam } from '../game-events';
|
||||
import { Physical } from '../physics/physical';
|
||||
import { CirclePhysical } from './circle-physical';
|
||||
import { PhysicalContainer } from '../physics/containers/physical-container';
|
||||
import { BoundingBoxBase } from '../physics/bounding-boxes/bounding-box-base';
|
||||
import { PhysicalContainer } from '../physics/physical-container';
|
||||
import { BoundingBox } from '../physics/bounding-box';
|
||||
import { ProjectilePhysical } from './projectile-physical';
|
||||
import { forceAtPosition } from '../physics/functions/force-at-position';
|
||||
import { getBoundingBoxOfCircle } from '../physics/functions/get-bounding-box-of-circle';
|
||||
import { PlanetPhysical } from './planet-physical';
|
||||
import { StepCommand } from '../commands/step';
|
||||
import { ReactToCollisionCommand } from '../commands/react-to-collision';
|
||||
import { GeneratePointsCommand } from '../commands/generate-points';
|
||||
import { PlanetPhysical, planetsNear } from './planet-physical';
|
||||
|
||||
@serializesTo(CharacterBase)
|
||||
export class CharacterPhysical extends CharacterBase implements DynamicPhysical {
|
||||
const placeholder = new Circle(vec2.create(), 0);
|
||||
|
||||
export class CharacterPhysical extends CharacterBase implements Physical {
|
||||
public readonly canCollide = true;
|
||||
public readonly canMove = true;
|
||||
|
||||
private projectileStrength = settings.playerMaxStrength;
|
||||
|
||||
// Body geometry (head/foot radii, posture offsets, bound radius) is defined
|
||||
// once in the shared movement module and imported here, so the authoritative
|
||||
// body and the client's predicted body are bit-identical by construction
|
||||
// instead of by a hand-synced "copied verbatim" duplicate. Re-exposed as a
|
||||
// static only because external callers reference CharacterPhysical.boundRadius.
|
||||
public static readonly boundRadius = boundRadius;
|
||||
|
||||
private timeSinceDying = 0;
|
||||
private isDestroyed = false;
|
||||
private timeSinceBorn = 0;
|
||||
private hasJustBorn = true;
|
||||
private timeAlive = 0;
|
||||
|
||||
private timeSinceLastShot = settings.projectileCreationInterval;
|
||||
private timeSinceLastDamage = settings.playerOutOfCombatDelaySeconds;
|
||||
private lastSyncedHealth = settings.playerMaxHealth;
|
||||
|
||||
private killStreak = 0;
|
||||
|
||||
private direction = 0;
|
||||
private currentPlanet?: PlanetPhysical;
|
||||
private secondsSinceOnSurface = settings.planetDetachmentSeconds;
|
||||
|
||||
private bodyVelocity = vec2.create();
|
||||
private timeSinceLastLeap = settings.leapCooldownSeconds;
|
||||
|
||||
public head: CirclePhysical;
|
||||
public leftFoot: CirclePhysical;
|
||||
public rightFoot: CirclePhysical;
|
||||
|
||||
private movementState!: CharacterMovementState;
|
||||
private movementWorld!: CharacterWorld;
|
||||
public direction = 0;
|
||||
public currentPlanet: GroundSurface | undefined;
|
||||
public secondsSinceOnSurface = settings.planetDetachmentSeconds;
|
||||
public readonly bodyVelocity = vec2.create();
|
||||
|
||||
private movementActions: Array<MoveActionCommand> = [];
|
||||
private lastMovementAction: MoveActionCommand = new MoveActionCommand(vec2.create());
|
||||
private projectileStrength = settings.playerMaxStrength;
|
||||
private timeAlive = 0;
|
||||
private timeSinceDying = 0;
|
||||
private isDestroyed = false;
|
||||
private hasJustBorn = true;
|
||||
private hasFiredSinceSpawn = false;
|
||||
private timeSinceLastShot = settings.projectileCreationInterval;
|
||||
private timeSinceLastLeap = settings.leapCooldownSeconds;
|
||||
private timeSinceLastDamage = settings.playerOutOfCombatDelaySeconds;
|
||||
private lastSyncedHealth = settings.playerMaxHealth;
|
||||
private killStreak = 0;
|
||||
|
||||
private headVelocity = new Circle(vec2.create(), 0);
|
||||
private leftFootVelocity = new Circle(vec2.create(), 0);
|
||||
private rightFootVelocity = new Circle(vec2.create(), 0);
|
||||
private readonly movementDirection = vec2.create();
|
||||
|
||||
protected commandExecutors: CommandExecutors = {
|
||||
[StepCommand.type]: this.step.bind(this),
|
||||
[ReactToCollisionCommand.type]: this.onCollision.bind(this),
|
||||
};
|
||||
private readonly previousPose = [0, 1, 2].map(() => new Circle(vec2.create(), 0));
|
||||
private readonly velocities = [0, 1, 2].map(() => new Circle(vec2.create(), 0));
|
||||
private readonly box = new BoundingBox();
|
||||
|
||||
constructor(
|
||||
name: string,
|
||||
|
|
@ -99,112 +76,93 @@ export class CharacterPhysical extends CharacterBase implements DynamicPhysical
|
|||
private readonly container: PhysicalContainer,
|
||||
startPosition: vec2,
|
||||
) {
|
||||
super(id(), name, killCount, deathCount, team, settings.playerMaxHealth);
|
||||
this.head = new CirclePhysical(
|
||||
vec2.add(vec2.create(), startPosition, headOffset),
|
||||
headRadius,
|
||||
this,
|
||||
container,
|
||||
super(
|
||||
id(),
|
||||
name,
|
||||
killCount,
|
||||
deathCount,
|
||||
team,
|
||||
settings.playerMaxHealth,
|
||||
placeholder,
|
||||
placeholder,
|
||||
placeholder,
|
||||
);
|
||||
this.leftFoot = new CirclePhysical(
|
||||
vec2.add(vec2.create(), startPosition, leftFootOffset),
|
||||
feetRadius,
|
||||
this,
|
||||
container,
|
||||
);
|
||||
this.rightFoot = new CirclePhysical(
|
||||
vec2.add(vec2.create(), startPosition, rightFootOffset),
|
||||
feetRadius,
|
||||
this,
|
||||
container,
|
||||
);
|
||||
container.addObject(this.head);
|
||||
container.addObject(this.leftFoot);
|
||||
container.addObject(this.rightFoot);
|
||||
|
||||
this.initMovementBridge();
|
||||
const part = (offset: vec2, radius: number) =>
|
||||
new CirclePhysical(
|
||||
vec2.add(vec2.create(), startPosition, offset),
|
||||
radius,
|
||||
this,
|
||||
container,
|
||||
);
|
||||
this.head = part(headOffset, headRadius);
|
||||
this.leftFoot = part(leftFootOffset, feetRadius);
|
||||
this.rightFoot = part(rightFootOffset, feetRadius);
|
||||
}
|
||||
|
||||
private initMovementBridge() {
|
||||
// The movementState object-literal getters/setters below can't use `this`
|
||||
// (it would bind to the literal), so alias the character instance.
|
||||
// eslint-disable-next-line @typescript-eslint/no-this-alias
|
||||
const self = this;
|
||||
this.movementState = {
|
||||
head: this.head,
|
||||
leftFoot: this.leftFoot,
|
||||
rightFoot: this.rightFoot,
|
||||
get direction() {
|
||||
return self.direction;
|
||||
},
|
||||
set direction(value: number) {
|
||||
self.direction = value;
|
||||
},
|
||||
get currentPlanet() {
|
||||
return self.currentPlanet;
|
||||
},
|
||||
set currentPlanet(value: GroundSurface | undefined) {
|
||||
// On the server every ground is a PlanetPhysical (the world only ever
|
||||
// hands back planets), so this narrowing is safe.
|
||||
self.currentPlanet = value as PlanetPhysical | undefined;
|
||||
},
|
||||
get secondsSinceOnSurface() {
|
||||
return self.secondsSinceOnSurface;
|
||||
},
|
||||
set secondsSinceOnSurface(value: number) {
|
||||
self.secondsSinceOnSurface = value;
|
||||
},
|
||||
bodyVelocity: this.bodyVelocity,
|
||||
};
|
||||
private readonly movementWorld: CharacterWorld = {
|
||||
groundsNear: (center, radius) => planetsNear(this.container, center, radius),
|
||||
stepBody: (body, deltaTimeInSeconds) => {
|
||||
const hit = (body as CirclePhysical).stepManually(deltaTimeInSeconds);
|
||||
return hit instanceof PlanetPhysical ? hit : undefined;
|
||||
},
|
||||
};
|
||||
|
||||
this.movementWorld = {
|
||||
// Same set and order forceAtPosition used: planets in the force field,
|
||||
// in container-traversal order (so the f64 gravity sum is unchanged).
|
||||
groundsNear: (center, radius) =>
|
||||
self.container
|
||||
.findIntersecting(getBoundingBoxOfCircle(new Circle(center, radius)))
|
||||
.filter((o): o is PlanetPhysical => o instanceof PlanetPhysical),
|
||||
stepBody: (body, deltaTimeInSeconds) => {
|
||||
const { hitObject } = (body as CirclePhysical).stepManually(deltaTimeInSeconds);
|
||||
return hitObject instanceof PlanetPhysical ? hitObject : undefined;
|
||||
},
|
||||
};
|
||||
private get parts(): Array<CirclePhysical> {
|
||||
return [this.head, this.leftFoot, this.rightFoot];
|
||||
}
|
||||
|
||||
private get isSpawnProtected(): boolean {
|
||||
return (
|
||||
!this.hasFiredSinceSpawn &&
|
||||
this.timeAlive <
|
||||
settings.spawnDespawnTime + settings.spawnInvulnerabilityExtraSeconds
|
||||
settings.spawnDespawnTime + settings.spawnInvulnerabilityExtraSeconds
|
||||
);
|
||||
}
|
||||
|
||||
private hasGeneratedPoints = false;
|
||||
private getPoints(game: CommandReceiver) {
|
||||
if (!this.isAlive && !this.hasGeneratedPoints) {
|
||||
this.hasGeneratedPoints = true;
|
||||
const blue = this.team === CharacterTeam.blue ? 0 : settings.playerKillPoint;
|
||||
const red = this.team === CharacterTeam.red ? 0 : settings.playerKillPoint;
|
||||
|
||||
game.handleCommand(new GeneratePointsCommand(blue, red));
|
||||
}
|
||||
}
|
||||
|
||||
public get isAlive(): boolean {
|
||||
return !this.isDestroyed;
|
||||
}
|
||||
|
||||
public handleMovementAction(c: MoveActionCommand) {
|
||||
this.movementActions.push(c);
|
||||
}
|
||||
|
||||
public get groundPlanet(): PlanetPhysical | undefined {
|
||||
return this.currentPlanet;
|
||||
return this.currentPlanet as PlanetPhysical | undefined;
|
||||
}
|
||||
|
||||
// Persistent launch momentum, streamed to the owning client so its predictor
|
||||
// can reproduce a leap/slingshot/recoil flight instead of only snapping to it.
|
||||
public get launchMomentum(): vec2 {
|
||||
return this.bodyVelocity;
|
||||
public get movementSnapshot(): CharacterMovementSnapshot {
|
||||
return new CharacterMovementSnapshot(
|
||||
this.direction,
|
||||
vec2.clone(this.bodyVelocity),
|
||||
vec2.clone(this.leftFoot.lastNormal),
|
||||
vec2.clone(this.rightFoot.lastNormal),
|
||||
this.groundPlanet?.id ?? null,
|
||||
this.secondsSinceOnSurface,
|
||||
Math.max(0, settings.leapCooldownSeconds - this.timeSinceLastLeap),
|
||||
);
|
||||
}
|
||||
|
||||
public get boundingBox(): BoundingBox {
|
||||
return this.box.setCircle(this.center, boundRadius);
|
||||
}
|
||||
|
||||
public get gameObject(): this {
|
||||
return this;
|
||||
}
|
||||
|
||||
public get center(): vec2 {
|
||||
return characterCenter(this.head, this.leftFoot, this.rightFoot);
|
||||
}
|
||||
|
||||
public distance(target: vec2): number {
|
||||
return (
|
||||
Math.min(
|
||||
this.head.distance(target),
|
||||
this.leftFoot.distance(target),
|
||||
this.rightFoot.distance(target),
|
||||
) - 5
|
||||
);
|
||||
}
|
||||
|
||||
public setMoveDirection(direction: vec2) {
|
||||
vec2.normalize(this.movementDirection, direction);
|
||||
}
|
||||
|
||||
public addKill(victimName: string, charge = 0) {
|
||||
|
|
@ -212,11 +170,13 @@ export class CharacterPhysical extends CharacterBase implements DynamicPhysical
|
|||
this.killStreak++;
|
||||
this.remoteCall('setKillCount', this.killCount);
|
||||
|
||||
this.health = Math.min(
|
||||
settings.playerMaxHealth,
|
||||
this.health + settings.playerKillHealthReward,
|
||||
);
|
||||
this.syncHealth();
|
||||
if (this.isAlive) {
|
||||
this.health = Math.min(
|
||||
settings.playerMaxHealth,
|
||||
this.health + settings.playerKillHealthReward,
|
||||
);
|
||||
this.syncHealth();
|
||||
}
|
||||
this.remoteCall('onKillConfirmed', victimName, this.killStreak, charge);
|
||||
}
|
||||
|
||||
|
|
@ -232,39 +192,38 @@ export class CharacterPhysical extends CharacterBase implements DynamicPhysical
|
|||
}
|
||||
}
|
||||
|
||||
public onCollision({ other }: ReactToCollisionCommand) {
|
||||
public onCollision(other: GameObject) {
|
||||
if (
|
||||
// A corpse keeps its collidable circles for the despawn animation; the
|
||||
// isAlive guard stops a flying corpse from eating shots aimed past it.
|
||||
this.isAlive &&
|
||||
other instanceof ProjectilePhysical &&
|
||||
other.team !== this.team &&
|
||||
other.isAlive
|
||||
!this.isAlive ||
|
||||
!(other instanceof ProjectilePhysical) ||
|
||||
other.team === this.team ||
|
||||
!other.isAlive
|
||||
) {
|
||||
other.destroy();
|
||||
return;
|
||||
}
|
||||
|
||||
if (this.isSpawnProtected) {
|
||||
return;
|
||||
}
|
||||
other.destroy();
|
||||
|
||||
this.timeSinceLastDamage = 0;
|
||||
this.health -= other.strength;
|
||||
this.lastSyncedHealth = Math.round(this.health);
|
||||
this.remoteCall('setHealth', this.health);
|
||||
if (this.isSpawnProtected) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (this.health <= 0 && this.isAlive) {
|
||||
// Throw the corpse along the killing shot, harder for charged hits.
|
||||
vec2.scaleAndAdd(
|
||||
this.bodyVelocity,
|
||||
this.bodyVelocity,
|
||||
other.direction,
|
||||
mix(settings.deathImpulseMin, settings.deathImpulseMax, other.charge),
|
||||
);
|
||||
this.onDie();
|
||||
other.originator.addKill(this.name, other.charge);
|
||||
} else {
|
||||
other.originator.registerHit(other.charge);
|
||||
}
|
||||
this.timeSinceLastDamage = 0;
|
||||
this.health -= other.strength;
|
||||
this.lastSyncedHealth = Math.round(this.health);
|
||||
this.remoteCall('setHealth', this.health);
|
||||
|
||||
if (this.health <= 0) {
|
||||
vec2.scaleAndAdd(
|
||||
this.bodyVelocity,
|
||||
this.bodyVelocity,
|
||||
other.direction,
|
||||
mix(settings.deathImpulseMin, settings.deathImpulseMax, other.charge),
|
||||
);
|
||||
this.onDie(true);
|
||||
other.originator.addKill(this.name, other.charge);
|
||||
} else {
|
||||
other.originator.registerHit(other.charge);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -277,42 +236,45 @@ export class CharacterPhysical extends CharacterBase implements DynamicPhysical
|
|||
return;
|
||||
}
|
||||
|
||||
const direction = vec2.subtract(vec2.create(), position, this.center);
|
||||
if (vec2.length(direction) === 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.timeSinceLastShot = 0;
|
||||
this.hasFiredSinceSpawn = true;
|
||||
|
||||
const c = clamp01(charge);
|
||||
const desiredStrength = mix(
|
||||
settings.chargeShotStrengthMin,
|
||||
settings.chargeShotStrengthMax,
|
||||
c,
|
||||
clamp01(charge),
|
||||
);
|
||||
const strength = Math.min(desiredStrength, this.projectileStrength);
|
||||
this.projectileStrength -= strength;
|
||||
|
||||
const c = strengthToCharge(strength);
|
||||
const radius = mix(settings.chargeShotRadiusMin, settings.chargeShotRadiusMax, c);
|
||||
const speed = mix(settings.chargeShotSpeedMin, settings.chargeShotSpeedMax, c);
|
||||
|
||||
const direction = vec2.subtract(vec2.create(), position, this.center);
|
||||
vec2.normalize(direction, direction);
|
||||
// Keep the unit direction before vec2.scale repurposes it as the velocity.
|
||||
const shotDirection = vec2.clone(direction);
|
||||
const velocity = vec2.scale(direction, direction, speed);
|
||||
const projectile = new ProjectilePhysical(
|
||||
vec2.clone(this.center),
|
||||
radius,
|
||||
strength,
|
||||
this.team,
|
||||
velocity,
|
||||
this,
|
||||
this.container,
|
||||
c,
|
||||
this.container.addObject(
|
||||
new ProjectilePhysical(
|
||||
vec2.clone(this.center),
|
||||
radius,
|
||||
strength,
|
||||
this.team,
|
||||
vec2.scale(vec2.create(), direction, speed),
|
||||
this,
|
||||
this.container,
|
||||
c,
|
||||
),
|
||||
);
|
||||
this.container.addObject(projectile);
|
||||
|
||||
if (c > 0) {
|
||||
vec2.scaleAndAdd(
|
||||
this.bodyVelocity,
|
||||
this.bodyVelocity,
|
||||
shotDirection,
|
||||
direction,
|
||||
-settings.chargeShotRecoilMax * c,
|
||||
);
|
||||
}
|
||||
|
|
@ -333,210 +295,89 @@ export class CharacterPhysical extends CharacterBase implements DynamicPhysical
|
|||
|
||||
this.timeSinceLastLeap = 0;
|
||||
this.projectileStrength -= settings.leapStrengthCost;
|
||||
|
||||
// Same impulse the client predicts with (shared), so a leap launches
|
||||
// identically on both sides.
|
||||
applyLeapImpulse(this.movementState, this.lastMovementAction.direction);
|
||||
applyLeapImpulse(this, this.movementDirection);
|
||||
this.remoteCall('onLeap');
|
||||
}
|
||||
|
||||
public get boundingBox(): BoundingBoxBase {
|
||||
return getBoundingBoxOfCircle(new Circle(this.center, CharacterPhysical.boundRadius));
|
||||
}
|
||||
|
||||
public get gameObject(): this {
|
||||
return this;
|
||||
}
|
||||
|
||||
public get center(): vec2 {
|
||||
const bodyCenter = vec2.add(vec2.create(), this.head.center, this.leftFoot.center);
|
||||
vec2.add(bodyCenter, bodyCenter, this.rightFoot.center);
|
||||
return vec2.scale(bodyCenter, bodyCenter, 1 / 3);
|
||||
}
|
||||
|
||||
public distance(target: vec2): number {
|
||||
return (
|
||||
Math.min(
|
||||
this.head.distance(target),
|
||||
this.leftFoot.distance(target),
|
||||
this.rightFoot.distance(target),
|
||||
) - 5
|
||||
);
|
||||
}
|
||||
|
||||
private averageAndResetMovementActions(): vec2 {
|
||||
let direction: vec2;
|
||||
if (this.movementActions.length === 0) {
|
||||
direction = vec2.clone(this.lastMovementAction.direction);
|
||||
} else {
|
||||
direction = this.movementActions.reduce(
|
||||
(sum, current) => vec2.add(sum, sum, current.direction),
|
||||
vec2.create(),
|
||||
);
|
||||
|
||||
vec2.scale(direction, direction, 1 / this.movementActions.length);
|
||||
|
||||
this.lastMovementAction = last(this.movementActions)!;
|
||||
this.movementActions = [];
|
||||
public onDie(killedInCombat = false) {
|
||||
if (this.isDestroyed) {
|
||||
return;
|
||||
}
|
||||
this.isDestroyed = true;
|
||||
this.remoteCall('onDie');
|
||||
|
||||
return vec2.length(direction) > 0
|
||||
? vec2.normalize(direction, direction)
|
||||
: vec2.create();
|
||||
if (killedInCombat) {
|
||||
const opposingTeam =
|
||||
this.team === CharacterTeam.blue ? CharacterTeam.red : CharacterTeam.blue;
|
||||
addPointsForTeam(this.container.game, opposingTeam, settings.playerKillPoint);
|
||||
}
|
||||
}
|
||||
|
||||
private animateScaling(q: number) {
|
||||
this.head.radius = headRadius * q;
|
||||
this.leftFoot.radius = this.rightFoot.radius = feetRadius * q;
|
||||
}
|
||||
|
||||
public getPropertyUpdates(): PropertyUpdatesForObject {
|
||||
public getPropertyUpdates(timeScale = 1): PropertyUpdatesForObject {
|
||||
const [headVelocity, leftFootVelocity, rightFootVelocity] = this.velocities.map(
|
||||
(velocity) =>
|
||||
new Circle(
|
||||
vec2.scale(vec2.create(), velocity.center, timeScale),
|
||||
velocity.radius * timeScale,
|
||||
),
|
||||
);
|
||||
return new PropertyUpdatesForObject(this.id, [
|
||||
new UpdatePropertyCommand('head', this.head, this.headVelocity),
|
||||
new UpdatePropertyCommand('leftFoot', this.leftFoot, this.leftFootVelocity),
|
||||
new UpdatePropertyCommand('rightFoot', this.rightFoot, this.rightFootVelocity),
|
||||
new UpdatePropertyCommand('head', this.head, headVelocity),
|
||||
new UpdatePropertyCommand('leftFoot', this.leftFoot, leftFootVelocity),
|
||||
new UpdatePropertyCommand('rightFoot', this.rightFoot, rightFootVelocity),
|
||||
new UpdatePropertyCommand(
|
||||
'strength',
|
||||
this.projectileStrength,
|
||||
settings.playerStrengthRegenerationPerSeconds,
|
||||
settings.playerStrengthRegenerationPerSeconds * timeScale,
|
||||
),
|
||||
]);
|
||||
}
|
||||
|
||||
private setPropertyUpdates(
|
||||
oldHead: Circle,
|
||||
oldLeftFoot: Circle,
|
||||
oldRightFoot: Circle,
|
||||
deltaTime: number,
|
||||
) {
|
||||
this.headVelocity = new Circle(
|
||||
vec2.scale(
|
||||
oldHead.center,
|
||||
vec2.subtract(oldHead.center, this.head.center, oldHead.center),
|
||||
1 / deltaTime,
|
||||
),
|
||||
(this.head.radius - oldHead.radius) / deltaTime,
|
||||
);
|
||||
|
||||
this.leftFootVelocity = new Circle(
|
||||
vec2.scale(
|
||||
oldLeftFoot.center,
|
||||
vec2.subtract(oldLeftFoot.center, this.leftFoot.center, oldLeftFoot.center),
|
||||
1 / deltaTime,
|
||||
),
|
||||
(this.leftFoot.radius - oldLeftFoot.radius) / deltaTime,
|
||||
);
|
||||
|
||||
this.rightFootVelocity = new Circle(
|
||||
vec2.scale(
|
||||
oldRightFoot.center,
|
||||
vec2.subtract(oldRightFoot.center, this.rightFoot.center, oldRightFoot.center),
|
||||
1 / deltaTime,
|
||||
),
|
||||
(this.rightFoot.radius - oldRightFoot.radius) / deltaTime,
|
||||
);
|
||||
|
||||
this.animateScaling(1);
|
||||
}
|
||||
|
||||
private step({ deltaTimeInSeconds, game }: StepCommand) {
|
||||
this.getPoints(game);
|
||||
public step(deltaTimeInSeconds: number) {
|
||||
this.timeAlive += deltaTimeInSeconds;
|
||||
this.timeSinceLastLeap += deltaTimeInSeconds;
|
||||
const oldHead = new Circle(vec2.clone(this.head.center), this.head.radius);
|
||||
const oldLeftFoot = new Circle(
|
||||
vec2.clone(this.leftFoot.center),
|
||||
this.leftFoot.radius,
|
||||
);
|
||||
const oldRightFoot = new Circle(
|
||||
vec2.clone(this.rightFoot.center),
|
||||
this.rightFoot.radius,
|
||||
);
|
||||
this.parts.forEach((part, i) => {
|
||||
vec2.copy(this.previousPose[i].center, part.center);
|
||||
this.previousPose[i].radius = part.radius;
|
||||
});
|
||||
|
||||
if (this.isDestroyed) {
|
||||
if ((this.timeSinceDying += deltaTimeInSeconds) > settings.spawnDespawnTime) {
|
||||
this.destroy();
|
||||
this.container.removeObject(this);
|
||||
} else {
|
||||
this.freeFallCorpse(deltaTimeInSeconds);
|
||||
this.animateScaling(1 - this.timeSinceDying / settings.spawnDespawnTime);
|
||||
}
|
||||
this.setPropertyUpdates(oldHead, oldLeftFoot, oldRightFoot, deltaTimeInSeconds);
|
||||
return;
|
||||
}
|
||||
|
||||
if (this.hasJustBorn) {
|
||||
if ((this.timeSinceBorn += deltaTimeInSeconds) > settings.spawnDespawnTime) {
|
||||
} else if (this.hasJustBorn) {
|
||||
if (this.timeAlive > settings.spawnDespawnTime) {
|
||||
this.hasJustBorn = false;
|
||||
this.animateScaling(1);
|
||||
} else {
|
||||
this.animateScaling(this.timeSinceBorn / settings.spawnDespawnTime);
|
||||
this.animateScaling(this.timeAlive / settings.spawnDespawnTime);
|
||||
}
|
||||
this.setPropertyUpdates(oldHead, oldLeftFoot, oldRightFoot, deltaTimeInSeconds);
|
||||
return;
|
||||
} else {
|
||||
this.stepAlive(deltaTimeInSeconds);
|
||||
}
|
||||
|
||||
if (
|
||||
(this.secondsSinceOnSurface += deltaTimeInSeconds) >
|
||||
settings.planetDetachmentSeconds
|
||||
) {
|
||||
this.currentPlanet = undefined;
|
||||
}
|
||||
this.parts.forEach((part, i) => {
|
||||
const velocity = this.velocities[i];
|
||||
const previous = this.previousPose[i];
|
||||
vec2.subtract(velocity.center, part.center, previous.center);
|
||||
vec2.scale(velocity.center, velocity.center, 1 / deltaTimeInSeconds);
|
||||
velocity.radius = (part.radius - previous.radius) / deltaTimeInSeconds;
|
||||
});
|
||||
}
|
||||
|
||||
private stepAlive(deltaTimeInSeconds: number) {
|
||||
tickPlanetDetachment(this, deltaTimeInSeconds);
|
||||
|
||||
this.timeSinceLastShot += deltaTimeInSeconds;
|
||||
|
||||
this.projectileStrength = Math.min(
|
||||
settings.playerMaxStrength,
|
||||
this.projectileStrength +
|
||||
settings.playerStrengthRegenerationPerSeconds * deltaTimeInSeconds,
|
||||
);
|
||||
|
||||
this.regenerateHealth(deltaTimeInSeconds);
|
||||
|
||||
// The planet tallies who is standing on it and resolves capture itself, so
|
||||
// a contested rock can freeze instead of two squads silently cancelling.
|
||||
this.currentPlanet?.registerPresence(this);
|
||||
|
||||
// The whole walking model — gravity gather, movement force, on/off-planet
|
||||
// branch, posture springs, body-momentum, and stepping the three parts —
|
||||
// is the shared simulation the client predicts with, so the two can never
|
||||
// drift. Server-only concerns (scoring, health, shooting, spawn/death,
|
||||
// ownership) stay here around it.
|
||||
const direction = this.averageAndResetMovementActions();
|
||||
stepCharacterMovement(
|
||||
this.movementState,
|
||||
this.movementWorld,
|
||||
direction,
|
||||
deltaTimeInSeconds,
|
||||
);
|
||||
|
||||
this.setPropertyUpdates(oldHead, oldLeftFoot, oldRightFoot, deltaTimeInSeconds);
|
||||
}
|
||||
|
||||
private freeFallCorpse(deltaTime: number) {
|
||||
const intersecting = this.container.findIntersecting(
|
||||
getBoundingBoxOfCircle(
|
||||
new Circle(
|
||||
this.center,
|
||||
CharacterPhysical.boundRadius + settings.maxGravityDistance,
|
||||
),
|
||||
),
|
||||
);
|
||||
let grounded = false;
|
||||
for (const part of [this.leftFoot, this.rightFoot, this.head]) {
|
||||
part.applyForce(forceAtPosition(part.center, intersecting), deltaTime);
|
||||
vec2.add(part.velocity, part.velocity, this.bodyVelocity);
|
||||
const { hitObject } = part.stepManually(deltaTime);
|
||||
if (hitObject instanceof PlanetPhysical) {
|
||||
grounded = true;
|
||||
}
|
||||
}
|
||||
// Brake with the exact shared model the living body uses: stiff on contact
|
||||
// so the corpse skids to rest, gentle in the air, plus the constant stop and
|
||||
// the speed cap — so a flung corpse comes to a definite stop instead of
|
||||
// sliding forever.
|
||||
decayMomentum(this.bodyVelocity, grounded, deltaTime);
|
||||
}
|
||||
|
||||
private regenerateHealth(deltaTimeInSeconds: number) {
|
||||
this.timeSinceLastDamage += deltaTimeInSeconds;
|
||||
if (
|
||||
this.timeSinceLastDamage > settings.playerOutOfCombatDelaySeconds &&
|
||||
|
|
@ -548,17 +389,35 @@ export class CharacterPhysical extends CharacterBase implements DynamicPhysical
|
|||
);
|
||||
this.syncHealth();
|
||||
}
|
||||
|
||||
this.groundPlanet?.registerPresence(this);
|
||||
|
||||
stepCharacterMovement(
|
||||
this,
|
||||
this.movementWorld,
|
||||
this.movementDirection,
|
||||
deltaTimeInSeconds,
|
||||
);
|
||||
}
|
||||
|
||||
public onDie() {
|
||||
this.isDestroyed = true;
|
||||
this.remoteCall('onDie');
|
||||
private animateScaling(q: number) {
|
||||
this.head.radius = headRadius * q;
|
||||
this.leftFoot.radius = this.rightFoot.radius = feetRadius * q;
|
||||
}
|
||||
|
||||
private destroy() {
|
||||
this.container.removeObject(this);
|
||||
this.container.removeObject(this.head);
|
||||
this.container.removeObject(this.leftFoot);
|
||||
this.container.removeObject(this.rightFoot);
|
||||
private freeFallCorpse(deltaTime: number) {
|
||||
const planets = this.movementWorld.groundsNear(
|
||||
this.center,
|
||||
boundRadius + settings.maxGravityDistance,
|
||||
);
|
||||
let grounded = false;
|
||||
for (const part of this.parts) {
|
||||
vec2.copy(part.velocity, this.bodyVelocity);
|
||||
applyForce(part, sumGravity(planets, part.center), deltaTime);
|
||||
if (part.stepManually(deltaTime) instanceof PlanetPhysical) {
|
||||
grounded = true;
|
||||
}
|
||||
}
|
||||
decayMomentum(this.bodyVelocity, grounded, deltaTime);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,143 +1,64 @@
|
|||
import { vec2 } from 'gl-matrix';
|
||||
import {
|
||||
Circle,
|
||||
CommandExecutors,
|
||||
CommandReceiver,
|
||||
GameObject,
|
||||
resolveCircleMovement,
|
||||
serializesTo,
|
||||
} from 'shared';
|
||||
import { BoundingBox } from '../physics/bounding-boxes/bounding-box';
|
||||
import { BoundingBoxBase } from '../physics/bounding-boxes/bounding-box-base';
|
||||
import { PhysicalContainer } from '../physics/containers/physical-container';
|
||||
import { DynamicPhysical } from '../physics/physicals/dynamic-physical';
|
||||
import { Physical } from '../physics/physicals/physical';
|
||||
import { ReactToCollisionCommand } from '../commands/react-to-collision';
|
||||
|
||||
@serializesTo(Circle)
|
||||
export class CirclePhysical extends CommandReceiver implements Circle, DynamicPhysical {
|
||||
readonly canCollide = true;
|
||||
readonly canMove = true;
|
||||
import { Circle, GameObject, resolveCircleMovement } from 'shared';
|
||||
import { BoundingBox } from '../physics/bounding-box';
|
||||
import { PhysicalContainer } from '../physics/physical-container';
|
||||
import { Physical } from '../physics/physical';
|
||||
|
||||
export class CirclePhysical extends Circle implements Physical {
|
||||
public readonly canCollide = true;
|
||||
public velocity = vec2.create();
|
||||
public lastNormal = vec2.fromValues(0, 1);
|
||||
|
||||
private _boundingBox: BoundingBox;
|
||||
|
||||
protected commandExecutors: CommandExecutors = {
|
||||
[ReactToCollisionCommand.type]: this.onCollision.bind(this),
|
||||
};
|
||||
private readonly box = new BoundingBox();
|
||||
|
||||
constructor(
|
||||
private _center: vec2,
|
||||
private _radius: number,
|
||||
public owner: GameObject,
|
||||
center: vec2,
|
||||
radius: number,
|
||||
public readonly owner: Physical,
|
||||
private readonly container: PhysicalContainer,
|
||||
// Public + readonly so a CirclePhysical structurally satisfies the shared
|
||||
// PhysicsBody interface the movement simulation operates on.
|
||||
public readonly restitution = 0,
|
||||
) {
|
||||
super();
|
||||
this._boundingBox = new BoundingBox();
|
||||
this.recalculateBoundingBox();
|
||||
super(center, radius);
|
||||
}
|
||||
|
||||
public get boundingBox(): BoundingBoxBase {
|
||||
return this._boundingBox;
|
||||
}
|
||||
|
||||
public get center(): vec2 {
|
||||
return this._center;
|
||||
}
|
||||
|
||||
public set center(value: vec2) {
|
||||
this._center = value;
|
||||
this.recalculateBoundingBox();
|
||||
}
|
||||
|
||||
public onCollision(c: ReactToCollisionCommand) {
|
||||
this.owner.handleCommand(c);
|
||||
public get boundingBox(): BoundingBox {
|
||||
return this.box.setCircle(this.center, this.radius);
|
||||
}
|
||||
|
||||
public get gameObject(): GameObject {
|
||||
return this.owner;
|
||||
return this.owner.gameObject;
|
||||
}
|
||||
|
||||
public get radius(): number {
|
||||
return this._radius;
|
||||
public onCollision(other: GameObject) {
|
||||
this.owner.onCollision?.(other);
|
||||
}
|
||||
|
||||
public set radius(value: number) {
|
||||
this._radius = value;
|
||||
this.recalculateBoundingBox();
|
||||
}
|
||||
|
||||
public distance(target: vec2): number {
|
||||
return vec2.distance(target, this.center) - this.radius;
|
||||
}
|
||||
|
||||
private recalculateBoundingBox() {
|
||||
this._boundingBox.xMin = this.center.x - this._radius;
|
||||
this._boundingBox.xMax = this.center.x + this._radius;
|
||||
this._boundingBox.yMin = this.center.y - this._radius;
|
||||
this._boundingBox.yMax = this.center.y + this._radius;
|
||||
}
|
||||
|
||||
public applyForce(force: vec2, timeInSeconds: number) {
|
||||
vec2.add(
|
||||
this.velocity,
|
||||
this.velocity,
|
||||
vec2.scale(vec2.create(), force, timeInSeconds),
|
||||
);
|
||||
}
|
||||
|
||||
// Position-resolution for one tick. Delegates to the shared
|
||||
// resolveCircleMovement so the server integrates a body with the exact same
|
||||
// geometry the client predictor runs (shared/physics) — no parallel copy to
|
||||
// keep in sync. The onHit callback dispatches the collision reactions at the
|
||||
// same points the old inline move-circle did (both the initial march and the
|
||||
// post-bounce slide). `possibleIntersectors`, when supplied, lets a caller
|
||||
// that already broadphased (e.g. a projectile's gravity query) avoid a second
|
||||
// container query; otherwise it is self-gathered from the swept bounding box.
|
||||
public stepManually(
|
||||
deltaTimeInSeconds: number,
|
||||
possibleIntersectors?: Array<Physical>,
|
||||
): {
|
||||
hitObject: GameObject | undefined;
|
||||
velocity: vec2;
|
||||
} {
|
||||
): GameObject | undefined {
|
||||
const intersecting = (
|
||||
possibleIntersectors ?? this.sweptBroadphase(deltaTimeInSeconds)
|
||||
).filter((b) => b.gameObject !== this.gameObject && b.canCollide);
|
||||
|
||||
const { hitObject, velocity } = resolveCircleMovement(
|
||||
const hit = resolveCircleMovement(
|
||||
this,
|
||||
deltaTimeInSeconds,
|
||||
intersecting,
|
||||
(intersected) => {
|
||||
const physical = intersected as Physical;
|
||||
physical.handleCommand(new ReactToCollisionCommand(this.gameObject));
|
||||
this.handleCommand(new ReactToCollisionCommand(physical.gameObject));
|
||||
physical.onCollision?.(this.gameObject);
|
||||
this.onCollision(physical.gameObject);
|
||||
},
|
||||
);
|
||||
) as Physical | undefined;
|
||||
|
||||
return { hitObject: (hitObject as Physical | undefined)?.gameObject, velocity };
|
||||
return hit?.gameObject;
|
||||
}
|
||||
|
||||
// Query the container with the bounding box grown by this tick's travel, so a
|
||||
// fast-moving body still sees what it is about to sweep into.
|
||||
private sweptBroadphase(deltaTimeInSeconds: number): Array<Physical> {
|
||||
const sweep = vec2.length(
|
||||
vec2.scale(vec2.create(), this.velocity, deltaTimeInSeconds),
|
||||
const sweep = vec2.length(this.velocity) * deltaTimeInSeconds;
|
||||
return this.container.findIntersecting(
|
||||
BoundingBox.ofCircle(this.center, this.radius + sweep),
|
||||
);
|
||||
this.radius += sweep;
|
||||
const intersecting = this.container.findIntersecting(this.boundingBox);
|
||||
this.radius -= sweep;
|
||||
return intersecting;
|
||||
}
|
||||
|
||||
public toArray(): Array<any> {
|
||||
const { center, radius } = this;
|
||||
return [center, radius];
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue