9e5f83df37
7 factions already implemented: - Norther Realms - Nilfgaard Empire - Scoia'Tael - Monsters - Skellige - Redenia - Toussaint In progress: - Velen To do: - Witchers - Wild Hunt
5775 lines
223 KiB
JavaScript
5775 lines
223 KiB
JavaScript
"use strict"
|
|
|
|
class Controller { }
|
|
|
|
var nilfgaard_wins_draws = false;
|
|
|
|
// Makes decisions for the AI opponent player
|
|
class ControllerAI {
|
|
constructor(player) {
|
|
this.player = player;
|
|
}
|
|
|
|
// Computes the weights of the given cards
|
|
getWeights(cards) {
|
|
let data_max = this.getMaximums();
|
|
let data_board = this.getBoardData();
|
|
return cards.map(c =>
|
|
({
|
|
weight: this.weightCard(c, data_max, data_board),
|
|
card: c
|
|
}));
|
|
}
|
|
|
|
// Return the card among the provided list having the highest weight
|
|
getHighestWeightCard(cards) {
|
|
let w = this.getWeights(cards).sort((a, b) => (b.weight - a.weight));
|
|
if (w.length > 0) {
|
|
return w[0].card;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Return the card among the provided list having the lowest weight
|
|
getLowestWeightCard(cards) {
|
|
let w = this.getWeights(cards).sort((a, b) => (a.weight - b.weight));
|
|
if (w.length > 0) {
|
|
return w[0].card;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Collects data and weighs options before taking a weighted random action
|
|
async startTurn(player) {
|
|
let data_max = this.getMaximums();
|
|
let data_board = this.getBoardData();
|
|
// In case of a forced action, play it if positive weight, pass otherwise
|
|
if (player.forcedActions.length > 0) {
|
|
let card = player.forcedActions.splice(0, 1)[0];
|
|
let w = this.weightCard(card, data_max, data_board);
|
|
if (w > 0) {
|
|
await this.playCard(card, data_max, data_board)
|
|
} else {
|
|
await player.passRound();
|
|
}
|
|
return;
|
|
}
|
|
if (player.opponent().passed && (player.winning || player.deck.faction === "nilfgaard" && player.total === player.opponent().total)) {
|
|
nilfgaard_wins_draws = player.deck.faction === "nilfgaard" && player.total === player.opponent().total;
|
|
await player.passRound();
|
|
return;
|
|
}
|
|
|
|
let weights = player.hand.cards.map(c =>
|
|
({
|
|
weight: this.weightCard(c, data_max, data_board),
|
|
action: async () => await this.playCard(c, data_max, data_board),
|
|
card: c
|
|
}));
|
|
|
|
// If the opponent has passed and is not too far ahead, let's try to take the win
|
|
let diff = player.opponent().total - player.total;
|
|
if (player.opponent().passed && diff < 16) {
|
|
// Looking for a one shot that isn't overkill
|
|
let oneshot = weights.filter(w => (w.card.basePower > diff && w.card.basePower < diff + 5) || (w.weight > diff && w.weight > diff + 5));
|
|
if (oneshot.length > 0) {
|
|
let oneshot_card = oneshot.sort((a, b) => (a.weight - b.weight))[0];
|
|
await oneshot_card.action();
|
|
return;
|
|
}
|
|
// Can we catch up in 2 plays?
|
|
let playable = weights.filter(w => w.weight > 0).sort((a, b) => (b.weight - a.weight));
|
|
if (playable.length > 2)
|
|
playable = playable.slice(0, 2);
|
|
let weightTotal = playable.reduce((a, c) => a + c.weight, 0);
|
|
if (weightTotal > diff) {
|
|
await playable[0].action();
|
|
return;
|
|
}
|
|
}
|
|
if (player.leaderAvailable)
|
|
weights.push({
|
|
name: "Leader Ability",
|
|
weight: this.weightLeader(player.leader, data_max, data_board),
|
|
action: async () => {
|
|
await ui.notification("op-leader", 1200);
|
|
await player.activateLeader();
|
|
}
|
|
});
|
|
if (player.factionAbilityUses > 0) {
|
|
let factionAbility = factions[player.deck.faction];
|
|
weights.push({
|
|
name: "Faction ability",
|
|
weight: factionAbility.weight(player),
|
|
action: async () => {
|
|
await player.useFactionAbility();
|
|
}
|
|
});
|
|
}
|
|
weights.push({
|
|
name: "Pass",
|
|
weight: this.weightPass(),
|
|
action: async () => await player.passRound()
|
|
});
|
|
let weightTotal = weights.reduce((a, c) => a + c.weight, 0);
|
|
if (weightTotal === 0) {
|
|
for (let i = 0; i < player.hand.cards.length; ++i) {
|
|
let card = player.hand.cards[i];
|
|
if (card.row === "weather" && this.weightWeather(card) > -1 || card.abilities.includes("avenger")) {
|
|
await weights[i].action();
|
|
return;
|
|
}
|
|
}
|
|
await player.passRound();
|
|
} else {
|
|
for (var i = 0; i < weights.length; ++i) {
|
|
if (weights[i].card)
|
|
console.log("[" + weights[i].card.name + "] Weight: " + weights[i].weight);
|
|
else
|
|
console.log("[" + weights[i].name + "] Weight: " + weights[i].weight);
|
|
}
|
|
let rand = randomInt(weightTotal);
|
|
console.log("Chosen weight: " + rand);
|
|
for (var i = 0; i < weights.length; ++i) {
|
|
rand -= weights[i].weight;
|
|
if (rand < 0)
|
|
break;
|
|
}
|
|
console.log(weights[i]);
|
|
await weights[i].action();
|
|
}
|
|
}
|
|
|
|
isSelfRowIndex(i) {
|
|
return (this.player === player_me && i > 2) || (this.player === player_op && i < 3);
|
|
}
|
|
|
|
getSelfRowIndexes() {
|
|
if (this.player === player_me)
|
|
return [3, 4, 5];
|
|
return [0, 1, 2];
|
|
}
|
|
|
|
// Collects data about card with the hightest power on the board
|
|
getMaximums() {
|
|
let rmax = board.row.map(r => ({
|
|
row: r,
|
|
cards: r.cards.filter(c => c.isUnit() && !c.isImmortal()).reduce((a, c) =>
|
|
(!a.length || a[0].power < c.power) ? [c] : a[0].power === c.power ? a.concat([c]) : a, [])
|
|
}));
|
|
|
|
let max = rmax.filter((r, i) => r.cards.length && this.isSelfRowIndex(i)).reduce((a, r) => Math.max(a, r.cards[0].power), 0);
|
|
let max_me = rmax.filter((r, i) => this.isSelfRowIndex(i) && r.cards.length && r.cards[0].power === max).reduce((a, r) =>
|
|
a.concat(r.cards.map(c => ({
|
|
row: r,
|
|
card: c
|
|
}))), []);
|
|
|
|
max = rmax.filter((r, i) => r.cards.length && !this.isSelfRowIndex(i)).reduce((a, r) => Math.max(a, r.cards[0].power), 0);
|
|
let max_op = rmax.filter((r, i) => !this.isSelfRowIndex(i) && r.cards.length && r.cards[0].power === max).reduce((a, r) =>
|
|
a.concat(r.cards.map(c => ({
|
|
row: r,
|
|
card: c
|
|
}))), []);
|
|
|
|
// Also compute for rows without a shield
|
|
let rmax_noshield = rmax.filter((r, i) => !r.row.isShielded());
|
|
let max_noshield = rmax_noshield.filter((r, i) => r.cards.length && this.isSelfRowIndex(i)).reduce((a, r) => Math.max(a, r.cards[0].power), 0);
|
|
let max_me_noshield = rmax_noshield.filter((r, i) => this.isSelfRowIndex(i) && r.cards.length && r.cards[0].power === max_noshield).reduce((a, r) =>
|
|
a.concat(r.cards.map(c => ({
|
|
row: r,
|
|
card: c
|
|
}))), []);
|
|
|
|
max_noshield = rmax_noshield.filter((r, i) => r.cards.length && !this.isSelfRowIndex(i)).reduce((a, r) => Math.max(a, r.cards[0].power), 0);
|
|
let max_op_noshield = rmax_noshield.filter((r, i) => !this.isSelfRowIndex(i) && r.cards.length && r.cards[0].power === max_noshield).reduce((a, r) =>
|
|
a.concat(r.cards.map(c => ({
|
|
row: r,
|
|
card: c
|
|
}))), []);
|
|
|
|
return {
|
|
rmax: rmax,
|
|
me: max_me,
|
|
op: max_op,
|
|
rmax_noshield: rmax_noshield,
|
|
me_noshield: max_me_noshield,
|
|
op_noshield: max_op_noshield
|
|
};
|
|
}
|
|
|
|
// Collects data about the types of cards on the board and in each player's graves
|
|
getBoardData() {
|
|
let data = this.countCards(new CardContainer());
|
|
this.player.getAllRows().forEach(r => this.countCards(r, data));
|
|
data.grave_me = this.countCards(this.player.grave);
|
|
data.grave_op = this.countCards(this.player.opponent().grave);
|
|
return data;
|
|
}
|
|
|
|
// Catalogs the kinds of cards in a given CardContainer
|
|
countCards(container, data) {
|
|
data = data ? data : {
|
|
spy: [],
|
|
medic: [],
|
|
bond: {},
|
|
scorch: []
|
|
};
|
|
container.cards.filter(c => c.isUnit()).forEach(c => {
|
|
for (let x of c.abilities) {
|
|
if (!c.isLocked()) {
|
|
switch (x) {
|
|
case "spy":
|
|
case "medic":
|
|
data[x].push(c);
|
|
break;
|
|
case "scorch_r":
|
|
case "scorch_c":
|
|
case "scorch_s":
|
|
data["scorch"].push(c);
|
|
break;
|
|
case "bond":
|
|
if (!data.bond[c.target])
|
|
data.bond[c.target] = 0;
|
|
data.bond[c.target]++;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return data;
|
|
}
|
|
|
|
// Swaps a card from the hand with the deck if beneficial
|
|
redraw() {
|
|
let card = this.discardOrder({
|
|
holder: this.player
|
|
}).shift();
|
|
if (card && card.power < 15) {
|
|
this.player.deck.swap(this.player.hand, this.player.hand.removeCard(card));
|
|
}
|
|
}
|
|
|
|
// Orders discardable cards from most to least discardable
|
|
discardOrder(card, src = null, force = false) {
|
|
let cards = [];
|
|
let groups = {};
|
|
let source = src ? src : card.holder.hand;
|
|
|
|
let musters = source.cards.filter(c => c.abilities.includes("muster"));
|
|
// Grouping Musters together
|
|
musters.forEach(curr => {
|
|
let name = curr.target;
|
|
if (!groups[name])
|
|
groups[name] = [];
|
|
groups[name].push(curr);
|
|
});
|
|
// Keeping one in hand for each muster group
|
|
for (let group of Object.values(groups)) {
|
|
group.sort(Card.compare);
|
|
group.pop();
|
|
cards.push(...group);
|
|
}
|
|
|
|
// Targets of muster that do not have the ability themselves for which we already have the "summoner"
|
|
let tmusters = source.cards.filter(c => Object.keys(groups).includes(c.target) && !c.abilities.includes("muster"));
|
|
cards.push(...tmusters);
|
|
|
|
// Discarding randomly weather cards to keep only 1 in hand
|
|
let weathers = source.cards.filter(c => c.row === "weather");
|
|
if (weathers.length > 1) {
|
|
weathers.splice(randomInt(weathers.length), 1);
|
|
cards.push(...weathers);
|
|
}
|
|
// Discarding cards with no abilities by order of strength, unless they are of 7+
|
|
let normal = source.cards.filter(c => c.abilities.length === 0 && c.basePower < 7);
|
|
normal.sort(Card.compare);
|
|
cards.push(...normal);
|
|
|
|
// Grouping bonds together
|
|
let bonds = source.cards.filter(c => c.abilities.includes("bond"));
|
|
groups = {};
|
|
bonds.forEach(curr => {
|
|
let name = curr.target;
|
|
if (!groups[name])
|
|
groups[name] = [];
|
|
groups[name].push(curr);
|
|
});
|
|
// Discarding those that are alone and weak (< 6)
|
|
for (let group of Object.values(groups)) {
|
|
if (group.length === 1 && group[0].basePower < 6) {
|
|
cards.push(group[0]);
|
|
}
|
|
}
|
|
|
|
// In this mode, we force all cards to be ordered - let's add remaining ones by order of basePower
|
|
if (force) {
|
|
source.cards.sort((a, b) => a.basePower - b.basePower).forEach(c => {
|
|
if (cards.indexOf(c) < 0)
|
|
cards.push(c);
|
|
});
|
|
}
|
|
|
|
return cards;
|
|
}
|
|
|
|
// Tells the Player that this object controls to play a card
|
|
async playCard(c, max, data) {
|
|
if (c.key === "spe_horn")
|
|
await this.horn(c);
|
|
else if (c.key === "spe_mardroeme")
|
|
await this.mardroeme(c);
|
|
else if (c.abilities.includes("decoy"))
|
|
await this.decoy(c, max, data);
|
|
else if (c.faction === "special" && c.abilities.includes("scorch"))
|
|
await this.scorch(c, max, data);
|
|
else if (c.faction === "special" && c.abilities.includes("cintra_slaughter"))
|
|
await this.slaughterCintra(c);
|
|
else if (c.faction === "special" && c.abilities.includes("seize"))
|
|
await this.seizeCards(c);
|
|
else if (c.faction === "special" && (c.abilities.includes("shield") || c.abilities.includes("shield_c") || c.abilities.includes("shield_r") || c.abilities.includes("shield_s")))
|
|
await this.shieldCards(c);
|
|
else if (c.faction === "special" && c.abilities.includes("lock"))
|
|
await this.lock(c);
|
|
else if (c.faction === "special" && c.abilities.includes("curse"))
|
|
await this.curse(c);
|
|
else if (c.faction === "special" && c.abilities.includes("knockback"))
|
|
await this.knockback(c);
|
|
else if (c.faction === "special" && c.abilities.includes("toussaint_wine"))
|
|
await this.toussaintWine(c);
|
|
else if ((c.isUnit() || c.hero) && c.abilities.includes("witch_hunt"))
|
|
await this.witchHunt(c);
|
|
else if ((c.isUnit() || c.hero) && c.row.includes("agile") && (c.abilities.includes("morale") || c.abilities.includes("horn") || c.abilities.includes("bond") ))
|
|
await this.player.playCardToRow(c, this.bestAgileRowChange(c).row);
|
|
else if (c.faction === "special" && c.abilities.includes("bank"))
|
|
await this.bank(c);
|
|
else if (c.faction === "special" && c.abilities.includes("skellige_fleet"))
|
|
await this.skelligeFleet(c);
|
|
else if (c.faction === "special" && c.abilities.includes("royal_decree"))
|
|
await this.royalDecree(c);
|
|
else
|
|
await this.player.playCard(c);
|
|
}
|
|
|
|
// Plays a Commander's Horn to the most beneficial row. Assumes at least one viable row.
|
|
async horn(card) {
|
|
let rows = this.player.getAllRows().filter(r => !r.special.containsCardByKey("spe_horn"));
|
|
let max_row;
|
|
let max = 0;
|
|
for (let i = 0; i < rows.length; ++i) {
|
|
let r = rows[i];
|
|
let dif = [0, 0];
|
|
this.calcRowPower(r, dif, true);
|
|
r.effects.horn++;
|
|
this.calcRowPower(r, dif, false);
|
|
r.effects.horn--;
|
|
let score = dif[1] - dif[0];
|
|
if (max < score) {
|
|
max = score;
|
|
max_row = r;
|
|
}
|
|
}
|
|
await this.player.playCardToRow(card, max_row);
|
|
}
|
|
|
|
// Plays a Mardroeme to the most beneficial row. Assumes at least one viable row.
|
|
async mardroeme(card) {
|
|
let row, max = 0;
|
|
this.getSelfRowIndexes().forEach(i => {
|
|
let curr = this.weightMardroemeRow(card, board.row[i]);
|
|
if (curr > max) {
|
|
max = curr;
|
|
row = board.row[i];
|
|
}
|
|
});
|
|
await this.player.playCardToRow(card, row);
|
|
}
|
|
|
|
// Selects a card to remove from a Grave. Assumes at least one valid card.
|
|
medic(card, grave) {
|
|
let data = this.countCards(grave);
|
|
let targ;
|
|
if (data.spy.length) {
|
|
let min = data.spy.reduce((a, c) => Math.min(a, c.power), Number.MAX_VALUE);
|
|
targ = data.spy.filter(c => c.power === min)[0];
|
|
} else if (data.medic.length) {
|
|
let max = data.medic.reduce((a, c) => Math.max(a, c.power), 0);
|
|
targ = data.medic.filter(c => c.power === max)[0];
|
|
} else if (data.scorch.length) {
|
|
targ = data.scorch[randomInt(data.scorch.length)];
|
|
} else {
|
|
let units = grave.findCards(c => c.isUnit());
|
|
targ = units.reduce((a, c) => a.power < c.power ? c : a, units[0]);
|
|
}
|
|
return targ;
|
|
}
|
|
|
|
// Selects a card to return to the Hand and replaces it with a Decoy. Assumes at least one valid card.
|
|
async decoy(card, max, data) {
|
|
let targ, row;
|
|
if (game.decoyCancelled)
|
|
return;
|
|
let usable_data;
|
|
if (card.row.length > 0) {
|
|
// Units with decoy ability only work on a specific row
|
|
if (["close", "agile","agile_cr","agile_cs","agile_crs"].includes(card.row))
|
|
usable_data = this.countCards(board.getRow(card, "close", this.player), usable_data);
|
|
if (["ranged", "agile", "agile_cr", "agile_rs", "agile_crs"].includes(card.row))
|
|
usable_data = this.countCards(board.getRow(card, "ranged", this.player), usable_data);
|
|
if (["siege", "agile_rs", "agile_cs", "agile_crs"].includes(card.row))
|
|
usable_data = this.countCards(board.getRow(card, "siege", this.player), usable_data);
|
|
} else {
|
|
usable_data = data;
|
|
}
|
|
if (usable_data.spy.length) {
|
|
let min = usable_data.spy.reduce((a, c) => Math.min(a, c.power), Number.MAX_VALUE);
|
|
targ = usable_data.spy.filter(c => c.power === min)[0];
|
|
} else if (usable_data.medic.length) {
|
|
targ = usable_data.medic[randomInt(usable_data.medic.length)];
|
|
} else if (usable_data.scorch.length) {
|
|
targ = usable_data.scorch[randomInt(usable_data.scorch.length)];
|
|
} else {
|
|
let pairs = max.rmax.filter((r, i) => this.isSelfRowIndex(i) && r.cards.length)
|
|
.filter((r, i) => card.row.length === 0 || (["close", "agile", "agile_cr", "agile_cs", "agile_crs"].includes(card.row) && (i === 2 || i === 3))
|
|
|| (["ranged", "agile", "agile_cr", "agile_rs", "agile_crs"].includes(card.row) && (i === 1 || i === 4))
|
|
|| (["siege", "agile_rs", "agile_cs", "agile_crs"].includes(card.row) && (i === 0 || i === 5)))
|
|
.reduce((a, r) =>
|
|
r.cards.map(c => ({
|
|
r: r.row,
|
|
c: c
|
|
})).concat(a), []);
|
|
|
|
if (pairs.length) {
|
|
let pair = pairs[randomInt(pairs.length)];
|
|
targ = pair.c;
|
|
row = pair.r;
|
|
}
|
|
}
|
|
|
|
if (targ) {
|
|
for (let i = 0; !row; ++i) {
|
|
if (board.row[i].cards.indexOf(targ) !== -1) {
|
|
row = board.row[i];
|
|
break;
|
|
}
|
|
}
|
|
targ.decoyTarget = true;
|
|
setTimeout(() => board.toHand(targ, row), 1000);
|
|
} else {
|
|
row = ["close", "agile", "agile_cr", "agile_cs", "agile_crs"].includes(card.row) ? board.getRow(card, "close", this.player) : ["ranged", "agile_rs"].includes(card.row) ? board.getRow(card, "ranged", this.player) : board.getRow(card, "siege", this.player);
|
|
}
|
|
await this.player.playCardToRow(card, row);
|
|
}
|
|
|
|
// Tells the controlled Player to play the Scorch card
|
|
async scorch(card, max, data) {
|
|
await this.player.playScorch(card);
|
|
}
|
|
|
|
// Tells the controlled Player to play the Scorch card
|
|
async slaughterCintra(card) {
|
|
await this.player.playSlaughterCintra(card);
|
|
}
|
|
|
|
// Tells the controlled Player to play the seize special card
|
|
async seizeCards(card) {
|
|
await this.player.playSeize(card);
|
|
}
|
|
|
|
// Plays a shield special card to the most beneficial row. Assumes at least one viable row.
|
|
// Also applicable for shield cards which affect only one row.
|
|
async shieldCards(card) {
|
|
if (card.abilities.includes("shield_c")) {
|
|
await this.player.playCardToRow(card, board.getRow(card, "close", this.player));
|
|
return;
|
|
} else if (card.abilities.includes("shield_r")) {
|
|
await this.player.playCardToRow(card, board.getRow(card, "ranged", this.player));
|
|
return;
|
|
}
|
|
if (card.abilities.includes("shield_s")) {
|
|
await this.player.playCardToRow(card, board.getRow(card, "siege", this.player));
|
|
return;
|
|
}
|
|
|
|
let units = card.holder.getAllRowCards().concat(card.holder.hand.cards).filter(c => c.isUnit()).filter(c => !c.abilities.includes("spy"));
|
|
let rowStats = {
|
|
"close": 0,
|
|
"ranged": 0,
|
|
"siege": 0,
|
|
"agile": 0,
|
|
"agile_cr": 0,
|
|
"agile_rs": 0,
|
|
"agile_cs": 0,
|
|
"agile_crs": 0
|
|
};
|
|
units.forEach(c => {
|
|
rowStats[c.row] += c.power;
|
|
});
|
|
rowStats["close"] += (rowStats["agile"] + rowStats["agile_cr"] + rowStats["agile_cs"] + rowStats["agile_crs"]);
|
|
rowStats["ranged"] += rowStats["agile_rs"]
|
|
let max_row;
|
|
if (rowStats["close"] >= rowStats["ranged"] && rowStats["close"] >= rowStats["siege"])
|
|
max_row = board.getRow(card, "close", this.player);
|
|
else if (rowStats["ranged"] > rowStats["close"] && rowStats["ranged"] >= rowStats["siege"])
|
|
max_row = board.getRow(card, "ranged", this.player);
|
|
else
|
|
max_row = board.getRow(card, "siege", this.player);
|
|
await this.player.playCardToRow(card, max_row);
|
|
}
|
|
|
|
// Plays the lock special card in the enemy melee row
|
|
async lock(card) {
|
|
await this.player.playCardToRow(card, board.getRow(card, "close", this.player.opponent()));
|
|
}
|
|
|
|
// Plays the curse special card in the enemy melee row
|
|
async curse(card) {
|
|
await this.player.playCardToRow(card, board.getRow(card, "close", this.player.opponent()));
|
|
}
|
|
|
|
// Plays the knockback special card in the most beneficial row - by default enemy melee row
|
|
async knockback(card) {
|
|
await this.player.playKnockback(card);
|
|
}
|
|
|
|
// Play special wine card to the most beneficial row.
|
|
async toussaintWine(card) {
|
|
await this.player.playCardToRow(card, this.bestRowToussaintWine(card));
|
|
}
|
|
|
|
// Play special wine card to the most beneficial row.
|
|
async witchHunt(card) {
|
|
await this.player.playCardToRow(card, this.bestWitchHuntRow(card).getOppositeRow());
|
|
}
|
|
|
|
// Plays the bank special card
|
|
async bank(card) {
|
|
await this.player.playBank(card);
|
|
}
|
|
|
|
// Plays the Skellige Fleet special card
|
|
async skelligeFleet(card) {
|
|
await this.player.playSkelligeFleet(card);
|
|
}
|
|
|
|
// Plays the Royal Decree special card
|
|
async royalDecree(card) {
|
|
await this.player.playRoyalDecree(card);
|
|
}
|
|
|
|
bestWitchHuntRow(card) {
|
|
if (card.row.includes("agile")) {
|
|
let r = board.getAgileRows(card, this.player.opponent());
|
|
let rows = r.filter(r => !r.isShielded() && !game.scorchCancelled).map(r => ({
|
|
row: r,
|
|
value: r.minUnits().reduce((a, c) => a + c.power, 0)
|
|
}));
|
|
if (rows.length > 0)
|
|
return rows.sort((a, b) => b.value - a.value)[0].row;
|
|
else
|
|
return r[0];
|
|
} else {
|
|
return board.getRow(card, card.row, card.holder.opponent());
|
|
}
|
|
}
|
|
|
|
bestRowToussaintWine(card) {
|
|
let units = card.holder.getAllRowCards().concat(card.holder.hand.cards).filter(c => c.isUnit()).filter(c => !c.abilities.includes("spy"));
|
|
let rowStats = {
|
|
"close": 0,
|
|
"ranged": 0,
|
|
"siege": 0,
|
|
"agile": 0,
|
|
"agile_cr": 0,
|
|
"agile_rs": 0,
|
|
"agile_cs": 0,
|
|
"agile_crs": 0
|
|
};
|
|
units.forEach(c => {
|
|
rowStats[c.row] += 1;
|
|
});
|
|
rowStats["close"] += (rowStats["agile"] + rowStats["agile_cr"] + rowStats["agile_cs"] + rowStats["agile_crs"]);
|
|
rowStats["ranged"] += rowStats["agile_rs"]
|
|
let rows = card.holder.getAllRows();
|
|
rowStats["close"] = board.getRow(card, "close", this.player).effects.toussaint_wine > 0 ? 0 : rowStats["close"];
|
|
rowStats["ranged"] = board.getRow(card, "ranged", this.player).effects.toussaint_wine > 0 ? 0 : rowStats["ranged"];
|
|
rowStats["siege"] = board.getRow(card, "siege", this.player).effects.toussaint_wine > 0 ? 0 : rowStats["siege"];
|
|
let max_row;
|
|
if (rowStats["close"] >= rowStats["ranged"] && rowStats["close"] >= rowStats["siege"])
|
|
max_row = board.getRow(card, "close", this.player);
|
|
else if (rowStats["ranged"] > rowStats["close"] && rowStats["ranged"] >= rowStats["siege"])
|
|
max_row = board.getRow(card, "ranged", this.player);
|
|
else
|
|
max_row = board.getRow(card, "siege", this.player);
|
|
return max_row;
|
|
}
|
|
|
|
// Gives the list of cards on the board for which we can find a similar card in the grave or deck (either same name or target)
|
|
// Returns for each entry: target card on bard / card in deck or grave / target row / weight
|
|
bestSimilarCards(card) {
|
|
let units = card.holder.getAllRowCards().filter(c => c.isUnit());
|
|
let candidates = new Array();
|
|
units.forEach(srcCard => {
|
|
let targets = srcCard.holder.grave.cards.concat(srcCard.holder.deck.cards).filter((c => srcCard.name === c.name || ("target" in srcCard && srcCard.target !== "" && srcCard.target === c.target)));
|
|
if (targets.length > 0) {
|
|
targets.forEach(c => {
|
|
let pRows = c.getPlayableRows();
|
|
pRows.forEach(r => {
|
|
let weight = this.weightRowChange(c, r);
|
|
candidates.push([srcCard, c, r, weight]);
|
|
});
|
|
});
|
|
}
|
|
});
|
|
return candidates.sort((a, b) => b[3] - a[3]);
|
|
}
|
|
|
|
// Assigns a weight for how likely the conroller is to Pass the round
|
|
weightPass() {
|
|
if (this.player.health === 1)
|
|
return 0;
|
|
let dif = this.player.opponent().total - this.player.total;
|
|
if (dif > 30)
|
|
return 100;
|
|
if (dif < -30 && this.player.opponent().hand.cards.length - this.player.hand.cards.length > 2)
|
|
return 100;
|
|
return Math.floor(Math.abs(dif));
|
|
}
|
|
|
|
// Assigns a weight for how likely the controller is to activate its leader ability
|
|
weightLeader(card, max, data) {
|
|
let w = ability_dict[card.abilities[0]].weight;
|
|
if (ability_dict[card.abilities[0]].weight) {
|
|
let score = w(card, this, max, data);
|
|
return score;
|
|
}
|
|
return 10 + (game.roundCount - 1) * 15;
|
|
}
|
|
|
|
// Assigns a weight for how likely the controller will use a scorch-row card
|
|
weightScorchRow(card, max, row_name) {
|
|
if (game.scorchCancelled)
|
|
return 0;
|
|
let index = 3 + (row_name === "close" ? 0 : row_name === "ranged" ? 1 : 2);
|
|
if (this.player === player_me)
|
|
index = 2 - (row_name === "close" ? 0 : row_name === "ranged" ? 1 : 2);
|
|
if (board.row[index].total < 10 || board.row[index].isShielded())
|
|
return 0;
|
|
let score = max.rmax[index].cards.reduce((a, c) => a + c.power, 0);
|
|
return score;
|
|
}
|
|
|
|
// Calculates a weight for how likely the controller will use horn on this row
|
|
weightHornRow(card, row) {
|
|
return row.effects.horn ? 0 : this.weightRowChange(card, row);
|
|
}
|
|
|
|
// Calculates weight for playing a card on a given row, min 0
|
|
weightRowChange(card, row) {
|
|
return Math.max(0, this.weightRowChangeTrue(card, row));
|
|
}
|
|
|
|
bestAgileRowChange(card) {
|
|
let rows = [];
|
|
let r = board.getAgileRows(card, card.holder);
|
|
r.forEach(row => rows.push({ row: row, score: 0 }));
|
|
for (var i = 0; i < rows.length ; i++) {
|
|
rows[i].score = this.weightRowChange(card, rows[i].row);
|
|
}
|
|
return rows.sort((a, b) => b.score - a.score)[0];
|
|
}
|
|
|
|
// Calculates weight for playing a card on the given row
|
|
weightRowChangeTrue(card, row) {
|
|
let dif = [0, 0];
|
|
this.calcRowPower(row, dif, true);
|
|
row.updateState(card, true);
|
|
this.calcRowPower(row, dif, false);
|
|
if (!card.isSpecial())
|
|
dif[0] -= row.calcCardScore(card);
|
|
row.updateState(card, false);
|
|
return dif[1] - dif[0];
|
|
}
|
|
|
|
// Weights the diff of changing a card from a row to another
|
|
weightRowSwap(card, src, dest) {
|
|
if (src === dest)
|
|
return 0;
|
|
return (this.weightRowChangeTrue(card, dest) - this.weightRowChangeTrue(card, src));
|
|
}
|
|
|
|
// Calculates for all cards on the given player's side of the board the diff of score if changing location to another row
|
|
// Returns results sorted by best or worst first, depending if "best" parameter is on or off
|
|
weightAllCardsRowChanges(player, best = true) {
|
|
let weights = [];
|
|
let cards = player.getAllRowCards();
|
|
let rows = player.getAllRows();
|
|
cards.filter(c => c.hero || c.isUnit()).forEach(c => {
|
|
rows.forEach(r => {
|
|
if (r !== c.currentLocation) {
|
|
weights.push({ row: r, card: c, score: this.weightRowSwap(c, c.currentLocation, r) })
|
|
}
|
|
});
|
|
});
|
|
if (best) {
|
|
return weights.sort((a, b) => b.score - a.score);
|
|
} else {
|
|
return weights.sort((a, b) => a.score - b.score);
|
|
}
|
|
}
|
|
|
|
// Calculates the weight for playing a weather card
|
|
weightWeather(card) {
|
|
let rows;
|
|
// This specific weather card has 2 modes
|
|
if (card.key === "spe_storm") {
|
|
return Math.max(this.weightWeather({ key: "storm", abilities: ["frost", "fog"] }), this.weightWeather({ key: "storm", abilities: ["rain", "fog"] }));
|
|
}
|
|
if (card.abilities) {
|
|
if (card.key === "spe_clear")
|
|
rows = Object.values(weather.types).filter(t => t.count > 0).flatMap(t => t.rows);
|
|
else
|
|
rows = Object.values(weather.types).filter(t => t.count === 0 && card.abilities.includes(t.name)).flatMap(t => t.rows);
|
|
} else {
|
|
if (card.ability == "clear")
|
|
rows = Object.values(weather.types).filter(t => t.count > 0).flatMap(t => t.rows);
|
|
else
|
|
rows = Object.values(weather.types).filter(t => t.count === 0 && t.name === card.ability).flatMap(t => t.rows);
|
|
}
|
|
|
|
if (!rows.length)
|
|
return 1;
|
|
let dif = [0, 0];
|
|
rows.forEach(r => {
|
|
let state = r.effects.weather;
|
|
this.calcRowPower(r, dif, true);
|
|
r.effects.weather = !state;
|
|
this.calcRowPower(r, dif, false);
|
|
r.effects.weather = state;
|
|
});
|
|
return dif[1] - dif[0];
|
|
}
|
|
|
|
// Calculates the weight for playing a mardroeme card
|
|
weightMardroemeRow(card, row) {
|
|
if (card.key === "spe_mardroeme" && row.special.containsCardByKey("spe_mardroeme"))
|
|
return 0;
|
|
let ermion = card.holder.hand.cards.filter(c => c.key === "sk_ermion").length > 0;
|
|
if (ermion && card.key !== "sk_ermion" && row === board.getRow(card, "ranged", this.player))
|
|
return 0;
|
|
let bers_cards = row.cards.filter(c => c.abilities.includes("berserker"));
|
|
let weightData = {
|
|
bond: {},
|
|
strength: 0,
|
|
scorch: 0
|
|
};
|
|
|
|
for (var i = 0; i < bers_cards.length; i++) {
|
|
var c = bers_cards[i];
|
|
var ctarget = card_dict[c.target];
|
|
weightData.strength -= c.power;
|
|
if (ctarget.ability.includes("morale"))
|
|
weightData.strength += Number(ctarget["strength"]) + row.cards.filter(c => c.isUnit()).length - 1;
|
|
if (ctarget.ability.includes("bond")) {
|
|
if (!weightData.bond[c.target])
|
|
weightData.bond[c.target] = [0, Number(ctarget["strength"])];
|
|
weightData.bond[c.target][0]++;
|
|
}
|
|
if (ctarget.ability.includes("scorch_c"))
|
|
weightData.scorch += this.weightScorchRow(card, this.getMaximums(), "close");
|
|
}
|
|
let weight = weightData.strength + Object.keys(weightData.bond).reduce((s, c) => s + Math.pow(weightData.bond[c][0], 2) * weightData.bond[c][1], 0) + weightData.scorch;
|
|
return Math.max(1, weight);
|
|
}
|
|
|
|
// Calculates the weight for cards with the medic ability
|
|
weightMedic(data, score, owner) {
|
|
let units = owner.grave.findCards(c => c.isUnit());
|
|
let grave = data["grave_" + owner.opponent().tag];
|
|
return !units.length ? Math.min(1, score) : score + (grave.spy.length ? 50 : grave.medic.length ? 15 : grave.scorch.length ? 10 : this.player.health === 1 ? 1 : 0);
|
|
}
|
|
|
|
// Calculates the weight for cards with the berserker ability
|
|
weightBerserker(card, row, score) {
|
|
if (card.holder.hand.cards.filter(c => c.abilities.includes("mardroeme")).length < 1 && !row.effects.mardroeme > 0)
|
|
return score;
|
|
score -= card.basePower;
|
|
let ctarget = card_dict[card.target];
|
|
if (ctarget.ability.includes("morale")) {
|
|
score += Number(ctarget["strength"]) + row.cards.filter(c => c.isUnit()).length - 1;
|
|
} else if (ctarget.ability.includes("bond")) {
|
|
let n = 1;
|
|
if (!row.effects.mardroeme)
|
|
n += row.cards.filter(c => c.key === card.key).filter(c => !c.isLocked()).length;
|
|
else
|
|
n += row.cards.filter(c => c.key === card.target).filter(c => !c.isLocked()).length;
|
|
score += Number(ctarget["strength"]) * (n * n);
|
|
} else if (ctarget.ability.includes("scorch_c")) {
|
|
score += this.weightScorchRow(card, this.getMaximums(), "close");
|
|
} else {
|
|
score += Number(ctarget["strength"]);
|
|
}
|
|
return Math.max(1, score);
|
|
}
|
|
|
|
// Calculates the weight for a weather card if played from the deck
|
|
weightWeatherFromDeck(card, weather_id) {
|
|
if (card.holder.deck.findCard(c => c.abilities.includes(weather_id)) === undefined)
|
|
return 0;
|
|
return this.weightCard({
|
|
abilities: [weather_id],
|
|
row: "weather"
|
|
});
|
|
}
|
|
|
|
// Assigns a weights for how likely the controller with play a card from its hand
|
|
weightCard(card, max, data) {
|
|
let abi
|
|
if (card.abilities) {
|
|
abi = card.abilities;
|
|
} else if (card["ability"]) {
|
|
abi = card["ability"].split(" ");
|
|
} else {
|
|
abi = [];
|
|
console.log("Missing abilities for card:");
|
|
console.log(card);
|
|
}
|
|
if (abi.includes("decoy")) {
|
|
if (card.row.length > 0) {
|
|
let row_data;
|
|
if (["close","agile","agile_cr","agile_cs","agile_crs"].includes(card.row))
|
|
row_data = this.countCards(board.getRow(card, "close", this.player), row_data);
|
|
if (["ranged", "agile", "agile_cr", "agile_rs", "agile_crs"].includes(card.row))
|
|
row_data = this.countCards(board.getRow(card, "ranged", this.player), row_data);
|
|
if (["agile_cs", "agile_rs", "agile_crs"].includes(card.row))
|
|
row_data = this.countCards(board.getRow(card, "siege", this.player), row_data);
|
|
return game.decoyCancelled ? 0 : row_data.spy.length ? 50 : row_data.medic.length ? 15 : row_data.scorch.length ? 10 : max.me.length ? card.power : 0;
|
|
} else
|
|
return game.decoyCancelled ? 0 : data.spy.length ? 50 : data.medic.length ? 15 : data.scorch.length ? 10 : max.me.length ? 1 : 0;
|
|
}
|
|
if (abi.includes("horn")) {
|
|
let rows = this.player.getAllRows().filter(r => !r.special.containsCardByKey("spe_horn"));
|
|
if (!rows.length)
|
|
return 0;
|
|
rows = rows.map(r => this.weightHornRow(card, r));
|
|
return Math.max(...rows) / 2;
|
|
}
|
|
|
|
if (abi) {
|
|
if (abi.includes("scorch")) {
|
|
if (game.scorchCancelled)
|
|
return Math.max(0, card.power);
|
|
let power_op = max.op_noshield.length ? max.op_noshield[0].card.power : 0;
|
|
let power_me = max.me_noshield.length ? max.me_noshield[0].card.power : 0;
|
|
let total_op = power_op * max.op_noshield.length;
|
|
let total_me = power_me * max.me_noshield.length;
|
|
return power_me > power_op ? 0 : power_me < power_op ? total_op : Math.max(0, total_op - total_me);
|
|
}
|
|
if (abi.includes("decoy")) {
|
|
return game.decoyCancelled ? 0 : data.spy.length ? 50 : data.medic.length ? 15 : data.scorch.length ? 10 : max.me.length ? 1 : 0;
|
|
}
|
|
if (abi.includes("mardroeme")) {
|
|
let rows = this.player.getAllRows();
|
|
return Math.max(...rows.map(r => this.weightMardroemeRow(card, r)));
|
|
}
|
|
if (["cintra_slaughter", "seize", "lock", "shield", "knockback", "shield_c", "shield_r", "shield_s", "bank", "skellige_fleet","immortal","royal_decree","summon_one_of","curse"].includes(abi.at(-1))) {
|
|
return ability_dict[abi.at(-1)].weight(card);
|
|
}
|
|
if (abi.includes("witch_hunt")) {
|
|
if (game.scorchCancelled)
|
|
return card.power;
|
|
let best_row = this.bestWitchHuntRow(card)
|
|
if (best_row) {
|
|
let dmg = best_row.minUnits().reduce((a, c) => a + c.power, 0);
|
|
if (dmg < 6) // Let's not waste it on isolated weak units
|
|
dmg = 0;
|
|
return dmg + card.power;
|
|
}
|
|
return card.power
|
|
}
|
|
if (abi.includes("toussaint_wine")) {
|
|
let units = card.holder.getAllRowCards().concat(card.holder.hand.cards).filter(c => c.isUnit()).filter(c => !c.abilities.includes("spy"));
|
|
let rowStats = {
|
|
"close": 0,
|
|
"ranged": 0,
|
|
"siege": 0,
|
|
"agile": 0,
|
|
"agile_cr": 0,
|
|
"agile_rs": 0,
|
|
"agile_cs": 0,
|
|
"agile_crs": 0
|
|
};
|
|
units.forEach(c => {
|
|
rowStats[c.row] += 1;
|
|
});
|
|
rowStats["close"] += (rowStats["agile"] + rowStats["agile_cr"] + rowStats["agile_cs"] + rowStats["agile_crs"]);
|
|
rowStats["ranged"] += rowStats["agile_rs"]
|
|
|
|
let rows = card.holder.getAllRows();
|
|
rowStats["close"] = board.getRow(card, "close", this.player).effects.toussaint_wine > 0 ? 0 : rowStats["close"];
|
|
rowStats["ranged"] = board.getRow(card, "ranged", this.player).effects.toussaint_wine > 0 ? 0 : rowStats["ranged"];
|
|
rowStats["siege"] = board.getRow(card, "siege", this.player).effects.toussaint_wine > 0 ? 0 : rowStats["siege"];
|
|
return 2 * Math.max(rowStats["close"], rowStats["ranged"], rowStats["siege"]);
|
|
}
|
|
if (abi.at(-1) && abi.at(-1).startsWith("witcher_")) {
|
|
let witchers = card.holder.getAllRowCards().filter(c => c.abilities.includes(abi.at(-1)));
|
|
let keep = witchers.filter(c => c.hero);
|
|
return card.power + (2 * witchers.length * 2) + (keep.length > 0 ? keep[0].power : 0);
|
|
}
|
|
if (abi.includes("inspire")) {
|
|
let insp = card.holder.getAllRowCards().filter(c => c.abilities.includes("inspire"));
|
|
let best_power = 0;
|
|
if (insp.length > 0)
|
|
best_power = insp.sort((a, b) => b.power - a.power)[0].power;
|
|
let max_power = Math.max(card.power, best_power);
|
|
if (card.power === max_power)
|
|
return max_power + insp.map(c => max_power - c.power).reduce((a, c) => a + c, 0);
|
|
return max_power;
|
|
}
|
|
}
|
|
|
|
if (card.row === "weather" || (card.deck && card.deck.startsWith("weather"))) {
|
|
return Math.max(0, this.weightWeather(card));
|
|
}
|
|
|
|
let row = board.getRow(card, ["agile", "agile_cr", "agile_cs", "agile_crs"].includes(card.row) ? "close" : ["ranged","agile_rs"].includes(card.row) ? "ranged" : card.row, this.player);
|
|
let score = row.calcCardScore(card);
|
|
switch (abi[abi.length - 1]) {
|
|
case "bond":
|
|
case "morale":
|
|
case "toussaint_wine":
|
|
case "horn":
|
|
score = card.row.includes("agile") ? this.bestAgileRowChange(card).score : this.weightRowChange(card, row);
|
|
break;
|
|
case "medic":
|
|
score = this.weightMedic(data, score, card.holder);
|
|
break;
|
|
case "spy":
|
|
score = 15 + score;
|
|
break;
|
|
case "muster":
|
|
let pred = c => c.target === card.target;
|
|
let units = card.holder.hand.cards.filter(pred).concat(card.holder.deck.cards.filter(pred));
|
|
score *= units.length;
|
|
break;
|
|
case "scorch_c":
|
|
score = Math.max(1, this.weightScorchRow(card, max, "close"));
|
|
break;
|
|
case "scorch_r":
|
|
score = Math.max(1, this.weightScorchRow(card, max, "ranged"));
|
|
break;
|
|
case "scorch_s":
|
|
score = Math.max(1, this.weightScorchRow(card, max, "siege"));
|
|
break;
|
|
case "berserker":
|
|
score = this.weightBerserker(card, row, score);
|
|
break;
|
|
case "avenger":
|
|
case "avenger_kambi":
|
|
case "whorshipper":
|
|
case "necrophage":
|
|
case "goetia":
|
|
case "ambush":
|
|
return score + ability_dict[abi.at(-1)].weight(card);
|
|
}
|
|
|
|
return score;
|
|
}
|
|
|
|
// Calculates the current power of a row associated with each Player
|
|
calcRowPower(r, dif, add) {
|
|
r.findCards(c => c.isUnit()).forEach(c => {
|
|
let p = r.calcCardScore(c);
|
|
c.holder === this.player ? (dif[0] += add ? p : -p) : (dif[1] += add ? p : -p);
|
|
});
|
|
}
|
|
}
|
|
|
|
var may_leader = true,
|
|
exibindo_lider = false;
|
|
|
|
// Can make actions during turns like playing cards that it owns
|
|
class Player {
|
|
constructor(id, name, deck, isAI = true) {
|
|
this.id = id;
|
|
this.tag = (id === 0) ? "me" : "op";
|
|
//this.controller = (id === 0) ? new Controller() : new ControllerAI(this);
|
|
if (isAI) {
|
|
this.controller = new ControllerAI(this);
|
|
} else {
|
|
this.controller = new Controller();
|
|
this.ai = new ControllerAI(this); // Exposes AI features which can be used by the actual AI to make estimations
|
|
}
|
|
|
|
if (game.mode === 2) {
|
|
// AI vs AI
|
|
this.hand = (id === 0) ? new Hand(document.getElementById("hand-row"), this.tag) : new Hand(document.getElementById("op-hand-row"), this.tag);
|
|
} else if (game.mode === 3) {
|
|
// Player vs Player
|
|
if (id === 0) {
|
|
this.hand = new Hand(document.getElementById("hand-row"), this.tag);
|
|
} else {
|
|
this.hand = new Hand(document.getElementById("op-hand-row"), this.tag);
|
|
document.getElementById("op-hand-row").classList.add("human-op"); // This a playable opponent hand
|
|
}
|
|
} else {
|
|
this.hand = (id === 0) ? new Hand(document.getElementById("hand-row"), this.tag) : new HandAI(this.tag);
|
|
}
|
|
this.hand.player = this;
|
|
this.grave = new Grave(document.getElementById("grave-" + this.tag));
|
|
this.deck = new Deck(deck.faction, document.getElementById("deck-" + this.tag));
|
|
this.deck_data = deck;
|
|
this.leader = new Card(deck.leader.index, deck.leader.card, this);
|
|
this.elem_leader = document.getElementById("leader-" + this.tag);
|
|
this.elem_leader.children[0].appendChild(this.leader.elem);
|
|
|
|
this.reset();
|
|
|
|
this.name = name;
|
|
document.getElementById("name-" + this.tag).innerHTML = name;
|
|
|
|
if (deck.title)
|
|
document.getElementById("deck-name-" + this.tag).innerHTML = deck.title;
|
|
else
|
|
document.getElementById("deck-name-" + this.tag).innerHTML = factions[deck.faction].name;
|
|
document.getElementById("stats-" + this.tag).getElementsByClassName("profile-img")[0].children[0].children[0];
|
|
let x = document.querySelector("#stats-" + this.tag + " .profile-img > div > div");
|
|
x.style.backgroundImage = iconURL("deck_shield_" + deck.faction);
|
|
}
|
|
|
|
getAIController() {
|
|
if (this.controller instanceof ControllerAI) {
|
|
return this.controller;
|
|
} else {
|
|
return this.ai;
|
|
}
|
|
}
|
|
|
|
// Sets default values
|
|
reset() {
|
|
this.grave.reset();
|
|
this.hand.reset();
|
|
this.deck.reset();
|
|
this.deck.initializeFromID(this.deck_data.cards, this);
|
|
|
|
this.health = 2;
|
|
this.total = 0;
|
|
this.passed = false;
|
|
this.handsize = 10;
|
|
this.mulliganCount = 2;
|
|
this.winning = false;
|
|
this.factionAbilityUses = 0;
|
|
this.effects = {
|
|
"witchers": {},
|
|
"whorshippers": 0,
|
|
"inspire": 0
|
|
};
|
|
this.capabilities = {
|
|
"drawOPdeck": 0,
|
|
"endTurnRetake": 0,
|
|
"cardEdit": 0
|
|
};
|
|
this.forcedActions = [];
|
|
this.endturn_action = null;
|
|
|
|
// Handling Faction abilities: active or passive
|
|
let factionAbility = factions[this.deck.faction];
|
|
if (factionAbility["activeAbility"]) {
|
|
// Init ability if need be
|
|
if (factionAbility.factionAbilityInit) {
|
|
factionAbility.factionAbilityInit(this);
|
|
}
|
|
this.updateFactionAbilityUses(factionAbility["abilityUses"]);
|
|
|
|
document.getElementById("faction-ability-" + this.tag).classList.remove("hide");
|
|
if (this.tag === "me" || game.isPvP())
|
|
document.getElementById("faction-ability-" + this.tag).addEventListener("click", () => this.activateFactionAbility(), false);
|
|
} else {
|
|
document.getElementById("faction-ability-" + this.tag).classList.add("hide");
|
|
}
|
|
|
|
this.enableLeader();
|
|
this.setPassed(false);
|
|
document.getElementById("gem1-" + this.tag).classList.add("gem-on");
|
|
document.getElementById("gem2-" + this.tag).classList.add("gem-on");
|
|
}
|
|
|
|
roundStartReset() {
|
|
this.effects = {
|
|
"witchers": {},
|
|
"whorshippers": 0,
|
|
"inspire": 0
|
|
};
|
|
this.forcedActions = [];
|
|
}
|
|
|
|
// Returns the opponent Player
|
|
opponent() {
|
|
return board.opponent(this);
|
|
}
|
|
|
|
// Updates the player's total score and notifies the gamee
|
|
updateTotal(n) {
|
|
this.total += n;
|
|
document.getElementById("score-total-" + this.tag).children[0].innerHTML = this.total;
|
|
board.updateLeader();
|
|
}
|
|
|
|
// Puts the player in the winning state
|
|
setWinning(isWinning) {
|
|
if (this.winning ^ isWinning)
|
|
document.getElementById("score-total-" + this.tag).classList.toggle("score-leader");
|
|
this.winning = isWinning;
|
|
}
|
|
|
|
// Puts the player in the passed state
|
|
setPassed(hasPassed) {
|
|
if (this.passed ^ hasPassed)
|
|
document.getElementById("passed-" + this.tag).classList.toggle("passed");
|
|
this.passed = hasPassed;
|
|
}
|
|
|
|
// Sets up board for turn
|
|
async startTurn() {
|
|
document.getElementById("stats-" + this.tag).classList.add("current-turn");
|
|
if (this.leaderAvailable)
|
|
this.elem_leader.children[1].classList.remove("hide");
|
|
|
|
if (this === player_me || game.isPvP()) {
|
|
document.getElementById("pass-button").classList.remove("noclick");
|
|
may_pass1 = true;
|
|
}
|
|
|
|
if (this.controller instanceof ControllerAI) {
|
|
await this.controller.startTurn(this);
|
|
} else {
|
|
// If there is a pending forced action, do it or pass
|
|
if (this.forcedActions.length > 0) {
|
|
let card = this.forcedActions.splice(0, 1)[0];
|
|
ui.showPreviewVisuals(card);
|
|
// Ask if the player wants to play the card or pass
|
|
let c = await ui.popup("Play card [E]", (p) => p.choice = true, "Pass [Q]", (p) => p.choice = false, "Play card or pass?", "You are forced to play this card or pass for this round, which option do you choose?");
|
|
ui.enablePlayer(true);
|
|
if (c) {
|
|
document.getElementById("click-background").classList.add("noclick");
|
|
this.hand.cards.forEach(c => c.elem.classList.add("noclick"));
|
|
ui.setSelectable(card, true);
|
|
} else {
|
|
this.passRound();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Passes the round and ends the turn
|
|
async passRound() {
|
|
this.setPassed(true);
|
|
ui.notification("op-pass", 1200);
|
|
await this.endTurn();
|
|
}
|
|
|
|
// Plays a scorch card
|
|
async playScorch(card) {
|
|
if (!game.scorchCancelled)
|
|
await this.playCardAction(card, async () => await ability_dict["scorch"].activated(card));
|
|
}
|
|
|
|
// Plays a Slaughter of Cintra card
|
|
async playSlaughterCintra(card) {
|
|
await this.playCardAction(card, async () => await ability_dict["cintra_slaughter"].activated(card));
|
|
}
|
|
|
|
// Plays a Seize special card card
|
|
async playSeize(card) {
|
|
await this.playCardAction(card, async () => await ability_dict["seize"].activated(card));
|
|
}
|
|
|
|
// Plays a Knockback special card card, assuming 1 valid
|
|
async playKnockback(card) {
|
|
let best_row = board.getRow(card, "close", this.opponent());
|
|
//If melee row is empty, better target ranged
|
|
if (board.getRow(card, "close", this.opponent()).cards.length === 0)
|
|
best_row = board.getRow(card, "ranged", this.opponent());
|
|
// If siege has an active weather effect, better target ranged
|
|
if (board.getRow(card, "ranged", this.opponent()).cards.length > 1 && board.getRow(card, "siege", this.opponent()).effects.weather)
|
|
best_row = board.getRow(card, "ranged", this.opponent());
|
|
// If ranged has a horn or shield effect, better target it
|
|
if ((board.getRow(card, "ranged", this.opponent()).isShielded() || board.getRow(card, "ranged", this.opponent()).effects.horn > 0) && board.getRow(card, "ranged", this.opponent()).cards.length > 0)
|
|
best_row = board.getRow(card, "ranged", this.opponent());
|
|
// If there are some bond units in the ranged row, better try to break it before it grows
|
|
if (Object.keys(board.getRow(card, "ranged", this.opponent()).effects.bond).length > 0 && board.getRow(card, "siege", this.opponent()).effects.horn === 0)
|
|
best_row = board.getRow(card, "ranged", this.opponent());
|
|
await this.playCardAction(card, async () => await ability_dict["knockback"].activated(card, best_row));
|
|
}
|
|
|
|
// Play the bank card
|
|
async playBank(card) {
|
|
await this.playCardAction(card, async () => await ability_dict["bank"].activated(card));
|
|
}
|
|
|
|
// Play the skellige fleet card
|
|
async playSkelligeFleet(card) {
|
|
await this.playCardAction(card, async () => await ability_dict["skellige_fleet"].activated(card));
|
|
}
|
|
|
|
// Play the royal decree card
|
|
async playRoyalDecree(card) {
|
|
await this.playCardAction(card, async () => await ability_dict["royal_decree"].activated(card));
|
|
}
|
|
|
|
// Plays a card to a specific row
|
|
async playCardToRow(card, row, endTurn=true) {
|
|
await this.playCardAction(card, async () => await board.moveTo(card, row, this.hand), endTurn);
|
|
}
|
|
|
|
// Plays a card to the board
|
|
async playCard(card) {
|
|
await this.playCardAction(card, async () => await card.autoplay(this.hand));
|
|
}
|
|
|
|
// Shows a preview of the card being played, plays it to the board and ends the turn
|
|
async playCardAction(card, action, endTurn = true) {
|
|
ui.showPreviewVisuals(card);
|
|
await sleep(1000);
|
|
ui.hidePreview(card);
|
|
await action();
|
|
if(endTurn)
|
|
await this.endTurn();
|
|
}
|
|
|
|
// Handles end of turn visuals and behavior the notifies the game
|
|
async endTurn(noEffects=false) {
|
|
if (this.endturn_action) {
|
|
// Call action instead of ending turn
|
|
await this.endturn_action();
|
|
return;
|
|
}
|
|
if (!this.passed && !this.canPlay()) {
|
|
this.setPassed(true);
|
|
ui.notification("op-pass", 1200);
|
|
}
|
|
if (this === player_me) {
|
|
document.getElementById("pass-button").classList.add("noclick");
|
|
may_pass1 = false;
|
|
}
|
|
document.getElementById("stats-" + this.tag).classList.remove("current-turn");
|
|
this.elem_leader.children[1].classList.add("hide");
|
|
game.endTurn(noEffects)
|
|
}
|
|
|
|
// Tells the the Player if it won the round. May damage health.
|
|
endRound(win) {
|
|
if (!win) {
|
|
if (this.health < 1)
|
|
return;
|
|
document.getElementById("gem" + this.health + "-" + this.tag).classList.remove("gem-on");
|
|
this.health--;
|
|
}
|
|
this.setPassed(false);
|
|
this.setWinning(false);
|
|
}
|
|
|
|
// Returns true if the Player can make any action other than passing
|
|
canPlay() {
|
|
return this.hand.cards.length > 0 || this.leaderAvailable || this.factionAbilityUses > 0;
|
|
}
|
|
|
|
// Use a leader's Activate ability, then disable the leader
|
|
// Option to not end turn and disable leader - useful when we want to trigger the leader ability in other circumstances
|
|
async activateLeader(endTurn=true,disableLeader=true) {
|
|
try {
|
|
Carousel.curr.cancel();
|
|
} catch (err) { }
|
|
if (this.leaderAvailable) {
|
|
this.endTurnAfterAbilityUse = endTurn;
|
|
let res = await this.leader.activated[0](this.leader, this);
|
|
// If the leader activity signaled it couldn't be actually used, we stop right here
|
|
if (res == false) {
|
|
ui.enablePlayer(true);
|
|
return false;
|
|
}
|
|
if (disableLeader)
|
|
this.disableLeader();
|
|
// Some abilities require further actions before ending the turn, such as selecting a card
|
|
if (this.endTurnAfterAbilityUse)
|
|
await this.endTurn();
|
|
else {
|
|
// Make selections for AI player
|
|
if (this.controller instanceof ControllerAI) {
|
|
if (this.leader.key === "wu_alzur_maker") {
|
|
let worse_unit = this.getAllRowCards().filter(c => c.isUnit()).sort((a, b) => a.power - b.power)[0];
|
|
ui.selectCard(worse_unit);
|
|
} else if (this.leader.key === "to_anna_henrietta_duchess") {
|
|
let horns = player_me.getAllRows().filter(r => r.special.findCards(c => c.abilities.includes("horn")).length > 0).sort((a, b) => b.total - a.total);
|
|
if (horns[0])
|
|
ui.selectRow(horns[0]);
|
|
} else if (this.leader.key === "lr_meve_princess" || this.leader.key === "sy_carlo_varese") {
|
|
let max = this.controller.getMaximums();
|
|
let rows = [this.controller.weightScorchRow(this.leader, max, "close"), this.controller.weightScorchRow(this.leader, max, "ranged"), this.controller.weightScorchRow(this.leader, max, "siege")];
|
|
let maxv = 0,
|
|
max_row;
|
|
let offset = 3;
|
|
if (this === player_me) {
|
|
offset = 0;
|
|
rows = rows.reverse();
|
|
}
|
|
for (var i = 0; i < 3; i++) {
|
|
if (rows[i] > maxv) {
|
|
maxv = rows[i];
|
|
max_row = board.row[offset + i];
|
|
}
|
|
}
|
|
if (max_row)
|
|
ui.selectRow(max_row);
|
|
} else if (this.leader.key === "sy_cyrus_hemmelfart") {
|
|
// We select a random row to put shackles on
|
|
let offset = 3;
|
|
if (this === player_me)
|
|
offset = 0;
|
|
ui.selectRow(board.row[offset + randomInt(2)]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Disable access to leader ability and toggles leader visuals to off state
|
|
disableLeader() {
|
|
this.leaderAvailable = false;
|
|
let elem = this.elem_leader.cloneNode(true);
|
|
this.elem_leader.parentNode.replaceChild(elem, this.elem_leader);
|
|
this.elem_leader = elem;
|
|
this.elem_leader.children[0].classList.add("fade");
|
|
this.elem_leader.children[1].classList.add("hide");
|
|
this.elem_leader.addEventListener("click", async () => await ui.viewCard(this.leader), false);
|
|
}
|
|
|
|
// Enable access to leader ability and toggles leader visuals to on state
|
|
enableLeader() {
|
|
this.leaderAvailable = this.leader.activated.length > 0;
|
|
let elem = this.elem_leader.cloneNode(true);
|
|
this.elem_leader.parentNode.replaceChild(elem, this.elem_leader);
|
|
this.elem_leader = elem;
|
|
this.elem_leader.children[0].classList.remove("fade");
|
|
this.elem_leader.children[1].classList.remove("hide");
|
|
|
|
if ((this.id === 0 || game.isPvP()) && this.leader.activated.length > 0) {
|
|
this.elem_leader.children[0].addEventListener("click",
|
|
async () => await ui.viewCard(this.leader, async () => await this.activateLeader()),
|
|
false
|
|
);
|
|
this.elem_leader.children[0].addEventListener("mouseover", function () {
|
|
tocar("card", false);
|
|
this.style.boxShadow = "0 0 1.5vw #6d5210"
|
|
});
|
|
this.elem_leader.children[0].addEventListener("mouseout", function () {
|
|
this.style.boxShadow = "0 0 0 #6d5210"
|
|
});
|
|
|
|
window.addEventListener("keydown", function (e) {
|
|
if (may_leader && may_pass1) {
|
|
if (e.keyCode == 88) {
|
|
if (exibindo_lider) {
|
|
exibindo_lider = false;
|
|
player_me.activateLeader();
|
|
} else if (player_me.leaderAvailable) {
|
|
may_leader = false;
|
|
exibindo_lider = true;
|
|
player_me.callLeader();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
window.addEventListener("keyup", function (e) {
|
|
if (player_me.leaderAvailable) may_leader = true;
|
|
});
|
|
} else {
|
|
this.elem_leader.children[0].addEventListener("click", async () => await ui.viewCard(this.leader), false);
|
|
this.elem_leader.children[0].addEventListener("mouseover", function () { });
|
|
this.elem_leader.children[0].addEventListener("mouseout", function () { });
|
|
}
|
|
// TODO set crown color
|
|
}
|
|
|
|
async callLeader() {
|
|
await ui.viewCard(player_me.leader, async () => await player_me.activateLeader());
|
|
}
|
|
|
|
async activateFactionAbility() {
|
|
let factionData = factions[this.deck.faction];
|
|
if (factionData.activeAbility && this.factionAbilityUses > 0) {
|
|
await ui.popup("Use faction ability [E]", () => this.useFactionAbility(), "Cancel [Q]", () => this.escapeFactionAbility(), "Would you like to use your faction ability?", "Faction ability: " + factionData.description);
|
|
}
|
|
return;
|
|
}
|
|
|
|
async useFactionAbility() {
|
|
let factionData = factions[this.deck.faction];
|
|
if (factionData.activeAbility && this.factionAbilityUses > 0) {
|
|
this.endTurnAfterAbilityUse = true;
|
|
await factionData.factionAbility(this);
|
|
this.updateFactionAbilityUses(this.factionAbilityUses - 1);
|
|
// Some faction abilities require extra interractions
|
|
if (this.endTurnAfterAbilityUse)
|
|
await this.endTurn();
|
|
if (this.controller instanceof ControllerAI) {
|
|
if (this.deck.faction === "lyria_rivia") {
|
|
let best_row = this.controller.bestRowToussaintWine(ui.previewCard); // Reusing bestRowToussaintWine because it is nearly the same principle
|
|
ui.selectRow(best_row, true);
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Called when chose to not play the faction ability
|
|
async escapeFactionAbility() {
|
|
ui.enablePlayer(true);
|
|
}
|
|
|
|
updateFactionAbilityUses(count) {
|
|
this.factionAbilityUses = Math.max(0, count);
|
|
document.getElementById("faction-ability-count-" + this.tag).innerHTML = this.factionAbilityUses;
|
|
if (this.factionAbilityUses === 0) {
|
|
document.getElementById("faction-ability-" + this.tag).classList.add("fade");
|
|
} else {
|
|
document.getElementById("faction-ability-" + this.tag).classList.remove("fade");
|
|
}
|
|
}
|
|
|
|
// Get all rows for this player, sorted to have close > ranged > siege
|
|
getAllRows() {
|
|
if (this === player_me) {
|
|
return board.row.filter((r, i) => i > 2);
|
|
}
|
|
return board.row.filter((r, i) => i < 3).reverse();
|
|
}
|
|
|
|
// Get all special rows for this player, sorted to have close > ranged > siege
|
|
getAllSpecialRows() {
|
|
return this.getAllRows().map(r => r.special);
|
|
}
|
|
|
|
// Get all cards in rows for this player
|
|
getAllRowCards() {
|
|
return this.getAllRows().reduce((a, r) => r.cards.concat(a), []);
|
|
}
|
|
|
|
// Get all cards in special rows for this player
|
|
getAllSpecialRowCards() {
|
|
return this.getAllSpecialRows().reduce((a, r) => r.cards.concat(a), []);
|
|
}
|
|
|
|
// Prepare game and UI to let the player select where on the board to play the given card
|
|
selectCardDestination(card,src=null,callback=null) {
|
|
// Move from deck to hand
|
|
if(src)
|
|
src.removeCard(card);
|
|
this.hand.addCard(card);
|
|
// Enable board interaction - Force to select a destination
|
|
ui.showPreviewVisuals(card);
|
|
document.getElementById("click-background").classList.add("noclick");
|
|
this.hand.cards.forEach(c => c.elem.classList.add("noclick"));
|
|
ui.setSelectable(card, true);
|
|
// Prevent the end of turn while selecting cards
|
|
this.endturn_action = async () => {
|
|
this.endturn_action = null;
|
|
if (callback)
|
|
callback();
|
|
}
|
|
ui.enablePlayer(true);
|
|
}
|
|
}
|
|
|
|
function alteraClicavel(obj, add) {
|
|
try {
|
|
if (!add && fileira_clicavel.elem.id == obj.elem.id) fileira_clicavel = null;
|
|
else fileira_clicavel = obj;
|
|
} catch (err) { }
|
|
}
|
|
|
|
// Handles the adding, removing and formatting of cards in a container
|
|
class CardContainer {
|
|
constructor(elem) {
|
|
this.elem = elem;
|
|
this.cards = [];
|
|
}
|
|
|
|
// Indicates whether or not this container contains any card
|
|
isEmpty() {
|
|
return this.cards.length === 0;
|
|
}
|
|
|
|
// Returns the first card that satisfies the predcicate. Does not modify container.
|
|
findCard(predicate) {
|
|
for (let i = this.cards.length - 1; i >= 0; --i)
|
|
if (predicate(this.cards[i]))
|
|
return this.cards[i];
|
|
}
|
|
|
|
// Returns a list of cards that satisfy the predicate. Does not modify container.
|
|
findCards(predicate) {
|
|
return this.cards.filter(predicate);
|
|
}
|
|
|
|
// Indicates whether or not the card with given Key can be found in container
|
|
containsCardByKey(key) {
|
|
return (this.findCards(c => c.key === key).length) > 0;
|
|
}
|
|
|
|
// Returns a list of up to n cards that satisfy the predicate. Does not modify container.
|
|
findCardsRandom(predicate, n) {
|
|
let valid = predicate ? this.cards.filter(predicate) : this.cards;
|
|
if (valid.length === 0)
|
|
return [];
|
|
if (!n || n === 1)
|
|
return [valid[randomInt(valid.length)]];
|
|
// Randum shuffle then select first n items
|
|
valid = [...valid].sort(() => 0.5 - Math.random())
|
|
return valid.slice(0, n);
|
|
}
|
|
|
|
// Removes and returns a list of cards that satisy the predicate.
|
|
getCards(predicate) {
|
|
return this.cards.reduce((a, c, i) => (predicate(c, i) ? [i] : []).concat(a), []).map(i => this.removeCard(i));
|
|
}
|
|
|
|
// Removes and returns a card that satisfies the predicate.
|
|
getCard(predicate) {
|
|
for (let i = this.cards.length - 1; i >= 0; --i)
|
|
if (predicate(this.cards[i]))
|
|
return this.removeCard(i);
|
|
}
|
|
|
|
// Removes and returns any cards up to n that satisfy the predicate.
|
|
getCardsRandom(predicate, n) {
|
|
return this.findCardsRandom(predicate, n).map(c => this.removeCard(c));
|
|
}
|
|
|
|
// Adds a card to the container along with its associated HTML element.
|
|
addCard(card, index) {
|
|
this.cards.push(card);
|
|
this.addCardElement(card, index ? index : 0);
|
|
this.resize();
|
|
card.currentLocation = this;
|
|
}
|
|
|
|
// Removes a card from the container along with its associated HTML element.
|
|
removeCard(card, index) {
|
|
if (this.cards.length === 0)
|
|
throw "Cannot draw from empty " + this.constructor.name;
|
|
card = this.cards.splice(isNumber(card) ? card : this.cards.indexOf(card), 1)[0];
|
|
this.removeCardElement(card, index ? index : 0);
|
|
this.resize();
|
|
if (card.temporaryPower) {
|
|
card.basePower = card.originalBasePower;
|
|
card.originalBasePower = null;
|
|
card.temporaryPower = false;
|
|
}
|
|
return card;
|
|
}
|
|
|
|
// Adds a card to a pre-sorted CardContainer
|
|
addCardSorted(card) {
|
|
let i = this.getSortedIndex(card);
|
|
this.cards.splice(i, 0, card);
|
|
return i;
|
|
}
|
|
|
|
// Returns the expected index of a card in a sorted CardContainer
|
|
getSortedIndex(card) {
|
|
for (var i = 0; i < this.cards.length; ++i)
|
|
if (Card.compare(card, this.cards[i]) < 0)
|
|
break;
|
|
return i;
|
|
}
|
|
|
|
// Adds a card to a random index of the CardContainer
|
|
addCardRandom(card) {
|
|
this.cards.push(card);
|
|
let index = randomInt(this.cards.length);
|
|
if (index !== this.cards.length - 1) {
|
|
let t = this.cards[this.cards.length - 1];
|
|
this.cards[this.cards.length - 1] = this.cards[index];
|
|
this.cards[index] = t;
|
|
}
|
|
card.currentLocation = this;
|
|
return index;
|
|
}
|
|
|
|
// Removes the HTML element associated with the card from this CardContainer
|
|
removeCardElement(card, index) {
|
|
if (this.elem)
|
|
this.elem.removeChild(card.elem);
|
|
}
|
|
|
|
// Adds the HTML element associated with the card to this CardContainer
|
|
addCardElement(card, index) {
|
|
if (this.elem) {
|
|
if (index === this.cards.length)
|
|
this.elem.appendChild(card.elem);
|
|
else
|
|
this.elem.insertBefore(card.elem, this.elem.children[index]);
|
|
}
|
|
}
|
|
|
|
// Empty function to be overried by subclasses that resize their content
|
|
resize() { }
|
|
|
|
// Modifies the margin of card elements inside a row-like container to stack properly
|
|
resizeCardContainer(overlap_count, gap, coef) {
|
|
let n = this.elem.children.length;
|
|
let param = (n < overlap_count) ? "" + gap + "vw" : defineCardRowMargin(n, coef);
|
|
let children = this.elem.getElementsByClassName("card");
|
|
for (let x of children)
|
|
x.style.marginLeft = x.style.marginRight = param;
|
|
|
|
function defineCardRowMargin(n, coef = 0) {
|
|
return "calc((100% - (4.45vw * " + n + ")) / (2*" + n + ") - (" + coef + "vw * " + n + "))";
|
|
}
|
|
}
|
|
|
|
// Allows the row to be clicked
|
|
setSelectable() {
|
|
this.elem.classList.add("row-selectable");
|
|
alteraClicavel(this, true);
|
|
}
|
|
|
|
// Disallows the row to be clicked
|
|
clearSelectable() {
|
|
this.elem.classList.remove("row-selectable");
|
|
alteraClicavel(this, false);
|
|
for (card in this.cards)
|
|
card.elem.classList.add("noclick");
|
|
}
|
|
|
|
// Returns the container to its default, empty state
|
|
reset() {
|
|
while (this.cards.length)
|
|
this.removeCard(0);
|
|
if (this.elem)
|
|
while (this.elem.firstChild)
|
|
this.elem.removeChild(this.elem.firstChild);
|
|
this.cards = [];
|
|
}
|
|
|
|
}
|
|
|
|
// Contians all used cards in the order that they were discarded
|
|
class Grave extends CardContainer {
|
|
constructor(elem) {
|
|
super(elem)
|
|
elem.addEventListener("click", () => ui.viewCardsInContainer(this), false);
|
|
}
|
|
|
|
// Override
|
|
addCard(card) {
|
|
this.setCardOffset(card, this.cards.length);
|
|
super.addCard(card, this.cards.length);
|
|
card.destructionRound = game.roundCount;
|
|
}
|
|
|
|
// Override
|
|
removeCard(card) {
|
|
let n = isNumber(card) ? card : this.cards.indexOf(card);
|
|
return super.removeCard(card, n);
|
|
}
|
|
|
|
// Override
|
|
removeCardElement(card, index) {
|
|
card.elem.style.left = "";
|
|
for (let i = index; i < this.cards.length; ++i) this.setCardOffset(this.cards[i], i);
|
|
super.removeCardElement(card, index);
|
|
}
|
|
|
|
// Offsets the card element in the deck
|
|
setCardOffset(card, n) {
|
|
card.elem.style.left = -0.03 * n + "vw";
|
|
}
|
|
}
|
|
|
|
// Contians all special cards for a given row
|
|
class RowSpecial extends CardContainer {
|
|
constructor(elem, row) {
|
|
super(elem)
|
|
this.row = row;
|
|
}
|
|
|
|
// Override
|
|
addCard(card) {
|
|
this.setCardOffset(card, this.cards.length);
|
|
super.addCard(card, this.cards.length);
|
|
}
|
|
|
|
// Override
|
|
removeCard(card) {
|
|
let n = isNumber(card) ? card : this.cards.indexOf(card);
|
|
if (card.removed) {
|
|
for (let x of card.removed)
|
|
x(card);
|
|
}
|
|
return super.removeCard(card, n);
|
|
}
|
|
|
|
// Override
|
|
removeCardElement(card, index) {
|
|
card.elem.style.left = "";
|
|
for (let i = index; i < this.cards.length; ++i) this.setCardOffset(this.cards[i], i);
|
|
super.removeCardElement(card, index);
|
|
}
|
|
|
|
// Offsets the card element in the deck
|
|
setCardOffset(card, n) {
|
|
card.elem.style.left = (1 + n) + "vw";
|
|
}
|
|
|
|
}
|
|
|
|
// Contains a randomized set of cards to be drawn from
|
|
class Deck extends CardContainer {
|
|
constructor(faction, elem) {
|
|
super(elem);
|
|
this.faction = faction;
|
|
|
|
this.counter = document.createElement("div");
|
|
this.counter.classList = "deck-counter center";
|
|
this.counter.appendChild(document.createTextNode(this.cards.length));
|
|
this.elem.appendChild(this.counter);
|
|
}
|
|
|
|
// Creates duplicates of cards with a count of more than one, then initializes deck
|
|
initializeFromID(card_id_list, player) {
|
|
this.initialize(card_id_list.reduce((a, c) => a.concat(clone(c.count, c)), []), player);
|
|
|
|
function clone(n, elem) {
|
|
for (var i = 0, a = []; i < n; ++i) a.push(elem);
|
|
return a;
|
|
}
|
|
}
|
|
|
|
// Populates a this deck with a list of card data and associated those cards with the owner of this deck.
|
|
initialize(card_data_list, player) {
|
|
this.player = player;
|
|
for (let i = 0; i < card_data_list.length; ++i) {
|
|
let card = new Card(card_data_list[i].index, card_dict[card_data_list[i].index], player);
|
|
card.holder = player;
|
|
this.addCardRandom(card);
|
|
this.addCardElement();
|
|
}
|
|
this.resize();
|
|
}
|
|
|
|
// Override
|
|
addCard(card) {
|
|
this.addCardRandom(card);
|
|
this.addCardElement();
|
|
this.resize();
|
|
card.currentLocation = this;
|
|
}
|
|
|
|
// Sends the top card to the passed hand
|
|
async draw(hand) {
|
|
tocar("game_buy", false);
|
|
// In case a player draws from opponent deck
|
|
if (hand.player && this.player !== hand.player)
|
|
this.cards[0].holder = hand.player;
|
|
if (hand instanceof HandAI)
|
|
hand.addCard(this.removeCard(0));
|
|
else
|
|
await board.toHand(this.cards[0], this, hand);
|
|
}
|
|
|
|
// Draws a card and sends it to the container before adding a card from the container back to the deck.
|
|
swap(container, card) {
|
|
container.addCard(this.removeCard(0));
|
|
this.addCard(card);
|
|
}
|
|
|
|
// Override
|
|
addCardElement() {
|
|
let elem = document.createElement("div");
|
|
elem.classList.add("deck-card");
|
|
elem.style.backgroundImage = iconURL("deck_back_" + this.faction, "jpg");
|
|
this.setCardOffset(elem, this.cards.length - 1);
|
|
this.elem.insertBefore(elem, this.counter);
|
|
}
|
|
|
|
// Override
|
|
removeCardElement() {
|
|
this.elem.removeChild(this.elem.children[this.cards.length]).style.left = "";
|
|
}
|
|
|
|
// Offsets the card element in the deck
|
|
setCardOffset(elem, n) {
|
|
elem.style.left = -0.03 * n + "vw";
|
|
}
|
|
|
|
// Override
|
|
resize() {
|
|
this.counter.innerHTML = this.cards.length;
|
|
this.setCardOffset(this.counter, this.cards.length);
|
|
}
|
|
|
|
// Override
|
|
reset() {
|
|
super.reset();
|
|
this.elem.appendChild(this.counter);
|
|
}
|
|
}
|
|
|
|
// Hand used by computer AI. Has an offscreen HTML element for card transitions.
|
|
class HandAI extends CardContainer {
|
|
constructor(tag) {
|
|
super(undefined, tag);
|
|
this.player = null;
|
|
if (this.tag === "me") {
|
|
this.counter = document.getElementById("hand-count-me");
|
|
this.hidden_elem = document.getElementById("hand-me");
|
|
} else {
|
|
this.counter = document.getElementById("hand-count-op");
|
|
this.hidden_elem = document.getElementById("hand-op");
|
|
}
|
|
|
|
}
|
|
resize() {
|
|
this.counter.innerHTML = this.cards.length;
|
|
}
|
|
}
|
|
|
|
// Hand used by current player
|
|
class Hand extends CardContainer {
|
|
constructor(elem, tag) {
|
|
super(elem);
|
|
this.tag = tag;
|
|
this.player = null;
|
|
if (this.tag === "me") {
|
|
this.counter = document.getElementById("hand-count-me");
|
|
} else {
|
|
this.counter = document.getElementById("hand-count-op");
|
|
}
|
|
}
|
|
|
|
// Override
|
|
addCard(card) {
|
|
let i = this.addCardSorted(card);
|
|
this.addCardElement(card, i);
|
|
this.resize();
|
|
card.currentLocation = this;
|
|
}
|
|
|
|
// Override
|
|
resize() {
|
|
this.counter.innerHTML = this.cards.length;
|
|
this.resizeCardContainer(11, 0.075, .00225);
|
|
}
|
|
|
|
toggleDisplay() {
|
|
if (this.elem.hidden) {
|
|
this.elem.style.visibility = "visible";
|
|
} else {
|
|
this.elem.style.visibility = "hidden";
|
|
}
|
|
this.elem.hidden = !this.elem.hidden;
|
|
}
|
|
|
|
hide() {
|
|
this.elem.style.visibility = "hidden";
|
|
}
|
|
|
|
show() {
|
|
this.elem.style.visibility = "visible";
|
|
}
|
|
}
|
|
|
|
var may_act_card = true;
|
|
|
|
// Contains active cards and effects. Calculates the current score of each card and the row.
|
|
class Row extends CardContainer {
|
|
constructor(elem) {
|
|
super(elem.getElementsByClassName("row-cards")[0]);
|
|
this.elem_parent = elem;
|
|
this.special = new RowSpecial(elem.getElementsByClassName("row-special")[0], this);
|
|
this.total = 0;
|
|
this.effects = {
|
|
weather: false,
|
|
weather_type: "",
|
|
bond: {},
|
|
morale: 0,
|
|
horn: 0,
|
|
mardroeme: 0,
|
|
shield: 0,
|
|
lock: 0,
|
|
curse: 0,
|
|
toussaint_wine: 0,
|
|
ambush: false
|
|
};
|
|
this.halfWeather = false;
|
|
this.elem.addEventListener("click", () => ui.selectRow(this), true);
|
|
this.elem.addEventListener("mouseover", function () {
|
|
if (hover_row) {
|
|
tocar("card", false);
|
|
this.style.boxShadow = "0 0 1.5vw #6d5210";
|
|
}
|
|
});
|
|
this.elem.addEventListener("mouseout", function () {
|
|
this.style.boxShadow = "0 0 0 #6d5210"
|
|
});
|
|
window.addEventListener("keydown", function (e) {
|
|
if (e.keyCode == 13 && fileira_clicavel !== null && may_act_card) {
|
|
ui.selectRow(fileira_clicavel);
|
|
may_act_card = false;
|
|
fileira_clicavel = null;
|
|
}
|
|
});
|
|
window.addEventListener("keyup", function (e) {
|
|
if (e.keyCode == 13) may_act_card = true;
|
|
});
|
|
this.special.elem.addEventListener("click", () => ui.selectRow(this, true), false, true);
|
|
}
|
|
|
|
// Override
|
|
async addCard(card, runEffect = true) {
|
|
if (card.isSpecial()) {
|
|
this.special.addCard(card);
|
|
} else {
|
|
let index = this.addCardSorted(card);
|
|
this.addCardElement(card, index);
|
|
this.resize();
|
|
}
|
|
card.currentLocation = this;
|
|
if (this.effects.curse && card.isUnit()) {
|
|
this.effects.curse = Math.max(this.effects.curse - 1, 0);
|
|
await card.animate("curse");
|
|
await board.toGrave(card, this);
|
|
let curse_card = this.special.findCard(c => c.abilities.includes("curse"));
|
|
await board.toGrave(curse_card, this.special);
|
|
return;
|
|
} else if (this.effects.lock && card.isUnit() && card.abilities.length) {
|
|
card.locked = true;
|
|
this.effects.lock = Math.max(this.effects.lock - 1, 0);
|
|
let lock_card = this.special.findCard(c => c.abilities.includes("lock"));
|
|
// If several units arrive at the same time, it can be triggered several times, so we first remove the lock before doing animations
|
|
if (lock_card)
|
|
await board.toGrave(lock_card, this.special);
|
|
await card.animate("lock");
|
|
}
|
|
// Some cards have abilities with permanent row effects - such has horn, bond or morale
|
|
if (!runEffect && card.abilities.length > 0) {
|
|
for (var i = 0; i < card.abilities.length; i++) {
|
|
if ("effectAfterMove" in ability_dict[card.abilities[i]] && ability_dict[card.abilities[i]]["effectAfterMove"])
|
|
runEffect = true;
|
|
}
|
|
}
|
|
if (runEffect && !card.isLocked()) {
|
|
this.updateState(card, true);
|
|
for (let x of card.placed)
|
|
await x(card, this);
|
|
}
|
|
if (runEffect && this.effects.ambush) {
|
|
let ambushCards = this.cards.filter(c => c.abilities.includes("ambush") &&
|
|
(c.holder !== card.holder && !card.abilities.includes("spy") && !card.abilities.includes("emissary")) ||
|
|
(c.holder === card.holder && (card.abilities.includes("spy") || card.abilities.includes("emissary")))); // Spy/Emissaries switch sides before being placed and would have triggerd when played by the owner of an ambush card
|
|
if (ambushCards.length > 0 && ambushCards[0] !== card) {
|
|
let targetCard = ambushCards[0];
|
|
// Remove status first before animations to avoid triggering the ambush several times when several cards arrive at the same time
|
|
if (ambushCards.length < 2)
|
|
this.effects.ambush = false;
|
|
// Owner draws 2 cards
|
|
await targetCard.animate("ambush");
|
|
targetCard.holder.deck.draw(targetCard.holder.hand);
|
|
targetCard.holder.deck.draw(targetCard.holder.hand);
|
|
// Cards goes to the grave
|
|
await board.toGrave(targetCard, targetCard.currentLocation);
|
|
|
|
}
|
|
}
|
|
card.elem.classList.add("noclick");
|
|
await sleep(600);
|
|
//this.updateScore();
|
|
// Let's update all rows for better accuracy
|
|
board.updateScores();
|
|
}
|
|
|
|
// Override
|
|
removeCard(card, runEffect = true) {
|
|
// TODO: This case should no longer happen
|
|
if (isNumber(card) && card === -1) {
|
|
card = this.special.cards[0];
|
|
this.special.reset();
|
|
return card;
|
|
}
|
|
card = isNumber(card) ? this.cards[card] : card;
|
|
if (card.isSpecial()) {
|
|
this.special.removeCard(card);
|
|
} else {
|
|
super.removeCard(card);
|
|
card.resetPower();
|
|
card.locked = false;
|
|
}
|
|
this.updateState(card, false);
|
|
if (runEffect) {
|
|
if (!card.decoyTarget) {
|
|
for (let x of card.removed)
|
|
x(card);
|
|
} else {
|
|
card.decoyTarget = false;
|
|
}
|
|
|
|
}
|
|
this.updateScore();
|
|
return card;
|
|
}
|
|
|
|
// Override
|
|
removeCardElement(card, index) {
|
|
super.removeCardElement(card, index);
|
|
let x = card.elem;
|
|
x.style.marginLeft = x.style.marginRight = "";
|
|
x.classList.remove("noclick");
|
|
}
|
|
|
|
// Updates a card's effect on the row
|
|
updateState(card, activate) {
|
|
for (let x of card.abilities) {
|
|
if (!card.isLocked()) {
|
|
switch (x) {
|
|
case "morale":
|
|
case "horn":
|
|
case "mardroeme":
|
|
case "lock":
|
|
case "curse":
|
|
case "toussaint_wine":
|
|
this.effects[x] += activate ? 1 : -1;
|
|
break;
|
|
case "shield":
|
|
case "shield_c":
|
|
case "shield_r":
|
|
case "shield_s":
|
|
if (activate)
|
|
Promise.all(this.cards.filter(c => c.isUnit()).map(c => c.animate("shield")));
|
|
this.effects["shield"] += activate ? 1 : -1;
|
|
break;
|
|
case "bond":
|
|
if (!this.effects.bond[card.target])
|
|
this.effects.bond[card.target] = 0;
|
|
this.effects.bond[card.target] += activate ? 1 : -1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Activates weather effect and visuals
|
|
addOverlay(overlay) {
|
|
var som = overlay == "fog" || overlay == "rain" ? overlay : overlay == "frost" ? "cold" : "";
|
|
if (som != "") tocar(som, false);
|
|
this.effects.weather = true;
|
|
this.effects.weather_type = overlay;
|
|
this.elem_parent.getElementsByClassName("row-weather")[0].classList.add(overlay);
|
|
this.updateScore();
|
|
}
|
|
|
|
// Deactivates weather effect and visuals
|
|
removeOverlay(overlay) {
|
|
this.effects.weather = false;
|
|
this.effects.weather_type = "";
|
|
this.elem_parent.getElementsByClassName("row-weather")[0].classList.remove(overlay);
|
|
this.updateScore();
|
|
}
|
|
|
|
// Override
|
|
resize() {
|
|
this.resizeCardContainer(10, 0.075, .00325);
|
|
}
|
|
|
|
// Updates the row's score by summing the current power of its cards
|
|
updateScore() {
|
|
let total = 0;
|
|
for (let card of this.cards) {
|
|
total += this.cardScore(card);
|
|
}
|
|
let player = this.elem_parent.parentElement.id === "field-op" ? player_op : player_me;
|
|
player.updateTotal(total - this.total);
|
|
this.total = total;
|
|
this.elem_parent.getElementsByClassName("row-score")[0].innerHTML = this.total;
|
|
}
|
|
|
|
// Calculates and set the card's current power
|
|
cardScore(card) {
|
|
let total = this.calcCardScore(card);
|
|
card.setPower(total);
|
|
return total;
|
|
}
|
|
|
|
// Calculates the current power of a card affected by row affects
|
|
calcCardScore(card) {
|
|
if (card.key === "spe_decoy")
|
|
return 0;
|
|
let total = card.basePower * card.multiplier;
|
|
if (card.hero)
|
|
return total;
|
|
if (card.abilities.includes("spy") || card.abilities.includes("emissary"))
|
|
total = Math.floor(game.spyPowerMult * total);
|
|
// Inspire - changes base strength, before weather
|
|
if (card.abilities.includes("inspire") && !card.isLocked()) {
|
|
let inspires = card.holder.getAllRowCards().filter(c => !c.isLocked() && c.abilities.includes("inspire"));
|
|
if (inspires.length > 1) {
|
|
let maxBase = inspires.reduce((a, b) => a.power > b.power ? a : b);
|
|
total = maxBase.power;
|
|
}
|
|
}
|
|
if (this.effects.weather)
|
|
if (!(card.abilities.includes("fog_summoning") && this.effects.weather_type === "fog")) {
|
|
if (this.halfWeather)
|
|
total = Math.max(Math.min(1, total), Math.floor(total / 2)); // 2 special cases, if intially 1, we want to keep one, not 0 (floor(0.5)). If 0, we want to keep 0, not 1
|
|
else
|
|
total = Math.min(1, total);
|
|
}
|
|
// Bond
|
|
if (card.abilities.includes("bond")) {
|
|
let bond = this.effects.bond[card.target];
|
|
if (isNumber(bond) && bond > 1 && !card.isLocked())
|
|
total *= Number(bond);
|
|
}
|
|
// Morale
|
|
total += Math.max(0, this.effects.morale + (card.abilities.includes("morale") ? -1 : 0));
|
|
// Toussiant Wine
|
|
total += Math.max(0, 3 * this.effects.toussaint_wine);
|
|
// Witcher Schools
|
|
if (card.abilities.at(-1) && card.abilities.at(-1).startsWith("witcher_") && !card.isLocked()) {
|
|
let school = card.abilities.at(-1);
|
|
if (card.holder.effects["witchers"][school]) {
|
|
total += (card.holder.effects["witchers"][school] - 1) * 2;
|
|
}
|
|
}
|
|
// Whorshipped
|
|
if (card.abilities.includes("whorshipped") && card.holder.effects["whorshippers"] > 0 && !card.isLocked())
|
|
total += card.holder.effects["whorshippers"] * game.whorshipBoost;
|
|
// Horn
|
|
if (this.effects.horn - (card.abilities.includes("horn") ? 1 : 0) > 0)
|
|
total *= 2;
|
|
return total;
|
|
}
|
|
|
|
// Applies a temporary leader horn affect that is removed at the end of the round
|
|
async leaderHorn(card) {
|
|
if (this.special.containsCardByKey("spe_horn"))
|
|
return;
|
|
let horn = new Card("spe_horn", card_dict["spe_horn"], card.holder);
|
|
await this.addCard(horn);
|
|
game.roundEnd.push(() => this.removeCard(horn));
|
|
}
|
|
|
|
// Applies a local scorch effect to this row
|
|
async scorch() {
|
|
if (this.total >= 10 && !this.isShielded() && !game.scorchCancelled)
|
|
await Promise.all(this.maxUnits().map(async c => {
|
|
await c.animate("scorch", true, false);
|
|
await board.toGrave(c, this);
|
|
}));
|
|
}
|
|
|
|
// Removes all cards and effects from this row
|
|
clear() {
|
|
this.special.cards.filter(c => !c.noRemove).forEach(c => board.toGrave(c, this, true));
|
|
this.cards.filter(c => !c.noRemove).forEach(c => board.toGrave(c, this, true));
|
|
}
|
|
|
|
// Returns all regular unit cards with the heighest power
|
|
maxUnits() {
|
|
let max = [];
|
|
for (let i = 0; i < this.cards.length; ++i) {
|
|
let card = this.cards[i];
|
|
if (!card.isUnit() || card.isImmortal())
|
|
continue;
|
|
if (!max[0] || max[0].power < card.power)
|
|
max = [card];
|
|
else if (max[0].power === card.power)
|
|
max.push(card);
|
|
}
|
|
return max;
|
|
}
|
|
|
|
minUnits() {
|
|
let min = [];
|
|
for (let i = 0; i < this.cards.length; ++i) {
|
|
let card = this.cards[i];
|
|
if (!card.isUnit() || card.isImmortal())
|
|
continue;
|
|
if (!min[0] || min[0].power > card.power)
|
|
min = [card];
|
|
else if (min[0].power === card.power)
|
|
min.push(card);
|
|
}
|
|
return min;
|
|
}
|
|
|
|
// Override
|
|
reset() {
|
|
super.reset();
|
|
this.special.reset();
|
|
this.total = 0;
|
|
this.effects = {
|
|
weather: false,
|
|
bond: {},
|
|
morale: 0,
|
|
horn: 0,
|
|
mardroeme: 0,
|
|
shield: 0,
|
|
lock: 0,
|
|
curse: 0,
|
|
toussaint_wine: 0,
|
|
ambush: false
|
|
};
|
|
}
|
|
|
|
// Indicates whether or not a shield is protecting that row from abilities (does not protect from weather effects though)
|
|
isShielded() {
|
|
return (this.effects.shield > 0);
|
|
}
|
|
|
|
// True if at least 1 unit and total of power >= 10
|
|
canBeScorched() {
|
|
if (game.scorchCancelled)
|
|
return false;
|
|
return (this.cards.reduce((a, c) => a + c.power, 0) >= 10) && (this.cards.filter(c => c.isUnit()).length > 0);
|
|
}
|
|
|
|
// Return the index of the current row in the list of rows on the board
|
|
getRowIndex() {
|
|
for (let i = 0; i < board.row.length; i++) {
|
|
if (board.row[i] === this)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// Returns the opposite Row object - the one on the opponent's side of the field
|
|
getOppositeRow() {
|
|
let index = 5 - this.getRowIndex();
|
|
if (index >= 0 && index < board.row.length)
|
|
return board.row[index]
|
|
return null;
|
|
}
|
|
|
|
// Debug/cheat - Invokes any given card to the row
|
|
invokeCard(key) {
|
|
let player = this.elem_parent.parentElement.id === "field-op" ? player_op : player_me;
|
|
this.addCard(new Card(key, card_dict[key], player), true)
|
|
}
|
|
}
|
|
|
|
// Handles how weather effects are added and removed
|
|
class Weather extends CardContainer {
|
|
constructor(elem) {
|
|
super(document.getElementById("weather"));
|
|
this.types = {
|
|
rain: {
|
|
name: "rain",
|
|
count: 0,
|
|
rows: []
|
|
},
|
|
fog: {
|
|
name: "fog",
|
|
count: 0,
|
|
rows: []
|
|
},
|
|
frost: {
|
|
name: "frost",
|
|
count: 0,
|
|
rows: []
|
|
}
|
|
}
|
|
let i = 0;
|
|
for (let key of Object.keys(this.types))
|
|
this.types[key].rows = [board.row[i], board.row[5 - i++]];
|
|
|
|
this.elem.addEventListener("click", () => ui.selectRow(this), false);
|
|
}
|
|
|
|
// Adds a card if unique and clears all weather if 'clear weather' card added
|
|
async addCard(card, withEffects = true) {
|
|
super.addCard(card);
|
|
card.elem.classList.add("noclick");
|
|
if (!withEffects)
|
|
return;
|
|
// Run possible actions
|
|
if (withEffects && !card.isLocked()) {
|
|
for (let x of card.placed)
|
|
await x(card, this);
|
|
}
|
|
if (card.key === "spe_clear") {
|
|
// TODO Sunlight animation
|
|
tocar("clear", false);
|
|
await sleep(500);
|
|
this.clearWeather();
|
|
} else {
|
|
this.changeWeather(card, x => ++this.types[x].count === 1, (r, t) => r.addOverlay(t.name));
|
|
for (let i = this.cards.length - 2; i >= 0; --i) {
|
|
if (card.abilities.at(-1) === this.cards[i].abilities.at(-1)) {
|
|
await sleep(750);
|
|
await board.toGrave(card, this);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
await sleep(750);
|
|
}
|
|
|
|
// Override
|
|
removeCard(card, withEffects = true) {
|
|
card = super.removeCard(card);
|
|
card.elem.classList.remove("noclick");
|
|
if (withEffects) {
|
|
this.changeWeather(card, x => --this.types[x].count === 0, (r, t) => r.removeOverlay(t.name));
|
|
// Run possible actions
|
|
if (withEffects && !card.isLocked()) {
|
|
for (let x of card.removed) {
|
|
x(card, this);
|
|
}
|
|
}
|
|
}
|
|
return card;
|
|
}
|
|
|
|
// Checks if a card's abilities are a weather type. If the predicate is met, perfom the action
|
|
// on the type's associated rows
|
|
changeWeather(card, predicate, action) {
|
|
for (let x of card.abilities) {
|
|
if (x in this.types && predicate(x)) {
|
|
for (let r of this.types[x].rows)
|
|
action(r, this.types[x]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Removes all weather effects and cards
|
|
async clearWeather() {
|
|
await Promise.all(this.cards.map((c, i) => this.cards[this.cards.length - i - 1]).map(c => board.toGrave(c, this)));
|
|
}
|
|
|
|
// Override
|
|
resize() {
|
|
this.resizeCardContainer(4, 0.075, .045);
|
|
}
|
|
|
|
// Override
|
|
reset() {
|
|
super.reset();
|
|
Object.keys(this.types).map(t => this.types[t].count = 0);
|
|
}
|
|
}
|
|
|
|
//
|
|
class Board {
|
|
constructor() {
|
|
this.op_score = 0;
|
|
this.me_score = 0;
|
|
this.row = [];
|
|
for (let x = 0; x < 6; ++x) {
|
|
let elem = document.getElementById((x < 3) ? "field-op" : "field-me").children[x % 3];
|
|
this.row[x] = new Row(elem);
|
|
}
|
|
}
|
|
|
|
// Get the opponent of this Player
|
|
opponent(player) {
|
|
return player === player_me ? player_op : player_me;
|
|
}
|
|
|
|
// Sends and translates a card from the source to the Deck of the card's holder
|
|
async toDeck(card, source) {
|
|
tocar("discard", false);
|
|
await this.moveTo(card, "deck", source);
|
|
}
|
|
|
|
// Sends and translates a card from the source to the Grave of the card's holder
|
|
async toGrave(card, source, turnEnd=false) {
|
|
let destroy = true;
|
|
let protectors = null;
|
|
if (card.isUnit() && source instanceof Row) {
|
|
|
|
// Checking Protection abilities such as Comrade
|
|
protectors = card.holder.getAllRowCards().filter(c => c.abilities.includes("comrade") && c.protects);
|
|
if (protectors.length > 0) {
|
|
let choice = false;
|
|
if (!(card.holder.controller instanceof ControllerAI)) {
|
|
choice = await ui.popup("Save it [E]", () => true, "Let it die [Q]", () => false, "Do you want to save this unit?", "Comrade ability can prevent the destruction of the following card: " + card.name + " (strength: " + card.power + "). Do you want to save it?");
|
|
if (choice) {
|
|
destroy = false;
|
|
protectors[0].protects = false;
|
|
}
|
|
|
|
} else {
|
|
// AI saves the unit only if its value is > 5
|
|
if (card.power > 5) {
|
|
protectors[0].protects = false;
|
|
destroy = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (destroy) {
|
|
await this.moveTo(card, "grave", source);
|
|
if (game.unitDestroyed && game.unitDestroyed.length > 0 && !turnEnd) {
|
|
for (var i = 0; i < game.unitDestroyed.length; i++) {
|
|
let cb = game.unitDestroyed[i];
|
|
if (await cb(card))
|
|
game.unitDestroyed.splice(i, 1)
|
|
}
|
|
}
|
|
} else {
|
|
card.animate("comrade");
|
|
await protectors[0].animate("comrade");
|
|
}
|
|
}
|
|
|
|
// Sends and translates a card from the source to the Hand of the card's holder
|
|
// Possible to specify a different destination
|
|
async toHand(card, source, dest = null) {
|
|
await this.moveTo(card, dest ? dest : "hand", source);
|
|
}
|
|
|
|
// Sends and translates a card from the source to Weather
|
|
async toWeather(card, source) {
|
|
await this.moveTo(card, weather, source);
|
|
}
|
|
|
|
// Sends and translates a card from the source to the Deck of the card's combat row
|
|
async toRow(card, source) {
|
|
let row = ["close", "agile", "agile_cr", "agile_cs", "agile_crs"].includes(card.row) ? "close" : ["ranged", "agile_rs"].includes(card.row) ? "ranged" : card.row ? card.row : "close";
|
|
await this.moveTo(card, row, source);
|
|
}
|
|
|
|
// Sends and translates a card from the source to a specified row name or CardContainer
|
|
async moveTo(card, dest, source = null) {
|
|
if (isString(dest)) dest = this.getRow(card, dest);
|
|
try {
|
|
cartaNaLinha(dest.elem.id, card);
|
|
} catch (err) { }
|
|
await translateTo(card, source ? source : null, dest);
|
|
if (dest instanceof Row || dest instanceof Weather)
|
|
await dest.addCard(source ? source.removeCard(card) : card); //Only the override in the Row/Weather classes are asynchronous
|
|
else
|
|
dest.addCard(source ? source.removeCard(card) : card);
|
|
}
|
|
|
|
// Sends and translates a card from the source to a specified row name or CardContainer - NO EFFECTS/ABILITIES
|
|
async moveToNoEffects(card, dest, source = null) {
|
|
if (isString(dest)) dest = this.getRow(card, dest);
|
|
try {
|
|
cartaNaLinha(dest.elem.id, card);
|
|
} catch (err) { }
|
|
await translateTo(card, source ? source : null, dest);
|
|
if (dest instanceof Row || dest instanceof Weather)
|
|
await dest.addCard(source ? source.removeCard(card, false) : card, false); //Only the override in the Row/Weather classes are asynchronous
|
|
else
|
|
dest.addCard(source ? source.removeCard(card) : card);
|
|
}
|
|
|
|
// Sends and translates a card from the source to a row name associated with the passed player
|
|
async addCardToRow(card, row_name, player, source) {
|
|
let row;
|
|
if (row_name instanceof Row) {
|
|
row = row_name;
|
|
} else {
|
|
row = this.getRow(card, row_name, player);
|
|
}
|
|
try {
|
|
cartaNaLinha(row.elem.id, card);
|
|
} catch (err) { }
|
|
await translateTo(card, source, row);
|
|
await row.addCard(card);
|
|
}
|
|
|
|
// Returns the Card associated with the row name that the card would be sent to
|
|
getRow(card, row_name, player) {
|
|
player = player ? player : card ? card.holder : player_me;
|
|
let isMe = player === player_me;
|
|
let isSpy = (card.abilities.includes("spy") || card.abilities.includes("emissary") || card.abilities.includes("ambush"));
|
|
switch (row_name) {
|
|
case "weather":
|
|
return weather;
|
|
break;
|
|
case "close":
|
|
return this.row[isMe ^ isSpy ? 3 : 2];
|
|
case "ranged":
|
|
return this.row[isMe ^ isSpy ? 4 : 1];
|
|
case "siege":
|
|
return this.row[isMe ^ isSpy ? 5 : 0];
|
|
case "grave":
|
|
return player.grave;
|
|
case "deck":
|
|
return player.deck;
|
|
case "hand":
|
|
return player.hand;
|
|
default:
|
|
console.error(card.name + " sent to incorrect row \"" + row_name + "\" by " + card.holder.name);
|
|
}
|
|
}
|
|
|
|
// Return the list of rows possible for the given card
|
|
getAgileRows(card, player) {
|
|
switch (card.row) {
|
|
case "agile":
|
|
case "agile_cr":
|
|
return [board.getRow(card, "close", player), board.getRow(card, "ranged", player)];
|
|
case "agile_cs":
|
|
return [board.getRow(card, "close", player), board.getRow(card, "siege", player)];
|
|
case "agile_rs":
|
|
return [board.getRow(card, "ranged", player), board.getRow(card, "siege", player)];
|
|
case "agile_crs":
|
|
return [board.getRow(card, "close", player), board.getRow(card, "ranged", player), board.getRow(card, "siege", player)];
|
|
default:
|
|
return [board.getRow(card, card.row, player)];
|
|
}
|
|
}
|
|
|
|
// Updates which player currently is in the lead
|
|
updateLeader() {
|
|
let dif = player_me.total - player_op.total;
|
|
player_me.setWinning(dif > 0);
|
|
player_op.setWinning(dif < 0);
|
|
}
|
|
|
|
updateScores() {
|
|
//this.row.map(r => r.cards.map(c => r.cardScore(c)));
|
|
this.row.map(r => r.updateScore());
|
|
}
|
|
}
|
|
|
|
function limpar() {
|
|
fileira_clicavel = null;
|
|
load_pass = load_passT;
|
|
may_pass1 = false;
|
|
may_pass2 = "";
|
|
may_pass3 = true;
|
|
timer2 = null;
|
|
lCard = null;
|
|
}
|
|
|
|
class Game {
|
|
constructor() {
|
|
this.endScreen = document.getElementById("end-screen");
|
|
let buttons = this.endScreen.getElementsByTagName("button");
|
|
this.customize_elem = buttons[0];
|
|
this.replay_elem = buttons[1];
|
|
this.customize_elem.addEventListener("click", () => this.returnToCustomization(), false);
|
|
this.replay_elem.addEventListener("click", () => this.restartGame(), false);
|
|
this.reset();
|
|
this.randomOPDeck = true;
|
|
this.mode = 1;
|
|
}
|
|
|
|
reset() {
|
|
this.firstPlayer;
|
|
this.currPlayer = null;
|
|
|
|
this.gameStart = [];
|
|
this.roundStart = [];
|
|
this.roundEnd = [];
|
|
this.turnStart = [];
|
|
this.turnEnd = [];
|
|
this.unitDestroyed = [];
|
|
|
|
this.roundCount = 0;
|
|
this.roundHistory = [];
|
|
this.over = false;
|
|
|
|
this.randomRespawn = false;
|
|
this.medicCount = 1;
|
|
this.whorshipBoost = 1;
|
|
this.spyPowerMult = 1;
|
|
this.decoyCancelled = false;
|
|
this.scorchCancelled = false;
|
|
|
|
// Also resetting some board/row properties affected during the course of a game
|
|
if (board) {
|
|
if (board.row) {
|
|
board.row.forEach(r => {
|
|
r.halfWeather = false;
|
|
});
|
|
}
|
|
}
|
|
|
|
weather.reset();
|
|
board.row.forEach(r => r.reset());
|
|
}
|
|
|
|
// Sets up player faction abilities and psasive leader abilities
|
|
initPlayers(p1, p2) {
|
|
let l1 = ability_dict[p1.leader.abilities[0]];
|
|
let l2 = ability_dict[p2.leader.abilities[0]];
|
|
let special_abilities = {
|
|
meve_white_queen: false
|
|
};
|
|
initLeader(p1, l1);
|
|
initLeader(p2, l2);
|
|
if (l1 === ability_dict["meve_white_queen"] || l2 === ability_dict["meve_white_queen"])
|
|
special_abilities["meve_white_queen"] = true;
|
|
if (p1.deck.faction === p2.deck.faction && p1.deck.faction === "scoiatael")
|
|
return special_abilities;
|
|
initFaction(p1);
|
|
initFaction(p2);
|
|
|
|
function initLeader(player, leader) {
|
|
if (leader.placed)
|
|
leader.placed(player.leader);
|
|
Object.keys(leader).filter(key => game[key]).map(key => game[key].push(leader[key]));
|
|
}
|
|
|
|
function initFaction(player) {
|
|
//Only passive faction abilities
|
|
if (factions[player.deck.faction] && factions[player.deck.faction].factionAbility && !factions[player.deck.faction].activeAbility)
|
|
factions[player.deck.faction].factionAbility(player);
|
|
}
|
|
|
|
return special_abilities;
|
|
}
|
|
|
|
// Sets initializes player abilities, player hands and redraw
|
|
async startGame() {
|
|
ui.toggleMusic_elem.classList.remove("music-customization");
|
|
var special_abilities = this.initPlayers(player_me, player_op);
|
|
await Promise.all([...Array(10).keys()].map(async () => {
|
|
await player_me.deck.draw(player_me.hand);
|
|
await player_op.deck.draw(player_op.hand);
|
|
}));
|
|
|
|
await this.runEffects(this.gameStart);
|
|
if (!this.firstPlayer)
|
|
this.firstPlayer = await this.coinToss();
|
|
if (special_abilities["meve_white_queen"]) await ui.notification("meve_white_queen", 1200);
|
|
this.initialRedraw();
|
|
somCarta();
|
|
}
|
|
|
|
// Simulated coin toss to determine who starts game
|
|
async coinToss() {
|
|
this.firstPlayer = (Math.random() < 0.5) ? player_me : player_op;
|
|
await ui.notification(this.firstPlayer.tag + "-coin", 1200);
|
|
return this.firstPlayer;
|
|
}
|
|
|
|
// Allows the player to swap out up to two cards from their iniitial hand
|
|
async initialRedraw() {
|
|
if (player_op.controller instanceof ControllerAI) {
|
|
if (player_op.leader.key === "sc_francesca_daisy") {
|
|
let cards = player_op.controller.discardOrder(player_op.leader, player_op.hand, true).splice(0, player_op.mulliganCount);
|
|
cards.forEach(c => {
|
|
board.toDeck(c, player_op.hand);
|
|
});
|
|
} else {
|
|
for (let i = 0; i < player_op.mulliganCount; i++)
|
|
player_op.controller.redraw();
|
|
}
|
|
}
|
|
if (player_me.controller instanceof ControllerAI) {
|
|
if (player_me.leader.key === "sc_francesca_daisy") {
|
|
let cards = player_me.controller.discardOrder(player_me.leader, player_me.hand, true).splice(0, player_me.mulliganCount);
|
|
cards.forEach(c => {
|
|
board.toDeck(c, player_me.hand);
|
|
});
|
|
} else {
|
|
for (let i = 0; i < player_me.mulliganCount; i++)
|
|
player_me.controller.redraw();
|
|
}
|
|
} else {
|
|
// player vs player - both have a redraw - player 1 first
|
|
if (this.mode === 3) {
|
|
if (player_me.leader.key === "sc_francesca_daisy") {
|
|
await ui.queueCarousel(player_me.hand, player_me.mulliganCount, async (c, i) => await board.toDeck(c.cards[i], c), c => true, true, false, "Player 1 - Choose " + player_me.mulliganCount +" cards to put back to deck.");
|
|
} else {
|
|
await ui.queueCarousel(player_me.hand, player_me.mulliganCount, async (c, i) => await player_me.deck.swap(c, c.removeCard(i)), c => true, true, true, "Player 1 - Choose up to " + player_me.mulliganCount +" cards to redraw.");
|
|
}
|
|
if (player_op.leader.key === "sc_francesca_daisy") {
|
|
await ui.queueCarousel(player_op.hand, player_op.mulliganCount, async (c, i) => await board.toDeck(c.cards[i], c), c => true, true, false, "Player 2 - Choose " + player_op.mulliganCount +" cards to put back to deck.");
|
|
} else {
|
|
await ui.queueCarousel(player_op.hand, player_op.mulliganCount, async (c, i) => await player_op.deck.swap(c, c.removeCard(i)), c => true, true, true, "Player 2 - Choose up to " + player_op.mulliganCount +" cards to redraw.");
|
|
}
|
|
} else {
|
|
if (player_me.leader.key === "sc_francesca_daisy") {
|
|
await ui.queueCarousel(player_me.hand, player_me.mulliganCount, async (c, i) => await board.toDeck(c.cards[i], c), c => true, true, false, "Choose " + player_me.mulliganCount +" cards to put back to deck.");
|
|
} else {
|
|
await ui.queueCarousel(player_me.hand, player_me.mulliganCount, async (c, i) => await player_me.deck.swap(c, c.removeCard(i)), c => true, true, true, "Choose up to " + player_me.mulliganCount +" cards to redraw.");
|
|
}
|
|
}
|
|
ui.enablePlayer(false);
|
|
}
|
|
game.startRound();
|
|
}
|
|
|
|
// Initiates a new round of the game
|
|
async startRound(verdict = false) {
|
|
this.roundCount++;
|
|
if (verdict && verdict.winner) {
|
|
//Last round winner starts the round, verdict.winner can be null if draw
|
|
this.currPlayer = verdict.winner.opponent();
|
|
} else {
|
|
this.currPlayer = (this.roundCount % 2 === 0) ? this.firstPlayer : this.firstPlayer.opponent();
|
|
}
|
|
player_me.roundStartReset();
|
|
player_op.roundStartReset();
|
|
|
|
await this.runEffects(this.roundStart);
|
|
|
|
board.row.map(r => r.updateScore());
|
|
|
|
if (!player_me.canPlay())
|
|
player_me.setPassed(true);
|
|
if (!player_op.canPlay())
|
|
player_op.setPassed(true);
|
|
|
|
if (player_op.passed && player_me.passed)
|
|
return this.endRound();
|
|
|
|
if (this.currPlayer.passed)
|
|
this.currPlayer = this.currPlayer.opponent();
|
|
|
|
await ui.notification("round-start", 1200);
|
|
if (this.currPlayer.opponent().passed)
|
|
await ui.notification(this.currPlayer.tag + "-turn", 1200);
|
|
|
|
this.startTurn();
|
|
}
|
|
|
|
// Starts a new turn. Enables client interraction in client's turn.
|
|
async startTurn() {
|
|
await this.runEffects(this.turnStart);
|
|
if (!this.currPlayer.opponent().passed) {
|
|
this.currPlayer = this.currPlayer.opponent();
|
|
await ui.notification(this.currPlayer.tag + "-turn", 1200);
|
|
}
|
|
ui.enablePlayer(this.currPlayer === player_me);
|
|
// Player vs player - hide opponent's hand
|
|
if (game.isPvP()) {
|
|
this.currPlayer.opponent().hand.hide();
|
|
this.currPlayer.hand.show();
|
|
}
|
|
this.currPlayer.startTurn();
|
|
}
|
|
|
|
// Ends the current turn and may end round. Disables client interraction in client's turn.
|
|
async endTurn(noEffects=false) {
|
|
if (this.currPlayer === player_me)
|
|
ui.enablePlayer(false);
|
|
|
|
if (!noEffects)
|
|
await this.runEffects(this.turnEnd);
|
|
// Player might have "end turn" events which delay the actual end of the turn
|
|
if (this.currPlayer.endturn_action) {
|
|
// Call action instead of ending turn
|
|
await this.currPlayer.endturn_action();
|
|
return;
|
|
}
|
|
if (this.currPlayer.passed)
|
|
await ui.notification(this.currPlayer.tag + "-pass", 1200);
|
|
board.updateScores();
|
|
if (player_op.passed && player_me.passed)
|
|
this.endRound();
|
|
else
|
|
this.startTurn();
|
|
}
|
|
|
|
// Ends the round and may end the game. Determines final scores and the round winner.
|
|
async endRound() {
|
|
limpar();
|
|
|
|
// Clean and update scores
|
|
board.row.forEach(r => {
|
|
r.cards.forEach(c => {
|
|
if (c.temporaryPower)
|
|
c.basePower = c.originalBasePower;
|
|
});
|
|
r.updateScore();
|
|
});
|
|
board.updateScores();
|
|
let dif = player_me.total - player_op.total;
|
|
if (dif === 0) {
|
|
let nilf_me = player_me.deck.faction === "nilfgaard",
|
|
nilf_op = player_op.deck.faction === "nilfgaard";
|
|
dif = nilf_me ^ nilf_op ? nilf_me ? 1 : -1 : 0;
|
|
}
|
|
let winner = dif > 0 ? player_me : dif < 0 ? player_op : null;
|
|
let verdict = {
|
|
winner: winner,
|
|
score_me: player_me.total,
|
|
score_op: player_op.total
|
|
}
|
|
this.roundHistory.push(verdict);
|
|
|
|
await this.runEffects(this.roundEnd);
|
|
|
|
player_me.endRound(dif > 0);
|
|
player_op.endRound(dif < 0);
|
|
if (player_me.health === 0 || player_op.health === 0)
|
|
this.over = true;
|
|
|
|
weather.clearWeather();
|
|
// In case some cards stay on the board, we want to reset their power
|
|
board.row.forEach(row => {
|
|
row.clear();
|
|
row.cards.forEach(c => {
|
|
c.power = c.basePower;
|
|
});
|
|
});
|
|
|
|
if (dif > 0) {
|
|
await ui.notification("win-round", 1200);
|
|
} else if (dif < 0) {
|
|
if (nilfgaard_wins_draws) {
|
|
nilfgaard_wins_draws = false;
|
|
await ui.notification("nilfgaard-wins-draws", 1200);
|
|
}
|
|
await ui.notification("lose-round", 1200);
|
|
} else
|
|
await ui.notification("draw-round", 1200);
|
|
|
|
if (player_me.health === 0 || player_op.health === 0)
|
|
this.endGame();
|
|
else
|
|
this.startRound(verdict);
|
|
}
|
|
|
|
// Sets up and displays the end-game screen
|
|
async endGame() {
|
|
this.over = true;
|
|
let endScreen = document.getElementById("end-screen");
|
|
let rows = endScreen.getElementsByTagName("tr");
|
|
rows[1].children[0].innerHTML = player_me.name;
|
|
rows[2].children[0].innerHTML = player_op.name;
|
|
|
|
for (let i = 1; i < 4; ++i) {
|
|
let round = this.roundHistory[i - 1];
|
|
rows[1].children[i].innerHTML = round ? round.score_me : 0;
|
|
rows[1].children[i].style.color = round && round.winner === player_me ? "goldenrod" : "";
|
|
|
|
rows[2].children[i].innerHTML = round ? round.score_op : 0;
|
|
rows[2].children[i].style.color = round && round.winner === player_op ? "goldenrod" : "";
|
|
}
|
|
|
|
endScreen.children[0].className = "";
|
|
if (player_op.health <= 0 && player_me.health <= 0) {
|
|
tocar("");
|
|
endScreen.getElementsByTagName("p")[0].classList.remove("hide");
|
|
endScreen.children[0].classList.add("end-draw");
|
|
} else if (player_op.health === 0) {
|
|
tocar("game_win", true);
|
|
endScreen.children[0].classList.add("end-win");
|
|
} else {
|
|
tocar("game_lose", true);
|
|
endScreen.children[0].classList.add("end-lose");
|
|
}
|
|
|
|
fadeIn(endScreen, 300);
|
|
ui.enablePlayer(true);
|
|
}
|
|
|
|
// Returns the client to the deck customization screen
|
|
returnToCustomization() {
|
|
iniciarMusica();
|
|
this.reset();
|
|
player_me.reset();
|
|
player_op.reset();
|
|
ui.toggleMusic_elem.classList.add("music-customization");
|
|
this.endScreen.classList.add("hide");
|
|
document.getElementById("deck-customization").classList.remove("hide");
|
|
}
|
|
|
|
// Restarts the last game with the same decks
|
|
restartGame() {
|
|
iniciarMusica();
|
|
limpar();
|
|
this.reset();
|
|
player_me.reset();
|
|
player_op.reset();
|
|
this.endScreen.classList.add("hide");
|
|
this.startGame();
|
|
}
|
|
|
|
// Executes effects in list. If effect returns true, effect is removed.
|
|
async runEffects(effects) {
|
|
for (let i = effects.length - 1; i >= 0; --i) {
|
|
let effect = effects[i];
|
|
if (await effect())
|
|
effects.splice(i, 1)
|
|
}
|
|
}
|
|
|
|
isPvP() {
|
|
return (this.mode === 3);
|
|
}
|
|
|
|
}
|
|
|
|
// Contians information and behavior of a Card
|
|
class Card {
|
|
|
|
constructor(key, card_data, player) {
|
|
if (!card_data) {
|
|
console.log("Invalid card data for: " + key);
|
|
}
|
|
this.id;
|
|
if (card_data.id)
|
|
this.id = Number(card_data.id);
|
|
this.key = key;
|
|
this.name = card_data.name;
|
|
this.basePower = this.power = Number(card_data.strength);
|
|
this.faction = card_data.deck;
|
|
// To clean the field in case it is a faction specific weather/special card
|
|
if (this.faction.startsWith("weather") || this.faction.startsWith("special")) {
|
|
this.faction = this.faction.split(" ")[0];
|
|
}
|
|
this.abilities = (card_data.ability === "") ? [] : card_data.ability.split(" ");
|
|
this.row = (this.faction === "weather") ? this.faction : card_data.row;
|
|
this.filename = card_data.filename;
|
|
this.placed = [];
|
|
this.removed = [];
|
|
this.activated = [];
|
|
this.holder = player;
|
|
this.locked = false;
|
|
this.decoyTarget = false;
|
|
this.target = "";
|
|
this.currentLocation = board; // By default, updated later
|
|
this.temporaryPower = false;
|
|
this.multiplier = 1;
|
|
if ("target" in card_data) {
|
|
this.target = card_data.target;
|
|
}
|
|
this.quote = "";
|
|
if ("quote" in card_data) {
|
|
this.quote = card_data.quote;
|
|
}
|
|
this.meta = [];
|
|
if ("meta" in card_data) {
|
|
if (Array.isArray(card_data.meta)) {
|
|
this.meta = card_data.meta;
|
|
} else {
|
|
this.meta = card_data.meta.split(" ");
|
|
}
|
|
}
|
|
|
|
this.hero = false;
|
|
if (this.abilities.length > 0) {
|
|
if (this.abilities[0] === "hero") {
|
|
this.hero = true;
|
|
this.abilities.splice(0, 1);
|
|
}
|
|
for (let x of this.abilities) {
|
|
let ab = ability_dict[x];
|
|
if ("placed" in ab) this.placed.push(ab.placed);
|
|
if ("removed" in ab) this.removed.push(ab.removed);
|
|
if ("activated" in ab) this.activated.push(ab.activated);
|
|
}
|
|
}
|
|
|
|
if (this.row === "leader")
|
|
this.desc_name = "Leader Ability";
|
|
else if (this.abilities.length > 0) {
|
|
this.desc_name = ability_dict[this.abilities[this.abilities.length - 1]].name;
|
|
if (this.abilities.length > 1)
|
|
this.desc_name += " / " + ability_dict[this.abilities[this.abilities.length - 2]].name;
|
|
} else if (this.row === "agile" || this.row === "agile_cr")
|
|
this.desc_name = "Agile Close / Ranged";
|
|
else if (this.row === "agile_cs")
|
|
this.desc_name = "Agile Close / Siege";
|
|
else if (this.row === "agile_rs")
|
|
this.desc_name = "Agile Ranged / Siege";
|
|
else if (this.row === "agile_crs")
|
|
this.desc_name = "Agile Close / Ranged / Siege";
|
|
else if (this.hero)
|
|
this.desc_name = "Hero";
|
|
else
|
|
this.desc_name = "";
|
|
|
|
this.desc = this.row.includes("agile") ? "<p><b>Agile:</b> " + ability_dict[this.row].description + "</p>" : "";
|
|
for (let i = this.abilities.length - 1; i >= 0; --i) {
|
|
let abi_name = (ability_dict[this.abilities[i]].name ? ability_dict[this.abilities[i]].name : "Leader Ability");
|
|
let faction_abi_desc = "description_" + this.faction;
|
|
if (ability_dict[this.abilities[i]][faction_abi_desc]) {
|
|
// If there is a faction specific description/behaviour
|
|
this.desc += "<p><b>" + abi_name + " (" + factions[this.faction].name + "):</b> " + ability_dict[this.abilities[i]][faction_abi_desc] + "</p>";
|
|
} else {
|
|
this.desc += "<p><b>" + abi_name + ":</b> " + ability_dict[this.abilities[i]].description + "</p>";
|
|
}
|
|
|
|
}
|
|
// If Summon Avenger or Invoke card, give information about the card being summoned
|
|
if (this.abilities.includes("avenger") && this.target) {
|
|
let target = card_dict[this.target];
|
|
this.desc += "<p>Summons <b>" + target["name"] + "</b> with strength " + target["strength"];
|
|
if (target["ability"].length > 0)
|
|
this.desc += " and abilities " + target["ability"].split(" ").map(a => ability_dict[a]["name"]).join(" / ");
|
|
this.desc += "</p>";
|
|
} else if (this.abilities.includes("muster") && this.target) {
|
|
let units = Object.keys(card_dict).filter(cid => card_dict[cid].target === this.target).map(cid => card_dict[cid]);
|
|
let units_summary = {};
|
|
units.forEach(function (u) {
|
|
let key = "<b>" + u.name + "</b> (str: " + u.strength + ")";
|
|
if (!(key in units_summary))
|
|
units_summary[key] = 0;
|
|
units_summary[key] = units_summary[key] + 1;
|
|
});
|
|
this.desc += "<p><u>Summons</u> " + Object.keys(units_summary).map(t => units_summary[t] + " * " + t).join(", ");
|
|
|
|
} else if (this.abilities.includes("invoke") && this.target) {
|
|
let target = Object.keys(card_dict).filter(cid => card_dict[cid].target === this.target && cid !== this.key).map(cid => card_dict[cid]);
|
|
if (target.length > 0) {
|
|
target = target[0];
|
|
this.desc += "<p>Invokes <b>" + target["name"] + "</b> with strength " + target["strength"];
|
|
if (target["ability"].length > 0)
|
|
this.desc += " and abilities " + target["ability"].split(" ").map(a => ability_dict[a]["name"]).join(" / ");
|
|
this.desc += "</p>";
|
|
}
|
|
} else if ((this.abilities.includes("berserker") || this.abilities.includes("monster_toussaint")) && this.target) {
|
|
let target = card_dict[this.target];
|
|
this.desc += "<p>Turns into <b>" + target["name"] + "</b> with strength " + target["strength"];
|
|
if (target["ability"].length > 0)
|
|
this.desc += " and abilities " + target["ability"].split(" ").map(a => ability_dict[a]["name"]).join(" / ");
|
|
this.desc += "</p>";
|
|
}
|
|
if (this.hero)
|
|
this.desc += "<p><b>Hero:</b> " + ability_dict["hero"].description + "</p>";
|
|
|
|
this.elem = this.createCardElem(this);
|
|
}
|
|
|
|
// Returns the identifier for this type of card
|
|
getId() {
|
|
return this.key;
|
|
}
|
|
|
|
// Sets and displays the current power of this card
|
|
setPower(n) {
|
|
if (this.key === "spe_decoy")
|
|
return;
|
|
let elem = this.elem.children[0].children[0];
|
|
if (n !== this.power) {
|
|
this.power = n;
|
|
elem.innerHTML = this.power;
|
|
}
|
|
elem.style.color = (n > this.basePower) ? "goldenrod" : (n < this.basePower) ? "red" : "";
|
|
if (this.temporaryPower)
|
|
elem.style.color = "green";
|
|
}
|
|
|
|
// Resets the power of this card to default
|
|
resetPower() {
|
|
this.setPower(this.basePower);
|
|
this.multiplier = 1;
|
|
}
|
|
|
|
// Automatically sends and translates this card to its apropriate row from the passed source
|
|
async autoplay(source) {
|
|
await board.toRow(this, source);
|
|
}
|
|
|
|
// Animates an ability effect
|
|
async animate(name, bFade = true, bExpand = true) {
|
|
if (!may_pass1 && playingOnline) await sleep(600);
|
|
var guia = {
|
|
"medic": "med",
|
|
"muster": "ally",
|
|
"morale": "moral",
|
|
"bond": "moral"
|
|
}
|
|
var temSom = new Array();
|
|
for (var x in guia) temSom[temSom.length] = x;
|
|
var literais = ["scorch", "spy", "horn", "shield", "lock", "seize", "knockback", "resilience", "curse", "immortal", "aerondight", "ambush", "necrophage", "comrade", "emissary", "invoke","monster_toussaint"];
|
|
var som = literais.indexOf(name) > -1 ? literais[literais.indexOf(name)] : temSom.indexOf(name) > -1 ? guia[name] : "";
|
|
if (som != "") tocar(som, false);
|
|
if (name === "scorch") {
|
|
return await this.scorch(name);
|
|
}
|
|
let anim = this.elem.children[this.elem.children.length - 1];
|
|
anim.style.backgroundImage = iconURL("anim_" + name);
|
|
await sleep(50);
|
|
|
|
if (bFade) fadeIn(anim, 300);
|
|
if (bExpand) anim.style.backgroundSize = "100% auto";
|
|
await sleep(300);
|
|
|
|
if (bExpand) anim.style.backgroundSize = "80% auto";
|
|
await sleep(1000);
|
|
|
|
if (bFade) fadeOut(anim, 300);
|
|
if (bExpand) anim.style.backgroundSize = "40% auto";
|
|
await sleep(300);
|
|
|
|
anim.style.backgroundImage = "";
|
|
}
|
|
|
|
// Animates the scorch effect
|
|
async scorch(name) {
|
|
let anim = this.elem.children[this.elem.children.length - 1];
|
|
anim.style.backgroundSize = "cover";
|
|
anim.style.backgroundImage = iconURL("anim_" + name);
|
|
await sleep(50);
|
|
|
|
fadeIn(anim, 300);
|
|
await sleep(1300);
|
|
|
|
fadeOut(anim, 300);
|
|
await sleep(300);
|
|
|
|
anim.style.backgroundSize = "";
|
|
anim.style.backgroundImage = "";
|
|
}
|
|
|
|
// Returns true if this is a combat card that is not a Hero
|
|
isUnit() {
|
|
return !this.hero && (this.row === "close" || this.row === "ranged" || this.row === "siege" || this.row.includes("agile"));
|
|
}
|
|
|
|
// Returns true if card is sent to a Row's special slot
|
|
isSpecial() {
|
|
return ["spe_horn", "spe_mardroeme", "spe_sign_quen", "spe_sign_yrden", "spe_toussaint_wine", "spe_lyria_rivia_morale", "spe_wyvern_shield", "spe_mantlet", "spe_garrison", "spe_dimeritium_shackles", "spe_curse"].includes(this.key);
|
|
}
|
|
|
|
// Compares by type then power then name
|
|
static compare(a, b) {
|
|
var dif = factionRank(a) - factionRank(b);
|
|
if (dif !== 0)
|
|
return dif;
|
|
// Muster/Bond cards
|
|
if (a.target && b.target && a.target === b.target) {
|
|
if (a.id && b.id)
|
|
return Number(a.id) - Number(b.id);
|
|
if (a.key && b.key)
|
|
return a.key.localeCompare(b.key);
|
|
}
|
|
dif = a.basePower - b.basePower;
|
|
if (dif && dif !== 0)
|
|
return dif;
|
|
|
|
return a.name.localeCompare(b.name);
|
|
|
|
function factionRank(c) {
|
|
return c.faction === "special" ? -2 : (c.faction === "weather") ? -1 : 0;
|
|
}
|
|
}
|
|
|
|
getPlayableRows() {
|
|
if (this.row.includes("agile")) {
|
|
return board.getAgileRows(this, this.holder);
|
|
} else if (this.isSpecial()) {
|
|
return this.getAllRows();
|
|
}
|
|
return [board.getRow(this, this.row, this.holder)];
|
|
}
|
|
|
|
// Creates an HTML element based on the card's properties
|
|
createCardElem(card) {
|
|
let elem = document.createElement("div");
|
|
elem.style.backgroundImage = smallURL(card.faction + "_" + card.filename);
|
|
elem.classList.add("card");
|
|
elem.addEventListener("click", () => ui.selectCard(card), false);
|
|
|
|
if (card.row === "leader")
|
|
return elem;
|
|
|
|
let power = document.createElement("div");
|
|
elem.appendChild(power);
|
|
let bg;
|
|
if (card.hero) {
|
|
bg = "power_hero";
|
|
elem.classList.add("hero");
|
|
} else if (card.faction === "weather") {
|
|
bg = "power_" + card.abilities[0];
|
|
} else if (card.faction === "special") {
|
|
let str = card.abilities[0];
|
|
if (str === "shield_c" || str === "shield_r" || str === "shield_s")
|
|
str = "shield";
|
|
bg = "power_" + str;
|
|
elem.classList.add("special");
|
|
} else {
|
|
bg = "power_normal";
|
|
}
|
|
power.style.backgroundImage = iconURL(bg);
|
|
|
|
let row = document.createElement("div");
|
|
elem.appendChild(row);
|
|
if (card.row === "close" || card.row === "ranged" || card.row === "siege" || card.row.includes("agile")) {
|
|
let num = document.createElement("div");
|
|
num.appendChild(document.createTextNode(card.basePower));
|
|
num.classList.add("center");
|
|
power.appendChild(num);
|
|
row.style.backgroundImage = iconURL("card_row_" + card.row);
|
|
}
|
|
|
|
let abi = document.createElement("div");
|
|
elem.appendChild(abi);
|
|
if (card.faction !== "special" && card.faction !== "weather" && card.abilities.length > 0) {
|
|
let str = card.abilities[card.abilities.length - 1];
|
|
if (str === "cerys")
|
|
str = "muster";
|
|
if (str.startsWith("avenger"))
|
|
str = "avenger";
|
|
if (str === "scorch_c" || str == "scorch_r" || str === "scorch_s")
|
|
str = "scorch_combat";
|
|
if (str === "shield_c" || str == "shield_r" || str === "shield_s")
|
|
str = "shield";
|
|
abi.style.backgroundImage = iconURL("card_ability_" + str);
|
|
} else if (card.row.includes("agile"))
|
|
abi.style.backgroundImage = iconURL("card_ability_" + card.row);
|
|
|
|
// For cards with 2 abilities
|
|
if (card.abilities.length > 1) {
|
|
let abi2 = document.createElement("div");
|
|
abi2.classList.add("card-ability-2");
|
|
elem.appendChild(abi2);
|
|
let str = card.abilities[card.abilities.length - 2];
|
|
if (str === "cerys")
|
|
str = "muster";
|
|
if (str.startsWith("avenger"))
|
|
str = "avenger";
|
|
if (str === "scorch_c" || str == "scorch_r" || str === "scorch_s")
|
|
str = "scorch_combat";
|
|
if (str === "shield_c" || str == "shield_r" || str === "shield_s")
|
|
str = "shield";
|
|
abi2.style.backgroundImage = iconURL("card_ability_" + str);
|
|
}
|
|
|
|
elem.appendChild(document.createElement("div")); // animation overlay
|
|
return elem;
|
|
}
|
|
|
|
// Indicates whether or not the abilities of this card are locked
|
|
isLocked() {
|
|
return this.locked;
|
|
}
|
|
|
|
isImmortal() {
|
|
return this.abilities.includes("immortal");
|
|
}
|
|
}
|
|
|
|
function passBreak() {
|
|
clearInterval(timer2);
|
|
load_pass = load_passT;
|
|
may_pass2 = "";
|
|
document.getElementById("pass-button").innerHTML = original;
|
|
}
|
|
|
|
function passStart(input) {
|
|
if (may_pass1 && may_pass2 == "") {
|
|
may_pass2 = input;
|
|
ui.passLoad();
|
|
timer2 = setInterval(function () {
|
|
ui.passLoad();
|
|
}, 750);
|
|
}
|
|
}
|
|
|
|
var original = "Pass";
|
|
var fileira_clicavel = null;
|
|
const load_passT = 3;
|
|
var cache_notif = ["op-leader"];
|
|
var load_pass = load_passT,
|
|
may_pass1 = false,
|
|
may_pass2 = "",
|
|
may_pass3 = true,
|
|
fimU = false,
|
|
carta_c = false,
|
|
hover_row = true,
|
|
timer2, lCard;
|
|
|
|
// Handles notifications and client interration with menus
|
|
class UI {
|
|
constructor() {
|
|
this.carousels = [];
|
|
this.notif_elem = document.getElementById("notification-bar");
|
|
this.preview = document.getElementsByClassName("card-preview")[0];
|
|
this.previewCard = null;
|
|
this.lastRow = null;
|
|
this.underRearrangement = false;
|
|
this.underCardPowerEdit = false;
|
|
this.arrangementMoves = 0;
|
|
if (!isMobile()) {
|
|
document.getElementById("pass-button").addEventListener("mousedown", function (e) {
|
|
if (e.button == 0) {
|
|
passStart("mouse");
|
|
may_pass3 = false;
|
|
} else if (may_pass2 == "mouse") passBreak();
|
|
});
|
|
document.getElementById("pass-button").addEventListener("mouseup", () => {
|
|
if (may_pass2 == "mouse") passBreak();
|
|
}, false);
|
|
document.getElementById("pass-button").addEventListener("mouseout", () => {
|
|
if (may_pass2 == "mouse") passBreak();
|
|
}, false);
|
|
window.addEventListener("keydown", function (e) {
|
|
switch (e.keyCode) {
|
|
case 81:
|
|
e.preventDefault();
|
|
try {
|
|
ui.cancel();
|
|
} catch (err) { }
|
|
break;
|
|
case 32:
|
|
if (may_pass3) passStart("keyboard");
|
|
break;
|
|
}
|
|
});
|
|
window.addEventListener("keyup", function (e) {
|
|
if (e.keyCode == 32 && may_pass1) {
|
|
may_pass3 = true;
|
|
if (may_pass2 == "keyboard") passBreak();
|
|
}
|
|
});
|
|
} else document.getElementById("pass-button").addEventListener("click", function (e) {
|
|
if (game.isPvP()) {
|
|
game.currPlayer.passRound();
|
|
} else {
|
|
player_me.passRound();
|
|
}
|
|
});
|
|
document.getElementById("click-background").addEventListener("click", () => ui.cancel(), false);
|
|
this.youtube;
|
|
this.ytActive;
|
|
this.toggleMusic_elem = document.getElementById("toggle-music");
|
|
this.toggleMusic_elem.classList.add("fade");
|
|
this.toggleMusic_elem.addEventListener("click", () => this.toggleMusic(), false);
|
|
document.getElementById("arrangementWindow-button").addEventListener("click", () => {
|
|
this.updateArrangementCounter(0);
|
|
this.underRearrangement = false;
|
|
game.currPlayer.endTurn();
|
|
|
|
}, false);
|
|
|
|
this.helper = new HelperBox();
|
|
}
|
|
|
|
passLoad() {
|
|
load_pass--;
|
|
if (load_pass == -1) {
|
|
document.getElementById("pass-button").innerHTML = original;
|
|
load_pass = load_passT;
|
|
if (game.isPvP()) {
|
|
game.currPlayer.passRound();
|
|
} else {
|
|
player_me.passRound();
|
|
}
|
|
passBreak();
|
|
} else document.getElementById("pass-button").innerHTML = load_pass + 1;
|
|
}
|
|
|
|
// Enables or disables client interration
|
|
enablePlayer(enable) {
|
|
// Player vs player
|
|
if (game.isPvP()) {
|
|
document.getElementsByTagName("main")[0].classList.remove("noclick");
|
|
} else {
|
|
let main = document.getElementsByTagName("main")[0].classList;
|
|
if (enable) main.remove("noclick");
|
|
else main.add("noclick");
|
|
}
|
|
}
|
|
|
|
// Initializes the youtube background music object
|
|
initYouTube() {
|
|
this.youtube = new YT.Player('youtube', {
|
|
videoId: "UE9fPWy1_o4",
|
|
playerVars: {
|
|
"autoplay": 1,
|
|
"controls": 0,
|
|
"loop": 1,
|
|
"playlist": "UE9fPWy1_o4",
|
|
"rel": 0,
|
|
"version": 3,
|
|
"modestbranding": 1
|
|
},
|
|
events: {
|
|
'onStateChange': initButton
|
|
}
|
|
});
|
|
|
|
function initButton() {
|
|
if (ui.ytActive !== undefined)
|
|
return;
|
|
ui.ytActive = true;
|
|
ui.youtube.playVideo();
|
|
let timer = setInterval(() => {
|
|
if (ui.youtube.getPlayerState() !== YT.PlayerState.PLAYING)
|
|
ui.youtube.playVideo();
|
|
else {
|
|
clearInterval(timer);
|
|
ui.toggleMusic_elem.classList.remove("fade");
|
|
}
|
|
}, 500);
|
|
}
|
|
}
|
|
|
|
// Called when client toggles the music
|
|
toggleMusic() {
|
|
if (this.youtube.getPlayerState() !== YT.PlayerState.PLAYING) iniciarMusica();
|
|
else {
|
|
this.youtube.pauseVideo();
|
|
this.toggleMusic_elem.classList.add("fade");
|
|
}
|
|
}
|
|
|
|
// Enables or disables backgorund music
|
|
setYouTubeEnabled(enable) {
|
|
if (this.ytActive === enable)
|
|
return;
|
|
if (enable && !this.mute)
|
|
ui.youtube.playVideo();
|
|
else
|
|
ui.youtube.pauseVideo();
|
|
this.ytActive = enable;
|
|
}
|
|
|
|
// Called when the player selects a selectable card
|
|
async selectCard(card) {
|
|
let row = this.lastRow;
|
|
let pCard = this.previewCard;
|
|
if (this.underRearrangement) {
|
|
this.showPreviewVisuals(card);
|
|
return;
|
|
}
|
|
if (this.underCardPowerEdit) {
|
|
if (this.previewCard == null) {
|
|
this.showPreviewVisuals(card);
|
|
ui.editCardPower(card);
|
|
}
|
|
return;
|
|
}
|
|
if (card === pCard)
|
|
return;
|
|
if (pCard === null || card.holder.hand.cards.includes(card)) {
|
|
this.setSelectable(null, false);
|
|
this.showPreview(card);
|
|
} else if (pCard.abilities.includes("decoy")) {
|
|
this.hidePreview(card);
|
|
this.enablePlayer(false);
|
|
card.decoyTarget = true;
|
|
board.toHand(card, row);
|
|
await board.moveTo(pCard, row, pCard.holder.hand);
|
|
await pCard.holder.endTurn();
|
|
} else if (pCard.abilities.includes("alzur_maker")) {
|
|
this.hidePreview(card);
|
|
this.enablePlayer(false);
|
|
await board.toGrave(card, row);
|
|
let target = new Card(ability_dict["alzur_maker"].target, card_dict[ability_dict["alzur_maker"].target], card.holder);
|
|
//target.removed.push(() => setTimeout(() => target.holder.grave.removeCard(target), 1001));
|
|
await board.addCardToRow(target, target.row, card.holder);
|
|
await pCard.holder.endTurn();
|
|
}
|
|
}
|
|
|
|
// Called when the player selects a selectable CardContainer
|
|
async selectRow(row, isSpecial = false) {
|
|
this.lastRow = row;
|
|
if (this.underRearrangement) {
|
|
if (this.previewCard !== null) {
|
|
if (row !== this.previewCard.currentLocation) {
|
|
board.moveToNoEffects(this.previewCard, row, this.previewCard.currentLocation);
|
|
this.updateArrangementCounter(this.arrangementMoves - 1);
|
|
}
|
|
this.preview.classList.add("hide");
|
|
let holder = this.previewCard.holder;
|
|
this.previewCard = null;
|
|
this.lastRow = null;
|
|
if (this.arrangementMoves < 1) {
|
|
this.underRearrangement = false;
|
|
ui.helper.hide();
|
|
await holder.endTurn();
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (this.underCardPowerEdit)
|
|
return;
|
|
if (this.previewCard === null) {
|
|
if (isSpecial)
|
|
await ui.viewCardsInContainer(row.special);
|
|
else
|
|
await ui.viewCardsInContainer(row);
|
|
return;
|
|
}
|
|
if (this.previewCard.key === "spe_decoy" || this.previewCard.abilities.includes("alzur_maker"))
|
|
return;
|
|
if (this.previewCard.abilities.includes("decoy") && row.cards.filter(c => c.isUnit()).length > 0)
|
|
return; // If a unit can be selected, we cannot select the whole row
|
|
let card = this.previewCard;
|
|
let holder = card.holder;
|
|
this.hidePreview();
|
|
this.enablePlayer(false);
|
|
if (card.faction === "special" && card.abilities.includes("scorch")) {
|
|
this.hidePreview();
|
|
if (game.scorchCancelled)
|
|
return;
|
|
await ability_dict["scorch"].activated(card);
|
|
} else if (card.faction === "special" && card.abilities.includes("cintra_slaughter")) {
|
|
this.hidePreview();
|
|
await ability_dict["cintra_slaughter"].activated(card);
|
|
} else if (card.faction === "special" && card.abilities.includes("seize")) {
|
|
this.hidePreview();
|
|
await ability_dict[card.abilities.at(-1)].activated(card);
|
|
} else if (card.faction === "special" && card.abilities.includes("knockback")) {
|
|
this.hidePreview();
|
|
await ability_dict[card.abilities.at(-1)].activated(card, row);
|
|
} else if (card.key === "spe_decoy" || card.abilities.includes("alzur_maker")) {
|
|
return;
|
|
} else if (card.abilities.includes("decoy") && row.cards.filter(c => c.isUnit()).length > 0) {
|
|
return; // If a unit can be selected, we cannot select the whole row
|
|
} else if (card.abilities.includes("anna_henrietta_duchess")) {
|
|
this.hidePreview(card);
|
|
this.enablePlayer(false);
|
|
let horn = row.special.cards.filter(c => c.abilities.includes("horn"))[0];
|
|
if (horn)
|
|
await board.toGrave(horn, row);
|
|
} else if (card.key === "spe_lyria_rivia_morale") {
|
|
await board.moveTo(card, row);
|
|
} else if (card.abilities.includes("meve_princess") || card.abilities.includes("carlo_varese")) {
|
|
this.hidePreview(card);
|
|
this.enablePlayer(false);
|
|
if (game.scorchCancelled)
|
|
return;
|
|
await row.scorch();
|
|
} else if (card.abilities.includes("cyrus_hemmelfart")) {
|
|
this.hidePreview(card);
|
|
this.enablePlayer(false);
|
|
let new_card = new Card("spe_dimeritium_shackles", card_dict["spe_dimeritium_shackles"], card.holder);
|
|
await board.moveTo(new_card, row);
|
|
} else if (card.faction === "special" && card.abilities.includes("bank")) {
|
|
this.hidePreview();
|
|
await ability_dict["bank"].activated(card);
|
|
} else if (card.faction === "special" && card.abilities.includes("skellige_fleet")) {
|
|
this.hidePreview();
|
|
await ability_dict["skellige_fleet"].activated(card);
|
|
} else if (card.faction === "special" && card.abilities.includes("royal_decree")) {
|
|
this.hidePreview();
|
|
await ability_dict["royal_decree"].activated(card);
|
|
} else {
|
|
await board.moveTo(card, row, card.holder.hand);
|
|
}
|
|
await holder.endTurn();
|
|
}
|
|
|
|
// Called when the client cancels out of a card-preview
|
|
cancel() {
|
|
if (!fimU) {
|
|
fimU = true;
|
|
tocar("discard", false);
|
|
lCard = null;
|
|
exibindo_lider = false;
|
|
carta_c = false;
|
|
this.hidePreview();
|
|
}
|
|
}
|
|
|
|
// Displays a card preview then enables and highlights potential card destinations
|
|
showPreview(card) {
|
|
fimU = false;
|
|
tocar("explaining", false);
|
|
this.showPreviewVisuals(card);
|
|
this.setSelectable(card, true);
|
|
document.getElementById("click-background").classList.remove("noclick");
|
|
}
|
|
|
|
// Sets up the graphics and description for a card preview
|
|
showPreviewVisuals(card) {
|
|
this.previewCard = card;
|
|
this.preview.classList.remove("hide");
|
|
getPreviewElem(this.preview.getElementsByClassName("card-lg")[0], card)
|
|
this.preview.getElementsByClassName("card-lg")[0].addEventListener("mousedown", function () {
|
|
if (fileira_clicavel !== null && may_act_card) {
|
|
ui.selectRow(fileira_clicavel);
|
|
may_act_card = false;
|
|
fileira_clicavel = null;
|
|
}
|
|
});
|
|
this.preview.getElementsByClassName("card-lg")[0].addEventListener("mouseup", function () {
|
|
may_act_card = true;
|
|
});
|
|
let desc_elem = this.preview.getElementsByClassName("card-description")[0];
|
|
this.setDescription(card, desc_elem);
|
|
}
|
|
|
|
// Hides the card preview then disables and removes highlighting from card destinations
|
|
hidePreview() {
|
|
document.getElementById("click-background").classList.add("noclick");
|
|
player_me.hand.cards.forEach(c => c.elem.classList.remove("noclick"));
|
|
|
|
this.preview.classList.add("hide");
|
|
this.setSelectable(null, false);
|
|
this.previewCard = null;
|
|
this.lastRow = null;
|
|
}
|
|
|
|
// Sets up description window for a card
|
|
setDescription(card, desc) {
|
|
if (card.hero || card.row.includes("agile") || card.abilities.length > 0 || card.faction === "faction") {
|
|
desc.classList.remove("hide");
|
|
let str = card.row.includes("agile") ? card.row : "";
|
|
if (card.abilities.length)
|
|
str = card.abilities[card.abilities.length - 1];
|
|
if (str === "cerys")
|
|
str = "muster";
|
|
if (str.startsWith("avenger"))
|
|
str = "avenger";
|
|
if (str === "scorch_c" || str == "scorch_r" || str === "scorch_s")
|
|
str = "scorch_combat";
|
|
if (str === "shield_c" || str == "shield_r" || str === "shield_s")
|
|
str = "shield";
|
|
|
|
if (card.faction === "faction" || card.abilities.length === 0 && card.row !== "agile")
|
|
desc.children[0].style.backgroundImage = "";
|
|
else if (card.row === "leader")
|
|
desc.children[0].style.backgroundImage = iconURL("deck_shield_" + card.faction);
|
|
else
|
|
desc.children[0].style.backgroundImage = iconURL("card_ability_" + str);
|
|
desc.children[1].innerHTML = card.desc_name;
|
|
desc.children[2].innerHTML = card.desc;
|
|
} else {
|
|
desc.classList.add("hide");
|
|
}
|
|
}
|
|
|
|
// Displayed a timed notification to the client
|
|
async notification(name, duration) {
|
|
var guia1 = {
|
|
"notif-nilfgaard-wins-draws": "Nilfgaard wins draws",
|
|
"notif-op-white-flame": "The opponent's leader cancel your opponent's Leader Ability",
|
|
"notif-op-leader": "Opponent uses leader",
|
|
"notif-me-first": "You will go first",
|
|
"notif-op-first": "Your opponent will go first",
|
|
"notif-me-coin": "You will go first",
|
|
"notif-op-coin": "Your opponent will go first",
|
|
"notif-round-start": "Round Start",
|
|
"notif-me-pass": "Round passed",
|
|
"notif-op-pass": "Your opponent has passed",
|
|
"notif-win-round": "You won the round!",
|
|
"notif-lose-round": "Your opponent won the round",
|
|
"notif-draw-round": "The round ended in a draw",
|
|
"notif-me-turn": "Your turn!",
|
|
"notif-op-turn": "Opponent's turn",
|
|
"notif-north": "Northern Realms faction ability triggered - North draws an additional card.",
|
|
"notif-monsters": "Monsters faction ability triggered - monsters retake one card to their hand",
|
|
"notif-scoiatael": "Opponent used the Scoia'tael faction perk to go first.",
|
|
"notif-skellige-op": "Opponent Skellige Ability Triggered!",
|
|
"notif-skellige-me": "Skellige Ability Triggered!",
|
|
"notif-witcher_universe": "Witcher Universe used its faction ability and skipped a turn",
|
|
"notif-toussaint": "Toussaint faction ability triggered - Toussaint draws an additional card.",
|
|
"notif-toussaint-decoy-cancelled": "Toussaint Leader ability used - Decoy ability cancelled for the rest of the round.",
|
|
"notif-lyria_rivia": "Lyria & Rivia ability used - Morale Boost effect applied to a row.",
|
|
"notif-meve_white_queen": "Lyria & Rivia leader allows both players to restore 2 units when using the medic ability.",
|
|
"notif-north-scorch-cancelled": "Northern Realms Leader ability used - Scorch ability cancelled for the rest of the round.",
|
|
"notif-zerrikania": "Zerrikania ability used - Unit restored from discard pile.",
|
|
"notif-redania": "Redania used its faction ability and skipped a turn",
|
|
"notif-velen": "Velen ability triggered: Player will draw a card"
|
|
}
|
|
var guia2 = {
|
|
"me-pass": "pass",
|
|
"win-round": "round_win",
|
|
"lose-round": "round_lose",
|
|
"me-turn": "turn_me",
|
|
"op-turn": "turn_op",
|
|
"op-leader": "turn_op",
|
|
"op-white-flame": "turn_op",
|
|
"nilfgaard-wins-draws": "turn_op"
|
|
}
|
|
var temSom = new Array();
|
|
for (var x in guia2) temSom[temSom.length] = x;
|
|
var som = temSom.indexOf(name) > -1 ? guia2[name] : name == "round-start" && game.roundHistory.length == 0 ? "round1_start" : "";
|
|
if (som != "") tocar(som, false);
|
|
this.notif_elem.children[0].id = "notif-" + name;
|
|
this.notif_elem.children[0].style.backgroundImage = name == "op-leader" ? "url(img/icons/notif_" + player_op.deck.faction + ".png)" : "";
|
|
var caracteres = guia1[this.notif_elem.children[0].id].length;
|
|
var palavras = guia1[this.notif_elem.children[0].id].split(" ").length;
|
|
duration = parseInt(0.7454878 * Math.max(parseInt((1e3 / 17) * caracteres), parseInt((6e4 / 300) * palavras)) + 211.653152) + 1;
|
|
const fadeSpeed = 150;
|
|
fadeIn(this.notif_elem, fadeSpeed);
|
|
var ch = playingOnline && duration < 1000 & cache_notif.indexOf(name) == -1 ? 800 : 0;
|
|
cache_notif[cache_notif.length] = name;
|
|
duration += ch;
|
|
let d = new Date().getTime();
|
|
fadeOut(this.notif_elem, fadeSpeed, duration - fadeSpeed - 50); // Removing some delay to avoid weird behaviours if the fadeOut starts late and has not ended when the next fadeIn starts
|
|
await sleep(duration);
|
|
}
|
|
|
|
// Displays a cancellable Carousel for a single card
|
|
async viewCard(card, action) {
|
|
if (card === null) return;
|
|
if (lCard !== card.name) {
|
|
lCard = card.name;
|
|
let container = new CardContainer();
|
|
container.cards.push(card);
|
|
await this.viewCardsInContainer(container, action);
|
|
}
|
|
}
|
|
|
|
// Displays a cancellable Carousel for all cards in a container
|
|
async viewCardsInContainer(container, action) {
|
|
action = action ? action : function () {
|
|
return this.cancel();
|
|
};
|
|
await this.queueCarousel(container, 1, action, () => true, false, true);
|
|
}
|
|
|
|
// Displays a Carousel menu of filtered container items that match the predicate.
|
|
// Suspends gameplay until the Carousel is closed. Automatically picks random card if activated for AI player
|
|
async queueCarousel(container, count, action, predicate, bSort, bQuit, title) {
|
|
if (game.currPlayer && game.currPlayer.controller instanceof ControllerAI) {
|
|
for (let i = 0; i < count; ++i) {
|
|
let cards = container.cards.reduce((a, c, i) => !predicate || predicate(c) ? a.concat([i]) : a, []);
|
|
await action(container, cards[randomInt(cards.length)]);
|
|
}
|
|
return;
|
|
}
|
|
let carousel = new Carousel(container, count, action, predicate, bSort, bQuit, title);
|
|
if (Carousel.curr === undefined || Carousel.curr === null) {
|
|
carousel.start();
|
|
} else {
|
|
this.carousels.push(carousel);
|
|
return;
|
|
}
|
|
await sleepUntil(() => this.carousels.length === 0 && !Carousel.curr, 100);
|
|
}
|
|
|
|
// Starts the next queued Carousel
|
|
quitCarousel() {
|
|
if (this.carousels.length > 0) {
|
|
this.carousels.shift().start();
|
|
}
|
|
}
|
|
|
|
// Displays a custom confirmation menu
|
|
async popup(yesName, yes, noName, no, title, description) {
|
|
let p = new Popup(yesName, yes, noName, no, title, description);
|
|
await sleepUntil(() => !Popup.curr);
|
|
return p.choice;
|
|
}
|
|
|
|
// Displays a custom menu to select a number
|
|
async numberPopup(v, min, max, callback, title, description) {
|
|
let p = new NumberValuePopup(v, min, max, callback, title, description);
|
|
await sleepUntil(() => !NumberValuePopup.curr);
|
|
return parseInt(p.value);
|
|
}
|
|
|
|
async startDeckSorter(cards, player, action, title, bottomAllowed = false) {
|
|
let deckSorter = new DeckSorter(cards, player, action, title, bottomAllowed);
|
|
deckSorter.start();
|
|
await sleepUntil(() => deckSorter.isCompleted(), 100);
|
|
}
|
|
|
|
// Enables or disables selection and highlighting of rows specific to the card
|
|
setSelectable(card, enable) {
|
|
if (!enable) {
|
|
for (let row of board.row) {
|
|
row.elem.classList.remove("row-selectable");
|
|
row.elem.classList.remove("noclick");
|
|
row.special.elem.classList.remove("row-selectable");
|
|
row.special.elem.classList.remove("noclick");
|
|
alteraClicavel(row, false);
|
|
|
|
for (let card of row.cards) {
|
|
card.elem.classList.add("noclick");
|
|
}
|
|
}
|
|
weather.elem.classList.remove("row-selectable");
|
|
weather.elem.classList.remove("noclick");
|
|
alteraClicavel(weather, false);
|
|
return;
|
|
}
|
|
if (card.faction === "weather") {
|
|
for (let row of board.row) {
|
|
row.elem.classList.add("noclick");
|
|
row.special.elem.classList.add("noclick");
|
|
}
|
|
weather.elem.classList.add("row-selectable");
|
|
carta_c = true;
|
|
document.getElementById("field-op").addEventListener("click", function () {
|
|
cancelaClima();
|
|
});
|
|
document.getElementById("field-me").addEventListener("click", function () {
|
|
cancelaClima();
|
|
});
|
|
alteraClicavel(weather, true);
|
|
return;
|
|
}
|
|
|
|
weather.elem.classList.add("noclick");
|
|
|
|
// Affects all board
|
|
if (card.faction === "special" && card.abilities.includes("scorch")) {
|
|
for (let r of board.row) {
|
|
if (r.isShielded() || game.scorchCancelled) {
|
|
r.elem.classList.add("noclick");
|
|
r.special.elem.classList.add("noclick");
|
|
} else {
|
|
r.elem.classList.add("row-selectable");
|
|
r.special.elem.classList.add("row-selectable");
|
|
alteraClicavel(r, true);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
// Affects only own side of board
|
|
if (card.faction === "special" && (card.abilities.includes("cintra_slaughter") || card.abilities.includes("bank") || card.abilities.includes("skellige_fleet") || card.abilities.includes("royal_decree"))) {
|
|
for (let i = 0; i < 6; i++) {
|
|
let r = board.row[i];
|
|
if ((!game.isPvP() && i > 2) || (game.isPvP() && ((card.holder.tag === player_me.tag && i > 2) || (card.holder.tag === player_op.tag && i < 3)))) {
|
|
r.elem.classList.add("row-selectable");
|
|
r.special.elem.classList.add("row-selectable");
|
|
alteraClicavel(r, true);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
// Affects enemy side of the board
|
|
// Affects only opponent melee and ranged row
|
|
if (card.faction === "special" && card.abilities.includes("knockback")) {
|
|
let rows = [1, 2];
|
|
if (game.isPvP() && card.holder.tag === player_op.tag) {
|
|
rows = [3, 4];
|
|
}
|
|
for (i of rows) {
|
|
let r = board.row[i];
|
|
if (!r.isShielded()) {
|
|
r.elem.classList.add("row-selectable");
|
|
r.special.elem.classList.add("row-selectable");
|
|
alteraClicavel(r, true);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
// Affects only opponent melee row
|
|
if (card.faction === "special" && card.abilities.includes("seize")) {
|
|
let r = board.row[2];
|
|
if (game.isPvP() && card.holder.tag === player_op.tag) {
|
|
r = board.row[3];
|
|
}
|
|
if (!r.isShielded()) {
|
|
r.elem.classList.add("row-selectable");
|
|
r.special.elem.classList.add("row-selectable");
|
|
alteraClicavel(r, true);
|
|
}
|
|
return;
|
|
}
|
|
//Affects only own rows that are available
|
|
if (card.isSpecial()) {
|
|
for (let i = 0; i < 6; i++) {
|
|
let r = board.row[i];
|
|
//Affects OP side
|
|
if (card.abilities.includes("lock")) {
|
|
if (r.special.containsCardByKey(card.key) || r.isShielded() || (!game.isPvP() && i > 2) ||
|
|
(game.isPvP() && ((card.holder.tag === player_me.tag && i > 2) || (card.holder.tag === player_op.tag && i < 3)))) {
|
|
r.elem.classList.add("noclick");
|
|
r.special.elem.classList.add("noclick");
|
|
} else {
|
|
r.special.elem.classList.add("row-selectable");
|
|
fileira_clicavel = null;
|
|
}
|
|
} else if (card.abilities.includes("curse")) {
|
|
//Affects both sides
|
|
if (r.isShielded()) {
|
|
r.elem.classList.add("noclick");
|
|
r.special.elem.classList.add("noclick");
|
|
} else {
|
|
r.special.elem.classList.add("row-selectable");
|
|
fileira_clicavel = null;
|
|
}
|
|
|
|
} else if (card.abilities.includes("shield_c") || card.abilities.includes("shield_r") || card.abilities.includes("shield_s")) {
|
|
if (((card.abilities.includes("shield_c") && i == 3) || (card.abilities.includes("shield_r") && i == 4) || (card.abilities.includes("shield_s") && i == 5)) &&
|
|
(!game.isPvP() || (game.isPvP() && card.holder.tag === player_me.tag))) {
|
|
r.special.elem.classList.add("row-selectable");
|
|
fileira_clicavel = null;
|
|
} else if ((game.isPvP() && card.holder.tag === player_op.tag && ((card.abilities.includes("shield_c") && i == 2) || (card.abilities.includes("shield_r") && i == 1) || (card.abilities.includes("shield_s") && i == 0)))) { } else {
|
|
r.elem.classList.add("noclick");
|
|
r.special.elem.classList.add("noclick");
|
|
}
|
|
} else {
|
|
// Affects own side - Toussaint Wine does not affect siege row
|
|
if (r.special.containsCardByKey(card.key) || (!game.isPvP() && ((card.abilities.includes("toussaint_wine") && i == 5) || i < 3)) ||
|
|
(game.isPvP() && ((card.holder.tag === player_me.tag && ((card.abilities.includes("toussaint_wine") && i == 5) || i < 3)) ||
|
|
(card.holder.tag === player_op.tag && ((card.abilities.includes("toussaint_wine") && i == 0) || i > 2))))) {
|
|
r.elem.classList.add("noclick");
|
|
r.special.elem.classList.add("noclick");
|
|
} else {
|
|
r.special.elem.classList.add("row-selectable");
|
|
fileira_clicavel = null;
|
|
}
|
|
}
|
|
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (card.abilities.includes("decoy") || card.abilities.includes("alzur_maker")) {
|
|
for (let i = 0; i < 6; i++) {
|
|
let r = board.row[i];
|
|
let units = r.cards.filter(c => c.isUnit());
|
|
if ((card.key === "spe_decoy" && units.length === 0) || (card.abilities.includes("decoy") && game.decoyCancelled) || (!game.isPvP() && i < 3) ||
|
|
(game.isPvP() && ((card.holder.tag === player_me.tag && i < 3) || (card.holder.tag === player_op.tag && i > 2)))) {
|
|
r.elem.classList.add("noclick");
|
|
r.special.elem.classList.add("noclick");
|
|
r.elem.classList.remove("card-selectable");
|
|
} else {
|
|
// For unit cards with Decoy ability, filter by the appropriate row
|
|
if (card.abilities.includes("decoy") && card.row.length > 0) {
|
|
if (((!game.isPvP() || (game.isPvP() && card.holder.tag === player_me.tag)) && ((i === 3 && ["close", "agile", "agile_cr", "agile_cs", "agile_crs"].includes(card.row)) || (i === 4 && ["ranged", "agile", "agile_cr", "agile_rs", "agile_crs"].includes(card.row)) || (i === 5 && ["siege", "agile_cs", "agile_rs", "agile_crs"].includes(card.row)))) ||
|
|
(game.isPvP() && card.holder.tag === player_op.tag && ((i === 2 && ["close", "agile", "agile_cr", "agile_cs", "agile_crs"].includes(card.row)) || (i === 1 && ["ranged", "agile", "agile_cr", "agile_rs", "agile_crs"].includes(card.row)) || (i === 0 && ["siege", "agile_cs", "agile_rs", "agile_crs"].includes(card.row))))) {
|
|
r.elem.classList.add("row-selectable");
|
|
// Row is selectable if it contains no unit to select, in order to play the unit itself without its effect
|
|
if (units.length === 0)
|
|
r.elem.classList.remove("noclick");
|
|
alteraClicavel(r, true);
|
|
units.forEach(c => c.elem.classList.remove("noclick"));
|
|
} else {
|
|
r.elem.classList.add("noclick");
|
|
r.special.elem.classList.add("noclick");
|
|
r.elem.classList.remove("card-selectable");
|
|
}
|
|
} else {
|
|
r.elem.classList.add("row-selectable");
|
|
alteraClicavel(r, true);
|
|
units.forEach(c => c.elem.classList.remove("noclick"));
|
|
}
|
|
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (card.abilities.includes("anna_henrietta_duchess")) {
|
|
let rows = [0, 1, 2];
|
|
if (game.isPvP() && card.holder.tag === player_op.tag) {
|
|
rows = [3, 4, 5];
|
|
}
|
|
for (i of rows) {
|
|
let r = board.row[i];
|
|
if (r.effects.horn > 0) {
|
|
r.elem.classList.add("row-selectable");
|
|
alteraClicavel(r, true);
|
|
} else {
|
|
r.elem.classList.add("noclick");
|
|
r.special.elem.classList.add("noclick");
|
|
r.elem.classList.remove("card-selectable");
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Target only enemy rows
|
|
if (card.abilities.includes("meve_princess") || card.abilities.includes("carlo_varese")) {
|
|
let rows = [0, 1, 2];
|
|
if (game.isPvP() && card.holder.tag === player_op.tag) {
|
|
rows = [3, 4, 5];
|
|
}
|
|
for (i of rows) {
|
|
let r = board.row[i];
|
|
if (r.isShielded() || !r.canBeScorched()) {
|
|
r.elem.classList.add("noclick");
|
|
r.special.elem.classList.add("noclick");
|
|
r.elem.classList.remove("card-selectable");
|
|
} else {
|
|
r.elem.classList.add("row-selectable");
|
|
alteraClicavel(r, true);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Play special card on any opponent row, provided it doesn't already have one
|
|
if (card.abilities.includes("cyrus_hemmelfart")) {
|
|
let rows = [0, 1, 2];
|
|
if (game.isPvP() && card.holder.tag === player_op.tag) {
|
|
rows = [3, 4, 5];
|
|
}
|
|
for (i of rows) {
|
|
let r = board.row[i];
|
|
if (r.containsCardByKey("spe_dimeritium_shackles") || r.isShielded()) {
|
|
r.elem.classList.add("noclick");
|
|
r.special.elem.classList.add("noclick");
|
|
r.elem.classList.remove("card-selectable");
|
|
} else {
|
|
r.elem.classList.add("row-selectable");
|
|
alteraClicavel(r, true);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
let currRows = card.row.includes("agile") ? board.getAgileRows(card, card.holder) : [board.getRow(card, card.row, card.holder)];
|
|
for (let i = 0; i < 6; i++) {
|
|
let row = board.row[i];
|
|
if (currRows.includes(row)) {
|
|
row.elem.classList.add("row-selectable");
|
|
if (!card.row.includes("agile")) alteraClicavel(row, true);
|
|
else fileira_clicavel = null;
|
|
} else if (card.abilities.includes("ambush") && currRows.includes(row.getOppositeRow())) {
|
|
// Ambush cards are symetrical, they affect available rows on each side of the battlefield
|
|
row.elem.classList.add("row-selectable");
|
|
} else {
|
|
row.elem.classList.add("noclick");
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// Make UI enter a mode where the player can re-arrange the cards on one side of the board (the one associated to the provided player)
|
|
// In this mode, when a player clicks a card, it displays the preview
|
|
// When the player clicks a row when a preview is displayed, move the card there (unless it was already there) and decrease remaining moves by one
|
|
enableBoardRearrangement(player,moves) {
|
|
if (this.underRearrangement)
|
|
return;
|
|
this.underRearrangement = true;
|
|
this.updateArrangementCounter(moves);
|
|
this.setSelectable(null, false);
|
|
let rows = (player === player_op) ? board.row.slice(0, 3) : board.row.slice(3);
|
|
player.hand.cards.forEach(c => c.elem.classList.add("noclick"));
|
|
for (let i = 0; i < 6; i++) {
|
|
let row = board.row[i];
|
|
//Valid side of board
|
|
if (rows.includes(row) ) {
|
|
row.elem.classList.remove("noclick");
|
|
if (row.cards.length > 0) {
|
|
alteraClicavel(row, true);
|
|
row.cards.filter(c => c.key !== "spe_decoy").forEach(c => c.elem.classList.remove("noclick"));
|
|
}
|
|
// Other side of board
|
|
} else {
|
|
row.elem.classList.add("noclick");
|
|
row.cards.forEach(c => c.elem.classList.add("noclick"));
|
|
}
|
|
|
|
}
|
|
ui.helper.showMessage("Select cards on the board to re-arrange.");
|
|
this.enablePlayer(true);
|
|
}
|
|
|
|
updateArrangementCounter(cnt) {
|
|
if (cnt > 0) {
|
|
this.arrangementMoves = cnt;
|
|
document.getElementById("arrangementWindow").classList.remove("hide");
|
|
document.getElementById("arrangementWindow-counter").innerText = cnt;
|
|
} else {
|
|
this.arrangementMoves = 0;
|
|
document.getElementById("arrangementWindow").classList.add("hide");
|
|
}
|
|
}
|
|
|
|
enableCardPowerEdit(player) {
|
|
if (this.underCardPowerEdit || !player.capabilities["cardEdit"] || player.capabilities["cardEdit"] < 1)
|
|
return;
|
|
this.underCardPowerEdit = true;
|
|
this.setSelectable(null, false);
|
|
let rows = (player === player_op) ? board.row.slice(0, 3) : board.row.slice(3);
|
|
player.hand.cards.forEach(c => c.elem.classList.add("noclick"));
|
|
for (let i = 0; i < 6; i++) {
|
|
let row = board.row[i];
|
|
//Valid side of board
|
|
if (rows.includes(row)) {
|
|
row.elem.classList.remove("noclick");
|
|
if (row.cards.length > 0) {
|
|
alteraClicavel(row, true);
|
|
row.cards.filter(c => c.hero || c.isUnit()).forEach(c => c.elem.classList.remove("noclick"));
|
|
}
|
|
// Other side of board
|
|
} else {
|
|
row.elem.classList.add("noclick");
|
|
row.cards.forEach(c => c.elem.classList.add("noclick"));
|
|
}
|
|
}
|
|
// Prevent the end of turn while selecting cards
|
|
player.endturn_action = async () => {
|
|
player.endturn_action = null;
|
|
}
|
|
ui.helper.showMessage("Select a card on your side of the board.");
|
|
this.enablePlayer(true);
|
|
}
|
|
|
|
async editCardPower(card) {
|
|
ui.helper.hide();
|
|
let newValue = await this.numberPopup(card.power, 0, 999, null, "Select a new base power", "Select the new base power (before other effects) for the selected card. Currently: " + String(card.power));
|
|
if (!card.originalBasePower)
|
|
card.originalBasePower = card.basePower;
|
|
card.basePower = newValue;
|
|
card.temporaryPower = true;
|
|
card.holder.capabilities["cardEdit"] -= 1;
|
|
this.underCardPowerEdit = false;
|
|
this.preview.classList.add("hide");
|
|
this.previewCard = null;
|
|
card.holder.hand.cards.forEach(c => c.elem.classList.remove("noclick"));
|
|
card.holder.endTurn(true);
|
|
}
|
|
}
|
|
|
|
var fimC = false;
|
|
|
|
// Displays up to 5 cards for the client to cycle through and select to perform an action
|
|
// Clicking the middle card performs the action on that card "count" times
|
|
// Clicking adejacent cards shifts the menu to focus on that card
|
|
class Carousel {
|
|
constructor(container, count, action, predicate, bSort, bExit = false, title) {
|
|
if (count <= 0 || !container || !action || container.cards.length === 0)
|
|
return;
|
|
this.container = container;
|
|
this.count = count;
|
|
this.action = action ? action : () => this.cancel();
|
|
this.predicate = predicate;
|
|
this.bSort = bSort;
|
|
this.indices = [];
|
|
this.index = 0;
|
|
this.bExit = bExit;
|
|
this.title = title;
|
|
this.cancelled = false;
|
|
this.selection = [];
|
|
|
|
if (!Carousel.elem) {
|
|
Carousel.elem = document.getElementById("carousel");
|
|
Carousel.elem.children[0].addEventListener("click", () => Carousel.curr.cancel(), false);
|
|
window.addEventListener("keydown", function (e) {
|
|
if (e.keyCode == 81) {
|
|
e.preventDefault();
|
|
try {
|
|
Carousel.curr.cancel();
|
|
} catch (err) { }
|
|
}
|
|
});
|
|
}
|
|
this.elem = Carousel.elem;
|
|
document.getElementsByTagName("main")[0].classList.remove("noclick");
|
|
|
|
this.elem.children[0].classList.remove("noclick");
|
|
this.previews = this.elem.getElementsByClassName("card-lg");
|
|
this.desc = this.elem.getElementsByClassName("card-description")[0];
|
|
this.title_elem = this.elem.children[2];
|
|
}
|
|
|
|
// Initializes the current Carousel
|
|
start() {
|
|
if (!this.elem)
|
|
return;
|
|
this.indices = this.container.cards.reduce((a, c, i) => (!this.predicate || this.predicate(c)) ? a.concat([i]) : a, []);
|
|
|
|
if (this.indices.length <= 0)
|
|
return this.exit();
|
|
if (this.bSort)
|
|
this.indices.sort((a, b) => Card.compare(this.container.cards[a], this.container.cards[b]));
|
|
|
|
this.update();
|
|
Carousel.setCurrent(this);
|
|
|
|
if (this.title) {
|
|
this.title_elem.innerHTML = this.title;
|
|
this.title_elem.classList.remove("hide");
|
|
} else {
|
|
this.title_elem.classList.add("hide");
|
|
}
|
|
|
|
this.elem.classList.remove("hide");
|
|
ui.enablePlayer(true);
|
|
tocar("explaining", false);
|
|
fimC = false;
|
|
setTimeout(function () {
|
|
var label = document.getElementById("carousel_label");
|
|
if (label.innerText.indexOf("redraw") > -1 && label.className.indexOf("hide") == -1) tocar("game_start", false);
|
|
}, 50);
|
|
}
|
|
|
|
// Called by the client to cycle cards displayed by n
|
|
shift(event, n) {
|
|
try {
|
|
(event || window.event).stopPropagation();
|
|
} catch (err) { }
|
|
tocar("card", false);
|
|
this.index = Math.max(0, Math.min(this.indices.length - 1, this.index + n));
|
|
this.update();
|
|
}
|
|
|
|
// Called by client to perform action on the middle card in focus
|
|
async select(event) {
|
|
try {
|
|
(event || window.event).stopPropagation();
|
|
} catch (err) { }
|
|
// In case of multiple selections, we only do action if not already selected
|
|
if (this.selection.indexOf(this.indices[this.index]) < 0) {
|
|
var label = document.getElementById("carousel_label");
|
|
if (label.innerText.indexOf("redraw") > -1 && label.className.indexOf("hide") == -1) {
|
|
tocar("redraw", false);
|
|
} else {
|
|
this.selection.push(this.indices[this.index]);
|
|
}
|
|
--this.count;
|
|
if (this.isLastSelection())
|
|
this.elem.classList.add("hide");
|
|
if (this.count <= 0)
|
|
ui.enablePlayer(false);
|
|
// For redraw, we run the action right away
|
|
if (label.innerText.indexOf("redraw") > -1 && label.className.indexOf("hide") == -1)
|
|
await this.action(this.container, this.indices[this.index]);
|
|
if (this.isLastSelection() && !this.cancelled) {
|
|
this.exit();
|
|
this.selection.map(async s => await this.action(this.container, s));
|
|
this.selection = [];
|
|
return;
|
|
}
|
|
|
|
} else {
|
|
// If already selected, remove from selection
|
|
this.selection.splice(this.selection.indexOf(this.indices[this.index]), 1);
|
|
this.count++;
|
|
}
|
|
this.update();
|
|
}
|
|
|
|
// Called by client to exit out of the current Carousel if allowed. Enables player interraction.
|
|
cancel() {
|
|
if (!fimC) {
|
|
fimC = true;
|
|
tocar("discard", false);
|
|
lCard = null;
|
|
exibindo_lider = false;
|
|
if (this.bExit) {
|
|
this.cancelled = true;
|
|
this.exit();
|
|
}
|
|
ui.enablePlayer(true);
|
|
}
|
|
}
|
|
|
|
// Returns true if there are no more cards to view or select
|
|
isLastSelection() {
|
|
return this.count <= 0 || this.indices.length === 0;
|
|
}
|
|
|
|
// Updates the visuals of the current selection of cards
|
|
update() {
|
|
this.indices = this.container.cards.reduce((a, c, i) => (!this.predicate || this.predicate(c)) ? a.concat([i]) : a, []);
|
|
if (this.index >= this.indices.length)
|
|
this.index = this.indices.length - 1;
|
|
for (let i = 0; i < this.previews.length; i++) {
|
|
let curr = this.index - 2 + i;
|
|
if (curr >= 0 && curr < this.indices.length) {
|
|
let card = this.container.cards[this.indices[curr]];
|
|
getPreviewElem(this.previews[i], card);
|
|
this.previews[i].classList.remove("hide");
|
|
this.previews[i].classList.remove("noclick");
|
|
if (this.selection.indexOf(this.indices[curr]) >= 0)
|
|
this.previews[i].classList.add("selection");
|
|
else
|
|
this.previews[i].classList.remove("selection");
|
|
} else {
|
|
this.previews[i].style.backgroundImage = "";
|
|
this.previews[i].classList.add("hide");
|
|
this.previews[i].classList.add("noclick");
|
|
this.previews[i].classList.remove("selection");
|
|
}
|
|
}
|
|
ui.setDescription(this.container.cards[this.indices[this.index]], this.desc);
|
|
}
|
|
|
|
// Clears and quits the current carousel
|
|
exit() {
|
|
for (let x of this.previews) {
|
|
x.style.backgroundImage = "";
|
|
x.classList.remove("selection");
|
|
}
|
|
this.elem.classList.add("hide");
|
|
Carousel.clearCurrent();
|
|
ui.quitCarousel();
|
|
}
|
|
|
|
// Statically sets the current carousel
|
|
static setCurrent(curr) {
|
|
this.curr = curr;
|
|
}
|
|
|
|
// Statically clears the current carousel
|
|
static clearCurrent() {
|
|
this.curr = null;
|
|
}
|
|
}
|
|
|
|
// Custom confirmation windows
|
|
class Popup {
|
|
constructor(yesName, yes, noName, no, header, description) {
|
|
this.yes = yes ? yes : () => { };
|
|
this.no = no ? no : () => { };
|
|
this.choice = false;
|
|
|
|
this.elem = document.getElementById("popup");
|
|
let main = this.elem.children[0];
|
|
main.children[0].innerHTML = header ? header : "";
|
|
main.children[1].innerHTML = description ? description : "";
|
|
main.children[2].children[0].innerHTML = (yesName) ? yesName : "Yes";
|
|
main.children[2].children[1].innerHTML = (noName) ? noName : "No";
|
|
|
|
this.elem.classList.remove("hide");
|
|
Popup.setCurrent(this);
|
|
ui.enablePlayer(true);
|
|
}
|
|
|
|
// Sets this as the current popup window
|
|
static setCurrent(curr) {
|
|
this.curr = curr;
|
|
}
|
|
|
|
// Unsets this as the current popup window
|
|
static clearCurrent() {
|
|
this.curr = null;
|
|
}
|
|
|
|
// Called when client selects the positive aciton
|
|
selectYes() {
|
|
this.clear();
|
|
this.choice = true;
|
|
this.yes(this);
|
|
return true;
|
|
}
|
|
|
|
// Called when client selects the negative option
|
|
selectNo() {
|
|
this.clear();
|
|
this.choice = false;
|
|
this.no(this);
|
|
return false;
|
|
}
|
|
|
|
// Clears the popup and diables player interraction
|
|
clear() {
|
|
ui.enablePlayer(false);
|
|
this.elem.classList.add("hide");
|
|
Popup.clearCurrent();
|
|
}
|
|
}
|
|
|
|
class NumberValuePopup {
|
|
constructor(value, min=0, max=999, callback, header, description) {
|
|
this.callback = callback ? callback : () => { };
|
|
this.choice = false;
|
|
|
|
this.elem = document.getElementById("number-popup");
|
|
let main = this.elem.children[0];
|
|
main.children[0].innerHTML = header ? header : "";
|
|
main.children[1].innerHTML = description ? description : "";
|
|
this.numberElem = document.getElementById("number-popup-value");
|
|
main.children[2].children[1].innerHTML = "Done";
|
|
|
|
this.numberElem.setAttribute("value", value);
|
|
this.numberElem.value = value;
|
|
this.numberElem.setAttribute("min", min);
|
|
this.numberElem.setAttribute("max", max);
|
|
|
|
this.elem.classList.remove("hide");
|
|
NumberValuePopup.setCurrent(this);
|
|
ui.enablePlayer(true);
|
|
}
|
|
|
|
// Sets this as the current popup window
|
|
static setCurrent(curr) {
|
|
this.curr = curr;
|
|
}
|
|
|
|
// Unsets this as the current popup window
|
|
static clearCurrent() {
|
|
this.curr = null;
|
|
}
|
|
|
|
// Called when client confirms value
|
|
done() {
|
|
this.value = this.numberElem.value;
|
|
if (!isNaN(this.value) && this.value != "") {
|
|
this.clear();
|
|
this.callback(this);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Clears the popup and diables player interraction
|
|
clear() {
|
|
ui.enablePlayer(false);
|
|
this.elem.classList.add("hide");
|
|
NumberValuePopup.clearCurrent();
|
|
}
|
|
}
|
|
|
|
class HelperBox {
|
|
constructor() {
|
|
this.text = "";
|
|
|
|
this.elem = document.getElementById("helper-box");
|
|
|
|
document.getElementById("help-box-close").addEventListener("click", () => this.hide(), false);
|
|
HelperBox.setCurrent(this);
|
|
}
|
|
|
|
// Sets this as the current helper box
|
|
static setCurrent(curr) {
|
|
this.curr = curr;
|
|
}
|
|
|
|
// Unsets this as the current helper box
|
|
static clearCurrent() {
|
|
this.curr = null;
|
|
}
|
|
|
|
showMessage(text, timer=0) {
|
|
this.text = text;
|
|
document.getElementById("helper-box-message").innerText = text;
|
|
this.elem.classList.remove("hide");
|
|
if (timer > 0) {
|
|
timer = Math.min(timer, 30);
|
|
var opacity = 1; // Initial opacity
|
|
var h = this;
|
|
setTimeout(function () {
|
|
// Fading out - 1s
|
|
var interval = setInterval(function () {
|
|
if (opacity > 0) {
|
|
opacity -= 0.1;
|
|
h.elem.style.opacity = opacity;
|
|
} else {
|
|
clearInterval(interval); // Stop the interval when opacity reaches 0
|
|
h.hide(); // Hide the element
|
|
h.elem.style.opacity = 1;
|
|
}
|
|
}, 100);
|
|
},timer*1000);
|
|
|
|
}
|
|
}
|
|
|
|
hide() {
|
|
this.elem.classList.add("hide");
|
|
}
|
|
}
|
|
|
|
var carta_selecionada = null;
|
|
|
|
// Screen used to customize, import and export deck contents
|
|
class DeckMaker {
|
|
constructor() {
|
|
this.elem = document.getElementById("deck-customization");
|
|
this.bank_elem = document.getElementById("card-bank");
|
|
this.deck_elem = document.getElementById("card-deck");
|
|
this.leader_elem = document.getElementById("card-leader");
|
|
this.leader_elem.children[1].addEventListener("click", () => this.selectLeader(), false);
|
|
this.leader_elem.children[1].addEventListener("mouseover", function () {
|
|
tocar("card", false);
|
|
this.style.boxShadow = "0 0 1.5vw #6d5210"
|
|
});
|
|
this.leader_elem.children[1].addEventListener("mouseout", function () {
|
|
this.style.boxShadow = "0 0 0 #6d5210"
|
|
});
|
|
|
|
this.faction = "realms";
|
|
this.setFaction(this.faction, true);
|
|
|
|
let start_deck = JSON.parse(JSON.stringify(premade_deck[0]));
|
|
start_deck.cards = start_deck.cards.map(c => ({
|
|
index: c[0],
|
|
count: c[1]
|
|
}));
|
|
this.me_deck_title = start_deck.title;
|
|
this.setLeader(start_deck.leader);
|
|
this.makeBank(this.faction, start_deck.cards);
|
|
|
|
this.start_op_deck;
|
|
this.me_deck_index = 0;
|
|
this.op_deck_index = 0;
|
|
|
|
this.change_elem = document.getElementById("change-faction");
|
|
this.change_elem.addEventListener("click", () => this.selectFaction(), false);
|
|
|
|
document.getElementById("select-deck").addEventListener("click", () => this.selectDeck(), false);
|
|
document.getElementById("select-op-deck").addEventListener("click", () => this.selectOPDeck(), false);
|
|
document.getElementById("download-deck").addEventListener("click", () => this.downloadDeck(), false);
|
|
document.getElementById("add-file").addEventListener("change", () => this.uploadDeck(), false);
|
|
document.getElementById("start-game").addEventListener("click", () => this.startNewGame(1), false);
|
|
document.getElementById("start-ai-game").addEventListener("click", () => this.startNewGame(2), false);
|
|
document.getElementById("start-pvp-game").addEventListener("click", () => this.startNewGame(3), false);
|
|
window.addEventListener("keydown", function (e) {
|
|
if (document.getElementById("deck-customization").className.indexOf("hide") == -1) {
|
|
switch (e.keyCode) {
|
|
case 69:
|
|
try {
|
|
Carousel.curr.cancel();
|
|
} catch (err) { }
|
|
if (isLoaded && iniciou) dm.startNewGame();
|
|
break;
|
|
case 88:
|
|
dm.selectLeader();
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
somCarta();
|
|
|
|
this.update();
|
|
}
|
|
|
|
// Called when client selects a deck faction. Clears previous cards and makes valid cards available.
|
|
async setFaction(faction_name, silent) {
|
|
if (!silent && this.faction === faction_name)
|
|
return false;
|
|
if (!silent) {
|
|
tocar("warning", false);
|
|
if (!confirm("Changing factions will clear the current deck. Continue? ")) {
|
|
tocar("warning", false);
|
|
return false;
|
|
}
|
|
}
|
|
this.elem.getElementsByTagName("h1")[0].innerHTML = factions[faction_name].name;
|
|
this.elem.getElementsByTagName("h1")[0].style.backgroundImage = iconURL("deck_shield_" + faction_name);
|
|
document.getElementById("faction-description").innerHTML = factions[faction_name].description;
|
|
|
|
this.leaders =
|
|
Object.keys(card_dict).map(cid => ({
|
|
card: card_dict[cid],
|
|
index: cid
|
|
}))
|
|
.filter(c => c.card.deck === faction_name && c.card.row === "leader");
|
|
if (!this.leader || this.faction !== faction_name) {
|
|
this.leader = this.leaders[0];
|
|
getPreviewElem(this.leader_elem.children[1], this.leader.card)
|
|
}
|
|
this.faction = faction_name;
|
|
setTimeout(function () {
|
|
somCarta();
|
|
}, 300);
|
|
return true;
|
|
}
|
|
|
|
// Called when client selects a leader for their deck
|
|
setLeader(index) {
|
|
this.leader = this.leaders.filter(l => l.index == index)[0];
|
|
getPreviewElem(this.leader_elem.children[1], this.leader.card)
|
|
}
|
|
|
|
// Constructs a bank of cards that can be used by the faction's deck.
|
|
// If a deck is provided, will not add cards to bank that are already in the deck.
|
|
makeBank(faction, deck) {
|
|
this.clear();
|
|
let cards = Object.keys(card_dict).map(cid => ({
|
|
card: card_dict[cid],
|
|
index: cid
|
|
})).filter(
|
|
p => (([faction, "neutral", "weather", "special"].includes(p.card.deck) ||
|
|
(["weather", "special"].includes(p.card.deck.split(" ")[0]) && p.card.deck.split(" ").includes(faction))) &&
|
|
p.card.row !== "leader" && !factions[faction].unavailableSpecials.includes(p.index)));
|
|
|
|
cards.sort(function (id1, id2) {
|
|
let a = card_dict[id1.index],
|
|
b = card_dict[id2.index];
|
|
let c1 = {
|
|
name: a.name,
|
|
basePower: -a.strength,
|
|
faction: a.deck.split(" ")[0] // Cleaning for faction specific special/weather cards
|
|
};
|
|
let c2 = {
|
|
name: b.name,
|
|
basePower: -b.strength,
|
|
faction: b.deck.split(" ")[0] // Cleaning for faction specific special/weather cards
|
|
};
|
|
return Card.compare(c1, c2);
|
|
});
|
|
|
|
|
|
let deckMap = {};
|
|
if (deck) {
|
|
for (let i of Object.keys(deck)) deckMap[deck[i].index] = deck[i].count;
|
|
}
|
|
cards.forEach(p => {
|
|
let count = deckMap[p.index] !== undefined ? Number(deckMap[p.index]) : 0;
|
|
this.makePreview(p.index, Number.parseInt(p.card.count) - count, this.bank_elem, this.bank,);
|
|
this.makePreview(p.index, count, this.deck_elem, this.deck);
|
|
});
|
|
}
|
|
|
|
// Creates HTML elements for the card previews
|
|
makePreview(index, num, container_elem, cards) {
|
|
let card_data = card_dict[index];
|
|
|
|
let elem = document.createElement("div");
|
|
elem.classList.add("card-lg");
|
|
elem = getPreviewElem(elem, card_data, num);
|
|
container_elem.appendChild(elem);
|
|
|
|
let bankID = {
|
|
index: index,
|
|
count: num,
|
|
elem: elem
|
|
};
|
|
let isBank = cards === this.bank;
|
|
cards.push(bankID);
|
|
let cardIndex = cards.length - 1;
|
|
elem.addEventListener("dblclick", () => this.select(cardIndex, isBank), false);
|
|
elem.addEventListener("mouseover", () => {
|
|
var aux = this;
|
|
carta_selecionada = function () {
|
|
aux.select(cardIndex, isBank);
|
|
}
|
|
}, false);
|
|
window.addEventListener("keydown", function (e) {
|
|
if (e.keyCode == 13 && carta_selecionada !== null) carta_selecionada();
|
|
});
|
|
// Right click allows to see more details about the selected card
|
|
elem.addEventListener('contextmenu', async (e) => {
|
|
e.preventDefault();
|
|
let container = new CardContainer();
|
|
container.cards = [new Card(index, card_data, null)];
|
|
try {
|
|
Carousel.curr.cancel();
|
|
} catch (err) { }
|
|
await ui.viewCardsInContainer(container);
|
|
}, false);
|
|
|
|
return bankID;
|
|
}
|
|
|
|
// Updates the card preview elements when any changes are made to the deck
|
|
update() {
|
|
for (let x of this.bank) {
|
|
if (x.count)
|
|
x.elem.classList.remove("hide");
|
|
else
|
|
x.elem.classList.add("hide");
|
|
}
|
|
let total = 0,
|
|
units = 0,
|
|
special = 0,
|
|
strength = 0,
|
|
hero = 0;
|
|
for (let x of this.deck) {
|
|
let card_data = card_dict[x.index];
|
|
if (x.count)
|
|
x.elem.classList.remove("hide");
|
|
else
|
|
x.elem.classList.add("hide");
|
|
total += x.count;
|
|
if (card_data.deck.startsWith("special") || card_data.deck.startsWith("weather")) {
|
|
special += x.count;
|
|
continue;
|
|
}
|
|
units += x.count;
|
|
strength += card_data.strength * x.count;
|
|
if (card_data.ability.split(" ").includes("hero"))
|
|
hero += x.count;
|
|
}
|
|
this.stats = {
|
|
total: total,
|
|
units: units,
|
|
special: special,
|
|
strength: strength,
|
|
hero: hero
|
|
};
|
|
this.updateStats();
|
|
}
|
|
|
|
// Updates and displays the statistics describing the cards currently in the deck
|
|
updateStats() {
|
|
let stats = document.getElementById("deck-stats");
|
|
stats.children[1].innerHTML = this.stats.total;
|
|
stats.children[3].innerHTML = this.stats.units + (this.stats.units < 22 ? "/22" : "");
|
|
stats.children[5].innerHTML = this.stats.special + "/10";
|
|
stats.children[7].innerHTML = this.stats.strength;
|
|
stats.children[9].innerHTML = this.stats.hero;
|
|
|
|
stats.children[3].style.color = this.stats.units < 22 ? "red" : "";
|
|
stats.children[5].style.color = (this.stats.special > 10) ? "red" : "";
|
|
}
|
|
|
|
// Opens a Carousel to allow the client to select a leader for their deck
|
|
selectLeader() {
|
|
let container = new CardContainer();
|
|
container.cards = this.leaders.map(c => {
|
|
let card = new Card(c.index, c.card, player_me);
|
|
card.data = c;
|
|
return card;
|
|
});
|
|
|
|
let index = this.leaders.indexOf(this.leader);
|
|
ui.queueCarousel(container, 1, (c, i) => {
|
|
let data = c.cards[i].data;
|
|
this.leader = data;
|
|
getPreviewElem(this.leader_elem.children[1], data.card);
|
|
}, () => true, false, true);
|
|
Carousel.curr.index = index;
|
|
Carousel.curr.update();
|
|
}
|
|
|
|
// Opens a Carousel to allow the client to select a faction for their deck
|
|
selectFaction() {
|
|
let container = new CardContainer();
|
|
container.cards = Object.keys(factions).map(f => {
|
|
return {
|
|
abilities: [f],
|
|
filename: f,
|
|
desc_name: factions[f].name,
|
|
desc: factions[f].description,
|
|
faction: "faction"
|
|
};
|
|
});
|
|
let index = container.cards.reduce((a, c, i) => c.filename === this.faction ? i : a, 0);
|
|
ui.queueCarousel(container, 1, (c, i) => {
|
|
let change = this.setFaction(c.cards[i].filename);
|
|
if (!change)
|
|
return;
|
|
this.makeBank(c.cards[i].filename);
|
|
this.update();
|
|
}, () => true, false, true);
|
|
Carousel.curr.index = index;
|
|
Carousel.curr.update();
|
|
}
|
|
|
|
// Called when client selects s a preview card. Moves it from bank to deck or vice-versa then updates;
|
|
select(index, isBank) {
|
|
carta_selecionada = null;
|
|
if (isBank) {
|
|
tocar("menu_buy", false);
|
|
this.add(index, this.deck);
|
|
this.remove(index, this.bank);
|
|
} else {
|
|
tocar("discard", false);
|
|
this.add(index, this.bank);
|
|
this.remove(index, this.deck);
|
|
}
|
|
this.update();
|
|
}
|
|
|
|
// Adds a card to container (Bank or deck)
|
|
add(index, cards) {
|
|
let id = cards[index];
|
|
id.elem.getElementsByClassName("card-count")[0].innerHTML = ++id.count;
|
|
id.elem.getElementsByClassName("card-count")[0].classList.remove("hide");
|
|
}
|
|
|
|
// Removes a card from container (bank or deck)
|
|
remove(index, cards) {
|
|
let id = cards[index];
|
|
id.elem.getElementsByClassName("card-count")[0].innerHTML = --id.count;
|
|
if (id.count === 0)
|
|
id.elem.getElementsByClassName("card-count")[0].classList.add("hide");
|
|
}
|
|
|
|
// Removes all elements in the bank and deck
|
|
clear() {
|
|
while (this.bank_elem.firstChild)
|
|
this.bank_elem.removeChild(this.bank_elem.firstChild);
|
|
while (this.deck_elem.firstChild)
|
|
this.deck_elem.removeChild(this.deck_elem.firstChild);
|
|
this.bank = [];
|
|
this.deck = [];
|
|
this.stats = {};
|
|
}
|
|
|
|
// Verifies current deck, creates the players and their decks, then starts a new game
|
|
// Modes:
|
|
// 1 - player VS AI
|
|
// 2 - AI vs AI
|
|
// 3 - player VS player (hotseat)
|
|
startNewGame(mode = 1) {
|
|
game.mode = mode;
|
|
openFullscreen();
|
|
let warning = "";
|
|
if (this.stats.units < 22)
|
|
warning += "Your deck must have at least 22 unit cards. \n";
|
|
if (this.stats.special > 10)
|
|
warning += "Your deck must have no more than 10 special cards. \n";
|
|
if (warning != "") {
|
|
return aviso(warning);
|
|
}
|
|
|
|
let me_deck = {
|
|
faction: this.faction,
|
|
leader: this.leader,
|
|
cards: this.deck.filter(x => x.count > 0),
|
|
title: this.me_deck_title
|
|
};
|
|
|
|
if (game.randomOPDeck || !this.start_op_deck) {
|
|
this.start_op_deck = JSON.parse(JSON.stringify(premade_deck[randomInt(Object.keys(premade_deck).length)]));
|
|
this.start_op_deck.cards = this.start_op_deck.cards.map(c => ({
|
|
index: c[0],
|
|
count: c[1]
|
|
}));
|
|
|
|
let leaders = Object.keys(card_dict).map(cid => {
|
|
return {
|
|
index: cid,
|
|
card: card_dict[cid]
|
|
};
|
|
}).filter(c => c.card.row === "leader" && c.card.deck === this.start_op_deck.faction);
|
|
this.start_op_deck.leader = leaders[randomInt(leaders.length)];
|
|
}
|
|
|
|
if (game.mode === 1) {
|
|
player_me = new Player(0, "Player 1", me_deck, false);
|
|
player_op = new Player(1, "Player 2", this.start_op_deck, true);
|
|
} else if (game.mode === 2) {
|
|
// AI vs AI
|
|
player_me = new Player(0, "Player 1", me_deck, true);
|
|
player_op = new Player(1, "Player 2", this.start_op_deck, true);
|
|
} else {
|
|
// PVP
|
|
player_me = new Player(0, "Player 1", me_deck, false);
|
|
player_op = new Player(1, "Player 2", this.start_op_deck, false);
|
|
}
|
|
|
|
|
|
this.elem.classList.add("hide");
|
|
tocar("game_opening", false);
|
|
game.startGame();
|
|
}
|
|
|
|
// Converts the current deck to a JSON string
|
|
deckToJSON() {
|
|
let obj = {
|
|
faction: this.faction,
|
|
leader: this.leader.index,
|
|
cards: this.deck.filter(x => x.count > 0).map(x => [x.index, x.count])
|
|
};
|
|
return JSON.stringify(obj);
|
|
}
|
|
|
|
// Select a premade deck
|
|
selectDeck() {
|
|
let container = new CardContainer();
|
|
container.cards = Object.values(premade_deck).map(d => {
|
|
let deck = d;
|
|
return {
|
|
abilities: [deck["faction"]],
|
|
name: card_dict[deck["leader"]]["name"],
|
|
row: "leader",
|
|
filename: card_dict[deck["leader"]]["filename"],
|
|
desc_name: deck["title"],
|
|
desc: "<p><b>Faction ability:</b> " + factions[deck["faction"]]["description"] + "</p><p><b>Leader ability:</b> " + ability_dict[card_dict[deck["leader"]]["ability"]].description + "</p><p><b>Deck description:</b> " + deck["description"],
|
|
faction: deck["faction"]
|
|
};
|
|
});
|
|
let index = container.cards.reduce((a, c, i) => c.faction === this.faction ? i : a, 0);
|
|
ui.queueCarousel(container, 1, (c, i) => {
|
|
this.me_deck_index = i;
|
|
this.setFaction(c.cards[i].faction, true);
|
|
this.deckFromJSON(premade_deck[i], false);
|
|
}, () => true, false, true);
|
|
Carousel.curr.index = this.me_deck_index;
|
|
Carousel.curr.update();
|
|
}
|
|
|
|
selectOPDeck() {
|
|
let container = new CardContainer();
|
|
// Adding first the option to select a random deck
|
|
container.cards = [{
|
|
abilities: [],
|
|
name: "Random deck",
|
|
row: "faction",
|
|
filename: "random",
|
|
desc_name: "Random deck",
|
|
desc: "A random deck from the pool that will change every game.",
|
|
faction: "faction"
|
|
}];
|
|
container.cards = container.cards.concat(Object.values(premade_deck).map(d => {
|
|
let deck = d;
|
|
return {
|
|
abilities: [deck["faction"]],
|
|
name: card_dict[deck["leader"]]["name"],
|
|
row: "leader",
|
|
filename: card_dict[deck["leader"]]["filename"],
|
|
desc_name: deck["title"],
|
|
desc: "<p><b>Faction ability:</b> " + factions[deck["faction"]]["description"] + "</p><p><b>Leader ability:</b> " + ability_dict[card_dict[deck["leader"]]["ability"]].description + "</p><p><b>Deck description:</b> " + deck["description"],
|
|
faction: deck["faction"]
|
|
};
|
|
}));
|
|
ui.queueCarousel(container, 1, (c, i) => {
|
|
this.op_deck_index = i;
|
|
if (i === 0) {
|
|
game.randomOPDeck = true;
|
|
document.getElementById("op-deck-name").innerHTML = "Random deck";
|
|
} else {
|
|
this.start_op_deck = JSON.parse(JSON.stringify(premade_deck[i - 1]));
|
|
this.start_op_deck.cards = this.start_op_deck.cards.map(c => ({
|
|
index: c[0],
|
|
count: c[1]
|
|
}));
|
|
this.start_op_deck.leader = {
|
|
index: this.start_op_deck.leader,
|
|
card: card_dict[this.start_op_deck.leader]
|
|
};
|
|
document.getElementById("op-deck-name").innerHTML = premade_deck[i - 1]["title"];
|
|
game.randomOPDeck = false;
|
|
}
|
|
}, () => true, false, true);
|
|
Carousel.curr.index = this.op_deck_index;
|
|
Carousel.curr.update();
|
|
}
|
|
|
|
// Called by the client to downlaod the current deck as a JSON file
|
|
downloadDeck() {
|
|
let json = this.deckToJSON();
|
|
let str = "data:text/json;charset=utf-8," + encodeURIComponent(json);
|
|
let hidden_elem = document.getElementById('download-json');
|
|
hidden_elem.href = str;
|
|
hidden_elem.download = "MyGwentDeck.json";
|
|
hidden_elem.click();
|
|
}
|
|
|
|
// Called by the client to upload a JSON file representing a new deck
|
|
uploadDeck() {
|
|
let files = document.getElementById("add-file").files;
|
|
if (files.length <= 0)
|
|
return false;
|
|
let fr = new FileReader();
|
|
fr.onload = e => {
|
|
try {
|
|
this.deckFromJSON(e.target.result, true);
|
|
} catch (e) {
|
|
aviso("Uploaded deck is not formatted correctly!");
|
|
}
|
|
}
|
|
fr.readAsText(files.item(0));
|
|
document.getElementById("add-file").value = "";
|
|
openFullscreen();
|
|
}
|
|
|
|
// Creates a deck from a JSON file's contents and sets that as the current deck
|
|
// Notifies client with warnings if the deck is invalid
|
|
deckFromJSON(json, parse) {
|
|
let deck;
|
|
if (parse) {
|
|
try {
|
|
deck = JSON.parse(json);
|
|
} catch (e) {
|
|
aviso("Uploaded deck is not parsable!");
|
|
return;
|
|
}
|
|
} else {
|
|
deck = JSON.parse(JSON.stringify(json));
|
|
}
|
|
let warning = "";
|
|
if (card_dict[deck.leader].row !== "leader")
|
|
warning += "'" + card_dict[deck.leader].name + "' is cannot be used as a leader\n";
|
|
if (deck.faction != card_dict[deck.leader].deck)
|
|
warning += "Leader '" + card_dict[deck.leader].name + "' doesn't match deck faction '" + deck.faction + "'.\n";
|
|
|
|
let cards = deck.cards.filter(c => {
|
|
let card = card_dict[c[0]];
|
|
if (!card) {
|
|
warning += "ID " + c[0] + " does not correspond to a card.\n";
|
|
return false
|
|
}
|
|
if (!([deck.faction, "neutral", "special", "weather"].includes(card.deck) ||
|
|
(["special", "weather"].includes(card.deck.split(" ")[0]) && card.deck.split(" ").includes(deck.faction)))) {
|
|
warning += "'" + card.name + "' cannot be used in a deck of faction type '" + deck.faction + "'\n";
|
|
return false;
|
|
}
|
|
if (card.count < c[1]) {
|
|
console.log(card);
|
|
warning += "Deck contains " + c[1] + "/" + card.count + " available " + card_dict[c[0]].name + " cards\n";
|
|
return false;
|
|
}
|
|
return true;
|
|
})
|
|
.map(c => ({
|
|
index: c[0],
|
|
count: Math.min(c[1], card_dict[c[0]].count)
|
|
}));
|
|
|
|
if (warning) {
|
|
tocar("warning", false);
|
|
if (!confirm(warning + "\n\n\Continue importing deck?")) {
|
|
tocar("warning", false);
|
|
return;
|
|
}
|
|
}
|
|
this.setFaction(deck.faction, true);
|
|
if (card_dict[deck.leader].row === "leader" && deck.faction === card_dict[deck.leader].deck) {
|
|
this.leader = this.leaders.filter(c => c.index === deck.leader)[0];
|
|
getPreviewElem(this.leader_elem.children[1], this.leader.card);
|
|
}
|
|
this.me_deck_title = deck.title;
|
|
this.makeBank(deck.faction, cards);
|
|
this.update();
|
|
}
|
|
}
|
|
|
|
class DeckSorter {
|
|
constructor(cards, player, action, title, bottomAllowed = false) {
|
|
if (!player || !cards || cards.length === 0)
|
|
return;
|
|
this.cards = cards;
|
|
this.player = player;
|
|
this.bottomAllowed = bottomAllowed;
|
|
this.action = action ? action : () => this.close();
|
|
this.title = title;
|
|
this.completed = false;
|
|
this.target_id = null;
|
|
|
|
if (!DeckSorter.elem) {
|
|
DeckSorter.elem = document.getElementById("deck-sorter");
|
|
}
|
|
this.elem = DeckSorter.elem;
|
|
document.getElementsByTagName("main")[0].classList.remove("noclick");
|
|
|
|
this.elem.children[0].classList.remove("noclick");
|
|
this.title_elem = document.getElementById("deck-sorter-title");
|
|
}
|
|
|
|
// Initializes the current DeckSorter
|
|
start() {
|
|
if (!this.elem || !this.cards | this.cards.length == 0)
|
|
return;
|
|
|
|
let bankRow = document.getElementById("drop-bank");
|
|
let deckTop = document.getElementById("drop-deck-top");
|
|
let deckBottom = document.getElementById("drop-deck-bottom");
|
|
//Remove old card boxes if any
|
|
this.elem.querySelectorAll('.drop-box').forEach(oi => {
|
|
oi.remove()
|
|
});
|
|
this.elem.querySelectorAll('.drop-susp').forEach(oi => {
|
|
oi.remove()
|
|
});
|
|
|
|
// Add a "..." at the beginning of the bottom row
|
|
let box = null;
|
|
if (this.bottomAllowed) {
|
|
deckBottom.style.visibility = 'visible';
|
|
box = document.createElement("div");
|
|
box.classList.add("drop-susp");
|
|
box.innerHTML = "···";
|
|
deckBottom.appendChild(box);
|
|
} else {
|
|
deckBottom.style.visibility = 'hidden';
|
|
}
|
|
for (var i = 0; i < this.cards.length; i++) {
|
|
// Create the bank box
|
|
box = document.createElement("div");
|
|
box.classList.add("drop-box");
|
|
bankRow.appendChild(box);
|
|
// Create the sortable item
|
|
let item = document.createElement("div");
|
|
item.classList.add("drop-item");
|
|
item.setAttribute("draggable", "true");
|
|
item.setAttribute("id", "item-" + i.toString());
|
|
item.setAttribute("data-pos", i.toString());
|
|
item.setAttribute("data-card-key", this.cards[i].key);
|
|
box.appendChild(item);
|
|
// Add card container
|
|
let cardContainer = document.createElement("div");
|
|
cardContainer.classList.add("card-lg");
|
|
// Add the card content
|
|
getPreviewElem(cardContainer, this.cards[i]);
|
|
cardContainer.classList.remove("hide");
|
|
cardContainer.classList.remove("noclick");
|
|
item.appendChild(cardContainer);
|
|
|
|
// Prevent all children elements from being draggable instead of the parent node
|
|
let children = item.querySelectorAll('*');
|
|
children.forEach(n => {
|
|
n.setAttribute("draggable", "false")
|
|
});
|
|
|
|
item.addEventListener('dragstart', dragStart);
|
|
item.addEventListener('dragend', dragEnd);
|
|
// Add a box in the Top row
|
|
box = document.createElement("div");
|
|
box.classList.add("drop-box");
|
|
deckTop.appendChild(box);
|
|
// Add a box in the Bottom row
|
|
if (this.bottomAllowed) {
|
|
box = document.createElement("div");
|
|
box.classList.add("drop-box");
|
|
deckBottom.appendChild(box);
|
|
}
|
|
}
|
|
// Add a "..." at the end of the bottom row
|
|
box = document.createElement("div");
|
|
box.classList.add("drop-susp");
|
|
box.innerHTML = "···";
|
|
deckTop.appendChild(box);
|
|
// Add done button
|
|
box = document.createElement("div");
|
|
box.classList.add("drop-susp");
|
|
//box.innerHTML = "DONE";
|
|
bankRow.appendChild(box);
|
|
let submitBtn = document.createElement("button");
|
|
submitBtn.setAttribute("id", "drop-submit");
|
|
submitBtn.disabled = true;
|
|
submitBtn.innerText = "DONE";
|
|
submitBtn.addEventListener('click', submitDeckSorter);
|
|
box.appendChild(submitBtn);
|
|
|
|
function dragStart(e) {
|
|
//e.dataTransfer.setData('text/plain', e.target.id);
|
|
if (e.target) {
|
|
DeckSorter.curr.target_id = e.target.id;
|
|
setTimeout(() => {
|
|
e.target.classList.add('hide');
|
|
}, 0);
|
|
}
|
|
}
|
|
|
|
function dragEnd(e) {
|
|
// get the draggable element
|
|
//let id = e.dataTransfer.getData('text/plain');
|
|
let id = DeckSorter.curr.target_id;
|
|
let draggable = document.getElementById(id);
|
|
|
|
// display the draggable element - by default
|
|
if (draggable) {
|
|
draggable.classList.remove('hide');
|
|
}
|
|
}
|
|
|
|
/* drop targets */
|
|
let boxes = document.querySelectorAll('.drop-box');
|
|
boxes.forEach(box => {
|
|
box.addEventListener('dragenter', dragEnter)
|
|
box.addEventListener('dragover', dragOver);
|
|
box.addEventListener('dragleave', dragLeave);
|
|
box.addEventListener('drop', drop);
|
|
});
|
|
|
|
function dragEnter(e) {
|
|
e.preventDefault();
|
|
if (e.target) {
|
|
e.target.classList.add('drag-over');
|
|
}
|
|
}
|
|
|
|
function dragOver(e) {
|
|
e.preventDefault();
|
|
if (e.target) {
|
|
e.target.classList.add('drag-over');
|
|
}
|
|
}
|
|
|
|
function dragLeave(e) {
|
|
if (e.target) {
|
|
e.target.classList.remove('drag-over');
|
|
}
|
|
}
|
|
|
|
function drop(e) {
|
|
if (e.target) {
|
|
e.target.classList.remove('drag-over');
|
|
/*let children = e.target.querySelectorAll('*');
|
|
children.forEach(n => { n.setAttribute("draggable", "false") });*/
|
|
//let id = e.dataTransfer.getData('text/plain');
|
|
let id = DeckSorter.curr.target_id;
|
|
let draggable = document.getElementById(id);
|
|
|
|
// get the draggable element
|
|
if (e.target.querySelectorAll('.drop-item').length == 0 && e.target.classList.contains("drop-box")) {
|
|
// add it to the drop target
|
|
e.target.appendChild(draggable);
|
|
}
|
|
|
|
// display the draggable element
|
|
if (draggable) {
|
|
draggable.classList.remove('hide');
|
|
}
|
|
|
|
//Enable/disable submit button if all cards have been sorted
|
|
var bank = document.getElementById("drop-bank").querySelectorAll('.drop-item');
|
|
document.getElementById("drop-submit").disabled = (bank.length > 0);
|
|
}
|
|
}
|
|
|
|
function submitDeckSorter(e) {
|
|
var bank = document.getElementById("drop-bank").querySelectorAll('.drop-item');
|
|
var deckTop = document.getElementById("drop-deck-top").querySelectorAll('.drop-item');
|
|
var deckBottom = document.getElementById("drop-deck-bottom").querySelectorAll('.drop-item');
|
|
|
|
// If bank has been sorted, ready to go
|
|
if (bank.length == 0 && (deckTop.length + deckBottom.length) == DeckSorter.curr.cards.length) {
|
|
DeckSorter.curr.applyChanges();
|
|
DeckSorter.curr.exit();
|
|
}
|
|
}
|
|
|
|
if (this.title) {
|
|
this.title_elem.innerHTML = this.title;
|
|
this.title_elem.classList.remove("hide");
|
|
} else {
|
|
this.title_elem.classList.add("hide");
|
|
}
|
|
|
|
DeckSorter.setCurrent(this);
|
|
|
|
this.elem.classList.remove("hide");
|
|
ui.enablePlayer(true);
|
|
}
|
|
|
|
// Closes the deck sorter interface
|
|
exit() {
|
|
let bankRow = document.getElementById("drop-bank");
|
|
let deckTop = document.getElementById("drop-deck-top");
|
|
let deckBottom = document.getElementById("drop-deck-bottom");
|
|
//Remove old card boxes if any
|
|
bankRow.querySelectorAll('.drop-item').forEach(oi => {
|
|
oi.remove()
|
|
});
|
|
deckTop.querySelectorAll('.drop-susp').forEach(oi => {
|
|
oi.remove()
|
|
});
|
|
deckBottom.querySelectorAll('.drop-susp').forEach(oi => {
|
|
oi.remove()
|
|
});
|
|
this.elem.classList.add("hide");
|
|
DeckSorter.clearCurrent();
|
|
ui.enablePlayer(true);
|
|
}
|
|
|
|
isCompleted() {
|
|
return this.completed;
|
|
}
|
|
|
|
applyChanges() {
|
|
let deckTop = Array.from(document.getElementById("drop-deck-top").querySelectorAll('.drop-item'));
|
|
let deckBottom = Array.from(document.getElementById("drop-deck-bottom").querySelectorAll('.drop-item'));
|
|
// Init new deck without the first X cards being sorted
|
|
let newdeck = this.player.deck.cards.slice(this.cards.length);
|
|
let head = [];
|
|
//Adding cards at the top
|
|
let cards_bank = this.cards;
|
|
deckTop.forEach(function (el) {
|
|
let pos = parseInt(el.dataset.pos);
|
|
head.push(cards_bank[pos]);
|
|
});
|
|
newdeck.unshift(...head);
|
|
//Adding cards at the bottom
|
|
deckBottom.forEach(function (el) {
|
|
let pos = parseInt(el.dataset.pos);
|
|
newdeck.push(cards_bank[pos]);
|
|
});
|
|
// set new deck order
|
|
this.player.deck.cards = newdeck;
|
|
|
|
this.completed = true;
|
|
}
|
|
|
|
// Statically sets the current carousel
|
|
static setCurrent(curr) {
|
|
this.curr = curr;
|
|
}
|
|
|
|
// Statically clears the current carousel
|
|
static clearCurrent() {
|
|
this.curr = null;
|
|
}
|
|
}
|
|
|
|
// Translates a card between two containers
|
|
async function translateTo(card, container_source, container_dest) {
|
|
if (!container_dest || !container_source)
|
|
return;
|
|
// When solo vs AI, do not display the translations between hand and deck for the AI
|
|
if (game.mode == 1 && (container_dest === player_op.hand && container_source === player_op.deck) || (container_dest === player_op.deck && container_source === player_op.hand) )
|
|
return;
|
|
|
|
let elem = card.elem;
|
|
let source = !container_source ? card.elem : getSourceElem(card, container_source, container_dest);
|
|
let dest = getDestinationElem(card, container_source, container_dest);
|
|
if (!isInDocument(elem))
|
|
source.appendChild(elem);
|
|
let x = trueOffsetLeft(dest) - trueOffsetLeft(elem) + dest.offsetWidth / 2 - elem.offsetWidth;
|
|
let y = trueOffsetTop(dest) - trueOffsetTop(elem) + dest.offsetHeight / 2 - elem.offsetHeight / 2;
|
|
if (container_dest instanceof Row && container_dest.cards.length !== 0 && !card.isSpecial()) {
|
|
x += (container_dest.getSortedIndex(card) === container_dest.cards.length) ? elem.offsetWidth / 2 : -elem.offsetWidth / 2;
|
|
}
|
|
if (card.holder.controller instanceof ControllerAI)
|
|
x += elem.offsetWidth / 2;
|
|
if (container_source instanceof Row && container_dest instanceof Grave && !card.isSpecial()) {
|
|
let mid = trueOffset(container_source.elem, true) + container_source.elem.offsetWidth / 2;
|
|
x += trueOffset(elem, true) - mid;
|
|
}
|
|
if (container_source instanceof Row && container_dest === player_me.hand)
|
|
y *= 7 / 8;
|
|
await translate(elem, x, y);
|
|
|
|
// Returns true if the element is visible in the viewport
|
|
function isInDocument(elem) {
|
|
return elem.getBoundingClientRect().width !== 0;
|
|
}
|
|
|
|
// Returns the true offset of a nested element in the viewport
|
|
function trueOffset(elem, left) {
|
|
let total = 0;
|
|
let curr = elem;
|
|
while (curr) {
|
|
total += (left ? curr.offsetLeft : curr.offsetTop);
|
|
curr = curr.parentElement;
|
|
}
|
|
return total;
|
|
}
|
|
|
|
function trueOffsetLeft(elem) {
|
|
return trueOffset(elem, true);
|
|
}
|
|
|
|
function trueOffsetTop(elem) {
|
|
return trueOffset(elem, false);
|
|
}
|
|
|
|
// Returns the source container's element to transition from
|
|
function getSourceElem(card, source, dest) {
|
|
if (source instanceof HandAI)
|
|
return source.hidden_elem;
|
|
if (source instanceof Deck)
|
|
return source.elem.children[source.elem.children.length - 2];
|
|
return source.elem;
|
|
}
|
|
|
|
// Returns the destination container's element to transition to
|
|
function getDestinationElem(card, source, dest) {
|
|
if (dest instanceof HandAI)
|
|
return dest.hidden_elem;
|
|
if (card.isSpecial() && dest instanceof Row)
|
|
//return dest.elem_special;
|
|
return dest.special.elem;
|
|
if (dest instanceof Row || dest instanceof Hand || dest instanceof Weather) {
|
|
if (dest.cards.length === 0)
|
|
return dest.elem;
|
|
let index = dest.getSortedIndex(card);
|
|
let dcard = dest.cards[index === dest.cards.length ? index - 1 : index];
|
|
return dcard.elem;
|
|
}
|
|
return dest.elem;
|
|
}
|
|
}
|
|
|
|
// Translates an element by x from the left and y from the top
|
|
async function translate(elem, x, y) {
|
|
let vw100 = 100 / document.getElementById("dimensions").offsetWidth;
|
|
x *= vw100;
|
|
y *= vw100;
|
|
elem.style.transform = "translate(" + x + "vw, " + y + "vw)";
|
|
let margin = elem.style.marginLeft;
|
|
elem.style.marginRight = -elem.offsetWidth * vw100 + "vw";
|
|
elem.style.marginLeft = "";
|
|
await sleep(499);
|
|
elem.style.transform = "";
|
|
elem.style.position = "";
|
|
elem.style.marginLeft = margin;
|
|
elem.style.marginRight = margin;
|
|
}
|
|
|
|
// Fades out an element until hidden over the duration
|
|
async function fadeOut(elem, duration, delay) {
|
|
await fade(false, elem, duration, delay);
|
|
}
|
|
|
|
// Fades in an element until opaque over the duration
|
|
async function fadeIn(elem, duration, delay) {
|
|
await fade(true, elem, duration, delay);
|
|
}
|
|
|
|
// Fades an element over a duration
|
|
async function fade(fadeIn, elem, dur, delay) {
|
|
if (delay)
|
|
await sleep(delay);
|
|
let op = fadeIn ? 0.1 : 1;
|
|
elem.style.opacity = op;
|
|
elem.style.filter = "alpha(opacity=" + (op * 100) + ")";
|
|
if (fadeIn)
|
|
elem.classList.remove("hide");
|
|
let timer = setInterval(async function () {
|
|
op += (fadeIn ? 0.1 : -0.1);
|
|
if (op >= 1) {
|
|
clearInterval(timer);
|
|
return;
|
|
} else if (op <= 0.1) {
|
|
elem.classList.add("hide");
|
|
elem.style.opacity = "";
|
|
elem.style.filter = "";
|
|
clearInterval(timer);
|
|
return;
|
|
}
|
|
elem.style.opacity = op;
|
|
elem.style.filter = "alpha(opacity=" + (op * 100) + ")";
|
|
}, dur / 10);
|
|
}
|
|
|
|
// Get Image paths
|
|
function iconURL(name, ext = "png") {
|
|
return imgURL("icons/" + name, ext);
|
|
}
|
|
|
|
function largeURL(name, ext = "jpg") {
|
|
return imgURL("lg/" + name, ext)
|
|
}
|
|
|
|
function smallURL(name, ext = "jpg") {
|
|
return imgURL("sm/" + name, ext);
|
|
}
|
|
|
|
function bottomBgURL() {
|
|
return imgURL("icons/gwent_bottom_bg", "png");
|
|
}
|
|
|
|
function imgURL(path, ext) {
|
|
return "url('img/" + path + "." + ext + "')";
|
|
}
|
|
|
|
function getPreviewElem(elem, card, nb = 0) {
|
|
// Cleaning existing child nodes
|
|
while (elem.hasChildNodes()) {
|
|
elem.removeChild(elem.lastChild);
|
|
}
|
|
elem.classList.remove("hero");
|
|
elem.classList.remove("faction");
|
|
|
|
let c_abilities = "";
|
|
if ("ability" in card) {
|
|
c_abilities = card.ability.split(" ");
|
|
} else {
|
|
c_abilities = card.abilities;
|
|
}
|
|
let faction = ""
|
|
if ("deck" in card) {
|
|
faction = card.deck.split(" ")[0]; // Cleaning in case of special/weather cards being faction specific
|
|
} else {
|
|
faction = card.faction;
|
|
}
|
|
|
|
elem.style.backgroundImage = smallURL(faction + "_" + card.filename);
|
|
|
|
if (faction == "faction") {
|
|
elem.classList.add("faction");
|
|
return elem;
|
|
}
|
|
|
|
if (card.row != "leader" && !faction.startsWith("special") && faction != "neutral" && !faction.startsWith("weather")) {
|
|
let factionBand = document.createElement("div");
|
|
factionBand.style.backgroundImage = iconURL("faction-band-" + faction);
|
|
factionBand.classList.add("card-large-faction-band");
|
|
elem.appendChild(factionBand);
|
|
}
|
|
|
|
let cardbg = document.createElement("div");
|
|
cardbg.style.backgroundImage = bottomBgURL();
|
|
cardbg.classList.add("card-large-bg");
|
|
elem.appendChild(cardbg);
|
|
|
|
|
|
let card_name = document.createElement("div");
|
|
card_name.classList.add("card-large-name");
|
|
card_name.appendChild(document.createTextNode(card.name));
|
|
elem.appendChild(card_name);
|
|
|
|
if ("quote" in card) {
|
|
let quote_elem = document.createElement("div");
|
|
quote_elem.classList.add("card-large-quote");
|
|
quote_elem.appendChild(document.createTextNode(card.quote));
|
|
elem.appendChild(quote_elem);
|
|
}
|
|
|
|
// Nothing else to display for leaders
|
|
if (card.row === "leader") {
|
|
return elem;
|
|
}
|
|
|
|
let count = document.createElement("div");
|
|
count.innerHTML = nb;
|
|
count.classList.add("card-count");
|
|
cardbg.appendChild(count);
|
|
if (nb == 0) {
|
|
count.classList.add("hide");
|
|
}
|
|
|
|
let power = document.createElement("div");
|
|
power.classList.add("card-large-power");
|
|
elem.appendChild(power);
|
|
let bg;
|
|
if (c_abilities[0] === "hero" || ("hero" in card && card.hero)) {
|
|
bg = "power_hero";
|
|
elem.classList.add("hero");
|
|
} else if (faction.startsWith("weather")) {
|
|
bg = "power_" + c_abilities[0];
|
|
} else if (faction.startsWith("special")) {
|
|
let str = c_abilities[0];
|
|
if (str === "shield_c" || str == "shield_r" || str === "shield_s")
|
|
str = "shield";
|
|
bg = "power_" + str;
|
|
elem.classList.add("special");
|
|
} else {
|
|
bg = "power_normal";
|
|
}
|
|
power.style.backgroundImage = iconURL(bg);
|
|
|
|
let row = document.createElement("div");
|
|
row.classList.add("card-large-row");
|
|
elem.appendChild(row);
|
|
if (card.row === "close" || card.row === "ranged" || card.row === "siege" || card.row.includes("agile")) {
|
|
let num = document.createElement("div");
|
|
if ("strength" in card) {
|
|
num.appendChild(document.createTextNode(card.strength));
|
|
} else {
|
|
num.appendChild(document.createTextNode(card.basePower));
|
|
}
|
|
num.classList.add("card-large-power-strength");
|
|
power.appendChild(num);
|
|
row.style.backgroundImage = iconURL("card_row_" + card.row);
|
|
}
|
|
|
|
if (c_abilities.length > 0) {
|
|
let abi = document.createElement("div");
|
|
abi.classList.add("card-large-ability");
|
|
elem.appendChild(abi);
|
|
|
|
if (!faction.startsWith("special") && !faction.startsWith("weather") && c_abilities.length > 0 && c_abilities[c_abilities.length - 1] != "hero") {
|
|
let str = c_abilities[c_abilities.length - 1];
|
|
if (str === "cerys")
|
|
str = "muster";
|
|
if (str.startsWith("avenger"))
|
|
str = "avenger";
|
|
if (str === "scorch_c" || str == "scorch_r" || str === "scorch_s")
|
|
str = "scorch_combat";
|
|
if (str === "shield_c" || str == "shield_r" || str === "shield_s")
|
|
str = "shield";
|
|
abi.style.backgroundImage = iconURL("card_ability_" + str);
|
|
} else if (card.row.includes("agile")) {
|
|
abi.style.backgroundImage = iconURL("card_ability_" + "agile");
|
|
}
|
|
|
|
// In case of double abilities
|
|
if ((c_abilities.length > 1 && !(c_abilities[0] === "hero")) || (c_abilities.length > 2 && c_abilities[0] === "hero")) {
|
|
let abi2 = document.createElement("div");
|
|
abi2.classList.add("card-large-ability-2");
|
|
elem.appendChild(abi2);
|
|
|
|
let str = c_abilities[c_abilities.length - 2];
|
|
if (str === "cerys")
|
|
str = "muster";
|
|
if (str.startsWith("avenger"))
|
|
str = "avenger";
|
|
if (str === "scorch_c" || str == "scorch_r" || str === "scorch_s")
|
|
str = "scorch_combat";
|
|
if (str === "shield_c" || str == "shield_r" || str === "shield_s")
|
|
str = "shield";
|
|
abi2.style.backgroundImage = iconURL("card_ability_" + str);
|
|
}
|
|
}
|
|
|
|
return elem;
|
|
}
|
|
|
|
// Returns true if n is an Number
|
|
function isNumber(n) {
|
|
return !isNaN(parseFloat(n)) && isFinite(n);
|
|
}
|
|
|
|
// Returns true if s is a String
|
|
function isString(s) {
|
|
return typeof (s) === 'string' || s instanceof String;
|
|
}
|
|
|
|
// Returns a random integer in the range [0,n)
|
|
function randomInt(n) {
|
|
return Math.floor(Math.random() * n);
|
|
}
|
|
|
|
// Pauses execution until the passed number of milliseconds as expired
|
|
function sleep(ms) {
|
|
return new Promise(resolve => setTimeout(resolve, ms));
|
|
}
|
|
|
|
// Suspends execution until the predicate condition is met, checking every ms milliseconds
|
|
function sleepUntil(predicate, ms) {
|
|
return new Promise(resolve => {
|
|
let timer = setInterval(function () {
|
|
if (predicate()) {
|
|
clearInterval(timer);
|
|
resolve();
|
|
}
|
|
}, ms)
|
|
});
|
|
}
|
|
|
|
// Initializes the interractive YouTube object
|
|
function onYouTubeIframeAPIReady() {
|
|
ui.initYouTube();
|
|
}
|
|
|
|
/*----------------------------------------------------*/
|
|
|
|
var ui = new UI();
|
|
var board = new Board();
|
|
var weather = new Weather();
|
|
var game = new Game();
|
|
var player_me, player_op;
|
|
|
|
ui.enablePlayer(false);
|
|
let dm = new DeckMaker();
|
|
|
|
document.addEventListener('contextmenu', event => event.preventDefault());
|
|
|
|
document.onkeydown = function (e) {
|
|
if (e.keyCode != 123) {
|
|
if (document.getElementById("carousel").className != "hide") {
|
|
switch (e.keyCode) {
|
|
case 13:
|
|
Carousel.curr.select(e);
|
|
break;
|
|
case 37:
|
|
Carousel.curr.shift(e, -1);
|
|
break;
|
|
case 39:
|
|
Carousel.curr.shift(e, 1);
|
|
break;
|
|
}
|
|
} else if (document.getElementsByClassName("hover_un")[0].innerText.length > 1) {
|
|
switch (e.keyCode) {
|
|
case 69:
|
|
Popup.curr.selectYes();
|
|
break;
|
|
case 81:
|
|
Popup.curr.selectNo();
|
|
break;
|
|
}
|
|
} else if (!iniciou && isLoaded && (e.keyCode == 13 || e.keyCode == 69)) inicio();
|
|
} else return false;
|
|
}
|
|
|
|
var elem_principal = document.documentElement;
|
|
|
|
function openFullscreen() {
|
|
try {
|
|
if (elem_principal.requestFullscreen) elem_principal.requestFullscreen();
|
|
else if (elem_principal.webkitRequestFullscreen) elem_principal.webkitRequestFullscreen();
|
|
else if (elem_principal.msRequestFullscreen) elem_principal.msRequestFullscreen();
|
|
window.screen.orientation.lock("landscape");
|
|
} catch (err) { }
|
|
}
|
|
|
|
var lastSound = "";
|
|
|
|
function tocar(arquivo, pararMusica) {
|
|
if (arquivo != lastSound && arquivo != "") {
|
|
var s = new Audio("sfx/" + arquivo + ".mp3");
|
|
if (pararMusica && ui.youtube && ui.youtube.getPlayerState() === YT.PlayerState.PLAYING) {
|
|
ui.youtube.pauseVideo();
|
|
ui.toggleMusic_elem.classList.add("fade");
|
|
}
|
|
lastSound = arquivo;
|
|
if (iniciou) s.play();
|
|
setTimeout(function () {
|
|
lastSound = "";
|
|
}, 50);
|
|
}
|
|
}
|
|
|
|
function aviso(texto) {
|
|
tocar("warning", false);
|
|
setTimeout(function () {
|
|
alert(texto);
|
|
document.getElementById("start-game").blur();
|
|
tocar("warning", false);
|
|
}, 150);
|
|
}
|
|
|
|
function somCarta() {
|
|
var classes = ["card", "card-lg"];
|
|
for (var i = 0; i < classes.length; i++) {
|
|
var cartas = document.getElementsByClassName(classes[i]);
|
|
for (var j = 0; j < cartas.length; j++) {
|
|
if (cartas[j].id != "no_sound" && cartas[j].id != "no_hover") cartas[j].addEventListener("mouseover", function () {
|
|
tocar("card", false);
|
|
});
|
|
}
|
|
}
|
|
var tags = ["label", "a", "button"];
|
|
for (var i = 0; i < tags.length; i++) {
|
|
var rec = document.getElementsByTagName(tags[i]);
|
|
for (var j = 0; j < rec.length; j++) rec[j].addEventListener("mouseover", function () {
|
|
tocar("card", false);
|
|
});
|
|
}
|
|
var ids = ["pass-button", "toggle-music"];
|
|
for (var i = 0; i < ids.length; i++) document.getElementById(ids[i]).addEventListener("mouseover", function () {
|
|
tocar("card", false);
|
|
});
|
|
}
|
|
|
|
function cartaNaLinha(id, carta) {
|
|
if (id.charAt(0) == "f") {
|
|
if (!carta.hero) {
|
|
if (carta.name != "Decoy") {
|
|
var linha = parseInt(id.charAt(1));
|
|
if (linha == 1 || linha == 6) tocar("common3", false);
|
|
else if (linha == 2 || linha == 5) tocar("common2", false);
|
|
else if (linha == 3 || linha == 4) tocar("common1", false);
|
|
} else tocar("menu_buy", false);
|
|
} else tocar("hero", false);
|
|
}
|
|
}
|
|
|
|
function inicio() {
|
|
var classe = document.getElementsByClassName("abs");
|
|
for (var i = 0; i < classe.length; i++) classe[i].style.display = "none";
|
|
iniciou = true;
|
|
tocar("menu_opening", false);
|
|
openFullscreen();
|
|
iniciarMusica();
|
|
}
|
|
|
|
function iniciarMusica() {
|
|
try {
|
|
if (ui.youtube.getPlayerState() !== YT.PlayerState.PLAYING) {
|
|
ui.youtube.playVideo();
|
|
ui.toggleMusic_elem.classList.remove("fade");
|
|
}
|
|
} catch (err) { }
|
|
}
|
|
|
|
function cancelaClima() {
|
|
if (carta_c) {
|
|
ui.cancel();
|
|
hover_row = false;
|
|
setTimeout(function () {
|
|
hover_row = true;
|
|
}, 100);
|
|
}
|
|
}
|
|
|
|
var iniciou = false,
|
|
isLoaded = false;
|
|
|
|
var playingOnline;
|
|
|
|
window.onload = function () {
|
|
dimensionar();
|
|
playingOnline = window.location.href == "https://randompianist.github.io/gwent-classic-v2.0/";
|
|
document.getElementById("load_text").style.display = "none";
|
|
document.getElementById("button_start").style.display = "inline-block";
|
|
document.getElementById("deck-customization").style.display = "";
|
|
document.getElementById("toggle-music").style.display = "";
|
|
document.getElementsByTagName("main")[0].style.display = "";
|
|
document.getElementById("button_start").addEventListener("click", function () {
|
|
inicio();
|
|
});
|
|
isLoaded = true;
|
|
}
|
|
|
|
window.onresize = function () {
|
|
dimensionar();
|
|
}
|
|
|
|
function dimensionar() {
|
|
var prop = window.innerWidth / window.innerHeight;
|
|
var dim = document.getElementById("dimensions").offsetHeight;
|
|
document.getElementById("very_start_bg2").style.height = prop < 1.8 ? (parseInt(dim * 0.94) - 8) + "px" : "";
|
|
document.getElementById("very_start").style.paddingTop = "";
|
|
document.getElementById("very_start").style.paddingTop = parseInt(
|
|
(document.getElementById("very_start_bg2").offsetHeight - document.getElementById("very_start").offsetHeight) / 2
|
|
) + "px";
|
|
}
|
|
|
|
setTimeout(dimensionar(), 300);
|
|
|
|
function isMobile() {
|
|
if (navigator.userAgentData)
|
|
return navigator.userAgentData.mobile;
|
|
return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
|
|
} |