237 lines
5.6 KiB
TypeScript
237 lines
5.6 KiB
TypeScript
import { LobbyState } from "./LobbyState";
|
|
import { Client, Id } from "./jsonTypes";
|
|
import {
|
|
validateClientSchema,
|
|
validateMessageSchema,
|
|
} from "./schemaValidators";
|
|
import { log } from "./utils/debugUtils";
|
|
import { Event, Evented } from "./utils/Evented";
|
|
import { MatchState } from "./MatchState";
|
|
import { BaseSocket, MessageEvent } from "./sockets/BaseSocket";
|
|
import { Socket } from "./sockets/Socket";
|
|
|
|
type MessageType = "join" | "rejoin" | "toggleRole" | "toggleReady";
|
|
|
|
interface Request {
|
|
messageType: MessageType;
|
|
}
|
|
|
|
interface JoinRequest {
|
|
messageType: "join";
|
|
messageContent: {
|
|
name: string;
|
|
};
|
|
}
|
|
|
|
interface RejoinRequest {
|
|
messageType: "rejoin";
|
|
messageContent: {
|
|
id: Id;
|
|
};
|
|
}
|
|
|
|
interface ToggleRoleRequest {
|
|
messageType: "toggleRole";
|
|
messageContent: Record<string, never>;
|
|
}
|
|
|
|
interface ToggleReadyRequest {
|
|
messageType: "toggleReady";
|
|
messageContent: Record<string, never>;
|
|
}
|
|
|
|
export class LobbyMessageEvent extends Event {
|
|
constructor(public lobbyState: LobbyState) {
|
|
super();
|
|
}
|
|
}
|
|
|
|
export class MatchMessageEvent extends Event {
|
|
constructor(public matchState: MatchState) {
|
|
super();
|
|
}
|
|
}
|
|
|
|
export class ConnectEvent extends Event {}
|
|
export class DisconnectEvent extends Event {}
|
|
export class JoinedEvent extends Event {}
|
|
export class ConnectOrDisconnectEvent extends Event {
|
|
constructor(public connected: boolean) {
|
|
super();
|
|
}
|
|
}
|
|
|
|
export const ConnectionEvents = {
|
|
"lobby-message": LobbyMessageEvent,
|
|
"match-message": MatchMessageEvent,
|
|
joined: JoinedEvent,
|
|
connect: ConnectEvent,
|
|
disconnect: DisconnectEvent,
|
|
"connect-or-disconnect": ConnectOrDisconnectEvent,
|
|
} as const;
|
|
|
|
export class Connection extends Evented<typeof ConnectionEvents> {
|
|
private _socket: BaseSocket | null = null;
|
|
private _wasConnected = false;
|
|
|
|
private _waitForJoin = false;
|
|
private _client: Client | null = null;
|
|
|
|
get connected(): boolean {
|
|
return this._socket?.connected ?? false;
|
|
}
|
|
|
|
connect(mock?: BaseSocket): void {
|
|
this._socket?.offAll();
|
|
this._socket = mock ?? new Socket();
|
|
|
|
this._socket.on("open", () => this._onConnect());
|
|
this._socket.on("close", () => this._onDisconnect());
|
|
this._socket.on("error", (event) => this._onError(event));
|
|
this._socket.on("message", (event) => this._onMessage(event));
|
|
}
|
|
|
|
private _onMessage(message: MessageEvent): void {
|
|
log("Connection", "received", message);
|
|
|
|
// TODO: Print error if not valid json.
|
|
const messageObject = JSON.parse(message.json);
|
|
|
|
if (this._waitForJoin) {
|
|
const client = messageObject.messageContent.client;
|
|
if (!validateClientSchema(client)) {
|
|
return;
|
|
}
|
|
this._client = client;
|
|
|
|
storeClient(this._client);
|
|
|
|
this._waitForJoin = false;
|
|
this.emit("joined", new JoinedEvent());
|
|
return;
|
|
}
|
|
|
|
// We only accept state messages events when we have joined.
|
|
if (this._client) {
|
|
const validated = validateMessageSchema(messageObject);
|
|
if (!validated) {
|
|
return;
|
|
}
|
|
|
|
switch (messageObject.messageType) {
|
|
case "lobbyState":
|
|
this.emit(
|
|
"lobby-message",
|
|
new LobbyMessageEvent(new LobbyState(messageObject, this._client)),
|
|
);
|
|
break;
|
|
case "matchState":
|
|
this.emit(
|
|
"match-message",
|
|
new MatchMessageEvent(new MatchState(messageObject, this._client)),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
private _onConnect(): void {
|
|
log("Connection", "connected");
|
|
|
|
this._wasConnected = true;
|
|
|
|
this.emit("connect", new ConnectEvent());
|
|
this.emit("connect-or-disconnect", new ConnectOrDisconnectEvent(true));
|
|
}
|
|
|
|
private _onDisconnect(): void {
|
|
log("Connection", "disconnected");
|
|
|
|
// The socket close event is also invoked when a connection attempt fails.
|
|
// Only emit the disconnect event when we actually had a connection.
|
|
if (this._wasConnected) {
|
|
this._wasConnected = false;
|
|
this.emit("disconnect", new DisconnectEvent());
|
|
this.emit("connect-or-disconnect", new ConnectOrDisconnectEvent(false));
|
|
}
|
|
|
|
// Try again
|
|
this.connect();
|
|
}
|
|
|
|
private _onError(event: globalThis.Event): void {
|
|
log("Connection", "error", event);
|
|
}
|
|
|
|
private _send(request: Request): void {
|
|
if (!this.connected) {
|
|
return;
|
|
}
|
|
|
|
const message = JSON.stringify(request);
|
|
this._socket!.send(message);
|
|
}
|
|
|
|
join(name: string): void {
|
|
const joinRequest = {
|
|
messageType: "join",
|
|
messageContent: {
|
|
name,
|
|
},
|
|
} as JoinRequest;
|
|
|
|
this._waitForJoin = true;
|
|
this._send(joinRequest);
|
|
}
|
|
|
|
rejoin(id: Id): void {
|
|
const rejoinRequest = {
|
|
messageType: "rejoin",
|
|
messageContent: { id },
|
|
} as RejoinRequest;
|
|
|
|
this._waitForJoin = true;
|
|
this._send(rejoinRequest);
|
|
}
|
|
|
|
toggleRole(): void {
|
|
const toggleRoleRequest = {
|
|
messageType: "toggleRole",
|
|
messageContent: {},
|
|
} as ToggleRoleRequest;
|
|
|
|
this._send(toggleRoleRequest);
|
|
}
|
|
|
|
toggleReady(): void {
|
|
const toggleReadyRequest = {
|
|
messageType: "toggleReady",
|
|
messageContent: {},
|
|
} as ToggleReadyRequest;
|
|
|
|
this._send(toggleReadyRequest);
|
|
}
|
|
}
|
|
|
|
export function storedClient(): Client | null {
|
|
const clientString = localStorage.getItem("client");
|
|
if (clientString == null) {
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
const clientRaw = JSON.parse(clientString) as Client;
|
|
if (!validateClientSchema(clientRaw)) {
|
|
return null;
|
|
}
|
|
|
|
return clientRaw;
|
|
} catch (error) {
|
|
log("Connection", error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function storeClient(client: Client) {
|
|
localStorage.setItem("client", JSON.stringify(client));
|
|
}
|