"use strict"

// TODO: campaign messed up who is who after battle
// TODO: retreat with 0 CU after battle

// TODO: bit flags for regulars, european_war, french alliance triggered

/* DATA */

const data = require("./data")

const CARDS = data.cards
const SPACES = data.spaces
const COLONIES = data.colony_spaces
const GENERALS = data.generals

const Canada = 0
const NH = 1
const NY = 2
const MA = 3
const CT = 4
const RI = 5
const PA = 6
const NJ = 7
const MD = 8
const DE = 9
const VA = 10
const NC = 11
const SC = 12
const GA = 13

const P_BRITAIN = "Britain"
const P_AMERICA = "America"

const PC_NONE = 0
const PC_BRITISH = 1
const PC_AMERICAN = 2

const CU_BRITISH_SHIFT = 2
const CU_AMERICAN_SHIFT = 8
const CU_FRENCH_SHIFT = 14
const CU_BRITISH_MASK = 63 << CU_BRITISH_SHIFT
const CU_AMERICAN_MASK = 63 << CU_AMERICAN_SHIFT
const CU_FRENCH_MASK = 7 << CU_FRENCH_SHIFT

const AMERICAN_GENERALS = [ 0, 1, 2, 3, 4, 5, 6, 7 ]
const BRITISH_GENERALS = [ 8, 9, 10, 11, 12 ]

const NOBODY = -1
const ARNOLD = data.general_index["Arnold"]
const BURGOYNE = data.general_index["Burgoyne"]
const CLINTON = data.general_index["Clinton"]
const CORNWALLIS = data.general_index["Cornwallis"]
const GATES = data.general_index["Gates"]
const GREENE = data.general_index["Greene"]
const LAFAYETTE = data.general_index["Lafayette"]
const LEE = data.general_index["Lee"]
const LINCOLN = data.general_index["Lincoln"]
const ROCHAMBEAU = data.general_index["Rochambeau"]
const WASHINGTON = data.general_index["Washington"]
const CARLETON = data.general_index["Carleton"]
const HOWE = data.general_index["Howe"]

const BOSTON = data.space_index["Boston"]
const CHARLESTON = data.space_index["Charleston"]
const FALMOUTH = data.space_index["Falmouth"]
const FORT_DETROIT = data.space_index["Fort Detroit"]
const GILBERT_TOWN = data.space_index["Gilbert Town"]
const LEXINGTON_CONCORD = data.space_index["Lexington Concord"]
const MONTREAL = data.space_index["Montreal"]
const NEWPORT = data.space_index["Newport"]
const NINETY_SIX = data.space_index["Ninety Six"]
const NORFOLK = data.space_index["Norfolk"]
const PHILADELPHIA = data.space_index["Philadelphia"]
const QUEBEC = data.space_index["Quebec"]
const WILMINGTON_NC = data.space_index["Wilmington NC"]

const CAPTURED_GENERALS = data.space_index["Captured Generals"]
const CONTINENTAL_CONGRESS_DISPERSED = data.space_index["Continental Congress Dispersed"]
const BRITISH_REINFORCEMENTS = data.space_index["British Leader Reinforcements"]
const AMERICAN_REINFORCEMENTS = data.space_index["American Leader Reinforcements"]
const FRENCH_REINFORCEMENTS = data.space_index["French Reinforcements"]
const NOWHERE = data.spaces.length

const THE_13_COLONIES = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 ]
const SOUTH_OF_WINTER_ATTRITION_LINE = [ 11, 12, 13 ]

const CAMPAIGN_CARDS = [ 67, 68, 69, 70 ]
const DECLARATION_OF_INDEPENDENCE = 99
const BARON_VON_STEUBEN = 86
const WAR_ENDS_1779 = 71
const BENJAMIN_FRANKLIN = 101

const general_count = data.generals.length
const space_count = 66
const all_spaces = new Array(space_count).fill(0).map((_,i)=>i)

const ENEMY = { [P_AMERICA]: P_BRITAIN, [P_BRITAIN]: P_AMERICA }

let states = {}
let events = {}

let game
let view

/* SETUP */

function setup_game(seed) {
	game = {
		seed: seed,
		log: [],
		undo: [],
		active: P_AMERICA,
		state: null,

		// tracks
		year: 1775,
		french_alliance_triggered: false,
		european_war: false,
		regulars: true,

		// played cards
		war_ends: 0,
		reinforcements: [0,0,0],

		// pieces and markers
		french_alliance: 0,
		congress: PHILADELPHIA,
		french_navy: -1,
		loc: new Array(general_count).fill(NOWHERE),
		spc: new Array(space_count + 2).fill(PC_NONE),

		// hands & card deck
		a_hand: [],
		b_hand: [],
		a_queue: 0,
		b_queue: 0,

		reshuffle: false,
		deck: null,
		removed: [],

		// transient state
		moved: [],
		mcu: [],
	}

	set_space_pc(QUEBEC, PC_BRITISH)
	set_space_pc(MONTREAL, PC_BRITISH)
	set_space_pc(FORT_DETROIT, PC_BRITISH)
	set_space_pc(BOSTON, PC_BRITISH)
	set_space_pc(NORFOLK, PC_BRITISH)
	set_space_pc(GILBERT_TOWN, PC_BRITISH)
	set_space_pc(WILMINGTON_NC, PC_BRITISH)
	set_space_pc(NINETY_SIX, PC_BRITISH)

	set_general_location(CARLETON, QUEBEC)
	set_general_location(HOWE, BOSTON)

	place_british_cu(QUEBEC, 2)
	place_british_cu(BOSTON, 5)
	place_british_cu(FORT_DETROIT, 1)

	set_space_pc(LEXINGTON_CONCORD, PC_AMERICAN)
	set_space_pc(CHARLESTON, PC_AMERICAN)
	set_space_pc(PHILADELPHIA, PC_AMERICAN)

	set_general_location(WASHINGTON, LEXINGTON_CONCORD)
	set_general_location(GREENE, NEWPORT)

	place_american_cu(LEXINGTON_CONCORD, 5)
	place_american_cu(NEWPORT, 2)
	place_american_cu(CHARLESTON, 2)

	set_general_location(BURGOYNE, BRITISH_REINFORCEMENTS)
	set_general_location(CLINTON, BRITISH_REINFORCEMENTS)
	set_general_location(CORNWALLIS, BRITISH_REINFORCEMENTS)

	set_general_location(ARNOLD, AMERICAN_REINFORCEMENTS)
	set_general_location(LINCOLN, AMERICAN_REINFORCEMENTS)
	set_general_location(GATES, AMERICAN_REINFORCEMENTS)
	set_general_location(LEE, AMERICAN_REINFORCEMENTS)
	set_general_location(LAFAYETTE, AMERICAN_REINFORCEMENTS)

	set_general_location(ROCHAMBEAU, FRENCH_REINFORCEMENTS)

	place_french_cu(FRENCH_REINFORCEMENTS, 5)

	create_deck()

	goto_committees_of_correspondence()
}

/* GAME STATE */

function create_deck() {
	game.deck = []
	for (let i = 1; i <= 110; ++i) {
		// No DoI or Baron von Steuben first year.
		if (i === DECLARATION_OF_INDEPENDENCE || i === BARON_VON_STEUBEN)
			continue
		game.deck.push(i)
	}
	shuffle(game.deck)
}

function reshuffle_deck() {
	log("Reshuffled the deck.")
	game.reshuffle = false

	// Reconstitute deck, minus removed cards, cards in hand, war_ends, and reinforcement cards.
	// Rule 6.1B clarification.
	for (let c = 1; c <= 110; ++c) {
		if (game.a_hand.includes(c))
			continue
		if (game.b_hand.includes(c))
			continue
		if (game.reinforcements.includes(c))
			continue
		if (set_has(game.removed, c))
			continue
		if (game.war_ends === c)
			continue
		game.deck.push(c)
	}

	shuffle(game.deck)
}

function roll_d6() {
	return random(6) + 1
}

function deal_card() {
	if (game.deck.length === 0)
		reshuffle_deck()
	return game.deck.pop()
}

function active_hand() {
	return game.active === P_AMERICA ? game.a_hand : game.b_hand
}

function play_card(c, reason) {
	if (reason)
		log(game.active[0] + " played #" + c + " " + reason)
	else
		log(game.active[0] + " played #" + c)
	if (CARDS[c].reshuffle === "if_played")
		game.reshuffle = true
	set_delete(active_hand(), c)
	game.last_played = c
	if (CARDS[c].once) {
		log("Removed card " + c + ".")
		set_add(game.removed, c)
	}
}

function discard_card_from_hand(hand, c) {
	set_delete(hand, c)
	if (CARDS[c].reshuffle === "if_discarded")
		game.reshuffle = true
	logp("discarded #" + c)
}

function discard_card(c, reason) {
	game.last_played = c
	discard_card_from_hand(active_hand(), c)
	if (reason)
		logp("discarded #" + c + " " + reason)
	else
		logp("discarded #" + c)
}

function can_exchange_for_discard(c) {
	if (game.did_discard_event > 0) {
		if (game.active === P_BRITAIN)
			return true
		return CARDS[c].count > 1
	}
	return false
}

function can_play_event(c) {
	let card = CARDS[c]
	switch (card.when) {
		case "before_french_alliance":
			return !game.french_alliance_triggered
		case "after_french_alliance":
			return game.french_alliance_triggered
		case "european_war_in_effect":
			return game.european_war
	}
	switch (card.event) {
		case "john_glovers_marblehead_regiment":
			return has_general_on_map()
	}
	return true
}

function can_play_reinforcements() {
	if (game.active === P_BRITAIN) {
		if (game.reinforcements[0] === 0) {
			let n = count_british_cu(BRITISH_REINFORCEMENTS)
			for (let g of BRITISH_GENERALS)
				if (is_general_at_location(g, BRITISH_REINFORCEMENTS))
					++n
			return n > 0
		}
		return false
	}
	if (game.active === P_AMERICA)
		return game.reinforcements[1] === 0 || game.reinforcements[2] === 0
	return false
}

function is_map_space(s) {
	return s >= 0 && s <= 65
}

function is_port(where) {
	return SPACES[where].port
}

function is_non_blockaded_port(where) {
	let port = SPACES[where].port
	return (port > 0 && port !== game.french_navy)
}

function is_fortified_port(where) {
	return SPACES[where].type === "fortified-port"
}

function is_continental_congress_dispersed() {
	return game.congress === CONTINENTAL_CONGRESS_DISPERSED
}

function is_winter_quarter_space(where) {
	let colony = SPACES[where].colony
	if (set_has(SOUTH_OF_WINTER_ATTRITION_LINE, colony))
		return true // south of winter attrition line
	let type = SPACES[where].type
	if (type === "winter-quarters" || type === "fortified-port")
		return true
	return false
}

function allowed_to_place_american_pc() {
	if (is_continental_congress_dispersed())
		return false
	if (game.pennsylvania_and_new_jersey_line_mutinies)
		return false
	return true
}

function is_british_militia(space) {
	return get_colony_control(SPACES[space].colony) === PC_BRITISH
}

function is_american_militia(space) {
	return get_colony_control(SPACES[space].colony) === PC_AMERICAN
}

function is_american_winter_offensive() {
	if (game.who === WASHINGTON && game.a_hand.length === 0)
		return true
	return false
}

/* PC */

function set_space_pc(space, pc) {
	game.spc[space] &= ~3
	game.spc[space] |= pc
}

function get_space_pc(space) {
	return game.spc[space] & 3
}

function has_no_pc(space) {
	return get_space_pc(space) === PC_NONE
}

function has_british_pc(space) {
	return get_space_pc(space) === PC_BRITISH
}

function has_american_pc(space) {
	return get_space_pc(space) === PC_AMERICAN
}

function has_enemy_pc(space) {
	if (game.active === P_BRITAIN)
		return has_american_pc(space)
	else
		return has_british_pc(space)
}

function is_adjacent_to_british_pc(a) {
	for (let b of SPACES[a].adjacent)
		if (has_british_pc(b))
			return true
	if (SPACES[a].port) {
		for (let b of all_spaces) {
			if (SPACES[b].port)
				if (has_british_pc(b))
					return true
		}
	}
	return false
}

function is_adjacent_to_american_pc(a) {
	for (let b of SPACES[a].adjacent)
		if (has_american_pc(b))
			return true
	return false
}

function place_british_pc(space) {
	logp("placed PC in " + space)
	if (game.british_pc_space_list)
		set_delete(game.british_pc_space_list, space)
	set_space_pc(space, PC_BRITISH)
}

function place_american_pc(space) {
	logp("placed PC in " + space)
	set_space_pc(space, PC_AMERICAN)
}

function remove_pc(space) {
	if (game.active === P_BRITAIN)
		logp("removed PC in " + space)
	else
		logp("removed PC in " + space)
	set_space_pc(space, PC_NONE)
}

function flip_pc(space) {
	if (game.active === P_BRITAIN)
		logp("flipped PC in " + space)
	else
		logp("flipped PC in " + space)
	if (has_british_pc(space))
		set_space_pc(space, PC_AMERICAN)
	else
		set_space_pc(space, PC_BRITISH)
}

function get_colony_control(c) {
	let control = 0
	for (let space of COLONIES[c]) {
		let pc = get_space_pc(space)
		if (pc === PC_BRITISH)
			--control
		else if (pc === PC_AMERICAN)
			++control
	}
	if (control < 0)
		return PC_BRITISH
	if (control > 0)
		return PC_AMERICAN
	return PC_NONE
}

/* CU */

function reset_moved_cu() {
	map_clear(game.mcu)
}

function count_british_cu(s) {
	return (game.spc[s] & CU_BRITISH_MASK) >>> CU_BRITISH_SHIFT
}

function count_american_cu(s) {
	return (game.spc[s] & CU_AMERICAN_MASK) >>> CU_AMERICAN_SHIFT
}

function count_french_cu(s) {
	return (game.spc[s] & CU_FRENCH_MASK) >>> CU_FRENCH_SHIFT
}

function set_british_cu(s, n) {
	game.spc[s] &= ~CU_BRITISH_MASK
	game.spc[s] |= n << CU_BRITISH_SHIFT
}

function set_american_cu(s, n) {
	game.spc[s] &= ~CU_AMERICAN_MASK
	game.spc[s] |= n << CU_AMERICAN_SHIFT
}

function set_french_cu(s, n) {
	game.spc[s] &= ~CU_FRENCH_MASK
	game.spc[s] |= n << CU_FRENCH_SHIFT
}

function has_british_cu(space) {
	return count_british_cu(space) > 0
}

function has_no_british_cu(space) {
	return count_british_cu(space) === 0
}

function has_american_or_french_cu(space) {
	return count_american_cu(space) > 0 || count_french_cu(space) > 0
}

function has_american_cu(space) {
	return count_american_cu(space) > 0
}

function has_french_cu(space) {
	return count_french_cu(space) > 0
}

function has_enemy_cu(where) {
	if (game.active === P_BRITAIN)
		return has_american_or_french_cu(where)
	else
		return has_british_cu(where)
}

function count_unmoved_british_cu(where) {
	return count_british_cu(where) - map_get(game.mcu, where * 3 + 0, 0)
}

function count_unmoved_american_cu(where) {
	return count_american_cu(where) - map_get(game.mcu, where * 3 + 1, 0)
}

function count_unmoved_french_cu(where) {
	return count_french_cu(where) - map_get(game.mcu, where * 3 + 2, 0)
}

function mark_moved_cu_imp(offset, where, moved) {
	if (moved > 0) {
		let old = map_get(game.mcu, where * 3 + offset, 0)
		map_set(game.mcu, where * 3 + offset, old + moved)
	}
}

function mark_moved_british_cu(space, moved) {
	mark_moved_cu_imp(0, space, moved)
}

function mark_moved_american_cu(space, moved) {
	mark_moved_cu_imp(1, space, moved)
}

function mark_moved_french_cu(space, moved) {
	mark_moved_cu_imp(2, space, moved)
}

function count_american_and_french_cu(where) {
	return count_american_cu(where) + count_french_cu(where)
}

function count_enemy_cu(where) {
	if (game.active === P_BRITAIN)
		return count_american_and_french_cu(where)
	else
		return count_british_cu(where)
}

function remove_british_cu(where, count) {
	set_british_cu(where, count_british_cu(where) - count)
}

function remove_american_cu(where, count) {
	set_american_cu(where, count_american_cu(where) - count)
}

function remove_french_cu(where, count) {
	set_french_cu(where, count_french_cu(where) - count)
}

function place_british_cu(where, count) {
	set_british_cu(where, count_british_cu(where) + count)
}

function place_american_cu(where, count) {
	set_american_cu(where, count_american_cu(where) + count)
}

function place_french_cu(where, count) {
	set_french_cu(where, count_french_cu(where) + count)
}

function move_british_cu(from, to, count) {
	set_british_cu(from, count_british_cu(from) - count)
	set_british_cu(to, count_british_cu(to) + count)
}

function move_american_cu(from, to, count) {
	set_american_cu(from, count_american_cu(from) - count)
	set_american_cu(to, count_american_cu(to) + count)
}

function move_french_cu(from, to, count) {
	set_french_cu(from, count_french_cu(from) - count)
	set_french_cu(to, count_french_cu(to) + count)
}

/* GENERALS */

function location_of_general(g) {
	return game.loc[g]
}

function set_general_location(g, s) {
	game.loc[g] = s
}

function is_general_at_location(g, s) {
	return location_of_general(g) === s
}

function is_general_on_map(g) {
	return is_map_space(location_of_general(g))
}

function has_general_moved(g) {
	return set_has(game.moved, g)
}

function set_general_moved(g) {
	set_add(game.moved, g)
}

function reset_moved_generals() {
	set_clear(game.moved)
}

function find_british_general(where) {
	for (let general of BRITISH_GENERALS)
		if (is_general_at_location(general, where))
			return general
	return NOBODY
}

function find_american_or_french_general(where) {
	for (let general of AMERICAN_GENERALS)
		if (is_general_at_location(general, where))
			return general
	return NOBODY
}

function has_british_general(where) {
	return find_british_general(where) !== NOBODY
}

function has_american_or_french_general(where) {
	return find_american_or_french_general(where) !== NOBODY
}

function has_enemy_general(where) {
	if (game.active === P_BRITAIN)
		return has_american_or_french_general(where)
	else
		return has_british_general(where)
}

function count_friendly_generals(where) {
	let list
	if (game.active === P_BRITAIN)
		list = BRITISH_GENERALS
	else
		list = AMERICAN_GENERALS
	let count = 0
	for (let g of list)
		if (is_general_at_location(g, where))
			++count
	return count
}

function has_general_on_map() {
	if (game.active === P_BRITAIN)
		return has_british_general_on_map()
	else
		return has_american_general_on_map()
}

function has_british_general_on_map() {
	for (let g of BRITISH_GENERALS)
		if (is_general_on_map(g))
			return true
	return false
}

function has_american_general_on_map() {
	for (let g of AMERICAN_GENERALS)
		if (is_general_on_map(g))
			return true
	return false
}

function can_activate_general(c) {
	if (game.active === P_BRITAIN)
		return can_activate_british_general(c)
	else
		return can_activate_american_general(c)
}

function can_activate_british_general(c) {
	let ops = CARDS[c].count + game.b_queue
	for (let g of BRITISH_GENERALS)
		if (is_general_on_map(g) && GENERALS[g].strategy <= ops)
			return true
	return false
}

function can_activate_american_general(c) {
	let ops = CARDS[c].count + game.a_queue
	for (let g of AMERICAN_GENERALS)
		if (is_general_on_map(g) && GENERALS[g].strategy <= ops)
			return true
	return false
}

function move_general(who, where) {
	set_general_location(who, where)
}

function capture_washington() {
	set_general_location(WASHINGTON, NOWHERE)

	if (!game.french_alliance_triggered) {
		game.french_alliance -= 3
		if (game.french_alliance < 0)
			game.french_alliance = 0
	}

	goto_george_washington_captured()
}

function capture_british_general(where) {
	let g = find_british_general(where)
	log(g + " was captured!")
	move_general(g, CAPTURED_GENERALS)
}

function capture_american_or_french_general(where) {
	let g = find_american_or_french_general(where)
	log(g + " was captured!")
	if (g === WASHINGTON)
		capture_washington()
	else
		move_general(g, CAPTURED_GENERALS)
}

function capture_enemy_general(where) {
	if (game.active === P_BRITAIN)
		capture_american_or_french_general(where)
	else
		capture_british_general(where)
}

function remove_benedict_arnold() {
	if (!is_general_at_location(ARNOLD, NOWHERE)) {
		log("Removed Arnold from the game!")
		set_general_location(ARNOLD, NOWHERE)
	}
}

/* ARMIES */

function has_british_army(where) {
	return has_british_general(where) && has_british_cu(where)
}

function has_american_army(where) {
	return has_american_or_french_general(where) && has_american_or_french_cu(where)
}

function has_no_british_playing_piece(where) {
	if (has_british_pc(where))
		return false
	if (has_british_general(where))
		return false
	if (has_british_cu(where))
		return false
	return true
}

function has_no_american_unit(where) {
	if (has_american_or_french_general(where))
		return false
	if (has_american_or_french_cu(where))
		return false
	if (game.congress === where)
		return false
	return true
}

function place_british_reinforcements(who, count, where) {
	let already_there = find_british_general(where)
	if (who !== NOBODY && already_there !== NOBODY) {
		move_general(already_there, BRITISH_REINFORCEMENTS)
	}
	if (who !== NOBODY) {
		logp("reinforced " + where + " with " + who)
		move_general(who, where)
	}
	if (count > 0) {
		logp("reinforced " + where + " with " + count + " CU")
		move_british_cu(BRITISH_REINFORCEMENTS, where, count)
		if (has_enemy_general(where))
			capture_enemy_general(where)
		if (game.active === P_BRITAIN && game.congress === where)
			disperse_continental_congress()
	}
}

function place_american_reinforcements(who, count, where) {
	let already_there = find_american_or_french_general(where)
	if (who !== NOBODY && already_there !== NOBODY) {
		// Never replace Washington
		if (already_there === WASHINGTON)
			who = NOBODY
		else
			move_general(already_there, AMERICAN_REINFORCEMENTS)
	}
	if (who !== NOBODY) {
		logp("reinforced " + where + " with " + who)
		move_general(who, where)
	}
	logp("reinforced " + where + " with " + count + " CU")
	place_american_cu(where, count)
	if (has_enemy_general(where))
		capture_enemy_general(where)
}

function place_french_reinforcements(who, where) {
	let already_there = find_american_or_french_general(where)
	if (who !== NOBODY && already_there !== NOBODY) {
		// Never replace Washington
		if (already_there === WASHINGTON)
			who = NOBODY
		else
			move_general(already_there, AMERICAN_REINFORCEMENTS)
	}
	if (who !== NOBODY) {
		logp("reinforced " + where + " with " + who)
		move_general(who, where)
	}
	logp("reinforced " + where + " with the French CU")
	move_french_cu(FRENCH_REINFORCEMENTS, where, count_french_cu(FRENCH_REINFORCEMENTS))
	move_french_cu(AMERICAN_REINFORCEMENTS, where, count_french_cu(AMERICAN_REINFORCEMENTS))
}

function pickup_max_british_cu(where) {
	game.carry_british = count_unmoved_british_cu(where)
	if (game.carry_british > 5)
		game.carry_british = 5
	game.carry_american = 0
	game.carry_french = 0
}

function pickup_max_american_cu(where) {
	game.carry_british = 0
	game.carry_french = count_unmoved_french_cu(where)
	game.carry_american = count_unmoved_american_cu(where)
	if (game.carry_french > 5)
		game.carry_french = 5
	if (game.carry_american + game.carry_french > 5)
		game.carry_american = 5 - game.carry_french
}

function move_army(who, from, to) {
	game.count -= movement_cost(from, to)
	if (game.mobility && has_enemy_cu(to)) {
		game.mobility = false
		game.count -= 1
	}
	if (game.carry_british > 0)
		move_british_cu(from, to, game.carry_british)
	if (game.carry_american > 0)
		move_american_cu(from, to, game.carry_american)
	if (game.carry_french > 0)
		move_french_cu(from, to, game.carry_french)
	move_general(who, to)
}

function intercept_army(who, from, to) {
	if (game.carry_british > 0)
		move_british_cu(from, to, game.carry_british)
	if (game.carry_american > 0)
		move_american_cu(from, to, game.carry_american)
	if (game.carry_french > 0)
		move_french_cu(from, to, game.carry_french)
	move_general(who, to)
}

function overrun(where) {
	logp("overran CU in " + where)
	if (game.active === P_BRITAIN) {
		if (count_american_cu(where) > 0)
			remove_american_cu(where, 1)
		else
			remove_french_cu(where, 1)
	} else {
		remove_british_cu(where, 1)
	}
}

function retreat_american_army(from, to) {
	let g = find_american_or_french_general(from)
	if (g)
		move_general(g, to)
	move_american_cu(from, to, count_american_cu(from))
	move_french_cu(from, to, count_french_cu(from))
}

function retreat_british_army(from, to) {
	let g = find_british_general(from)
	if (g)
		move_general(g, to)
	move_british_cu(from, to, count_british_cu(from))
}

function surrender_american_army(where) {
	let g = find_american_or_french_general(where)
	if (g)
		capture_american_or_french_general(where)
	remove_american_cu(where, count_american_cu(where))
	remove_french_cu(where, count_french_cu(where))
}

function surrender_british_army(where) {
	let g = find_british_general(where)
	if (g)
		capture_british_general(where)
	game.british_losses += count_british_cu(where)
	remove_british_cu(where, count_british_cu(where))
}

function disperse_continental_congress() {
	log("Contintental Congress dispersed!")
	game.congress = CONTINENTAL_CONGRESS_DISPERSED
	game.congress_was_dispersed = true
}

/* MOVE GENERATORS */

function gen_remove_british_pc_from(list_of_colonies) {
	for (let colony of list_of_colonies) {
		for (let space of COLONIES[colony]) {
			if (has_british_pc(space) && has_no_british_cu(space)) {
				gen_action("remove_pc", space)
			}
		}
	}
}

function gen_remove_american_pc() {
	for (let space of all_spaces) {
		if (has_american_pc(space) && has_no_american_unit(space)) {
			gen_action("remove_pc", space)
		}
	}
}

function gen_remove_american_pc_from(list_of_colonies) {
	for (let colony of list_of_colonies) {
		for (let space of COLONIES[colony]) {
			if (has_american_pc(space) && has_no_american_unit(space)) {
				gen_action("remove_pc", space)
			}
		}
	}
}

function gen_remove_american_pc_from_non_port(list_of_colonies) {
	for (let colony of list_of_colonies) {
		for (let space of COLONIES[colony]) {
			if (!SPACES[space].port) {
				if (has_american_pc(space) && has_no_american_unit(space)) {
					gen_action("remove_pc", space)
				}
			}
		}
	}
}

function gen_remove_american_pc_within_two_spaces_of_a_british_general() {
	let candidates = []
	for (let g of BRITISH_GENERALS) {
		let a = location_of_general(g)
		if (is_map_space(a)) {
			set_add(candidates, a)
			for (let b of SPACES[a].adjacent) {
				set_add(candidates, b)
				for (let c of SPACES[b].adjacent) {
					set_add(candidates, c)
				}
			}
		}
	}
	for (let space of candidates)
		if (has_american_pc(space) && has_no_american_unit(space))
			gen_action("remove_pc", space)
}

function gen_place_american_pc() {
	for (let space of all_spaces) {
		if (has_no_pc(space) && has_no_british_playing_piece(space)) {
			gen_action("place_american_pc", space)
		}
	}
}

function gen_place_american_pc_in(list_of_colonies) {
	for (let colony of list_of_colonies) {
		for (let space of COLONIES[colony]) {
			if (has_no_pc(space) && has_no_british_playing_piece(space)) {
				gen_action("place_american_pc", space)
			}
		}
	}
}

/* SETUP PHASE */

function goto_committees_of_correspondence() {
	log(".h2.american Committes of Correspondence")
	logbr()
	game.active = P_AMERICA
	game.state = "committees_of_correspondence"
	game.coc = THE_13_COLONIES.slice()
}

states.committees_of_correspondence = {
	inactive: "Committees of Correspondence",
	prompt() {
		view.prompt =
			"Committees of Correspondence: Place 1 PC marker in each of the 13 colonies. " + game.coc.length + " left."
		if (game.coc.length > 0)
			gen_place_american_pc_in(game.coc)
		else
			gen_pass()
	},
	place_american_pc(space) {
		push_undo()
		let colony = SPACES[space].colony
		set_delete(game.coc, colony)
		place_american_pc(space)
	},
	pass() {
		clear_undo()
		goto_for_the_king()
	},
}

function goto_for_the_king() {
	logbr()
	log(".h2.british For the King")
	logbr()
	delete game.coc
	game.active = P_BRITAIN
	game.state = "for_the_king"
	game.count = 3
	gen_british_pc_ops_start()
}

states.for_the_king = {
	inactive: "For the King",
	prompt() {
		view.prompt = "For the King: Place 3 PC markers. " + game.count + " left."
		if (game.count > 0)
			gen_british_pc_ops()
		else
			gen_pass()
	},
	place_british_pc(space) {
		push_undo()
		place_british_pc(space)
		--game.count
	},
	pass() {
		clear_undo()
		gen_british_pc_ops_end()
		goto_start_year()
	},
}

/* REINFORCEMENTS AND START OF STRATEGY PHASE */

function automatic_victory() {
	let n_american = 0
	let n_british = 0
	for (let space of all_spaces) {
		n_american += count_french_cu(space) + count_american_cu(space)
		if (SPACES[space].colony !== "CA")
			n_british += count_british_cu(space)
	}
	if (n_american === 0) {
		game.victory = "British Automatic Victory!"
		game.active = "None"
		game.result = P_BRITAIN
		game.state = "game_over"
		log(game.victory)
		return true
	}
	if (n_british === 0) {
		game.victory = "American Automatic Victory!"
		game.active = "None"
		game.result = P_AMERICA
		game.state = "game_over"
		log(game.victory)
		return true
	}
	return false
}

function goto_start_year() {
	logbr()
	log(".h1 Year " + game.year)
	logbr()

	// Prisoner exchange
	for (let g of BRITISH_GENERALS)
		if (is_general_at_location(g, CAPTURED_GENERALS))
			move_general(g, BRITISH_REINFORCEMENTS)
	for (let g of AMERICAN_GENERALS)
		if (is_general_at_location(g, CAPTURED_GENERALS))
			move_general(g, AMERICAN_REINFORCEMENTS)

	switch (game.year) {
		case 1775:
			place_british_cu(BRITISH_REINFORCEMENTS, 3)
			break
		case 1776:
			place_british_cu(BRITISH_REINFORCEMENTS, 8)
			break
		case 1777:
			place_british_cu(BRITISH_REINFORCEMENTS, 1)
			break
		case 1778:
			place_british_cu(BRITISH_REINFORCEMENTS, 8)
			break
		case 1779:
			place_british_cu(BRITISH_REINFORCEMENTS, 1)
			break
		case 1780:
			place_british_cu(BRITISH_REINFORCEMENTS, 5)
			break
		case 1781:
			place_british_cu(BRITISH_REINFORCEMENTS, 1)
			break
		case 1782:
			place_british_cu(BRITISH_REINFORCEMENTS, 1)
			break
		case 1783:
			place_british_cu(BRITISH_REINFORCEMENTS, 1)
			break
	}

	if (game.year === 1776) {
		game.deck.push(DECLARATION_OF_INDEPENDENCE)
		game.deck.push(BARON_VON_STEUBEN)
		shuffle(game.deck)
	}

	if (game.reshuffle)
		reshuffle_deck()

	game.a_queue = 0
	game.b_queue = 0
	game.did_discard_event = 0

	game.reinforcements = [0,0,0]
	game.active = P_BRITAIN
	game.state = "british_declare_first"

	game.a_hand = []
	game.b_hand = []
	for (let i = 0; i < 7; ++i) {
		set_add(game.a_hand, deal_card())
		set_add(game.b_hand, deal_card())
	}
}

states.british_declare_first = {
	prompt() {
		view.prompt = "Declare yourself as the first player by playing a campaign card?"
		gen_pass()
		for (let c of CAMPAIGN_CARDS) {
			if (game.b_hand.includes(c)) {
				gen_action("card_campaign", c)
			}
		}
	},
	card_campaign(c) {
		delete game.congress_was_dispersed
		logp("went first by playing a campaign card")
		game.active = P_BRITAIN
		goto_campaign(c)
	},
	pass() {
		if (game.congress_was_dispersed)
			game.active = P_BRITAIN
		else
			game.active = P_AMERICA
		game.state = "choose_first_player"
		delete game.congress_was_dispersed
	},
}

states.choose_first_player = {
	prompt() {
		view.prompt = "Choose who will play the first strategy card."
		view.actions.america_first = 1
		view.actions.britain_first = 1
	},
	america_first() {
		logp("went first")
		goto_strategy_phase(P_AMERICA)
	},
	britain_first() {
		logp("went first")
		goto_strategy_phase(P_BRITAIN)
	},
}

/* STRATEGY PHASE */

function goto_strategy_phase(new_active) {
	game.active = new_active
	game.state = "strategy_phase"
	logbr()
	if (game.active === P_AMERICA)
		log(".h2.american American Turn")
	else
		log(".h2.british British Turn")
	logbr()
}

states.strategy_phase = {
	inactive: "strategy phase",
	prompt() {
		view.prompt = "Play a strategy card."
		gen_strategy_plays(active_hand())
	},
	card_campaign(c) {
		game.did_discard_event = 0
		clear_queue()
		goto_campaign(c)
	},
	card_play_event(c) {
		push_undo()
		game.did_discard_event = 0
		clear_queue()
		do_event(c)
	},
	card_discard_event(c) {
		push_undo()
		game.did_discard_event = 0
		clear_queue()
		discard_card(c, "PC action")
		game.state = "discard_event_pc_action"
	},
	card_ops_pc(c) {
		push_undo()
		game.did_discard_event = 0
		clear_queue()
		play_card(c, "for PC")
		goto_ops_pc(CARDS[c].count)
	},
	card_ops_reinforcements(c) {
		push_undo()
		game.did_discard_event = 0
		clear_queue()
		goto_ops_reinforcements(c)
	},
	card_ops_queue(c) {
		game.did_discard_event = 0
		play_card(c, "to queue")
		if (game.active === P_BRITAIN)
			game.b_queue += CARDS[c].count
		else
			game.a_queue += CARDS[c].count
		end_strategy_card()
	},
	card_ops_general(c) {
		push_undo()
		game.did_discard_event = 0
		goto_ops_general(c)
	},
	exchange_for_discard(c) {
		let d = game.did_discard_event = 0
		game.did_discard_event = 0
		discard_card(c)
		set_add(active_hand(), d)
		logp("picked up up #" + d)
	},
}

function end_strategy_card() {
	clear_undo()

	if (automatic_victory())
		return

	if (game.campaign) {
		if (--game.campaign > 0) {
			game.count = 3 // can activate any general!
			game.state = "ops_general_who"
			return
		} else {
			delete game.landing_party
			delete game.campaign
		}
	}

	if (!game.french_alliance_triggered && game.french_alliance === 9) {
		log("The French signed an alliance with the Americans!")
		game.french_alliance_triggered = true
		if (game.french_navy === -1) {
			game.save_active = game.active
			game.active = P_AMERICA
			game.state = "place_french_navy_trigger"
			return
		}
	}

	reset_moved_generals()
	reset_moved_cu()

	goto_strategy_phase(ENEMY[game.active])

	let hand = active_hand()
	if (hand.length === 0) {
		game.active = ENEMY[game.active]
		hand = active_hand()
		if (hand.length === 0)
			return goto_winter_attrition_phase()
	}

}

function clear_queue() {
	if (game.active === P_BRITAIN)
		game.b_queue = 0
	else
		game.a_queue = 0
}

function gen_strategy_plays(hand) {
	for (let c of hand) {
		let card = CARDS[c]
		switch (card.type) {
			case "mandatory-event":
				gen_action("card_play_event", c)
				break
			case "campaign":
				gen_action("card_campaign", c)
				break
			case "ops":
				if (can_exchange_for_discard(c))
					gen_action("exchange_for_discard", c)
				if (can_activate_general(c))
					gen_action("card_ops_general", c)
				gen_action("card_ops_pc", c)
				if (can_play_reinforcements())
					gen_action("card_ops_reinforcements", c)
				if (card.count < 3)
					gen_action("card_ops_queue", c)
				break
			case "british-event":
			case "british-event-or-battle":
				if (game.active === P_BRITAIN)
					if (can_play_event(c))
						gen_action("card_play_event", c)
				gen_action("card_discard_event", c)
				break
			case "american-event":
				if (game.active === P_AMERICA)
					if (can_play_event(c))
						gen_action("card_play_event", c)
				gen_action("card_discard_event", c)
				break
			case "british-battle":
			case "american-battle":
				gen_action("card_discard_event", c)
				break
		}
	}
}

/* DISCARD EVENT CARD FOR PC ACTION */

states.discard_event_pc_action = {
	prompt() {
		view.prompt = "Place, flip, or remove PC marker."
		gen_pass()
		if (game.active === P_BRITAIN)
			gen_british_discard_event_pc_action()
		else
			gen_american_discard_event_pc_action()
	},
	place_british_pc(space) {
		place_british_pc(space)
		end_strategy_card()
	},
	place_american_pc(space) {
		place_american_pc(space)
		end_strategy_card()
	},
	remove_pc(space) {
		remove_pc(space)
		end_strategy_card()
	},
	flip_pc(space) {
		flip_pc(space)
		end_strategy_card()
	},
	pass() {
		end_strategy_card()
	},
}

function gen_british_discard_event_pc_action() {
	for (let space of all_spaces) {
		if (is_adjacent_to_british_pc(space)) {
			if (has_no_pc(space) && has_no_american_unit(space))
				gen_action("place_british_pc", space)
			else if (has_american_pc(space) && has_british_army(space))
				gen_action("flip_pc", space)
			else if (has_american_pc(space) && has_no_american_unit(space))
				gen_action("remove_pc", space)
		}
	}
}

function gen_american_discard_event_pc_action() {
	for (let space of all_spaces) {
		if (is_adjacent_to_american_pc(space)) {
			if (has_no_pc(space) && has_no_british_cu(space)) {
				if (allowed_to_place_american_pc())
					gen_action("place_american_pc", space)
			} else if (has_british_pc(space) && has_american_or_french_general(space)) {
				gen_action("flip_pc", space)
			} else if (has_british_pc(space) && has_no_british_cu(space)) {
				gen_action("remove_pc", space)
			}
		}
	}
}

/* PLAY OPS CARD FOR PC ACTIONS */

function goto_ops_pc(count) {
	game.count = count
	game.state = "ops_pc"
	if (game.active === P_BRITAIN)
		gen_british_pc_ops_start()
}

states.ops_pc = {
	prompt() {
		view.prompt = "Place or flip PC markers. " + game.count + " left."
		gen_pass()
		if (game.count > 0) {
			if (game.active === P_BRITAIN)
				gen_british_pc_ops()
			else
				gen_american_pc_ops()
		}
	},
	place_british_pc(space) {
		push_undo()
		place_british_pc(space)
		--game.count
	},
	place_american_pc(space) {
		push_undo()
		place_american_pc(space)
		--game.count
	},
	flip_pc(space) {
		push_undo()
		flip_pc(space)
		--game.count
	},
	pass() {
		if (game.active === P_BRITAIN)
			gen_british_pc_ops_end()
		end_strategy_card()
	},
}

function gen_british_pc_ops_start() {
	game.british_pc_space_list = []
	for (let space of all_spaces) {
		if (has_no_pc(space) && has_no_american_unit(space)) {
			if (is_adjacent_to_british_pc(space))
				set_add(game.british_pc_space_list, space)
		}
	}
}

function gen_british_pc_ops() {
	for (let space of game.british_pc_space_list)
		gen_action("place_british_pc", space)
	for (let space of all_spaces) {
		if (has_british_army(space)) {
			if (has_no_pc(space))
				gen_action("place_british_pc", space)
			else if (has_american_pc(space))
				gen_action("flip_pc", space)
		}
	}
}

function gen_british_pc_ops_end() {
	delete game.british_pc_space_list
}

function gen_american_pc_ops() {
	for (let space of all_spaces) {
		if (has_no_pc(space) && has_no_british_cu(space)) {
			if (allowed_to_place_american_pc())
				gen_action("place_american_pc", space)
		} else if (has_british_pc(space) && has_american_or_french_general(space)) {
			gen_action("flip_pc", space)
		}
	}
}

/* PLAY OPS CARD FOR REINFORCEMENTS */

function goto_ops_reinforcements(c) {
	let count = CARDS[c].count
	play_card(c, "for reinforcements")
	if (game.active === P_BRITAIN) {
		game.reinforcements[0] = c
		game.count = count_british_cu(BRITISH_REINFORCEMENTS)
		game.state = "ops_british_reinforcements_who"
	} else {
		if (game.reinforcements[1] === 0)
			game.reinforcements[1] = c
		else
			game.reinforcements[2] = c
		game.count = count
		game.state = "ops_american_reinforcements_who"
	}
}

states.ops_british_reinforcements_who = {
	prompt() {
		view.prompt = "Reinforcements: choose an available general or pass to bring only CU."
		view.prompt += " Carrying " + game.count + " British CU."
		gen_pass()
		gen_british_reinforcements_who()
	},
	drop_british_cu() {
		--game.count
	},
	pickup_british_cu() {
		++game.count
	},
	select_general(g) {
		push_undo()
		game.state = "ops_british_reinforcements_where"
		game.who = g
	},
	pass() {
		push_undo()
		game.state = "ops_british_reinforcements_where"
		game.who = NOBODY
	},
}

states.ops_british_reinforcements_where = {
	prompt() {
		view.prompt = "Reinforcements: choose a port space."
		view.prompt += " Carrying " + game.count + " British CU."
		gen_british_reinforcements_where()
	},
	drop_british_cu() {
		--game.count
	},
	pickup_british_cu() {
		++game.count
	},
	place_reinforcements(space) {
		place_british_reinforcements(game.who, game.count, space)
		end_strategy_card()
		game.who = NOBODY
	},
}

states.ops_american_reinforcements_who = {
	prompt() {
		view.prompt = "Reinforcements: choose an available general or pass to bring only CU."
		gen_pass()
		gen_american_reinforcements_who()
	},
	select_general(g) {
		push_undo()
		game.state = "ops_american_reinforcements_where"
		game.who = g
	},
	pass() {
		push_undo()
		game.state = "ops_american_reinforcements_where"
		game.who = NOBODY
	},
}

states.ops_american_reinforcements_where = {
	prompt() {
		view.prompt = "Reinforcements: choose a space."
		gen_american_reinforcements_where(game.who)
	},
	place_reinforcements(space) {
		if (game.who === ROCHAMBEAU)
			place_french_reinforcements(game.who, space)
		else
			place_american_reinforcements(game.who, game.count, space)
		end_strategy_card()
		game.who = NOBODY
	},
}

function gen_british_reinforcements_who() {
	for (let g of BRITISH_GENERALS) {
		if (is_general_at_location(g, BRITISH_REINFORCEMENTS)) {
			gen_action("select_general", g)
		}
	}
	if (game.count > 0)
		gen_action("drop_british_cu")
	if (game.count < count_british_cu(BRITISH_REINFORCEMENTS))
		gen_action("pickup_british_cu")
}

function gen_british_reinforcements_where() {
	for (let space of all_spaces) {
		if (is_non_blockaded_port(space))
			if (!has_american_or_french_cu(space) && !has_american_pc(space))
				gen_action("place_reinforcements", space)
	}
	if (game.count > 0)
		gen_action("drop_british_cu")
	if (game.count < count_british_cu(BRITISH_REINFORCEMENTS))
		gen_action("pickup_british_cu")
}

function gen_american_reinforcements_who() {
	for (let g of AMERICAN_GENERALS) {
		if (is_general_at_location(g, AMERICAN_REINFORCEMENTS)) {
			gen_action("select_general", g)
		}
	}
}

function gen_american_reinforcements_where(general) {
	for (let space of all_spaces) {
		if (!has_british_cu(space) && !has_british_pc(space)) {
			if (general === ROCHAMBEAU) {
				if (SPACES[space].port)
					gen_action("place_reinforcements", space)
			} else {
				gen_action("place_reinforcements", space)
			}
		}
	}
}

/* PLAY OPS CARD TO MOVE A GENERAL */

function goto_ops_general(c) {
	play_card(c, " to activate a general")
	if (game.active === P_BRITAIN) {
		game.count = CARDS[c].count + game.b_queue
		game.b_queue = 0
	} else {
		game.count = CARDS[c].count + game.a_queue
		game.a_queue = 0
	}
	game.state = "ops_general_who"
}

states.ops_general_who = {
	prompt() {
		if (game.campaign && game.landing_party)
			view.prompt = "Campaign: Activate a general or use a landing party. " + game.campaign + " left."
		else if (game.campaign)
			view.prompt = "Campaign: Activate a general. " + game.campaign + " left."
		else
			view.prompt = "Activate a general with strategy rating " + game.count + " or lower."
		if (game.landing_party)
			gen_landing_party()
		gen_activate_general()
		gen_pass()
	},
	place_british_pc(where) {
		game.landing_party = 0
		place_british_pc(where)
		end_strategy_card()
	},
	flip_pc(where) {
		game.landing_party = 0
		flip_pc(where)
		end_strategy_card()
	},
	select_general(g) {
		push_undo()
		goto_ops_general_move(g, false)
	},
	pass() {
		if (game.campaign > 0)
			game.campaign = 0
		end_strategy_card()
	},
}

function gen_landing_party() {
	for (let space of all_spaces) {
		if (!is_fortified_port(space) && is_non_blockaded_port(space)) {
			if (has_american_pc(space) && has_no_american_unit(space))
				gen_action("flip_pc", space)
			if (has_no_pc(space) && has_no_american_unit(space) && has_no_british_playing_piece(space))
				gen_action("place_british_pc", space)
		}
	}
}

function gen_activate_general() {
	if (game.active === P_BRITAIN)
		return gen_activate_british_general()
	else
		return gen_activate_american_general()
}

function gen_activate_british_general() {
	for (let g of BRITISH_GENERALS)
		if (is_general_on_map(g) && GENERALS[g].strategy <= game.count && !has_general_moved(g))
			gen_action("select_general", g)
}

function gen_activate_american_general() {
	for (let g of AMERICAN_GENERALS)
		if (is_general_on_map(g) && GENERALS[g].strategy <= game.count && !has_general_moved(g))
			gen_action("select_general", g)
}

function goto_remove_general(where) {
	game.state = "remove_general"
	game.where = where
}

states.remove_general = {
	prompt() {
		view.prompt = "Remove a general to the reinforcements box."
		gen_remove_general()
	},
	select_general(g) {
		if (game.active === P_BRITAIN)
			move_general(g, BRITISH_REINFORCEMENTS)
		else
			move_general(g, AMERICAN_REINFORCEMENTS)
		end_strategy_card()
	},
}

function goto_remove_general_after_intercept() {
	game.state = "remove_general_after_intercept"
}

states.remove_general_after_intercept = {
	prompt() {
		view.prompt = "Remove a general to the reinforcements box."
		gen_remove_general()
	},
	select_general(g) {
		if (game.active === P_BRITAIN)
			move_general(g, BRITISH_REINFORCEMENTS)
		else
			move_general(g, AMERICAN_REINFORCEMENTS)
		end_intercept()
	},
}

function goto_remove_general_after_retreat(where) {
	game.state = "remove_general_after_retreat"
	game.where = where
}

states.remove_general_after_retreat = {
	prompt() {
		view.prompt = "Remove a general to the reinforcements box."
		gen_remove_general()
	},
	select_general(g) {
		if (game.active === P_BRITAIN)
			move_general(g, BRITISH_REINFORCEMENTS)
		else
			move_general(g, AMERICAN_REINFORCEMENTS)
		end_battle()
	},
}

function gen_remove_general() {
	if (game.active === P_BRITAIN)
		return gen_remove_british_general()
	else
		return gen_remove_american_general()
}

function gen_remove_british_general() {
	for (let g of BRITISH_GENERALS)
		if (is_general_at_location(g, game.where))
			gen_action("select_general", g)
}

function gen_remove_american_general() {
	for (let g of AMERICAN_GENERALS)
		if (g !== WASHINGTON)
			if (is_general_at_location(g, game.where))
				gen_action("select_general", g)
}

function goto_ops_general_move(g, marblehead) {
	game.state = "ops_general_move"
	game.who = g
	if (marblehead) {
		game.mobility = false
		game.count = 6
	} else {
		if (game.active === P_BRITAIN) {
			game.mobility = false
			game.count = 4
		} else {
			game.mobility = true
			game.count = 5
		}
	}
	let where = location_of_general(g)
	if (game.active === P_BRITAIN)
		pickup_max_british_cu(where)
	else
		pickup_max_american_cu(where)
}

states.ops_general_move = {
	prompt() {
		view.prompt = "Move " + game.who + " with "
		if (game.carry_british > 0) {
			view.prompt += game.carry_british + " British CU."
		} else if (game.carry_french + game.carry_american > 0) {
			if (game.carry_french > 0) {
				if (game.carry_american > 0) {
					view.prompt += game.carry_french + " French CU and "
					view.prompt += game.carry_american + " American CU."
				} else {
					view.prompt += game.carry_french + " French CU."
				}
			} else {
				view.prompt += game.carry_american + " American CU."
			}
		} else {
			view.prompt += game.carry_american + " no CU."
		}
		if (game.count === 1)
			view.prompt += " " + game.count + " move left."
		else if (game.count > 1)
			view.prompt += " " + game.count + " moves left."

		// Cannot stop on enemy general
		if (!has_enemy_general(location_of_general(game.who)))
			gen_pass()

		gen_carry_cu()
		gen_move_general()
	},

	pickup_british_cu() {
		++game.carry_british
	},
	pickup_american_cu() {
		++game.carry_american
	},
	pickup_french_cu() {
		++game.carry_french
	},

	drop_british_cu() {
		push_undo()
		--game.carry_british
		if (has_general_moved(game.who))
			mark_moved_british_cu(location_of_general(game.who), 1)
	},
	drop_american_cu() {
		push_undo()
		--game.carry_american
		if (has_general_moved(game.who))
			mark_moved_american_cu(location_of_general(game.who), 1)
	},
	drop_french_cu() {
		push_undo()
		--game.carry_french
		if (has_general_moved(game.who))
			mark_moved_french_cu(location_of_general(game.who), 1)
	},

	move(to) {
		push_undo()

		set_general_moved(game.who)
		let from = location_of_general(game.who)
		let cu = game.carry_british + game.carry_american + game.carry_french

		let intercept = false
		if (game.active === P_BRITAIN) {
			let is_sea_move = path_type(from, to) === "sea"
			if (has_american_pc(to) && cu > 0 && !is_sea_move && !has_british_cu(to))
				intercept = can_intercept_to(to)
		}

		move_army(game.who, from, to)

		if (cu > 0) {
			if (has_enemy_general(to) && !has_enemy_cu(to)) {
				capture_enemy_general(to)
			}
			if (game.active === P_BRITAIN && game.congress === to && !has_enemy_cu(to)) {
				disperse_continental_congress()
			}
			if (cu >= 4 && count_enemy_cu(to) === 1 && !has_enemy_general(to)) {
				overrun(to)
			}
		}

		if (intercept)
			goto_intercept(from, to)
		else
			resume_moving(from, to)
	},
	pass() {
		clear_undo()
		let where = location_of_general(game.who)
		end_move()
		if (count_friendly_generals(where) > 1)
			goto_remove_general(where)
		else
			end_strategy_card()
	},
}

function resume_moving(from, to) {
	if (has_enemy_cu(to)) {
		end_move()
		goto_start_battle(from, to)
	}
}

function can_intercept_to(to) {
	for (let space of SPACES[to].adjacent) {
		if (has_american_army(space)) {
			let g = find_american_or_french_general(space)
			if (g && !has_general_moved(g))
				return true
		}
	}
	return false
}

function gen_intercept() {
	for (let space of SPACES[game.where].adjacent) {
		if (has_american_army(space)) {
			let g = find_american_or_french_general(space)
			if (g && !has_general_moved(g))
				gen_action("select_general", g)
		}
	}
}

function goto_intercept(from, where) {
	clear_undo()
	game.save_who = game.who
	game.who = NOBODY
	game.from = from
	game.where = where
	game.active = P_AMERICA
	game.state = "intercept"
}

states.intercept = {
	prompt() {
		view.prompt = "Intercept " + game.save_who + " in " + game.where + "?"
		gen_pass()
		gen_intercept()
	},
	select_general(g) {
		set_general_moved(g)
		let die = roll_d6()
		if (die <= GENERALS[g].agility) {
			log(g + " intercepted (" + die + " <= " + GENERALS[g].agility + ")")
			game.did_intercept = 1

			let save_carry_british = game.carry_british
			let save_carry_american = game.carry_american
			let save_carry_french = game.carry_french

			pickup_max_american_cu(location_of_general(g))
			intercept_army(g, location_of_general(g), game.where)

			game.carry_british = save_carry_british
			game.carry_american = save_carry_american
			game.carry_french = save_carry_french

			if (count_friendly_generals(game.where) > 1)
				goto_remove_general_after_intercept()
			else
				end_intercept()
		} else {
			log(g + " failed to intercept (" + die + " > " + GENERALS[g].agility + ")")
			if (!can_intercept_to(game.where))
				end_intercept()
		}
	},
	pass() {
		end_intercept()
	},
}

function end_intercept() {
	game.active = P_BRITAIN
	game.state = "ops_general_move"
	game.who = game.save_who
	delete game.save_who
	resume_moving(game.from, game.where)
	delete game.from
}

function end_move() {
	let where = location_of_general(game.who)
	if (has_general_moved(game.who)) {
		mark_moved_british_cu(where, game.carry_british)
		mark_moved_american_cu(where, game.carry_american)
		mark_moved_french_cu(where, game.carry_french)
	}
	game.who = NOBODY
	delete game.mobility
	delete game.carry_british
	delete game.carry_american
	delete game.carry_french
}

function path_type(from, to) {
	if (set_has(SPACES[from].path, to))
		return "path"
	if (set_has(SPACES[from].wilderness, to))
		return "wilderness"
	return "sea"
}

function gen_carry_cu() {
	let where = location_of_general(game.who)
	if (game.active === P_BRITAIN) {
		if (game.carry_british > 0)
			gen_action("drop_british_cu")
		if (game.carry_british < 5 && game.carry_british < count_unmoved_british_cu(where))
			gen_action("pickup_british_cu")
	} else {
		let carry_total = game.carry_french + game.carry_american
		if (game.carry_french > 0)
			gen_action("drop_french_cu")
		if (game.carry_american > 0)
			gen_action("drop_american_cu")
		if (carry_total < 5 && game.carry_french < count_unmoved_french_cu(where))
			gen_action("pickup_french_cu")
		if (carry_total < 5 && game.carry_american < count_unmoved_american_cu(where))
			gen_action("pickup_american_cu")
	}
}

function movement_cost(from, to) {
	switch (path_type(from, to)) {
		case "sea":
			return 4 /* must be a sea connection if no direct path */
		case "wilderness":
			return 3
		case "path":
			return 1
		default:
			throw "IMPOSSIBLE"
	}
}

function gen_move_general() {
	let from = location_of_general(game.who)
	let alone = game.carry_british + game.carry_american + game.carry_french === 0
	for (let to of SPACES[from].adjacent) {
		let mp = 1
		if (path_type(from, to) === "wilderness") {
			if ((from === QUEBEC && to === FALMOUTH) || (to === QUEBEC && from === FALMOUTH))
				if (game.who !== ARNOLD)
					continue
			mp = 3
		}

		if (alone) {
			if (has_enemy_cu(to))
				continue
			if (has_enemy_pc(to))
				continue
			// TODO: more robust check for not stopping (or allow undo in case he gets stuck)
			if (has_enemy_general(to) && game.count - mp === 0)
				continue
		}

		if (game.mobility && has_enemy_cu(to)) {
			if (game.count - mp >= 1)
				gen_action("move", to)
		} else {
			if (game.count - mp >= 0)
				gen_action("move", to)
		}
	}
	if (game.active === P_BRITAIN && game.count === 4) {
		if (is_non_blockaded_port(from)) {
			for (let to of all_spaces) {
				if (to !== from) {
					if (is_non_blockaded_port(to)) {
						if (!has_american_pc(to) && !has_american_or_french_cu(to)) {
							// don't leave alone
							if (alone && has_enemy_general(to))
								continue
							// TODO: duplicate action if can move by normal road
							gen_action("move", to)
						}
					}
				}
			}
		}
	}
}

/* CAMPAIGN */

function goto_campaign(c) {
	play_card(c)
	game.state = "campaign"
	game.campaign = CARDS[c].count
	game.landing_party = game.active === P_BRITAIN ? 1 : 0
	game.count = 3 // can activate any general!
	game.state = "ops_general_who"
}

/* EVENTS */

events.the_war_ends = function (c, card) {
	logp("played #" + c)
	log("The war will end in " + card.year)
	game.last_played = c
	set_delete(active_hand(), c)
	game.war_ends = c
	end_strategy_card()
}

events.remove_random_british_card = function (c, card) {
	play_card(c)
	remove_random_card(game.b_hand)
}

events.remove_random_american_card = function (c, card) {
	play_card(c)
	remove_random_card(game.a_hand)
}

function remove_random_card(hand) {
	if (hand.length > 0) {
		let i = random(hand.length)
		let c = hand[i]
		discard_card_from_hand(hand, c)
		if (CARDS[c].type === "mandatory-event")
			do_event(c)
		else
			end_strategy_card()
	} else
		end_strategy_card()
}

function advance_french_alliance(count) {
	if (game.french_alliance < 9) {
		game.french_alliance += count
		if (game.french_alliance > 9)
			game.french_alliance = 9
		log("French alliance advanced to " + count)
	}
}

function lose_regular_advantage() {
	if (game.regulars) {
		log("British Regulars Advantage lost!")
		game.regulars = false
		advance_french_alliance(2)
	}
}

events.baron_von_steuben_trains_the_continental_army = function (c, card) {
	play_card(c)
	if (is_general_on_map(WASHINGTON)) {
		let where = location_of_general(WASHINGTON)
		logp("placed 2 CU with Washington in " + where)
		place_american_cu(where, 2)
		lose_regular_advantage()
	}
	end_strategy_card()
}

events.advance_french_alliance = function (c, card) {
	play_card(c)
	advance_french_alliance(card.count)
	end_strategy_card()
}

events.remove_french_navy = function (c, card) {
	play_card(c)
	game.french_navy = game.year + 1
	end_strategy_card()
}

events.remove_british_pc_from = function (c, card) {
	play_card(c)
	game.count = card.count
	game.where = card.where
	game.state = "remove_british_pc_from"
}

states.remove_british_pc_from = {
	prompt() {
		view.prompt = "Remove British PC markers from " + game.where.join(", ") + ". " + game.count + " left."
		gen_pass()
		gen_remove_british_pc_from(game.where)
	},
	remove_pc(where) {
		remove_pc(where)
		if (--game.count === 0) {
			delete game.where
			end_strategy_card()
		}
	},
	pass() {
		delete game.where
		end_strategy_card()
	},
}

events.remove_american_pc = function (c, card) {
	play_card(c)
	game.count = card.count
	game.state = "remove_american_pc"
}

states.remove_american_pc = {
	prompt() {
		view.prompt = "Remove American PC markers. " + game.count + " left."
		gen_pass()
		gen_remove_american_pc()
	},
	remove_pc(where) {
		remove_pc(where)
		if (--game.count === 0) {
			end_strategy_card()
		}
	},
	pass() {
		end_strategy_card()
	},
}

events.remove_american_pc_from = function (c, card) {
	play_card(c)
	game.count = card.count
	game.where = card.where
	game.state = "remove_american_pc_from"
}

states.remove_american_pc_from = {
	prompt() {
		view.prompt = "Remove American PC markers from " + game.where.join(", ") + ". " + game.count + " left."
		gen_pass()
		gen_remove_american_pc_from(game.where)
	},
	remove_pc(where) {
		remove_pc(where)
		if (--game.count === 0) {
			delete game.where
			end_strategy_card()
		}
	},
	pass() {
		delete game.where
		end_strategy_card()
	},
}

events.remove_american_pc_from_non_port = function (c, card) {
	play_card(c)
	game.count = card.count
	game.where = card.where
	game.state = "remove_american_pc_from_non_port"
}

states.remove_american_pc_from_non_port = {
	prompt() {
		view.prompt =
			"Remove American PC markers from non-Port space in " + game.where.join(", ") + ". " + game.count + " left."
		gen_pass()
		gen_remove_american_pc_from_non_port(game.where)
	},
	remove_pc(where) {
		remove_pc(where)
		if (--game.count === 0) {
			delete game.where
			end_strategy_card()
		}
	},
	pass() {
		delete game.where
		end_strategy_card()
	},
}

events.remove_american_pc_within_two_spaces_of_a_british_general = function (c, card) {
	play_card(c)
	game.count = card.count
	game.state = "remove_american_pc_within_two_spaces_of_a_british_general"
}

states.remove_american_pc_within_two_spaces_of_a_british_general = {
	prompt() {
		view.prompt = "Remove American PC markers within two spaces of a British general. " + game.count + " left."
		gen_pass()
		gen_remove_american_pc_within_two_spaces_of_a_british_general()
	},
	remove_pc(where) {
		remove_pc(where)
		if (--game.count === 0) {
			delete game.where
			end_strategy_card()
		}
	},
	pass() {
		delete game.where
		end_strategy_card()
	},
}

events.place_american_pc = function (c, card) {
	play_card(c)
	game.count = card.count
	game.state = "place_american_pc"
}

states.place_american_pc = {
	prompt() {
		view.prompt = "Place American PC markers. " + game.count + " left."
		gen_pass()
		gen_place_american_pc()
	},
	place_american_pc(where) {
		place_american_pc(where)
		if (--game.count === 0) {
			end_strategy_card()
		}
	},
	pass() {
		end_strategy_card()
	},
}

events.place_american_pc_in = function (c, card) {
	play_card(c)
	game.count = card.count
	game.where = card.where
	game.state = "place_american_pc_in"
}

states.place_american_pc_in = {
	prompt() {
		view.prompt = "Place American PC markers in " + game.where.join(", ") + ". " + game.count + " left."
		gen_pass()
		gen_place_american_pc_in(game.where)
	},
	place_american_pc(where) {
		place_american_pc(where)
		if (--game.count === 0) {
			delete game.where
			end_strategy_card()
		}
	},
	pass() {
		delete game.where
		end_strategy_card()
	},
}

events.lord_sandwich_coastal_raids = function (c, card) {
	play_card(c)
	game.state = "lord_sandwich_coastal_raids"
	game.count = 2
	game.where = NOWHERE
}

states.lord_sandwich_coastal_raids = {
	prompt() {
		view.prompt = "Remove two or flip one American PC in a port space."
		gen_pass()
		gen_lord_sandwich_coastal_raids(game.where)
	},
	place_british_pc(where) {
		place_british_pc(where)
		end_strategy_card()
	},
	remove_pc(where) {
		game.where = where
		remove_pc(where)
		if (--game.count === 0)
			end_strategy_card()
	},
	pass() {
		end_strategy_card()
	},
}

function gen_lord_sandwich_coastal_raids(first_removed) {
	for (let space of all_spaces) {
		if (SPACES[space].port)
			if (has_american_pc(space) && has_no_american_unit(space))
				gen_action("remove_pc", space)
		if (space === first_removed)
			gen_action("place_british_pc", space)
	}
}

events.remove_american_cu = function (c, card) {
	play_card(c)
	game.state = "remove_american_cu"
}

states.remove_american_cu = {
	prompt() {
		view.prompt = "Remove one American CU from any space."
		gen_pass()
		gen_remove_american_cu()
	},
	remove_cu(where) {
		if (count_american_cu(where) > 0)
			remove_american_cu(where, 1)
		else
			remove_french_cu(where, 1)
		end_strategy_card()
	},
	pass() {
		end_strategy_card()
	},
}

function gen_remove_american_cu() {
	for (let space of all_spaces) {
		if (has_american_or_french_cu(space))
			gen_action("remove_cu", space)
	}
}

events.remove_british_cu = function (c, card) {
	play_card(c)
	game.state = "remove_british_cu"
	game.count = card.count
}

states.remove_british_cu = {
	prompt() {
		view.prompt = "Remove " + game.count + " British CU from any space."
		gen_pass()
		gen_remove_british_cu()
	},
	remove_cu(where) {
		remove_british_cu(where, 1)
		if (--game.count === 0)
			end_strategy_card()
	},
	pass() {
		end_strategy_card()
	},
}

function gen_remove_british_cu() {
	for (let space of all_spaces) {
		if (has_british_cu(space))
			gen_action("remove_cu", space)
	}
}

events.pennsylvania_and_new_jersey_line_mutinies = function (c, card) {
	play_card(c)
	game.pennsylvania_and_new_jersey_line_mutinies = true
	game.state = "pennsylvania_and_new_jersey_line_mutinies"
	game.count = 2
	game.where = NOWHERE
}

states.pennsylvania_and_new_jersey_line_mutinies = {
	prompt() {
		view.prompt = "Remove two American CUs from the map, one each from two different spaces."
		gen_pass()
		gen_pennsylvania_and_new_jersey_line_mutinies(game.where)
	},
	remove_cu(where) {
		if (count_american_cu(where) > 0)
			remove_american_cu(where, 1)
		else
			remove_french_cu(where, 1)
		game.where = where
		if (--game.count === 0)
			end_strategy_card()
	},
	pass() {
		end_strategy_card()
	},
}

function gen_pennsylvania_and_new_jersey_line_mutinies(first_removed) {
	for (let space of all_spaces) {
		if (has_american_or_french_cu(space))
			if (space !== first_removed)
				gen_action("remove_cu", space)
	}
}

events.john_glovers_marblehead_regiment = function (c, card) {
	play_card(c)
	game.state = "john_glovers_marblehead_regiment_who"
	game.count = 3 // strategy rating for gen_activate_general
}

states.john_glovers_marblehead_regiment_who = {
	prompt() {
		view.prompt = "Activate an American general."
		gen_activate_general()
	},
	select_general(g) {
		goto_ops_general_move(g, true)
	},
}

events.declaration_of_independence = function (c, card) {
	play_card(c)
	game.last_active = game.active
	game.active = P_AMERICA
	game.doi = THE_13_COLONIES.slice()
	game.state = "declaration_of_independence"
}

states.declaration_of_independence = {
	prompt() {
		view.prompt = "Declaration of Independence: Place 1 PC marker in each of the 13 colonies. "
		view.prompt += game.doi.length + " left."
		gen_pass()
		gen_place_american_pc_in(game.doi)
	},
	place_american_pc(space) {
		let colony = SPACES[space].colony
		set_delete(game.doi, colony)
		place_american_pc(space)
		if (game.doi.length === 0)
			end_declaration_of_independence()
	},
	pass() {
		end_declaration_of_independence()
	},
}

function end_declaration_of_independence() {
	game.active = game.last_active
	delete game.last_active
	delete game.doi
	end_strategy_card()
}

function goto_george_washington_captured() {
	/* Save all the state we clobber during the interrupt. */
	game.last_state = game.state
	game.last_active = game.active
	game.last_count = game.count

	game.state = "george_washington_captured"
	game.active = P_BRITAIN
	game.count = 5
}

states.george_washington_captured = {
	prompt() {
		view.prompt = "George Washington is captured! Remove American PC markers. " + game.count + " left."
		gen_pass()
		gen_remove_american_pc()
	},
	remove_pc(where) {
		remove_pc(where)
		if (--game.count === 0) {
			end_george_washington_captured()
		}
	},
	pass() {
		end_george_washington_captured()
	},
}

function end_george_washington_captured() {
	/* Restore previous state. */
	game.state = game.last_state
	game.count = game.last_count
	game.active = game.last_active
	delete game.last_state
	delete game.last_active
	delete game.last_count
}

function do_event(c) {
	let card = CARDS[c]
	if (card.event in events)
		events[card.event](c, card)
	else
		throw new Error("Event not implemented yet: " + card.event)
}

/* BATTLE */

function can_retreat_before_battle(where) {
	if (game.did_intercept)
		return false
	// can't retreat if attempted (successful or not) interception!
	let g = find_american_or_french_general(where)
	if (g && !has_general_moved(g))
		return true
	return false
}

function goto_start_battle(from, where) {
	clear_undo()
	game.attacker = game.active
	game.attack_from = from
	game.british_losses = 0
	game.where = where
	game.a_bonus = 0
	game.b_bonus = 0
	if (game.active === P_BRITAIN && can_retreat_before_battle(where))
		goto_retreat_before_battle()
	else
		goto_play_attacker_battle_card()
}

function goto_retreat_before_battle() {
	game.active = P_AMERICA
	game.who = find_american_or_french_general(game.where)
	game.state = "retreat_before_battle"
}

states.retreat_before_battle = {
	prompt() {
		view.prompt = "Attempt retreat before battle?"
		gen_pass()
		gen_defender_retreat()
	},
	move(to) {
		let agility = GENERALS[game.who].agility
		if (GENERALS[game.who].bonus)
			agility += 2
		let roll = roll_d6()
		if (roll <= agility) {
			logp("successfully retreated before battle: " + roll + " <= " + agility)
			pickup_max_american_cu(game.where)
			move_army(game.who, game.where, to)
			goto_remove_general_after_retreat_before_battle(to)
		} else {
			logp("failed to retreat before battle: " + roll + " > " + agility)
			end_retreat_before_battle()
		}
	},
	pass() {
		end_retreat_before_battle()
	},
}

function goto_remove_general_after_retreat_before_battle(to) {
	if (count_friendly_generals(to) > 1) {
		game.state = "remove_general_after_retreat_before_battle"
		game.save_where = game.where
		game.where = to
	} else {
		end_remove_general_after_retreat_before_battle()
	}
}

states.remove_general_after_retreat_before_battle = {
	prompt() {
		view.prompt = "Remove a general to the reinforcements box."
		gen_remove_general()
	},
	select_general(g) {
		if (game.active === P_BRITAIN)
			move_general(g, BRITISH_REINFORCEMENTS)
		else
			move_general(g, AMERICAN_REINFORCEMENTS)
		game.where = game.save_where
		delete game.save_where
		end_remove_general_after_retreat_before_battle()
	},
}

function end_remove_general_after_retreat_before_battle() {
	let b_cu = count_british_cu(game.where)
	let a_cu = count_american_and_french_cu(game.where)
	if (a_cu === 0) {
		end_battle()
	} else if (b_cu >= 4 && a_cu === 1) {
		overrun(game.where)
		end_battle()
	} else {
		end_retreat_before_battle()
	}
}

function can_defender_retreat(to) {
	if (to === game.attack_from)
		return false
	if (has_enemy_pc(to))
		return false
	if (has_enemy_cu(to))
		return false
	return true
}

function can_attacker_retreat() {
	let to = game.attack_from
	if (has_enemy_pc(to))
		return false
	if (has_enemy_cu(to))
		return false
	return true
}

function gen_defender_retreat() {
	let from = game.where
	for (let to of SPACES[from].adjacent) {
		if (can_defender_retreat(to))
			gen_action("move", to)
	}
	if (game.active === P_BRITAIN) {
		let can_sea_retreat = false
		if (is_non_blockaded_port(from)) {
			if (is_fortified_port(from)) {
				if (has_british_pc(from) && is_non_blockaded_port(from))
					can_sea_retreat = true
			} else {
				can_sea_retreat = true
			}
		}
		if (can_sea_retreat) {
			for (let to of all_spaces) {
				if (to !== from && is_non_blockaded_port(to)) {
					if (!has_american_pc(to) && !has_american_or_french_cu(to)) {
						gen_action("move", to)
					}
				}
			}
		}
	}
}

function gen_attacker_retreat() {
	if (can_attacker_retreat())
		gen_action("move", game.attack_from)
}

function end_retreat_before_battle() {
	game.who = NOBODY
	goto_play_attacker_battle_card()
}

function goto_play_attacker_battle_card() {
	game.active = game.attacker
	game.state = "play_attacker_battle_card"
}

states.play_attacker_battle_card = {
	prompt() {
		view.prompt = "Attack: Play or discard event for DRM."
		gen_pass()
		gen_battle_card()
	},
	card_battle_play(c) {
		play_card(c, "for +2 DRM")
		if (game.active === P_BRITAIN) {
			if (CARDS[c].event === "remove_benedict_arnold")
				remove_benedict_arnold()
			game.b_draw_after_battle = true
			game.b_bonus += 2
		} else {
			game.a_draw_after_battle = true
			game.a_bonus += 2
		}
		goto_play_defender_battle_card()
	},
	card_battle_discard(c) {
		discard_card(c, "for +1 DRM")
		if (game.active === P_BRITAIN) {
			game.b_draw_after_battle = true
			game.b_bonus += 1
		} else {
			game.a_draw_after_battle = true
			game.a_bonus += 1
		}
		goto_play_defender_battle_card()
	},
	pass() {
		goto_play_defender_battle_card()
	},
}

function goto_play_defender_battle_card() {
	game.state = "play_defender_battle_card"
	game.active = ENEMY[game.attacker]
}

states.play_defender_battle_card = {
	prompt() {
		view.prompt = "Defend: Play or discard event for DRM."
		gen_pass()
		gen_battle_card()
	},
	card_battle_play(c) {
		play_card(c, "for +2 DRM")
		if (game.active === P_BRITAIN) {
			if (CARDS[c].event === "remove_benedict_arnold")
				remove_benedict_arnold()
			game.b_draw_after_battle = true
			game.b_bonus += 2
		} else {
			game.a_draw_after_battle = true
			game.a_bonus += 2
		}
		resolve_battle()
	},
	card_battle_discard(c) {
		discard_card(c, "for +1 DRM")
		if (game.active === P_BRITAIN) {
			game.b_draw_after_battle = true
			game.b_bonus += 1
		} else {
			game.a_draw_after_battle = true
			game.a_bonus += 1
		}
		resolve_battle()
	},
	pass() {
		resolve_battle()
	},
}

function gen_battle_card() {
	for (let c of active_hand()) {
		let card = CARDS[c]
		if (game.active === P_BRITAIN) {
			switch (card.type) {
				case "british-battle":
				case "british-event-or-battle":
					gen_action("card_battle_play", c)
					break
				case "british-event":
				case "american-event":
				case "american-battle":
					gen_action("card_battle_discard", c)
					break
			}
		} else {
			switch (card.type) {
				case "british-battle":
				case "british-event-or-battle":
				case "british-event":
				case "american-event":
					gen_action("card_battle_discard", c)
					break
				case "american-battle":
					gen_action("card_battle_play", c)
					break
			}
		}
	}
}

function roll_loser_combat_losses(log) {
	let roll = roll_d6()
	let losses = 0
	log.push("Loser Combat Loss Roll: " + roll)
	switch (roll) {
		case 1:
		case 2:
		case 3:
			losses = 1
			break
		case 4:
		case 5:
			losses = 2
			break
		case 6:
			losses = 3
			break
	}
	return losses
}

function roll_winner_combat_losses(log, losing_general) {
	let agility = losing_general ? GENERALS[losing_general].agility : 0
	let roll = roll_d6()
	log.push("Enemy Agility Rating: " + agility)
	log.push("Winner Combat Loss Roll: " + roll)
	let losses = 0
	switch (agility) {
		case 0:
			losses = roll === 1 ? 1 : 0
			break
		case 1:
			losses = roll <= 2 ? 1 : 0
			break
		case 2:
			losses = roll <= 3 ? 1 : 0
			break
		case 3:
			losses = roll <= 4 ? 1 : 0
			break
	}
	return losses
}

function apply_british_combat_losses(max) {
	let n = Math.min(count_british_cu(game.where), max)
	remove_british_cu(game.where, n)
	return n
}

function apply_american_combat_losses(max) {
	let n = Math.min(count_american_cu(game.where), max)
	remove_american_cu(game.where, n)
	return n
}

function apply_french_combat_losses(max) {
	let n = Math.min(count_french_cu(game.where), max)
	remove_french_cu(game.where, n)
	return n
}

function apply_american_and_french_combat_losses(max) {
	let n = apply_american_combat_losses(max)
	if (n < max)
		n += apply_french_combat_losses(max - n)
	return n
}

function resolve_battle() {
	let a_log = []
	let b_log = []

	game.active = ENEMY[game.active]
	let b_g = find_british_general(game.where)
	let b_cu = count_british_cu(game.where)
	let a_g = find_american_or_french_general(game.where)
	let a_cu = count_american_and_french_cu(game.where)
	let b_br = 0
	let a_br = 0

	if (b_g)
		b_log.push("General: " + b_g)
	if (a_g)
		a_log.push("General: " + a_g)

	if (b_g) {
		let roll = roll_d6()
		if (roll <= 3)
			b_br = Math.min(Math.floor(GENERALS[b_g].battle / 2), b_cu)
		else
			b_br = Math.min(GENERALS[b_g].battle, b_cu)
		b_log.push("Actual Battle Rating Roll: " + roll)
	}

	if (a_g) {
		let roll = roll_d6()
		if (roll <= 3)
			a_br = Math.min(Math.floor(GENERALS[a_g].battle / 2), a_cu)
		else
			a_br = Math.min(GENERALS[a_g].battle, a_cu)
		a_log.push("Actual Battle Rating Roll: " + roll)
	}

	b_log.push("+" + b_cu + " CU")
	a_log.push("+" + a_cu + " CU")
	b_log.push("+" + b_br + " Actual Battle Rating")
	a_log.push("+" + a_br + " Actual Battle Rating")

	let b_drm = b_cu + b_br + game.b_bonus
	if (game.regulars) {
		b_log.push("+1 British Regulars' Advantage")
		b_drm += 1
	}
	if (is_non_blockaded_port(game.where)) {
		if (is_fortified_port(game.where)) {
			if (has_british_pc(game.where)) {
				b_log.push("+1 Royal Navy Support")
				b_drm += 1
			}
		} else {
			b_log.push("+1 Royal Navy Support")
			b_drm += 1
		}
	}
	if (is_british_militia(game.where)) {
		b_log.push("+1 Militia")
		b_drm += 1
	}
	if (game.b_bonus === 2)
		b_log.push("+2 Battle Card")
	else if (game.b_bonus === 1)
		b_log.push("+1 Discard of an Event Card")

	let a_drm = a_cu + a_br + game.a_bonus
	if (is_american_militia(game.where)) {
		a_log.push("+1 Militia")
		a_drm += 1
	}
	if (is_american_winter_offensive()) {
		a_log.push("+2 American Winter Offensive")
		a_drm += 2
	}
	if (game.a_bonus === 2)
		a_log.push("+2 Battle Card")
	else if (game.a_bonus === 1)
		a_log.push("+1 Discard of an Event Card")
	if (game.did_intercept) {
		a_log.push("+1 Interception")
		a_drm += 1
	}

	let b_roll = roll_d6()
	let a_roll = roll_d6()

	b_log.push("Battle Roll: " + b_roll)
	b_log.push("Battle Total: " + (b_roll + b_drm))
	a_log.push("Battle Roll: " + a_roll)
	a_log.push("Battle Total: " + (a_roll + a_drm))

	let victor
	if (game.active === P_BRITAIN)
		victor = b_roll + b_drm >= a_roll + a_drm ? P_BRITAIN : P_AMERICA
	else
		victor = b_roll + b_drm >= a_roll + a_drm ? P_BRITAIN : P_AMERICA

	let a_lost_cu, b_lost_cu
	if (victor === P_BRITAIN) {
		b_lost_cu = roll_winner_combat_losses(b_log, a_g)
		a_lost_cu = roll_loser_combat_losses(a_log)
	} else {
		b_lost_cu = roll_loser_combat_losses(b_log)
		a_lost_cu = roll_winner_combat_losses(a_log, b_g)
	}

	game.british_losses = apply_british_combat_losses(b_lost_cu)
	let american_losses = apply_american_and_french_combat_losses(a_lost_cu)

	b_log.push("Losses: " + game.british_losses + " CU")
	a_log.push("Losses: " + american_losses + " CU")

	// Special case: winning general with no CU on enemy PC is captured
	if (victor === P_BRITAIN) {
		if (b_g && count_british_cu(game.where) === 0 && has_american_pc(game.where))
			capture_british_general(game.where)
	} else {
		if (a_g && count_american_and_french_cu(game.where) === 0 && has_british_pc(game.where))
			capture_american_or_french_general(game.where)
	}

	log("BRITISH BATTLE REPORT:\n" + b_log.join("\n"))
	log("AMERICAN BATTLE REPORT:\n" + a_log.join("\n"))
	log(victor + " victory in " + game.where + "!")

	if (victor === P_AMERICA)
		advance_french_alliance(1)

	goto_retreat_after_battle(victor)
}

function goto_retreat_after_battle(victor) {
	if (victor === P_BRITAIN) {
		game.who = find_american_or_french_general(game.where)
		if (game.who === NOBODY && count_american_and_french_cu(game.where) === 0)
			return end_battle()
	} else {
		game.who = find_british_general(game.where)
		if (game.who === NOBODY && count_british_cu(game.where) === 0)
			return end_battle()
	}
	game.active = ENEMY[victor]
	game.state = "retreat_after_battle"
}

states.retreat_after_battle = {
	prompt() {
		view.prompt = "Retreat after battle."
		gen_action("surrender")
		if (game.active === game.attacker)
			gen_attacker_retreat()
		else
			gen_defender_retreat()
	},
	move(to) {
		logp("retreated to " + to)
		if (game.active === P_BRITAIN)
			retreat_british_army(game.where, to)
		else
			retreat_american_army(game.where, to)
		if (count_friendly_generals(to) > 1)
			goto_remove_general_after_retreat(to)
		else
			end_battle()
	},
	surrender() {
		// End battle here, so if Washington is captured we can handle the interrupt state.
		let active = game.active
		let where = game.where
		end_battle()

		logp("surrendered")
		if (active === P_BRITAIN)
			surrender_british_army(where)
		else
			surrender_american_army(where)
	},
}

function end_battle() {
	game.active = game.attacker

	if (game.active === P_BRITAIN && game.congress === game.where)
		disperse_continental_congress()

	if (game.british_losses >= 3)
		lose_regular_advantage()

	// TODO: delay until end of campaign
	if (game.b_draw_after_battle)
		set_add(game.b_hand, deal_card())
	if (game.a_draw_after_battle)
		set_add(game.a_hand, deal_card())

	delete game.did_intercept
	delete game.b_bonus
	delete game.a_bonus
	delete game.b_draw_after_battle
	delete game.a_draw_after_battle
	delete game.attack_from
	delete game.british_losses
	delete game.attacker
	game.where = NOWHERE
	game.who = NOBODY
	end_strategy_card()
}

/* END TURN PHASES */

function apply_single_winter_attrition(owner, space) {
	let die = roll_d6()
	log(owner[0] + " attrition roll " + die + " in " + space)
	if (die <= 3) {
		log(owner[0] + " lost 1 CU in " + space)
		remove_cu(owner, space, 1)
	}
}

function apply_winter_attrition(owner, space, n) {
	let half = Math.floor(n / 2)
	log(owner[0] + " lost " + half + " CU in " + space)
	remove_cu(owner, space, half)
}

function goto_winter_attrition_phase() {
	logbr()
	log("Winter Attrition")

	for (let space of all_spaces) {
		let wq = is_winter_quarter_space(space)
		let n_british = count_british_cu(space)
		let n_american = count_american_cu(space)
		let n_french = count_french_cu(space)
		let has_washington = is_general_at_location(WASHINGTON, space)

		if (n_british === 1 && !wq)
			apply_single_winter_attrition(BRITISH, space, has_british_general(space))
		if (n_british > 1 && !wq)
			apply_winter_attrition(BRITISH, space, n_british)

		if (n_american === 0 && n_french === 1 && !wq)
			apply_single_winter_attrition(FRENCH, space, has_american_or_french_general(space))
		if (n_american === 0 && n_french > 1 && !wq)
			apply_winter_attrition(FRENCH, space, n_french)

		if (n_american === 1 && n_french === 0)
			apply_single_winter_attrition(AMERICAN, space, has_american_or_french_general(space))
		if (n_american > 1 && n_french === 0) {
			let n = n_american
			if (has_washington && wq)
				n = Math.max(0, n - 5)
			apply_winter_attrition(AMERICAN, space, n)
		}

		if (n_american > 0 && n_french > 0) {
			let n = n_american + n_french
			if (has_washington && wq)
				n = Math.max(0, n - 5)
			let half = Math.floor(n / 2)

			// TODO: let player choose (but why would he ever choose the french?)
			let lose_american = Math.min(half, n_american)
			log(owner[0] + " lost " + lose_american + " American CU  in " + space)
			remove_american_cu(space, n_american)
			half -= lose_american
			n_american -= lose_american

			if (half > 0) {
				log(owner[0] + " lost " + half + " French CU in " + space)
				remove_french_cu(space, half)
			}
		}
	}

	if (automatic_victory())
		return

	goto_french_naval_phase()
}

function goto_french_naval_phase() {
	if (game.french_navy !== -1) {
		game.active = P_AMERICA
		game.state = "place_french_navy"
	} else {
		goto_political_control_phase()
	}
}

function gen_place_french_navy() {
	gen_action("place_navy", "Sea1")
	gen_action("place_navy", "Sea2")
	gen_action("place_navy", "Sea3")
	gen_action("place_navy", "Sea4")
	gen_action("place_navy", "Sea5")
	gen_action("place_navy", "Sea6")
	gen_action("place_navy", "Sea7")
}

states.place_french_navy_trigger = {
	prompt() {
		view.prompt = "Place the French Navy in a blockade zone."
		gen_place_french_navy()
	},
	place_navy(zone) {
		logp("placed French Navy.")
		game.french_navy = zone
		game.active = game.save_active
		delete game.save_active
		end_strategy_card()
	},
}

states.place_french_navy = {
	prompt() {
		view.prompt = "Place the French Navy in a blockade zone."
		gen_place_french_navy()
	},
	place_navy(zone) {
		logp("placed French Navy.")
		game.french_navy = zone
		goto_political_control_phase()
	},
}

function place_pc_markers_segment() {
	for (let space of all_spaces) {
		if (has_american_army(space)) {
			if (has_no_pc(space))
				place_american_pc(space)
			else if (has_british_pc(space))
				flip_pc(space)
		}
		if (has_british_army(space)) {
			if (has_no_pc(space))
				place_british_pc(space)
			else if (has_american_pc(space))
				flip_pc(space)
		}
	}
}

function is_american_pc_root(space) {
	if (has_no_pc(space) && has_no_british_cu(space))
		return true
	if (game.congress === space)
		return true
	if (has_american_pc(space)) {
		if (has_american_or_french_cu(space))
			return true
		if (has_american_or_french_general(space))
			return true
	}
	return false
}

function is_british_pc_root(space) {
	if (has_no_pc(space) && !has_american_or_french_cu(space) && !has_american_or_french_general(space))
		return true
	if (has_british_pc(space)) {
		if (is_port(space))
			return true
		if (has_british_cu(space))
			return true
	}
	return false
}

function is_american_pc_path(space) {
	if (has_american_pc(space))
		return !has_british_army(space)
	return false
}

function is_british_pc_path(space) {
	if (has_british_pc(space))
		return !has_american_army(space)
	return false
}

function spread_american_path(seen, from) {
	// TODO: BFS
	for (let to of SPACES[from].adjacent) {
		if (set_has(seen, to))
			continue
		if (is_american_pc_path(to)) {
			set_add(seen, to)
			spread_american_path(seen, to)
		}
	}
}

function spread_british_path(seen, from) {
	// TODO: BFS
	for (let to of SPACES[from].adjacent) {
		if (set_has(seen, to))
			continue
		if (is_british_pc_path(to)) {
			set_add(seen, to)
			spread_british_path(seen, to)
		}
	}
}

function remove_isolated_american_pc_segment() {
	log("Removed isolated American PC")
	let seen = []
	for (let space of all_spaces) {
		if (is_american_pc_root(space)) {
			set_add(seen, space)
			spread_american_path(seen, space)
		}
	}
	for (let space of all_spaces)
		if (has_american_pc(space) && !set_has(seen, space))
			remove_pc(space)
}

function remove_isolated_british_pc_segment() {
	log("Removed isolated British PC")
	let seen = []
	for (let space of all_spaces) {
		if (is_british_pc_root(space)) {
			set_add(seen, space)
			spread_british_path(seen, space)
		}
	}
	for (let space of all_spaces)
		if (has_british_pc(space) && !set_has(seen, space))
			remove_pc(space)
}

function gen_place_continental_congress() {
	let n = 0
	for (let space of all_spaces) {
		if (SPACES[space].colony !== "CA") {
			if (has_american_pc(space) && has_no_british_playing_piece(space)) {
				gen_action("place_continental_congress", space)
				++n
			}
		}
	}
	return n
}

function goto_political_control_phase() {
	if (game.congress === CONTINENTAL_CONGRESS_DISPERSED) {
		game.active = P_AMERICA
		game.state = "return_continental_congress"
	} else {
		goto_political_control_phase_2()
	}
}

states.return_continental_congress = {
	prompt() {
		view.prompt = "Return Continental Congress to a space in the 13 colonies."
		if (gen_place_continental_congress() === 0)
			gen_pass()
	},
	place_continental_congress(where) {
		game.congress = where
		goto_political_control_phase_2()
	},
	pass() {
		goto_political_control_phase_2()
	},
}

function goto_political_control_phase_2() {
	// TODO: manually place and remove
	place_pc_markers_segment()
	remove_isolated_american_pc_segment()
	remove_isolated_british_pc_segment()
	goto_end_phase()
}

states.european_war = {
	prompt() {
		view.prompt = "European War: Remove 2 British CU from any spaces. " + game.count + " left."
		gen_pass()
		gen_remove_british_cu()
	},
	remove_cu(where) {
		remove_british_cu(where, 1)
		if (--game.count === 0)
			goto_end_phase()
	},
	pass() {
		goto_end_phase()
	},
}

function norths_government_falls() {
	let n_american = 0
	for (let c = 0; c <= 13; ++c)
		if (get_colony_control(c) === PC_AMERICAN)
			++n_american

	if (n_american >= 7)
		game.result = P_AMERICA
	else
		game.result = P_BRITAIN

	game.victory = "North's Government Falls: " + game.result + " Victory!"
	game.active = "None"
	game.state = "game_over"

	log(game.victory)
}

function goto_end_phase() {
	if (game.french_alliance_triggered && !game.european_war) {
		game.european_war = true
		game.count = 2
		game.active = P_AMERICA
		game.state = "european_war"
		game.reshuffle = true
		return
	}

	if ((game.war_ends && game.year >= CARDS[game.war_ends].year) || game.year === 1783)
		return norths_government_falls()

	delete game.pennsylvania_and_new_jersey_line_mutinies
	game.a_queue = game.b_queue = 0
	game.year += 1
	goto_start_year()
}

states.game_over = {
	prompt() {
		view.prompt = game.victory
	},
}

/* CLIENT/SERVER COMMS */

function gen_action(action, argument) {
	if (argument === undefined) {
		view.actions.action = 1
	} else {
		if (!(action in view.actions))
			view.actions[action] = []
		set_add(view.actions[action], argument)
	}
}

exports.scenarios = [ "Standard" ]

exports.roles = [ P_BRITAIN, P_AMERICA ]

exports.setup = function (seed, scenario, options) {
	setup_game(seed)
	return game
}

exports.action = function (state, current, action, arg) {
	game = state

	Object.seal(game) // don't allow adding properties!

	// TODO: check against action list
	if (current === game.active) {
		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 game
}

exports.view = function (state, current) {
	game = state

	view = {
		year: state.year,
		war_ends: state.war_ends,
		reinforcements: state.reinforcements,
		french_alliance: state.french_alliance,
		european_war: state.european_war,
		congress: state.congress,
		french_navy: state.french_navy,
		regulars: state.regulars,

		loc: state.loc,
		spc: state.spc,

		a_cards: state.a_hand.length,
		b_cards: state.b_hand.length,
		a_queue: state.a_queue,
		b_queue: state.b_queue,
		last_played: state.last_played,
		who: state.who,
		log: state.log,
	}

	if (state.pennsylvania_and_new_jersey_line_mutinies)
		view.pennsylvania_and_new_jersey_line_mutinies = true

	if (current === P_AMERICA)
		view.hand = state.a_hand
	else if (current === P_BRITAIN)
		view.hand = state.b_hand
	else
		view.hand = []

	if (current === state.active) {
		view.actions = {}
		states[game.state].prompt()
		if (game.undo && game.undo.length > 0)
			view.actions.undo = 1
		else
			view.actions.undo = 0
	} else {
		let inactive = states[game.state].inactive
		if (typeof inactive !== "string")
			inactive = game.state
		view.prompt = "Waiting for " + game.active + " to " + inactive + "."
	}

	return view
}

/* COMMON LIBRARY */

function log(s) {
	game.log.push(s)
}

function logp(s) {
	game.log.push(game.active + " " + s)
}

function logbr() {
	if (game.log.length > 0 && game.log[game.log.length - 1] !== "")
		game.log.push("")
}

function clear_undo() {
	if (game.undo) {
		game.undo.length = 0
	}
}

function push_undo() {
	if (game.undo) {
		let copy = {}
		for (let k in game) {
			let v = game[k]
			if (k === "undo")
				continue
			else if (k === "log")
				v = v.length
			else if (typeof v === "object" && v !== null)
				v = object_copy(v)
			copy[k] = v
		}
		game.undo.push(copy)
	}
}

function pop_undo() {
	if (game.undo) {
		let save_log = game.log
		let save_undo = game.undo
		game = save_undo.pop()
		save_log.length = game.log
		game.log = save_log
		game.undo = save_undo
	}
}

function random(range) {
	// An MLCG using integer arithmetic with doubles.
	// https://www.ams.org/journals/mcom/1999-68-225/S0025-5718-99-00996-5/S0025-5718-99-00996-5.pdf
	// m = 2**35 − 31
	return (game.seed = game.seed * 200105 % 34359738337) % range
}

function random_bigint(range) {
	// Largest MLCG that will fit its state in a double.
	// Uses BigInt for arithmetic, so is an order of magnitude slower.
	// https://www.ams.org/journals/mcom/1999-68-225/S0025-5718-99-00996-5/S0025-5718-99-00996-5.pdf
	// m = 2**53 - 111
	return (game.seed = Number(BigInt(game.seed) * 5667072534355537n % 9007199254740881n)) % range
}

function shuffle(list) {
	// Fisher-Yates shuffle
	for (let i = list.length - 1; i > 0; --i) {
		let j = random(i + 1)
		let tmp = list[j]
		list[j] = list[i]
		list[i] = tmp
	}
}

function shuffle_bigint(list) {
	// Fisher-Yates shuffle
	for (let i = list.length - 1; i > 0; --i) {
		let j = random_bigint(i + 1)
		let tmp = list[j]
		list[j] = list[i]
		list[i] = tmp
	}
}

// Fast deep copy for objects without cycles
function object_copy(original) {
	if (Array.isArray(original)) {
		let n = original.length
		let copy = new Array(n)
		for (let i = 0; i < n; ++i) {
			let v = original[i]
			if (typeof v === "object" && v !== null)
				copy[i] = object_copy(v)
			else
				copy[i] = v
		}
		return copy
	} else {
		let copy = {}
		for (let i in original) {
			let v = original[i]
			if (typeof v === "object" && v !== null)
				copy[i] = object_copy(v)
			else
				copy[i] = v
		}
		return copy
	}
}

// Array remove and insert (faster than splice)

function array_remove(array, index) {
	let n = array.length
	for (let i = index + 1; i < n; ++i)
		array[i - 1] = array[i]
	array.length = n - 1
}

function array_remove_item(array, item) {
	let n = array.length
	for (let i = 0; i < n; ++i)
		if (array[i] === item)
			return array_remove(array, i)
}

function array_insert(array, index, item) {
	for (let i = array.length; i > index; --i)
		array[i] = array[i - 1]
	array[index] = item
}

function array_remove_pair(array, index) {
	let n = array.length
	for (let i = index + 2; i < n; ++i)
		array[i - 2] = array[i]
	array.length = n - 2
}

function array_insert_pair(array, index, key, value) {
	for (let i = array.length; i > index; i -= 2) {
		array[i] = array[i-2]
		array[i+1] = array[i-1]
	}
	array[index] = key
	array[index+1] = value
}

// Set as plain sorted array

function set_clear(set) {
	set.length = 0
}

function set_has(set, item) {
	let a = 0
	let b = set.length - 1
	while (a <= b) {
		let m = (a + b) >> 1
		let x = set[m]
		if (item < x)
			b = m - 1
		else if (item > x)
			a = m + 1
		else
			return true
	}
	return false
}

function set_add(set, item) {
	let a = 0
	let b = set.length - 1
	while (a <= b) {
		let m = (a + b) >> 1
		let x = set[m]
		if (item < x)
			b = m - 1
		else if (item > x)
			a = m + 1
		else
			return
	}
	array_insert(set, a, item)
}

function set_delete(set, item) {
	let a = 0
	let b = set.length - 1
	while (a <= b) {
		let m = (a + b) >> 1
		let x = set[m]
		if (item < x)
			b = m - 1
		else if (item > x)
			a = m + 1
		else {
			array_remove(set, m)
			return
		}
	}
}

function set_toggle(set, item) {
	let a = 0
	let b = set.length - 1
	while (a <= b) {
		let m = (a + b) >> 1
		let x = set[m]
		if (item < x)
			b = m - 1
		else if (item > x)
			a = m + 1
		else {
			array_remove(set, m)
			return
		}
	}
	array_insert(set, a, item)
}

// Map as plain sorted array of key/value pairs

function map_clear(map) {
	map.length = 0
}

function map_has(map, key) {
	let a = 0
	let b = (map.length >> 1) - 1
	while (a <= b) {
		let m = (a + b) >> 1
		let x = map[m<<1]
		if (key < x)
			b = m - 1
		else if (key > x)
			a = m + 1
		else
			return true
	}
	return false
}

function map_get(map, key, missing) {
	let a = 0
	let b = (map.length >> 1) - 1
	while (a <= b) {
		let m = (a + b) >> 1
		let x = map[m<<1]
		if (key < x)
			b = m - 1
		else if (key > x)
			a = m + 1
		else
			return map[(m<<1)+1]
	}
	return missing
}

function map_set(map, key, value) {
	let a = 0
	let b = (map.length >> 1) - 1
	while (a <= b) {
		let m = (a + b) >> 1
		let x = map[m<<1]
		if (key < x)
			b = m - 1
		else if (key > x)
			a = m + 1
		else {
			map[(m<<1)+1] = value
			return
		}
	}
	array_insert_pair(map, a<<1, key, value)
}

function map_delete(map, key) {
	let a = 0
	let b = (map.length >> 1) - 1
	while (a <= b) {
		let m = (a + b) >> 1
		let x = map[m<<1]
		if (key < x)
			b = m - 1
		else if (key > x)
			a = m + 1
		else {
			array_remove_pair(map, m<<1)
			return
		}
	}
}