616 lines
16 KiB
JavaScript
Executable File
616 lines
16 KiB
JavaScript
Executable File
"use strict";
|
|
|
|
const express = require("express"),
|
|
crypto = require("crypto"),
|
|
{ readFile, writeFile } = require("fs").promises;
|
|
|
|
let gameDB;
|
|
|
|
require("../db/games").then(function(db) {
|
|
gameDB = db;
|
|
});
|
|
|
|
const router = express.Router();
|
|
|
|
function shuffle(array) {
|
|
var currentIndex = array.length, temporaryValue, randomIndex;
|
|
|
|
// While there remain elements to shuffle...
|
|
while (0 !== currentIndex) {
|
|
|
|
// Pick a remaining element...
|
|
randomIndex = Math.floor(Math.random() * currentIndex);
|
|
currentIndex -= 1;
|
|
|
|
// And swap it with the current element.
|
|
temporaryValue = array[currentIndex];
|
|
array[currentIndex] = array[randomIndex];
|
|
array[randomIndex] = temporaryValue;
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
const assetData = {
|
|
tiles: [
|
|
{ type: "wood", y: 0. / 4. },
|
|
{ type: "wood", y: 1. / 4. },
|
|
{ type: "wood", y: 2. / 4. },
|
|
{ type: "wood", y: 3. / 4. },
|
|
{ type: "wheat", y: 0. / 4. },
|
|
{ type: "wheat", y: 1. / 4. },
|
|
{ type: "wheat", y: 2. / 4. },
|
|
{ type: "wheat", y: 3. / 4. },
|
|
{ type: "stone", y: 0. / 4. },
|
|
{ type: "stone", y: 1. / 4. },
|
|
{ type: "stone", y: 2. / 4. },
|
|
{ type: "sheep", y: 0. / 4. },
|
|
{ type: "sheep", y: 1. / 4. },
|
|
{ type: "sheep", y: 2. / 4. },
|
|
{ type: "sheep", y: 3. / 4. },
|
|
{ type: "brick", y: 0. / 4. },
|
|
{ type: "brick", y: 1. / 4. },
|
|
{ type: "brick", y: 2. / 4. },
|
|
{ type: "robber", y: 0 }
|
|
],
|
|
pips: [
|
|
{ roll: 7, pips: 0, y: 3. / 6., x: 0. / 6. },
|
|
{ roll: 5, pips: 4, y: 0. / 6., x: 0. / 6. },
|
|
{ roll: 2, pips: 1, y: 0. / 6., x: 1. / 6. },
|
|
{ roll: 6, pips: 5, y: 0. / 6., x: 2. / 6. },
|
|
{ roll: 3, pips: 2, y: 0. / 6., x: 3. / 6. },
|
|
{ roll: 8, pips: 5, y: 0. / 6., x: 4. / 6. },
|
|
{ roll: 10, pips: 3, y: 0. / 6., x: 5. / 6. },
|
|
{ roll: 9, pips: 4, y: 1. / 6., x: 0. / 6. },
|
|
{ roll: 12, pips: 1, y: 1. / 6., x: 1. / 6. },
|
|
{ roll: 11, pips: 2, y: 1. / 6., x: 2. / 6. },
|
|
{ roll: 4, pips: 3, y: 1. / 6., x: 3. / 6. },
|
|
{ roll: 8, pips: 5, y: 1. / 6., x: 4. / 6. },
|
|
{ roll: 10, pips: 3, y: 1. / 6., x: 5. / 6. },
|
|
{ roll: 9, pips: 4, y: 2. / 6., x: 0. / 6. },
|
|
{ roll: 4, pips: 3, y: 2. / 6., x: 1. / 6. },
|
|
{ roll: 5, pips: 4, y: 2. / 6., x: 2. / 6. },
|
|
{ roll: 6, pips: 6, y: 2. / 6., x: 3. / 6. },
|
|
{ roll: 3, pips: 2, y: 2. / 6., x: 4. / 6. },
|
|
{ roll: 11, pips: 2, y: 2. / 6., x: 5. / 6. }
|
|
],
|
|
borders: [
|
|
{ file: 'borders-1.6.png', left: "sheep", right: "bank" },
|
|
{ file: 'borders-2.1.png', center: "sheep" },
|
|
{ file: 'borders-3.2.png', left: "wheat", right: "bank" },
|
|
{ file: 'borders-4.3.png', center: "wood" },
|
|
{ file: 'borders-5.4.png', left: "sheep", right: "bank" },
|
|
{ file: 'borders-6.5.png', center: "bank" }
|
|
],
|
|
developmentCards: []
|
|
};
|
|
for (let i = 0; i < 14; i++) {
|
|
assetData.developmentCards.push("knight");
|
|
}
|
|
for (let i = 0; i < 6; i++) {
|
|
assetData.developmentCards.push("progress");
|
|
}
|
|
for (let i = 0; i < 5; i++) {
|
|
assetData.developmentCards.push("victoryPoint");
|
|
}
|
|
|
|
const games = {};
|
|
|
|
const roll = (game, session) => {
|
|
let message;
|
|
|
|
const player = session.player,
|
|
name = session.name ? session.name : "Unnamed";
|
|
|
|
switch (game.state) {
|
|
case "lobby":
|
|
return `Rolling dice in the lobby is not allowed!`;
|
|
|
|
case "game-order":
|
|
if (player.order) {
|
|
return `Player ${name} already rolled for order.`;
|
|
}
|
|
game.dice = [ Math.ceil(Math.random() * 6) ];
|
|
player.order = game.dice[0];
|
|
message = `${name} rolled ${game.dice[0]} for play order.`;
|
|
game.chat.push({ date: Date.now(), message: message });
|
|
break;
|
|
|
|
case "active":
|
|
game.dice = [ Math.ceil(Math.random() * 6), Math.ceil(Math.random() * 6) ];
|
|
message = `${name} rolled ${game.dice[0] + game.dice[1]}.`;
|
|
game.chat.push({ date: Date.now(), message: message });
|
|
return;
|
|
|
|
default:
|
|
return `Invalid game state (${game.state}) in roll.`;
|
|
}
|
|
};
|
|
|
|
const getPlayer = (game, color) => {
|
|
if (!game) {
|
|
return {
|
|
roads: 15,
|
|
cities: 4,
|
|
settlements: 5,
|
|
points: 0,
|
|
status: "Not active",
|
|
lastActive: 0,
|
|
order: 0
|
|
};
|
|
}
|
|
|
|
return game.players[color];
|
|
};
|
|
|
|
const getSession = (game, session) => {
|
|
if (!game.sessions) {
|
|
game.sessions = {};
|
|
}
|
|
|
|
if (!session.player_id) {
|
|
session.player_id = crypto.randomBytes(32).toString('hex');
|
|
}
|
|
|
|
const id = session.player_id;
|
|
|
|
/* If this session is not yet in the game,
|
|
* add it and set the player's name */
|
|
if (!(id in game.sessions)) {
|
|
game.sessions[id] = {
|
|
name: undefined,
|
|
color: undefined,
|
|
player: undefined
|
|
};
|
|
}
|
|
|
|
return game.sessions[id];
|
|
};
|
|
|
|
const loadGame = async (id) => {
|
|
if (/^\.|\//.exec(id)) {
|
|
return undefined;
|
|
}
|
|
|
|
if (id in games) {
|
|
return games[id];
|
|
}
|
|
|
|
let game = await readFile(`games/${id}`)
|
|
.catch(() => {
|
|
return;
|
|
});
|
|
|
|
if (!game) {
|
|
game = createGame(id);
|
|
} else {
|
|
try {
|
|
game = JSON.parse(game);
|
|
} catch (error) {
|
|
console.error(error, game);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/* Reconnect session player colors to the player objects */
|
|
for (let id in game.sessions) {
|
|
const session = game.sessions[id];
|
|
if (session.color && session.color in game.players) {
|
|
session.player = game.players[session.color];
|
|
} else {
|
|
session.color = undefined;
|
|
session.player = undefined;
|
|
}
|
|
}
|
|
|
|
games[id] = game;
|
|
return game;
|
|
};
|
|
|
|
const clearPlayer = (player) => {
|
|
player.status = 'Not active';
|
|
player.lastActive = 0;
|
|
player.order = 0;
|
|
}
|
|
|
|
const adminActions = (game, action, value) => {
|
|
switch (action) {
|
|
case "kick":
|
|
let color;
|
|
switch (value) {
|
|
case 'orange': color = 'O'; break;
|
|
case 'red': color = 'R'; break;
|
|
case 'blue': color = 'B'; break;
|
|
case 'white': color = 'W'; break;
|
|
}
|
|
if (!color) {
|
|
return `Unable to find player ${value}`
|
|
}
|
|
|
|
const player = game.players[color];
|
|
for (let id in game.sessions) {
|
|
const session = game.sessions[id];
|
|
if (session.player !== player) {
|
|
continue;
|
|
}
|
|
console.log(`Kicking ${value} from ${game.id}.`);
|
|
const preamble = session.name ? `${session.name}, playing as ${color},` : color;
|
|
game.chat.push({
|
|
date: Date.now(),
|
|
message: `${preamble} was kicked from game by the Admin.`
|
|
});
|
|
if (player) {
|
|
session.player = undefined;
|
|
clearPlayer(player);
|
|
}
|
|
session.color = undefined;
|
|
return;
|
|
}
|
|
return `Unable to find active session for ${color} (${value})`;
|
|
|
|
default:
|
|
return `Invalid admin action ${action}.`;
|
|
}
|
|
};
|
|
|
|
const setPlayerName = (game, session, name) => {
|
|
if (session.color) {
|
|
return `You cannot change your name while you are in game.`;
|
|
}
|
|
|
|
/* Check to ensure name is not already in use */
|
|
if (game && name) for (let key in game.sessions) {
|
|
const tmp = game.sessions[key];
|
|
if (tmp.name && tmp.name.toLowerCase() === name.toLowerCase()) {
|
|
return `${name} is already taken.`;
|
|
}
|
|
}
|
|
|
|
const old = session.name;
|
|
let message;
|
|
|
|
session.name = name;
|
|
|
|
if (name) {
|
|
if (!old) {
|
|
message = `A new player has entered the lobby as ${name}.`;
|
|
} else {
|
|
message = `${old} has changed their name to ${name}.`;
|
|
}
|
|
} else {
|
|
return `You can not set your name to nothing!`;
|
|
}
|
|
|
|
game.chat.push({
|
|
date: Date.now(),
|
|
message: message
|
|
});
|
|
}
|
|
|
|
const setPlayerColor = (game, session, color) => {
|
|
if (!game) {
|
|
return `No game found`;
|
|
}
|
|
|
|
const name = session.name, player = session.player;
|
|
|
|
/* Selecting the same color is a NO-OP */
|
|
if (session.color === color) {
|
|
return;
|
|
}
|
|
|
|
if (player) {
|
|
/* Deselect currently active player for this session */
|
|
clearPlayer(player);
|
|
game.chat.push({
|
|
date: Date.now(),
|
|
message: `${name} is no longer ${session.color}.`
|
|
});
|
|
session.player = undefined;
|
|
session.color = undefined;
|
|
}
|
|
|
|
/* Verify the player has a name set */
|
|
if (!name) {
|
|
return `You may only select a player when you have set your name.`;
|
|
}
|
|
|
|
/* If the player is not selecting a color, then return */
|
|
if (!color) {
|
|
return;
|
|
}
|
|
|
|
/* Verify selection is valid */
|
|
if (!(color in game.players)) {
|
|
return `An invalid player selection was attempted.`;
|
|
}
|
|
|
|
/* Verify selection is not already taken */
|
|
for (let key in game.sessions) {
|
|
const tmp = game.sessions[key].player;
|
|
if (tmp && tmp.color === color) {
|
|
return `${game.sessions[key].name} already has ${color}`;
|
|
}
|
|
}
|
|
|
|
/* All good -- set this player to requested selection */
|
|
session.player = getPlayer(game, color);
|
|
|
|
session.player.status = `Active`;
|
|
session.player.lastActive = Date.now();
|
|
session.color = color;
|
|
game.chat.push({
|
|
date: Date.now(),
|
|
message: `${session.name} has chosen to play as ${color}.`
|
|
});
|
|
};
|
|
|
|
router.put("/:id/:action/:value?", async (req, res) => {
|
|
const { action, id } = req.params,
|
|
value = req.params.value ? req.params.value : "";
|
|
console.log(`PUT games/${id}/${action}/${value}`);
|
|
|
|
const game = await loadGame(id);
|
|
if (!game) {
|
|
const error = `Game not found and cannot be created: ${id}`;
|
|
return res.status(404).send(error);
|
|
}
|
|
|
|
let error;
|
|
|
|
if ('private-token' in req.headers) {
|
|
if (req.headers['private-token'] !== req.app.get('admin')) {
|
|
error = `Invalid admin credentials.`;
|
|
} else {
|
|
error = adminActions(game, action, value);
|
|
}
|
|
return sendGame(req, res, game, error);
|
|
}
|
|
|
|
const session = getSession(game, req.session);
|
|
|
|
switch (action) {
|
|
case 'player-name':
|
|
error = setPlayerName(game, session, value);
|
|
return sendGame(req, res, game, error);
|
|
case 'player-selected':
|
|
error = setPlayerColor(game, session, value);
|
|
return sendGame(req, res, game, error);
|
|
}
|
|
|
|
if (!session.player) {
|
|
error = `Player must have an active color.`;
|
|
return sendGame(req, res, game, error);
|
|
}
|
|
|
|
const name = session.name;
|
|
|
|
switch (action) {
|
|
case "roll":
|
|
error = roll(game, session);
|
|
break;
|
|
case "shuffle":
|
|
if (game.state !== "lobby") {
|
|
error = `Game no longer in lobby (${game.state}). Can not shuffle board.`;
|
|
}
|
|
if (!error && game.turns > 0) {
|
|
error = `Game already in progress (${game.turns} so far!) and cannot be shuffled.`;
|
|
}
|
|
if (!error) {
|
|
shuffleBoard(game);
|
|
const message = `${name} requested a new board.`;
|
|
game.chat.push({ date: Date.now(), message: message });
|
|
console.log(message);
|
|
}
|
|
break
|
|
case "state":
|
|
const state = value;
|
|
if (!state) {
|
|
error = `Invalid state.`;
|
|
} else if (state != game.state) {
|
|
game.state = state;
|
|
const message = `${name} set game state to ${state}.`;
|
|
game.chat.push({ date: Date.now(), message: message });
|
|
}
|
|
break;
|
|
}
|
|
|
|
return sendGame(req, res, game, error);
|
|
})
|
|
|
|
router.get("/:id", async (req, res/*, next*/) => {
|
|
const { id } = req.params;
|
|
console.log("GET games/" + id);
|
|
|
|
let game = await loadGame(id);
|
|
if (game) {
|
|
return sendGame(req, res, game)
|
|
}
|
|
|
|
game = createGame(id);
|
|
|
|
return sendGame(req, res, game);
|
|
});
|
|
|
|
router.put("/:id", (req, res/*, next*/) => {
|
|
const { id } = req.params;
|
|
|
|
console.log("PUT games/" + id);
|
|
if (!(id in games)) {
|
|
const error = `Game not found: ${req.params.id}`;
|
|
return res.status(404).send(error);
|
|
}
|
|
|
|
const game = games[id],
|
|
changes = req.body;
|
|
|
|
for (let change in changes) {
|
|
switch (change) {
|
|
case "chat":
|
|
console.log("Chat change.");
|
|
game.chat.push({
|
|
from: changes.chat.player,
|
|
date: Date.now(),
|
|
message: changes.chat.message
|
|
});
|
|
if (game.chat.length > 10) {
|
|
game.chat.splice(0, game.chat.length - 10);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return sendGame(req, res, game);
|
|
});
|
|
|
|
const sendGame = async (req, res, game, error) => {
|
|
let active = 0;
|
|
for (let color in game.players) {
|
|
const player = game.players[color];
|
|
active += ((player.status && player.status != 'Not active') ? 1 : 0);
|
|
}
|
|
if (active < 2 && game.state != 'lobby' && game.state != 'invalid') {
|
|
let message = "Insufficient players in game. Setting back to lobby."
|
|
game.chat.push({ date: Date.now(), message: message });
|
|
console.log(message);
|
|
game.state = 'lobby';
|
|
}
|
|
game.active = active;
|
|
|
|
let session;
|
|
if (req.session) {
|
|
session = getSession(game, req.session);
|
|
session.lastActive = Date.now();
|
|
if (session.player) {
|
|
session.player.lastActive = session.lastActive;
|
|
}
|
|
} else {
|
|
session = {
|
|
name: "command line"
|
|
};
|
|
}
|
|
|
|
/* Shallow copy game, filling its sessions with a shallow copy of sessions so we can then
|
|
* delete the player field from them */
|
|
const reducedGame = Object.assign({}, game, { sessions: {} }),
|
|
reducedSessions = [];
|
|
|
|
for (let id in game.sessions) {
|
|
const reduced = Object.assign({}, game.sessions[id]);
|
|
if (reduced.player) {
|
|
delete reduced.player;
|
|
}
|
|
reducedGame.sessions[id] = reduced;
|
|
|
|
/* Do not send session-id as those are secrets */
|
|
reducedSessions.push(reduced);
|
|
}
|
|
|
|
await writeFile(`games/${game.id}`, JSON.stringify(reducedGame, null, 2))
|
|
.catch((error) => {
|
|
console.error(`Unable to write to games/${game.id}`);
|
|
console.error(error);
|
|
});
|
|
|
|
const playerGame = Object.assign({}, reducedGame, {
|
|
timestamp: Date.now(),
|
|
status: error ? error : "success",
|
|
name: session.name,
|
|
color: session.color,
|
|
order: (session.color in game.players) ? game.players[session.color].order : 0,
|
|
sessions: reducedSessions
|
|
});
|
|
|
|
return res.status(200).send(playerGame);
|
|
}
|
|
|
|
const createGame = (id) => {
|
|
id = id ? id : crypto.randomBytes(8).toString('hex');
|
|
const game = {
|
|
startTime: Date.now(),
|
|
turns: 0,
|
|
state: "lobby", /* lobby, active, finished */
|
|
tiles: [],
|
|
pips: [],
|
|
borders: [],
|
|
tokens: [],
|
|
players: {
|
|
R: getPlayer(),
|
|
O: getPlayer(),
|
|
B: getPlayer(),
|
|
W: getPlayer()
|
|
},
|
|
developmentCards: assetData.developmentCards.slice(),
|
|
dice: [ 0, 0 ],
|
|
sheep: 19,
|
|
ore: 19,
|
|
wool: 19,
|
|
brick: 19,
|
|
wheat: 19,
|
|
longestRoad: null,
|
|
largestArmy: null,
|
|
chat: [ { date: Date.now(), message: `New game started for ${id}` } ],
|
|
id: id
|
|
};
|
|
games[game.id] = game;
|
|
shuffleBoard(game);
|
|
console.log(`New game created: ${game.id}`);
|
|
return game;
|
|
};
|
|
|
|
router.post("/:id?", (req, res/*, next*/) => {
|
|
console.log("POST games/");
|
|
const { id } = req.params;
|
|
if (id && id in games) {
|
|
const error = `Can not create new game for ${id} -- it already exists.`
|
|
console.error(error);
|
|
return res.status(400).send(error);
|
|
}
|
|
|
|
const game = createGame(id);
|
|
|
|
return sendGame(req, res, game);
|
|
});
|
|
|
|
const shuffleBoard = (game) => {
|
|
[ "tiles", "pips", "borders" ].forEach((field) => {
|
|
game[field] = []
|
|
for (let i = 0; i < assetData[field].length; i++) {
|
|
game[field].push(i);
|
|
}
|
|
/* Shuffle an array of indexes */
|
|
shuffle(game[field]);
|
|
/* Convert from an index array to a full array */
|
|
for (let i = 0; i < assetData[field].length; i++) {
|
|
game[field][i] = assetData[field][game[field][i]];
|
|
}
|
|
});
|
|
|
|
shuffle(game.developmentCards)
|
|
}
|
|
|
|
/*
|
|
return gameDB.sequelize.query("SELECT " +
|
|
"photos.*,albums.path AS path,photohashes.hash,modified,(albums.path || photos.filename) AS filepath FROM photos " +
|
|
"LEFT JOIN albums ON albums.id=photos.albumId " +
|
|
"LEFT JOIN photohashes ON photohashes.photoId=photos.id " +
|
|
"WHERE photos.id=:id", {
|
|
replacements: {
|
|
id: id
|
|
}, type: gameDB.Sequelize.QueryTypes.SELECT,
|
|
raw: true
|
|
}).then(function(photos) {
|
|
if (photos.length == 0) {
|
|
return null;
|
|
}
|
|
*/
|
|
if (0) {
|
|
router.get("/*", (req, res/*, next*/) => {
|
|
return gameDB.sequelize.query(query, {
|
|
replacements: replacements, type: gameDB.Sequelize.QueryTypes.SELECT
|
|
}).then((photos) => {
|
|
});
|
|
});
|
|
}
|
|
|
|
module.exports = router;
|