Files
autobeerpong/src/frontend/src/Connection.ts
T

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));
}