Washington's War: DO NOT PUBLISH.

1 files changed, 3509 insertions, 0 deletions

diff --git a/rules.js b/rules.js
new file mode 100644
index 0000000..09f5a11
--- /dev/null
+++ b/rules.js
@@ -0,0 +1,3509 @@
+"use strict";
+
+// TODO: campaign messed up who is who after battle
+// TODO: retreat with 0 CU after battle
+
+exports.scenarios = [
+	"Historical"
+];
+
+const CARDS = require('./cards');
+const DATA = require('./data');
+const SPACES = DATA.SPACES;
+const COLONIES = DATA.COLONIES;
+const GENERALS = DATA.GENERALS;
+const BLOCKADE = DATA.BLOCKADE;
+const PATH_INDEX = DATA.PATH_INDEX;
+const PATH_NAME = DATA.PATH_NAME;
+const PATH_TYPE = DATA.PATH_TYPE;
+
+const BRITISH = 'British';
+const AMERICAN = 'American';
+const FRENCH = 'French';
+
+const BRITISH_GENERALS = [ "Burgoyne", "Carleton", "Clinton", "Cornwallis", "Howe" ];
+const AMERICAN_GENERALS = [ "Arnold", "Gates", "Greene", "Lafayette", "Lee", "Lincoln", "Washington", "Rochambeau" ];
+const WASHINGTON = "Washington";
+const ROCHAMBEAU = "Rochambeau";
+const ARNOLD = "Arnold";
+
+const CAPTURED_GENERALS = "Captured Generals";
+const CONTINENTAL_CONGRESS_DISPERSED = "Continental Congress Dispersed";
+const BRITISH_REINFORCEMENTS = "British Leader Reinforcements";
+const AMERICAN_REINFORCEMENTS = "American Leader Reinforcements";
+const FRENCH_REINFORCEMENTS = "French Reinforcements";
+const TURN_TRACK = {
+	1775: "Game Turn 1775",
+	1776: "Game Turn 1776",
+	1777: "Game Turn 1777",
+	1778: "Game Turn 1778",
+	1779: "Game Turn 1779",
+	1780: "Game Turn 1780",
+	1781: "Game Turn 1781",
+	1782: "Game Turn 1782",
+	1783: "Game Turn 1783",
+};
+
+const FALMOUTH_QUEBEC = "Falmouth/Quebec";
+
+const THE_13_COLONIES = [ 'NH', 'NY', 'MA', 'CT', 'RI', 'PA', 'NJ', 'MD', 'DE', 'VA', 'NC', 'SC', 'GA' ];
+const SOUTH_OF_WINTER_ATTRITION_LINE = [ 'NC', 'SC', 'GA' ];
+
+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 ENEMY = { "American": BRITISH, "British": AMERICAN };
+
+const default_options = {};
+
+let states = {};
+let events = {};
+
+let game;
+
+function random(n) {
+	return Math.floor(((game.seed = game.seed * 48271 % 0x7fffffff) / 0x7fffffff) * n);
+}
+
+function log(s) {
+	game.log.push(s);
+}
+
+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 remove_from_array(array, item) {
+	let i = array.indexOf(item);
+	if (i >= 0)
+		array.splice(i, 1);
+}
+
+function setup_game(seed) {
+	game = {
+		seed: seed,
+		year: 1775,
+		congress: "Philadelphia",
+		french_alliance: 0,
+		french_alliance_triggered: false,
+		european_war: false,
+		french_navy: FRENCH_REINFORCEMENTS,
+		regulars: true,
+		war_ends: 0,
+		played_british_reinforcements: 0,
+		played_american_reinforcements: [],
+
+		pc: {},
+		generals: {},
+		moved: {},
+		cu: [],
+		control: {},
+
+		deck: create_deck(),
+		discard: [],
+		reshuffle: false,
+		a_hand: [],
+		b_hand: [],
+		a_queue: 0,
+		b_queue: 0,
+
+		log: [],
+		undo: [],
+
+		prompt: null,
+		actions: [],
+	}
+
+	function spawn_unit(owner, location, pc, cu, name) {
+		if (pc)
+			game.pc[location] = owner;
+		if (name) {
+			game.generals[name] = {
+				location: location,
+			}
+		}
+		if (cu > 0) {
+			game.cu.push({
+				owner: owner,
+				location: location,
+				count: cu,
+				moved: 0,
+			});
+		}
+	}
+
+	function british(place, pc, cu, ld) { spawn_unit(BRITISH, place, pc, cu, ld); }
+	function american(place, pc, cu, ld) { spawn_unit(AMERICAN, place, pc, cu, ld); }
+	function french(place, pc, cu, ld) { spawn_unit(FRENCH, place, pc, cu, ld); }
+
+	british("Quebec", true, 2, "Carleton");
+	british("Montreal", true);
+	british("Fort Detroit", true, 1);
+	british("Boston", true, 5, "Howe");
+	british("Norfolk", true);
+	british("Gilbert Town", true);
+	british("Wilmington NC", true);
+	british("Ninety Six", true);
+
+	american("Lexington Concord", true, 5, "Washington");
+	american("Newport", false, 2, "Greene");
+	american("Charleston", true, 2);
+	american("Philadelphia", true);
+
+	british(BRITISH_REINFORCEMENTS, false, 0, "Burgoyne");
+	british(BRITISH_REINFORCEMENTS, false, 0, "Clinton");
+	british(BRITISH_REINFORCEMENTS, false, 0, "Cornwallis");
+
+	american(AMERICAN_REINFORCEMENTS, false, 0, "Arnold");
+	american(AMERICAN_REINFORCEMENTS, false, 0, "Lincoln");
+	american(AMERICAN_REINFORCEMENTS, false, 0, "Gates");
+	american(AMERICAN_REINFORCEMENTS, false, 0, "Lee");
+	american(AMERICAN_REINFORCEMENTS, false, 0, "Lafayette");
+
+	french(FRENCH_REINFORCEMENTS, false, 5, "Rochambeau");
+
+	goto_committees_of_correspondence();
+}
+
+/* GAME STATE */
+
+function create_deck() {
+	let 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;
+		deck.push(i);
+	}
+	return deck;
+}
+
+function reshuffle_deck() {
+	game.log.push("The deck is reshuffled.");
+	game.reshuffle = false;
+	game.deck = game.deck.concat(game.discard);
+	game.discard = [];
+}
+
+function roll_d6() {
+	return random(6) + 1;
+}
+
+function deal_card() {
+	if (game.deck.length == 0)
+		reshuffle_deck();
+	let i = random(game.deck.length);
+	let c = game.deck[i];
+	game.deck.splice(i, 1);
+	return c;
+}
+
+function last_discard() {
+	if (game.discard.length > 0)
+		return game.discard[game.discard.length-1];
+	return null;
+}
+
+function active_hand() {
+	return (game.active == AMERICAN) ? game.a_hand : game.b_hand;
+}
+
+function play_card(c, reason) {
+	if (reason)
+		game.log.push(game.active[0] + " plays [" + c + ": " + CARDS[c].title + "] " + reason);
+	else
+		game.log.push(game.active[0] + " plays [" + c + ": " + CARDS[c].title + "]");
+	if (CARDS[c].reshuffle == 'if_played')
+		game.reshuffle = true;
+	remove_from_array(active_hand(), c);
+	game.last_played = c;
+	if (!CARDS[c].once)
+		game.discard.push(c);
+	else
+		game.log.push("Card " + c + " removed from game.");
+}
+
+function discard_card_from_hand(hand, c) {
+	remove_from_array(hand, c);
+	game.discard.push(c);
+	if (CARDS[c].reshuffle == 'if_discarded')
+		game.reshuffle = true;
+	game.log.push(game.active[0] + " discards [" + c + ": " + CARDS[c].title + "]");
+}
+
+function discard_card(c, reason) {
+	game.last_played = c;
+	discard_card_from_hand(active_hand(), c);
+	if (reason)
+		game.log.push(game.active[0] + " discards [" + c + ": " + CARDS[c].title + "] " + reason);
+	else
+		game.log.push(game.active[0] + " discards [" + c + ": " + CARDS[c].title + "]");
+}
+
+function can_exchange_for_discard(c) {
+	if (game.did_discard_event) {
+		if (game.active == BRITISH)
+			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;
+	}
+	return true;
+}
+
+function can_play_reinforcements() {
+	if (game.active == BRITISH) {
+		if (game.played_british_reinforcements == 0) {
+			let n = count_british_cu(BRITISH_REINFORCEMENTS);
+			for (let g of BRITISH_GENERALS)
+				if (game.generals[g].location == BRITISH_REINFORCEMENTS)
+					++n;
+			return n > 0;
+		}
+		return false;
+	}
+	if (game.active == AMERICAN)
+		return game.played_american_reinforcements.length < 2;
+	return false;
+}
+
+function is_port(where) {
+	return SPACES[where].port;
+}
+
+function is_non_blockaded_port(where) {
+	if (SPACES[where].port && BLOCKADE[where] != game.french_navy)
+		return true;
+	return false;
+}
+
+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 (colony == 'GA' || colony == 'SC' || colony == 'NC')
+		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 game.control[SPACES[space].colony] == BRITISH;
+}
+
+function is_american_militia(space) {
+	return game.control[SPACES[space].colony] == AMERICAN;
+}
+
+function is_american_winter_offensive() {
+	if (game.who == WASHINGTON && game.a_hand.length == 0)
+		return true;
+	return false;
+}
+
+/* PC */
+
+function has_no_pc(space) {
+	return game.pc[space] != BRITISH && game.pc[space] != AMERICAN;
+}
+
+function has_british_pc(space) {
+	return game.pc[space] == BRITISH;
+}
+
+function has_american_pc(space) {
+	return game.pc[space] == AMERICAN;
+}
+
+function has_enemy_pc(space) {
+	if (game.active == BRITISH)
+		return has_american_pc(space);
+	else
+		return has_british_pc(space);
+}
+
+function has_no_pc(space) {
+	return game.pc[space] != BRITISH && game.pc[space] != AMERICAN;
+}
+
+function is_adjacent_to_british_pc(a) {
+	for (let b of SPACES[a].exits)
+		if (has_british_pc(b))
+			return true;
+	if (SPACES[a].port) {
+		for (let b in 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].exits)
+		if (has_american_pc(b))
+			return true;
+	return false;
+}
+
+function place_british_pc(space) {
+	game.log.push("B places PC in " + space);
+	if (game.british_pc_space_list)
+		remove_from_array(game.british_pc_space_list, space);
+	game.pc[space] = BRITISH;
+}
+
+function place_american_pc(space) {
+	game.log.push("A places PC in " + space);
+	game.pc[space] = AMERICAN;
+}
+
+function remove_pc(space) {
+	if (game.active == BRITISH)
+		game.log.push("B removes PC in " + space);
+	else
+		game.log.push("A removes PC in " + space);
+	game.pc[space] = undefined;
+}
+
+function flip_pc(space) {
+	if (game.active == BRITISH)
+		game.log.push("B flips PC in " + space);
+	else
+		game.log.push("A flips PC in " + space);
+	game.pc[space] = ENEMY[game.pc[space]];
+}
+
+function update_colony_control() {
+	for (let c in COLONIES) {
+		let control = 0;
+		for (let space of COLONIES[c]) {
+			if (game.pc[space] == BRITISH)
+				--control;
+			else if (game.pc[space] == AMERICAN)
+				++control;
+		}
+		if (control < 0)
+			game.control[c] = BRITISH;
+		else if (control > 0)
+			game.control[c] = AMERICAN;
+		else
+			game.control[c] = undefined;
+	}
+}
+
+/* CU */
+
+function find_cu(owner, space) {
+	for (let i = 0; i < game.cu.length; ++i) {
+		let cu = game.cu[i];
+		if (cu.location == space && cu.owner == owner)
+			return cu;
+	}
+	return null;
+}
+
+function find_british_cu(space) {
+	return find_cu(BRITISH, space);
+}
+
+function find_american_cu(space) {
+	return find_cu(AMERICAN, space);
+}
+
+function find_french_cu(space) {
+	return find_cu(FRENCH, space);
+}
+
+function has_british_cu(space) {
+	return find_british_cu(space) != null;
+}
+
+function has_no_british_cu(space) {
+	return !has_british_cu(space);
+}
+
+function has_american_or_french_cu(space) {
+	return find_american_cu(space) != null || find_french_cu(space) != null;
+}
+
+function has_american_cu(space) {
+	return find_american_cu(space) != null;
+}
+
+function has_french_cu(space) {
+	return find_french_cu(space) != null;
+}
+
+function has_enemy_cu(where) {
+	if (game.active == BRITISH)
+		return has_american_or_french_cu(where);
+	else
+		return has_british_cu(where);
+}
+
+function count_cu(owner, space) {
+	let cu = find_cu(owner, space);
+	return cu ? cu.count : 0;
+}
+
+function count_british_cu(where) {
+	let cu = find_british_cu(where);
+	return cu ? cu.count : 0;
+}
+
+function count_american_cu(where) {
+	let cu = find_american_cu(where);
+	return cu ? cu.count : 0;
+}
+
+function count_french_cu(where) {
+	let cu = find_french_cu(where);
+	return cu ? cu.count : 0;
+}
+
+function count_unmoved_british_cu(where) {
+	let cu = find_british_cu(where);
+	return cu ? cu.count - cu.moved : 0;
+}
+
+function count_unmoved_american_cu(where) {
+	let cu = find_american_cu(where);
+	return cu ? cu.count - cu.moved : 0;
+}
+
+function count_unmoved_french_cu(where) {
+	let cu = find_french_cu(where);
+	return cu ? cu.count - cu.moved : 0;
+}
+
+function mark_moved_cu(owner, space, moved) {
+	if (moved > 0)
+		find_cu(owner, space).moved += 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 == BRITISH)
+		return count_american_and_french_cu(where);
+	else
+		return count_british_cu(where);
+}
+
+function spawn_cu(owner, where, count) {
+	game.cu.push({owner:owner, location:where, count:count, moved:0});
+}
+
+function remove_cu(owner, where, count) {
+	if (count == 0)
+		return;
+	let cu = find_cu(owner, where);
+	if (count >= cu.count) {
+		let i = game.cu.indexOf(cu);
+		remove_from_array(game.cu, cu);
+	} else {
+		cu.count -= count;
+	}
+}
+
+function place_cu(owner, where, count) {
+	let cu = find_cu(owner, where);
+	if (!cu)
+		spawn_cu(owner, where, count);
+	else
+		cu.count += count;
+}
+
+function place_british_cu(where, count) {
+	place_cu(BRITISH, where, count);
+}
+
+function place_american_cu(where, count) {
+	place_cu(AMERICAN, where, count);
+}
+
+function place_french_cu(where, count) {
+	place_cu(FRENCH, where, count);
+}
+
+function move_cu(owner, from, to, count) {
+	if (count == 0)
+		return;
+	let from_cu = find_cu(owner, from);
+	if (count < from_cu.count) {
+		from_cu.count -= count;
+		place_cu(owner, to, count);
+	} else {
+		let to_cu = find_cu(owner, to);
+		if (to_cu) {
+			remove_cu(owner, from, from_cu.count);
+			to_cu.count += count;
+		} else {
+			from_cu.location = to;
+		}
+	}
+}
+
+function move_british_cu(from, to, count) {
+	move_cu(BRITISH, from, to, count);
+}
+
+/* GENERALS */
+
+function is_general_on_map(g) {
+	switch (game.generals[g].location) {
+	case null: /* killed */
+	case CAPTURED_GENERALS:
+	case BRITISH_REINFORCEMENTS:
+	case AMERICAN_REINFORCEMENTS:
+	case FRENCH_REINFORCEMENTS:
+		return false;
+	}
+	return true;
+}
+
+function find_british_general(where) {
+	for (let general of BRITISH_GENERALS)
+		if (game.generals[general].location == where)
+			return general;
+	return null;
+}
+
+function find_american_or_french_general(where) {
+	for (let general of AMERICAN_GENERALS)
+		if (game.generals[general].location == where)
+			return general;
+	return null;
+}
+
+function has_british_general(where) {
+	return find_british_general(where) != null;
+}
+
+function has_american_or_french_general(where) {
+	return find_american_or_french_general(where) != null;
+}
+
+function has_enemy_general(where) {
+	if (game.active == BRITISH)
+		return has_american_or_french_general(where);
+	else
+		return has_british_general(where);
+}
+
+function count_friendly_generals(where) {
+	let list;
+	if (game.active == BRITISH)
+		list = BRITISH_GENERALS;
+	else
+		list = AMERICAN_GENERALS;
+	let count = 0;
+	for (let g of list)
+		if (location_of_general(g) == where)
+			++count;
+	return count;
+}
+
+function can_activate_general(c) {
+	if (game.active == BRITISH)
+		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) {
+	game.generals[who].location = where;
+}
+
+function capture_washington() {
+	game.generals[WASHINGTON].location = null;
+
+	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);
+	game.log.push(g + " is captured!");
+	move_general(g, CAPTURED_GENERALS);
+}
+
+function capture_american_or_french_general(where) {
+	let g = find_american_or_french_general(where);
+	game.log.push(g + " is captured!");
+	if (g == WASHINGTON)
+		capture_washington();
+	else
+		move_general(g, CAPTURED_GENERALS);
+}
+
+function capture_enemy_general(where) {
+	if (game.active == BRITISH)
+		capture_american_or_french_general(where);
+	else
+		capture_british_general(where);
+}
+
+function remove_benedict_arnold() {
+	if (game.generals[ARNOLD].location) {
+		game.log.push("Arnold is removed from the game!");
+		game.generals[ARNOLD].location = null;
+	}
+}
+
+/* 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 && already_there) {
+		move_general(already_there, BRITISH_REINFORCEMENTS);
+	}
+	if (who) {
+		game.log.push("B reinforces " + where + " with " + who);
+		move_general(who, where);
+	}
+	if (count > 0) {
+		game.log.push("B reinforces " + where + " with " + count + " CU");
+		move_british_cu(BRITISH_REINFORCEMENTS, where, count);
+	}
+}
+
+function place_american_reinforcements(who, count, where) {
+	let already_there = find_american_or_french_general(where);
+	if (who && already_there) {
+		// Never replace Washington
+		if (already_there == WASHINGTON)
+			who = null;
+		else
+			move_general(already_there, AMERICAN_REINFORCEMENTS);
+	}
+	if (who) {
+		game.log.push("A reinforces " + where + " with " + who);
+		move_general(who, where);
+	}
+	game.log.push("A reinforces " + where + " with " + count + " CU");
+	place_american_cu(where, count);
+}
+
+function place_french_reinforcements(who, where) {
+	let already_there = find_american_or_french_general(where);
+	if (who && already_there) {
+		// Never replace Washington
+		if (already_there == WASHINGTON)
+			who = null;
+		else
+			move_general(already_there, AMERICAN_REINFORCEMENTS);
+	}
+	if (who) {
+		game.log.push("A reinforces " + where + " with " + who);
+		move_general(who, where);
+	}
+	game.log.push("A reinforces " + where + " with the French CU");
+	move_cu(FRENCH, FRENCH_REINFORCEMENTS, where, count_french_cu(FRENCH_REINFORCEMENTS));
+	move_cu(FRENCH, AMERICAN_REINFORCEMENTS, where, count_french_cu(AMERICAN_REINFORCEMENTS));
+}
+
+function location_of_general(g) {
+	return game.generals[g].location;
+}
+
+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_cu(BRITISH, from, to, game.carry_british);
+	if (game.carry_american > 0)
+		move_cu(AMERICAN, from, to, game.carry_american);
+	if (game.carry_french > 0)
+		move_cu(FRENCH, from, to, game.carry_french);
+	move_general(who, to);
+}
+
+function intercept_army(who, from, to) {
+	if (game.carry_british > 0)
+		move_cu(BRITISH, from, to, game.carry_british);
+	if (game.carry_american > 0)
+		move_cu(AMERICAN, from, to, game.carry_american);
+	if (game.carry_french > 0)
+		move_cu(FRENCH, from, to, game.carry_french);
+	move_general(who, to);
+}
+
+function overrun(where) {
+	game.log.push(game.active[0] + " overruns CU in " + where);
+	let cu;
+	if (game.active == BRITISH)
+		cu = find_american_cu(where) || find_french_cu(where);
+	else
+		cu = find_british_cu(where);
+	remove_cu(cu.owner, where, 1);
+}
+
+function retreat_american_army(from, to) {
+	let g = find_american_or_french_general(from);
+	if (g)
+		move_general(g, to);
+	move_cu(AMERICAN, from, to, count_american_cu(from));
+	move_cu(FRENCH, 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_cu(BRITISH, 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_cu(AMERICAN, where, count_american_cu(where));
+	remove_cu(FRENCH, where, count_french_cu(where));
+}
+
+function surrender_british_army(where) {
+	let g = find_british_general(where);
+	if (g)
+		capture_british_general(g);
+	game.british_losses += count_british_cu(where);
+	remove_cu(BRITISH, where, count_british_cu(where));
+}
+
+function disperse_continental_congress(where) {
+	game.log.push("Contintental Congress dispersed!");
+	game.congress = CONTINENTAL_CONGRESS_DISPERSED;
+	game.congress_was_dispersed = true;
+}
+
+/* MOVE GENERATORS */
+
+function gen_action(action, argument) {
+	if (!game.actions)
+		game.actions = {}
+	if (argument != undefined) {
+		if (!(action in game.actions))
+			game.actions[action] = [ argument ];
+		else
+			game.actions[action].push(argument);
+	} else {
+		game.actions[action] = 1;
+	}
+}
+
+function gen_action_undo() {
+	if (!game.actions)
+		game.actions = {}
+	if (game.undo && game.undo.length > 0)
+		game.actions.undo = 1;
+	else
+		game.actions.undo = 0;
+}
+
+function gen_pass() {
+	gen_action('pass');
+}
+
+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 in 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 = game.generals[g].location;
+		if (a in SPACES) {
+			candidates[a] = true;
+			for (let b of SPACES[a].exits) {
+				candidates[b] = true;
+				for (let c of SPACES[b].exits) {
+					candidates[c] = true;
+				}
+			}
+		}
+	}
+	for (let space in candidates)
+		if (has_american_pc(space) && has_no_american_unit(space))
+			gen_action('remove_pc', space);
+}
+
+function gen_place_american_pc() {
+	for (let space in 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");
+	log("");
+	game.active = AMERICAN;
+	game.state = 'committees_of_correspondence';
+	game.coc = THE_13_COLONIES.slice();
+}
+
+states.committees_of_correspondence = {
+	prompt: function (current) {
+		game.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: function (space) {
+		push_undo();
+		let colony = SPACES[space].colony;
+		remove_from_array(game.coc, colony);
+		place_american_pc(space);
+	},
+	pass: function () {
+		clear_undo();
+		goto_for_the_king();
+	}
+}
+
+function goto_for_the_king() {
+	log("");
+	log(".h2.british For the King");
+	log("");
+	delete game.coc;
+	game.active = BRITISH;
+	game.state = 'for_the_king';
+	game.count = 3;
+	gen_british_pc_ops_start();
+}
+
+states.for_the_king = {
+	prompt: function (current) {
+		game.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: function (space) {
+		push_undo();
+		place_british_pc(space);
+		--game.count;
+	},
+	pass: function () {
+		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 in 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 = BRITISH;
+		game.state = 'game_over';
+		game.log.push(game.victory);
+		return true;
+	}
+	if (n_british == 0) {
+		game.victory = "American Automatic Victory!";
+		game.active = "None";
+		game.result = AMERICAN;
+		game.state = 'game_over';
+		game.log.push(game.victory);
+		return true;
+	}
+	return false;
+}
+
+function goto_start_year() {
+	log("");
+	log(".h1 Year " + game.year);
+	log("");
+
+	// Prisoner exchange
+	for (let g of BRITISH_GENERALS)
+		if (game.generals[g].location == CAPTURED_GENERALS)
+			move_general(g, BRITISH_REINFORCEMENTS);
+	for (let g of AMERICAN_GENERALS)
+		if (game.generals[g].location == 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);
+	}
+
+	if (game.reshuffle)
+		reshuffle_deck();
+
+	game.a_hand = [];
+	game.b_hand = [];
+	for (let i = 0; i < 7; ++i) {
+		game.a_hand.push(deal_card());
+		game.b_hand.push(deal_card());
+	}
+
+	game.a_queue = 0;
+	game.b_queue = 0;
+	game.did_discard_event = false;
+
+	// TODO: save the played card numbers instead (rule 6.1B clarification)
+	game.played_british_reinforcements = 0;
+	game.played_american_reinforcements = [];
+	game.active = BRITISH;
+	game.state = 'british_declare_first';
+}
+
+states.british_declare_first = {
+	prompt: function (current) {
+		game.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: function (c) {
+		delete game.congress_was_dispersed;
+		game.log.push("B goes first by playing a campaign card");
+		game.active = BRITISH;
+		goto_campaign(c);
+	},
+	pass: function () {
+		if (game.congress_was_dispersed)
+			game.active = BRITISH;
+		else
+			game.active = AMERICAN;
+		game.state = 'choose_first_player';
+		delete game.congress_was_dispersed;
+	},
+}
+
+states.choose_first_player = {
+	prompt: function (current) {
+		game.prompt = "Choose who will play the first strategy card.";
+		gen_action('american_first');
+		gen_action('british_first');
+	},
+	american_first: function (c) {
+		game.log.push("A goes first");
+		goto_strategy_phase(AMERICAN);
+	},
+	british_first: function (c) {
+		game.log.push("B goes first");
+		goto_strategy_phase(BRITISH);
+	},
+}
+
+/* STRATEGY PHASE */
+
+function goto_strategy_phase(new_active) {
+	game.active = new_active;
+	game.state = 'strategy_phase';
+	log("");
+	if (game.active === AMERICAN)
+		log(".h2.american American Turn");
+	else
+		log(".h2.british British Turn");
+	log("");
+}
+
+states.strategy_phase = {
+	prompt: function (current) {
+		game.prompt = "Play a strategy card.";
+		gen_strategy_plays(active_hand());
+	},
+	card_campaign: function (c) {
+		game.did_discard_event = false;
+		clear_queue();
+		goto_campaign(c);
+	},
+	card_play_event: function (c) {
+		push_undo();
+		game.did_discard_event = false;
+		clear_queue();
+		do_event(c);
+	},
+	card_discard_event: function (c) {
+		push_undo();
+		game.did_discard_event = true;
+		clear_queue();
+		discard_card(c, "PC action");
+		game.state = 'discard_event_pc_action';
+	},
+	card_ops_pc: function (c) {
+		push_undo();
+		game.did_discard_event = false;
+		clear_queue();
+		play_card(c, "for PC");
+		goto_ops_pc(CARDS[c].count);
+	},
+	card_ops_reinforcements: function (c) {
+		push_undo();
+		game.did_discard_event = false;
+		clear_queue();
+		goto_ops_reinforcements(c);
+	},
+	card_ops_queue: function (c) {
+		game.did_discard_event = false;
+		play_card(c, "to queue");
+		if (game.active == BRITISH)
+			game.b_queue += CARDS[c].count;
+		else
+			game.a_queue += CARDS[c].count;
+		end_strategy_card();
+	},
+	card_ops_general: function (c) {
+		push_undo();
+		game.did_discard_event = false;
+		goto_ops_general(c);
+	},
+	exchange_for_discard: function (c) {
+		game.did_discard_event = false;
+		let d = game.discard.pop();
+		discard_card(c);
+		active_hand().push(d);
+		game.log.push(game.active[0] + " picks up " + d + ": " + CARDS[d].title);
+	},
+}
+
+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) {
+		game.log.push("The French sign an alliance with the Americans!");
+		game.french_alliance_triggered = true;
+		if (game.french_navy == FRENCH_REINFORCEMENTS) {
+			game.save_active = game.active;
+			game.active = AMERICAN;
+			game.state = 'place_french_navy_trigger';
+			return;
+		}
+	}
+
+	game.moved = {};
+	for (let cu of game.cu)
+		cu.moved = 0;
+
+	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 == BRITISH)
+		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 == BRITISH)
+				if (can_play_event(c))
+					gen_action('card_play_event', c);
+			gen_action('card_discard_event', c);
+			break;
+		case 'american-event':
+			if (game.active == AMERICAN)
+				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: function (current) {
+		game.prompt = "Place, flip, or remove PC marker.";
+		gen_pass();
+		if (game.active == BRITISH)
+			gen_british_discard_event_pc_action();
+		else
+			gen_american_discard_event_pc_action();
+	},
+	place_british_pc: function (space) {
+		place_british_pc(space);
+		end_strategy_card();
+	},
+	place_american_pc: function (space) {
+		place_american_pc(space);
+		end_strategy_card();
+	},
+	remove_pc: function (space) {
+		remove_pc(space);
+		end_strategy_card();
+	},
+	flip_pc: function (space) {
+		flip_pc(space);
+		end_strategy_card();
+	},
+	pass: function () {
+		end_strategy_card();
+	},
+}
+
+function gen_british_discard_event_pc_action() {
+	for (let space in 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 in 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 == BRITISH)
+		gen_british_pc_ops_start();
+}
+
+states.ops_pc = {
+	prompt: function (current) {
+		game.prompt = "Place or flip PC markers. " + game.count + " left.";
+		gen_pass();
+		if (game.count > 0) {
+			if (game.active == BRITISH)
+				gen_british_pc_ops();
+			else
+				gen_american_pc_ops()
+		}
+	},
+	place_british_pc: function (space) {
+		push_undo();
+		place_british_pc(space);
+		--game.count;
+	},
+	place_american_pc: function (space) {
+		push_undo();
+		place_american_pc(space);
+		--game.count;
+	},
+	flip_pc: function (space) {
+		push_undo();
+		flip_pc(space);
+		--game.count;
+	},
+	pass: function () {
+		if (game.active == BRITISH)
+			gen_british_pc_ops_end();
+		end_strategy_card();
+	},
+}
+
+function gen_british_pc_ops_start() {
+	game.british_pc_space_list = [];
+	for (let space in SPACES) {
+		if (has_no_pc(space) && has_no_american_unit(space)) {
+			if (is_adjacent_to_british_pc(space))
+				game.british_pc_space_list.push(space);
+		}
+	}
+}
+
+function gen_british_pc_ops() {
+	for (let space of game.british_pc_space_list)
+		gen_action('place_british_pc', space);
+	for (let space in 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(space) {
+	delete game.british_pc_space_list;
+}
+
+function gen_american_pc_ops() {
+	for (let space in 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 == BRITISH) {
+		game.played_british_reinforcements = count;
+		game.count = count_british_cu(BRITISH_REINFORCEMENTS);
+		game.state = 'ops_british_reinforcements_who';
+	} else {
+		game.played_american_reinforcements.push(count);
+		game.count = count;
+		game.state = 'ops_american_reinforcements_who';
+	}
+}
+
+states.ops_british_reinforcements_who = {
+	prompt: function (current) {
+		game.prompt = "Reinforcements: choose an available general or pass to bring only CU."
+		game.prompt += " Carrying " + game.count + " British CU.";
+		gen_pass();
+		gen_british_reinforcements_who();
+	},
+	drop_british_cu: function () {
+		--game.count;
+	},
+	pickup_british_cu: function () {
+		++game.count;
+	},
+	select_general: function (g) {
+		push_undo();
+		game.state = 'ops_british_reinforcements_where';
+		game.who = g;
+	},
+	pass: function () {
+		push_undo();
+		game.state = 'ops_british_reinforcements_where';
+		game.who = null;
+	},
+}
+
+states.ops_british_reinforcements_where = {
+	prompt: function (current) {
+		game.prompt = "Reinforcements: choose a port space.";
+		game.prompt += " Carrying " + game.count + " British CU.";
+		gen_british_reinforcements_where();
+	},
+	drop_british_cu: function () {
+		--game.count;
+	},
+	pickup_british_cu: function () {
+		++game.count;
+	},
+	place_reinforcements: function (space) {
+		place_british_reinforcements(game.who, game.count, space);
+		end_strategy_card();
+		game.who = null;
+	},
+}
+
+states.ops_american_reinforcements_who = {
+	prompt: function (current) {
+		game.prompt = "Reinforcements: choose an available general or pass to bring only CU.";
+		gen_pass();
+		gen_american_reinforcements_who();
+	},
+	select_general: function (g) {
+		push_undo();
+		game.state = 'ops_american_reinforcements_where';
+		game.who = g;
+	},
+	pass: function () {
+		push_undo();
+		game.state = 'ops_american_reinforcements_where';
+		game.who = null;
+	},
+}
+
+states.ops_american_reinforcements_where = {
+	prompt: function (current) {
+		game.prompt = "Reinforcements: choose a space.";
+		gen_american_reinforcements_where(game.who);
+	},
+	place_reinforcements: function (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 = null;
+	},
+}
+
+function gen_british_reinforcements_who() {
+	for (let g of BRITISH_GENERALS) {
+		let general = game.generals[g];
+		if (general.location == 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 in 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) {
+		let general = game.generals[g];
+		if (general.location == AMERICAN_REINFORCEMENTS) {
+			gen_action('select_general', g);
+		}
+	}
+}
+
+function gen_american_reinforcements_where(general) {
+	for (let space in 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 == BRITISH) {
+		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: function (current) {
+		if (game.campaign && game.landing_party)
+			game.prompt = "Campaign: Activate a general or use a landing party. " + game.campaign + " left.";
+		else if (game.campaign)
+			game.prompt = "Campaign: Activate a general. " + game.campaign + " left.";
+		else
+			game.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: function (where) {
+		game.landing_party = 0;
+		place_british_pc(where);
+		end_strategy_card();
+	},
+	flip_pc: function (where) {
+		game.landing_party = 0;
+		flip_pc(where);
+		end_strategy_card();
+	},
+	select_general: function (g) {
+		push_undo();
+		goto_ops_general_move(g, false);
+	},
+	pass: function () {
+		if (game.campaign > 0)
+			game.campaign = 0;
+		end_strategy_card();
+	}
+}
+
+function gen_landing_party() {
+	for (let space in 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 == BRITISH)
+		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 && !game.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 && !game.moved[g])
+			gen_action('select_general', g);
+}
+
+function goto_remove_general(where) {
+	game.state = 'remove_general';
+	game.where = where;
+}
+
+states.remove_general = {
+	prompt: function (current) {
+		game.prompt = "Remove a general to the reinforcements box.";
+		gen_remove_general();
+	},
+	select_general: function (g) {
+		if (game.active == BRITISH)
+			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: function (current) {
+		game.prompt = "Remove a general to the reinforcements box.";
+		gen_remove_general();
+	},
+	select_general: function (g) {
+		if (game.active == BRITISH)
+			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: function (current) {
+		game.prompt = "Remove a general to the reinforcements box.";
+		gen_remove_general();
+	},
+	select_general: function (g) {
+		if (game.active == BRITISH)
+			move_general(g, BRITISH_REINFORCEMENTS);
+		else
+			move_general(g, AMERICAN_REINFORCEMENTS);
+		end_battle();
+	},
+}
+
+function gen_remove_general() {
+	if (game.active == BRITISH)
+		return gen_remove_british_general();
+	else
+		return gen_remove_american_general();
+}
+
+function gen_remove_british_general() {
+	for (let g of BRITISH_GENERALS)
+		if (location_of_general(g) == game.where)
+			gen_action('select_general', g);
+}
+
+function gen_remove_american_general() {
+	for (let g of AMERICAN_GENERALS)
+		if (g != WASHINGTON)
+			if (location_of_general(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 == BRITISH) {
+			game.mobility = false;
+			game.count = 4;
+		} else {
+			game.mobility = true;
+			game.count = 5;
+		}
+	}
+	let where = location_of_general(g);
+	if (game.active == BRITISH)
+		pickup_max_british_cu(where);
+	else
+		pickup_max_american_cu(where);
+}
+
+states.ops_general_move = {
+	prompt: function (current) {
+		game.prompt = "Move " + game.who + " with ";
+		if (game.carry_british > 0) {
+			game.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) {
+					game.prompt += game.carry_french + " French CU and ";
+					game.prompt += game.carry_american + " American CU.";
+				} else {
+					game.prompt += game.carry_french + " French CU.";
+				}
+			} else {
+				game.prompt += game.carry_american + " American CU.";
+			}
+		} else {
+			game.prompt += game.carry_american + " no CU.";
+		}
+		if (game.count == 1)
+			game.prompt += " " + game.count + " move left.";
+		else if (game.count > 1)
+			game.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: function () { ++game.carry_british; },
+	pickup_american_cu: function () { ++game.carry_american; },
+	pickup_french_cu: function () { ++game.carry_french; },
+
+	drop_british_cu: function () {
+		push_undo();
+		--game.carry_british;
+		if (game.moved[game.who])
+			mark_moved_cu(BRITISH, location_of_general(game.who), 1);
+	},
+	drop_american_cu: function () {
+		push_undo();
+		--game.carry_american;
+		if (game.moved[game.who])
+			mark_moved_cu(AMERICAN, location_of_general(game.who), 1);
+	},
+	drop_french_cu: function () {
+		push_undo();
+		--game.carry_french;
+		if (game.moved[game.who])
+			mark_moved_cu(FRENCH, location_of_general(game.who), 1);
+	},
+
+	move: function (to) {
+		push_undo();
+
+		game.moved[game.who] = 1;
+		let from = location_of_general(game.who);
+		let cu = game.carry_british + game.carry_american + game.carry_french;
+
+		let intercept = false;
+		if (game.active == BRITISH) {
+			let is_sea_move = (path_type(from, to) == undefined);
+			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 == BRITISH && game.congress == to && !has_enemy_cu(to)) {
+				disperse_continental_congress(to);
+			}
+			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: function () {
+		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].exits) {
+		if (has_american_army(space)) {
+			let g = find_american_or_french_general(space);
+			if (g && !game.moved[g])
+				return true;
+		}
+	}
+	return false;
+}
+
+function gen_intercept() {
+	for (let space of SPACES[game.where].exits) {
+		if (has_american_army(space)) {
+			let g = find_american_or_french_general(space);
+			if (g && !game.moved[g])
+				gen_action('select_general', g);
+			else if (g)
+				console.log(g, "already moved");
+		}
+	}
+}
+
+function goto_intercept(from, where) {
+	clear_undo();
+	game.save_who = game.who;
+	game.who = null;
+	game.from = from;
+	game.where = where;
+	game.active = AMERICAN;
+	game.state = 'intercept';
+}
+
+states.intercept = {
+	prompt: function (current) {
+		game.prompt = "Intercept " + game.save_who + " in " + game.where + "?";
+		gen_pass();
+		gen_intercept();
+	},
+	select_general: function (g) {
+		// TODO: roll for intercept!
+		game.moved[g] = 1;
+		let die = roll_d6();
+		if (die <= GENERALS[g].agility) {
+			game.log.push(g + " intercepts (" + 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 {
+			game.log.push(g + " fails to intercept (" + die + " > " + GENERALS[g].agility + ")");
+			if (!can_intercept_to(game.where))
+				end_intercept();
+		}
+	},
+	pass: function () {
+		end_intercept();
+	},
+}
+
+function end_intercept() {
+	game.active = BRITISH;
+	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 (game.moved[game.who]) {
+		mark_moved_cu(BRITISH, where, game.carry_british);
+		mark_moved_cu(AMERICAN, where, game.carry_american);
+		mark_moved_cu(FRENCH, where, game.carry_french);
+	}
+	game.who = null;
+	delete game.mobility;
+	delete game.carry_british;
+	delete game.carry_american;
+	delete game.carry_french;
+}
+
+function path_type(from, to) {
+	return PATH_TYPE[PATH_INDEX[from][to]];
+}
+
+function path_name(from, to) {
+	return PATH_NAME[PATH_INDEX[from][to]];
+}
+
+function gen_carry_cu() {
+	let where = location_of_general(game.who);
+	if (game.active == BRITISH) {
+		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 undefined: return 4; /* must be a sea connection if no direct path */
+	case 'wilderness': return 3;
+	default: return 1;
+	}
+}
+
+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].exits) {
+		let mp = 1;
+		if (path_type(from, to) == 'wilderness') {
+			if (path_name(from, to) == FALMOUTH_QUEBEC)
+				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 == BRITISH && game.count == 4) {
+		if (is_non_blockaded_port(from)) {
+			for (let to in SPACES) {
+				if (to != from) {
+					if (is_non_blockaded_port(to)) {
+						if (!has_american_pc(to) && !has_american_or_french_cu(to)) {
+							// 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 == BRITISH ? 1 : 0;
+	game.count = 3; // can activate any general!
+	game.state = 'ops_general_who';
+}
+
+/* EVENTS */
+
+events.the_war_ends = function (c, card) {
+	game.log.push(game.active[0] + " plays " + c + ": " + CARDS[c].title);
+	game.log.push("The war will end in " + card.year);
+	game.last_played = c;
+	remove_from_array(active_hand(), c);
+	if (game.war_ends)
+		game.discard.push(WAR_ENDS_1779 + game.war_ends - 1779);
+	game.war_ends = card.year;
+	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();
+	}
+}
+
+function advance_french_alliance(count) {
+	if (game.french_alliance < 9) {
+		game.french_alliance += count;
+		if (game.french_alliance > 9)
+			game.french_alliance = 9;
+		game.log.push("French alliance advances to " + count);
+	}
+}
+
+function lose_regular_advantage() {
+	if (game.regulars) {
+		game.log.push("The British Regulars Advantage is 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);
+		game.log.push("A places 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 = TURN_TRACK[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: function (current) {
+		game.prompt = "Remove British PC markers from " + game.where.join(", ") + ". " + game.count + " left.";
+		gen_pass();
+		gen_remove_british_pc_from(game.where);
+	},
+	remove_pc: function (where) {
+		remove_pc(where);
+		if (--game.count == 0) {
+			delete game.where;
+			end_strategy_card();
+		}
+	},
+	pass: function () {
+		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: function (current) {
+		game.prompt = "Remove American PC markers. " + game.count + " left.";
+		gen_pass();
+		gen_remove_american_pc();
+	},
+	remove_pc: function (where) {
+		remove_pc(where);
+		if (--game.count == 0) {
+			end_strategy_card();
+		}
+	},
+	pass: function () {
+		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: function (current) {
+		game.prompt = "Remove American PC markers from " + game.where.join(", ") + ". " + game.count + " left.";
+		gen_pass();
+		gen_remove_american_pc_from(game.where);
+	},
+	remove_pc: function (where) {
+		remove_pc(where);
+		if (--game.count == 0) {
+			delete game.where;
+			end_strategy_card();
+		}
+	},
+	pass: function () {
+		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: function (current) {
+		game.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: function (where) {
+		remove_pc(where);
+		if (--game.count == 0) {
+			delete game.where;
+			end_strategy_card();
+		}
+	},
+	pass: function () {
+		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: function (current) {
+		game.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: function (where) {
+		remove_pc(where);
+		if (--game.count == 0) {
+			delete game.where;
+			end_strategy_card();
+		}
+	},
+	pass: function () {
+		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: function (current) {
+		game.prompt = "Place American PC markers. " + game.count + " left.";
+		gen_pass();
+		gen_place_american_pc();
+	},
+	place_american_pc: function (where) {
+		place_american_pc(where);
+		if (--game.count == 0) {
+			end_strategy_card();
+		}
+	},
+	pass: function () {
+		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: function (current) {
+		game.prompt = "Place American PC markers in " + game.where.join(", ") + ". " + game.count + " left.";
+		gen_pass();
+		gen_place_american_pc_in(game.where);
+	},
+	place_american_pc: function (where) {
+		place_american_pc(where);
+		if (--game.count == 0) {
+			delete game.where;
+			end_strategy_card();
+		}
+	},
+	pass: function () {
+		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 = null;
+}
+
+states.lord_sandwich_coastal_raids = {
+	prompt: function (current) {
+		game.prompt = "Remove two or flip one American PC in a port space.";
+		gen_pass();
+		gen_lord_sandwich_coastal_raids(game.where);
+	},
+	place_british_pc: function (where) {
+		place_british_pc(where);
+		end_strategy_card();
+	},
+	remove_pc: function (where) {
+		game.where = where;
+		remove_pc(where);
+		if (--game.count == 0)
+			end_strategy_card();
+	},
+	pass: function () {
+		end_strategy_card();
+	},
+}
+
+function gen_lord_sandwich_coastal_raids(first_removed) {
+	for (let space in 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: function (current) {
+		game.prompt = "Remove one American CU from any space.";
+		gen_pass();
+		gen_remove_american_cu();
+	},
+	remove_cu: function (where) {
+		let cu = find_american_cu(where) || find_french_cu(where);
+		remove_cu(cu.owner, where, 1);
+		end_strategy_card();
+	},
+	pass: function () {
+		end_strategy_card();
+	},
+}
+
+function gen_remove_american_cu() {
+	for (let space in SPACES) {
+		if (has_american_or_french_cu(space))
+			gen_action('remove_cu', space);
+	}
+}
+
+function gen_remove_british_cu() {
+	for (let space in 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 = null;
+}
+
+states.pennsylvania_and_new_jersey_line_mutinies = {
+	prompt: function (current) {
+		game.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: function (where) {
+		let cu = find_american_cu(where) || find_french_cu(where);
+		remove_cu(cu.owner, where, 1);
+		game.where = where;
+		if (--game.count == 0)
+			end_strategy_card();
+	},
+	pass: function () {
+		end_strategy_card();
+	},
+}
+
+function gen_pennsylvania_and_new_jersey_line_mutinies(first_removed) {
+	for (let space in 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: function (current) {
+		game.prompt = "Activate an American general.";
+		gen_activate_general();
+	},
+	select_general: function (g) {
+		goto_ops_general_move(g, true);
+	},
+}
+
+events.declaration_of_independence = function (c, card) {
+	play_card(c);
+	game.last_active = game.active;
+	game.active = AMERICAN;
+	game.doi = THE_13_COLONIES.slice();
+	game.state = 'declaration_of_independence';
+}
+
+states.declaration_of_independence = {
+	prompt: function (current) {
+		game.prompt = "Declaration of Independence: Place 1 PC marker in each of the 13 colonies. ";
+		game.prompt += game.doi.length + " left.";
+		gen_pass();
+		gen_place_american_pc_in(game.doi);
+	},
+	place_american_pc: function (space) {
+		let colony = SPACES[space].colony;
+		remove_from_array(game.doi, colony);
+		place_american_pc(space);
+		if (game.doi.length == 0)
+			end_declaration_of_independence();
+	},
+	pass: function () {
+		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 = BRITISH;
+	game.count = 5;
+}
+
+states.george_washington_captured = {
+	prompt: function (current) {
+		game.prompt = "George Washington is captured! Remove American PC markers. " + game.count + " left.";
+		gen_pass();
+		gen_remove_american_pc();
+	},
+	remove_pc: function (where) {
+		remove_pc(where);
+		if (--game.count == 0) {
+			end_george_washington_captured();
+		}
+	},
+	pass: function () {
+		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 && !game.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 == BRITISH && can_retreat_before_battle(where))
+		goto_retreat_before_battle();
+	else
+		goto_play_attacker_battle_card();
+}
+
+function goto_retreat_before_battle() {
+	game.active = AMERICAN;
+	game.who = find_american_or_french_general(game.where);
+	game.state = 'retreat_before_battle';
+}
+
+states.retreat_before_battle = {
+	prompt: function (current) {
+		game.prompt = "Attempt retreat before battle?";
+		gen_pass();
+		gen_defender_retreat();
+	},
+	move: function (to) {
+		let agility = GENERALS[game.who].agility;
+		if (GENERALS[game.who].bonus)
+			agility += 2;
+		let roll = roll_d6();
+		if (roll <= agility) {
+			game.log.push("A successfully retreats 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 {
+			game.log.push("A fails to retreat before battle: " + roll + " > " + agility);
+			end_retreat_before_battle();
+		}
+	},
+	pass: function () {
+		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: function (current) {
+		game.prompt = "Remove a general to the reinforcements box.";
+		gen_remove_general();
+	},
+	select_general: function (g) {
+		if (game.active == BRITISH)
+			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].exits) {
+		if (can_defender_retreat(to))
+			gen_action('move', to);
+	}
+	if (game.active == BRITISH) {
+		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 in 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 = null;
+	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: function (current) {
+		game.prompt = "Attack: Play or discard event for DRM.";
+		gen_pass();
+		gen_battle_card();
+	},
+	card_battle_play: function (c) {
+		play_card(c, "for +2 DRM");
+		if (game.active == BRITISH) {
+			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: function (c) {
+		discard_card(c, "for +1 DRM");
+		if (game.active == BRITISH) {
+			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: function () {
+		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: function (current) {
+		game.prompt = "Defend: Play or discard event for DRM.";
+		gen_pass();
+		gen_battle_card();
+	},
+	card_battle_play: function (c) {
+		play_card(c, "for +2 DRM");
+		if (game.active == BRITISH) {
+			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: function (c) {
+		discard_card(c, "for +1 DRM");
+		if (game.active == BRITISH) {
+			game.b_draw_after_battle = true;
+			game.b_bonus += 1;
+		} else {
+			game.a_draw_after_battle = true;
+			game.a_bonus += 1;
+		}
+		resolve_battle();
+	},
+	pass: function () {
+		resolve_battle();
+	},
+}
+
+function gen_battle_card() {
+	for (let c of active_hand()) {
+		let card = CARDS[c];
+		if (game.active == BRITISH) {
+			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 cu = find_british_cu(game.where);
+	if (cu.count > max) {
+		cu.count -= max;
+		return max;
+	}
+	remove_from_array(game.cu, cu);
+	return cu.count;
+}
+
+function apply_american_combat_losses(max) {
+	let cu = find_american_cu(game.where);
+	if (cu) {
+		if (cu.count > max) {
+			cu.count -= max;
+			return max;
+		}
+		remove_from_array(game.cu, cu);
+		return cu.count;
+	}
+	return 0;
+}
+
+function apply_french_combat_losses(max) {
+	let cu = find_french_cu(game.where);
+	if (cu) {
+		if (cu.count > max) {
+			cu.count -= max;
+			return max;
+		}
+		remove_from_array(game.cu, cu);
+		return cu.count;
+	}
+	return 0;
+}
+
+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 == BRITISH)
+		victor = (b_roll + b_drm) >= (a_roll + a_drm) ? BRITISH : AMERICAN;
+	else
+		victor = (b_roll + b_drm) >= (a_roll + a_drm) ? BRITISH : AMERICAN;
+
+	let a_lost_cu, b_lost_cu;
+	if (victor == BRITISH) {
+		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 == BRITISH) {
+		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);
+	}
+
+	game.log.push("BRITISH BATTLE REPORT:\n" + b_log.join("\n"));
+	game.log.push("AMERICAN BATTLE REPORT:\n" + a_log.join("\n"));
+	game.log.push(victor + " victory in " + game.where + "!");
+
+	if (victor == AMERICAN)
+		advance_french_alliance(1);
+
+	goto_retreat_after_battle(victor);
+}
+
+function goto_retreat_after_battle(victor) {
+	if (victor == BRITISH) {
+		game.who = find_american_or_french_general(game.where);
+		if (game.who == null && count_american_and_french_cu(game.where) == 0)
+			return end_battle();
+	} else {
+		game.who = find_british_general(game.where);
+		if (game.who == null && count_british_cu(game.where) == 0)
+			return end_battle();
+	}
+	game.active = ENEMY[victor];
+	game.state = 'retreat_after_battle';
+}
+
+states.retreat_after_battle = {
+	prompt: function (current) {
+		game.prompt = "Retreat after battle.";
+		gen_action('surrender');
+		if (game.active == game.attacker)
+			gen_attacker_retreat();
+		else
+			gen_defender_retreat();
+	},
+	move: function (to) {
+		game.log.push(game.active[0] + " retreats to " + to);
+		if (game.active == BRITISH)
+			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: function () {
+		// End battle here, so if Washington is captured we can handle the interrupt state.
+		let active = game.active;
+		let where = game.where;
+		end_battle();
+
+		game.log.push(active[0] + " surrenders");
+		if (active == BRITISH)
+			surrender_british_army(where);
+		else
+			surrender_american_army(where);
+	},
+}
+
+function end_battle() {
+	game.active = game.attacker;
+
+	if (game.british_losses >= 3)
+		lose_regular_advantage();
+
+	// TODO: delay until end of campaign
+	if (game.b_draw_after_battle)
+		game.b_hand.push(deal_card());
+	if (game.a_draw_after_battle)
+		game.a_hand.push(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 = null;
+	game.who = null;
+	end_strategy_card();
+}
+
+/* END TURN PHASES */
+
+function apply_single_winter_attrition(owner, space) {
+	let die = roll_d6();
+	game.log.push(owner[0] + " attrition roll " + die + " in " + space);
+	if (die <= 3) {
+		game.log.push(owner[0] + " lose 1 CU in " + space);
+		remove_cu(owner, space, 1);
+	}
+}
+
+function apply_winter_attrition(owner, space, n) {
+	let half = Math.floor(n / 2);
+	game.log.push(owner[0] + " lose " + half + " CU in " + space);
+	remove_cu(owner, space, half);
+}
+
+function goto_winter_attrition_phase() {
+	game.log.push("");
+	game.log.push("Winter Attrition");
+
+	for (let space in 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 = game.generals[WASHINGTON].location == 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);
+			game.log.push(owner[0] + " lose " + lose_american + " American CU  in " + space);
+			remove_cu(AMERICAN, space, n_american);
+			half -= lose_american;
+			n_american -= lose_american;
+
+			if (half > 0) {
+				game.log.push(owner[0] + " lose " + half + " French CU in " + space);
+				remove_cu(FRENCH, space, half);
+			}
+		}
+	}
+
+	if (automatic_victory())
+		return;
+
+	goto_french_naval_phase();
+}
+
+function goto_french_naval_phase() {
+	if (game.french_navy != FRENCH_REINFORCEMENTS) {
+		game.active = AMERICAN;
+		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: function (current) {
+		game.prompt = "Place the French Navy in a blockade zone.";
+		gen_place_french_navy();
+	},
+	place_navy: function (zone) {
+		game.log.push("A places French Navy.");
+		game.french_navy = zone;
+		game.active = game.save_active;
+		delete game.save_active;
+		end_strategy_card()
+	},
+}
+
+states.place_french_navy = {
+	prompt: function (current) {
+		game.prompt = "Place the French Navy in a blockade zone.";
+		gen_place_french_navy();
+	},
+	place_navy: function (zone) {
+		game.log.push("A places French Navy.");
+		game.french_navy = zone;
+		goto_political_control_phase();
+	},
+}
+
+function place_pc_markers_segment() {
+	for (let space in 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) {
+	for (let to of SPACES[from].exits) {
+		if (to in seen)
+			continue;
+		if (is_american_pc_path(to)) {
+			seen[to] = 1;
+			spread_american_path(seen, to);
+		}
+	}
+}
+
+function spread_british_path(seen, from) {
+	for (let to of SPACES[from].exits) {
+		if (to in seen)
+			continue;
+		if (is_british_pc_path(to)) {
+			seen[to] = 1;
+			spread_british_path(seen, to);
+		}
+	}
+}
+
+function remove_isolated_american_pc_segment() {
+	game.log.push("Removing isolated American PC");
+	let seen = {};
+	for (let space in SPACES) {
+		if (is_american_pc_root(space)) {
+			seen[space] = 1;
+			spread_american_path(seen, space);
+		}
+	}
+	for (let space in SPACES)
+		if (has_american_pc(space) && !seen[space])
+			remove_pc(space);
+}
+
+function remove_isolated_british_pc_segment() {
+	game.log.push("Removing isolated British PC");
+	let seen = {};
+	for (let space in SPACES) {
+		if (is_british_pc_root(space)) {
+			seen[space] = 1;
+			spread_british_path(seen, space);
+		}
+	}
+	for (let space in SPACES)
+		if (has_british_pc(space) && !seen[space])
+			remove_pc(space);
+}
+
+function gen_return_continental_congress() {
+	let n = 0;
+	for (let space in 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 = AMERICAN;
+		game.state = 'return_continental_congress';
+	} else {
+		goto_political_control_phase_2();
+	}
+}
+
+states.return_continental_congress = {
+	prompt: function () {
+		game.prompt = "Return Continental Congress to a space in the 13 colonies.";
+		if (gen_place_continental_congress() == 0)
+			gen_pass();
+	},
+	place_continental_congress: function (where) {
+		game.congess = where;
+		goto_political_control_phase_2();
+	},
+	pass: function () {
+		goto_political_control_phase_2();
+	}
+}
+
+function goto_political_control_phase_2() {
+	place_pc_markers_segment();
+	remove_isolated_american_pc_segment();
+	remove_isolated_british_pc_segment();
+	goto_end_phase();
+}
+
+states.european_war = {
+	prompt: function () {
+		game.prompt = "European War: Remove 2 British CU from any spaces. " + game.count + " left.";
+		gen_pass();
+		gen_remove_british_cu();
+	},
+	remove_cu: function (where) {
+		let cu = find_british_cu(where);
+		remove_cu(BRITISH, where, 1);
+		if (--game.count == 0)
+			goto_end_phase();
+	},
+	pass: function () {
+		goto_end_phase();
+	}
+}
+
+function norths_government_falls() {
+	update_colony_control();
+
+	let n_american = 0;
+	for (let c in COLONIES)
+		if (game.control[c] == AMERICAN)
+			++n_american;
+
+	if (n_american >= 7)
+		game.result = AMERICAN;
+	else
+		game.result = BRITISH;
+
+	game.victory = "North's Government Falls: " + game.result + " Victory!";
+	game.active = "None";
+	game.state = 'game_over';
+
+	game.log.push(game.victory);
+}
+
+function goto_end_phase() {
+	if (game.french_alliance_triggered && !game.european_war) {
+		game.european_war = true;
+		game.count = 2;
+		game.active = AMERICAN;
+		game.state = 'european_war';
+		game.reshuffle = true;
+		return;
+	}
+
+	if ((game.war_ends && game.year >= game.war_ends) || 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: function () {
+		game.prompt = game.victory;
+	}
+}
+
+/* CLIENT/SERVER COMMS */
+
+exports.ready = function (scenario, options, players) {
+	return players.length === 2;
+}
+
+exports.setup = function (seed, scenario, players) {
+	setup_game(seed);
+	return game;
+}
+
+exports.action = function (state, current, action, arg) {
+	game = state;
+	// 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;
+}
+
+function list_actions(current) {
+	game.actions = {}
+	game.prompt = "";
+	states[game.state].prompt(current);
+}
+
+exports.view = function(state, current) {
+	game = state;
+
+	list_actions(current);
+
+	update_colony_control();
+
+	let view = {
+		active: state.active,
+		year: state.year,
+		war_ends: state.war_ends,
+		played_british_reinforcements: state.played_british_reinforcements,
+		played_american_reinforcements: state.played_american_reinforcements,
+		congress: state.congress,
+		european_war: state.european_war,
+		french_alliance: state.french_alliance,
+		french_navy: state.french_navy,
+		regulars: state.regulars,
+		generals: state.generals,
+		cu: state.cu,
+		pc: state.pc,
+		control: state.control,
+		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 == AMERICAN)
+		view.hand = state.a_hand;
+	else if (current == BRITISH)
+		view.hand = state.b_hand;
+	else
+		view.hand = [];
+
+	if (current == state.active) {
+		gen_action_undo();
+		view.prompt = state.prompt;
+		view.actions = state.actions;
+	} else {
+		view.prompt = "Waiting for " + game.active + " player \u2014 " + game.prompt;
+	}
+
+	return view;
+}