Initial public release of PSX Adventure Engine
Browser reference stack for PSX-era third-person adventure: fixed cameras, inventory puzzles, Box3D physics, host-authoritative P2P co-op, and a modular character harness. Ships the Ashgrove Precinct Level 1 investigation demo with a full cast and nine linked rooms.
This commit is contained in:
ryanfitzpatrickio
@@ -0,0 +1,186 @@
|
||||
import type { ClientMessage, GameMessage, HostMessage, PeerId, PeerInfo } from "@psx/shared";
|
||||
import { validateClientMessage, validateHostMessage } from "@psx/shared";
|
||||
import { PeerLink, type PeerLinkState } from "./PeerLink.js";
|
||||
import { SignalingClient } from "./SignalingClient.js";
|
||||
|
||||
/**
|
||||
* Transport layer for a co-op session — GDD §8.
|
||||
*
|
||||
* Topology is a star centred on the host, not a mesh. The host is
|
||||
* authoritative, so a guest-to-guest link would carry nothing either side is
|
||||
* permitted to act on; every guest holds exactly one link, to peer 0.
|
||||
*
|
||||
* This class is role-agnostic: it moves validated messages and reports
|
||||
* membership. What to *do* with a message is `HostAuthority`'s or the guest
|
||||
* session's problem.
|
||||
*/
|
||||
|
||||
export const HOST_PEER_ID = 0;
|
||||
|
||||
export class NetSession {
|
||||
private readonly signaling: SignalingClient;
|
||||
private readonly links = new Map<PeerId, PeerLink>();
|
||||
private readonly peers = new Map<PeerId, PeerInfo>();
|
||||
|
||||
localPeerId: PeerId = -1;
|
||||
isHost = false;
|
||||
|
||||
/** Host side: a guest sent input or an action. Already validated. */
|
||||
onClientMessage: ((message: ClientMessage, from: PeerId) => void) | null = null;
|
||||
/** Guest side: the host sent authoritative state. Already validated. */
|
||||
onHostMessage: ((message: HostMessage) => void) | null = null;
|
||||
onPeersChanged: ((peers: PeerInfo[]) => void) | null = null;
|
||||
onLinkStateChanged: ((peerId: PeerId, state: PeerLinkState) => void) | null = null;
|
||||
onFatal: ((message: string) => void) | null = null;
|
||||
|
||||
/**
|
||||
* World-level peer lifecycle, distinct from the transport-level membership
|
||||
* in `onPeersChanged`. `Game` uses these to spawn and despawn bodies, and
|
||||
* only wants them once the peer is actually reachable.
|
||||
*/
|
||||
onPeerJoinedWorld: ((peerId: PeerId) => void) | null = null;
|
||||
onPeerLeftWorld: ((peerId: PeerId) => void) | null = null;
|
||||
|
||||
constructor(
|
||||
signalingUrl: string,
|
||||
private readonly iceServers?: RTCIceServer[],
|
||||
) {
|
||||
this.signaling = new SignalingClient(signalingUrl, {
|
||||
onWelcome: (peerId, isHost, peers) => {
|
||||
this.localPeerId = peerId;
|
||||
this.isHost = isHost;
|
||||
for (const peer of peers) this.peers.set(peer.peerId, peer);
|
||||
|
||||
// The host opens connections to everyone already present; a guest
|
||||
// waits to be offered, so both sides never offer simultaneously.
|
||||
if (isHost) {
|
||||
for (const peer of peers) {
|
||||
if (peer.peerId !== peerId) this.openLink(peer.peerId, true);
|
||||
}
|
||||
}
|
||||
this.onPeersChanged?.(this.peerList());
|
||||
},
|
||||
|
||||
onPeerJoined: (peer) => {
|
||||
this.peers.set(peer.peerId, peer);
|
||||
if (this.isHost) this.openLink(peer.peerId, true);
|
||||
this.onPeersChanged?.(this.peerList());
|
||||
},
|
||||
|
||||
onPeerLeft: (peerId) => {
|
||||
this.peers.delete(peerId);
|
||||
this.links.get(peerId)?.close();
|
||||
this.links.delete(peerId);
|
||||
this.onPeerLeftWorld?.(peerId);
|
||||
this.onPeersChanged?.(this.peerList());
|
||||
},
|
||||
|
||||
onPeerUpdated: (peer) => {
|
||||
this.peers.set(peer.peerId, peer);
|
||||
this.onPeersChanged?.(this.peerList());
|
||||
},
|
||||
|
||||
onSignal: (from, payload) => {
|
||||
// A guest learns of the host by being offered, so create on demand.
|
||||
const link = this.links.get(from) ?? this.openLink(from, false);
|
||||
void link.handleSignal(payload);
|
||||
},
|
||||
|
||||
onStart: () => {
|
||||
/* Room transitions are driven by the host over the data channel. */
|
||||
},
|
||||
|
||||
onError: (message) => this.onFatal?.(message),
|
||||
onClose: () => {
|
||||
/* Data channels outlive the signalling socket; not fatal on its own. */
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
connect(token: string, lobbyCode: string): Promise<void> {
|
||||
return this.signaling.connect(token, lobbyCode);
|
||||
}
|
||||
|
||||
private openLink(peerId: PeerId, isInitiator: boolean): PeerLink {
|
||||
const existing = this.links.get(peerId);
|
||||
if (existing) return existing;
|
||||
|
||||
const link = new PeerLink({
|
||||
peerId,
|
||||
isInitiator,
|
||||
sendSignal: (payload) => this.signaling.sendSignal(peerId, payload),
|
||||
...(this.iceServers ? { iceServers: this.iceServers } : {}),
|
||||
});
|
||||
|
||||
link.onMessage = (message, from) => this.route(message, from);
|
||||
link.onStateChange = (state, id) => {
|
||||
// Spawn a body only once the channel is actually usable — announcing on
|
||||
// `peer-joined` would create a body for a peer that may never connect.
|
||||
if (state === "connected" && this.isHost) this.onPeerJoinedWorld?.(id);
|
||||
if (state === "closed" || state === "failed") this.onPeerLeftWorld?.(id);
|
||||
this.onLinkStateChanged?.(id, state);
|
||||
};
|
||||
|
||||
this.links.set(peerId, link);
|
||||
return link;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate before dispatch. The host must never act on unvalidated guest
|
||||
* input, and a guest should not be crashable by a malformed host frame.
|
||||
*/
|
||||
private route(message: GameMessage, from: PeerId): void {
|
||||
if (this.isHost) {
|
||||
const result = validateClientMessage(message);
|
||||
if (result.ok) this.onClientMessage?.(result.value, from);
|
||||
return;
|
||||
}
|
||||
|
||||
// Guests accept authoritative state only from the host's link.
|
||||
if (from !== HOST_PEER_ID) return;
|
||||
const result = validateHostMessage(message);
|
||||
if (result.ok) this.onHostMessage?.(result.value);
|
||||
}
|
||||
|
||||
/** Host: unreliable broadcast, for state superseded by the next frame. */
|
||||
broadcastState(message: HostMessage): void {
|
||||
for (const link of this.links.values()) link.sendState(message);
|
||||
}
|
||||
|
||||
/** Host: reliable broadcast, for state that must not be dropped. */
|
||||
broadcastEvent(message: HostMessage): void {
|
||||
for (const link of this.links.values()) link.sendEvent(message);
|
||||
}
|
||||
|
||||
sendToPeer(peerId: PeerId, message: HostMessage): void {
|
||||
this.links.get(peerId)?.sendEvent(message);
|
||||
}
|
||||
|
||||
/** Guest: input goes on the unreliable channel, actions on the reliable one. */
|
||||
sendInput(message: ClientMessage): void {
|
||||
this.links.get(HOST_PEER_ID)?.sendState(message);
|
||||
}
|
||||
|
||||
sendAction(message: ClientMessage): void {
|
||||
this.links.get(HOST_PEER_ID)?.sendEvent(message);
|
||||
}
|
||||
|
||||
setReady(isReady: boolean): void {
|
||||
this.signaling.setReady(isReady);
|
||||
}
|
||||
|
||||
peerList(): PeerInfo[] {
|
||||
return [...this.peers.values()].sort((a, b) => a.peerId - b.peerId);
|
||||
}
|
||||
|
||||
get connectedPeerCount(): number {
|
||||
return [...this.links.values()].filter((link) => link.isOpen).length;
|
||||
}
|
||||
|
||||
close(): void {
|
||||
for (const link of this.links.values()) link.close();
|
||||
this.links.clear();
|
||||
this.peers.clear();
|
||||
this.signaling.close();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user