317 lines
8.4 KiB
JavaScript
317 lines
8.4 KiB
JavaScript
import { Packet } from "./packet.js";
|
|
import { socket } from "./main.js";
|
|
|
|
// Timeout to consider a player disconnected
|
|
const TIMEOUT = 30_000;
|
|
|
|
const PHASE_REINFORCE = 1;
|
|
const PHASE_ATTACK = 2;
|
|
const PHASE_FORTIFY = 3;
|
|
|
|
let totalDice = 0;
|
|
|
|
export class Player {
|
|
constructor(id, local) {
|
|
this.timeout = null;
|
|
this.id = id;
|
|
this.ready = false;
|
|
|
|
// Data which is reset every turn
|
|
this.isPlaying = false;
|
|
this.reinforcementsPlaced = 0;
|
|
this.reinforcementsAvailable = 0;
|
|
this.offenderRegion = null;
|
|
this.turnPhase = PHASE_REINFORCE;
|
|
|
|
// Data for defending
|
|
this.defenderPromise = null;
|
|
this.defenderAmount = null;
|
|
|
|
this.resetColor();
|
|
|
|
if (local) {
|
|
// Emit keepalive messages to inform other players we are still here
|
|
window.setInterval(() => {
|
|
socket.emit("message", Packet.createKeepAlive());
|
|
}, TIMEOUT / 2);
|
|
}
|
|
}
|
|
|
|
resetTimeout(game) {
|
|
if (this.timeout !== null) {
|
|
window.clearTimeout(this.timeout);
|
|
}
|
|
|
|
this.timeout = window.setTimeout(() => {
|
|
game.removePlayer(this);
|
|
}, TIMEOUT);
|
|
}
|
|
|
|
/**
|
|
* Get our color as used on the board.
|
|
*/
|
|
getColor() {
|
|
return this.color;
|
|
}
|
|
|
|
resetColor() {
|
|
let randomColor = Math.random() * 360;
|
|
this.color = `hsl(${randomColor} 57% 50%)`;
|
|
}
|
|
|
|
/**
|
|
* Claim a region of the map.
|
|
*
|
|
* @param data Data received via socket.
|
|
*/
|
|
claim(data) {
|
|
let region = Region.getRegion(data.region);
|
|
|
|
if (region.owner === null) {
|
|
region.claim(this);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reinforce a region of the map.
|
|
*
|
|
* @param data Data received via socket.
|
|
*/
|
|
reinforce(data) {
|
|
let region = Region.getRegion(data.region);
|
|
|
|
if (region.owner === this) {
|
|
region.reinforce(1);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Process a generic action packet representing a player's move.
|
|
*
|
|
* @param data Data received via socket
|
|
* @returns {boolean} Whether this player's turn has ended or not.
|
|
*/
|
|
async act(data) {
|
|
console.log(`player: ${this.id}`);
|
|
console.log(data);
|
|
|
|
if (this.turnPhase === PHASE_REINFORCE) {
|
|
if (data.region !== undefined) {
|
|
if (this.reinforce(data)) {
|
|
this.reinforcementsPlaced += 1;
|
|
}
|
|
|
|
if (this.reinforcementsPlaced === this.reinforcementsAvailable) {
|
|
this.turnPhase = PHASE_ATTACK;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
} else {
|
|
// End turn prematurely.
|
|
if (data.action === "END") {
|
|
return true;
|
|
}
|
|
|
|
if (this.turnPhase === PHASE_ATTACK && data.action === "ATTACK") {
|
|
await this.attack(data);
|
|
return false;
|
|
}
|
|
|
|
this.turnPhase = PHASE_FORTIFY;
|
|
|
|
if (data.action === "FORTIFY") {
|
|
return this.fortify(data);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Process an action which is to attack another region.
|
|
*
|
|
* @param data Data received via socket
|
|
*/
|
|
async attack(data) {
|
|
let offender = Region.getRegion(data.startRegion);
|
|
let defender = Region.getRegion(data.endRegion);
|
|
let offenderStrength = parseInt(data.strength);
|
|
|
|
// Basic validation on game state
|
|
if (
|
|
offender.owner !== this ||
|
|
defender.owner === this ||
|
|
offenderStrength > 3 ||
|
|
offenderStrength <= 0 ||
|
|
offenderStrength >= offender.strength ||
|
|
(this.offenderRegion !== null && this.offenderRegion !== offender)
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
// If we're the defender, we need to send a packet to state our defense.
|
|
if (defender.owner === us) {
|
|
showDefenseDom(defender.name);
|
|
}
|
|
|
|
// Grab the defense amount from
|
|
let defenderStrength = 0;
|
|
while (
|
|
defenderStrength <= 0 ||
|
|
defenderStrength > Math.min(2, defender.strength)
|
|
) {
|
|
defenderStrength = await defender.owner.getDefense();
|
|
}
|
|
|
|
/* How do Risk attacks work?
|
|
- Offender signs 1-3 armies, defender signs 1-2 armies
|
|
- Both roll respective dice
|
|
- Compare pairs of highest die in the rolls to remove armies.
|
|
*/
|
|
|
|
if (this.offenderRegion === null) {
|
|
this.offenderRegion = offender;
|
|
}
|
|
|
|
let offenderRolls = [];
|
|
let defenderRolls = [];
|
|
|
|
// Get random values
|
|
for (let i = 0; i < offenderStrength; i++) {
|
|
offenderRolls.push(await random.get(6, `dice-${totalDice}`));
|
|
totalDice += 1;
|
|
}
|
|
|
|
for (let i = 0; i < defenderStrength; i++) {
|
|
defenderRolls.push(await random.get(6, `dice-${totalDice}`));
|
|
totalDice += 1;
|
|
}
|
|
|
|
console.log(`attacker rolls: ${offenderRolls}`);
|
|
console.log(`defender rolls: ${defenderRolls}`);
|
|
|
|
offenderRolls.sort();
|
|
defenderRolls.sort();
|
|
|
|
// Compare and settle.
|
|
while (offenderRolls.length * defenderRolls.length > 0) {
|
|
let offenderResult = offenderRolls.pop();
|
|
let defenderResult = defenderRolls.pop();
|
|
|
|
if (offenderResult > defenderResult) {
|
|
defender.strength -= 1;
|
|
} else {
|
|
offender.strength -= 1;
|
|
}
|
|
|
|
if (defender.strength === 0) {
|
|
defender.strength = offenderRolls.length + 1;
|
|
offender.strength -= offenderRolls.length + 1;
|
|
defender.owner = this;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Reset the promises in case they attack again.
|
|
defender.owner.defenderPromise = null;
|
|
defender.owner.defenderAmount = null;
|
|
|
|
updateDom();
|
|
}
|
|
|
|
async setDefense(amount) {
|
|
await navigator.locks.request("defender", () => {
|
|
this.defenderAmount = amount;
|
|
if (this.defenderPromise !== null) {
|
|
this.defenderPromise(amount);
|
|
}
|
|
});
|
|
}
|
|
|
|
async getDefense() {
|
|
let promise, resolver;
|
|
await navigator.locks.request("defender", () => {
|
|
if (this.defenderAmount === null) {
|
|
promise = new Promise((resolve) => {
|
|
resolver = resolve;
|
|
});
|
|
this.defenderPromise = resolver;
|
|
} else {
|
|
promise = new Promise((resolve) => {
|
|
resolve(this.defenderAmount);
|
|
});
|
|
}
|
|
});
|
|
return promise;
|
|
}
|
|
|
|
/**
|
|
* Process an action which is to attack another region.
|
|
*
|
|
* @param data Data received via socket
|
|
*/
|
|
fortify(data) {
|
|
let sender = Region.getRegion(data.startRegion);
|
|
let receiver = Region.getRegion(data.endRegion);
|
|
let strength = parseInt(data.strength);
|
|
|
|
if (
|
|
sender.owner === this &&
|
|
receiver.owner === this &&
|
|
sender.strength > strength &&
|
|
strength > 0
|
|
) {
|
|
receiver.reinforce(strength);
|
|
sender.strength -= strength;
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calculate the number of additional reinforcements to gain on this turn.
|
|
*/
|
|
additionalReinforcements() {
|
|
return Math.min(
|
|
3,
|
|
Math.floor(
|
|
Object.values(REGIONS).filter((region) => region.owner === this).length /
|
|
3
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Start a player's turn.
|
|
*/
|
|
startTurn() {
|
|
this.isPlaying = true;
|
|
this.reinforcementsPlaced = 0;
|
|
this.reinforcementsAvailable = this.additionalReinforcements();
|
|
this.offenderRegion = null;
|
|
this.turnPhase = PHASE_REINFORCE;
|
|
}
|
|
|
|
/**
|
|
* End player's turn
|
|
*/
|
|
endTurn() {
|
|
this.isPlaying = false;
|
|
this.nextPlayer().startTurn();
|
|
}
|
|
|
|
nextPlayer() {
|
|
let sorted = Object.values(players).sort((a, b) => (a.id < b.id ? -1 : 1));
|
|
let ourIndex = sorted.findIndex((player) => player.id === this.id);
|
|
|
|
return sorted[(ourIndex + 1) % sorted.length];
|
|
}
|
|
}
|