425 lines
15 KiB
JavaScript
425 lines
15 KiB
JavaScript
const { Room } = require("@colyseus/core");
|
|
const { GameState, Player } = require("../schema/GameState");
|
|
|
|
const ROUND_MODES = ["race", "survival", "teams"];
|
|
const LOBBY_TIMEOUT = 30; // seconds before auto-start
|
|
const COUNTDOWN_DURATION = 3;
|
|
const ROUND_END_DURATION = 5;
|
|
const RACE_TIMEOUT = 180; // 3 min
|
|
const SURVIVAL_START_DELAY = 20; // seconds before deathzone rises
|
|
const SURVIVAL_RISE_RATE = 0.3; // units/sec
|
|
const SURVIVAL_MAX_Y = 15;
|
|
const TEAMS_DURATION = 90;
|
|
const QUALIFY_RATIO = 0.6; // top 60% qualify in race
|
|
|
|
class ArenaRoom extends Room {
|
|
maxClients = 20;
|
|
|
|
onCreate(options) {
|
|
this.setState(new GameState());
|
|
this.setPatchRate(16); // ~62.5 Hz
|
|
|
|
this._phaseTimer = null;
|
|
this._survivalInterval = null;
|
|
this._teamInterval = null;
|
|
this._lobbyTimer = null;
|
|
this._inZonePlayers = new Set(); // sessionIds currently in zone
|
|
|
|
console.log(`[ArenaRoom] Room ${this.roomId} created`);
|
|
|
|
this.onMessage("position", (client, data) => {
|
|
const player = this.state.players.get(client.sessionId);
|
|
if (!player || player.isEliminated) return;
|
|
player.x = data.x ?? player.x;
|
|
player.y = data.y ?? player.y;
|
|
player.z = data.z ?? player.z;
|
|
player.vx = data.vx ?? player.vx;
|
|
player.vy = data.vy ?? player.vy;
|
|
player.vz = data.vz ?? player.vz;
|
|
player.rx = data.rx ?? player.rx;
|
|
player.ry = data.ry ?? player.ry;
|
|
player.rz = data.rz ?? player.rz;
|
|
player.rw = data.rw ?? player.rw;
|
|
player.avx = data.avx ?? player.avx;
|
|
player.avy = data.avy ?? player.avy;
|
|
player.avz = data.avz ?? player.avz;
|
|
player.t = Date.now();
|
|
});
|
|
|
|
this.onMessage("ready", (client) => {
|
|
const player = this.state.players.get(client.sessionId);
|
|
if (!player || this.state.phase !== "lobby") return;
|
|
player.isReady = true;
|
|
console.log(`[ArenaRoom] ${client.sessionId} ready`);
|
|
this._checkAllReady();
|
|
});
|
|
|
|
this.onMessage("checkpointReached", (client, data) => {
|
|
if (this.state.phase !== "playing" || this.state.gameMode !== "race") return;
|
|
const player = this.state.players.get(client.sessionId);
|
|
if (!player || player.isEliminated || player.isQualified) return;
|
|
const expected = player.checkpointIndex;
|
|
if (data.index !== expected) return; // must hit in order
|
|
player.checkpointIndex = data.index + 1;
|
|
// The last checkpoint (index 4 = finish) qualifies the player
|
|
// CheckpointSystem sends index after increment, so finish = totalCheckpoints
|
|
const TOTAL_CHECKPOINTS = 5;
|
|
if (player.checkpointIndex >= TOTAL_CHECKPOINTS) {
|
|
this._qualifyPlayer(client.sessionId, "finish");
|
|
}
|
|
});
|
|
|
|
this.onMessage("deathZoneHit", (client) => {
|
|
if (this.state.phase !== "playing" || this.state.gameMode !== "survival") return;
|
|
this._eliminatePlayer(client.sessionId, "deathzone");
|
|
});
|
|
|
|
this.onMessage("inZone", (client, data) => {
|
|
if (this.state.phase !== "playing" || this.state.gameMode !== "teams") return;
|
|
const player = this.state.players.get(client.sessionId);
|
|
if (!player || player.isEliminated) return;
|
|
if (data.inZone) {
|
|
this._inZonePlayers.add(client.sessionId);
|
|
} else {
|
|
this._inZonePlayers.delete(client.sessionId);
|
|
}
|
|
});
|
|
}
|
|
|
|
onJoin(client, options) {
|
|
console.log(`[ArenaRoom] ${client.sessionId} joined (${options.name || "anonymous"})`);
|
|
const player = new Player();
|
|
player.name = options.name || "Joueur";
|
|
player.colorR = options.colorR ?? 1;
|
|
player.colorG = options.colorG ?? 0.4;
|
|
player.colorB = options.colorB ?? 0.2;
|
|
const spawn = this._findSpawnPosition();
|
|
player.x = spawn.x;
|
|
player.y = spawn.y;
|
|
player.z = spawn.z;
|
|
player.t = Date.now();
|
|
this.state.players.set(client.sessionId, player);
|
|
this._updatePlayersAlive();
|
|
|
|
// Auto-start lobby timer on first player
|
|
if (this.state.players.size === 1 && this.state.phase === "lobby") {
|
|
this._startLobbyTimer();
|
|
}
|
|
}
|
|
|
|
onLeave(client, consented) {
|
|
console.log(`[ArenaRoom] ${client.sessionId} left`);
|
|
this._inZonePlayers.delete(client.sessionId);
|
|
this.state.players.delete(client.sessionId);
|
|
this._updatePlayersAlive();
|
|
if (this.state.phase === "playing") {
|
|
this._checkRoundEndCondition();
|
|
}
|
|
}
|
|
|
|
onDispose() {
|
|
this._clearAllTimers();
|
|
console.log(`[ArenaRoom] Room ${this.roomId} disposed`);
|
|
}
|
|
|
|
// ─── Phase transitions ──────────────────────────────────────────────
|
|
|
|
_startLobbyTimer() {
|
|
if (this._lobbyTimer) return;
|
|
this._lobbyTimer = setTimeout(() => this._startCountdown(), LOBBY_TIMEOUT * 1000);
|
|
console.log(`[ArenaRoom] Lobby timer started (${LOBBY_TIMEOUT}s)`);
|
|
}
|
|
|
|
_checkAllReady() {
|
|
if (this.state.players.size < 2) return;
|
|
let allReady = true;
|
|
this.state.players.forEach((p) => { if (!p.isReady) allReady = false; });
|
|
if (allReady) {
|
|
clearTimeout(this._lobbyTimer);
|
|
this._lobbyTimer = null;
|
|
this._startCountdown();
|
|
}
|
|
}
|
|
|
|
_startCountdown() {
|
|
if (this.state.phase !== "lobby") return;
|
|
this.state.phase = "countdown";
|
|
this.state.countdown = COUNTDOWN_DURATION;
|
|
console.log(`[ArenaRoom] Countdown started`);
|
|
|
|
const tick = () => {
|
|
this.state.countdown -= 1;
|
|
if (this.state.countdown <= 0) {
|
|
this._startPlaying();
|
|
} else {
|
|
this._phaseTimer = setTimeout(tick, 1000);
|
|
}
|
|
};
|
|
this._phaseTimer = setTimeout(tick, 1000);
|
|
}
|
|
|
|
_startPlaying() {
|
|
const modeIndex = (this.state.roundNumber - 1) % ROUND_MODES.length;
|
|
this.state.gameMode = ROUND_MODES[modeIndex];
|
|
this.state.phase = "playing";
|
|
this.state.countdown = 0;
|
|
|
|
// Reset player state for new round
|
|
let teamToggle = 0;
|
|
this.state.players.forEach((p, id) => {
|
|
p.isEliminated = false;
|
|
p.isQualified = false;
|
|
p.isReady = false;
|
|
p.checkpointIndex = 0;
|
|
if (this.state.gameMode === "teams") {
|
|
p.team = (teamToggle++ % 2 === 0) ? 1 : 2;
|
|
} else {
|
|
p.team = 0;
|
|
}
|
|
});
|
|
|
|
this.state.deathZoneY = -50;
|
|
this.state.teamScoreRed = 0;
|
|
this.state.teamScoreBlue = 0;
|
|
this._inZonePlayers.clear();
|
|
this._updatePlayersAlive();
|
|
|
|
this.broadcast("roundStart", {
|
|
round: this.state.roundNumber,
|
|
mode: this.state.gameMode,
|
|
totalRounds: this.state.totalRounds,
|
|
});
|
|
|
|
console.log(`[ArenaRoom] Round ${this.state.roundNumber} started (mode: ${this.state.gameMode})`);
|
|
|
|
if (this.state.gameMode === "race") {
|
|
this._phaseTimer = setTimeout(() => this._endRaceTimeout(), RACE_TIMEOUT * 1000);
|
|
} else if (this.state.gameMode === "survival") {
|
|
this._phaseTimer = setTimeout(() => this._startSurvivalRise(), SURVIVAL_START_DELAY * 1000);
|
|
} else if (this.state.gameMode === "teams") {
|
|
this._startTeamsScoring();
|
|
this._phaseTimer = setTimeout(() => this._endTeamsRound(), TEAMS_DURATION * 1000);
|
|
}
|
|
}
|
|
|
|
_endRound() {
|
|
if (this.state.phase !== "playing") return;
|
|
this._clearAllTimers();
|
|
this.state.phase = "roundEnd";
|
|
this.broadcast("roundEnd", { round: this.state.roundNumber });
|
|
console.log(`[ArenaRoom] Round ${this.state.roundNumber} ended`);
|
|
|
|
// Check if all rounds done
|
|
if (this.state.roundNumber >= this.state.totalRounds) {
|
|
this._phaseTimer = setTimeout(() => this._endGame(), ROUND_END_DURATION * 1000);
|
|
} else {
|
|
this._phaseTimer = setTimeout(() => this._nextRound(), ROUND_END_DURATION * 1000);
|
|
}
|
|
}
|
|
|
|
_nextRound() {
|
|
this.state.roundNumber += 1;
|
|
this.state.phase = "lobby";
|
|
this.state.playersAlive = 0;
|
|
this.state.players.forEach((p) => {
|
|
if (!p.isEliminated) {
|
|
p.isReady = false;
|
|
const spawn = this._findSpawnPosition();
|
|
p.x = spawn.x; p.y = spawn.y; p.z = spawn.z;
|
|
}
|
|
});
|
|
this._updatePlayersAlive();
|
|
this._lobbyTimer = null;
|
|
this._startLobbyTimer();
|
|
console.log(`[ArenaRoom] Lobby for round ${this.state.roundNumber}`);
|
|
}
|
|
|
|
_endGame() {
|
|
this.state.phase = "gameEnd";
|
|
// Find winner: last qualified player, or player with most checkpoints
|
|
let winner = "";
|
|
let best = -1;
|
|
this.state.players.forEach((p) => {
|
|
const score = p.isQualified ? 1000 : p.checkpointIndex;
|
|
if (score > best) { best = score; winner = p.name; }
|
|
});
|
|
this.state.winnerName = winner;
|
|
this.broadcast("gameEnd", { winner });
|
|
console.log(`[ArenaRoom] Game over — winner: ${winner}`);
|
|
}
|
|
|
|
// ─── Race mode ──────────────────────────────────────────────────────
|
|
|
|
_endRaceTimeout() {
|
|
// Eliminate anyone who hasn't qualified
|
|
this.state.players.forEach((p, id) => {
|
|
if (!p.isQualified && !p.isEliminated) {
|
|
this._eliminatePlayer(id, "timeout");
|
|
}
|
|
});
|
|
this._endRound();
|
|
}
|
|
|
|
// ─── Survival mode ──────────────────────────────────────────────────
|
|
|
|
_startSurvivalRise() {
|
|
console.log(`[ArenaRoom] DeathZone starts rising`);
|
|
this._survivalInterval = setInterval(() => {
|
|
this.state.deathZoneY += SURVIVAL_RISE_RATE * (16 / 1000);
|
|
if (this.state.deathZoneY > SURVIVAL_MAX_Y) {
|
|
this.state.deathZoneY = SURVIVAL_MAX_Y;
|
|
}
|
|
}, 16);
|
|
}
|
|
|
|
// ─── Teams mode ─────────────────────────────────────────────────────
|
|
|
|
_startTeamsScoring() {
|
|
this._teamInterval = setInterval(() => {
|
|
let redInZone = 0;
|
|
let blueInZone = 0;
|
|
this._inZonePlayers.forEach((id) => {
|
|
const p = this.state.players.get(id);
|
|
if (!p || p.isEliminated) return;
|
|
if (p.team === 1) redInZone++;
|
|
else if (p.team === 2) blueInZone++;
|
|
});
|
|
if (redInZone > blueInZone) this.state.teamScoreRed = Math.min(this.state.teamScoreRed + 1, 32767);
|
|
else if (blueInZone > redInZone) this.state.teamScoreBlue = Math.min(this.state.teamScoreBlue + 1, 32767);
|
|
}, 1000);
|
|
}
|
|
|
|
_endTeamsRound() {
|
|
// Eliminate losing team
|
|
const redWins = this.state.teamScoreRed >= this.state.teamScoreBlue;
|
|
const losingTeam = redWins ? 2 : 1;
|
|
this.state.players.forEach((p, id) => {
|
|
if (p.team === losingTeam && !p.isEliminated) {
|
|
this._eliminatePlayer(id, "teams_lost");
|
|
} else if (!p.isEliminated) {
|
|
this._qualifyPlayer(id, "teams_won");
|
|
}
|
|
});
|
|
this._endRound();
|
|
}
|
|
|
|
// ─── Elimination helpers ─────────────────────────────────────────────
|
|
|
|
_eliminatePlayer(sessionId, reason) {
|
|
const player = this.state.players.get(sessionId);
|
|
if (!player || player.isEliminated || player.isQualified) return;
|
|
player.isEliminated = true;
|
|
this._updatePlayersAlive();
|
|
this.broadcast("eliminated", { sessionId, name: player.name, reason });
|
|
console.log(`[ArenaRoom] ${player.name} (${sessionId}) eliminated: ${reason}`);
|
|
this._checkRoundEndCondition();
|
|
}
|
|
|
|
_qualifyPlayer(sessionId, reason) {
|
|
const player = this.state.players.get(sessionId);
|
|
if (!player || player.isQualified || player.isEliminated) return;
|
|
player.isQualified = true;
|
|
this._updatePlayersAlive();
|
|
this.broadcast("qualified", { sessionId, name: player.name });
|
|
console.log(`[ArenaRoom] ${player.name} (${sessionId}) qualified: ${reason}`);
|
|
|
|
if (this.state.gameMode === "race") {
|
|
const aliveCount = this._getAliveCount();
|
|
const totalActive = this._getActiveCount();
|
|
const qualifiedCount = this._getQualifiedCount();
|
|
// Eliminate once qualify_ratio reached
|
|
const toQualify = Math.ceil(totalActive * QUALIFY_RATIO);
|
|
if (qualifiedCount >= toQualify) {
|
|
this.state.players.forEach((p, id) => {
|
|
if (!p.isQualified && !p.isEliminated) {
|
|
this._eliminatePlayer(id, "too_slow");
|
|
}
|
|
});
|
|
this._endRound();
|
|
}
|
|
} else if (this.state.gameMode === "survival") {
|
|
// In survival: only 1 qualifies (last one), rest get eliminated by zone
|
|
this._checkRoundEndCondition();
|
|
}
|
|
}
|
|
|
|
_checkRoundEndCondition() {
|
|
if (this.state.phase !== "playing") return;
|
|
const alive = this._getAliveCount();
|
|
const qualified = this._getQualifiedCount();
|
|
const total = this._getActiveCount();
|
|
|
|
if (this.state.gameMode === "survival") {
|
|
if (alive <= 1) {
|
|
// Qualify the last survivor
|
|
this.state.players.forEach((p, id) => {
|
|
if (!p.isEliminated && !p.isQualified) {
|
|
this._qualifyPlayer(id, "last_survivor");
|
|
}
|
|
});
|
|
this._endRound();
|
|
}
|
|
} else if (alive === 0 || alive + qualified >= total) {
|
|
this._endRound();
|
|
}
|
|
}
|
|
|
|
_getAliveCount() {
|
|
let n = 0;
|
|
this.state.players.forEach((p) => { if (!p.isEliminated && !p.isQualified) n++; });
|
|
return n;
|
|
}
|
|
|
|
_getQualifiedCount() {
|
|
let n = 0;
|
|
this.state.players.forEach((p) => { if (p.isQualified) n++; });
|
|
return n;
|
|
}
|
|
|
|
_getActiveCount() {
|
|
return this.state.players.size;
|
|
}
|
|
|
|
_updatePlayersAlive() {
|
|
this.state.playersAlive = this._getAliveCount();
|
|
}
|
|
|
|
_clearAllTimers() {
|
|
if (this._phaseTimer) { clearTimeout(this._phaseTimer); this._phaseTimer = null; }
|
|
if (this._lobbyTimer) { clearTimeout(this._lobbyTimer); this._lobbyTimer = null; }
|
|
if (this._survivalInterval) { clearInterval(this._survivalInterval); this._survivalInterval = null; }
|
|
if (this._teamInterval) { clearInterval(this._teamInterval); this._teamInterval = null; }
|
|
}
|
|
|
|
// ─── Spawn helper ────────────────────────────────────────────────────
|
|
|
|
_findSpawnPosition() {
|
|
const MIN_DIST = 3.0;
|
|
const SPAWN_Y = 5;
|
|
const RANGE = 20;
|
|
const existing = [];
|
|
this.state.players.forEach((p) => existing.push({ x: p.x, z: p.z }));
|
|
|
|
if (existing.length === 0) {
|
|
return { x: (Math.random() - 0.5) * RANGE, y: SPAWN_Y, z: (Math.random() - 0.5) * RANGE };
|
|
}
|
|
|
|
let best = { x: 0, y: SPAWN_Y, z: 0 };
|
|
let bestDist = 0;
|
|
for (let i = 0; i < 10; i++) {
|
|
const cx = (Math.random() - 0.5) * RANGE;
|
|
const cz = (Math.random() - 0.5) * RANGE;
|
|
let minD = Infinity;
|
|
for (const p of existing) {
|
|
const d = Math.sqrt((cx - p.x) ** 2 + (cz - p.z) ** 2);
|
|
if (d < minD) minD = d;
|
|
}
|
|
if (minD >= MIN_DIST) return { x: cx, y: SPAWN_Y, z: cz };
|
|
if (minD > bestDist) { bestDist = minD; best = { x: cx, y: SPAWN_Y, z: cz }; }
|
|
}
|
|
return best;
|
|
}
|
|
}
|
|
|
|
module.exports = { ArenaRoom };
|