942 lines
24 KiB
TypeScript
942 lines
24 KiB
TypeScript
interface WebSocketData {
|
|
role: "teacher" | "student" | "unknown";
|
|
roomCode: string | null;
|
|
name?: string;
|
|
}
|
|
|
|
type Phase = "lobby" | "day" | "trading";
|
|
|
|
interface Player {
|
|
name: string;
|
|
clientId: string;
|
|
ws: any | null;
|
|
fish: number;
|
|
wood: number;
|
|
fishingPerHour: number;
|
|
foragingPerHour: number;
|
|
hours: number;
|
|
preserver: boolean;
|
|
boat: boolean;
|
|
pendingFishing: number;
|
|
pendingForaging: number;
|
|
found: Set<string>;
|
|
discoveryDay: number;
|
|
}
|
|
|
|
interface TradeOffer {
|
|
id: string;
|
|
from: string;
|
|
to: string;
|
|
giveFish: number;
|
|
giveWood: number;
|
|
wantFish: number;
|
|
wantWood: number;
|
|
}
|
|
|
|
type Room = {
|
|
code: string;
|
|
teacherWs: any | null;
|
|
teacherToken: string;
|
|
players: Map<string, Player>;
|
|
phase: Phase;
|
|
day: number;
|
|
offers: Map<string, TradeOffer>;
|
|
};
|
|
|
|
const IMPROVE_HOURS = 8;
|
|
const PRESERVER_HOURS = 8;
|
|
const PRESERVER_WOOD = 25;
|
|
const BOAT_HOURS = 16;
|
|
const BOAT_WOOD = 100;
|
|
|
|
const rooms = new Map<string, Room>();
|
|
|
|
const pages: Record<string, string> = {
|
|
"/": "index.html",
|
|
"/host": "lobby.html",
|
|
"/lobby": "lobby.html",
|
|
"/waiting": "waiting.html",
|
|
"/game": "game.html",
|
|
"/trading": "trading.html",
|
|
"/ws-test": "ws-test.html",
|
|
};
|
|
|
|
async function serveFile(path: string): Promise<Response> {
|
|
const file = Bun.file(path);
|
|
if (!(await file.exists())) return new Response("Not Found", { status: 404 });
|
|
|
|
const headers: Record<string, string> = {
|
|
"Content-Type": file.type || "application/octet-stream",
|
|
};
|
|
|
|
// Pages and scripts change while developing, so don't let the browser serve
|
|
// a stale copy. Images can still be cached normally.
|
|
if (/\.(html|css|js)$/.test(path)) {
|
|
headers["Cache-Control"] = "no-store";
|
|
}
|
|
|
|
return new Response(file, { headers });
|
|
}
|
|
|
|
function safeSend(ws: any | null, message: unknown): boolean {
|
|
if (!ws) return false;
|
|
|
|
try {
|
|
ws.send(JSON.stringify(message));
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function sendError(ws: any, message: string, code?: string) {
|
|
const payload: Record<string, unknown> = { type: "ERROR", message };
|
|
if (code) payload.code = code;
|
|
safeSend(ws, payload);
|
|
}
|
|
|
|
function playerView(player: Player, room: Room) {
|
|
return {
|
|
name: player.name,
|
|
fish: player.fish,
|
|
wood: player.wood,
|
|
hours: player.hours,
|
|
fishingPerHour: player.fishingPerHour,
|
|
foragingPerHour: player.foragingPerHour,
|
|
preserver: player.preserver,
|
|
boat: player.boat,
|
|
pendingFishing: player.pendingFishing,
|
|
pendingForaging: player.pendingForaging,
|
|
found: Array.from(player.found, (key) => room.players.get(key)?.name ?? key),
|
|
discoveryDay: player.discoveryDay,
|
|
connected: player.ws !== null,
|
|
};
|
|
}
|
|
|
|
// Trade offers are only sent to the two students involved. The teacher still
|
|
// sees the roster but not the private offers.
|
|
function offersFor(room: Room, playerKey: string) {
|
|
const nameOf = (key: string) => room.players.get(key)?.name ?? key;
|
|
|
|
return Array.from(room.offers.values())
|
|
.filter((offer) => offer.from === playerKey || offer.to === playerKey)
|
|
.map((offer) => ({
|
|
id: offer.id,
|
|
from: nameOf(offer.from),
|
|
to: nameOf(offer.to),
|
|
giveFish: offer.giveFish,
|
|
giveWood: offer.giveWood,
|
|
wantFish: offer.wantFish,
|
|
wantWood: offer.wantWood,
|
|
incoming: offer.to === playerKey,
|
|
}));
|
|
}
|
|
|
|
function notify(ws: any | null, message: string, tone = "") {
|
|
safeSend(ws, { type: "NOTICE", message, tone });
|
|
}
|
|
|
|
// Send the authoritative room state to the teacher and every student.
|
|
// Each student gets the same roster plus their own `you` object and any trade
|
|
// offers they are involved in.
|
|
function broadcastSync(room: Room) {
|
|
const players = Array.from(room.players.values()).map((player) =>
|
|
playerView(player, room),
|
|
);
|
|
const base = {
|
|
type: "SYNC",
|
|
code: room.code,
|
|
phase: room.phase,
|
|
day: room.day,
|
|
players,
|
|
};
|
|
|
|
if (
|
|
room.teacherWs &&
|
|
!safeSend(room.teacherWs, { ...base, you: null, offers: [] })
|
|
) {
|
|
room.teacherWs = null;
|
|
}
|
|
|
|
for (const [key, player] of room.players) {
|
|
if (!player.ws) continue;
|
|
|
|
const payload = {
|
|
...base,
|
|
you: playerView(player, room),
|
|
offers: offersFor(room, key),
|
|
};
|
|
|
|
if (!safeSend(player.ws, payload)) {
|
|
player.ws = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
function createPlayer(
|
|
name: string,
|
|
clientId: string,
|
|
ws: any,
|
|
room: Room,
|
|
): Player {
|
|
const first = Math.floor(Math.random() * 2) + 1;
|
|
|
|
return {
|
|
name,
|
|
clientId,
|
|
ws,
|
|
fish: 0,
|
|
wood: 0,
|
|
fishingPerHour: first,
|
|
foragingPerHour: first === 1 ? 2 : 1,
|
|
hours: room.phase === "trading" ? 0 : 16,
|
|
preserver: false,
|
|
boat: false,
|
|
pendingFishing: 0,
|
|
pendingForaging: 0,
|
|
found: new Set(),
|
|
discoveryDay: 0,
|
|
};
|
|
}
|
|
|
|
function teacherRoom(ws: any): Room | null {
|
|
if (ws.data.role !== "teacher" || !ws.data.roomCode) return null;
|
|
|
|
const room = rooms.get(ws.data.roomCode);
|
|
if (!room || room.teacherWs !== ws) return null;
|
|
|
|
return room;
|
|
}
|
|
|
|
function studentInRoom(
|
|
ws: any,
|
|
): { room: Room; player: Player; key: string } | null {
|
|
if (ws.data.role !== "student" || !ws.data.roomCode || !ws.data.name) {
|
|
return null;
|
|
}
|
|
|
|
const room = rooms.get(ws.data.roomCode);
|
|
if (!room) return null;
|
|
|
|
const key = ws.data.name.toLowerCase();
|
|
const player = room.players.get(key);
|
|
if (!player || player.ws !== ws) return null;
|
|
|
|
return { room, player, key };
|
|
}
|
|
|
|
function startGame(room: Room) {
|
|
room.phase = "day";
|
|
room.day = 1;
|
|
|
|
for (const player of room.players.values()) {
|
|
player.hours = 16;
|
|
}
|
|
|
|
console.log(`Room ${room.code}: day 1 started`);
|
|
broadcastSync(room);
|
|
}
|
|
|
|
function endDay(room: Room) {
|
|
room.phase = "trading";
|
|
console.log(`Room ${room.code}: day ${room.day} ended, trading open`);
|
|
broadcastSync(room);
|
|
}
|
|
|
|
function startNextDay(room: Room) {
|
|
room.day += 1;
|
|
room.phase = "day";
|
|
room.offers.clear();
|
|
|
|
for (const player of room.players.values()) {
|
|
player.hours = 16;
|
|
player.fishingPerHour += player.pendingFishing;
|
|
player.foragingPerHour += player.pendingForaging;
|
|
player.pendingFishing = 0;
|
|
player.pendingForaging = 0;
|
|
}
|
|
|
|
console.log(`Room ${room.code}: day ${room.day} started`);
|
|
broadcastSync(room);
|
|
}
|
|
|
|
// If every connected student has spent all their hours, open trading
|
|
// automatically. Returns true when it changed the phase.
|
|
function checkAutoEndDay(room: Room): boolean {
|
|
if (room.phase !== "day") return false;
|
|
|
|
const active = Array.from(room.players.values()).filter(
|
|
(player) => player.ws !== null,
|
|
);
|
|
|
|
if (active.length === 0) return false;
|
|
if (!active.every((player) => player.hours <= 0)) return false;
|
|
|
|
room.phase = "trading";
|
|
console.log(
|
|
`Room ${room.code}: every connected player is out of hours; trading open`,
|
|
);
|
|
broadcastSync(room);
|
|
return true;
|
|
}
|
|
|
|
function finishAction(room: Room) {
|
|
if (!checkAutoEndDay(room)) broadcastSync(room);
|
|
}
|
|
|
|
function parseAmount(value: unknown): number | null {
|
|
const amount = Number(value ?? 0);
|
|
return Number.isInteger(amount) && amount >= 0 ? amount : null;
|
|
}
|
|
|
|
function findOfferBetween(
|
|
room: Room,
|
|
a: string,
|
|
b: string,
|
|
): TradeOffer | undefined {
|
|
for (const offer of room.offers.values()) {
|
|
if (
|
|
(offer.from === a && offer.to === b) ||
|
|
(offer.from === b && offer.to === a)
|
|
) {
|
|
return offer;
|
|
}
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
function handleDiscover(
|
|
ws: any,
|
|
room: Room,
|
|
player: Player,
|
|
key: string,
|
|
) {
|
|
if (room.phase !== "day") {
|
|
sendError(ws, "You can only explore during the day.");
|
|
return;
|
|
}
|
|
|
|
if (player.discoveryDay === room.day) {
|
|
sendError(ws, "You already found someone today.");
|
|
return;
|
|
}
|
|
|
|
const candidates = Array.from(room.players.entries()).filter(
|
|
([otherKey, other]) =>
|
|
otherKey !== key && other.ws !== null && !player.found.has(otherKey),
|
|
);
|
|
|
|
if (candidates.length === 0) {
|
|
const connectedOthers = Array.from(room.players.entries()).filter(
|
|
([otherKey, other]) => otherKey !== key && other.ws !== null,
|
|
);
|
|
|
|
sendError(
|
|
ws,
|
|
connectedOthers.length === 0
|
|
? "No other castaways are online right now."
|
|
: "You have already found every online castaway.",
|
|
);
|
|
return;
|
|
}
|
|
|
|
const picked = candidates[Math.floor(Math.random() * candidates.length)];
|
|
if (!picked) return;
|
|
|
|
const [otherKey, other] = picked;
|
|
|
|
player.found.add(otherKey);
|
|
other.found.add(key);
|
|
player.discoveryDay = room.day;
|
|
|
|
broadcastSync(room);
|
|
notify(ws, `You found ${other.name}!`, "good");
|
|
notify(
|
|
other.ws,
|
|
`${player.name} found you. You can now trade with each other.`,
|
|
"good",
|
|
);
|
|
}
|
|
|
|
function handleTradeOffer(
|
|
ws: any,
|
|
room: Room,
|
|
player: Player,
|
|
key: string,
|
|
data: any,
|
|
) {
|
|
if (room.phase !== "trading") {
|
|
sendError(ws, "Trading is only open after the day ends.");
|
|
return;
|
|
}
|
|
|
|
const targetName = String(data.to || "").trim();
|
|
const targetKey = targetName.toLowerCase();
|
|
const target = room.players.get(targetKey);
|
|
|
|
if (!target || targetKey === key) {
|
|
sendError(ws, "That castaway is not in this room.");
|
|
return;
|
|
}
|
|
|
|
if (!player.found.has(targetKey)) {
|
|
sendError(ws, "You can only trade with a castaway you have found.");
|
|
return;
|
|
}
|
|
|
|
if (!target.ws) {
|
|
sendError(ws, `${target.name} is offline right now.`);
|
|
return;
|
|
}
|
|
|
|
const giveFish = parseAmount(data.giveFish);
|
|
const giveWood = parseAmount(data.giveWood);
|
|
const wantFish = parseAmount(data.wantFish);
|
|
const wantWood = parseAmount(data.wantWood);
|
|
|
|
if (
|
|
giveFish === null ||
|
|
giveWood === null ||
|
|
wantFish === null ||
|
|
wantWood === null
|
|
) {
|
|
sendError(ws, "Trade amounts must be whole numbers of 0 or more.");
|
|
return;
|
|
}
|
|
|
|
if (giveFish + giveWood + wantFish + wantWood === 0) {
|
|
sendError(ws, "Offer at least one fish or piece of wood.");
|
|
return;
|
|
}
|
|
|
|
if (player.fish < giveFish || player.wood < giveWood) {
|
|
sendError(ws, "You do not have enough supplies for that offer.");
|
|
return;
|
|
}
|
|
|
|
if (target.fish < wantFish || target.wood < wantWood) {
|
|
sendError(ws, `${target.name} does not have enough supplies for that offer.`);
|
|
return;
|
|
}
|
|
|
|
if (findOfferBetween(room, key, targetKey)) {
|
|
sendError(ws, "There is already a pending offer between you two.");
|
|
return;
|
|
}
|
|
|
|
const offer: TradeOffer = {
|
|
id: crypto.randomUUID(),
|
|
from: key,
|
|
to: targetKey,
|
|
giveFish,
|
|
giveWood,
|
|
wantFish,
|
|
wantWood,
|
|
};
|
|
|
|
room.offers.set(offer.id, offer);
|
|
broadcastSync(room);
|
|
notify(ws, `Offer sent to ${target.name}.`);
|
|
notify(target.ws, `Offer from ${player.name}. Check the trading post.`);
|
|
}
|
|
|
|
function handleTradeAccept(
|
|
ws: any,
|
|
room: Room,
|
|
player: Player,
|
|
key: string,
|
|
data: any,
|
|
) {
|
|
if (room.phase !== "trading") {
|
|
sendError(ws, "Trading is only open after the day ends.");
|
|
return;
|
|
}
|
|
|
|
const offer = room.offers.get(String(data.id || ""));
|
|
if (!offer || offer.to !== key) {
|
|
sendError(ws, "That offer is no longer available.");
|
|
return;
|
|
}
|
|
|
|
const fromPlayer = room.players.get(offer.from);
|
|
if (!fromPlayer) {
|
|
room.offers.delete(offer.id);
|
|
broadcastSync(room);
|
|
sendError(ws, "That castaway is no longer in the room.");
|
|
return;
|
|
}
|
|
|
|
if (
|
|
fromPlayer.fish < offer.giveFish ||
|
|
fromPlayer.wood < offer.giveWood ||
|
|
player.fish < offer.wantFish ||
|
|
player.wood < offer.wantWood
|
|
) {
|
|
sendError(ws, "That offer can no longer be completed. Ask for a new one.");
|
|
return;
|
|
}
|
|
|
|
fromPlayer.fish -= offer.giveFish;
|
|
fromPlayer.wood -= offer.giveWood;
|
|
player.fish += offer.giveFish;
|
|
player.wood += offer.giveWood;
|
|
player.fish -= offer.wantFish;
|
|
player.wood -= offer.wantWood;
|
|
fromPlayer.fish += offer.wantFish;
|
|
fromPlayer.wood += offer.wantWood;
|
|
|
|
room.offers.delete(offer.id);
|
|
broadcastSync(room);
|
|
notify(ws, `Trade complete with ${fromPlayer.name}.`, "good");
|
|
notify(fromPlayer.ws, `Trade complete with ${player.name}.`, "good");
|
|
}
|
|
|
|
function handleTradeDecline(
|
|
ws: any,
|
|
room: Room,
|
|
player: Player,
|
|
key: string,
|
|
data: any,
|
|
) {
|
|
const offer = room.offers.get(String(data.id || ""));
|
|
if (!offer || offer.to !== key) {
|
|
sendError(ws, "That offer is no longer available.");
|
|
return;
|
|
}
|
|
|
|
const fromPlayer = room.players.get(offer.from);
|
|
room.offers.delete(offer.id);
|
|
broadcastSync(room);
|
|
notify(ws, "Offer declined.");
|
|
notify(fromPlayer?.ws ?? null, `${player.name} declined your offer.`);
|
|
}
|
|
|
|
function handleTradeCancel(
|
|
ws: any,
|
|
room: Room,
|
|
player: Player,
|
|
key: string,
|
|
data: any,
|
|
) {
|
|
const offer = room.offers.get(String(data.id || ""));
|
|
if (!offer || offer.from !== key) {
|
|
sendError(ws, "That offer is no longer available.");
|
|
return;
|
|
}
|
|
|
|
const target = room.players.get(offer.to);
|
|
room.offers.delete(offer.id);
|
|
broadcastSync(room);
|
|
notify(ws, "Offer cancelled.");
|
|
notify(target?.ws ?? null, `${player.name} cancelled their offer.`);
|
|
}
|
|
|
|
const server = Bun.serve<WebSocketData>({
|
|
port: Number(process.env.PORT ?? 3000),
|
|
async fetch(req, server) {
|
|
const url = new URL(req.url);
|
|
|
|
console.log(req.method, url.pathname);
|
|
|
|
if (url.pathname === "/ws") {
|
|
if (server.upgrade(req, { data: { role: "unknown", roomCode: null } }))
|
|
return;
|
|
return new Response("WebSocket upgrade failed", { status: 400 });
|
|
}
|
|
|
|
const page = pages[url.pathname];
|
|
if (page) return serveFile(page);
|
|
|
|
if (
|
|
url.pathname.startsWith("/client/") ||
|
|
url.pathname.startsWith("/assets/")
|
|
) {
|
|
if (url.pathname.includes("..")) {
|
|
return new Response("Bad path", { status: 400 });
|
|
}
|
|
return serveFile("." + url.pathname);
|
|
}
|
|
|
|
if (url.pathname === "/styles.css") return serveFile("styles.css");
|
|
if (url.pathname == "/api/health") {
|
|
return Response.json({ ok: true, time: Date.now() });
|
|
}
|
|
if (url.pathname == "/hello") {
|
|
return new Response("Hello from bun");
|
|
}
|
|
return new Response("Not Found", { status: 404 });
|
|
},
|
|
websocket: {
|
|
open() {
|
|
console.log("A client connect via websocket!");
|
|
},
|
|
message(ws, message) {
|
|
const text = typeof message === "string" ? message : message.toString();
|
|
|
|
let data: any;
|
|
try {
|
|
data = JSON.parse(text);
|
|
} catch {
|
|
sendError(ws, "Invalid JSON");
|
|
return;
|
|
}
|
|
|
|
if (data.type === "PING") {
|
|
safeSend(ws, { type: "PONG" });
|
|
return;
|
|
}
|
|
|
|
console.log("recv:", text);
|
|
|
|
if (data.type === "ECHO") {
|
|
safeSend(ws, { type: "ECHO", text: data.text });
|
|
return;
|
|
}
|
|
|
|
if (data.type === "CREATE_ROOM") {
|
|
if (ws.data.roomCode) {
|
|
sendError(ws, "Already in a room");
|
|
return;
|
|
}
|
|
|
|
let roomCode = "";
|
|
|
|
do {
|
|
roomCode = Math.floor(1000 + Math.random() * 9000).toString();
|
|
} while (rooms.has(roomCode));
|
|
|
|
const teacherToken = crypto.randomUUID();
|
|
const room: Room = {
|
|
code: roomCode,
|
|
teacherWs: ws,
|
|
teacherToken,
|
|
players: new Map(),
|
|
phase: "lobby",
|
|
day: 0,
|
|
offers: new Map(),
|
|
};
|
|
|
|
rooms.set(roomCode, room);
|
|
ws.data = { role: "teacher", roomCode };
|
|
|
|
safeSend(ws, {
|
|
type: "ROOM_CREATED",
|
|
code: roomCode,
|
|
token: teacherToken,
|
|
});
|
|
broadcastSync(room);
|
|
console.log(`Teacher created room: ${roomCode}`);
|
|
return;
|
|
}
|
|
|
|
if (data.type === "RESUME_TEACHER") {
|
|
const code = String(data.code || "").trim();
|
|
const token = String(data.token || "").trim();
|
|
|
|
if (!code || !token) {
|
|
sendError(ws, "Code and token required");
|
|
return;
|
|
}
|
|
|
|
const room = rooms.get(code);
|
|
if (!room) {
|
|
sendError(ws, "Room not found", "ROOM_NOT_FOUND");
|
|
return;
|
|
}
|
|
|
|
if (room.teacherToken !== token) {
|
|
sendError(ws, "Not allowed to resume that room");
|
|
return;
|
|
}
|
|
|
|
if (room.teacherWs && room.teacherWs !== ws) {
|
|
try {
|
|
room.teacherWs.close(4000, "Replaced by newer connection");
|
|
} catch {}
|
|
}
|
|
|
|
room.teacherWs = ws;
|
|
ws.data = { role: "teacher", roomCode: code };
|
|
safeSend(ws, { type: "ROOM_RESUMED", code });
|
|
broadcastSync(room);
|
|
console.log(`Teacher resumed room: ${code}`);
|
|
return;
|
|
}
|
|
|
|
if (data.type === "JOIN_ROOM") {
|
|
const code = String(data.code || "").trim();
|
|
const name = String(data.name || "").trim();
|
|
const clientId = String(data.clientId || "").trim();
|
|
|
|
if (!code || !name || !clientId) {
|
|
sendError(ws, "Name, code and clientId required");
|
|
return;
|
|
}
|
|
|
|
const room = rooms.get(code);
|
|
if (!room) {
|
|
sendError(ws, "Room not found!", "ROOM_NOT_FOUND");
|
|
return;
|
|
}
|
|
|
|
const key = name.toLowerCase();
|
|
const existing = room.players.get(key);
|
|
|
|
if (existing) {
|
|
if (existing.clientId === clientId) {
|
|
if (existing.ws && existing.ws !== ws) {
|
|
try {
|
|
existing.ws.close(4000, "Replaced by newer connection");
|
|
} catch {}
|
|
}
|
|
|
|
existing.ws = ws;
|
|
ws.data = { role: "student", roomCode: code, name: existing.name };
|
|
safeSend(ws, { type: "JOIN_SUCCESS", rejoined: true });
|
|
console.log(`Student ${existing.name} rejoined room ${code}`);
|
|
broadcastSync(room);
|
|
return;
|
|
}
|
|
|
|
if (!existing.ws) {
|
|
existing.ws = ws;
|
|
existing.clientId = clientId;
|
|
ws.data = { role: "student", roomCode: code, name: existing.name };
|
|
safeSend(ws, { type: "JOIN_SUCCESS", rejoined: true });
|
|
console.log(`Student ${existing.name} took over room ${code}`);
|
|
broadcastSync(room);
|
|
return;
|
|
}
|
|
|
|
sendError(ws, "That name is already in use in another tab");
|
|
return;
|
|
}
|
|
|
|
const player = createPlayer(name, clientId, ws, room);
|
|
room.players.set(key, player);
|
|
ws.data = { role: "student", roomCode: code, name };
|
|
safeSend(ws, { type: "JOIN_SUCCESS" });
|
|
console.log(`Student ${name} joined room ${code}`);
|
|
broadcastSync(room);
|
|
return;
|
|
}
|
|
|
|
if (
|
|
data.type === "START_GAME" ||
|
|
data.type === "END_DAY" ||
|
|
data.type === "NEXT_DAY"
|
|
) {
|
|
const room = teacherRoom(ws);
|
|
|
|
if (!room) {
|
|
sendError(ws, "Only the teacher can control the game.");
|
|
return;
|
|
}
|
|
|
|
if (data.type === "START_GAME") {
|
|
if (room.phase !== "lobby") {
|
|
sendError(ws, "The game has already started.");
|
|
} else if (room.players.size === 0) {
|
|
sendError(ws, "Wait for at least one student to join.");
|
|
} else {
|
|
startGame(room);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (data.type === "END_DAY") {
|
|
if (room.phase !== "day") {
|
|
sendError(ws, "The game is not in a day phase.");
|
|
} else {
|
|
endDay(room);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (room.phase !== "trading") {
|
|
sendError(ws, "The game is not in the trading phase.");
|
|
} else {
|
|
startNextDay(room);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (
|
|
data.type === "FISH" ||
|
|
data.type === "FORAGE" ||
|
|
data.type === "IMPROVE_FISHING" ||
|
|
data.type === "IMPROVE_FORAGING" ||
|
|
data.type === "BUILD_PRESERVER" ||
|
|
data.type === "BUILD_BOAT"
|
|
) {
|
|
const student = studentInRoom(ws);
|
|
|
|
if (!student) {
|
|
sendError(ws, "You are not in a room.");
|
|
return;
|
|
}
|
|
|
|
const { room, player } = student;
|
|
|
|
if (room.phase !== "day") {
|
|
sendError(ws, "The day is not active.");
|
|
return;
|
|
}
|
|
|
|
if (data.type === "FISH" || data.type === "FORAGE") {
|
|
if (player.hours <= 0) {
|
|
sendError(ws, "You have no hours left today.");
|
|
return;
|
|
}
|
|
|
|
const hours = Number(data.hours);
|
|
|
|
if (
|
|
!Number.isInteger(hours) ||
|
|
hours < 1 ||
|
|
hours > player.hours
|
|
) {
|
|
sendError(ws, `Choose between 1 and ${player.hours} hours.`);
|
|
return;
|
|
}
|
|
|
|
if (data.type === "FISH") {
|
|
player.fish += hours * player.fishingPerHour;
|
|
} else {
|
|
player.wood += hours * player.foragingPerHour;
|
|
}
|
|
|
|
player.hours -= hours;
|
|
finishAction(room);
|
|
return;
|
|
}
|
|
|
|
if (
|
|
data.type === "IMPROVE_FISHING" ||
|
|
data.type === "IMPROVE_FORAGING"
|
|
) {
|
|
if (player.hours < IMPROVE_HOURS) {
|
|
sendError(
|
|
ws,
|
|
`Improving a skill costs ${IMPROVE_HOURS} hours.`,
|
|
);
|
|
return;
|
|
}
|
|
|
|
player.hours -= IMPROVE_HOURS;
|
|
|
|
if (data.type === "IMPROVE_FISHING") {
|
|
player.pendingFishing += 1;
|
|
} else {
|
|
player.pendingForaging += 1;
|
|
}
|
|
|
|
finishAction(room);
|
|
return;
|
|
}
|
|
|
|
if (data.type === "BUILD_PRESERVER") {
|
|
if (player.preserver) {
|
|
sendError(ws, "You already have a preserver.");
|
|
} else if (player.hours < PRESERVER_HOURS) {
|
|
sendError(
|
|
ws,
|
|
`Building a preserver costs ${PRESERVER_HOURS} hours.`,
|
|
);
|
|
} else if (player.wood < PRESERVER_WOOD) {
|
|
sendError(
|
|
ws,
|
|
`Building a preserver costs ${PRESERVER_WOOD} wood.`,
|
|
);
|
|
} else {
|
|
player.hours -= PRESERVER_HOURS;
|
|
player.wood -= PRESERVER_WOOD;
|
|
player.preserver = true;
|
|
finishAction(room);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (data.type === "BUILD_BOAT") {
|
|
if (player.boat) {
|
|
sendError(ws, "You already have a boat.");
|
|
} else if (player.hours < BOAT_HOURS) {
|
|
sendError(ws, `Building a boat costs ${BOAT_HOURS} hours.`);
|
|
} else if (player.wood < BOAT_WOOD) {
|
|
sendError(ws, `Building a boat costs ${BOAT_WOOD} wood.`);
|
|
} else {
|
|
player.hours -= BOAT_HOURS;
|
|
player.wood -= BOAT_WOOD;
|
|
player.boat = true;
|
|
finishAction(room);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (
|
|
data.type === "DISCOVER" ||
|
|
data.type === "TRADE_OFFER" ||
|
|
data.type === "TRADE_ACCEPT" ||
|
|
data.type === "TRADE_DECLINE" ||
|
|
data.type === "TRADE_CANCEL"
|
|
) {
|
|
const student = studentInRoom(ws);
|
|
|
|
if (!student) {
|
|
sendError(ws, "You are not in a room.");
|
|
return;
|
|
}
|
|
|
|
const { room, player, key } = student;
|
|
|
|
if (data.type === "DISCOVER") {
|
|
handleDiscover(ws, room, player, key);
|
|
} else if (data.type === "TRADE_OFFER") {
|
|
handleTradeOffer(ws, room, player, key, data);
|
|
} else if (data.type === "TRADE_ACCEPT") {
|
|
handleTradeAccept(ws, room, player, key, data);
|
|
} else if (data.type === "TRADE_DECLINE") {
|
|
handleTradeDecline(ws, room, player, key, data);
|
|
} else {
|
|
handleTradeCancel(ws, room, player, key, data);
|
|
}
|
|
return;
|
|
}
|
|
},
|
|
close(ws) {
|
|
if (!ws.data || !ws.data.roomCode) return;
|
|
|
|
const room = rooms.get(ws.data.roomCode);
|
|
if (!room) return;
|
|
|
|
if (ws.data.role === "teacher") {
|
|
if (room.teacherWs === ws) {
|
|
room.teacherWs = null;
|
|
console.log(`Teacher disconnected from room ${ws.data.roomCode}`);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (ws.data.role === "student" && ws.data.name) {
|
|
const key = ws.data.name.toLowerCase();
|
|
const player = room.players.get(key);
|
|
|
|
if (player && player.ws === ws) {
|
|
player.ws = null;
|
|
console.log(
|
|
`Student ${player.name} disconnected from room ${ws.data.roomCode}`,
|
|
);
|
|
|
|
if (!checkAutoEndDay(room)) broadcastSync(room);
|
|
}
|
|
return;
|
|
}
|
|
|
|
console.log("A client disconnected");
|
|
},
|
|
},
|
|
});
|
|
|
|
console.log(`Listening on ${server.url}`);
|