diff options
Diffstat (limited to 'rules.js')
| -rw-r--r-- | rules.js | 4503 |
1 files changed, 4503 insertions, 0 deletions
diff --git a/rules.js b/rules.js new file mode 100644 index 0000000..805e075 --- /dev/null +++ b/rules.js @@ -0,0 +1,4503 @@ +"use strict"; + +// INTERRUPT CARDS: +// Card 13 - Blockhouses (before enemy rolls on raid table) +// Card 14 - Foul Weather (when enemy is about to move) +// Card 15 - Lake Schooner (when enemy moves into friendly fortification along lake etc) + +// TODO: show british leader pool +// TODO: show discard/removed card list in UI + +// TODO: re-evaluate fortress ownership and VP when pieces move or are eliminated + +// TODO: rename node/space -> location/space or raw_space/space or box/space? +// TODO: replace piece[p].type lookups with index range checks + +const { spaces, pieces, cards } = require('./data'); + +const BRITAIN = 'Britain'; +const FRANCE = 'France'; + +// Order of pieces: br.leaders/br.units/fr.leaders/fr.units +let first_british_piece = -1; +let last_british_leader = -1; +let last_british_piece = -1; +let first_french_piece = -1; +let last_french_leader = -1; +let last_french_piece = -1; + +let british_militia_units = []; +let french_militia_units = []; + +// Create card event names. +for (let c = 1; c < cards.length; ++c) { + cards[c].event = cards[c].name + .replace(/&/g, "and") + .replace(/!/g, "") + .replace(/ /g, "_") + .toLowerCase(); +} + +// Figure out piece indices. +for (let p = 1; p < pieces.length; ++p) { + if (pieces[p].faction === 'british') { + if (pieces[p].type === 'militias') + british_militia_units.push(p); + if (first_british_piece < 0) + first_british_piece = p; + if (pieces[p].type === 'leader') + last_british_leader = p; + last_british_piece = p; + } else { + if (pieces[p].type === 'militias') + french_militia_units.push(p); + if (first_french_piece < 0) + first_french_piece = p; + if (pieces[p].type === 'leader') + last_french_leader = p; + last_french_piece = p; + } +} + +// Patch up leader/box associations. +for (let s = 1; s < spaces.length; ++s) { + if (spaces[s].type === 'leader-box') { + let p = find_leader(spaces[s].name); + spaces[s].leader = p; + pieces[p].box = s; + } +} + + +let game; +let view = null; +let states = {}; +let events = {}; + +let player; // aliased to game[friendly()] per-player state +let enemy_player; // aliased to game[enemy()] per-player state + +// These looping indices are updated with update_active_aliases() +let first_enemy_leader; +let first_enemy_piece; +let first_enemy_unit; +let first_friendly_leader; +let first_friendly_piece; +let first_friendly_unit; +let last_enemy_leader; +let last_enemy_piece; +let last_enemy_unit; +let last_friendly_leader; +let last_friendly_piece; +let last_friendly_unit; + +function DEBUG() { + console.log("WW("+game.state+","+game.active+"):\n\t" + JSON.stringify(game, (k,v) => (k!=='undo'&&k!=='log')?v:undefined)); +} + +function random(n) { + return ((game.seed = game.seed * 69621 % 0x7fffffff) / 0x7fffffff) * n | 0; +} + +function roll_d6() { + return random(6) + 1; +} + +function clamp(x, min, max) { + return Math.min(Math.max(x, min), max); +} + +function remove_from_array(array, item) { + let i = array.indexOf(item); + if (i >= 0) + array.splice(i, 1); +} + +function log(...args) { + let s = Array.from(args).join(" "); + console.log("LOG", s); + game.log.push(s); +} + +function friendly() { + return game.active; +} + +function enemy() { + return game.active === FRANCE ? BRITAIN : FRANCE; +} + +function enemy_of(role) { + return role === FRANCE ? BRITAIN : FRANCE; +} + +function set_active(new_active) { + console.log("ACTIVE =", game.state, new_active); + game.active = new_active; + update_active_aliases(); +} + +function update_active_aliases() { + player = game[friendly()]; + enemy_player = game[enemy()]; + if (game.active === BRITAIN) { + first_enemy_piece = first_french_piece; + last_enemy_leader = last_french_leader; + last_enemy_piece = last_french_piece; + first_friendly_piece = first_british_piece; + last_friendly_leader = last_british_leader; + last_friendly_piece = last_british_piece; + } else { + first_enemy_piece = first_british_piece; + last_enemy_leader = last_british_leader; + last_enemy_piece = last_british_piece; + first_friendly_piece = first_french_piece; + last_friendly_leader = last_french_leader; + last_friendly_piece = last_french_piece; + } + first_enemy_leader = first_enemy_piece; + first_friendly_leader = first_friendly_piece; + first_enemy_unit = last_enemy_leader + 1; + first_friendly_unit = last_friendly_leader + 1; + last_enemy_unit = last_enemy_piece; + last_friendly_unit = last_friendly_piece; +} + +function set_enemy_active(new_state) { + game.state = new_state; + set_active(enemy()); +} + +// LISTS + +const EARLY = 0; +const LATE = 1; + +const RELUCTANT = 0; +const SUPPORTIVE = 1; +const ENTHUSIASTIC = 2; + +function find_space(name) { + let ix = spaces.findIndex(node => node.name === name); + if (ix < 0) + throw new Error("cannot find space " + name); + return ix; +} + +function find_leader(name) { + let ix = pieces.findIndex(piece => piece.name === name); + if (ix < 0) + throw new Error("cannot find leader " + name); + return ix; +} + +function exists_unused_unit(name) { + for (let i = 0; i < pieces.length; ++i) + if (pieces[i].name === name && game.pieces.location[i] === 0) + return true; + return 0; +} + +function find_unused_unit(name) { + for (let i = 0; i < pieces.length; ++i) + if (pieces[i].name === name && game.pieces.location[i] === 0) + return i; + throw new Error("cannot find unit " + name); +} + +const ports = [ + "Alexandria", + "Baltimore", + "Boston", + "Halifax", + "Louisbourg", + "New Haven", + "New York", + "Philadelphia", + "Québec", +].map(name => spaces.findIndex(space => space.name === name)); + +const french_ports = [ + "Louisbourg", + "Québec", +].map(name => spaces.findIndex(space => space.name === name)); + +const fortresses = [ + "Albany", + "Alexandria", + "Baltimore", + "Boston", + "Halifax", + "Louisbourg", + "Montréal", + "New Haven", + "New York", + "Philadelphia", + "Québec", +].map(name => spaces.findIndex(space => space.name === name)); + +const departments = { + st_lawrence: [ + "Baie-St-Paul", + "Bécancour", + "Kahnawake", + "Lac des Deux Montagnes", + "Montréal", + "Québec", + "Rivière-Ouelle", + "Sorel", + "St-François", + "St-Jean", + "Trois-Rivières", + "Île d'Orléans", + ].map(name => spaces.findIndex(space => space.name === name)), + northern: [ + "Albany", + "Boston", + "Burlington", + "Charlestown", + "Concord", + "Deerfield", + "Gloucester", + "Hartford", + "Hoosic", + "Kinderhook", + "Manchester", + "New Haven", + "New York", + "Northampton", + "Peekskill", + "Portsmouth", + "Poughkeepsie", + "Providence", + "Schenectady", + "Trenton", + "Worcester", + ].map(name => spaces.findIndex(space => space.name === name)), + southern: [ + "Alexandria", + "Ashby's Gap", + "Augusta", + "Baltimore", + "Carlisle", + "Culpeper", + "Easton", + "Frederick", + "Harris's Ferry", + "Head of Elk", + "Lancaster", + "New Castle", + "Philadelphia", + "Reading", + "Shepherd's Ferry", + "Winchester", + "Woodstock", + "Wright's Ferry", + "York", + ].map(name => spaces.findIndex(space => space.name === name)), +} + +const indian_spaces = { + northern_indians: [ + "Kahnawake", + "Lac des Deux Montagnes", + "Mississauga", + "St-François", + ].map(name => spaces.findIndex(space => space.name === name)), + western_indians: [ + "Kittaning", + "Logstown", + "Mingo Town", + ].map(name => spaces.findIndex(space => space.name === name)), + mohawks: [ + "Canajoharie", + ].map(name => spaces.findIndex(space => space.name === name)), + iroquois: [ + "Cayuga", + "Karaghiyadirha", + "Oneida Castle", + "Onondaga", + "Shawiangto", + ].map(name => spaces.findIndex(space => space.name === name)), +} + +const indian_tribe = {}; + +function define_indian_settlement(space_name, tribe) { + let space = find_space(space_name); + if (space_name !== "Pays d'en Haut") + indian_tribe[space] = tribe; + for (let p = 1; p < pieces.length; ++p) + if (pieces[p].name === tribe) + pieces[p].settlement = space; +} + +define_indian_settlement("Kahnawake", "Caughnawaga"); +define_indian_settlement("Lac des Deux Montagnes", "Algonquin"); +define_indian_settlement("Mississauga", "Mississauga"); +define_indian_settlement("St-François", "Abenaki"); + +define_indian_settlement("Mingo Town", "Mingo"); +define_indian_settlement("Logstown", "Shawnee"); +define_indian_settlement("Kittaning", "Delaware"); + +define_indian_settlement("Canajoharie", "Mohawk"); + +define_indian_settlement("Cayuga", "Cayuga"); +define_indian_settlement("Karaghiyadirha", "Seneca"); +define_indian_settlement("Oneida Castle", "Oneida"); +define_indian_settlement("Onondaga", "Onondaga"); +define_indian_settlement("Shawiangto", "Tuscarora"); + +define_indian_settlement("Pays d'en Haut", "Ojibwa"); +define_indian_settlement("Pays d'en Haut", "Ottawa"); +define_indian_settlement("Pays d'en Haut", "Potawatomi"); +define_indian_settlement("Pays d'en Haut", "Huron"); + +const JOHNSON = find_leader('Johnson'); +const HALIFAX = find_space('Halifax'); +const LOUISBOURG = find_space('Louisbourg'); +const ST_LAWRENCE_CANADIAN_MILITIAS = find_space('St. Lawrence Canadian Militias'); +const NORTHERN_COLONIAL_MILITIAS = find_space('Northern Colonial Militias'); +const SOUTHERN_COLONIAL_MILITIAS = find_space('Southern Colonial Militias'); + +// Map spaces except militia boxes and leader boxes. +const first_space = 1; +const last_space = NORTHERN_COLONIAL_MILITIAS-1; + +const british_iroquois_or_mohawk_names = [ + "Seneca", "Cayuga", "Onondaga", "Tuscarora", "Oneida", "Mohawk" +]; + +const british_iroquois_or_mohawk_units = []; +for (let i = 0; i < pieces.length; ++i) { + let piece = pieces[i]; + if (piece.faction === 'british' && piece.type === 'indians' && british_iroquois_or_mohawk_names.includes(piece.name)) + british_iroquois_or_mohawk_units.push(i); +} + +const originally_friendly_spaces = { + France: departments.st_lawrence.concat([LOUISBOURG]), + Britain: departments.northern.concat(departments.southern).concat([HALIFAX]), +} + +// CARD DECK + +function reshuffle_deck() { + game.log.push("The deck is reshuffled."); + game.cards.draw_pile = game.draw_pile.concat(game.cards.discarded); + game.cards.discarded = []; +} + +function last_discard() { + if (game.cards.discarded.length > 0) + return game.cards.discarded[game.cards.discarded.length-1]; + return null; +} + +function deal_card() { + if (game.cards.draw_pile.length === 0) + reshuffle_deck(); + let i = random(game.cards.draw_pile.length); + let c = game.cards.draw_pile[i]; + game.cards.draw_pile.splice(i, 1); + return c; +} + +function deal_cards() { + let fn = game.France.hand_size - game.France.hand.length; + let bn = game.Britain.hand_size - game.Britain.hand.length; + + log("Dealt " + fn + " cards to France."); + log("Dealt " + bn + " cards to Britain."); + + while (fn > 0 && bn > 0) { + if (fn > 0) { + game.France.hand.push(deal_card()); + --fn; + } + if (bn > 0) { + game.Britain.hand.push(deal_card()); + --bn; + } + } +} + +function draw_leader_from_pool() { + if (game.pieces.pool.length > 0) { + let i = random(game.pieces.pool.length); + let p = game.pieces.pool[i]; + game.pieces.pool.splice(i, 1); + return p; + } + return 0; +} + +// ITERATORS + +function for_each_exit(s, fn) { + let { land, river, lakeshore } = spaces[s]; + for (let i = 0; i < land.length; ++i) + fn(land[i], 'land'); + for (let i = 0; i < river.length; ++i) + fn(river[i], 'river'); + for (let i = 0; i < lakeshore.length; ++i) + fn(lakeshore[i], 'lakeshore'); +} + +function for_each_friendly_piece_in_node(node, fn) { + for (let p = first_friendly_piece; p <= last_friendly_piece; ++p) { + if (is_piece_in_node(p, node)) + fn(p); + } +} + +function for_each_friendly_leader_in_node(node, fn) { + for (let p = first_friendly_leader; p <= last_friendly_leader; ++p) { + if (is_piece_in_node(p, node)) + fn(p); + } +} + +function for_each_friendly_unit_in_node(node, fn) { + for (let p = first_friendly_unit; p <= last_friendly_unit; ++p) { + if (is_piece_in_node(p, node)) + fn(p); + } +} + +function for_each_friendly_piece_in_space(space, fn) { + for (let p = first_friendly_piece; p <= last_friendly_piece; ++p) { + if (is_piece_in_space(p, space)) + fn(p); + } +} + +function for_each_friendly_leader_in_space(space, fn) { + for (let p = first_friendly_leader; p <= last_friendly_leader; ++p) { + if (is_piece_in_space(p, space)) + fn(p); + } +} + +function for_each_friendly_unit_in_space(space, fn) { + for (let p = first_friendly_unit; p <= last_friendly_unit; ++p) { + if (is_piece_in_space(p, space)) + fn(p); + } +} + +function for_each_unbesieged_enemy_in_space(space, fn) { + for (let p = first_enemy_unit; p <= last_enemy_unit; ++p) { + if (is_piece_unbesieged(p) && is_piece_in_space(p, space)) + fn(p); + } +} + +function for_each_piece_in_force(force, fn) { + for (let p = 0; p < pieces.length; ++p) + if (is_piece_in_force(p, force)) + fn(p); +} + +function for_each_unit_in_force(force, fn) { + for (let p = 0; p < pieces.length; ++p) + if (!is_leader(p) && is_piece_in_force(p, force)) + fn(p); +} + +function for_each_british_controlled_port(fn) { + for (let i = 0; i < ports.length; ++i) + if (is_british_controlled_space(ports[i])) + fn(ports[i]); +} + +function list_auxiliary_units_in_force(force) { + let list = []; + for_each_unit_in_force(force, p => { + if (is_auxiliary_unit(p)) + list.push(p); + }); + return list; +} + +// STATIC PROPERTIES + +function get_department(space) { + if (departments.st_lawrence.includes(space)) + return departments.st_lawrence; + if (departments.northern.includes(space)) + return departments.northern; + if (departments.southern.includes(space)) + return departments.southern; + return null; +} + +function department_militia(space) { + if (departments.st_lawrence.includes(space)) + return ST_LAWRENCE_CANADIAN_MILITIAS; + if (departments.northern.includes(space)) + return NORTHERN_COLONIAL_MILITIAS; + if (departments.southern.includes(space)) + return SOUTHERN_COLONIAL_MILITIAS; + return 0; +} + +function space_name(s) { + return spaces[s].name; +} + +function is_wilderness_or_mountain(space) { + let type = spaces[space].type; + return type === 'wilderness' || type === 'mountain'; +} + +function is_wilderness(space) { + return spaces[space].type === 'wilderness'; +} + +function is_mountain(space) { + return spaces[space].type === 'mountain'; +} + +function is_cultivated(space) { + return spaces[space].type === 'cultivated'; +} + +function is_militia_box(space) { + return spaces[space].type === 'militia-box'; +} + +function is_leader_box(space) { + return spaces[space].type === 'leader-box'; +} + +function is_originally_friendly(space) { + return originally_friendly_spaces[friendly()].includes(space); +} + +function is_originally_enemy(space) { + return originally_friendly_spaces[enemy()].includes(space); +} + +function is_fortress(space) { + return fortresses.includes(space); +} + +function is_port(space) { + return ports.includes(space); +} + +function is_only_port_space(space) { + return space === HALIFAX || space === LOUISBOURG; +} + +function is_leader(p) { + return pieces[p].type === 'leader'; +} + +function is_unit(p) { + return pieces[p].type !== 'leader'; +} + +function is_british_iroquois_or_mohawk(p) { + return british_iroquois_or_mohawk_units.includes(p); +} + +function is_drilled_troops(p) { + switch (pieces[p].type) { + case 'regulars': return true; + case 'light-infantry': return true; + case 'northern-provincials': return true; + case 'southern-provincials': return true; + } + return false; +} + +function is_militia_unit(p) { + return pieces[p].type === 'militias'; +} + +function is_light_infantry_unit(p) { + return pieces[p].type === 'light-infantry'; +} + +function is_indian_unit(p) { + return pieces[p].type === 'indians'; +} + +function is_indian_tribe(p, tribe) { + return pieces[p].name === tribe; +} + +function indian_home_settlement(p) { + return pieces[p].settlement || 0; +} + +function is_regulars_unit(p) { + return pieces[p].type === 'regulars'; +} + +function is_rangers_unit(p) { + return pieces[p].type === 'rangers'; +} + +function is_coureurs_unit(p) { + return pieces[p].type === 'coureurs'; +} + +function is_auxiliary_unit(p) { + switch (pieces[p].type) { + case 'indians': return true; + case 'coureurs': return true; + case 'rangers': return true; + } + return false; +} + +function piece_name(p) { + return pieces[p].name; +} + +function piece_movement(p) { + return pieces[p].movement; +} + +function leader_box_leader(s) { + return spaces[s].leader; +} + +function leader_box(p) { + return pieces[p].box; +} + +function leader_initiative(p) { + return pieces[p].initiative; +} + +function leader_command(p) { + return pieces[p].command; +} + +function leader_tactics(p) { + return pieces[p].tactics; +} + +// DYNAMIC PROPERTIES + +function piece_node(p) { + return game.pieces.location[p]; +} + +function piece_space(p) { + let where = piece_node(p); + while (is_leader_box(where)) + where = piece_node(leader_box_leader(where)); + return where; +} + +// commanding leader or self +function piece_force(self) { + let force = self; + let where = piece_node(force); + while (is_leader_box(where)) { + force = leader_box_leader(where); + where = piece_node(force); + } + return force; +} + +// is piece commanded by a leader (or self) +function is_piece_in_force(self, query) { + let force = self; + if (force === query) + return true; + let where = piece_node(force); + while (is_leader_box(where)) { + force = leader_box_leader(where); + if (force === query) + return true; + where = piece_node(force); + } + return false; +} + +function count_non_british_iroquois_and_mohawk_units_in_leader_box(leader) { + let n = 0; + for_each_friendly_piece_in_node(leader_box(leader), p => { + if (!is_british_iroquois_or_mohawk(p)) + ++n; + }); + return n; +} + +function count_pieces_in_force(force) { + let n = 0; + for_each_piece_in_force(force, p => { + ++n; + }); + return n; +} + +function count_units_in_force(force) { + let n = 0; + for_each_unit_in_force(force, p => { + ++n; + }); + return n; +} + +function count_friendly_units_inside(where) { + let n = 0; + for_each_friendly_unit_in_space(where, p => { + if (is_piece_inside(p)) + ++n; + }); + return n; +} + +function count_friendly_units_in_space(where) { + let n = 0; + for_each_friendly_unit_in_space(where, p => { + ++n; + }); + return n; +} + +function count_unbesieged_enemy_units_in_space(where) { + let n = 0; + for_each_unbesieged_enemy_in_space(where, p => { + ++n; + }); + return n; +} + +function unit_strength(p) { + if (is_unit_reduced(p)) + return pieces[p].reduced_strength; + return pieces[p].strength; +} + +function is_piece_activated(p) { + return game.pieces.activated.includes(p); +} + +function is_unit_reduced(p) { + return game.pieces.reduced.includes(p); +} + +function set_unit_reduced(p, v) { + if (v) { + if (!game.pieces.reduced.includes(p)) + game.pieces.reduced.push(p); + } else { + remove_from_array(game.pieces.reduced, p); + } +} + +function is_piece_inside(p) { + return game.pieces.inside.includes(p); +} + +function is_piece_unbesieged(p) { + return !game.pieces.inside.includes(p); +} + +function set_piece_inside(p) { + if (!game.pieces.inside.includes(p)) + game.pieces.inside.push(p); +} + +function set_piece_outside(p) { + remove_from_array(game.pieces.inside, p); +} + +function set_force_inside(force) { + // TODO: do we need to flatten forces inside a fort? + if (is_leader(force)) { + for_each_unit_in_force(force, p => { + isolate_piece_from_force(p); + set_piece_inside(p); + }); + for_each_piece_in_force(force, p => { + isolate_piece_from_force(p); + set_piece_inside(p); + }); + } else { + set_piece_inside(force); + } +} + +function is_piece_on_map(p) { + // TODO: militia boxes? + return piece_node(p) > 0; +} + +function is_unit_unused(p) { + // TODO: permanently eliminated + return piece_node(p) === 0; +} + +function is_piece_in_node(p, node) { + return piece_node(p) === node; +} + +function is_piece_in_space(p, space) { + return piece_space(p) === space; +} + +function has_amphib(space) { + return game.Britain.amphib.includes(space); +} + +function has_friendly_amphib(space) { + return game.active === BRITAIN && game.Britain.amphib.includes(space); +} + +function has_enemy_amphib(space) { + return game.active === FRANCE && game.Britain.amphib.includes(space); +} + +function place_friendly_raided_marker(space) { + player.raids.push(space); +} + +function has_friendly_raided_marker(space) { + return player.raids.includes(space); +} + +function has_enemy_raided_marker(space) { + return enemy_player.raids.includes(space); +} + +function is_space_besieged(space) { + return space in game.sieges; +} + +function is_space_unbesieged(space) { + return !is_space_besieged(space); +} + +function has_enemy_allied_settlement(space) { + return enemy_player.allied.includes(space); +} + +function has_friendly_allied_settlement(space) { + return player.allied.includes(space); +} + +function has_enemy_stockade(space) { + return enemy_player.stockades.includes(space); +} + +function has_friendly_stockade(space) { + return player.stockades.includes(space); +} + +function has_friendly_fortress(space) { + return is_fortress(space) && is_friendly_controlled_space(space); +} + +function has_enemy_fortress(space) { + return is_fortress(space) && is_enemy_controlled_space(space); +} + +function has_enemy_fort(space) { + return enemy_player.forts.includes(space); +} + +function has_friendly_fort(space) { + return player.forts.includes(space); +} + +function has_enemy_fort_uc(space) { + return enemy_player.forts_uc.includes(space); +} + +function has_friendly_fort_uc(space) { + return player.forts_uc.includes(space); +} + +function has_enemy_fort_or_fortress(space) { + return has_enemy_fort(space) || has_enemy_fortress(space); +} + +function has_enemy_fortifications(space) { + return has_enemy_stockade(space) || has_enemy_fort(space) || has_enemy_fortress(space); +} + +function has_friendly_fort_or_fortress(space) { + return has_friendly_fort(space) || has_friendly_fortress(space); +} + +function has_friendly_fortifications(space) { + return has_friendly_stockade(space) || has_friendly_fort(space) || has_friendly_fortress(space); +} + +function has_unbesieged_friendly_fortifications(space) { + return is_space_unbesieged(space) && has_friendly_fortifications(space); +} + +function has_unbesieged_friendly_fortress(space) { + return is_space_unbesieged(space) && has_friendly_fortress(space); +} + +function has_friendly_units(space) { + for (let p = first_friendly_unit; p <= last_friendly_unit; ++p) + if (is_piece_in_space(p, space)) + return true; + return false; +} + +function has_enemy_units(space) { + for (let p = first_enemy_unit; p <= last_enemy_unit; ++p) + if (is_piece_in_space(p, space)) + return true; + return false; +} + +function has_unbesieged_enemy_units(space) { + for (let p = first_enemy_unit; p <= last_enemy_unit; ++p) + if (is_piece_in_space(p, space) && !is_piece_inside(p)) + return true; + return false; +} + +function is_friendly_controlled_space(space) { + if (is_space_unbesieged(space) && !has_enemy_units(space)) { + if (is_originally_enemy(space)) { + if (has_friendly_units(space)) + return true; + if (has_friendly_amphib(space)) + return true; + } else { + // TODO: neutral spaces? + // return !is_originally_friendly(space); + return true; + } + } + return false; +} + +function is_enemy_controlled_space(space) { + if (is_space_unbesieged(space) && !has_friendly_units(space)) { + if (is_originally_friendly(space)) { + if (has_enemy_units(space)) + return true; + if (has_enemy_amphib(space)) + return true; + } else { + // TODO: neutral spaces? + // return !is_originally_enemy(space); + return true; + } + } + return false; +} + +function is_british_controlled_space(space) { + if (game.active === BRITAIN) + return is_friendly_controlled_space(space); + return is_enemy_controlled_space(space); +} + +function is_friendly_controlled_port(space) { + return is_port(space) && is_friendly_controlled_space(space); +} + +function has_friendly_supplied_drilled_troops(space) { + for (let p = first_friendly_unit; p <= last_friendly_unit; ++p) + if (is_drilled_troops(p) && is_piece_in_space(p, space) && is_in_supply(space)) + return true; + return false; +} + +function has_friendly_drilled_troops(space) { + for (let p = first_friendly_unit; p <= last_friendly_unit; ++p) + if (is_drilled_troops(p) && is_piece_in_space(p, space)) + return true; + return false; +} + +function has_friendly_rangers(space) { + if (game.active === BRITAIN) + for (let p = first_british_piece; p <= last_british_piece; ++p) + if (is_rangers_unit(p) && is_piece_in_space(p, space)) + return true; + return false; +} + +function has_friendly_coureurs(space) { + if (game.active === FRANCE) + for (let p = first_french_piece; p <= last_french_piece; ++p) + if (is_coureurs_unit(p) && is_piece_in_space(p, space)) + return true; + return false; +} + +function has_unbesieged_enemy_auxiliary(space) { + for (let p = first_enemy_unit; p <= last_enemy_unit; ++p) + if (is_auxiliary_unit(p) && is_piece_in_space(p, space) && !is_piece_inside(p)) + return true; + return false; +} + +function has_unbesieged_friendly_auxiliary(space) { + for (let p = first_friendly_unit; p <= last_friendly_unit; ++p) + if (is_auxiliary_unit(p) && is_piece_in_space(p, space) && !is_piece_inside(p)) + return true; + return false; +} + +function has_unbesieged_enemy_fortifications(space) { + return is_space_unbesieged(space) && has_enemy_fortifications(space); +} + +function has_besieged_enemy_fortifications(space) { + return is_space_besieged(space) && has_enemy_fortifications(space); +} + +function has_unbesieged_enemy_fort_or_fortress(space) { + return is_space_unbesieged(space) && has_enemy_fort_or_fortress(space); +} + +function has_unbesieged_friendly_units(space) { + for (let p = first_friendly_unit; p <= last_friendly_unit; ++p) + if (is_piece_in_space(p, space) && !is_piece_inside(p)) + return true; + return false; +} + +function count_militia_in_department(box) { + let list = (box === ST_LAWRENCE_CANADIAN_MILITIAS ? french_militia_units : british_militia_units); + for (let i = 0; i < list.length; ++i) + if (piece_node(list[i]) === box) + return true; + return false; +} + +function enemy_department_has_at_least_n_militia(where, n) { + let box = department_militia(where); + if (box) { + if (game.active === BRITAIN && box === ST_LAWRENCE_CANADIAN_MILITIAS) + return count_militia_in_department(box) >= n; + if (game.active === FRANCE && (box === NORTHERN_COLONIAL_MILITIAS || box === SOUTHERN_COLONIAL_MILITIAS)) + return count_militia_in_department(box) >= n; + } + return false; +} + +// Is a leader moving alone without a force. +function is_lone_leader(who) { + return is_leader(who) && count_pieces_in_force(who) === 0; +} + +// Is a single auxiliary unit (with or without leaders) +function is_lone_auxiliary(who) { + if (is_leader(who)) { + let only_ax = true; + let ax_count = 0; + for_each_unit_in_force(who, p => { + if (is_auxiliary_unit(p)) + ++ax_count; + else + only_ax = false; + }); + return only_ax && ax_count === 1; + } + return is_auxiliary_unit(who); +} + +function force_has_drilled_troops(who) { + if (is_leader(who)) { + let has_dt = false; + for_each_unit_in_force(who, p => { + if (is_drilled_troops(p)) + has_dt = true; + }); + return has_dt; + } + return is_drilled_troops(who); +} + +function force_has_auxiliary_unit(who) { + if (is_leader(who)) { + let has_ax = false; + for_each_unit_in_force(who, p => { + if (is_auxiliary_unit(p)) + has_ax = true; + }); + return has_ax; + } + return is_auxiliary_unit(who); +} + +function force_has_only_auxiliary_units(who) { + if (is_leader(who)) { + let only_ax = true; + for_each_unit_in_force(who, p => { + if (!is_auxiliary_unit(p)) + only_ax = false; + }); + return only_ax; + } + return is_auxiliary_unit(who); +} + +function is_raid_space(space) { + if (has_friendly_fort(space)) + return false; + if (has_friendly_fortress(space)) + return false; + if (has_friendly_stockade(space)) + return false; + if (has_friendly_drilled_troops(space)) + return false; + + if (is_originally_enemy(space)) + return true; + if (has_enemy_stockade(space)) + return true; + if (has_enemy_allied_settlement(space)) + return true; + + return false; +} + +function movement_allowance(who) { + let m = piece_movement(who); + for_each_unit_in_force(who, p => { + let pm = piece_movement(p); + if (pm < m) + m = pm; + }); + return m; +} + +function moving_piece() { + return game.move.moving; +} + +function moving_piece_space() { + return piece_space(moving_piece()); +} + +function intercepting_piece() { + return game.move.intercepting; +} + +function avoiding_piece() { + return game.move.avoiding; +} + +function moving_piece_came_from(here) { + return game.move.path[here]; +} + +function battle_space() { + return game.battle.where; +} + +function find_friendly_commanding_leader_in_space(space) { + let commander = 0; + for (let p = first_friendly_leader; p <= last_friendly_leader; ++p) + if (is_piece_in_space(p, space)) + if (!commander || leader_command(p) > leader_command(commander)) + commander = p; + return commander; +} + +function find_enemy_commanding_leader_in_space(space) { + let commander = 0; + for (let p = first_enemy_leader; p <= last_enemy_leader; ++p) + if (is_piece_in_space(p, space)) + if (!commander || leader_command(p) > leader_command(commander)) + commander = p; + return commander; +} + +// GAME STATE CHANGE HELPERS + +function award_vp(n) { + if (game.active === FRANCE) { + log(`France gains ${n} VP.`); + game.tracks.vp += n; + } else { + log(`Britain gains ${n} VP.`); + game.tracks.vp -= n; + } +} + +function remove_friendly_stockade(space) { + remove_from_array(player.stockades, space); +} + +function remove_friendly_fort_uc(space) { + remove_from_array(player.forts_uc, space); +} + +function remove_enemy_fort_uc(space) { + remove_from_array(enemy_player.forts_uc, space); +} + +function place_friendly_fort(space) { + remove_friendly_stockade(space); + remove_friendly_fort_uc(space); + player.forts.push(space); +} + +function place_friendly_fort_uc(space) { + player.forts_uc.push(space); +} + +// Isolate piece from any forces it may be involved in. +function isolate_piece_from_force(p) { + let where = piece_space(p); + if (is_leader(p)) + move_pieces_from_node_to_node(leader_box(p), where); + move_piece_to(p, where); +} + +function reduce_unit(p) { + if (is_unit_reduced(p)) { + eliminate_piece(p); + return true; + } + set_unit_reduced(p, 1); + log(piece_name(p) + " is reduced.") + return false; +} + +function eliminate_piece(p) { + log(piece_name(p) + " is eliminated."); + isolate_piece_from_force(p); + if (is_regulars_unit(p) || is_coureurs_unit(p)) + game.pieces.location[p] = 0; // TODO: permanently eliminated + else + game.pieces.location[p] = 0; +} + +function eliminate_indian_tribe(tribe) { + for (let p = first_enemy_unit; p <= last_enemy_unit; ++p) + if (is_indian_tribe(p, tribe) && is_piece_unbesieged(p)) + eliminate_piece(p); +} + +function move_piece_to(who, to) { + game.pieces.location[who] = to; +} + +function move_pieces_from_node_to_node(from, to) { + for (let p = 0; p < pieces.length; ++p) { + if (piece_node(p) === from) + move_piece_to(p, to); + } +} + +function capture_enemy_fortress(space) { + log("captures fortress"); + award_vp(3); +} + +function capture_enemy_fort(space) { + log(`captures enemy fort`); + remove_from_array(enemy_player.forts, space); + player.forts_uc.push(space); + award_vp(2); +} + +function capture_enemy_stockade(space) { + log(`captures enemy stockade`); + remove_from_array(enemy_player.stockades, space); + player.stockades.push(space); + award_vp(1); +} + +function eliminate_enemy_stockade_after_battle(space) { + log(`eliminates enemy stockade`); + remove_from_array(enemy_player.stockades, space); + award_vp(1); +} + +function eliminate_enemy_stockade_in_raid(space) { + log(`eliminates enemy stockade`); + remove_from_array(enemy_player.stockades, space); +} + +function add_raid(who) { + let where = piece_space(who); + console.log("add_raid", piece_name(who), "in", space_name(where)); + if (where && !game.raid.list.includes(where) && is_raid_space(where)) + game.raid.list.push(where); +} + +// PATH FINDING + +function is_in_supply(space) { + // TODO: trace supply + return true; +} + +function list_intercept_spaces(is_lone_ld, is_lone_ax) { + let intercept = {}; + + // 6.723 Leaders moving alone can NOT be intercepted + if (is_lone_ld) + return intercept; + + console.log("INTERCEPT SEARCH is_lone_ax=", is_lone_ax); + + for (let from = first_space; from <= last_space; ++from) { + if (has_unbesieged_enemy_units(from)) { + console.log("INTERCEPT FROM", space_name(from)); + + // 6.721 exception -- can always intercept units infiltrating same space + // TODO: infiltration + // intercept[from] = 3; + + for_each_exit(from, to => { + // 6.722 + if (has_unbesieged_friendly_units(to)) + return; + if (has_unbesieged_friendly_fortifications(to)) + return; + + // 6.721 + if (is_lone_ax && is_wilderness_or_mountain(to)) { + if (has_unbesieged_enemy_auxiliary(from)) { + console.log("INTERCEPT TO", space_name(to), "(lone ax)"); + intercept[to] = 2; + } + } else { + console.log("INTERCEPT TO", space_name(to)); + intercept[to] = 1; + } + }); + } + } + + return intercept; +} + +function gen_intercept(is_lone_ax, to) { + if (has_unbesieged_enemy_units(to)) { + // 6.721 exception -- can always intercept units infiltrating same space + // TODO: infiltration + /* + for_each_friendly_piece_in_space(to, p => { + // TODO: unbesieged + gen_action_piece(p); + }); + */ + + for_each_exit(to, from => { + // 6.721 + if (is_lone_ax && is_wilderness_or_mountain(to)) { + let has_ax = false; + let has_br_indians = false; + for_each_friendly_unit_in_space(from, p => { + // TODO: unbesieged + if (is_auxiliary_unit(p)) { + gen_action_piece(p); + if (is_british_iroquois_or_mohawk(p)) + has_br_indians = true; + else + has_ax = true; + } + }); + // allow leaders to accompany intercepting auxiliary unit + if (has_ax) { + for_each_friendly_leader_in_space(from, p => { + // TODO: unbesieged + gen_action_piece(p); + }); + } else if (has_br_indians) { + if (is_piece_in_space(JOHNSON, from)) { + // TODO: unbesieged + gen_action_piece(JOHNSON); + } + } + } else { + for_each_friendly_piece_in_space(from, p => { + // TODO: unbesieged + gen_action_piece(p); + }); + } + }); + } +} + +function search_naval_move(who, start_space, start_cost) { + let move_cost = game.move.cost = {}; + let move_path = game.move.path = {}; + let candidates = (game.active === FRANCE) ? french_ports : ports; + + if (start_cost > 0) + return; + + let from = piece_space(who); + + if (!candidates.includes(from) || !is_friendly_controlled_space(from)) + return; + + game.move.path[from] = null; + candidates.forEach(space => { + if (space === from) + return; + if (is_friendly_controlled_space(space)) { + game.move.cost[space] = 1; + game.move.path[space] = from; + } + }) +} + +// Use Breadth First Search to find all paths. + +function pq_push(queue, item, prio) { + // TODO: reprioritize if item is already in the queue + for (let i = 0, n = queue.length; i < n; ++i) + if (queue[i].prio > prio) + return queue.splice(i, 0, [prio, item]); + queue.push([prio, item]) +} + +function pq_pop(queue) { + return queue.shift()[1]; +} + +function search_boat_move(who, start_space, start_cost, max_cost) { + max_cost *= 2; // use odd numbers for paths with one land connection + + let move_cost = game.move.cost = {}; + let move_path = game.move.path = {}; + + if (start_cost >= max_cost) + return; + + let queue = []; + pq_push(queue, start_space, 0); + move_cost[start_space] = start_cost; + move_path[start_space] = null; + + const is_lone_ld = is_lone_leader(who); + const has_dt = force_has_drilled_troops(who); + + while (queue.length > 0) { + let current = pq_pop(queue); + let c_cost = move_cost[current]; + let c_ff = has_friendly_fortifications(current) || is_originally_friendly(current); + for_each_exit(current, (next, connection) => { + let n_ff = has_friendly_fortifications(next) || is_originally_friendly(next); + let n_cost = c_cost + 2; + let must_stop = false; + + if (connection === 'land') { + if (c_ff && n_ff && (c_cost & 1) === 0) { + n_cost += 1; + } else { + return; // Not a usable land connection + } + } + + // Must stop on entering interception space + if (next in game.move.intercept) + must_stop = true; + + // Must stop on entering enemy occupied spaces + if (has_unbesieged_enemy_units(next)) { + if (is_lone_ld) + return; // Lone leaders can never enter an enemy occupied space + // TODO: Infiltration + must_stop = true; // May continue if over-run + } + + if (has_enemy_stockade(next)) { + // TODO: Infiltration + n_cost = 18; // may not continue + } + + if (has_unbesieged_enemy_fort_or_fortress(next)) { + if (!has_dt) + return; // Must have Drilled Troops to enter an enemy fort or fortress space. + // TODO: Infiltration + n_cost = 18; // may not continue + } + + // No movement points left. + if (n_cost >= max_cost) + must_stop = true; + + console.log("SEARCH BOAT MOVE", space_name(current), ">", space_name(next), c_cost, n_cost); + + if (!(next in move_cost) || (n_cost < move_cost[next])) { + move_cost[next] = n_cost; + move_path[next] = current; + if (!must_stop) + pq_push(queue, next, n_cost); + } + + }); + } +} + +function search_land_move(who, start_space, start_cost, max_cost) { + let move_cost = game.move.cost = {}; + let move_path = game.move.path = {}; + + if (start_cost >= max_cost) + return; + + let queue = []; + pq_push(queue, start_space, 0); + move_cost[start_space] = start_cost; + move_path[start_space] = null; + + const is_lone_ld = is_lone_leader(who); + const has_dt = force_has_drilled_troops(who); + const has_ax = force_has_auxiliary_unit(who); + + while (queue.length > 0) { + let current = pq_pop(queue); + let c_cost = move_cost[current]; + let c_ff = has_friendly_fortifications(current); + for_each_exit(current, (next, connection) => { + let n_ff = has_friendly_fortifications(next); + let n_cost = c_cost + 1; + let must_stop = false; + + // Must stop on mountains. + if (is_mountain(next) && !n_ff) + n_cost = 9; // may not continue + + // Must stop in the next space after passing through... + if (current !== game.move.start_space && !c_ff) { + // Drilled Troops that pass through wilderness must stop in the next space. + if (has_dt && !has_ax && is_wilderness(current)) + n_cost = 9; // may not continue + + // Auxiliaries that pass through enemy cultivated must stop in the next space. + if (has_ax && !has_dt && is_originally_enemy(current)) + n_cost = 9; // may not continue + } + + // Must stop on entering interception space + if (next in game.move.intercept) + must_stop = true; + + // Must stop on entering enemy occupied spaces + if (has_unbesieged_enemy_units(next)) { + if (is_lone_ld) + return; // Lone leaders can never enter an enemy occupied space + // TODO: Infiltration + must_stop = true; // May continue if over-run + } + + if (has_enemy_stockade(next)) { + // TODO: Infiltration + n_cost = 9; // may not continue + } + + if (has_unbesieged_enemy_fort_or_fortress(next)) { + if (!has_dt) + return; // Must have Drilled Troops to enter an enemy fort or fortress space. + // TODO: Infiltration + n_cost = 9; // may not continue + } + + // No movement points left. + if (n_cost >= max_cost) + must_stop = true; + + console.log("SEARCH LAND MOVE", space_name(current), ">", space_name(next), c_cost, n_cost, must_stop); + + if (!(next in move_cost) || (n_cost < move_cost[next])) { + move_cost[next] = n_cost; + move_path[next] = current; + if (!must_stop) + pq_push(queue, next, n_cost); + } + }); + } +} + +function find_closest_friendly_unbesieged_fortification(start) { + let queue = []; + let seen = {}; + let stop = 1000; + let result = []; + + queue.push([start, 0]); + + while (queue.length > 0) { + let [ here, dist ] = queue.shift(); + console.log("CLOSEST", space_name(here), dist); + if (dist > stop) + break; + if (has_unbesieged_friendly_fortifications(here)) { + console.log(" FOUND FRIENDLY FORT"); + stop = dist; + result.push(here); + } + if (dist < stop) { + for_each_exit(here, (next) => { + if (!(next in seen)) + queue.push([next, dist+1]); + seen[next] = 1; + }); + } + } + + console.log("CLOSEST =>", result); + return result; +} + +// SEQUENCE OF PLAY + +function start_year() { + if (game.tracks.year === 1759 && !game.events.pitt) { + log("Placing Amherst, Forbes, and Wolfe into the British leader pool."); + game.pieces.pool.push(find_leader("Amherst")); + game.pieces.pool.push(find_leader("Forbes")); + game.pieces.pool.push(find_leader("Wolfe")); + setup_leader("Amherst", "Amherst"); + setup_leader("Forbes", "Forbes"); + setup_leader("Wolfe", "Wolfe"); + } + + game.tracks.season = EARLY; + start_season(); +} + +function start_season() { + switch (game.tracks.season) { + case EARLY: + log(""); + log(`.h1 Early Season of ${game.tracks.year}`); + log(""); + break; + case LATE: + log(""); + log(`.h1 Late Season of ${game.tracks.year}`); + log(""); + break; + } + + if (game.events.quiberon_bay) + set_active(BRITAIN); + else + set_active(FRANCE); + + deal_cards(); + + start_action_phase(); +} + +function start_action_phase() { + game.state = 'action_phase'; + log(""); + log(`.h2 ${game.active}`); + log(""); +} + +function end_action_phase() { + console.log("END ACTION PHASE"); + clear_undo(); + game.pieces.activated.length = 0; + game.count = 0; + // TODO: skip if next player has no cards or passed + // TODO: end season + set_active(enemy()); + start_action_phase(); +} + +function can_play_event(card) { + let symbol = cards[card].symbol; + if (game.active === FRANCE && symbol === 'red') + return false; + if (game.active === BRITAIN && symbol === 'blue') + return false; + let event = events[cards[card].event]; + if (event !== undefined) { + if (event.can_play) + return event.can_play(); + return true; + } + return false; +} + +function gen_card_menu(card) { + if (can_play_event(card)) + gen_action('play_event', card); + gen_action('activate_force', card); + gen_action('activate_individually', card); + if (!player.did_construct) { + gen_action('construct_stockades', card); + gen_action('construct_forts', card); + } +} + +function card_name(card) { + return `#${card} ${cards[card].name} [${cards[card].activation}]`; +} + +function play_card(card) { + log(`${game.active} plays ${card_name(card)}.`); + remove_from_array(player.hand, card); + game.cards.current = card; + if (cards[card].special === 'remove') + game.cards.removed.push(card); + else + game.cards.discarded.push(card); +} + +function discard_card(card, reason) { + log(`${game.active} discards ${card_name(card)}${reason}.`); + remove_from_array(player.hand, card); + game.cards.current = card; + if (cards[card].special === 'remove') + game.cards.removed.push(card); + else + game.cards.discarded.push(card); +} + +states.action_phase = { + prompt() { + view.prompt = "Action Phase \u2014 play a card."; + for (let i = 0; i < player.hand.length; ++i) + gen_card_menu(player.hand[i]); + if (player.hand.length === 1 && !player.held) + gen_action_pass(); + }, + play_event(card) { + push_undo(); + player.did_construct = 0; + play_card(card); + events[cards[card].event].play(); + }, + activate_force(card) { + goto_activate_force(card); + }, + activate_individually(card) { + goto_activate_individually(card); + }, + construct_stockades(card) { + goto_construct_stockades(card); + }, + construct_forts(card) { + goto_construct_forts(card); + }, + pass() { + // TODO: can you build fortifications, pass, then build next turn? + log(game.active + " pass."); + game.passed = game.active; + end_action_phase(); + }, +} + +// ACTIVATION + +function goto_activate_individually(card) { + push_undo(); + player.did_construct = 0; + discard_card(card, " to activate auxiliaries and leaders"); + game.count = cards[card].activation; + game.state = 'activate_individually'; +} + +function goto_activate_force(card) { + push_undo(); + player.did_construct = 0; + discard_card(card, " to activate a force"); + game.state = 'activate_force'; + game.count = cards[card].activation; +} + +states.activate_individually = { + prompt() { + view.prompt = `Activate units and/or leaders individually \u2014 ${format_remain(game.count)}.`; + gen_action_next(); + if (game.count >= 1) { + for (let p = first_friendly_leader; p <= last_friendly_leader; ++p) { + if (is_piece_on_map(p)) + gen_action_piece(p); + } + } + if (game.count > 0) { + for (let p = first_friendly_unit; p <= last_friendly_unit; ++p) { + if (is_piece_on_map(p)) { + if (game.count >= 0.5) { + if (is_indian_unit(p)) + gen_action_piece(p); + } + if (game.count >= 1) { + if (is_rangers_unit(p)) + gen_action_piece(p); + if (is_coureurs_unit(p)) + gen_action_piece(p); + if (is_drilled_troops(p)) + if (game.pieces.activated.length === 0) + gen_action_piece(p); + } + } + } + } + }, + piece(piece) { + push_undo(); + log(`Activate ${piece_name(piece)}.`); + isolate_piece_from_force(piece); + game.pieces.activated.push(piece); + if (is_drilled_troops(piece)) + game.count = 0; + else if (is_indian_unit(piece)) + game.count -= 0.5; + else + game.count -= 1.0; + }, + next() { + goto_pick_move(); + }, +} + +states.activate_force = { + prompt() { + gen_action_pass(); + if (game.count > 0) { + view.prompt = "Activate a Force."; + for (let p = first_friendly_leader; p <= last_friendly_leader; ++p) { + if (is_piece_on_map(p) && leader_initiative(p) <= game.count) + gen_action_piece(p); + } + } else { + view.prompt = "Activate a Force \u2014 done."; + } + }, + piece(leader) { + push_undo(); + log(`Activate force led by ${piece_name(leader)}.`); + game.pieces.activated.push(leader); + game.count = 0; + goto_pick_force(); + }, + pass() { + end_action_phase(); + }, +} + +function end_activation() { + clear_undo(); + // TODO: goto_pick_force for campaign event + goto_pick_move(); +} + +function goto_pick_force() { + if (game.pieces.activated.length === 0) { + end_action_phase(); + } else if (game.pieces.activated.length === 1) { + let leader = game.pieces.activated.pop(); + game.force = { + leader: leader, + selected: leader, + reason: 'move', + }; + game.state = 'define_force'; + } else { + // TODO: for campaign event + game.state = 'pick_force'; + } +} + +function goto_pick_move() { + if (game.pieces.activated.length === 0) + end_action_phase(); + else if (game.pieces.activated.length === 1) + goto_move_piece(game.pieces.activated[0]) + else { + game.state = 'pick_move'; + } +} + +states.pick_move = { + prompt() { + view.prompt = "Select an activated force, leader, or unit to move." + gen_action_next(); + game.pieces.activated.forEach(gen_action_piece); + }, + piece(piece) { + push_undo(); + goto_move_piece(piece); + }, + next() { + end_action_phase(); + }, +} + +// DEFINE FORCE (for various actions) + +states.define_force = { + prompt() { + DEBUG(); + let main_leader = game.force.leader; + let selected = game.force.selected; + let space = piece_space(main_leader); + + // 5.534 Johnson commands British Iroquois and Mohawk units for free + let cap = leader_command(main_leader) - count_non_british_iroquois_and_mohawk_units_in_leader_box(selected); + + view.prompt = `Define the force to ${game.force.reason} with ${piece_name(main_leader)} from ${space_name(space)}.`; + view.prompt += " (" + piece_name(selected) + ")"; + view.who = selected; + + gen_action_next(); + + // Short-cut to Siege/Assault if activated force is highest commanding leader in space. + if (game.force.reason === 'move' && has_besieged_enemy_fortifications(space)) { + let commanding = find_friendly_commanding_leader_in_space(space); + if (main_leader === commanding && has_friendly_supplied_drilled_troops(space)) { + // TODO: gen_action_space(space); + if (is_assault_possible(space)) + gen_action('assault'); + else + gen_action('siege'); + } + } + + // select any leader in the map space + for_each_friendly_leader_in_space(space, p => { + if (p !== selected && !is_piece_inside(p)) { + gen_action_space(leader_box(p)); + // XXX if (p !== main_leader && leader_command(p) <= leader_command(selected)) + // XXX gen_action_piece(p); + } + }); + + // pick up subordinate leaders + for_each_friendly_leader_in_node(space, p => { + if (p !== selected && !is_piece_inside(p)) { + if (p !== main_leader && leader_command(p) <= leader_command(selected)) + gen_action_piece(p); + } + }); + + // drop off subordinate leaders + for_each_friendly_leader_in_node(leader_box(selected), p => { + if (p !== selected && !is_piece_inside(p)) + gen_action_piece(p); + }); + + // pick up units + for_each_friendly_unit_in_node(space, p => { + if (!is_piece_inside(p)) { + if (is_british_iroquois_or_mohawk(p)) { + // 5.534 Only Johnson can command British Iroquois and Mohawk (and for free) + if (selected === JOHNSON) + gen_action_piece(p); + } else { + if (cap > 0) + gen_action_piece(p); + } + } + }); + + // drop off units + for_each_friendly_unit_in_node(leader_box(selected), p => { + if (!is_piece_inside(p)) { + gen_action_piece(p); + } + }); + }, + + piece(piece) { + push_undo(); + let main_leader = game.force.leader; + let selected = game.force.selected; + let space = piece_space(main_leader); + if (piece_node(piece) === leader_box(selected)) + move_piece_to(piece, space); + else + move_piece_to(piece, leader_box(selected)); + }, + + space(space) { + push_undo(); + game.force.selected = leader_box_leader(space); + }, + + siege() { + push_undo(); + let where = piece_space(game.force.leader); + delete game.force; + goto_resolve_siege(where); + }, + + assault() { + push_undo(); + let where = piece_space(game.force.leader); + delete game.force; + goto_assault(where); + }, + + next() { + push_undo(); + let main_leader = game.force.leader; + let reason = game.force.reason; + delete game.force; + if (reason === 'move') { + goto_move_piece(main_leader); + } else if (reason === 'intercept' ) { + attempt_intercept(); + } else if (reason === 'avoid' ) { + attempt_avoid_battle(); + } else if (reason === 'retreat_defender' ) { + game.state = 'retreat_defender'; + } else { + throw Error("unknown reason state: " + game.reason); + } + }, +} + +// MOVE + +function goto_move_piece(who) { + log(`Move ${piece_name(who)}.`); + remove_from_array(game.pieces.activated, who); + let from = piece_space(who); +console.log("GOTO_MOVE_PIECE", who); + game.state = 'move'; + game.move = { + moving: who, + intercepting: null, + intercepted: [], + did_attempt_intercept: 0, + avoiding: null, + avoided: [], + start_space: from, + start_cost: 0, + type: is_only_port_space(from) ? 'naval' : 'land', + cost: null, + path: null, + }; + game.raid = { + where: 0, + battle: 0, + from: {}, + aux: list_auxiliary_units_in_force(who) + } + resume_move(); +} + +function may_naval_move(who) { + if (is_leader(who) && count_pieces_in_force(who) > 0) + return cards[game.cards.current].activation === 3; + return true; +} + +function resume_move() { + if (game.move.type === null) { + game.move.cost = {}; + game.move.path = {}; + throw Error("WHAT IS THIS"); + } + + let who = moving_piece(); + + const is_lone_ax = is_lone_auxiliary(who); + const is_lone_ld = is_lone_leader(who); +console.log("RESUME_MOVE_UNIT is_lone_ax=" + is_lone_ax + " is_lone_ld=" + is_lone_ld); + game.move.intercept = list_intercept_spaces(is_lone_ld, is_lone_ax); + + switch (game.move.type) { + case 'boat': + search_boat_move(who, piece_space(who), game.move.start_cost, 9); + break; + case 'land': + search_land_move(who, piece_space(who), game.move.start_cost, movement_allowance(who)); + break; + case 'naval': + if (may_naval_move(who)) + search_naval_move(who, piece_space(who), game.move.start_cost); + break; + } +} + +function print_path(path, destination, first) { + function print_path_rec(prev, next) { + if (path[prev] !== null) + print_path_rec(path[prev], prev); + else if (first) + log("moves from " + space_name(prev)); + log("moves to " + space_name(next)); + } + print_path_rec(path[destination], destination); +} + +function remove_enemy_forts_uc_in_path(path, space) { + for (;;) { + if (has_enemy_fort_uc(space)) { + log(`remove fort u/c in ${space_name(space)}`); + remove_enemy_fort_uc(space); + } + let next = path[space]; + if (next === null) + break; + space = next; + } +} + +states.move = { + prompt() { + let who = moving_piece(); + let from = piece_space(who); + view.prompt = "Move " + piece_name(who) + "."; + view.who = who; + switch (game.move.type) { + default: view.prompt += " Select a movement type."; break; + case 'boat': view.prompt += " (boat)"; break; + case 'land': view.prompt += " (land)"; break; + case 'naval': view.prompt += " (naval)"; break; + } + if (game.move.start_cost === 0) { + if (!is_only_port_space(from)) { + gen_action_x('boat_move', game.move.type !== 'boat'); + gen_action_x('land_move', game.move.type !== 'land'); + } + if (is_port(from)) { + // TODO: check valid destinations too + if (may_naval_move(who)) + gen_action_x('naval_move', game.move.type !== 'naval'); + } + } + gen_action_next(); + if (game.move.cost) { + for (let space_id in game.move.cost) { + space_id = space_id | 0; + if (space_id !== from) + gen_action_space(space_id); + } + } + if (is_leader(who)) { + for_each_piece_in_force(who, p => { + if (p !== who) + gen_action_piece(p); + }); + } + }, + boat_move() { + game.move.type = 'boat'; + resume_move(); + }, + land_move() { + game.move.type = 'land'; + resume_move(); + }, + naval_move() { + game.move.type = 'naval'; + resume_move(); + }, + space(to) { + push_undo(); + print_path(game.move.path, to, game.move.start_cost === 0); + let who = moving_piece(); + let cost = game.move.cost[to]; + game.move.start_cost = game.move.cost[to]; + + // remember where we came from so we can retreat after battle + game.raid.from[to] = game.move.path[to]; + + // TODO: except space moved into, if it is guarded! + if (force_has_drilled_troops(who)) + remove_enemy_forts_uc_in_path(game.move.path, to); + + move_piece_to(who, to); + goto_intercept(); + }, + piece(who) { + push_undo(); + let force = moving_piece(); + let where = piece_space(force); + log(`drops off ${piece_name(who)}`); + move_piece_to(who, where); + resume_move(); + }, + next() { + // TODO + end_move(); + }, +} + +function remove_siege_marker(where) { + delete game.sieges[where]; +} + +function place_siege_marker(where) { + game.sieges[where] = 0; +} + +function change_siege_marker(where, amount) { + return game.sieges[where] = clamp(game.sieges[where] + amount, 0, 2); +} + +function goto_battle_check() { + let where = moving_piece_space(); + console.log("BATTLE CHECK", space_name(where)); + if (has_unbesieged_enemy_units(where)) { + // TODO: breaking the siege + goto_battle(where, false, false); + } else { + end_move_step(false); + } +} + +function end_move_step(final) { + let who = moving_piece(); + let where = moving_piece_space(); + console.log("END MOVE STEP"); + delete game.battle; + game.move.did_attempt_intercept = 0; // reset flag for next move step + if (has_unbesieged_enemy_fortifications(where)) { + if (has_enemy_fort(where) || is_fortress(where)) { + place_siege_marker(where); + } + if (has_enemy_stockade(where)) { + if (force_has_drilled_troops(who)) { + capture_enemy_stockade(where) + } + } + end_move(); + } else if (final) { + end_move(); + } else { + resume_move(); + } +} + +function end_move() { + let who = moving_piece(); + + console.log("END MOVE"); + delete game.move; + + game.raid.list = []; + for (let i = 0; i < game.raid.aux.length; ++i) + add_raid(game.raid.aux[i]); + + goto_pick_raid(); +} + +// INTERCEPT + +function goto_intercept() { + let where = moving_piece_space(); + if (where in game.move.intercept) { + clear_undo(); + set_enemy_active('intercept_who'); + } else { + goto_declare_inside(where); + } +} + +function is_moving_piece_lone_ax_in_wilderness_or_mountain() { + let p = moving_piece(); + let s = piece_space(p); + return is_lone_auxiliary(p) && is_wilderness_or_mountain(s); +} + +states.intercept_who = { + prompt() { + let who = moving_piece(); + let where = piece_space(who); + let is_lone_ax = is_lone_auxiliary(who); + view.prompt = "Select a force or unit to intercept into " + space_name(where) + "."; + view.where = where; + gen_action_pass(); + gen_intercept(is_lone_ax, where); + }, + piece(piece) { + console.log("INTERCEPT WITH", piece_name(piece)); + if (is_leader(piece)) { + push_undo(); + game.move.intercepting = piece; + game.force = { + leader: piece, + selected: piece, + reason: 'intercept', + }; + if (is_moving_piece_lone_ax_in_wilderness_or_mountain()) + game.state = 'define_force_lone_ax'; // TODO + else + game.state = 'define_force'; + } else { + game.move.intercepting = piece; + attempt_intercept(); + } + }, + pass() { + log(`${game.active} decline to intercept`); + end_intercept_fail(); + }, +} + +function did_attempt_intercept_to_space(space) { + return game.move.intercepted_spaces.includes(space); +} + +function attempt_intercept() { + let piece = intercepting_piece(); + let tactics = 0; + if (is_leader(piece)) { + tactics = leader_tactics(piece); + for_each_piece_in_force(piece, p => { + game.move.intercepted.push(p) + }); + } else { + game.move.intercepted.push(piece); + } + game.move.did_attempt_intercept = 1; + + let roll = roll_d6(); + if (roll + tactics >= 4) { + if (is_leader(piece)) + log(`${piece_name(piece)} attempts to intercept:\n${roll} + ${tactics} >= 4 \u2014 success!`); + else + log(`${piece_name(piece)} attempts to intercept:\n${roll} >= 4 \u2014 success!`); + end_intercept_success(); + } else { + if (is_leader(piece)) + log(`${piece_name(piece)} attempts to intercept:\n${roll} + ${tactics} < 4 \u2014 failure!`); + else + log(`${piece_name(piece)} attempts to intercept:\n${roll} < 4 \u2014 failure!`); + end_intercept_fail(); + } +} + +function end_intercept_fail() { + set_enemy_active('move'); + goto_declare_inside(); +} + +function end_intercept_success() { + let who = intercepting_piece(); + let to = moving_piece_space(); + console.log("INTERCEPT SUCCESS " + piece_name(who) + " TO " + space_name(to)); + move_piece_to(who, to); + set_enemy_active('move'); + goto_declare_inside(); +} + +// DECLARE INSIDE/OUTSIDE FORTIFICATION + +function has_unbesieged_enemy_units_that_did_not_intercept(where) { + // TODO + return has_unbesieged_enemy_units(where); +} + +function goto_declare_inside() { + let where = moving_piece_space(); + if (has_unbesieged_enemy_units_that_did_not_intercept(where)) { + if (is_fortress(where) || has_enemy_fort(where)) { + console.log("DECLARE INSIDE/OUTSIDE"); + set_enemy_active('declare_inside'); + return; + } + } + goto_avoid_battle(); +} + +states.declare_inside = { + prompt() { + let where = moving_piece_space(); + view.prompt = "Declare which units and leaders withdraw into the fortification."; + gen_action_next(); + let n = count_friendly_units_inside(where); + for_each_friendly_piece_in_space(where, p => { + if (!is_piece_inside(p) && !did_piece_intercept(p)) { + if (is_leader(p) || is_fortress(where) || n < 4) + gen_action_piece(p); + } + }); + }, + piece(piece) { + console.log("INSIDE WITH", piece_name(piece)); + push_undo(); + isolate_piece_from_force(piece); + set_piece_inside(piece); + }, + next() { + set_active(enemy()); + goto_avoid_battle(); + }, +} + +// AVOID BATTLE + +function goto_avoid_battle() { + let space = moving_piece_space(); + if (has_unbesieged_enemy_units(space)) { + if (!game.move.did_attempt_intercept) { + if (can_enemy_avoid_battle(space)) { + console.log("AVOID BATTLE " + space_name(space)); + set_enemy_active('avoid_who'); + return; + } + } + } + goto_battle_check(space); +} + +function did_piece_intercept(piece) { + return game.move.intercepted.includes(piece); +} + +function did_piece_avoid_battle(piece) { + return game.move.avoided.includes(piece); +} + +states.avoid_who = { + prompt() { + let from = piece_space(moving_piece()); + view.prompt = "Select a force or unit to avoid battle in " + space_name(from) + "."; + gen_action_pass(); + for_each_friendly_piece_in_space(from, p => { + if (!did_piece_intercept(p) && !is_piece_inside(p)) + gen_action_piece(p); + }); + }, + piece(piece) { + console.log("AVOID BATTLE WITH", piece_name(piece)); + if (is_leader(piece)) { + push_undo(); + game.move.avoiding = piece; + game.force = { + leader: piece, + selected: piece, + reason: 'avoid', + }; + game.state = 'define_force'; + } else { + game.move.avoiding = piece; + attempt_avoid_battle(); + } + }, + pass() { + log(`${game.active} decline to avoid battle`); + end_avoid_battle(); + }, +} + +function attempt_avoid_battle() { + let from = moving_piece_space(); + let piece = avoiding_piece(); + let tactics = 0; + if (is_leader(piece)) { + tactics = leader_tactics(piece); + for_each_piece_in_force(piece, p => { + game.move.avoided.push(p) + }); + } else { + game.move.avoided.push(piece); + } + + // 6.8 Exception: Auxiliary and all-Auxiliary forces automatically succeed. + if (is_wilderness_or_mountain(from) && force_has_only_auxiliary_units(piece)) { + log(`${piece_name(piece)} automatically avoids battle from ${from.type} space.`); + game.state = 'avoid_to'; + return; + } + + let roll = roll_d6(); + if (roll + tactics >= 4) { + if (is_leader(piece)) + log(`${piece_name(piece)} attempts to avoid battle:\n${roll} + ${tactics} >= 4 \u2014 success!`); + else + log(`${piece_name(piece)} attempts to avoid battle:\n${roll} >= 4 \u2014 success!`); + game.state = 'avoid_to'; + } else { + if (is_leader(piece)) + log(`${piece_name(piece)} attempts to avoid battle:\n${roll} + ${tactics} < 4 \u2014 failure!`); + else + log(`${piece_name(piece)} attempts to avoid battle:\n${roll} < 4 \u2014 failure!`); + end_avoid_battle(); + } +} + +function can_enemy_avoid_battle(from) { + let can_avoid = false; + for_each_exit(from, to => { + if ((moving_piece_came_from(from) !== to) + && !has_unbesieged_friendly_units(to) + && !has_unbesieged_friendly_fortifications(to)) + can_avoid = true; + }); + // 6.811 British units in Amphib space may avoid directly to port + if (game.active === FRANCE) { + if (has_amphib(from)) { + for_each_british_controlled_port(to => { + if (to !== from) + can_avoid = true; + }); + } + } + return can_avoid; +} + +states.avoid_to = { + prompt() { + let from = piece_space(moving_piece()); + view.prompt = "Select where to avoid battle to."; + gen_action_pass(); + for_each_exit(from, to => { + if ((moving_piece_came_from(from) !== to) + && !has_unbesieged_enemy_units(to) + && !has_unbesieged_enemy_fortifications(to)) + gen_action_space(to); + }); + // 6.811 British units in Amphib space may avoid directly to port + if (game.active === BRITAIN) { + if (has_amphib(from)) { + for_each_british_controlled_port(to => { + if (to !== from) + gen_action_space(to); + }); + } + } + }, + space(to) { + end_avoid_battle_success(to); + }, + pass() { + log(`${game.active} decline to avoid battle`); + end_avoid_battle(); + }, +} + +function end_avoid_battle_success(to) { + let who = avoiding_piece(); + console.log("AVOID BATTLE SUCCESS " + piece_name(who) + " TO " + space_name(to)); + move_piece_to(who, to); + end_avoid_battle(); +} + +function end_avoid_battle() { + console.log("END AVOID BATTLE"); + set_enemy_active('move'); + goto_battle_check(); +} + +// BATTLE + +function for_each_attacking_piece(fn) { + let where = game.battle.where; + if (game.battle.breaking_siege) { + if (game.battle.attacker === BRITAIN) { + for (let p = first_british_piece; p <= last_british_piece; ++p) + if (is_piece_in_space(p, where)) + fn(p); + } else { + for (let p = first_french_piece; p <= last_french_piece; ++p) + if (is_piece_in_space(p, where)) + fn(p); + } + } else { + if (game.battle.attacker === BRITAIN) { + for (let p = first_british_piece; p <= last_british_piece; ++p) + if (is_piece_unbesieged(p) && is_piece_in_space(p, where)) + fn(p); + } else { + for (let p = first_french_piece; p <= last_french_piece; ++p) + if (is_piece_unbesieged(p) && is_piece_in_space(p, where)) + fn(p); + } + } +} + +function for_each_defending_piece(fn) { + let where = game.battle.where; + if (game.battle.assault) { + if (game.battle.defender === BRITAIN) { + for (let p = first_british_piece; p <= last_british_piece; ++p) + if (is_piece_in_space(p, where)) + fn(p); + } else { + for (let p = first_french_piece; p <= last_french_piece; ++p) + if (is_piece_in_space(p, where)) + fn(p); + } + } else { + if (game.battle.defender === BRITAIN) { + for (let p = first_british_piece; p <= last_british_piece; ++p) + if (is_piece_unbesieged(p) && is_piece_in_space(p, where)) + fn(p); + } else { + for (let p = first_french_piece; p <= last_french_piece; ++p) + if (is_piece_unbesieged(p) && is_piece_in_space(p, where)) + fn(p); + } + } +} + +function attacker_combat_strength() { + let str = 0; + for_each_attacking_piece(p => { + if (is_unit(p)) + str += unit_strength(p); + }); + return str; +} + +function defender_combat_strength() { + let str = 0; + for_each_defending_piece(p => { + if (is_unit(p)) + str += unit_strength(p); + }); + return str; +} + +const COMBAT_RESULT_TABLE = [ + // S/D 0 1 2 3 4 5 6 7 + [ 0, [ 0, 0, 0, 0, 0, 1, 1, 1 ]], + [ 1, [ 0, 0, 0, 0, 1, 1, 1, 1 ]], + [ 2, [ 0, 0, 0, 1, 1, 1, 1, 2 ]], + [ 3, [ 0, 0, 1, 1, 1, 1, 2, 2 ]], + [ 5, [ 0, 0, 1, 1, 2, 2, 2, 3 ]], + [ 8, [ 0, 1, 2, 2, 2, 3, 3, 3 ]], + [ 12, [ 1, 2, 2, 2, 3, 3, 4, 4 ]], + [ 16, [ 1, 2, 3, 3, 4, 4, 4, 5 ]], + [ 21, [ 2, 3, 3, 4, 4, 5, 5, 6 ]], + [ 27, [ 3, 4, 4, 4, 5, 5, 6, 7 ]], + [ 28, [ 3, 4, 5, 5, 6, 6, 7, 8 ]], +] + +function combat_result(str, die) { + die = clamp(die, 0, 7); + str = clamp(str, 0, 28); + for (let i = 0; i < COMBAT_RESULT_TABLE.length; ++i) + if (str <= COMBAT_RESULT_TABLE[i][0]) + return COMBAT_RESULT_TABLE[i][1][die]; + return NaN; +} + +function goto_battle(where, is_assault=false, is_breaking_siege=false) { + clear_undo(); + + game.battle = { + where: where, + attacker: game.active, + defender: enemy(), + assault: is_assault, + breaking_siege: is_breaking_siege, + }; + + if (game.raid) + game.raid.battle = where; + + log("BATTLE IN " + space_name(where)); + + // No Militia take part in assaults + if (!game.battle.assault) + goto_battle_militia(); + else + goto_battle_events(); +} + +function goto_battle_militia() { + let box = department_militia(game.battle.where); + if (box && count_militia_in_department(box) > 0) { + console.log("MILITIA", space_name(game.battle.where), space_name(box)); + let dept = null; + switch (box) { + case ST_LAWRENCE_CANADIAN_MILITIAS: + set_active(FRANCE); + dept = departments.st_lawrence; + break; + case NORTHERN_COLONIAL_MILITIAS: + set_active(BRITAIN); + dept = departments.northern; + break; + case SOUTHERN_COLONIAL_MILITIAS: + set_active(BRITAIN); + dept = departments.southern; + break; + } + // 7.3 exception: No Militia if there are enemy raided markers. + for (let i = 0; i < dept.length; ++i) + if (has_enemy_raided_marker(dept[i])) + return goto_battle_events(); + game.state = 'militia_in_battle'; + } else { + goto_battle_events(); + } +} + +states.militia_in_battle = { + prompt() { + view.prompt = "Determine which Militia units will participate."; + let box = department_militia(game.battle.where); + view.where = game.battle.where; + for (let p = first_friendly_unit; p <= last_friendly_unit; ++p) + if (piece_node(p) === box) + gen_action_piece(p); + gen_action_next(); + }, + piece(p) { + push_undo(); + log(`Deploys militia in ${space_name(game.battle.where)}.`); + move_piece_to(p, game.battle.where); + }, + next() { + clear_undo(); + goto_battle_events(); + }, +} + +function goto_battle_events() { + set_active(game.battle.attacker); + // TODO: attacker then defender play events + // TODO: attacker MAY participate besieged units if breaking the siege + goto_battle_roll(); +} + +function goto_battle_roll() { + // TODO: modifiers + let atk_str = attacker_combat_strength(); + let atk_mod = 0; + game.battle.atk_roll = roll_d6(); + game.battle.atk_result = combat_result(atk_str, game.battle.atk_roll + atk_mod); + log("ATTACKER", "str="+atk_str, "roll="+game.battle.atk_roll, "+", atk_mod, "=", game.battle.atk_result); + + // TODO: modifiers + let def_str = defender_combat_strength(); + let def_mod = 0; + game.battle.def_roll = roll_d6(); + game.battle.def_result = combat_result(def_str, game.battle.def_roll + def_mod); + log("DEFENDER", "str="+def_str, "roll="+game.battle.def_roll, "+", def_mod, "=", game.battle.def_result); + + // Next state sequence: + // atk step losses + // atk leader checks + // def step losses + // def leader checks + // determine winner + + goto_atk_step_losses(); +} + +function end_step_losses() { + if (game.active === game.battle.attacker) + goto_atk_leader_check(); + else + goto_def_leader_check(); +} + +function end_leader_check() { + delete game.battle.leader_check; + if (game.active === game.battle.attacker) + goto_def_step_losses(); + else + goto_determine_winner(); +} + +// STEP LOSSES + +function goto_atk_step_losses() { + set_active(game.battle.attacker); + if (game.battle.def_result > 0) { + game.state = 'step_losses'; + game.battle.step_loss = game.battle.def_result; + if (game.battle.assault) + game.battle.dt_loss = game.battle.step_loss; + else + game.battle.dt_loss = Math.ceil(game.battle.step_loss / 2); + game.battle.units = []; + for_each_attacking_piece(p => { + if (is_unit(p)) + game.battle.units.push(p); + }); + } else { + end_step_losses(); + } +} + +function goto_def_step_losses() { + set_active(game.battle.defender); + if (game.battle.atk_result > 0) { + game.state = 'step_losses'; + game.battle.step_loss = game.battle.atk_result; + if (game.battle.assault) + game.battle.dt_loss = game.battle.step_loss; + else + game.battle.dt_loss = Math.ceil(game.battle.step_loss / 2); + game.battle.units = []; + for_each_defending_piece(p => { + if (is_unit(p)) + game.battle.units.push(p); + }); + } else { + end_step_losses(); + } +} + +states.step_losses = { + prompt() { + view.prompt = `Apply step losses (${game.battle.step_loss} total, ${game.battle.dt_loss} from drilled troops).`; + let can_reduce = false; + if (game.battle.step_loss > 0) { + if (game.battle.dt_loss > 0) { + for (let i = 0; i < game.battle.units.length; ++i) { + let p = game.battle.units[i]; + if (is_drilled_troops(p) && !is_unit_reduced(p)) { + can_reduce = true; + gen_action_piece(p); + } + } + if (!can_reduce) { + for (let i = 0; i < game.battle.units.length; ++i) { + let p = game.battle.units[i]; + if (is_drilled_troops(p)) { + can_reduce = true; + gen_action_piece(p); + } + } + } + } + if (!can_reduce) { + for (let i = 0; i < game.battle.units.length; ++i) { + let p = game.battle.units[i]; + if (!is_unit_reduced(p)) { + can_reduce = true; + gen_action_piece(p); + } + } + } + if (!can_reduce) { + for (let i = 0; i < game.battle.units.length; ++i) { + let p = game.battle.units[i]; + can_reduce = true; + gen_action_piece(p); + } + } + } + if (!can_reduce) + gen_action_next(); + }, + piece(p) { + push_undo(); + --game.battle.step_loss; + if (game.battle.dt_loss > 0 && is_drilled_troops(p)) + --game.battle.dt_loss; + if (reduce_unit(p)) + remove_from_array(game.battle.units, p); + }, + next() { + clear_undo(); + end_step_losses(); + }, +} + +function goto_raid_step_losses() { + if (game.raid.step_loss > 0) { + game.state = 'raid_step_losses'; + game.raid.units = []; + for_each_friendly_unit_in_space(game.raid.where, p => { + game.raid.units.push(p); + }); + } else { + goto_raid_leader_check(); + } +} + +states.raid_step_losses = { + prompt() { + view.prompt = `Apply step losses (${game.raid.step_loss}).`; + let can_reduce = false; + if (game.raid.step_loss > 0) { + for (let i = 0; i < game.raid.units.length; ++i) { + let p = game.raid.units[i]; + if (!is_unit_reduced(p)) { + can_reduce = true; + gen_action_piece(p); + } + } + if (!can_reduce) { + for (let i = 0; i < game.raid.units.length; ++i) { + let p = game.raid.units[i]; + can_reduce = true; + gen_action_piece(p); + } + } + } + if (!can_reduce) + gen_action_next(); + }, + piece(p) { + push_undo(); + --game.raid.step_loss; + if (reduce_unit(p)) + remove_from_array(game.raid.units, p); + }, + next() { + clear_undo(); + goto_raid_leader_check(); + }, +} + +// LEADER LOSSES + +function goto_atk_leader_check() { + set_active(game.battle.attacker); + game.battle.leader_check = []; + if ((game.battle.def_result > 0) && (game.battle.def_roll === 1 || game.battle.def_roll === 6)) { + log(`${game.battle.attacker} leader loss check`); + for_each_attacking_piece(p => { + if (is_leader(p)) + game.battle.leader_check.push(p); + }); + } + if (game.battle.leader_check.length > 0) + game.state = 'leader_check'; + else + end_leader_check(); +} + +function goto_def_leader_check() { + set_active(game.battle.defender); + game.battle.leader_check = []; + if ((game.battle.atk_result > 0) && (game.battle.atk_roll === 1 || game.battle.atk_roll === 6)) { + log(`${game.battle.defender} leader loss check`); + for_each_defending_piece(p => { + if (is_leader(p)) + game.battle.leader_check.push(p); + }); + } + if (game.battle.leader_check.length > 0) + game.state = 'leader_check'; + else + end_leader_check(); +} + +states.leader_check = { + prompt() { + view.prompt = "Roll for leader losses."; + for (let i = 0; i < game.battle.leader_check.length; ++i) + gen_action_piece(game.battle.leader_check[i]); + if (game.battle.leader_check.length === 0) + gen_action_next(); + }, + piece(piece) { + let die = roll_d6(); + if (die === 1) { + log(`${piece_name(piece)} rolls ${die} and is killed`); + eliminate_piece(piece); + } else { + log(`${piece_name(piece)} rolls ${die} and survives`); + } + remove_from_array(game.battle.leader_check, piece); + }, + next() { + end_leader_check(); + }, +} + +function goto_raid_leader_check() { + if (game.raid.leader_check) { + game.raid.leader_check = []; + log(`${game.active} leader loss check`); + for_each_friendly_leader_in_space(game.raid.where, p => { + game.raid.leader_check.push(p); + }); + if (game.raid.leader_check.length > 0) { + game.state = 'leader_check'; + } else { + game.raid.leader_check = 0; + raiders_go_home(); + } + } else { + raiders_go_home(); + } +} + +states.raid_leader_check = { + prompt() { + view.prompt = "Roll for leader losses."; + for (let i = 0; i < game.raid.leader_check.length; ++i) + gen_action_piece(game.raid.leader_check[i]); + if (game.raid.leader_check.length === 0) + gen_action_next(); + }, + piece(piece) { + let die = roll_d6(); + if (die === 1) { + log(`${piece_name(piece)} rolls ${die} and is killed`); + eliminate_piece(piece); + } else { + log(`${piece_name(piece)} rolls ${die} and survives`); + } + remove_from_array(game.raid.leader_check, piece); + }, + next() { + delete game.raid.leader_check; + raiders_go_home(); + }, +} + +// WINNER/LOSER + +function return_militia(where) { + let box = department_militia(where); + console.log("RETURN MILITIA", space_name(where), space_name(box)); + if (box) { + let n = 0; + for (let p = 1; p < pieces.length; ++p) { + if (is_militia_unit(p) && is_piece_in_space(p, where)) { + move_piece_to(p, box); + ++n; + } + } + if (n > 0) { + log(`${n} Militia units return to their box.`); + } + } +} + +function goto_determine_winner() { + set_active(game.battle.attacker); + if (game.battle.assault) + determine_winner_assault(); + else + determine_winner_battle(); +} + +function determine_winner_battle() { + let where = game.battle.where; + + // 7.8: Determine winner + let atk_surv = count_friendly_units_in_space(where); + let def_surv = count_unbesieged_enemy_units_in_space(where); + let victor; + if (atk_surv === 0 && def_surv === 0) + victor = game.battle.defender; + else if (def_surv === 0) + victor = game.battle.attacker; + else if (atk_surv === 0) + victor = game.battle.defender; + else if (game.battle.atk_result > game.battle.def_result) + victor = game.battle.attacker; + else + victor = game.battle.defender; + + // TODO: 7.64 leaders retreat if all units lost + + // TODO: 7.8: Award vp + + return_militia(game.battle.where); + + // Raid battle vs militia + if (game.raid && game.raid.where > 0) { + if (victor === game.battle.attacker) { + log("ATTACKER WON RAID BATTLE VS MILITIA"); + resolve_raid(); + } else { + log("DEFENDER WON RAID BATTLE VS MILITIA"); + retreat_attacker(game.raid.where, game.raid.from[game.raid.where] | 0); + goto_pick_raid(); + } + return; + } + + // TODO: Breakout + + // Normal battle + if (victor === game.battle.attacker) { + log("ATTACKER WON"); + if (has_unbesieged_enemy_units(where)) { + goto_retreat_defender(); + } else { + if (def_surv === 0 && game.battle.def_result === 0) { + console.log("POSSIBLE OVERRUN"); + end_move_step(false); + } else { + end_move_step(true); + } + } + } else { + log("DEFENDER WON"); + let from = game.battle.where; + let to = moving_piece_came_from(game.battle.where); + retreat_attacker(from, to); + + // if raiders need to retreat again, they go back to this + // space, unless they retreat to join other raiders + if (!game.raid.from[to]) + game.raid.from[to] = from; + + end_retreat(); + } +} + +function eliminate_enemy_pieces_inside(where) { + for (let p = first_enemy_piece; p <= last_enemy_piece; ++p) + if (is_piece_in_space(where) && is_piece_inside(p)) + eliminate_piece(p); +} + +function determine_winner_assault() { + let where = game.battle.where; + let victor; + + if (game.battle.atk_result > game.battle.def_result) + victor = game.battle.attacker; + else + victor = game.battle.defender; + + if (victor === game.battle.attacker) { + log("ATTACKER WON ASSAULT"); + eliminate_enemy_pieces_inside(where); + remove_siege_marker(where); + if (has_enemy_fortress(where)) { + capture_enemy_fortress(where); + } + if (has_enemy_fort(where)) { + capture_enemy_fort(where); + } + } else { + log("DEFENDER WON ASSAULT"); + } + + end_activation(); +} + +// RETREAT + +function can_attacker_retreat_from_to(p, from, to) { + console.log("RETREAT QUERY (ATTACK)", piece_name(p), space_name(from), space_name(to)); + if (to === 0) + return false; + if (has_unbesieged_enemy_units(to)) + return false; + if (has_unbesieged_enemy_fortifications(to)) + return false; + if (force_has_drilled_troops(p)) { + if (is_cultivated(to) || has_friendly_fortifications(to)) + return true; + else + return false; + } + return true; +} + +function retreat_attacker(from, to) { + set_active(game.battle.attacker); + + // TODO: manual user to click on retreat location + + console.log("RETREAT ATTACKER", space_name(from), "to", space_name(to)); + + // NOTE: Besieged pieces assaulting out are already inside so not affected by the code below. + // NOTE: We unstack forces here by retreating individual units before leaders! + for_each_friendly_unit_in_space(from, p => { + if (!is_piece_inside(p)) { + if (can_attacker_retreat_from_to(p, from, to)) + move_piece_to(p, to); + else + eliminate_piece(p); + } + }); + for_each_friendly_leader_in_space(from, p => { + if (!is_piece_inside(p)) { + if (can_attacker_retreat_from_to(p, from, to)) + move_piece_to(p, to); + else + eliminate_piece(p); + } + }); + + // TODO: lift siege if attack on enemy fort repulsed +} + +function goto_retreat_defender() { + set_active(game.battle.defender); + let from = battle_space(); + let commander = find_friendly_commanding_leader_in_space(from); + if (commander && has_friendly_units(from)) { + game.force = { + leader: commander, + selected: commander, + reason: 'retreat_defender', + }; + game.state = 'define_force'; + } else { + game.state = 'retreat_defender'; + } +} + +function can_defender_retreat_from_to(p, from, to) { + console.log("RETREAT QUERY", piece_name(p), space_name(from), space_name(to)); + if (has_unbesieged_enemy_units(to)) + return false; + if (has_unbesieged_enemy_fortifications(to)) + return false; + if (moving_piece_came_from(to) === battle_space()) + return false; + if (force_has_drilled_troops(p)) { + if (is_cultivated(to) || has_friendly_fortifications(to)) + return true; + else + return false; + } + return true; +} + +function can_defender_retreat_inside(p, from) { + if (has_friendly_fort_or_fortress(from)) { + let n = count_friendly_units_inside(from); + let m = count_units_in_force(p); + if (is_leader(p) || is_fortress(from) || (n + m) <= 4) + return true; + } + return false; +} + +function can_defender_retreat_from(p, from) { + if (is_piece_inside(p)) + return false; + if (can_defender_retreat_inside(p, from)) + return true; + // TODO: retreat from amphib to british controlled port + let can_retreat = false; + for_each_exit(from, to => { + if (can_defender_retreat_from_to(p, from, to)) + can_retreat = true; + }); + return can_retreat; +} + +states.retreat_defender = { + prompt() { + let from = battle_space(); + view.prompt = "Retreat losing leaders and units \u2014"; + view.where = from; + let can_retreat = false; + for_each_friendly_piece_in_node(from, p => { + if (can_defender_retreat_from(p, from)) { + console.log(piece_name(p) + " CAN RETREAT"); + can_retreat = true; + gen_action_piece(p); + } + else + console.log(piece_name(p) + " CANNOT RETREAT"); + }); + if (!can_retreat) { + view.prompt += " done."; + gen_action_next(); + } else { + view.prompt += " select piece to retreat."; + } + }, + piece(piece) { + push_undo(); + game.battle.who = piece; + game.state = 'retreat_defender_to'; + }, + next() { + clear_undo(); + // TODO: eliminate non-retreated units + let from = battle_space(); + for_each_friendly_piece_in_space(from, p => { + if (!is_piece_inside(p)) + eliminate_piece(p); + }); + end_retreat(); + }, +} + +states.retreat_defender_to = { + prompt() { + let from = battle_space(); + let who = game.battle.who; + view.prompt = "Retreat losing leaders and units \u2014 select destination."; + view.who = who; + // TODO: retreat from amphib to british controlled port + if (can_defender_retreat_inside(who, from)) + gen_action_space(from); + for_each_exit(from, to => { + if (can_defender_retreat_from_to(who, from, to)) { + gen_action_space(to); + } + }); + }, + space(to) { + let from = battle_space(); + let who = game.battle.who; + if (from === to) { + log("retreats inside fortification"); + set_force_inside(who); + } else { + log("retreats to " + space_name(to)); + move_piece_to(who, to); + } + game.state = 'retreat_defender'; + }, +} + +function end_retreat() { + set_active(game.battle.attacker); + end_move_step(true); +} + +// SIEGE + +const SIEGE_TABLE = [ 0, 0, 0, 1, 1, 1, 2, 2 ]; + +function goto_resolve_siege(space) { + // TODO: Coehorns + clear_undo(); + log("Resolve siege in " + space_name(space)); + let att_leader = find_friendly_commanding_leader_in_space(space); + let def_leader = find_enemy_commanding_leader_in_space(space); + let die = roll_d6(); + let msg = `Roll ${die}`; + let drm_att_ld = leader_tactics(att_leader); + let drm = drm_att_ld; + msg += `\n+${drm_att_ld} besieger's leader`; + if (def_leader) { + let drm_def_ld = leader_tactics(def_leader); + drm += drm_def_ld; + msg += `\n-${drm_def_ld} defender's leader`; + } + if (space == LOUISBOURG) { + msg += `\n-1 for Louisbourg`; + drm -= 1; + } + let result = SIEGE_TABLE[clamp(die + drm, 0, 7)]; + msg += `\n= ${result}`; + log(msg); + if (result > 0) { + let level = change_siege_marker(space, result); + log("Siege level is " + level); + } + goto_assault_possible(space); +} + +function is_assault_possible(space) { + let siege_level = game.sieges[space] | 0; + if (has_enemy_fort(space) && siege_level >= 1) + return true; + if (has_enemy_fortress(space) && siege_level >= 2) + return true; + return false; +} + +function goto_assault_possible(space) { + if (is_assault_possible(space)) { + game.state = 'assault_possible'; + game.assault_possible = space; + } else { + end_activation(); + } +} + +states.assault_possible = { + prompt() { + view.prompt = "Assault is possible."; + gen_action_space(game.assault_possible); + gen_action('assault'); + gen_action('pass'); + }, + space() { + let where = game.assault_possible; + delete game.assault_possible; + goto_assault(where); + }, + assault() { + let where = game.assault_possible; + delete game.assault_possible; + goto_assault(where); + }, + pass() { + log("does not assault " + space_name(where)); + end_activation(); + }, +} + +function goto_assault(where) { + log("Assault " + space_name(where)); + goto_battle(where, true, false); +} + +// RAID + +function goto_pick_raid() { + clear_undo(); + if (game.raid.list.length > 0) { + game.state = 'pick_raid'; + } else { + delete game.raid; + end_activation(); + } +} + +states.pick_raid = { + prompt() { + view.prompt = "Pick next raid space."; + for (let i=0; i < game.raid.list.length; ++i) + gen_action_space(game.raid.list[i]); + }, + space(s) { + log("raids " + space_name(s)) + game.raid.where = s; + remove_from_array(game.raid.list, s); + goto_raid_militia(); + }, +} + +function goto_raid_militia() { + let where = game.raid.where; + if (enemy_department_has_at_least_n_militia(where, 1)) { + console.log("MILITIA AGAINST RAID", space_name(where), space_name(game.raid.battle)); + if (where === game.raid.battle && has_enemy_stockade(where)) { + console.log("BATTLED AGAINST STOCKADE, NO MILITIA ALLOWED", space_name(game.raid.battle)); + resolve_raid(); + } else { + set_active(enemy()); + game.state = 'militia_against_raid'; + game.count = 1; + } + } else { + resolve_raid(); + } +} + +states.militia_against_raid = { + prompt() { + view.prompt = `You may deploy one Militia unit against the raid in ${space_name(game.raid.where)}.`; + view.where = game.raid.where; + if (game.count > 0) { + let box = department_militia(game.raid.where); + for (let p = first_friendly_unit; p <= last_friendly_unit; ++p) + if (piece_node(p) === box) + gen_action_piece(p); + } + gen_action_next(); + }, + piece(p) { + push_undo(); + log(`Deploys militia in ${space_name(game.raid.where)}.`); + move_piece_to(p, game.raid.where); + game.count --; + }, + next() { + clear_undo(); + set_active(enemy()); + if (game.count === 0) + goto_battle(game.raid.where, false, false); + else + resolve_raid(); + }, +} + +const RAID_TABLE = { + stockade: [ 2, 1, 1, 0, 2, 1, 0, 0 ], + cultivated: [ 2, 0, 0, 0, 1, 1, 0, 0 ], +}; + +function resolve_raid() { + let where = game.raid.where; + let x_stockade = has_enemy_stockade(where); + let x_allied = has_enemy_allied_settlement(where); + + let column = 'cultivated'; + if (x_stockade || x_allied || (game.events.blockhouses === game.active)) + column = 'stockade'; + + let d = roll_d6(); + let drm = 0; + let mods = []; + + let commander = find_friendly_commanding_leader_in_space(where); + if (commander) { + console.log(`${piece_name(commander)} leads the raid`); + let t = leader_tactics(commander); + drm += t; + mods.push(` +${t} tactics rating`); + } + + if (has_friendly_rangers(where)) { + drm += 1; + mods.push(" +1 for rangers"); + } + + if (enemy_department_has_at_least_n_militia(where, 2)) { + drm -= 1; + mods.push(" -1 for militia in department"); + } + + log(`Raid ${space_name(where)} roll ${d}${mods.join(",")} = ${d+drm} on column vs. ${column}.`); + let result = clamp(d + drm, 0, 7); + let success = result >= 5; + let losses = RAID_TABLE[column][result]; + + if (success) { + log(`Result: Success with ${losses} losses.`); + if (x_stockade || x_allied || !has_friendly_raided_marker(where)) + place_friendly_raided_marker(where); + if (x_stockade) + eliminate_enemy_stockade_in_raid(where); + if (x_allied) + eliminate_indian_tribe(indian_tribe[where]); + } else { + log(`Result: Failure with ${losses} losses.`); + } + + game.raid.step_loss = losses; + + // 10.32: leader check + if (d === 1 || (d === 6 && column === 'vs_stockade')) + game.raid.leader_check = 1; + else + game.raid.leader_check = 0; + + // Next states: + // raider step losses + // raider leader check + // raiders go home + + goto_raid_step_losses(); +} + +function next_raider_in_space(from) { + for (let p = first_friendly_piece; p <= last_friendly_piece; ++p) { + if (is_piece_in_space(p, from)) { + isolate_piece_from_force(p); + return p; + } + } + return 0; +} + +function raiders_go_home() { + // RULE: raiders go home -- can go to separate locations if many available? + // Leaders, coureurs and rangers go to nearest fortification + // Indians may follow leader + // Indians go to home settlement + + let from = game.raid.where; + let x_leader = find_friendly_commanding_leader_in_space(from); + let x_rangers = has_friendly_rangers(from); + let x_coureurs = has_friendly_coureurs(from); + + game.go_home = { + who: next_raider_in_space(from), + }; + + if (x_leader || x_rangers || x_coureurs) { + game.go_home.closest = find_closest_friendly_unbesieged_fortification(from); + if (x_leader) + game.go_home.leader = []; + } + + game.state = 'raiders_go_home'; +} + +states.raiders_go_home = { + prompt() { + let who = game.go_home.who; + + if (who) + view.prompt = "Raiders go home \u2014 " + piece_name(who) + "."; + else + view.prompt = "Raiders go home \u2014 done."; + view.who = who; + + if (!who) { + gen_action('next'); + } else if (is_indian_unit(who)) { + // 10.412: Cherokee have no home settlement (home=0) + let home = indian_home_settlement(who); + if (home && has_friendly_allied_settlement(home) && !has_enemy_units(home)) + gen_action_space(home); + else + gen_action('eliminate'); + + // 10.422: Indians stacked with a leader may accompany him + if (game.go_home.leader) + for (let i=0; i < game.go_home.leader.length; ++i) + gen_action_space(game.go_home.leader[i]); + } else { + for (let i=0; i < game.go_home.closest.length; ++i) + gen_action_space(game.go_home.closest[i]); + } + }, + space(s) { + push_undo(); + let who = game.go_home.who; + move_piece_to(who, s); + if (is_leader(who) && !game.go_home.leader.includes(s)) + game.go_home.leader.push(s); + game.go_home.who = next_raider_in_space(game.raid.where); + }, + eliminate() { + push_undo(); + eliminate_piece(game.go_home.who); + game.go_home.who = next_raider_in_space(game.raid.where); + }, + next() { + delete game.go_home; + goto_pick_raid(); + } +} + +// CONSTRUCTION + +function format_remain(n) { + if (n === 0) + return "done"; + return n + " left"; +} + +function goto_construct_stockades(card) { + push_undo(); + discard_card(card, " to construct stockades"); + player.did_construct = 1; + game.state = 'construct_stockades'; + game.count = cards[card].activation; +} + +states.construct_stockades = { + prompt() { + view.prompt = `Construct stockades \u2014 ${format_remain(game.count)}.`; + gen_action_next(); + if (game.count > 0) { + for (let space = first_space; space <= last_space; ++space) { + if (has_friendly_supplied_drilled_troops(space) || is_originally_friendly(space)) { + if (has_enemy_units(space)) + continue; + if (has_enemy_fortifications(space)) + continue; + if (has_friendly_fortifications(space)) + continue; + if (is_space_besieged(space)) + continue; + if (is_fortress(space)) + continue; + gen_action_space(space); + } + } + } + }, + space(space) { + push_undo(); + log(`build a stockade in ${space_name(space)}.`); + player.stockades.push(space); + game.count --; + }, + next() { + end_action_phase(); + }, +} + +function goto_construct_forts(card) { + push_undo(); + discard_card(card, " to construct forts"); + player.did_construct = 1; + game.state = 'construct_forts'; + game.count = cards[card].activation; + game.list = []; +} + +states.construct_forts = { + prompt() { + view.prompt = `Construct forts \u2014 ${format_remain(game.count)}.`; + gen_action_next(); + if (game.count > 0) { + for (let space = first_space; space <= last_space; ++space) { + if (has_friendly_supplied_drilled_troops(space)) { + if (game.list.includes(space)) + continue; + if (has_friendly_fort(space)) + continue; + if (is_space_besieged(space)) + continue; + if (is_fortress(space)) + continue; + gen_action_space(space); + } + } + } + }, + space(space) { + push_undo(); + if (has_friendly_fort_uc(space)) { + log(`finish building a fort in ${space_name(space)}.`); + place_friendly_fort(space); + } else { + log(`start building a fort in ${space_name(space)}.`); + place_friendly_fort_uc(space); + game.list.push(space); // don't finish it in the same action phase + } + game.count --; + }, + next() { + delete game.list; + end_action_phase(); + }, +} + +// EVENTS + +function find_unused_friendly_militia() { + for (let p = first_friendly_unit; p <= last_friendly_unit; ++p) + if (is_militia_unit(p) && is_unit_unused(p)) + return p; + return 0; +} + +events.call_out_militias = { + play() { + game.state = 'call_out_militias'; + game.count = 2; + } +} + +states.call_out_militias = { + prompt() { + view.prompt = `Place a Militia unit into a militia box, or restore 2 to full strength.`; + let can_place = false; + if (game.count === 2) { + if (game.active === BRITAIN) { + if (find_unused_friendly_militia()) { + can_place = true; + gen_action_space(SOUTHERN_COLONIAL_MILITIAS); + gen_action_space(NORTHERN_COLONIAL_MILITIAS); + } + } else { + if (find_unused_friendly_militia()) { + can_place = true; + gen_action_space(ST_LAWRENCE_CANADIAN_MILITIAS); + } + } + } + if (game.count > 0) { + for (let p = first_friendly_unit; p <= last_friendly_unit; ++p) { + if (is_militia_unit(p) && is_unit_reduced(p) && is_militia_box(piece_space(p))) { + can_place = true; + gen_action_piece(p); + } + } + } + if (game.count === 0 || !can_place) + gen_action_next(); + }, + space(s) { + push_undo(); + log(`Places militia in ${space_name(s)}.`); + let p = find_unused_friendly_militia(); + move_piece_to(p, s); + game.count -= 2; + }, + piece(p) { + push_undo(); + let s = piece_space(p); + log(`Restores militia in ${space_name(s)}.`); + set_unit_reduced(p, 0); + game.count -= 1; + }, + next() { + end_action_phase(); + }, +} + +function find_unused_rangers() { + for (let p = first_friendly_unit; p <= last_friendly_unit; ++p) + if (is_rangers_unit(p) && is_unit_unused(p)) + return p; + return 0; +} + +events.rangers = { + play() { + game.state = 'rangers'; + game.count = 2; + } +} + +states.rangers = { + prompt() { + view.prompt = `Place a Rangers unit at a fortification, or restore 2 to full strength.`; + let can_place = false; + if (game.count === 2) { + if (find_unused_rangers()) { + for (let s = first_space; s <= last_space; ++s) { + if (has_unbesieged_friendly_fortifications(s)) { + can_place = true; + gen_action_space(s); + } + + } + } + } + if (game.count > 0) { + for (let p = first_friendly_unit; p <= last_friendly_unit; ++p) { + if (is_rangers_unit(p) && is_unit_reduced(p) && is_piece_on_map(p)) { + if (is_piece_unbesieged(p)) { + can_place = true; + gen_action_piece(p); + } + } + } + } + if (game.count === 0 || !can_place) + gen_action_next(); + }, + space(s) { + push_undo(); + log(`Places rangers in ${space_name(s)}.`); + let p = find_unused_rangers(); + move_piece_to(p, s); + game.count -= 2; + }, + piece(p) { + push_undo(); + let s = piece_space(p); + log(`Restores rangers in ${space_name(s)}.`); + set_unit_reduced(p, 0); + game.count -= 1; + }, + next() { + end_action_phase(); + }, +} + +function find_unused_light_infantry() { + for (let p = first_friendly_unit; p <= last_friendly_unit; ++p) + if (is_light_infantry_unit(p) && is_unit_unused(p)) + return p; + return 0; +} + +function place_two_light_infantry(s) { + let p = find_unused_light_infantry(); + if (p) + move_piece_to(p, s); + p = find_unused_light_infantry(); + if (p) + move_piece_to(p, s); +} + +events.light_infantry = { + play() { + clear_undo(); // drawing leader from pool reveals information + game.state = 'light_infantry'; + game.leader = draw_leader_from_pool(); + game.count = 1; + if (game.leader) { + move_piece_to(game.leader, leader_box(game.leader)); + place_two_light_infantry(leader_box(game.leader)); + } + } +} + +states.light_infantry = { + prompt() { + if (game.leader) { + view.prompt = `Place 2 Light Infantry units and ${piece_name(game.leader)} at a fortress.`; + view.who = game.leader; + } else { + view.prompt = `Place 2 Light Infantry units at a fortress.`; + } + if (game.count > 0) { + for (let s = first_space; s <= last_space; ++s) { + if (has_unbesieged_friendly_fortress(s)) { + gen_action_space(s); + } + + } + } + if (game.count === 0) + gen_action_next(); + }, + space(s) { + push_undo(); + if (game.leader) { + log(`Places 2 Light Infantry and ${piece_name(game.leader)} in ${space_name(s)}.`); + move_piece_to(game.leader, s); + } else { + log(`Places 2 Light Infantry in ${space_name(s)}.`); + place_two_light_infantry(s); + } + game.count = 0; + }, + next() { + delete game.leader; + end_action_phase(); + }, +} + +// SETUP + +exports.scenarios = [ + "Annus Mirabilis", + "Early War Campaign", + "Late War Campaign", + "The Full Campaign", +]; + +exports.roles = [ + FRANCE, + BRITAIN, +]; + +exports.ready = function (scenario, options, players) { + return players.length === 2; +} + +function setup_markers(m, list) { + list.forEach(name => m.push(find_space(name))); +} + +function setup_leader(where, who) { + game.pieces.location[find_leader(who)] = find_space(where); +} + +function setup_unit(where, who) { + game.pieces.location[find_unused_unit(who)] = find_space(where); +} + +function setup_1757(end_year) { + game.tracks.year = 1757; + game.tracks.end_year = end_year; + game.tracks.season = EARLY; + game.tracks.vp = 4; + game.tracks.pa = SUPPORTIVE; + + // TODO: optional rule start at 2VP for balance + // see https://boardgamegeek.com/thread/1366550/article/19163465#19163465 + + for (let i = 1; i <= 62; ++i) + game.cards.draw_pile.push(i); + for (let i = 63; i <= 70; ++i) + game.cards.removed.push(i); + + setup_markers(game.France.allied, [ + "Mingo Town", + "Logstown", + "Pays d'en Haut", + "Mississauga", + ]); + + setup_markers(game.France.forts, [ + "Ticonderoga", + "Crown Point", + "Niagara", + "Ohio Forks", + ]); + + setup_markers(game.France.stockades, [ + "Île-aux-Noix", + "St-Jean", + "Oswegatchie", + "Cataraqui", + "Toronto", + "Presqu'île", + "French Creek", + "Venango", + ]); + + setup_leader("Louisbourg", "Drucour"); + setup_unit("Louisbourg", "Marine"); + setup_unit("Louisbourg", "Artois"); + setup_unit("Louisbourg", "Bourgogne"); + setup_unit("Louisbourg", "Boishébert Acadian"); + + setup_leader("Québec", "Lévis"); + setup_unit("Québec", "Marine"); + setup_unit("Québec", "Guyenne"); + setup_unit("Québec", "La Reine"); + + setup_leader("Montréal", "Montcalm"); + setup_leader("Montréal", "Vaudreuil"); + setup_unit("Montréal", "Béarn"); + setup_unit("Montréal", "La Sarre"); + setup_unit("Montréal", "Repentigny"); + setup_unit("Montréal", "Huron"); + setup_unit("Montréal", "Potawatomi"); + setup_unit("Montréal", "Ojibwa"); + setup_unit("Montréal", "Mississauga"); + + setup_unit("Crown Point", "Marine Detachment"); + setup_unit("Crown Point", "Perière"); + + setup_leader("Ticonderoga", "Rigaud"); + setup_leader("Ticonderoga", "Bougainville"); + setup_unit("Ticonderoga", "Languedoc"); + setup_unit("Ticonderoga", "Royal Roussillon"); + setup_unit("Ticonderoga", "Marin"); + + setup_leader("Cataraqui", "Villiers"); + setup_unit("Cataraqui", "Marine Detachment"); + setup_unit("Cataraqui", "Léry"); + + setup_unit("Niagara", "Marine Detachment"); + setup_unit("Niagara", "Joncaire"); + + setup_unit("Presqu'île", "Marine Detachment"); + setup_unit("French Creek", "Marine Detachment"); + setup_unit("Venango", "Langlade"); + + setup_leader("Ohio Forks", "Dumas"); + setup_unit("Ohio Forks", "Marine Detachment"); + setup_unit("Ohio Forks", "Marine Detachment"); + setup_unit("Ohio Forks", "Ligneris"); + + setup_unit("Logstown", "Shawnee"); + setup_unit("Mingo Town", "Mingo"); + + setup_leader("offmap", "Dieskau"); + setup_leader("offmap", "Beaujeu"); + + setup_markers(game.Britain.forts, [ + "Hudson Carry South", + "Hudson Carry North", + "Will's Creek", + "Shamokin", + ]); + + setup_markers(game.Britain.forts_uc, [ + "Winchester", + "Shepherd's Ferry", + ]); + + setup_markers(game.Britain.stockades, [ + "Schenectady", + "Hoosic", + "Charlestown", + "Augusta", + "Woodstock", + "Carlisle", + "Harris's Ferry", + "Lancaster", + "Reading", + "Easton", + ]); + + setup_unit("Winchester", "Virginia"); + setup_unit("Shepherd's Ferry", "Maryland"); + setup_unit("Carlisle", "Pennsylvania"); + setup_unit("Shamokin", "Pennsylvania"); + setup_unit("Philadelphia", "1/60th"); + + setup_leader("New York", "Loudoun"); + setup_leader("New York", "Abercromby"); + setup_unit("New York", "22nd"); + setup_unit("New York", "27th"); + setup_unit("New York", "35th"); + setup_unit("New York", "2/60th"); + setup_unit("New York", "3/60th"); + setup_unit("New York", "4/60th"); + + setup_leader("Albany", "Dunbar"); + setup_unit("Albany", "44th"); + setup_unit("Albany", "48th"); + + setup_leader("Hudson Carry South", "Webb"); + setup_unit("Hudson Carry South", "Rogers"); + setup_unit("Hudson Carry South", "Massachusetts"); + setup_unit("Hudson Carry South", "Connecticut"); + setup_unit("Hudson Carry South", "Rhode Island"); + + setup_unit("Hudson Carry North", "New Hampshire"); + setup_unit("Hudson Carry North", "New Jersey"); + + setup_leader("Schenectady", "Johnson"); + setup_unit("Schenectady", "New York"); + setup_unit("Schenectady", "1/42nd"); + + setup_leader("Halifax", "Monckton"); + setup_unit("Halifax", "40th"); + setup_unit("Halifax", "45th"); + setup_unit("Halifax", "47th"); + + setup_unit("Southern Colonial Militias", "Colonial Militia"); + + game.pieces.pool.push(find_leader("Amherst")); + game.pieces.pool.push(find_leader("Bradstreet")); + game.pieces.pool.push(find_leader("Forbes")); + game.pieces.pool.push(find_leader("Murray")); + game.pieces.pool.push(find_leader("Wolfe")); + + setup_leader("offmap", "Braddock"); + setup_leader("offmap", "Shirley"); + + game.events.pitt = 1; + + game.France.hand_size = 9; + game.Britain.hand_size = 9; + + start_year(); + + return game; +} + +function setup_1755() { + game.tracks.year = 1755; + game.tracks.season = EARLY; + game.tracks.vp = 0; + game.tracks.pa = SUPPORTIVE; + + for (let i = 1; i <= 70; ++i) + game.cards.draw_pile.push(i); + + setup_markers(game.France.allied, [ + "Pays d'en Haut", + "Kahnawake", + "St-François", + ]); + setup_markers(game.Britain.allied, [ + "Canajoharie", + ]); + + setup_markers(game.France.forts, [ + "Crown Point", + "Niagara", + "Ohio Forks", + ]); + setup_markers(game.France.stockades, [ + "Île-aux-Noix", + "St-Jean", + "Oswegatchie", + "Cataraqui", + "Toronto", + "Presqu'île", + "French Creek", + "Venango", + ]); + + setup_leader("Louisbourg", "Drucour"); + setup_unit("Louisbourg", "Marine"); + setup_unit("Louisbourg", "Artois"); + setup_unit("Louisbourg", "Bourgogne"); + + setup_leader("Québec", "Dieskau"); + setup_leader("Québec", "Vaudreuil"); + setup_unit("Québec", "Béarn"); + setup_unit("Québec", "Guyenne"); + setup_unit("Québec", "La Reine"); + setup_unit("Québec", "Languedoc"); + + setup_leader("Montréal", "Rigaud"); + setup_unit("Montréal", "Marine"); + setup_unit("Montréal", "Repentigny"); + setup_unit("Montréal", "Perière"); + setup_unit("Montréal", "Caughnawaga"); + setup_unit("Montréal", "Abenaki"); + + setup_unit("Île-aux-Noix", "Marine Detachment"); + + setup_unit("Crown Point", "Marine Detachment"); + setup_unit("Crown Point", "Marin"); + + setup_leader("Cataraqui", "Villiers"); + setup_unit("Cataraqui", "Marine Detachment"); + setup_unit("Cataraqui", "Léry"); + + setup_unit("Niagara", "Marine Detachment"); + setup_unit("Niagara", "Joncaire"); + + setup_unit("Presqu'île", "Marine Detachment"); + + setup_unit("French Creek", "Marine Detachment"); + + setup_unit("Venango", "Langlade"); + + setup_leader("Ohio Forks", "Beaujeu"); + setup_leader("Ohio Forks", "Dumas"); + setup_unit("Ohio Forks", "Marine Detachment"); + setup_unit("Ohio Forks", "Ligneris"); + setup_unit("Ohio Forks", "Ottawa"); + setup_unit("Ohio Forks", "Potawatomi"); + + setup_markers(game.Britain.forts, [ + "Hudson Carry South", + "Will's Creek", + "Oswego", + ]); + setup_markers(game.Britain.stockades, [ + "Oneida Carry West", + "Oneida Carry East", + "Schenectady", + "Hoosic", + "Charlestown", + ]); + + setup_unit("Oswego", "New York"); + + setup_leader("Albany", "Shirley"); + setup_leader("Albany", "Johnson"); + setup_unit("Albany", "Rhode Island"); + setup_unit("Albany", "Connecticut"); + setup_unit("Albany", "New Hampshire"); + setup_unit("Albany", "Massachusetts"); + setup_unit("Albany", "Massachusetts"); + setup_unit("Albany", "Mohawk"); + setup_unit("Albany", "Mohawk"); + + setup_leader("Halifax", "Monckton"); + setup_unit("Halifax", "47th"); + + setup_leader("Alexandria", "Braddock"); + setup_leader("Alexandria", "Dunbar"); + setup_unit("Alexandria", "44th"); + setup_unit("Alexandria", "48th"); + + setup_unit("Will's Creek", "Virginia"); + setup_unit("Will's Creek", "Maryland"); + + game.pieces.pool.push(find_leader("Abercromby")); + game.pieces.pool.push(find_leader("Bradstreet")); + game.pieces.pool.push(find_leader("Loudoun")); + game.pieces.pool.push(find_leader("Murray")); + game.pieces.pool.push(find_leader("Webb")); + + setup_leader("offmap", "Amherst"); + setup_leader("offmap", "Forbes"); + setup_leader("offmap", "Wolfe"); + + game.France.hand_size = 8; + game.Britain.hand_size = 8; + + start_year(); + + return game; +} + +exports.setup = function (seed, scenario, options) { + load_game_state({ + seed: seed, + state: null, + active: FRANCE, + tracks: { + year: 1755, + end_year: 1762, + season: 0, + vp: 0, + pa: 0, + }, + events: {}, + cards: { + current: 0, + draw_pile: [], + discarded: [], + removed: [], + }, + pieces: { + location: pieces.map(x => 0), + reduced: [], + inside: [], + activated: [], + pool: [], + }, + sieges: {}, + France: { + hand: [], + hand_size: 0, + held: 0, + did_construct: 0, + allied: [], + stockades: [], + forts_uc: [], + forts: [], + raids: [], + }, + Britain: { + hand: [], + hand_size: 0, + held: 0, + did_construct: 0, + allied: [], + stockades: [], + forts_uc: [], + forts: [], + raids: [], + amphib: [], + }, + + undo: [], + log: [], + }); + + switch (scenario) { + default: + case "Annus Mirabilis": return setup_1757(1759); + case "Early War Campaign": return setup_1755(1759); + case "Late War Campaign": return setup_1757(1762); + case "The Full Campaign": return setup_1755(1762); + } +} + +// ACTION HANDLERS + +function clear_undo() { + game.undo = []; +} + +function push_undo() { + game.undo.push(JSON.stringify(game, (k,v) => { + if (k === 'undo') return undefined; + if (k === 'log') return v.length; + return v; + })); +} + +function pop_undo() { + let undo = game.undo; + let save_log = game.log; + Object.assign(game, JSON.parse(undo.pop())); + game.undo = undo; + save_log.length = game.log; + game.log = save_log; +} + +function gen_action_undo() { + if (!view.actions) + view.actions = {} + if (game.undo && game.undo.length > 0) + view.actions.undo = 1; + else + view.actions.undo = 0; +} + +function gen_action_x(action, enabled) { + if (!view.actions) + view.actions = {} + view.actions[action] = enabled ? 1 : 0; +} + +function gen_action(action, argument) { + if (!view.actions) + view.actions = {} + if (argument !== undefined) { + if (!(action in view.actions)) { + view.actions[action] = [ argument ]; + } else { + if (!view.actions[action].includes(argument)) + view.actions[action].push(argument); + } + } else { + view.actions[action] = 1; + } +} + +function gen_action_pass() { + gen_action('pass'); +} + +function gen_action_next() { + gen_action('next'); +} + +function gen_action_space(space) { + gen_action('space', space); +} + +function gen_action_piece(piece) { + gen_action('piece', piece); +} + +function load_game_state(state) { + game = state; + update_active_aliases(); +} + +exports.resign = function (state, current) { + load_game_state(state); + if (game.state !== 'game_over') { + log(""); + log(current + " resigned."); + game.active = current; + game.state = 'game_over'; + game.victory = current + " resigned."; + game.result = enemy(current); + game.active = 'None'; + } + return state; +} + +exports.action = function (state, current, action, arg) { + load_game_state(state); + let S = states[game.state]; + if (action in S) { + S[action](arg); + } else { + if (action === 'undo' && game.undo && game.undo.length > 0) + pop_undo(); + else + throw new Error("Invalid action: " + action); + } + return state; +} + +exports.view = function(state, current) { + load_game_state(state); + view = { + tracks: game.tracks, + events: game.events, + pieces: game.pieces, + sieges: game.sieges, + markers: { + France: { + allied: game.France.allied, + stockades: game.France.stockades, + forts_uc: game.France.forts_uc, + forts: game.France.forts, + raids: game.France.raids, + }, + Britain: { + allied: game.Britain.allied, + stockades: game.Britain.stockades, + forts_uc: game.Britain.forts_uc, + forts: game.Britain.forts, + raids: game.Britain.raids, + amphib: game.Britain.amphib, + }, + }, + cards: { + current: game.cards.current, + draw_pile: game.cards.draw_pile.length, + discarded: game.cards.discarded, + removed: game.cards.removed, + }, + active: game.active, + prompt: null, + actions: null, + log: game.log, + }; + + if (game.move) + view.move = game.move; + if (game.force) + view.force = game.force; + + if (current === FRANCE) + view.hand = game.France.hand; + else if (current === BRITAIN) + view.hand = game.Britain.hand; + else + view.hand = []; + + if (!states[game.state]) { + view.prompt = "Invalid game state: " + game.state; + return view; + } + + if (current === 'Observer' || game.active !== current) { + if (states[game.state].inactive) + states[game.state].inactive(); + else + view.prompt = `Waiting for ${game.active} \u2014 ${game.state.replace(/_/g, ' ')}...`; + } else { + states[game.state].prompt(); + gen_action_undo(); + view.prompt = game.active + ": " + view.prompt; + } + + return view; +} |