removed global capabilities

no global capabailities in plantagenet

1 files changed, 7539 insertions, 9 deletions

diff --git a/rules.js b/rules.js
index 6b18c35..855fb5c 100644
--- a/rules.js
+++ b/rules.js
@@ -1,5 +1,7 @@
 "use strict"
 
+const data = require("./data.js")
+
 const BOTH = "Both"
 const LANCASTER = "Lancaster"
 const YORK = "York"
@@ -84,11 +86,8 @@ const FORCE_EVADE = [ 0, 0, 0, 0, 0, 0, 0 ]
 // asset types
 const PROV = 0
 const COIN = 1
-//const LOOT = 2
 const CART = 2
-//const SLED = 4
-//const BOAT = 5
-const SHIP = 4
+const SHIP = 3
 
 const ASSET_TYPE_NAME = [ "Provender", "Coin", "Cart", "Ship" ]
 
@@ -126,12 +125,13 @@ const vassal_count = data.vassals.length
 const first_lord = 0
 const last_lord = lord_count - 1
 
-const first_p1_locale = 0
+/*const first_p1_locale = 0
 const last_p1_locale = 23
 const first_p2_locale = 24
-const last_p2_locale = 52
+const last_p2_locale = 52 */
 const first_locale = 0
-const last_locale = 52
+const last_locale = data.locales.length - 1
+
 
 
 const first_p1_card = 0
@@ -228,7 +228,7 @@ const LORD_SALISBURY = find_lord("Salisbury")
 const LORD_RUTLAND = find_lord("Rutland")
 const LORD_PEMBROKE = find_lord("Pembroke")
 const LORD_DEVON = find_lord("Devon")
-const LORD_NORTHUMBERLAND = find_lord("Northumberland")
+const LORD_NORTHUMBERLANDY = find_lord("Northumberland")
 const LORD_GLOUCESTER = find_lord("Gloucester")
 const LORD_RICHARD_III = find_lord("Richard III")
 const LORD_NORFOLK = find_lord("Norfolk")
@@ -240,6 +240,7 @@ const LORD_SOMERSET = find_lord("Somerset")
 const LORD_EXETER = find_lord("Exeter")
 const LORD_BUCKINGHAM = find_lord("Buckingham")
 const LORD_CLARENCE = find_lord("Clarence")
+const LORD_NORTHUMBERLANDL = find_lord("Northumberland")
 
 const LORD_JASPER_TUDOR = find_lord("Jasper Tudor")
 const LORD_HENRY_TUDOR = find_lord("Henry Tudor")
@@ -308,4 +309,7533 @@ const LOC_ENGLISH_CHANNEL = find_locale("English Channel")
 const LOC_IRISH_SEA = find_locale("Irish Sea")
 const LOC_NORTH_SEA = find_locale("North Sea")
 const LOC_SCARBOROUGH = find_locale("Scarborough")
-const LOC_RAVENSPUR = find_locale("Ravenspur")
\ No newline at end of file
+const LOC_RAVENSPUR = find_locale("Ravenspur")
+
+
+
+// === === === === FROM NEVSKY === === === ===
+
+// TODO: log end victory conditions at scenario start
+
+// WONTFIX: choose crossbow/normal hit application order
+
+// Check all push/clear_undo
+
+const VASSAL_UNAVAILABLE = 0
+const VASSAL_READY = 1
+const VASSAL_MUSTERED = 2
+
+const NOBODY = -1
+const NOWHERE = -1
+const NOTHING = -1
+const NEVER = -1
+const CALENDAR = 100
+
+function current_turn() {
+	return game.turn >> 1
+}
+
+function current_turn_name() {
+	return String(game.turn >> 1)
+}
+
+function current_hand() {
+	if (game.active === P1)
+		return game.hand1
+	return game.hand2
+}
+
+function is_campaign_phase() {
+	return (game.turn & 1) === 1
+}
+
+function is_levy_phase() {
+	return (game.turn & 1) === 0
+}
+
+// === GAME STATE ===
+
+const first_p1_lord = 0
+const last_p1_lord = 13
+const first_p2_lord = 14
+const last_p2_lord = 27
+
+let first_friendly_lord = 0
+let last_friendly_lord = 13
+let first_enemy_lord = 14
+let last_enemy_lord = 27
+
+function update_aliases() {
+	if (game.active === P1) {
+		first_friendly_lord = 0
+		last_friendly_lord = 13
+		first_enemy_lord = 14
+		last_enemy_lord = 27
+	} else if (game.active === P2) {
+		first_friendly_lord = 14
+		last_friendly_lord = 27
+		first_enemy_lord = 0
+		last_enemy_lord = 13
+	} else {
+		first_friendly_lord = -1
+		last_friendly_lord = -1
+		first_enemy_lord = -1
+		last_enemy_lord = -1
+	}
+}
+
+function load_state(state) {
+	if (game !== state) {
+		game = state
+		update_aliases()
+	}
+}
+
+function push_state(next) {
+	if (!states[next])
+		throw Error("No such state: " + next)
+	game.stack.push([ game.state, game.who, game.count ])
+	game.state = next
+}
+
+function pop_state() {
+	;[ game.state, game.who, game.count ] = game.stack.pop()
+}
+
+function set_active(new_active) {
+	if (game.active !== new_active) {
+		game.active = new_active
+		update_aliases()
+	}
+}
+
+function set_active_enemy() {
+	game.active = enemy_player()
+	update_aliases()
+}
+
+function enemy_player() {
+	if (game.active === P1)
+		return P2
+	if (game.active === P2)
+		return P1
+	return null
+}
+
+function has_any_spoils() {
+	return (
+		game.spoils &&
+		game.spoils[PROV] +
+			game.spoils[COIN] +
+			game.spoils[CART] +
+			game.spoils[SHIP] >
+			0
+	)
+}
+
+function get_spoils(type) {
+	if (game.spoils)
+		return game.spoils[type]
+	return 0
+}
+
+function add_spoils(type, n) {
+	if (!game.spoils)
+		game.spoils = [ 0, 0, 0, 0, 0, 0, 0 ]
+	game.spoils[type] += n
+}
+
+function get_lord_calendar(lord) {
+	if (is_lord_on_calendar(lord))
+		return get_lord_locale(lord) - CALENDAR
+	else
+		return get_lord_service(lord)
+}
+
+function set_lord_cylinder_on_calendar(lord, turn) {
+	if (turn < 0) turn = 0
+	if (turn > 16) turn = 16
+	set_lord_locale(lord, CALENDAR + turn)
+}
+
+function set_lord_calendar(lord, turn) {
+	if (is_lord_on_calendar(lord))
+		set_lord_cylinder_on_calendar(lord, turn)
+	else
+		set_lord_service(lord, turn)
+}
+
+function get_lord_locale(lord) {
+	return game.pieces.locale[lord]
+}
+
+function get_lord_service(lord) {
+	return game.pieces.service[lord]
+}
+
+function get_lord_capability(lord, n) {
+	return game.pieces.capabilities[(lord << 1) + n]
+}
+
+function set_lord_capability(lord, n, x) {
+	game.pieces.capabilities[(lord << 1) + n] = x
+}
+
+function get_lord_assets(lord, n) {
+	return pack4_get(game.pieces.assets[lord], n)
+}
+
+function get_lord_forces(lord, n) {
+	return pack4_get(game.pieces.forces[lord], n)
+}
+
+function get_lord_routed_forces(lord, n) {
+	return pack4_get(game.pieces.routed[lord], n)
+}
+
+function lord_has_unrouted_units(lord) {
+	return game.pieces.forces[lord] !== 0
+}
+
+function lord_has_routed_units(lord) {
+	return game.pieces.routed[lord] !== 0
+}
+
+function set_lord_locale(lord, locale) {
+	game.pieces.locale[lord] = locale
+}
+
+function shift_lord_cylinder(lord, dir) {
+	set_lord_calendar(lord, get_lord_calendar(lord) + dir)
+}
+
+/*function set_lord_service(lord, service) {
+	if (service < 0)
+		service = 0
+	if (service > 17)
+		service = 17
+	game.pieces.service[lord] = service
+}*/
+
+/*function add_lord_service(lord, n) {
+	set_lord_service(lord, get_lord_service(lord) + n)
+}*/
+
+function set_lord_assets(lord, n, x) {
+	if (x < 0)
+		x = 0
+	if (x > 40)
+		x = 40
+	game.pieces.assets[lord] = pack4_set(game.pieces.assets[lord], n, x)
+}
+
+function add_lord_assets(lord, n, x) {
+	set_lord_assets(lord, n, get_lord_assets(lord, n) + x)
+}
+
+function set_lord_forces(lord, n, x) {
+	if (x < 0)
+		x = 0
+	if (x > 15)
+		x = 15
+	game.pieces.forces[lord] = pack4_set(game.pieces.forces[lord], n, x)
+}
+
+function add_lord_forces(lord, n, x) {
+	set_lord_forces(lord, n, get_lord_forces(lord, n) + x)
+}
+
+function set_lord_routed_forces(lord, n, x) {
+	if (x < 0)
+		x = 0
+	if (x > 15)
+		x = 15
+	game.pieces.routed[lord] = pack4_set(game.pieces.routed[lord], n, x)
+}
+
+function add_lord_routed_forces(lord, n, x) {
+	set_lord_routed_forces(lord, n, get_lord_routed_forces(lord, n) + x)
+}
+
+function clear_lords_moved() {
+	game.pieces.moved = 0
+}
+
+function get_lord_moved(lord) {
+	return pack2_get(game.pieces.moved, lord)
+}
+
+function set_lord_moved(lord, x) {
+	game.pieces.moved = pack2_set(game.pieces.moved, lord, x)
+}
+
+function set_lord_fought(lord) {
+	set_lord_moved(lord, 1)
+	game.battle.fought = pack1_set(game.battle.fought, lord, 1)
+}
+
+function get_lord_fought(lord) {
+	return pack1_get(game.battle.fought, lord)
+}
+
+function set_lord_unfed(lord, n) {
+	// reuse "moved" flag for hunger
+	set_lord_moved(lord, n)
+}
+
+function is_lord_unfed(lord) {
+	// reuse "moved" flag for hunger
+	return get_lord_moved(lord)
+}
+
+function feed_lord_skip(lord) {
+	// reuse "moved" flag for hunger
+	set_lord_moved(lord, 0)
+}
+
+function feed_lord(lord) {
+	// reuse "moved" flag for hunger
+	let n = get_lord_moved(lord) - 1
+	set_lord_moved(lord, n)
+	if (n === 0)
+		log(`Fed L${lord}.`)
+}
+
+function get_lord_array_position(lord) {
+	for (let p = 0; p < 12; ++p)
+		if (game.battle.array[p] === lord)
+			return p
+	return -1
+}
+
+/*function add_veche_vp(amount) {
+	game.pieces.veche_vp += amount
+	if (game.pieces.veche_vp < 0)
+		game.pieces.veche_vp = 0
+	if (game.pieces.veche_vp > 8)
+		game.pieces.veche_vp = 8
+}*/
+
+// === GAME STATE HELPERS ===
+
+function roll_die() {
+	return random(6) + 1
+}
+
+function get_shared_assets(loc, what) {
+	let n = 0
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+		if (get_lord_locale(lord) === loc)
+			n += get_lord_assets(lord, what)
+	return n
+}
+
+function count_lord_all_forces(lord) {
+	return (
+		get_lord_forces(lord, RETINUE) +
+		get_lord_forces(lord, VASSAL) +
+		get_lord_forces(lord, BURGUNDIANS) +
+		get_lord_forces(lord, MERCENARIES) +
+		get_lord_forces(lord, MEN_AT_ARMS) +
+		get_lord_forces(lord, MILITIA) +
+		get_lord_forces(lord, LONGBOWMEN)
+	)
+}
+
+/*function count_lord_horses(lord) {
+	return (
+		get_lord_forces(lord, KNIGHTS) +
+		get_lord_forces(lord, SERGEANTS) +
+		get_lord_forces(lord, LIGHT_HORSE) +
+		get_lord_forces(lord, ASIATIC_HORSE)
+	)
+}*/
+
+function count_lord_ships(lord) {
+	let ships = get_lord_assets(lord, SHIP)
+	return ships
+}
+
+function count_shared_ships() {
+	let here = get_lord_locale(game.command)
+	let n = 0
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+		if (get_lord_locale(lord) === here)
+			n += count_lord_ships(lord)
+	return n
+}
+
+function count_group_ships() {
+	let n = 0
+	for (let lord of game.group)
+		n += count_lord_ships(lord)
+	return n
+}
+
+function count_group_assets(type) {
+	let n = 0
+	for (let lord of game.group)
+		n += get_lord_assets(lord, type)
+	return n
+}
+
+function count_group_forces(type) {
+	let n = 0
+	for (let lord of game.group)
+		n += get_lord_forces(lord, type)
+	return n
+}
+/*
+function count_group_horses() {
+	let n = 0
+	for (let lord of game.group)
+		n += count_lord_horses(lord)
+	return n
+}*/
+
+function count_group_transport(type) {
+	let n = 0
+	for (let lord of game.group)
+		n += count_lord_transport(lord, type)
+	return n
+}
+
+function max_plan_length() {
+	switch (current_season()) {
+		case SUMMER:
+			return 6
+		case EARLY_WINTER:
+			return 4
+		case LATE_WINTER:
+			return 4
+		case RASPUTITSA:
+			return 5
+	}
+}
+
+function count_cards_in_plan(plan, lord) {
+	let n = 0
+	for (let c of plan)
+		if (c === lord)
+			++n
+	return n
+}
+
+/*function is_marshal(lord) {
+	switch (lord) {
+		case LORD_ANDREAS:
+			return true
+		case LORD_HERMANN:
+			return !is_lord_on_map(LORD_ANDREAS)
+		case LORD_ALEKSANDR:
+			return true
+		case LORD_ANDREY:
+			return !is_lord_on_map(LORD_ALEKSANDR)
+		default:
+			return false
+	}
+}*/
+
+function is_armored_force(type) {
+	return type === MEN_AT_ARMS || type === BURGUNDIANS || type === RETINUE || type === VASSAL || type === MERCENARIES
+}
+/*
+function is_no_event_card(c) {
+	if (c === 18 || c === 19 || c === 20)
+		return true
+	if (c === 39 || c === 40 || c === 41)
+		return true
+	return false
+}*/
+
+function is_p1_card(c) {
+	return c >= first_p1_card && c <= last_p1_card_no_event
+}
+
+function is_p2_card(c) {
+	return c >= first_p2_card && c <= last_p2_card_no_event
+}
+
+function is_card_in_use(c) {
+	if (set_has(game.hand1, c))
+		return true
+	if (set_has(game.hand2, c))
+		return true
+	if (set_has(game.events, c))
+		return true
+	if (set_has(game.capabilities, c))
+		return true
+	if (game.pieces.capabilities.includes(c))
+		return true
+	return false
+}
+
+function list_deck() {
+	let deck = []
+	let first_card = (game.active === P1) ? first_p1_card : first_p2_card
+	let last_card = (game.active === P1) ? last_p1_card : last_p2_card
+	for (let c = first_card; c <= last_card; ++c)
+		if (!is_card_in_use(c))
+			deck.push(c)
+	for (let c = last_card + 1; c <= last_card + no; ++c)
+		deck.push(c)
+	return deck
+}
+
+function is_friendly_card(c) {
+	if (game.active === P1)
+		return is_p1_card(c)
+	return is_p2_card(c)
+}
+
+function has_card_in_hand(c) {
+	if (game.active === P1)
+		return set_has(game.hand1, c)
+	return set_has(game.hand2, c)
+}
+
+function can_discard_card(c) {
+	if (set_has(game.hand1, c))
+		return true
+	if (set_has(game.hand2, c))
+		return true
+	if (set_has(game.capabilities, c))
+		return true
+	if (game.pieces.capabilities.includes(c))
+		return true
+}
+
+function is_lord_on_map(lord) {
+	let loc = get_lord_locale(lord)
+	return loc !== NOWHERE && loc < CALENDAR
+}
+
+function is_lord_in_play(lord) {
+	return get_lord_locale(lord) !== NOWHERE
+}
+/*
+function is_lord_besieged(lord) {
+	return false
+}
+
+function is_lord_unbesieged(lord) {
+	return true
+}*/
+
+function is_lord_on_calendar(lord) {
+	let loc = get_lord_locale(lord)
+	return loc >= CALENDAR
+}
+
+function is_lord_ready(lord) {
+	let loc = get_lord_locale(lord)
+	return loc >= CALENDAR && loc <= CALENDAR + (game.turn >> 1)
+}
+/*
+function is_special_vassal_available(vassal) {
+	let cap = data.vassals[vassal].capability
+	if (cap === "Crusade")
+		return has_global_capability(AOW_TEUTONIC_CRUSADE)
+	if (cap === "Steppe Warriors")
+		return has_global_capability(AOW_RUSSIAN_STEPPE_WARRIORS)
+	return true
+}*/
+
+function is_vassal_ready(vassal) {
+	return game.pieces.vassals[vassal] === VASSAL_READY
+}
+
+function is_vassal_mustered(vassal) {
+	return game.pieces.vassals[vassal] === VASSAL_MUSTERED
+}
+
+function is_york_lord(lord) {
+	return lord >= first_p1_lord && lord <= last_p1_lord
+}
+
+function is_lancaster_lord(lord) {
+	return lord >= first_p2_lord && lord <= last_p2_lord
+}
+
+function is_p1_lord(lord) {
+	return lord >= first_p1_lord && lord <= last_p1_lord
+}
+
+function is_friendly_lord(lord) {
+	return lord >= first_friendly_lord && lord <= last_friendly_lord
+}
+
+function is_lord_at_friendly_locale(lord) {
+	let loc = get_lord_locale(lord)
+	return is_friendly_locale(loc)
+}
+/*
+function used_seat_capability(lord, where, extra) {
+	let seats = data.lords[lord].seats
+	if (extra) {
+		if (set_has(seats, where) && !extra.includes(where))
+			return -1
+	} else {
+		if (set_has(seats, where))
+			return -1
+	}
+	if (is_teutonic_lord(lord))
+		if (has_global_capability(AOW_TEUTONIC_ORDENSBURGEN))
+			return AOW_TEUTONIC_ORDENSBURGEN
+	if (is_russian_lord(lord))
+		if (has_global_capability(AOW_RUSSIAN_ARCHBISHOPRIC))
+			return AOW_RUSSIAN_ARCHBISHOPRIC
+	return -1
+}*/
+/*
+function for_each_seat(lord, fn, repeat = false) {
+	let list = data.lords[lord].seats
+
+	for (let seat of list)
+		fn(seat)
+
+	if (is_teutonic_lord(lord)) {
+		if (has_global_capability(AOW_TEUTONIC_ORDENSBURGEN)) {
+			for (let commandery of COMMANDERIES)
+				if (repeat || !set_has(list, commandery))
+					fn(commandery)
+		}
+	}
+
+	if (is_russian_lord(lord)) {
+		if (has_global_capability(AOW_RUSSIAN_ARCHBISHOPRIC))
+			if (repeat || !set_has(list, LOC_NOVGOROD))
+				fn(LOC_NOVGOROD)
+	}
+
+	if (lord === LORD_YAROSLAV) {
+		if (has_conquered_marker(LOC_PSKOV))
+			if (repeat || !set_has(list, LOC_PSKOV))
+				fn(LOC_PSKOV)
+	}
+}*/
+
+function is_lord_seat(lord, here) {
+	let result = false
+	for_each_seat(lord, seat => {
+		if (seat === here)
+			result = true
+	})
+	return result
+}
+
+function is_lord_at_seat(lord) {
+	return is_lord_seat(lord, get_lord_locale(lord))
+}
+
+function has_free_seat(lord) {
+	let result = false
+	for_each_seat(lord, seat => {
+		if (!result && is_friendly_locale(seat))
+			result = true
+	})
+	return result
+}
+
+function has_york_lord(here) {
+	for (let lord = first_p1_lord; lord <= last_p1_lord; ++lord)
+		if (get_lord_locale(lord) === here)
+			return true
+}
+
+function has_lancaster_lord(here) {
+	for (let lord = first_p2_lord; lord <= last_p2_lord; ++lord)
+		if (get_lord_locale(lord) === here)
+			return true
+}
+
+function has_friendly_lord(loc) {
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+		if (get_lord_locale(lord) === loc)
+			return true
+	return false
+}
+/*
+function has_besieged_friendly_lord(loc) {
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+		if (get_lord_locale(lord) === loc && is_lord_besieged(lord))
+			return true
+	return false
+}*/
+
+function has_enemy_lord(loc) {
+	for (let lord = first_enemy_lord; lord <= last_enemy_lord; ++lord)
+		if (get_lord_locale(lord) === loc)
+			return true
+	return false
+}
+/*
+function has_unbesieged_enemy_lord(loc) {
+	for (let lord = first_enemy_lord; lord <= last_enemy_lord; ++lord)
+		if (get_lord_locale(lord) === loc && is_lord_unbesieged(lord))
+			return true
+	return false
+}
+
+function has_unbesieged_friendly_lord(loc) {
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+		if (get_lord_locale(lord) === loc && is_lord_unbesieged(lord))
+			return true
+	return false
+}
+*/
+function is_p1_locale(loc) {
+	return loc >= first_p1_locale && loc <= last_p1_locale
+}
+
+function is_p2_locale(loc) {
+	return loc >= first_p2_locale && loc <= last_p2_locale
+}
+/*
+function is_friendly_territory(loc) {
+	if (game.active === P1)
+		return loc >= first_p1_locale && loc <= last_p1_locale
+	return loc >= first_p2_locale && loc <= last_p2_locale
+}
+
+function is_enemy_territory(loc) {
+	if (game.active === P1)
+		return loc >= first_p2_locale && loc <= last_p2_locale
+	return loc >= first_p1_locale && loc <= last_p1_locale
+}*/
+
+function is_seaport(loc) {
+	return set_has(data.seaports, loc)
+}
+
+function is_city(loc) {
+	return data.locales[loc].type === "city"
+}
+
+function is_town(loc) {
+	return data.locales[loc].type === "town"
+}
+
+function is_fortress(loc) {
+	return data.locales[loc].type === "fortress"
+}
+
+function is_calais(loc) {
+	return data.locales[loc].type === "calais"
+}
+
+function is_sea(loc) {
+	return data.locales[loc].type === "sea"
+}
+
+function is_london(loc) {
+	return data.locales[loc].type === "london"
+}
+
+function is_harlech(loc) {
+	return data.locales[loc].type === "harlech"
+}
+
+function is_stronghold(loc) {
+	return data.locales[loc].stronghold > 0
+}
+
+function has_favour_marker(loc) {
+	return set_has(game.pieces.favour, loc)
+}
+
+function add_favour_marker(loc) {
+	set_add(game.pieces.favour, loc)
+}
+
+function remove_favour_marker(loc) {
+	set_delete(game.pieces.favour, loc)
+}
+
+function has_exhausted_marker(loc) {
+	return set_has(game.pieces.exhausted, loc)
+}
+
+function add_exhausted_marker(loc) {
+	set_add(game.pieces.exhausted, loc)
+}
+
+function remove_exhausted_marker(loc) {
+	set_delete(game.pieces.ravaged, loc)
+}
+/*
+function conquer_trade_route(loc) {
+	if (game.active === RUSSIANS) {
+		if (has_conquered_marker(loc)) {
+			log(`Conquered %${loc}.`)
+			remove_conquered_marker(loc)
+		}
+	} else {
+		if (!has_conquered_marker(loc)) {
+			log(`Conquered %${loc}.`)
+			add_conquered_marker(loc)
+		}
+	}
+}
+
+
+function conquer_stronghold(loc) {
+	if (has_castle_marker(loc))
+		flip_castle(loc)
+
+	remove_all_siege_markers(loc)
+
+	if (is_enemy_territory(loc))
+		add_conquered_marker(loc)
+	else
+		remove_conquered_marker(loc)
+}
+
+function count_castles() {
+	return game.pieces.castles1.length + game.pieces.castles2.length
+}
+
+function add_friendly_castle(loc) {
+	// only P1 can add
+	set_add(game.pieces.castles1, loc)
+}
+
+function has_enemy_castle(loc) {
+	if (game.active === P1)
+		return set_has(game.pieces.castles2, loc)
+	return set_has(game.pieces.castles1, loc)
+}
+
+function has_friendly_castle(loc) {
+	if (game.active === P1)
+		return set_has(game.pieces.castles1, loc)
+	return set_has(game.pieces.castles2, loc)
+}
+
+function has_castle_marker(loc) {
+	return (
+		set_has(game.pieces.castles1, loc) ||
+		set_has(game.pieces.castles2, loc)
+	)
+}
+
+function flip_castle(loc) {
+	if (game.active === P1) {
+		set_delete(game.pieces.castles2, loc)
+		set_add(game.pieces.castles1, loc)
+	} else {
+		set_delete(game.pieces.castles1, loc)
+		set_add(game.pieces.castles2, loc)
+	}
+}
+
+
+function is_friendly_stronghold_locale(loc) {
+	if (is_stronghold(loc) || has_friendly_castle(loc))
+		return is_friendly_locale(loc)
+	return false
+} 
+function is_enemy_stronghold(loc) {
+	if (is_stronghold(loc)) {
+		if (is_enemy_territory(loc) && !has_conquered_marker(loc))
+			return true
+		if (is_friendly_territory(loc) && has_conquered_marker(loc))
+			return true
+	}
+	if (has_enemy_castle(loc))
+		return true
+	return false
+}
+
+function is_friendly_stronghold(loc) {
+	if (is_stronghold(loc)) {
+		if (is_friendly_territory(loc) && !has_conquered_marker(loc))
+			return true
+		if (is_enemy_territory(loc) && has_conquered_marker(loc))
+			return true
+	}
+	if (has_friendly_castle(loc))
+		return true
+	return false
+}
+/*
+function is_unbesieged_enemy_stronghold(loc) {
+	return is_enemy_stronghold(loc) && !has_siege_marker(loc)
+}
+
+function is_unbesieged_friendly_stronghold(loc) {
+	return is_friendly_stronghold(loc) && !has_siege_marker(loc)
+}
+
+function is_besieged_enemy_stronghold(loc) {
+	return is_enemy_stronghold(loc) && has_siege_marker(loc)
+} 
+*/
+function is_friendly_locale(loc) {
+	if (loc !== NOWHERE && loc < CALENDAR) {
+		if (has_enemy_lord(loc))
+			return false
+		if (has_favour_marker(loc)) { //to add friendly favour marker later
+			return true
+		}
+	}
+	return false
+}
+
+function can_add_transport(who, what) {
+	return get_lord_assets(who, what) < 100
+}
+
+function count_lord_transport(lord, type) {
+	let season = current_season()
+	let n = 0
+	n += get_lord_assets(lord, CART)
+	return n
+}
+
+function list_ways(from, to) {
+	for (let ways of data.locales[from].ways)
+		if (ways[0] === to)
+			return ways
+	return null
+}
+/*
+function is_upper_lord(lord) {
+	return map_has(game.pieces.lieutenants, lord)
+}
+
+function is_lower_lord(lord) {
+	for (let i = 1; i < game.pieces.lieutenants.length; i += 2)
+		if (game.pieces.lieutenants[i] === lord)
+			return true
+	return false
+}
+
+function get_lower_lord(upper) {
+	return map_get(game.pieces.lieutenants, upper, NOBODY)
+}
+
+function set_lower_lord(upper, lower) {
+	map_set(game.pieces.lieutenants, upper, lower)
+}
+
+function add_lieutenant(upper) {
+	map_set(game.pieces.lieutenants, upper, NOBODY)
+}
+
+function remove_lieutenant(lord) {
+	for (let i = 0; i < game.pieces.lieutenants.length; i += 2) {
+		if (game.pieces.lieutenants[i] === lord || game.pieces.lieutenants[i + 1] === lord) {
+			array_remove_pair(game.pieces.lieutenants, i)
+			return
+		}
+	}
+}*/
+
+function group_has_capability(c) {
+	for (let lord of game.group)
+		if (lord_has_capability(lord, c))
+			return true
+	return false
+}
+/*
+function count_unbesieged_friendly_lords(loc) {
+	let n = 0
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+		if (get_lord_locale(lord) === loc && is_lord_unbesieged(lord))
+			++n
+	return n
+}
+*/
+// === MAP ===
+
+function calculate_distance(start, adjacent) {
+	let queue = []
+	queue.push([start, 0])
+
+	let distance = new Array(last_locale+1).fill(-1)
+	distance[start] = 0
+
+	while (queue.length > 0) {
+		let [ here, d ] = queue.shift()
+		for (let next of data.locales[here][adjacent]) {
+			if (distance[next] < 0) {
+				distance[next] = d+1
+				queue.push([next, d+1])
+			}
+		}
+	}
+
+	return distance
+}
+
+for (let loc = 0; loc <= last_locale; ++loc)
+	data.locales[loc].distance = calculate_distance(loc, "adjacent")
+
+function locale_distance(from, to) {
+	return data.locales[from].distance[to]
+}
+
+// === SETUP ===
+
+function muster_lord_forces(lord) {
+	let info = data.lords[lord]
+	set_lord_forces(lord, RETINUE, info.forces.retinue | 0)
+	set_lord_forces(lord, MEN_AT_ARMS, info.forces.men_at_arms | 0)
+	set_lord_forces(lord, MILITIA, info.forces.militia | 0)
+	set_lord_forces(lord, LONGBOWMEN, info.forces.longbowmen | 0)
+}
+/*
+function muster_vassal_forces(lord, vassal) {
+	let info = data.vassals[vassal]
+	add_lord_forces(lord, RETINUE, info.forces.knights | 0)
+	add_lord_forces(lord, SERGEANTS, info.forces.sergeants | 0)
+	add_lord_forces(lord, LIGHT_HORSE, info.forces.light_horse | 0)
+	add_lord_forces(lord, ASIATIC_HORSE, info.forces.asiatic_horse | 0)
+	add_lord_forces(lord, MEN_AT_ARMS, info.forces.men_at_arms | 0)
+	add_lord_forces(lord, MILITIA, info.forces.militia | 0)
+	add_lord_forces(lord, SERFS, info.forces.serfs | 0)
+}*/
+
+function restore_lord_forces(lord, type, count) {
+	if (get_lord_forces(lord, type) < count) {
+		set_lord_forces(lord, type, count)
+		return 1
+	}
+	return 0
+}
+
+function muster_lord(lord, locale) {
+	let info = data.lords[lord]
+
+	set_lord_locale(lord, locale)
+
+	set_lord_assets(lord, PROV, info.assets.prov | 0)
+	set_lord_assets(lord, COIN, info.assets.coin | 0)
+
+	set_lord_assets(lord, CART, info.assets.cart | 0)
+	set_lord_assets(lord, SHIP, info.assets.ship | 0)
+
+	muster_lord_forces(lord)
+}
+/*
+function disband_vassal(vassal) {
+	let info = data.vassals[vassal]
+	let lord = data.vassals[vassal].lord
+
+	add_lord_forces(lord, KNIGHTS, -(info.forces.knights | 0))
+	add_lord_forces(lord, SERGEANTS, -(info.forces.sergeants | 0))
+	add_lord_forces(lord, LIGHT_HORSE, -(info.forces.light_horse | 0))
+	add_lord_forces(lord, ASIATIC_HORSE, -(info.forces.asiatic_horse | 0))
+	add_lord_forces(lord, MEN_AT_ARMS, -(info.forces.men_at_arms | 0))
+	add_lord_forces(lord, MILITIA, -(info.forces.militia | 0))
+	add_lord_forces(lord, SERFS, -(info.forces.serfs | 0))
+
+	game.pieces.vassals[vassal] = VASSAL_READY
+
+	if (!lord_has_unrouted_units(lord)) {
+		disband_lord(lord)
+	}
+} */
+
+function muster_vassal(lord, vassal) {
+	game.pieces.vassals[vassal] = VASSAL_MUSTERED
+	muster_vassal_forces(lord, vassal)
+}
+
+function draw_card(deck) {
+	let i = random(deck.length)
+	let c = deck[i]
+	set_delete(deck, c)
+	return c
+}
+
+function discard_events(when) {
+	for (let i = 0; i < game.events.length; ) {
+		let c = game.events[i]
+		if (data.cards[c].when === when)
+			array_remove(game.events, i)
+		else
+			++i
+	}
+}
+
+function discard_friendly_events(when) {
+	for (let i = 0; i < game.events.length; ) {
+		let c = game.events[i]
+		if (is_friendly_card(c) && data.cards[c].when === when)
+			array_remove(game.events, i)
+		else
+			++i
+	}
+}
+
+exports.setup = function (seed, scenario, options) {
+	game = {
+		seed,
+		scenario,
+		hidden: options.hidden ? 1 : 0,
+
+		log: [],
+		undo: [],
+
+		active: P1,
+		state: "setup_lords",
+		stack: [],
+
+		hand1: [],
+		hand2: [],
+		plan1: [],
+		plan2: [],
+
+		turn: 0,
+		events: [], // this levy/this campaign cards
+		capabilities: [], // global capabilities
+
+		pieces: {
+			locale: Array(lord_count).fill(NOWHERE),
+			service: Array(lord_count).fill(NEVER),
+			assets: Array(lord_count).fill(0),
+			forces: Array(lord_count).fill(0),
+			routed: Array(lord_count).fill(0),
+			capabilities: Array(lord_count << 1).fill(NOTHING),
+			besieged: 0,
+			moved: 0,
+			vassals: Array(vassal_count).fill(VASSAL_UNAVAILABLE),
+			favour: [],
+		},
+
+		flags: {
+			first_action: 0,
+			first_march: 0,
+		},
+
+		command: NOBODY,
+		actions: 0,
+		group: 0,
+		who: NOBODY,
+		where: NOWHERE,
+		what: NOTHING,
+		count: 0,
+
+		supply: 0,
+		march: 0,
+		battle: 0,
+		spoils: 0,
+	}
+
+	update_aliases()
+
+	log_h1(scenario)
+
+	switch (scenario) {
+		default:
+		case "Ia. Henry VI":
+			setup_Ia()
+			break
+	}
+
+	return game
+}
+
+function setup_Ia() {
+	game.turn = 1 << 1
+
+	muster_lord(LORD_YORK, LOC_ELY)
+	muster_lord(LORD_MARCH, LOC_LUDLOW)
+	muster_lord(LORD_HENRYVI, LOC_LONDON)
+	muster_lord(LORD_SOMERSET, LOC_WELLS)
+
+	set_lord_cylinder_on_calendar(LORD_NORTHUMBERLANDL, 2)
+	set_lord_cylinder_on_calendar(LORD_EXETER, 3)
+	set_lord_cylinder_on_calendar(LORD_BUCKINGHAM, 5)
+	set_lord_cylinder_on_calendar(LORD_SALISBURY, 2)
+	set_lord_cylinder_on_calendar(LORD_WARWICKY, 3)
+	set_lord_cylinder_on_calendar(LORD_RUTLAND, 5)
+}
+/*
+states.setup_lords = {
+	inactive: "Set up Lords",
+	prompt() {
+		view.prompt = "Set up your Lords."
+		let done = true
+		for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+			if (is_lord_on_map(lord) && !get_lord_moved(lord)) {
+				if (data.lords[lord].assets.transport > 0) {
+					gen_action_lord(lord)
+					done = false
+				}
+			}
+		}
+		if (done) {
+			view.prompt += " All done."
+			view.actions.end_setup = 1
+		}
+	},
+	
+	lord(lord) {
+		push_undo()
+
+		// FIXME: clean up these transitions
+		push_state("muster_lord_transport")
+		set_lord_moved(lord, 1)
+		game.who = lord
+		game.count = data.lords[lord].assets.transport
+	},
+
+} */
+
+
+function end_setup() {
+	clear_lords_moved()
+	set_active_enemy()
+	if (game.active === P1) {
+		log_h1("Levy " + current_turn_name())
+		goto_levy_arts_of_war_first()
+	}
+}
+
+// === EVENTS ===
+
+function is_event_in_play(c) {
+	return set_has(game.events, c)
+}
+
+function is_ravens_rock_in_play() {
+	if (game.battle.round <= 1 && is_melee_step()) {
+		if (game.active === RUSSIANS)
+			return is_event_in_play(EVENT_RUSSIAN_RAVENS_ROCK)
+	}
+	return false
+}
+
+function is_marsh_in_play() {
+	if (game.battle.round <= 2) {
+		if (game.active === TEUTONS && is_event_in_play(EVENT_RUSSIAN_MARSH))
+			return true
+		if (game.active === RUSSIANS && is_event_in_play(EVENT_TEUTONIC_MARSH))
+			return true
+	}
+	return false
+}
+
+function is_hill_in_play() {
+	if (game.battle.round <= 2) {
+		if (game.active === TEUTONS && is_event_in_play(EVENT_TEUTONIC_HILL))
+			return true
+		if (game.active === RUSSIANS && is_event_in_play(EVENT_RUSSIAN_HILL))
+			return true
+	}
+	return false
+}
+
+function is_famine_in_play() {
+	if (game.active === TEUTONS)
+		if (is_event_in_play(EVENT_RUSSIAN_FAMINE))
+			return true
+	if (game.active === RUSSIANS)
+		if (is_event_in_play(EVENT_TEUTONIC_FAMINE))
+			return true
+	return false
+}
+
+function no_muster_of_or_by_lord(lord) {
+	if (lord === LORD_KNUD_ABEL)
+		return is_event_in_play(EVENT_RUSSIAN_VALDEMAR)
+	if (lord === LORD_ANDREAS || lord === LORD_RUDOLF)
+		return is_event_in_play(EVENT_RUSSIAN_DIETRICH_VON_GRUNINGEN)
+	return false
+}
+
+function goto_immediate_event(c) {
+	switch (c) {
+		// This Levy / Campaign
+		case EVENT_TEUTONIC_FAMINE:
+		case EVENT_RUSSIAN_FAMINE:
+			set_add(game.events, c)
+			// No immediate effects
+			return end_immediate_event()
+		case EVENT_RUSSIAN_DEATH_OF_THE_POPE:
+			set_add(game.events, c)
+			return goto_russian_event_death_of_the_pope()
+		case EVENT_RUSSIAN_VALDEMAR:
+			set_add(game.events, c)
+			return goto_russian_event_valdemar()
+		case EVENT_RUSSIAN_DIETRICH_VON_GRUNINGEN:
+			set_add(game.events, c)
+			return goto_russian_event_dietrich()
+
+		// Add to capabilities...
+		case EVENT_TEUTONIC_POPE_GREGORY:
+			deploy_global_capability(c)
+			return goto_teutonic_event_pope_gregory()
+
+		// Discard
+		case EVENT_TEUTONIC_GRAND_PRINCE:
+			return goto_teutonic_event_grand_prince()
+		case EVENT_TEUTONIC_KHAN_BATY:
+			return goto_teutonic_event_khan_baty()
+		case EVENT_TEUTONIC_SWEDISH_CRUSADE:
+			return goto_teutonic_event_swedish_crusade()
+		case EVENT_RUSSIAN_OSILIAN_REVOLT:
+			return goto_russian_event_osilian_revolt()
+		case EVENT_RUSSIAN_BATU_KHAN:
+			return goto_russian_event_batu_khan()
+		case EVENT_RUSSIAN_PRUSSIAN_REVOLT:
+			return goto_russian_event_prussian_revolt()
+		case EVENT_TEUTONIC_BOUNTIFUL_HARVEST:
+			return goto_event_bountiful_harvest()
+		case EVENT_RUSSIAN_BOUNTIFUL_HARVEST:
+			return goto_event_bountiful_harvest()
+		case EVENT_TEUTONIC_MINDAUGAS:
+			return goto_teutonic_event_mindaugas()
+		case EVENT_RUSSIAN_MINDAUGAS:
+			return goto_russian_event_mindaugas()
+		case EVENT_TEUTONIC_TORZHOK:
+			return goto_teutonic_event_torzhok()
+		case EVENT_RUSSIAN_TEMPEST:
+			return goto_russian_event_tempest()
+
+		default:
+			log("NOT IMPLEMENTED")
+			return end_immediate_event()
+	}
+}
+
+function end_immediate_event() {
+	clear_undo()
+	resume_levy_arts_of_war()
+}
+
+// === EVENTS: UNIQUE IMMEDIATE EVENTS ===
+
+// === EVENTS: SHIFT LORD OR SERVICE (IMMEDIATE) ===
+/*
+function prompt_shift_lord_on_calendar(boxes) {
+	if (game.who !== NOBODY) {
+		// Shift in direction beneficial to active player.
+		if (is_friendly_lord(game.who)) {
+			if (is_lord_on_calendar(game.who))
+				gen_action_calendar(get_lord_calendar(game.who) - boxes)
+			else
+				gen_action_calendar(get_lord_calendar(game.who) + boxes)
+		} else {
+			if (is_lord_on_calendar(game.who))
+				gen_action_calendar(get_lord_calendar(game.who) + boxes)
+			else
+				gen_action_calendar(get_lord_calendar(game.who) - boxes)
+		}
+	}
+}
+*/
+// === EVENTS: HOLD ===
+
+function play_held_event(c) {
+	log(`Played E${c}.`)
+	if (c >= first_p1_card && c <= last_p1_card_no_event)
+		set_delete(game.hand1, c)
+	else
+		set_delete(game.hand2, c)
+}
+
+function end_held_event() {
+	pop_state()
+	game.what = NOTHING
+}
+
+function prompt_held_event() {
+	for (let c of current_hand())
+		if (can_play_held_event(c))
+			gen_action_card(c)
+}
+
+function prompt_held_event_lordship() {
+	for (let c of current_hand())
+		if (can_play_held_event(c) || can_play_held_event_lordship(c))
+			gen_action_card(c)
+}
+
+function can_play_held_event(c) {
+	switch (c) {
+	}
+	return false
+}
+
+function can_play_held_event_lordship(c) {
+	switch (c) {
+	}
+	return false
+}
+
+function action_held_event(c) {
+	push_undo()
+	play_held_event(c)
+	game.what = c
+	goto_held_event(c)
+}
+
+function goto_held_event(c) {
+	switch (c) {
+	}
+}
+
+// === EVENTS: HOLD - UNIQUE ===
+
+// === EVENTS: HOLD - SHIFT CYLINDER ===
+
+function action_held_event_lordship(c) {
+	push_undo()
+	play_held_event(c)
+	if (can_play_held_event(c)) {
+		goto_held_event(c)
+		game.what = c
+	} else {
+		push_state("lordship")
+		game.what = c
+	}
+}
+/*
+states.lordship = {
+	get inactive() {
+		return data.cards[game.what].event
+	},
+	prompt() {
+		view.prompt = `${data.cards[game.what].event}: Play for +2 Lordship.`
+		view.actions.lordship = 1
+	},
+	lordship() {
+		end_held_event()
+		log("+2 Lordship")
+		game.count += 2
+	}
+}*/
+
+function prompt_shift_cylinder(list, boxes) {
+
+	// HACK: look at parent state to see if this can be used as a +2 Lordship event
+	let lordship = NOBODY
+	let parent = game.stack[game.stack.length-1]
+	if (parent[0] === "levy_muster_lord")
+		lordship = parent[1]
+
+	let names
+	if (game.what === EVENT_RUSSIAN_PRINCE_OF_POLOTSK)
+		names = "a Russian Lord"
+	else
+		names = list.filter(lord => is_lord_on_calendar(lord)).map(lord => lord_name[lord]).join(" or ")
+
+	if (boxes === 1)
+		view.prompt = `${data.cards[game.what].event}: Shift ${names} 1 Calendar box`
+	else
+		view.prompt = `${data.cards[game.what].event}: Shift ${names} 2 Calendar boxes`
+
+	for (let lord of list) {
+		if (lord === lordship) {
+			view.prompt += " or +2 Lordship"
+			view.actions.lordship = 1
+		}
+		if (is_lord_on_calendar(lord))
+			prompt_select_lord(lord)
+	}
+
+	view.prompt += "."
+
+	prompt_shift_lord_on_calendar(boxes)
+}
+/*
+function action_shift_cylinder_calendar(turn) {
+	log(`Shifted L${game.who} to ${turn}.`)
+	set_lord_calendar(game.who, turn)
+	game.who = NOBODY
+	end_held_event()
+}
+
+function action_shift_cylinder_lordship() {
+	end_held_event()
+	log("+2 Lordship")
+	game.count += 2
+}*/
+
+// === CAPABILITIES ===
+
+// === LEVY: ARTS OF WAR (FIRST TURN) ===
+
+function draw_two_cards() {
+	let deck = list_deck()
+	return [ draw_card(deck), draw_card(deck) ]
+}
+
+function discard_card_capability(c) {
+	log(`${game.active} discarded C${c}.`)
+}
+
+function discard_card_event(c) {
+	log(`${game.active} discarded E${c}.`)
+}
+
+function goto_levy_arts_of_war_first() {
+	if (game.active === TEUTONS)
+		log_h2("Teutonic Arts of War")
+	else
+		log_h2("Russian Arts of War")
+	game.state = "levy_arts_of_war_first"
+	game.what = draw_two_cards()
+}
+
+function resume_levy_arts_of_war_first() {
+	if (game.what.length === 0)
+		end_levy_arts_of_war_first()
+}
+
+states.levy_arts_of_war_first = {
+	inactive: "Arts of War",
+	prompt() {
+		let c = game.what[0]
+		view.arts_of_war = game.what
+		view.what = c
+		if (is_no_event_card(c)) {
+			view.prompt = `Arts of War: No Capability.`
+			view.actions.discard = 1
+		} else if (data.cards[c].this_lord) {
+			let discard = true
+			for (let lord of data.cards[c].lords) {
+				if (is_lord_on_map(lord) && !lord_already_has_capability(lord, c)) {
+					gen_action_lord(lord)
+					discard = false
+				}
+			}
+			if (discard) {
+				view.prompt = `Arts of War: Discard ${data.cards[c].capability}.`
+				view.actions.discard = 1
+			} else {
+				view.prompt = `Arts of War: Assign ${data.cards[c].capability} to a Lord.`
+			}
+		} else {
+			view.prompt = `Arts of War: Deploy ${data.cards[c].capability}.`
+			view.actions.deploy = 1
+		}
+	},
+	lord(lord) {
+		push_undo()
+		let c = game.what.shift()
+		log(`${game.active} deployed Capability.`)
+		add_lord_capability(lord, c)
+		resume_levy_arts_of_war_first()
+	},
+	deploy() {
+		push_undo()
+		let c = game.what.shift()
+		log(`${game.active} deployed C${c}.`)
+		deploy_global_capability(c)
+		resume_levy_arts_of_war_first()
+	},
+	discard() {
+		push_undo()
+		let c = game.what.shift()
+		discard_card_capability(c)
+		resume_levy_arts_of_war_first()
+	},
+}
+
+
+function end_levy_arts_of_war_first() {
+	clear_undo()
+	game.what = NOTHING
+	set_active_enemy()
+	if (game.active === P2)
+		goto_levy_arts_of_war_first()
+	else
+		goto_pay()
+}
+
+// === LEVY: ARTS OF WAR ===
+
+function goto_levy_arts_of_war() {
+	if (game.active === TEUTONS)
+		log_h2("Teutonic Arts of War")
+	else
+		log_h2("Russian Arts of War")
+	game.what = draw_two_cards()
+	resume_levy_arts_of_war()
+}
+
+function resume_levy_arts_of_war() {
+	game.state = "levy_arts_of_war"
+	if (game.what.length === 0)
+		end_levy_arts_of_war()
+}
+
+states.levy_arts_of_war = {
+	inactive: "Arts of War",
+	prompt() {
+		let c = game.what[0]
+		view.arts_of_war = [ c ]
+		view.what = c
+		switch (data.cards[c].when) {
+			case "this_levy":
+			case "this_campaign":
+			case "now":
+				view.prompt = `Arts of War: Play ${data.cards[c].event}.`
+				view.actions.play = 1
+				break
+			case "hold":
+				view.prompt = `Arts of War: Hold ${data.cards[c].event}.`
+				view.actions.hold = 1
+				break
+			case "never":
+				view.prompt = `Arts of War: Discard ${data.cards[c].event}.`
+				view.actions.discard = 1
+				break
+		}
+	},
+	play() {
+		let c = game.what.shift()
+		log(`${game.active} played E${c}.`)
+		goto_immediate_event(c)
+	},
+	hold() {
+		let c = game.what.shift()
+		log(`${game.active} Held Event.`)
+		if (game.active === P1)
+			set_add(game.hand1, c)
+		else
+			set_add(game.hand2, c)
+		resume_levy_arts_of_war()
+	},
+	discard() {
+		let c = game.what.shift()
+		discard_card_event(c)
+		resume_levy_arts_of_war()
+	},
+}
+
+function end_levy_arts_of_war() {
+	game.what = NOTHING
+	set_active_enemy()
+	if (game.active === P2)
+		goto_levy_arts_of_war()
+	else
+		goto_pay()
+}
+
+// === LEVY: MUSTER ===
+
+function goto_levy_muster() {
+	if (game.active === TEUTONS)
+		log_h2("Teutonic Muster")
+	else
+		log_h2("Russian Muster")
+	game.state = "levy_muster"
+}
+
+function end_levy_muster() {
+	clear_lords_moved()
+	set_active_enemy()
+	if (game.active === P2)
+		goto_levy_muster()
+	else
+		goto_levy_call_to_arms()
+}
+
+states.levy_muster = {
+	inactive: "Muster",
+	prompt() {
+		view.prompt = "Levy: Muster with your Lords."
+
+		prompt_held_event()
+
+		let done = true
+		for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+			if (is_lord_at_friendly_locale(lord) && !get_lord_moved(lord)) {
+				if (!no_muster_of_or_by_lord(lord)) {
+					gen_action_lord(lord)
+					done = false
+				}
+			}
+		}
+		if (done) {
+			view.prompt += " All done."
+			view.actions.end_muster = 1
+		}
+	},
+	lord(lord) {
+		push_undo()
+		log(`Mustered with L${lord}.`)
+		push_state("levy_muster_lord")
+		game.who = lord
+		game.count = data.lords[lord].lordship
+	},
+	end_muster() {
+		clear_undo()
+		end_levy_muster()
+	},
+	card: action_held_event,
+}
+
+function resume_levy_muster_lord() {
+	--game.count
+	if (game.count === 0) {
+		set_lord_moved(game.who, 1)
+		pop_state()
+	}
+}
+
+states.levy_muster_lord = {
+	inactive: "Muster",
+	prompt() {
+		if (game.count === 1)
+			view.prompt = `Levy: ${lord_name[game.who]} has ${game.count} action.`
+		else
+			view.prompt = `Levy: ${lord_name[game.who]} has ${game.count} actions.`
+
+		prompt_held_event_lordship()
+
+		if (game.count > 0) {
+			// Roll to muster Ready Lord at Seat
+			for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+				if (no_muster_of_or_by_lord(lord))
+					continue
+				if (is_lord_ready(lord) && has_free_seat(lord))
+					gen_action_lord(lord)
+			}
+
+			// Muster Ready Vassal Forces
+			for (let vassal of data.lords[game.who].vassals) {
+				if (is_vassal_ready(vassal))
+					gen_action_vassal(vassal)
+			}
+
+			// Add Transport
+			if (data.lords[game.who].ships) {
+				if (can_add_transport(game.who, SHIP))
+					view.actions.take_ship = 1
+			}
+			if (can_add_transport(game.who, CART))
+				view.actions.take_cart = 1
+
+			// Add Capability
+			if (can_muster_capability())
+				view.actions.capability = 1
+		}
+
+		view.actions.done = 1
+	},
+
+	card: action_held_event_lordship,
+
+	lord(other) {
+		clear_undo()
+		let die = roll_die()
+		let fealty = data.lords[other].fealty
+		if (die <= fealty) {
+			log(`L${other} ${range(fealty)}: ${HIT[die]}`)
+			push_state("muster_lord_at_seat")
+			game.who = other
+		} else {
+			log(`L${other} ${range(fealty)}: ${MISS[die]}`)
+			resume_levy_muster_lord()
+		}
+	},
+
+	vassal(vassal) {
+		push_undo()
+		muster_vassal(game.who, vassal)
+		resume_levy_muster_lord()
+	},
+
+	take_ship() {
+		push_undo()
+		add_lord_assets(game.who, SHIP, 1)
+		resume_levy_muster_lord()
+	},
+	take_cart() {
+		push_undo()
+		add_lord_assets(game.who, CART, 1)
+		resume_levy_muster_lord()
+	},
+
+	capability() {
+		push_undo()
+		push_state("muster_capability")
+	},
+
+	done() {
+		set_lord_moved(game.who, 1)
+		pop_state()
+	},
+}
+
+states.muster_lord_at_seat = {
+	inactive: "Muster",
+	prompt() {
+		view.prompt = `Muster: Select Seat for ${lord_name[game.who]}.`
+		for_each_seat(game.who, seat => {
+			if (is_friendly_locale(seat))
+				gen_action_locale(seat)
+		})
+	},
+	locale(loc) {
+		push_undo()
+
+		let cap = used_seat_capability(game.who, loc)
+		if (cap >= 0)
+			log(`L${game.who} to %${loc} (C${cap}).`)
+		else
+			log(`L${game.who} to %${loc}.`)
+
+		// FIXME: clean up these transitions
+		set_lord_moved(game.who, 1)
+		muster_lord(game.who, loc)
+		game.state = "muster_lord_transport"
+		game.count = data.lords[game.who].assets.transport | 0
+		resume_muster_lord_transport()
+	},
+}
+
+function resume_muster_lord_transport() {
+	if (game.count === 0)
+		pop_state()
+	if (game.state === "levy_muster_lord")
+		resume_levy_muster_lord()
+}
+
+states.muster_lord_transport = {
+	inactive: "Muster",
+	prompt() {
+		if (game.state === "veliky_knyaz")
+			view.prompt = `Veliky Knyaz: Select Transport for ${lord_name[game.who]}.`
+		else
+			view.prompt = `Muster: Select Transport for ${lord_name[game.who]}.`
+		view.prompt += ` ${game.count} left.`
+		if (data.lords[game.who].ships) {
+			if (can_add_transport(game.who, SHIP))
+				view.actions.take_ship = 1
+		}
+		if (can_add_transport(game.who, CART))
+			view.actions.take_cart = 1
+	},
+	take_ship() {
+		push_undo()
+		add_lord_assets(game.who, SHIP, 1)
+		--game.count
+		resume_muster_lord_transport()
+	},
+	take_cart() {
+		push_undo()
+		add_lord_assets(game.who, CART, 1)
+		--game.count
+		resume_muster_lord_transport()
+	},
+}
+
+function lord_has_capability_card(lord, c) {
+	if (get_lord_capability(lord, 0) === c)
+		return true
+	if (get_lord_capability(lord, 1) === c)
+		return true
+	return false
+}
+
+function lord_has_capability(lord, card_or_list) {
+	if (Array.isArray(card_or_list)) {
+		for (let card of card_or_list)
+			if (lord_has_capability_card(lord, card))
+				return true
+		return false
+	}
+	return lord_has_capability_card(lord, card_or_list)
+}
+
+function lord_already_has_capability(lord, c) {
+	// compare capabilities by name...
+	let name = data.cards[c].capability
+	let c1 = get_lord_capability(lord, 0)
+	if (c1 >= 0 && data.cards[c1].capability === name)
+		return true
+	let c2 = get_lord_capability(lord, 1)
+	if (c2 >= 0 && data.cards[c2].capability === name)
+		return true
+	return false
+}
+
+function can_add_lord_capability(lord) {
+	if (get_lord_capability(lord, 0) < 0)
+		return true
+	if (get_lord_capability(lord, 1) < 0)
+		return true
+	return false
+}
+
+function add_lord_capability(lord, c) {
+	if (get_lord_capability(lord, 0) < 0)
+		return set_lord_capability(lord, 0, c)
+	if (get_lord_capability(lord, 1) < 0)
+		return set_lord_capability(lord, 1, c)
+	throw new Error("no empty capability slots!")
+}
+
+function discard_lord_capability_n(lord, n) {
+	set_lord_capability(lord, n, NOTHING)
+}
+
+function discard_lord_capability(lord, c) {
+	if (get_lord_capability(lord, 0) === c)
+		return set_lord_capability(lord, 0, NOTHING)
+	if (get_lord_capability(lord, 1) === c)
+		return set_lord_capability(lord, 1, NOTHING)
+	throw new Error("capability not found")
+}
+
+function can_muster_capability() {
+	let deck = list_deck()
+	for (let c of deck) {
+		if (is_no_event_card(c))
+			continue
+		if (!data.cards[c].lords || set_has(data.cards[c].lords, game.who)) {
+			if (data.cards[c].this_lord) {
+				if (!lord_already_has_capability(game.who, c))
+					return true
+			} else {
+				if (can_deploy_global_capability(c))
+					return true
+			}
+		}
+	}
+	return false
+}
+
+states.muster_capability = {
+	inactive: "Muster",
+	prompt() {
+		let deck = list_deck()
+		view.prompt = `Muster: Select a new Capability for ${lord_name[game.who]}.`
+		view.arts_of_war = deck
+		for (let c of deck) {
+			if (is_no_event_card(c))
+				continue
+			if (!data.cards[c].lords || set_has(data.cards[c].lords, game.who)) {
+				if (data.cards[c].this_lord) {
+					if (!lord_already_has_capability(game.who, c))
+						gen_action_card(c)
+				} else {
+					if (can_deploy_global_capability(c))
+						gen_action_card(c)
+				}
+			}
+		}
+	},
+	card(c) {
+		if (data.cards[c].this_lord) {
+			if (can_add_lord_capability(game.who, c)) {
+				add_lord_capability(game.who, c)
+			} else {
+				game.what = c
+				game.state = "muster_capability_discard"
+				return
+			}
+		} else {
+			deploy_global_capability(c)
+		}
+		pop_state()
+		resume_levy_muster_lord()
+	},
+}
+
+states.muster_capability_discard = {
+	inactive: "Muster",
+	prompt() {
+		view.prompt = `Muster: Remove a Capability from ${lord_name[game.who]}.`
+		gen_action_card(get_lord_capability(game.who, 0))
+		gen_action_card(get_lord_capability(game.who, 1))
+	},
+	card(c) {
+		push_undo()
+		discard_lord_capability(game.who, c)
+		add_lord_capability(game.who, game.what)
+		game.what = NOTHING
+		pop_state()
+		resume_levy_muster_lord()
+	},
+}
+
+// === LEVY: CALL TO ARMS ===
+
+function goto_levy_call_to_arms() {
+	if (game.active === TEUTONS)
+		goto_teutonic_call_to_arms()
+	else
+		goto_russian_call_to_arms()
+}
+
+function end_levy_call_to_arms() {
+	clear_undo()
+	clear_lords_moved()
+	set_active_enemy()
+	if (game.active === P2)
+		goto_levy_call_to_arms()
+	else
+		goto_levy_discard_events()
+}
+
+function goto_levy_discard_events() {
+
+	// Discard "This Levy" events from play.
+	discard_events("this_levy")
+
+	set_active(P1)
+	goto_capability_discard()
+}
+
+// === LEVY: CALL TO ARMS - PAPAL LEGATE ===
+
+function goto_teutonic_call_to_arms() {
+	end_levy_call_to_arms()
+}
+
+// === LEVY: CALL TO ARMS - NOVGOROD VECHE ===
+
+function goto_russian_call_to_arms() {
+	end_levy_call_to_arms()
+}
+
+// === CAMPAIGN: CAPABILITY DISCARD ===
+
+function count_mustered_lords() {
+	let n = 0
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+		if (is_lord_on_map(lord))
+			++n
+	return n
+}
+
+function count_global_capabilities() {
+	let n = 0
+	for (let c of game.capabilities) {
+		if (game.active === P1 && c >= first_p1_card && c <= last_p1_card)
+			++n
+		if (game.active === P2 && c >= first_p2_card && c <= last_p2_card)
+			++n
+	}
+	return n
+}
+
+function goto_capability_discard() {
+
+	// Start of Campaign phase
+	if (check_campaign_victory())
+		return
+
+	if (count_global_capabilities() > count_mustered_lords())
+		game.state = "capability_discard"
+	else
+		end_capability_discard()
+}
+
+states.capability_discard = {
+	inactive: "Discard Capabilities",
+	prompt() {
+		if (count_global_capabilities() > count_mustered_lords()) {
+			view.prompt = "Discard Capabilities in excess of Mustered Lords."
+			for (let c of game.capabilities) {
+				if (game.active === P1 && c >= first_p1_card && c <= last_p1_card)
+					gen_action_card(c)
+				if (game.active === P2 && c >= first_p2_card && c <= last_p2_card)
+					gen_action_card(c)
+			}
+		} else {
+			view.prompt = "Discard Capabilities: All done."
+			view.actions.end_discard = 1
+		}
+	},
+	card(c) {
+		push_undo()
+		discard_global_capability(c)
+	},
+	end_discard() {
+		clear_undo()
+		end_capability_discard()
+	},
+}
+
+function end_capability_discard() {
+	set_active_enemy()
+	if (game.active === P2)
+		goto_capability_discard()
+	else
+		goto_campaign_plan()
+}
+
+// === CAMPAIGN: PLAN ===
+
+function goto_campaign_plan() {
+	game.turn++
+
+	log_h1("Campaign " + current_turn_name())
+
+	set_active(BOTH)
+	game.state = "campaign_plan"
+	game.plan1 = []
+	game.plan2 = []
+}
+
+function plan_has_lieutenant(first, last) {
+	for (let lord = first; lord <= last; ++lord)
+		if (is_upper_lord(lord))
+			return true
+	return false
+}
+
+function plan_selected_lieutenant(first, last) {
+	for (let lord = first; lord <= last; ++lord)
+		if (is_upper_lord(lord) && get_lower_lord(lord) === NOBODY)
+			return lord
+	return NOBODY
+}
+
+function plan_can_make_lieutenant(plan, upper, first, last) {
+	for (let lord = first; lord <= last; ++lord) {
+		if (!is_lord_on_map(lord))
+			continue
+		if (lord === upper)
+			continue
+		if (is_marshal(lord) || is_lord_besieged(lord))
+			continue
+		if (is_upper_lord(lord) || is_lower_lord(lord))
+			continue
+		if (get_lord_locale(upper) === get_lord_locale(lord))
+			return true
+	}
+	return false
+}
+
+states.campaign_plan = {
+	inactive: "Plan",
+	prompt(current) {
+		let plan = current === P1 ? game.plan1 : game.plan2
+		let first = current === P1 ? first_p1_lord : first_p2_lord
+		let last = current === P1 ? last_p1_lord : last_p2_lord
+		let upper = plan_selected_lieutenant(first, last)
+
+		view.plan = plan
+		view.who = upper
+		view.actions.plan = []
+
+		if (plan.length === 0 && upper === NOBODY)
+			view.prompt = "Plan: Designate Lieutenants and build a Plan."
+		else if (plan.length === 0 && upper !== NOBODY)
+			view.prompt = `Plan: Select Lower Lord for ${lord_name[upper]}.`
+		else if (plan.length === max_plan_length())
+			view.prompt = "Plan: All done."
+		else
+			view.prompt = "Plan: Build a Plan."
+
+		if (upper === NOBODY) {
+			if (plan.length < max_plan_length()) {
+				view.actions.end_plan = 0
+				if (count_cards_in_plan(plan, NOBODY) < 3)
+					gen_action_plan(NOBODY)
+				for (let lord = first; lord <= last; ++lord) {
+					if (is_lord_on_map(lord) && count_cards_in_plan(plan, lord) < 3)
+						gen_action_plan(lord)
+				}
+			} else {
+				view.actions.end_plan = 1
+			}
+		} else {
+			view.actions.end_plan = 0
+		}
+
+		// Designate Lieutenants only if no plan started.
+		if (plan.length === 0) {
+			if (upper !== NOBODY)
+				gen_action_lord(upper)
+
+			for (let lord = first; lord <= last; ++lord) {
+				if (is_marshal(lord) || is_lord_besieged(lord))
+					continue
+				if (is_upper_lord(lord) || is_lower_lord(lord))
+					continue
+				if (upper === NOBODY) {
+					if (plan_can_make_lieutenant(plan, lord, first, last))
+						gen_action_lord(lord)
+				} else {
+					if (get_lord_locale(upper) === get_lord_locale(lord))
+						gen_action_lord(lord)
+				}
+			}
+		}
+
+		if (plan.length > 0 || plan_has_lieutenant(first, last))
+			view.actions.undo = 1
+		else
+			view.actions.undo = 0
+	},
+	lord(lord, current) {
+		let upper
+		if (current === P1)
+			upper = plan_selected_lieutenant(first_p1_lord, last_p1_lord)
+		else
+			upper = plan_selected_lieutenant(first_p2_lord, last_p2_lord)
+		if (lord === upper)
+			remove_lieutenant(upper)
+		else if (upper === NOBODY)
+			add_lieutenant(lord)
+		else
+			set_lower_lord(upper, lord)
+	},
+	plan(lord, current) {
+		if (current === P1)
+			game.plan1.push(lord)
+		else
+			game.plan2.push(lord)
+	},
+	undo(_, current) {
+		if (current === P1) {
+			if (game.plan1.length > 0) {
+				game.plan1.pop()
+			} else {
+				for (let lord = first_p1_lord; lord <= last_p1_lord; ++lord)
+					if (is_upper_lord(lord))
+						remove_lieutenant(lord)
+			}
+		} else {
+			if (game.plan2.length > 0) {
+				game.plan2.pop()
+			} else {
+				for (let lord = first_p2_lord; lord <= last_p2_lord; ++lord)
+					if (is_upper_lord(lord))
+						remove_lieutenant(lord)
+			}
+		}
+	},
+	end_plan(_, current) {
+		if (game.active === BOTH) {
+			if (current === P1)
+				set_active(P2)
+			else
+				set_active(P1)
+		} else {
+			end_campaign_plan()
+		}
+	},
+}
+
+function end_campaign_plan() {
+	if (game.pieces.lieutenants.length > 0) {
+		log("Lieutenants")
+		for (let i = 0; i < game.pieces.lieutenants.length; i += 2) {
+			let upper = game.pieces.lieutenants[i]
+			let lower = game.pieces.lieutenants[i + 1]
+			logi(`L${upper} over L${lower}`)
+		}
+	}
+
+	set_active(P1)
+	goto_command_activation()
+}
+
+// === CAMPAIGN: COMMAND ACTIVATION ===
+
+function goto_command_activation() {
+	if (game.plan2.length === 0) {
+		game.command = NOBODY
+		goto_end_campaign()
+		return
+	}
+
+	if (check_campaign_victory())
+		return
+
+	if (game.plan2.length > game.plan1.length) {
+		set_active(P2)
+		game.command = game.plan2.shift()
+	} else {
+		set_active(P1)
+		game.command = game.plan1.shift()
+	}
+
+	if (game.command === NOBODY) {
+		log_h2("Pass")
+		goto_command_activation()
+	} else if (is_lower_lord(game.command)) {
+		log_h2(`L${game.command} - Pass`)
+		goto_command_activation()
+	} else if (!is_lord_on_map(game.command)) {
+		log_h2(`L${game.command} - Pass`)
+		goto_command_activation()
+	} else {
+		log_h2(`L${game.command} at %${get_lord_locale(game.command)}`)
+		goto_command()
+	}
+}
+
+// === CAMPAIGN: ACTIONS ===
+
+function set_active_command() {
+	if (game.command >= first_p1_lord && game.command <= last_p1_lord)
+		set_active(P1)
+	else
+		set_active(P2)
+}
+
+function is_active_command() {
+	if (game.command >= first_p1_lord && game.command <= last_p1_lord)
+		return game.active === P1
+	else
+		return game.active === P2
+}
+
+function is_first_action() {
+	return game.flags.first_action
+}
+
+function is_first_march() {
+	return game.flags.first_march
+}
+
+function goto_command() {
+	game.actions = data.lords[game.command].command
+
+	game.flags.first_action = 1
+	game.flags.first_march = 1
+
+	// 4.1.3 Lieutenants MUST take lower lord
+	game.group = [ game.command ]
+	let lower = get_lower_lord(game.command)
+	if (lower !== NOBODY)
+		set_add(game.group, lower)
+
+	resume_command()
+	update_supply_possible()
+}
+
+function resume_command() {
+	game.state = "command"
+}
+
+function spend_action(cost) {
+	game.flags.first_action = 0
+	game.actions -= cost
+}
+
+function spend_march_action(cost) {
+	game.flags.first_action = 0
+	game.flags.first_march = 0
+	game.actions -= cost
+}
+
+function spend_all_actions() {
+	game.flags.first_action = 0
+	game.flags.first_march = 0
+	game.actions = 0
+}
+
+function end_command() {
+	log_br()
+
+	game.group = 0
+
+	game.flags.first_action = 0
+	game.flags.first_march = 0
+	game.flags.famine = 0
+
+	// NOTE: Feed currently acting side first for expedience.
+	set_active_command()
+	goto_feed()
+}
+
+function this_lord_has_russian_druzhina() {
+	if (game.active === RUSSIANS)
+		if (lord_has_capability(game.command, AOW_RUSSIAN_DRUZHINA))
+			return get_lord_forces(game.command, KNIGHTS) > 0
+	return false
+}
+
+function this_lord_has_house_of_suzdal() {
+	if (game.active === RUSSIANS)
+		if (lord_has_capability(game.command, AOW_RUSSIAN_HOUSE_OF_SUZDAL))
+			return is_lord_on_map(LORD_ALEKSANDR) && is_lord_on_map(LORD_ANDREY)
+	return false
+}
+
+states.command = {
+	inactive: "Command",
+	prompt() {
+		if (game.actions === 0)
+			view.prompt = `Command: ${lord_name[game.command]} has no more actions.`
+		else if (game.actions === 1)
+			view.prompt = `Command: ${lord_name[game.command]} has ${game.actions} action.`
+		else
+			view.prompt = `Command: ${lord_name[game.command]} has ${game.actions} actions.`
+
+		view.group = game.group
+
+		let here = get_lord_locale(game.command)
+
+		prompt_held_event()
+
+		// 4.3.2 Marshals MAY take other lords
+		if (is_marshal(game.command)) {
+			for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+				if (lord !== game.command && !is_lower_lord(lord))
+					if (get_lord_locale(lord) === here)
+						gen_action_lord(lord)
+		}
+
+		if (game.actions > 0)
+			view.actions.pass = 1
+		else
+			view.actions.end_command = 1
+
+		prompt_march()
+
+		if (can_action_supply())
+			view.actions.supply = 1
+
+		if (can_action_siege())
+			view.actions.siege = 1
+		if (can_action_forage())
+			view.actions.forage = 1
+		if (can_action_ravage())
+			view.actions.ravage = 1
+		if (can_action_tax())
+			view.actions.tax = 1
+		if (can_action_sail())
+			view.actions.sail = 1
+	},
+
+	pass() {
+		push_undo()
+		log("Passed.")
+		spend_all_actions()
+	},
+
+	end_command() {
+		push_undo()
+		end_command()
+	},
+
+	forage: goto_forage,
+	ravage: goto_ravage,
+	supply: goto_supply,
+	tax: goto_tax,
+	sail: goto_sail,
+
+	locale: goto_march,
+
+	lord(lord) {
+		set_toggle(game.group, lord)
+		if (is_upper_lord(lord))
+			set_toggle(game.group, get_lower_lord(lord))
+	},
+
+	card: action_held_event,
+}
+
+// === ACTION: MARCH ===
+
+function format_group_move() {
+	if (game.group.length > 1) {
+		let list = []
+		for (let lord of game.group)
+			if (lord !== game.command)
+				list.push("L" + lord)
+		return " with " + list.join(" and ")
+	}
+	return ""
+}
+
+function group_has_teutonic_converts() {
+	if (game.active === TEUTONS) {
+		if (is_first_march())
+			if (group_has_capability(AOW_TEUTONIC_CONVERTS))
+				if (count_group_forces(LIGHT_HORSE) > 0)
+					return true
+	}
+	return false
+}
+
+function prompt_march() {
+	if (game.actions > 0 || group_has_teutonic_converts()) {
+		let here = get_lord_locale(game.command)
+		for (let to of data.locales[here].adjacent)
+			gen_action_locale(to)
+	}
+}
+
+function goto_march(to) {
+	push_undo()
+	let from = get_lord_locale(game.command)
+	let ways = list_ways(from, to)
+	if (ways.length > 2) {
+		game.march = { from, to, approach: -1, avoid: -1 }
+		game.state = "march_way"
+	} else {
+		game.march = { from, to, approach: ways[1], avoid: -1 }
+		march_with_group_1()
+	}
+}
+
+states.march_way = {
+	inactive: "March",
+	prompt() {
+		view.prompt = `March: Select Way.`
+		view.group = game.group
+		let from = game.march.from
+		let to = game.march.to
+		let ways = list_ways(from, to)
+		for (let i = 1; i < ways.length; ++i)
+			gen_action_way(ways[i])
+	},
+	way(way) {
+		game.march.approach = way
+		march_with_group_1()
+	},
+}
+
+function march_with_group_1() {
+	let way = game.march.approach
+	let type = data.ways[way].type
+
+	let transport = count_group_transport(type)
+	let prov = count_group_assets(PROV)
+
+	if (group_has_teutonic_converts() && prov <= transport * 2)
+		return march_with_group_2()
+
+	if (prov > transport)
+		game.state = "march_laden"
+	else
+		march_with_group_2()
+}
+
+states.march_laden = {
+	inactive: "March",
+	prompt() {
+		let to = game.march.to
+		let way = game.march.approach
+		let transport = count_group_transport(data.ways[way].type)
+		let prov = count_group_assets(PROV)
+
+		view.group = game.group
+
+		if (prov <= transport * 2 && group_has_teutonic_converts())
+			view.prompt = `March: Converts.`
+		else if (prov > transport * 2 || (prov > transport && view.actions < 2))
+			view.prompt = `March: Hindered with ${prov} Provender, and ${transport} Transport.`
+		else if (prov > transport)
+			view.prompt = `March: Laden with ${prov} Provender, and ${transport} Transport.`
+		else
+			view.prompt = `March: Unladen.`
+
+		if (group_has_teutonic_converts()) {
+			if (prov <= transport * 2) {
+				view.actions.march = 1
+				gen_action_locale(to)
+			} else {
+				for (let lord of game.group) {
+					if (get_lord_assets(lord, PROV) > 0) {
+						view.prompt += " Discard Provender."
+						gen_action_prov(lord)
+					}
+				}
+			}
+			return
+		}
+
+		if (prov <= transport * 2) {
+			if (prov > transport) {
+				if (game.actions >= 2) {
+					view.actions.march = 1 // other button?
+					gen_action_laden_march(to)
+				} else {
+					view.prompt += " 1 action left."
+				}
+			} else {
+				view.actions.march = 1
+				gen_action_locale(to)
+			}
+		}
+
+		if (prov > transport) {
+			for (let lord of game.group) {
+				if (prov > transport) {
+					if (get_lord_assets(lord, PROV) > 0) {
+						view.prompt += " Discard Provender."
+						gen_action_prov(lord)
+					}
+				}
+			}
+		}
+	},
+	prov: drop_prov,
+	march: march_with_group_2,
+	locale: march_with_group_2,
+	laden_march: march_with_group_2,
+}
+
+function march_with_group_2() {
+	let from = get_lord_locale(game.command)
+	let way = game.march.approach
+	let to = game.march.to
+	let transport = count_group_transport(data.ways[way].type)
+	let prov = count_group_assets(PROV)
+	let laden = prov > transport
+
+	if (group_has_teutonic_converts()) {
+		logcap(AOW_TEUTONIC_CONVERTS)
+		spend_march_action(0)
+	}
+	else if (laden)
+		spend_march_action(2)
+	else
+		spend_march_action(1)
+
+	if (data.ways[way].name)
+		log(`Marched to %${to} via W${way}${format_group_move()}.`)
+	else
+		log(`Marched to %${to}${format_group_move()}.`)
+
+	for (let lord of game.group) {
+		set_lord_locale(lord, to)
+		set_lord_moved(lord, 1)
+	}
+
+	if (has_unbesieged_enemy_lord(to)) {
+		goto_confirm_approach()
+	} else {
+		march_with_group_3()
+	}
+}
+
+function march_with_group_3() {
+	let here = get_lord_locale(game.command)
+
+	// Disbanded in battle!
+	if (here === NOWHERE) {
+		game.march = 0
+		spend_all_actions()
+		resume_command()
+		update_supply_possible()
+		return
+	}
+
+	if (is_unbesieged_enemy_stronghold(here)) {
+		add_siege_marker(here)
+		spend_all_actions() // ENCAMP
+	}
+
+	if (is_trade_route(here))
+		conquer_trade_route(here)
+
+	game.march = 0
+
+	resume_command()
+	update_supply_possible()
+}
+
+function goto_confirm_approach() {
+	if (game.skip_confirm_approach) {
+		goto_avoid_battle()
+		return
+	}
+	game.state = "confirm_approach"
+}
+
+states.confirm_approach = {
+	inactive: "March",
+	prompt() {
+		view.prompt = `March: Confirm Approach to enemy Lord.`
+		view.group = game.group
+		view.actions.approach = 1
+	},
+	approach() {
+		goto_avoid_battle()
+	}
+}
+
+// === ACTION: MARCH - AVOID BATTLE ===
+
+function count_besieged_lords(loc) {
+	let n = 0
+	for (let lord = first_lord; lord <= last_lord; ++lord)
+		if (get_lord_locale(lord) === loc && is_lord_besieged(lord))
+			++n
+	return n
+}
+
+function stronghold_strength(loc) {
+	if (has_castle_marker(loc))
+		return 2
+	return data.locales[loc].stronghold
+}
+
+function stronghold_capacity(loc) {
+	return stronghold_strength(loc) - count_besieged_lords(loc)
+}
+
+function spoil_prov(lord) {
+	add_lord_assets(lord, PROV, -1)
+	add_spoils(PROV, 1)
+}
+
+function can_any_avoid_battle() {
+        let here = game.march.to
+        for (let [to, way] of data.locales[here].ways)
+                if (can_avoid_battle(to, way))
+                        return true
+        return false
+}
+
+function can_avoid_battle(to, way) {
+	if (way === game.march.approach)
+		return false
+	if (has_unbesieged_enemy_lord(to))
+		return false
+	if (is_unbesieged_enemy_stronghold(to))
+		return false
+	return true
+}
+
+function goto_avoid_battle() {
+	clear_undo()
+	set_active_enemy()
+	if (can_any_avoid_battle()) {
+		// TODO: pre-select lone lord?
+		game.march.group = game.group // save group
+		game.state = "avoid_battle"
+		game.spoils = 0
+		resume_avoid_battle()
+	} else {
+		goto_march_withdraw()
+	}
+}
+
+function resume_avoid_battle() {
+	let here = game.march.to
+	if (has_unbesieged_friendly_lord(here)) {
+		game.group = []
+		game.state = "avoid_battle"
+	} else {
+		end_avoid_battle()
+	}
+}
+
+states.avoid_battle = {
+	inactive: "Avoid Battle",
+	prompt() {
+		view.prompt = "March: Select Lords and destination to Avoid Battle."
+		view.group = game.group
+
+		let here = game.march.to
+
+		for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+			if (get_lord_locale(lord) === here && !is_lower_lord(lord))
+				gen_action_lord(lord)
+
+		if (game.group.length > 0) {
+			for (let [to, way] of data.locales[here].ways) {
+				if (can_avoid_battle(to, way))
+					gen_action_locale(to)
+			}
+		}
+
+		view.actions.end_avoid_battle = 1
+	},
+	lord(lord) {
+		set_toggle(game.group, lord)
+		if (is_upper_lord(lord))
+			set_toggle(game.group, get_lower_lord(lord))
+	},
+	locale(to) {
+		push_undo()
+
+		// Save Assets and Lords in case Ambush cancels Avoid Battle.
+		if (!game.march.ambush) {
+			if (could_enemy_play_ambush()) {
+				// TODO: ambush object...
+				game.march.ambush = {
+					lords: [],
+					assets: game.pieces.assets.slice(),
+					conquered: game.pieces.conquered.slice(),
+				}
+			}
+		}
+
+		let from = get_lord_locale(game.command)
+		let ways = list_ways(from, to)
+		if (ways.length > 2) {
+			game.march.avoid_to = to
+			game.state = "avoid_battle_way"
+		} else {
+			game.march.avoid_to = to
+			game.march.avoid_way = ways[1]
+			avoid_battle_1()
+		}
+	},
+	end_avoid_battle() {
+		push_undo()
+		end_avoid_battle()
+	},
+}
+
+states.avoid_battle_way = {
+	inactive: "Avoid Battle",
+	prompt() {
+		view.prompt = `Avoid Battle: Select Way to destination.`
+		view.group = game.group
+		let from = game.march.to
+		let to = game.march.avoid_to
+		let ways = list_ways(from, to)
+		for (let i = 1; i < ways.length; ++i)
+			if (can_avoid_battle(to, ways[i]))
+				gen_action_way(ways[i])
+	},
+	way(way) {
+		game.march.avoid_way = way
+		avoid_battle_1()
+	},
+}
+
+function avoid_battle_1() {
+	let way = game.march.avoid_way
+	let transport = count_group_transport(data.ways[way].type)
+	let prov = count_group_assets(PROV)
+	if (prov > transport)
+		game.state = "avoid_battle_laden"
+	else
+		avoid_battle_2()
+}
+
+states.avoid_battle_laden = {
+	inactive: "Avoid Battle",
+	prompt() {
+		let to = game.march.avoid_to
+		let way = game.march.avoid_way
+		let transport = count_group_transport(data.ways[way].type)
+		let prov = count_group_assets(PROV)
+
+		if (prov > transport)
+			view.prompt = `Avoid Battle: Hindered with ${prov} Provender and ${transport} Transport.`
+		else
+			view.prompt = `Avoid Battle: Unladen.`
+		view.group = game.group
+
+		if (prov > transport) {
+			view.prompt += " Discard Provender."
+			for (let lord of game.group) {
+				if (get_lord_assets(lord, PROV) > 0)
+					gen_action_prov(lord)
+			}
+		} else {
+			gen_action_locale(to)
+			view.actions.avoid = 1
+		}
+	},
+	prov(lord) {
+		push_undo()
+		spoil_prov(lord)
+	},
+	locale(_) {
+		avoid_battle_2()
+	},
+	avoid() {
+		avoid_battle_2()
+	},
+}
+
+function avoid_battle_2() {
+	let to = game.march.avoid_to
+
+	for (let lord of game.group) {
+		log(`L${lord} Avoided Battle to %${to}.`)
+		if (game.march.ambush)
+			set_add(game.march.ambush.lords, lord)
+		set_lord_locale(lord, to)
+		set_lord_moved(lord, 1)
+	}
+
+	if (is_trade_route(to))
+		conquer_trade_route(to)
+
+	game.march.avoid_to = 0
+	game.march.avoid_way = 0
+	resume_avoid_battle()
+}
+
+function end_avoid_battle() {
+	game.group = game.march.group // restore group
+	game.march.group = 0
+	goto_march_withdraw()
+}
+
+// === ACTION: MARCH - WITHDRAW ===
+
+function can_withdraw(here, n) {
+	if (is_unbesieged_friendly_stronghold(here))
+		if (stronghold_capacity(here) >= n)
+			return true
+	return false
+}
+
+function goto_march_withdraw() {
+	let here = game.march.to
+	if (has_unbesieged_friendly_lord(here) && can_withdraw(here, 1)) {
+		game.state = "march_withdraw"
+	} else {
+		end_march_withdraw()
+	}
+}
+
+states.march_withdraw = {
+	inactive: "Withdraw",
+	prompt() {
+		view.prompt = "March: Select Lords to Withdraw into Stronghold."
+
+		let here = get_lord_locale(game.command)
+		let capacity = stronghold_capacity(here)
+
+		if (capacity >= 1) {
+			for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+				if (get_lord_locale(lord) === here && !is_lower_lord(lord) && is_lord_unbesieged(lord)) {
+					if (is_upper_lord(lord)) {
+						if (capacity >= 2)
+							gen_action_lord(lord)
+					} else {
+						gen_action_lord(lord)
+					}
+				}
+			}
+		}
+
+		view.actions.end_withdraw = 1
+	},
+	lord(lord) {
+		push_undo()
+		let lower = get_lower_lord(lord)
+
+		log(`L${lord} Withdrew.`)
+		set_lord_besieged(lord, 1)
+
+		if (lower !== NOBODY) {
+			log(`L${lower} Withdrew.`)
+			set_lord_besieged(lower, 1)
+		}
+	},
+	end_withdraw() {
+		end_march_withdraw()
+	},
+}
+
+function end_march_withdraw() {
+	clear_undo()
+	set_active_enemy()
+	goto_march_ambush()
+}
+
+// === ACTION: MARCH - AMBUSH ===
+
+function could_enemy_play_ambush() {
+	if (game.active === TEUTONS)
+		return could_play_card(EVENT_RUSSIAN_AMBUSH)
+	else
+		return could_play_card(EVENT_TEUTONIC_AMBUSH)
+}
+
+function goto_march_ambush() {
+	if (game.march.ambush && game.march.ambush.lords.length > 0)
+		game.state = "march_ambush"
+	else
+		goto_spoils_after_avoid_battle()
+}
+
+states.march_ambush = {
+	inactive: "Ambush",
+	prompt() {
+		view.prompt = "Avoid Battle: You may play Ambush if you have it."
+		if (has_card_in_hand(EVENT_TEUTONIC_AMBUSH))
+			gen_action_card(EVENT_TEUTONIC_AMBUSH)
+		if (has_card_in_hand(EVENT_RUSSIAN_AMBUSH))
+			gen_action_card(EVENT_RUSSIAN_AMBUSH)
+		view.actions.pass = 1
+	},
+	card(c) {
+		play_held_event(c)
+
+		// Restore assets and spoils and withdrawn lords
+		game.pieces.assets = game.march.ambush.assets
+		game.pieces.conquered = game.march.ambush.conquered
+		game.spoils = 0
+
+		// Restore lords who avoided battle
+		for (let lord of game.march.ambush.lords) {
+			set_lord_locale(lord, game.march.to)
+			set_lord_moved(lord, 0)
+		}
+
+		set_active_enemy()
+		game.march.ambush = 0
+		goto_march_withdraw()
+	},
+	pass() {
+		game.march.ambush = 0
+		goto_spoils_after_avoid_battle()
+	},
+}
+
+// === ACTION: MARCH - DIVIDE SPOILS AFTER AVOID BATTLE ===
+
+function list_spoils() {
+	let list = []
+	for (let type = 0; type < 7; ++type) {
+		let n = get_spoils(type)
+		if (n > 0)
+			list.push(`${n} ${ASSET_TYPE_NAME[type]}`)
+	}
+	if (list.length > 0)
+		return list.join(", ")
+	return "nothing"
+}
+
+function prompt_spoils() {
+	if (get_spoils(PROV) > 0)
+		view.actions.take_prov = 1
+	if (get_spoils(COIN) > 0)
+		view.actions.take_coin = 1
+	if (get_spoils(CART) > 0)
+		view.actions.take_cart = 1
+}
+
+function take_spoils(type) {
+	push_undo_without_who()
+	add_lord_assets(game.who, type, 1)
+	add_spoils(type, -1)
+	if (!has_any_spoils())
+		game.who = NOBODY
+}
+
+function take_spoils_prov() { take_spoils(PROV) }
+function take_spoils_coin() { take_spoils(COIN) }
+function take_spoils_cart() { take_spoils(CART) }
+
+function goto_spoils_after_avoid_battle() {
+	if (has_any_spoils()) {
+		game.state = "spoils_after_avoid_battle"
+		if (game.group.length === 1)
+			game.who = game.group[0]
+	} else {
+		goto_battle()
+	}
+}
+
+states.spoils_after_avoid_battle = {
+	inactive: "Spoils",
+	prompt() {
+		if (has_any_spoils()) {
+			view.prompt = "Spoils: Divide " + list_spoils() + "."
+			// only moving lords get to divide the spoils
+			for (let lord of game.group)
+				prompt_select_lord(lord)
+			if (game.who !== NOBODY)
+				prompt_spoils()
+		} else {
+			view.prompt = "Spoils: All done."
+			view.actions.end_spoils = 1
+		}
+	},
+	lord: action_select_lord,
+	take_prov: take_spoils_prov,
+	end_spoils() {
+		clear_undo()
+		game.spoils = 0
+		game.who = NOBODY
+		goto_battle()
+	},
+}
+
+// === ACTION: SUPPLY (SEARCHING) ===
+
+let _supply_stop = new Array(last_locale+1)
+let _supply_reached = new Array(last_locale+1)
+
+let _supply_seen = new Array(last_locale+1).fill(0)
+let _supply_cost = new Array(last_locale+1)
+let _supply_carts = new Array(last_locale+1)
+
+function is_supply_forbidden(here) {
+	if (has_unbesieged_enemy_lord(here))
+		return true
+	if (is_unbesieged_enemy_stronghold(here))
+		return true
+	if (is_friendly_territory(here) && has_conquered_marker(here))
+		return true
+	return false
+}
+
+function init_supply_forbidden() {
+	for (let here = 0; here <= last_locale; ++here) {
+		if (is_supply_forbidden(here))
+			_supply_stop[here] = 1
+		else
+			_supply_stop[here] = 0
+	}
+}
+
+function init_supply() {
+	let season = current_season()
+	let here = get_lord_locale(game.command)
+	let carts = 0
+	let ships = 0
+	let available = 2
+
+	if (season === SUMMER) {
+		carts = get_shared_assets(here, CART)
+	}
+	if (season === SUMMER || season === RASPUTITSA) {
+		ships = count_shared_ships()
+	}
+
+	if (ships > 2)
+		ships = 2
+
+	if (is_famine_in_play())
+		available = game.flags.famine ? 0 : 1
+
+	let seats = []
+	if (available > 0) {
+		for_each_seat(game.command, seat => {
+			if (!is_supply_forbidden(seat))
+				seats.push(seat)
+		}, true)
+		available = Math.min(seats.length, available)
+	}
+
+	let seaports = []
+	if (ships > 0) {
+		if (game.active === TEUTONS)
+			for (let port of data.seaports)
+				if (!is_supply_forbidden(port))
+					seaports.push(port)
+		if (game.active === RUSSIANS)
+			if (!is_supply_forbidden(LOC_NOVGOROD))
+				seaports.push(LOC_NOVGOROD)
+	}
+	if (seaports.length === 0)
+		ships = 0
+
+	game.supply = { seats, seaports, available, carts, ships }
+}
+
+function search_supply(start, carts, exit) {
+	if (_supply_stop[start])
+		return 0
+	_supply_reached[start] = 1
+	_supply_cost[start] = 0
+	if (exit && set_has(exit, start))
+		return 1
+	if (carts === 0)
+		return 0
+	let queue = [ start ]
+	while (queue.length > 0) {
+		let item = queue.shift()
+		let here = item & 63
+		let used = item >> 6
+		if (used + 1 <= carts) {
+			for (let next of data.locales[here].adjacent) {
+				if (!_supply_reached[next] && !_supply_stop[next]) {
+					if (exit && set_has(exit, next))
+						return 1
+					_supply_reached[next] = 1
+					_supply_cost[next] = used + 1
+					if (used + 1 < carts)
+						queue.push(next | ((used + 1) << 6))
+				}
+			}
+		}
+	}
+	return 0
+}
+
+// === ACTION: SUPPLY ===
+
+function update_supply_possible() {
+	if (game.actions < 1) {
+		game.supply = 0
+		return
+	}
+
+	update_supply_possible_pass()
+}
+
+function update_supply_possible_pass() {
+	init_supply()
+	init_supply_forbidden()
+	_supply_reached.fill(0)
+	let sources = []
+	for (let loc of game.supply.seats)
+		set_add(sources, loc)
+	for (let loc of game.supply.seaports)
+		set_add(sources, loc)
+	game.supply = search_supply(get_lord_locale(game.command), game.supply.carts, sources)
+}
+
+function search_supply_cost() {
+	init_supply_forbidden()
+	_supply_reached.fill(0)
+	search_supply(get_lord_locale(game.command), game.supply.carts, null)
+}
+
+function can_action_supply() {
+	if (game.actions < 1)
+		return false
+	return !!game.supply
+}
+
+function can_supply() {
+	if (game.supply.available > 0 && game.supply.seats.length > 0)
+		return true
+	if (game.supply.ships > 0 && game.supply.seaports.length > 0)
+		return true
+	return false
+}
+
+function goto_supply() {
+	push_undo()
+
+	if (is_famine_in_play() && !game.flags.famine) {
+		if (game.active === TEUTONS)
+			logevent(EVENT_RUSSIAN_FAMINE)
+		else
+			logevent(EVENT_TEUTONIC_FAMINE)
+	}
+
+	log(`Supplied`)
+	init_supply()
+	resume_supply()
+	game.state = "supply_source"
+}
+
+function resume_supply() {
+	if (game.supply.available + game.supply.ships === 0) {
+		game.supply.seats = []
+		game.supply.seaports = []
+	} else {
+		search_supply_cost()
+		game.supply.seats = game.supply.seats.filter(loc => _supply_reached[loc])
+		game.supply.seaports = game.supply.seaports.filter(loc => _supply_reached[loc])
+	}
+
+	if (can_supply())
+		game.state = "supply_source"
+	else
+		end_supply()
+}
+
+states.supply_source = {
+	inactive: "Supply",
+	prompt() {
+		if (!can_supply()) {
+			view.prompt = "Supply: No valid Supply Sources."
+			return
+		}
+
+		view.prompt = "Supply: Select Supply Source and Route."
+
+		let list = []
+		if (game.supply.carts > 0)
+			list.push(`${game.supply.carts} Cart`)
+		if (game.supply.ships > 0)
+			list.push(`${game.supply.ships} Ship`)
+
+		if (list.length > 0)
+			view.prompt += " " + list.join(", ") + "."
+
+		if (game.supply.available > 0)
+			for (let source of game.supply.seats)
+				gen_action_locale(source)
+		if (game.supply.ships > 0)
+			for (let source of game.supply.seaports)
+				gen_action_locale(source)
+		view.actions.end_supply = 1
+	},
+	locale(source) {
+		if (game.supply.available > 0 && game.supply.seats.includes(source)) {
+			array_remove_item(game.supply.seats, source)
+
+			let cap = used_seat_capability(game.command, source, game.supply.seats)
+			if (cap >= 0)
+				logi(`Seat at %${source} (C${cap})`)
+			else
+				logi(`Seat at %${source}`)
+
+			game.supply.available--
+			if (is_famine_in_play())
+				game.flags.famine = 1
+		} else {
+			logi(`Seaport at %${source}`)
+			game.supply.ships--
+		}
+
+		add_lord_assets(game.command, PROV, 1)
+
+		spend_supply_transport(source)
+	},
+	end_supply: end_supply,
+}
+
+function end_supply() {
+	spend_action(1)
+	resume_command()
+	game.supply = 1 // supply is possible!
+}
+
+function spend_supply_transport(source) {
+	if (source === get_lord_locale(game.command)) {
+		resume_supply()
+		return
+	}
+
+	search_supply_cost()
+	game.supply.carts -= _supply_cost[source]
+	resume_supply()
+}
+
+states.supply_path = {
+	inactive: "Supply",
+	prompt() {
+		view.prompt = "Supply: Trace Route to Supply Source."
+		view.supply = [ game.supply.here, game.supply.end ]
+		if (game.supply.carts > 0)
+			view.prompt += ` ${game.supply.carts} cart`
+		for (let i = 0; i < game.supply.path.length; i += 2) {
+			let wayloc = game.supply.path[i]
+			gen_action_locale(wayloc >> 8)
+		}
+	},
+	locale(next) {
+		let useloc = -1
+		let useway = -1
+		let twoway = false
+		for (let i = 0; i < game.supply.path.length; i += 2) {
+			let wayloc = game.supply.path[i]
+			let way = wayloc & 255
+			let loc = wayloc >> 8
+			if (loc === next) {
+				if (useloc < 0) {
+					useloc = loc
+					useway = way
+				} else {
+					twoway = true
+				}
+			}
+		}
+		if (twoway) {
+			game.state = "supply_path_way"
+			game.supply.next = next
+		} else {
+			walk_supply_path_way(next, useway)
+		}
+	},
+}
+
+function walk_supply_path_way(next, way) {
+	let type = data.ways[way].type
+	game.supply.carts--
+	game.supply.here = next
+	game.supply.path = map_get(game.supply.path, (next << 8) | way)
+	if (game.supply.path === 0)
+		resume_supply()
+	else
+		// Auto-pick path if only one choice.
+		if (AUTOWALK && game.supply.path.length === 2)
+			walk_supply_path_way(game.supply.path[0] >> 8, game.supply.path[0] & 255)
+}
+
+states.supply_path_way = {
+	inactive: "Supply",
+	prompt() {
+		view.prompt = "Supply: Trace path to supply source."
+		view.supply = [ game.supply.here, game.supply.end ]
+		if (game.supply.carts > 0)
+			view.prompt += ` ${game.supply.carts} cart`
+		for (let i = 0; i < game.supply.path.length; i += 2) {
+			let wayloc = game.supply.path[i]
+			let way = wayloc & 255
+			let loc = wayloc >> 8
+			if (loc === game.supply.next)
+				gen_action_way(way)
+		}
+	},
+	way(way) {
+		game.state = "supply_path"
+		walk_supply_path_way(game.supply.next, way)
+	},
+}
+
+// === ACTION: FORAGE ===
+
+function can_action_forage() {
+	if (game.actions < 1)
+		return false
+
+	if (is_famine_in_play())
+		return false
+
+	let here = get_lord_locale(game.command)
+	if (has_ravaged_marker(here))
+		return false
+	if (is_summer())
+		return true
+	if (is_friendly_stronghold_locale(here)) // FIXME: simpler check?
+		return true
+	return false
+}
+
+function goto_forage() {
+	push_undo()
+	let here = get_lord_locale(game.command)
+	log(`Foraged at %${here}`)
+	add_lord_assets(game.command, PROV, 1)
+	spend_action(1)
+	resume_command()
+}
+
+// === ACTION: RAVAGE ===
+
+function has_adjacent_unbesieged_enemy_lord(loc) {
+	for (let next of data.locales[loc].adjacent)
+		if (has_unbesieged_enemy_lord(next))
+			return true
+	return false
+}
+
+function can_ravage_locale(loc) {
+	if (!is_enemy_territory(loc))
+		return false
+	if (has_conquered_marker(loc))
+		return false
+	if (has_ravaged_marker(loc))
+		return false
+	if (is_friendly_locale(loc)) // faster check?
+		return false
+	if (has_adjacent_unbesieged_enemy_lord(loc))
+		return game.actions >= 2
+	else
+		return game.actions >= 1
+}
+
+function can_action_ravage() {
+	if (game.actions < 1)
+		return false
+
+	let here = get_lord_locale(game.command)
+
+	if (can_ravage_locale(here))
+		return true
+
+	if (this_lord_has_teutonic_raiders()) {
+		for (let there of data.locales[here].adjacent_by_trackway)
+			// XXX has_enemy_lord redundant with is_friendly_locale in can_ravage_locale
+			if (can_ravage_locale(there) && !has_enemy_lord(there))
+				return true
+	}
+
+	if (this_lord_has_russian_raiders()) {
+		for (let there of data.locales[here].adjacent)
+			// XXX has_enemy_lord redundant with is_friendly_locale in can_ravage_locale
+			if (can_ravage_locale(there) && !has_enemy_lord(there))
+				return true
+	}
+
+	return false
+}
+
+function goto_ravage() {
+	push_undo()
+	if (this_lord_has_teutonic_raiders() || this_lord_has_russian_raiders()) {
+		game.state = "ravage"
+	} else {
+		let here = get_lord_locale(game.command)
+		ravage_location(here, here)
+	}
+}
+
+states.ravage = {
+	inactive: "Ravage",
+	prompt() {
+		view.prompt = `Ravage: Select enemy territory to Ravage.`
+
+		let here = get_lord_locale(game.command)
+
+		if (can_ravage_locale(here))
+			gen_action_locale(here)
+
+		if (this_lord_has_teutonic_raiders()) {
+			for (let there of data.locales[here].adjacent_by_trackway)
+				if (can_ravage_locale(there) && !has_enemy_lord(there))
+					gen_action_locale(there)
+		}
+
+		if (this_lord_has_russian_raiders()) {
+			for (let there of data.locales[here].adjacent)
+				if (can_ravage_locale(there) && !has_enemy_lord(there))
+					gen_action_locale(there)
+		}
+	},
+	locale(there) {
+		let here = get_lord_locale(game.command)
+		ravage_location(here, there)
+	},
+}
+
+function ravage_location(here, there) {
+	if (here !== there) {
+		if (is_teutonic_lord(game.command))
+			log(`Ravaged %${there} (C${AOW_TEUTONIC_RAIDERS}).`)
+		else
+			log(`Ravaged %${there} (C${which_lord_capability(game.command, AOW_RUSSIAN_RAIDERS)}).`)
+	} else {
+		log(`Ravaged %${there}.`)
+	}
+
+	add_ravaged_marker(there)
+	add_lord_assets(game.command, PROV, 1)
+
+	if (here !== there && game.active === TEUTONS)
+		game.flags.teutonic_raiders = 1
+
+	if (has_adjacent_unbesieged_enemy_lord(there))
+		spend_action(2)
+	else
+		spend_action(1)
+	resume_command()
+}
+
+// === ACTION: TAX ===
+
+function restore_mustered_forces(lord) {
+	muster_lord_forces(lord)
+	for (let v of data.lords[lord].vassals)
+		if (is_vassal_mustered(v))
+			muster_vassal_forces(lord, v)
+}
+
+function can_action_tax() {
+	// Must use whole action
+	if (!is_first_action())
+		return false
+
+	// Must have space left to hold Coin
+	if (get_lord_assets(game.command, COIN) >= 8)
+		return false
+
+	// Must be at own seat
+	return is_lord_at_seat(game.command)
+}
+
+function goto_tax() {
+	push_undo()
+
+	let here = get_lord_locale(game.command)
+	log(`Taxed %${here}.`)
+
+	add_lord_assets(game.command, COIN, 1)
+
+	spend_all_actions()
+	resume_command()
+
+	if (lord_has_capability(game.command, AOW_RUSSIAN_VELIKY_KNYAZ)) {
+		logcap(AOW_RUSSIAN_VELIKY_KNYAZ)
+		restore_mustered_forces(game.command)
+		push_state("veliky_knyaz")
+		game.who = game.command
+		game.count = 2
+	}
+}
+
+states.veliky_knyaz = states.muster_lord_transport
+
+// === ACTION: SAIL ===
+
+function drop_prov(lord) {
+	add_lord_assets(lord, PROV, -1)
+}
+
+function has_enough_available_ships_for_horses() {
+	let ships = count_group_ships()
+	let horses = count_group_horses()
+
+	let needed_ships = horses
+	if (game.active === RUSSIANS)
+		needed_ships = horses * 2
+
+	return needed_ships <= ships
+}
+
+function can_action_sail() {
+	// Must use whole action
+	if (!is_first_action())
+		return false
+
+	// at a seaport
+	let here = get_lord_locale(game.command)
+	if (!is_seaport(here))
+		return false
+
+	// during Rasputitsa or Summer
+	if (is_winter())
+		return false
+
+	// with enough ships to carry all the horses
+	if (!has_enough_available_ships_for_horses())
+		return false
+
+	// and a valid destination
+	for (let to of data.seaports)
+		if (to !== here && !has_enemy_lord(to))
+			return true
+
+	return false
+}
+
+function goto_sail() {
+	push_undo()
+	game.state = "sail"
+}
+
+states.sail = {
+	inactive: "Sail",
+	prompt() {
+		view.group = game.group
+
+		let here = get_lord_locale(game.command)
+		let ships = count_group_ships()
+		let horses = count_group_horses()
+		let prov = count_group_assets(PROV)
+
+		let overflow = 0
+		if (game.active === TEUTONS)
+			overflow = (horses + prov) - ships
+		if (game.active === RUSSIANS)
+			overflow = (horses * 2 + prov) - ships
+
+		if (overflow > 0) {
+			view.prompt = `Sailing with ${ships} Ships and ${horses} Horses. Discard Loot or Provender.`
+			// TODO: stricter greed!
+			if (prov > 0) {
+				for (let lord of game.group) {
+					if (get_lord_assets(lord, PROV) > 0)
+						gen_action_prov(lord)
+				}
+			}
+		} else {
+			view.prompt = `Sail: Select a destination Seaport.`
+			for (let to of data.seaports) {
+				if (to === here)
+					continue
+				if (!has_enemy_lord(to))
+					gen_action_locale(to)
+			}
+		}
+	},
+	prov: drop_prov,
+	locale(to) {
+		push_undo()
+		log(`Sailed to %${to}${format_group_move()}.`)
+
+		let from = get_lord_locale(game.command)
+
+		for (let lord of game.group) {
+			set_lord_locale(lord, to)
+			set_lord_moved(lord, 1)
+		}
+
+		if (is_trade_route(to))
+			conquer_trade_route(to)
+
+		spend_all_actions()
+		resume_command()
+		update_supply_possible()
+	},
+}
+
+// === BATTLE ===
+
+function set_active_attacker() {
+	set_active(game.battle.attacker)
+}
+
+function set_active_defender() {
+	if (game.battle.attacker === P1)
+		set_active(P2)
+	else
+		set_active(P1)
+}
+
+function goto_battle() {
+	if (has_unbesieged_enemy_lord(game.march.to))
+		start_battle()
+	else
+		march_with_group_3()
+}
+
+function init_battle(here) {
+	game.battle = {
+		where: here,
+		round: 1,
+		step: 0,
+		relief: 0,
+		attacker: game.active,
+		ambush: 0,
+		conceded: 0,
+		loser: 0,
+		fought: 0, // flag all lords who participated
+		array: [
+			-1, game.command, -1,
+			-1, -1, -1,
+			-1, -1, -1,
+			-1, -1, -1,
+		],
+		garrison: 0,
+		reserves: [],
+		retreated: 0,
+		rearguard: 0,
+		strikers: 0,
+		warrior_monks: 0,
+		hits: 0,
+		xhits: 0,
+		fc: -1,
+		rc: -1,
+	}
+}
+
+function start_battle() {
+	let here = get_lord_locale(game.command)
+
+	log_h3(`Battle at %${here}`)
+
+	init_battle(here, 0, 0)
+
+	// All attacking lords to reserve
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+		if (get_lord_locale(lord) === here && !is_lord_besieged(lord)) {
+			set_lord_fought(lord)
+			if (lord !== game.command)
+				set_add(game.battle.reserves, lord)
+		}
+	}
+
+	// Array attacking lords if fewer than 3.
+	if (game.battle.reserves.length === 2)
+		game.battle.array[A3] = game.battle.reserves.pop()
+	if (game.battle.reserves.length === 1)
+		game.battle.array[A1] = game.battle.reserves.pop()
+
+	// All defending lords to reserve
+	for (let lord = first_enemy_lord; lord <= last_enemy_lord; ++lord) {
+		if (get_lord_locale(lord) === here && !is_lord_besieged(lord)) {
+			set_lord_fought(lord)
+			set_add(game.battle.reserves, lord)
+		}
+	}
+
+	goto_relief_sally()
+}
+
+function init_garrison(knights, men_at_arms) {
+	game.battle.garrison = { knights, men_at_arms }
+}
+
+// === BATTLE: BATTLE ARRAY ===
+
+// 0) Defender decides to stand for Battle, not Avoid.
+// 1) Attacker decides which Lords will relief sally, if any.
+// 2) Attacker positions front A.
+// 3) Defender positions front D.
+// 4) Attacker positions SA.
+// 5) Defender positions reaguard RG.
+
+function has_friendly_reserves() {
+	for (let lord of game.battle.reserves)
+		if (is_friendly_lord(lord))
+			return true
+	return false
+}
+
+function has_friendly_attacking_reserves() {
+	for (let lord of game.battle.reserves)
+		if (is_friendly_lord(lord) && (game.battle.sally || is_lord_unbesieged(lord)))
+			return true
+	return false
+}
+
+function has_friendly_sallying_reserves() {
+	for (let lord of game.battle.reserves)
+		if (is_friendly_lord(lord) && is_lord_besieged(lord))
+			return true
+	return false
+}
+
+function count_friendly_reserves() {
+	let n = 0
+	for (let lord of game.battle.reserves)
+		if (is_friendly_lord(lord))
+			++n
+	return n
+}
+
+function pop_first_reserve() {
+	for (let lord of game.battle.reserves) {
+		if (is_friendly_lord(lord)) {
+			set_delete(game.battle.reserves, lord)
+			return lord
+		}
+	}
+	return NOBODY
+}
+
+function prompt_array_place_opposed(X1, X2, X3, Y1, Y3) {
+	let array = game.battle.array
+	if (array[X2] === NOBODY) {
+		gen_action_array(X2)
+	} else if (array[Y1] !== NOBODY && array[Y3] === NOBODY && array[X1] === NOBODY) {
+		gen_action_array(X1)
+	} else if (array[Y1] === NOBODY && array[Y3] !== NOBODY && array[X3] === NOBODY) {
+		gen_action_array(X3)
+	} else {
+		if (array[X1] === NOBODY)
+			gen_action_array(X1)
+		if (array[X3] === NOBODY)
+			gen_action_array(X3)
+	}
+}
+
+function action_array_place(pos) {
+	push_undo_without_who()
+	game.battle.array[pos] = game.who
+	set_delete(game.battle.reserves, game.who)
+	game.who = NOBODY
+}
+
+function goto_array_attacker() {
+	clear_undo()
+	set_active_attacker()
+	game.state = "array_attacker"
+	game.who = NOBODY
+	if (!has_friendly_attacking_reserves())
+		end_array_attacker()
+}
+
+function goto_array_defender() {
+	clear_undo()
+	set_active_defender()
+	game.state = "array_defender"
+	game.who = NOBODY
+	let n = count_friendly_reserves()
+	if (n === 1) {
+		game.battle.array[D2] = pop_first_reserve()
+		end_array_defender()
+	}
+	if (n === 0)
+		end_array_defender()
+}
+
+function goto_array_sally() {
+	clear_undo()
+	set_active_attacker()
+	game.state = "array_sally"
+	game.who = NOBODY
+	if (!has_friendly_sallying_reserves())
+		end_array_sally()
+}
+
+function goto_array_rearguard() {
+	clear_undo()
+	set_active_defender()
+	game.state = "array_rearguard"
+	game.who = NOBODY
+	if (!has_friendly_reserves() || empty(SA2))
+		end_array_rearguard()
+}
+
+// NOTE: The order here can be easily change to attacker/sally/defender/rearguard if desired.
+
+function end_array_attacker() {
+	goto_array_defender()
+}
+
+function end_array_defender() {
+	goto_array_sally()
+}
+
+function end_array_sally() {
+	goto_array_rearguard()
+}
+
+function end_array_rearguard() {
+	goto_attacker_events()
+}
+
+states.array_attacker = {
+	inactive: "Array Attacking Lords",
+	prompt() {
+		view.prompt = "Battle Array: Position your Attacking Lords."
+		let array = game.battle.array
+		let done = true
+		if (array[A1] === NOBODY || array[A2] === NOBODY || array[A3] === NOBODY) {
+			for (let lord of game.battle.reserves) {
+				if (lord !== game.who && is_friendly_lord(lord)) {
+					if (game.battle.sally || is_lord_unbesieged(lord)) {
+						gen_action_lord(lord)
+						done = false
+					}
+				}
+			}
+		}
+		if (game.who === NOBODY && done)
+			view.actions.end_array = 1
+		if (game.who !== NOBODY) {
+			// A2 is already filled by command lord!
+			if (array[A1] === NOBODY)
+				gen_action_array(A1)
+			if (array[A3] === NOBODY)
+				gen_action_array(A3)
+		}
+	},
+	array: action_array_place,
+	lord: action_select_lord,
+	end_array: end_array_attacker,
+}
+
+states.array_defender = {
+	inactive: "Array Defending Lords",
+	prompt() {
+		view.prompt = "Battle Array: Position your Defending Lords."
+		let array = game.battle.array
+		let done = true
+		if (array[D1] === NOBODY || array[D2] === NOBODY || array[D3] === NOBODY) {
+			for (let lord of game.battle.reserves) {
+				if (lord !== game.who && is_friendly_lord(lord)) {
+					gen_action_lord(lord)
+					done = false
+				}
+			}
+		}
+		if (done && game.who === NOBODY)
+			view.actions.end_array = 1
+		if (game.who !== NOBODY)
+			prompt_array_place_opposed(D1, D2, D3, A1, A3)
+	},
+	array: action_array_place,
+	lord: action_select_lord,
+	end_array: end_array_defender,
+}
+
+// === BATTLE: EVENTS ===
+
+function goto_attacker_events() {
+	clear_undo()
+	set_active_attacker()
+	log_br()
+	if (can_play_battle_events())
+		game.state = "attacker_events"
+	else
+		end_attacker_events()
+}
+
+function end_attacker_events() {
+	goto_defender_events()
+}
+
+function goto_defender_events() {
+	set_active_defender()
+	log_br()
+	if (can_play_battle_events())
+		game.state = "defender_events"
+	else
+		end_defender_events()
+}
+
+function end_defender_events() {
+	goto_battle_rounds()
+}
+
+function resume_battle_events() {
+	game.what = -1
+	if (is_attacker())
+		goto_attacker_events()
+	else
+		goto_defender_events()
+}
+
+function could_play_card(c) {
+	if (set_has(game.capabilities, c))
+		return false
+	if (!game.hidden) {
+		// TODO: check capabilities on lords revealed in battle if hidden
+		if (game.pieces.capabilities.includes(c))
+			return false
+	}
+	if (set_has(game.events, c))
+		return false
+	if (is_p1_card(c))
+		return game.hand1.length > 0
+	if (is_p2_card(c))
+		return game.hand2.length > 0
+	return true
+}
+
+function has_lords_in_battle() {
+	for (let p = 0; p < 12; ++p)
+		if (is_friendly_lord(game.battle.array[p]))
+			return true
+	return has_friendly_reserves()
+}
+
+function can_play_battle_events() {
+	if (game.active === TEUTONS) {
+		if (could_play_card(EVENT_TEUTONIC_AMBUSH))
+			return true
+		if (is_defender()) {
+			if (could_play_card(EVENT_TEUTONIC_HILL))
+				return true
+			if (!is_winter())
+				if (could_play_card(EVENT_TEUTONIC_MARSH))
+					return true
+		}
+		if (!is_winter())
+			if (could_play_card(EVENT_TEUTONIC_BRIDGE))
+				return true
+	}
+
+	if (game.active === RUSSIANS) {
+		if (could_play_card(EVENT_RUSSIAN_AMBUSH))
+			return true
+		if (is_defender()) {
+			if (could_play_card(EVENT_RUSSIAN_HILL))
+				return true
+			if (!is_winter())
+				if (could_play_card(EVENT_RUSSIAN_MARSH))
+					return true
+		}
+		if (!is_winter())
+			if (could_play_card(EVENT_RUSSIAN_BRIDGE))
+				return true
+		if (!is_summer())
+			if (could_play_card(EVENT_RUSSIAN_RAVENS_ROCK))
+				return true
+	}
+
+	// Battle or Storm
+	if (game.active === TEUTONS) {
+		if (could_play_card(EVENT_TEUTONIC_FIELD_ORGAN))
+			if (has_lords_in_battle())
+				return true
+	}
+
+	return false
+}
+
+function prompt_battle_events() {
+	// both attacker and defender events
+	if (game.active === TEUTONS) {
+		gen_action_card_if_held(EVENT_TEUTONIC_AMBUSH)
+		if (!is_winter())
+			gen_action_card_if_held(EVENT_TEUTONIC_BRIDGE)
+		if (has_lords_in_battle())
+			gen_action_card_if_held(EVENT_TEUTONIC_FIELD_ORGAN)
+	}
+
+	if (game.active === RUSSIANS) {
+		gen_action_card_if_held(EVENT_RUSSIAN_AMBUSH)
+		if (!is_winter())
+			gen_action_card_if_held(EVENT_RUSSIAN_BRIDGE)
+		if (!is_summer())
+			gen_action_card_if_held(EVENT_RUSSIAN_RAVENS_ROCK)
+	}
+
+	view.actions.done = 1
+}
+
+states.attacker_events = {
+	inactive: "Attacker Events",
+	prompt() {
+		view.prompt = "Attacker may play Events."
+		prompt_battle_events()
+	},
+	card: action_battle_events,
+	done() {
+		end_attacker_events()
+	},
+}
+
+states.defender_events = {
+	inactive: "Defender Events",
+	prompt() {
+		view.prompt = "Defender may play Events."
+
+		prompt_battle_events()
+
+		// defender only events
+		if (game.active === TEUTONS) {
+			if (!is_winter())
+				gen_action_card_if_held(EVENT_TEUTONIC_MARSH)
+			gen_action_card_if_held(EVENT_TEUTONIC_HILL)
+		}
+
+		if (game.active === RUSSIANS) {
+			if (!is_winter())
+				gen_action_card_if_held(EVENT_RUSSIAN_MARSH)
+			gen_action_card_if_held(EVENT_RUSSIAN_HILL)
+		}
+	},
+	card: action_battle_events,
+	done() {
+		end_defender_events()
+	},
+}
+
+function action_battle_events(c) {
+	game.what = c
+	set_delete(current_hand(), c)
+	set_add(game.events, c)
+	switch (c) {
+		case EVENT_TEUTONIC_HILL:
+		case EVENT_TEUTONIC_MARSH:
+		case EVENT_RUSSIAN_HILL:
+		case EVENT_RUSSIAN_MARSH:
+		case EVENT_RUSSIAN_RAVENS_ROCK:
+			// nothing more needs to be done for these
+			log(`Played E${c}.`)
+			resume_battle_events()
+			break
+		case EVENT_TEUTONIC_AMBUSH:
+		case EVENT_RUSSIAN_AMBUSH:
+			log(`Played E${c}.`)
+			if (is_attacker())
+				game.battle.ambush |= 2
+			else
+				game.battle.ambush |= 1
+			break
+		case EVENT_TEUTONIC_BRIDGE:
+		case EVENT_RUSSIAN_BRIDGE:
+			// must select target lord
+			game.state = "bridge"
+			break
+		case EVENT_TEUTONIC_FIELD_ORGAN:
+			// must select target lord
+			game.state = "field_organ"
+			break
+	}
+}
+
+states.bridge = {
+	inactive: "Bridge",
+	prompt() {
+		view.prompt = "Bridge: Play on a Center Lord."
+		view.what = game.what
+		let array = game.battle.array
+		if (is_attacker()) {
+			if (array[D2] !== NOBODY)
+				gen_action_lord(array[D2])
+			if (array[RG2] !== NOBODY)
+				gen_action_lord(array[RG2])
+		} else {
+			// Cannot play on Relief Sallying lord
+			if (array[A2] !== NOBODY)
+				gen_action_lord(array[A2])
+		}
+	},
+	lord(lord) {
+		log(`Played E${game.what} on L${lord}.`)
+		if (!game.battle.bridge)
+			game.battle.bridge = { lord1: NOBODY, lord2: NOBODY, n1: 0, n2: 0 }
+		if (is_p1_lord(lord))
+			game.battle.bridge.lord1 = lord
+		else
+			game.battle.bridge.lord2 = lord
+		resume_battle_events()
+	},
+}
+
+states.field_organ = {
+	inactive: "Field Organ",
+	prompt() {
+		view.prompt = "Field Organ: Play on a Lord."
+		view.what = game.what
+		let array = game.battle.array
+		if (is_attacker()) {
+			for (let pos of battle_attacking_positions)
+				if (array[pos] !== NOBODY)
+					gen_action_lord(array[pos])
+		} else {
+			for (let pos of battle_defending_positions)
+				if (array[pos] !== NOBODY)
+					gen_action_lord(array[pos])
+		}
+	},
+	lord(lord) {
+		log(`Played E${game.what} on L${lord}.`)
+		game.battle.field_organ = lord
+		resume_battle_events()
+	},
+}
+
+
+// === BATTLE: CONCEDE THE FIELD ===
+
+function goto_battle_rounds() {
+	set_active_attacker()
+	goto_concede()
+}
+
+function goto_concede() {
+	log_h4(`Battle Round ${game.battle.round}`)
+	game.state = "concede_battle"
+}
+
+states.concede_battle = {
+	inactive: "Concede",
+	prompt() {
+		view.prompt = "Battle: Concede the Field?"
+		view.actions.concede = 1
+		view.actions.battle = 1
+	},
+	concede() {
+		log(game.active + " Conceded.")
+		game.battle.conceded = game.active
+		goto_reposition_battle()
+	},
+	battle() {
+		set_active_enemy()
+		if (is_attacker())
+			goto_reposition_battle()
+	},
+}
+
+// === BATTLE: REPOSITION ===
+
+function send_to_reserve(pos) {
+	if (game.battle.array[pos] !== NOBODY) {
+		set_add(game.battle.reserves, game.battle.array[pos])
+		game.battle.array[pos] = NOBODY
+	}
+}
+
+function slide_array(from, to) {
+	game.battle.array[to] = game.battle.array[from]
+	game.battle.array[from] = NOBODY
+}
+
+function goto_reposition_battle() {
+	let array = game.battle.array
+
+	// If all D routed.
+	if (array[D1] === NOBODY && array[D2] === NOBODY && array[D3] === NOBODY) {
+		log("Defenders Routed.")
+	}
+
+	// If all A routed.
+	if (array[A1] === NOBODY && array[A2] === NOBODY && array[A3] === NOBODY) {
+		log("Attackers Routed.")
+	}
+
+	set_active_attacker()
+	goto_reposition_advance()
+}
+
+function goto_reposition_advance() {
+	if (can_reposition_advance())
+		game.state = "reposition_advance"
+	else
+		end_reposition_advance()
+}
+
+function end_reposition_advance() {
+	game.who = NOBODY
+	set_active_enemy()
+	if (is_attacker())
+		goto_reposition_center()
+	else
+		goto_reposition_advance()
+}
+
+function goto_reposition_center() {
+	if (can_reposition_center())
+		game.state = "reposition_center"
+	else
+		end_reposition_center()
+}
+
+function end_reposition_center() {
+	game.who = NOBODY
+	set_active_enemy()
+	if (is_attacker())
+		goto_first_strike()
+	else
+		goto_reposition_center()
+}
+
+function can_reposition_advance() {
+	if (has_friendly_reserves()) {
+		let array = game.battle.array
+		if (is_attacker()) {
+			if (array[A1] === NOBODY || array[A2] === NOBODY || array[A3] === NOBODY)
+				return true
+		} else {
+			if (array[D1] === NOBODY || array[D2] === NOBODY || array[D3] === NOBODY)
+				return true
+		}
+	}
+	return false
+}
+
+states.reposition_advance = {
+	inactive: "Reposition",
+	prompt() {
+		view.prompt = "Reposition: Advance from Reserve."
+		let array = game.battle.array
+
+		for (let lord of game.battle.reserves)
+			if (is_friendly_lord(lord) && lord !== game.who)
+				gen_action_lord(lord)
+
+		if (game.who !== NOBODY) {
+			if (is_attacker()) {
+				if (array[A1] === NOBODY) gen_action_array(A1)
+				if (array[A2] === NOBODY) gen_action_array(A2)
+				if (array[A3] === NOBODY) gen_action_array(A3)
+			} else {
+				if (array[D1] === NOBODY) gen_action_array(D1)
+				if (array[D2] === NOBODY) gen_action_array(D2)
+				if (array[D3] === NOBODY) gen_action_array(D3)
+			}
+		}
+	},
+	lord(lord) {
+		game.who = lord
+	},
+	array(pos) {
+		set_delete(game.battle.reserves, game.who)
+		game.battle.array[pos] = game.who
+		game.who = NOBODY
+		goto_reposition_advance()
+	},
+}
+
+function can_reposition_center() {
+	let array = game.battle.array
+	if (is_attacker()) {
+		if (array[A2] === NOBODY && (array[A1] !== NOBODY || array[A3] !== NOBODY))
+			return true
+	} else {
+		if (array[D2] === NOBODY && (array[D1] !== NOBODY || array[D3] !== NOBODY))
+			return true
+	}
+	return false
+}
+
+states.reposition_center = {
+	inactive: "Reposition",
+	prompt() {
+		view.prompt = "Reposition: Slide to Center."
+		let array = game.battle.array
+
+		if (is_attacker()) {
+			if (array[A2] === NOBODY) {
+				if (array[A1] !== NOBODY) gen_action_lord(game.battle.array[A1])
+				if (array[A3] !== NOBODY) gen_action_lord(game.battle.array[A3])
+			}
+		} else {
+			if (array[D2] === NOBODY) {
+				if (array[D1] !== NOBODY) gen_action_lord(game.battle.array[D1])
+				if (array[D3] !== NOBODY) gen_action_lord(game.battle.array[D3])
+			}
+		}
+
+		if (game.who !== NOBODY) {
+			let from = get_lord_array_position(game.who)
+			if (from === A1 || from === A3) gen_action_array(A2)
+			if (from === D1 || from === D3) gen_action_array(D2)
+		}
+	},
+	lord(lord) {
+		game.who = lord
+	},
+	array(pos) {
+		let from = get_lord_array_position(game.who)
+		slide_array(from, pos)
+		game.who = NOBODY
+		goto_reposition_center()
+	},
+}
+
+// === BATTLE: STRIKE ===
+
+// Strike groups:
+// 	Strike opposing lord
+// 	Strike closest flanked lord (choice left/right) if not directly opposed
+// 	Combine strikes with lords targeting same position
+// 
+// Target groups:
+// 	If any striker is flanking target, single target.
+// 	If any other lords flank all strikers, add them to target group.
+
+function get_battle_array(pos) {
+	if (game.battle.ambush & 1)
+		if (pos === A1 || pos === A3)
+			return NOBODY
+	if (game.battle.ambush & 2)
+		if (pos === D1 || pos === D3)
+			return NOBODY
+	return game.battle.array[pos]
+}
+
+function filled(pos) {
+	return get_battle_array(pos) !== NOBODY
+}
+
+function empty(pos) {
+	return get_battle_array(pos) === NOBODY
+}
+
+const battle_defending_positions = [ D1, D2, D3 ]
+const battle_attacking_positions = [ A1, A2, A3 ]
+
+const battle_steps = [
+	{ name: "Defending Archery", hits: count_archery_hits, xhits: count_archery_xhits },
+	{ name: "Attacking Archery", hits: count_archery_hits, xhits: count_archery_xhits },
+	{ name: "Defending Horse", hits: count_horse_hits, xhits: count_zero_hits },
+	{ name: "Attacking Horse", hits: count_horse_hits, xhits: count_zero_hits },
+	{ name: "Defending Foot", hits: count_foot_hits, xhits: count_zero_hits },
+	{ name: "Attacking Foot", hits: count_foot_hits, xhits: count_zero_hits },
+]
+
+function count_zero_hits(_) {
+	return 0
+}
+
+function count_archery_xhits(lord) {
+	let xhits = 0
+	if (lord_has_capability(lord, AOW_TEUTONIC_BALISTARII) || lord_has_capability(lord, AOW_RUSSIAN_STRELTSY))
+		xhits += get_lord_forces(lord, MEN_AT_ARMS)
+	if (is_hill_in_play())
+		return xhits << 1
+	return xhits
+}
+
+function count_archery_hits(lord) {
+	let hits = 0
+	if (!is_marsh_in_play()) {
+		if (lord_has_capability(lord, AOW_RUSSIAN_LUCHNIKI)) {
+			hits += get_lord_forces(lord, LIGHT_HORSE)
+			hits += get_lord_forces(lord, MILITIA)
+		}
+		hits += get_lord_forces(lord, ASIATIC_HORSE)
+	} else {
+		if (lord_has_capability(lord, AOW_RUSSIAN_LUCHNIKI)) {
+			hits += get_lord_forces(lord, MILITIA)
+		}
+	}
+	if (is_hill_in_play())
+		return hits << 1
+	return hits
+}
+
+function count_melee_hits(lord) {
+	return count_horse_hits(lord) + count_foot_hits(lord)
+}
+
+function assemble_melee_forces(lord) {
+	let forces = {
+		knights: get_lord_forces(lord, KNIGHTS),
+		sergeants: get_lord_forces(lord, SERGEANTS),
+		light_horse: get_lord_forces(lord, LIGHT_HORSE),
+		men_at_arms: get_lord_forces(lord, MEN_AT_ARMS),
+		militia: get_lord_forces(lord, MILITIA),
+		serfs: get_lord_forces(lord, SERFS),
+	}
+
+	if (is_marsh_in_play()) {
+		forces.knights = 0
+		forces.sergeants = 0
+		forces.light_horse = 0
+	}
+
+	if (game.battle.bridge && (game.battle.bridge.lord1 === lord || game.battle.bridge.lord2 === lord)) {
+		let n = is_p1_lord(lord) ? game.battle.bridge.n1 : game.battle.bridge.n2
+
+		log(`Bridge L${lord}`)
+
+		if (is_horse_step()) {
+			// Pick at most 1 LH if there are any Foot (for +1/2 rounding benefit)
+			if (forces.men_at_arms + forces.militia + forces.serfs > 0 && forces.light_horse > 1)
+				forces.light_horse = 1
+
+			if (forces.knights >= n)
+				forces.knights = n
+			n -= forces.knights
+			if (forces.sergeants >= n)
+				forces.sergeants = n
+			n -= forces.sergeants
+			if (forces.light_horse >= n)
+				forces.light_horse = n
+			n -= forces.light_horse
+
+			if (forces.knights > 0) logi(`${forces.knights} Knights`)
+			if (forces.sergeants > 0) logi(`${forces.sergeants} Sergeants`)
+			if (forces.light_horse > 0) logi(`${forces.light_horse} Light Horse`)
+			if (forces.knights + forces.sergeants + forces.light_horse === 0) logi(`None`)
+		}
+
+		if (is_foot_step()) {
+			if (forces.men_at_arms >= n)
+				forces.men_at_arms = n
+			n -= forces.men_at_arms
+			if (forces.militia >= n)
+				forces.militia = n
+			n -= forces.militia
+			if (forces.serfs >= n)
+				forces.serfs = n
+			n -= forces.serfs
+
+			if (forces.men_at_arms > 0) logi(`${forces.men_at_arms} Men-at-Arms`)
+			if (forces.militia > 0) logi(`${forces.militia} Militia`)
+			if (forces.serfs > 0) logi(`${forces.serfs} Serfs`)
+			if (forces.men_at_arms + forces.militia + forces.serfs === 0) logi(`None`)
+		}
+
+		if (is_p1_lord(lord))
+			game.battle.bridge.n1 = n
+		else
+			game.battle.bridge.n2 = n
+	}
+
+	return forces
+}
+
+function count_horse_hits(lord) {
+	let hits = 0
+	if (!is_marsh_in_play()) {
+		let forces = assemble_melee_forces(lord)
+
+		hits += forces.knights << 2
+		hits += forces.sergeants << 1
+		hits += forces.light_horse
+
+		if (game.battle.field_organ === lord && game.battle.round === 1) {
+			log(`E${EVENT_TEUTONIC_FIELD_ORGAN} L${lord}.`)
+			hits += forces.knights << 1
+			hits += forces.sergeants << 1
+		}
+	}
+	return hits
+}
+
+function count_foot_hits(lord) {
+	let forces = assemble_melee_forces(lord)
+	let hits = 0
+	hits += forces.men_at_arms << 1
+	hits += forces.militia
+	hits += forces.serfs
+	return hits
+}
+
+function count_garrison_xhits() {
+	if (is_archery_step())
+		return game.battle.garrison.men_at_arms
+	return 0
+}
+
+function count_garrison_hits() {
+	if (is_melee_step())
+		return (game.battle.garrison.knights << 1) + (game.battle.garrison.men_at_arms << 1)
+	return 0
+}
+
+function count_lord_xhits(lord) {
+	return battle_steps[game.battle.step].xhits(lord)
+}
+
+function count_lord_hits(lord) {
+	return battle_steps[game.battle.step].hits(lord)
+}
+
+function is_battle_over() {
+	set_active_attacker()
+	if (has_no_unrouted_forces())
+		return true
+	set_active_defender()
+	if (has_no_unrouted_forces())
+		return true
+	return false
+}
+
+function has_no_unrouted_forces() {
+	// All unrouted lords are either in battle array or in reserves
+	for (let p = 0; p < 12; ++p)
+		if (is_friendly_lord(game.battle.array[p]))
+			return false
+	for (let lord of game.battle.reserves)
+		if (is_friendly_lord(lord))
+			return false
+	return true
+}
+
+function is_attacker() {
+	return game.active === game.battle.attacker
+}
+
+function is_defender() {
+	return game.active !== game.battle.attacker
+}
+
+function is_attacker_step() {
+	return (game.battle.step & 1) === 1
+}
+
+function is_defender_step() {
+	return (game.battle.step & 1) === 0
+}
+
+function is_archery_step() {
+	return game.battle.step < 2
+}
+
+function is_melee_step() {
+	return game.battle.step >= 2
+}
+
+function is_horse_step() {
+	return game.battle.step === 2 || game.battle.step === 3
+}
+
+function is_foot_step() {
+	return game.battle.step === 4 || game.battle.step === 5
+}
+
+function did_concede() {
+	return game.active === game.battle.conceded
+}
+
+function did_not_concede() {
+	return game.active !== game.battle.conceded
+}
+
+function has_strike(pos) {
+	return game.battle.ah[pos] + game.battle.ahx[pos] > 0
+}
+
+function current_strike_positions() {
+	return is_attacker_step() ? battle_attacking_positions : battle_defending_positions
+}
+
+function find_closest_target(A, B, C) {
+	if (filled(A)) return A
+	if (filled(B)) return B
+	if (filled(C)) return C
+	return -1
+}
+
+function find_closest_target_center(T2) {
+	if (game.battle.fc < 0) throw Error("unset front l/r choice")
+	if (game.battle.rc < 0) throw Error("unset rear l/r choice")
+	if (filled(T2))
+		return T2
+	if (T2 >= A1 && T2 <= D3)
+		return game.battle.fc
+	return game.battle.rc
+}
+
+function find_strike_target(S) {
+	switch (S) {
+	case A1: return find_closest_target(D1, D2, D3)
+	case A2: return find_closest_target_center(D2)
+	case A3: return find_closest_target(D3, D2, D1)
+	case D1: return find_closest_target(A1, A2, A3)
+	case D2: return find_closest_target_center(A2)
+	case D3: return find_closest_target(A3, A2, A1)
+	}
+}
+
+function has_strike_target(S) {
+	if (is_attacker_step() && has_garrison())
+		return true
+	if (S === A1 || S === A2 || S === A3)
+		return filled(D1) || filled(D2) || filled(D3)
+	if (S === D1 || S === D2 || S === D3)
+		return filled(A1) || filled(A2) || filled(A3)
+}
+
+function has_no_strike_targets() {
+	if (is_defender_step() && has_garrison())
+		if (has_strike_target(D2))
+			return false
+	for (let striker of game.battle.strikers)
+		if (has_strike_target(striker))
+			return false
+	return true
+}
+
+function has_no_strikers_and_strike_targets() {
+	if (is_defender_step() && has_garrison()) {
+		if (is_archery_step() && game.battle.garrison.men_at_arms > 0)
+			if (has_strike_target(D2))
+				return false
+		if (is_melee_step() && game.battle.garrison.men_at_arms + game.battle.garrison.knights > 0)
+			if (has_strike_target(D2))
+				return false
+	}
+	for (let pos of current_strike_positions())
+		if (has_strike(pos) && has_strike_target(pos))
+			return false
+	return true
+}
+
+function create_strike_group(start) {
+	let strikers = [ start ]
+	let target = find_strike_target(start)
+	for (let pos of current_strike_positions())
+		if (pos !== start && filled(pos) && find_strike_target(pos) === target)
+			set_add(strikers, pos)
+	return strikers
+}
+
+function flanks_position_row(S, T, S1, S2, S3, T1, T2, T3) {
+	// S and T are not empty
+	switch (S) {
+		case S1:
+			switch (T) {
+				case T1: return false
+				case T2: return empty(T1)
+				case T3: return empty(T1) && empty(T2)
+			}
+			break
+		case S2:
+			return empty(T2)
+		case S3:
+			switch (T) {
+				case T1: return empty(T3) && empty(T2)
+				case T2: return empty(T3)
+				case T3: return false
+			}
+			break
+	}
+	return false
+}
+
+function flanks_position(S, T) {
+	if (S === A1 || S === A2 || S === A3)
+		return flanks_position_row(S, T, A1, A2, A3, D1, D2, D3)
+	if (S === D1 || S === D2 || S === D3)
+		return flanks_position_row(S, T, D1, D2, D3, A1, A2, A3)
+}
+
+function flanks_all_positions(S, TT) {
+	for (let T of TT)
+		if (!flanks_position(S, T))
+			return false
+	return true
+}
+
+function strike_left_or_right(S2, T1, T2, T3) {
+	if (has_strike(S2)) {
+		if (filled(T2))
+			return T2
+		let has_t1 = filled(T1)
+		let has_t3 = filled(T3)
+		if (has_t1 && has_t3)
+			return -1
+		if (has_t1)
+			return T1
+		if (has_t3)
+			return T3
+	}
+	return 1000 // No target!
+}
+
+function strike_defender_row() {
+	let has_d1 = filled(D1)
+	let has_d2 = filled(D2)
+	let has_d3 = filled(D3)
+	if (has_d1 && !has_d2 && !has_d3) return D1
+	if (!has_d1 && has_d2 && !has_d3) return D2
+	if (!has_d1 && !has_d2 && has_d3) return D3
+	return -1
+}
+
+// === BATTLE: STRIKE ===
+
+// for each battle step:
+// 	generate strikes for each lord
+// 	while strikes remain:
+// 		create list of strike groups (choose left/right both rows)
+// 		select strike group
+// 		create target group (choose if sally)
+// 		total strikes and roll for walls
+// 		while hits remain:
+// 			assign hit to unit in target group
+// 			if lord routs:
+// 				forget choice of left/right strike group in current row
+// 				create new target group (choose if left/right/sally)
+
+function format_strike_step() {
+	return battle_steps[game.battle.step].name
+}
+
+function format_hits() {
+	if (game.battle.xhits > 0 && game.battle.hits > 0) {
+		if (game.battle.xhits > 1 && game.battle.hits > 1)
+			return `${game.battle.xhits} Crossbow Hits and ${game.battle.hits} Hits`
+		else if (game.battle.xhits > 1)
+			return `${game.battle.xhits} Crossbow Hits and ${game.battle.hits} Hit`
+		else if (game.battle.hits > 1)
+			return `${game.battle.xhits} Crossbow Hit and ${game.battle.hits} Hits`
+		else
+			return `${game.battle.xhits} Crossbow Hit and ${game.battle.hits} Hit`
+	} else if (game.battle.xhits > 0) {
+		if (game.battle.xhits > 1)
+			return `${game.battle.xhits} Crossbow Hits`
+		else
+			return `${game.battle.xhits} Crossbow Hit`
+	} else {
+		if (game.battle.hits > 1)
+			return `${game.battle.hits} Hits`
+		else
+			return `${game.battle.hits} Hit`
+	}
+}
+
+function goto_first_strike() {
+	game.battle.step = 0
+
+	if (game.battle.bridge) {
+		game.battle.bridge.n1 = game.battle.round * 2
+		game.battle.bridge.n2 = game.battle.round * 2
+	}
+
+	goto_strike()
+}
+
+function goto_next_strike() {
+	let end = 6
+	game.battle.step++
+	if (game.battle.step >= end)
+		end_battle_round()
+	else
+		goto_strike()
+}
+
+function goto_strike() {
+	// Exit early if one side is completely routed
+	if (is_battle_over()) {
+		end_battle_round()
+		return
+	}
+
+	if (is_attacker_step())
+		set_active_attacker()
+	else
+		set_active_defender()
+
+	log_h5(battle_steps[game.battle.step].name)
+
+	// Once per Archery and once per Melee.
+	if (game.battle.step === 0 || game.battle.step === 2) {
+		game.battle.warrior_monks = 0
+		for (let p = 0; p < 12; ++p) {
+			let lord = game.battle.array[p]
+			if (lord !== NOBODY && lord_has_capability(lord, AOW_TEUTONIC_WARRIOR_MONKS))
+				game.battle.warrior_monks |= 1 << lord
+		}
+	}
+
+	if (is_marsh_in_play()) {
+		if (game.active === TEUTONS)
+			logevent(EVENT_RUSSIAN_MARSH)
+		else
+			logevent(EVENT_TEUTONIC_MARSH)
+	}
+
+	if (is_archery_step() && is_hill_in_play()) {
+		if (game.active === TEUTONS)
+			logevent(EVENT_TEUTONIC_HILL)
+		else
+			logevent(EVENT_RUSSIAN_HILL)
+	}
+
+	// Generate hits
+	game.battle.ah = [ 0, 0, 0, 0, 0, 0 ]
+	game.battle.ahx = [ 0, 0, 0, 0, 0, 0 ]
+
+	for (let pos of current_strike_positions()) {
+		let lord = get_battle_array(pos)
+		if (lord !== NOBODY) {
+			let hits = count_lord_hits(lord)
+			let xhits = count_lord_xhits(lord)
+
+			game.battle.ah[pos] = hits
+			game.battle.ahx[pos] = xhits
+
+			if (xhits > 2)
+				log(`L${lord} ${frac(xhits)} Crossbow Hits.`)
+			else if (xhits > 0)
+				log(`L${lord} ${frac(xhits)} Crossbow Hit.`)
+			if (hits > 2)
+				log(`L${lord} ${frac(hits)} Hits.`)
+			else if (hits > 0)
+				log(`L${lord} ${frac(hits)} Hit.`)
+		}
+	}
+
+	if (did_concede())
+		log("Pursuit.")
+
+	// Strike left or right or defender
+	if (is_attacker_step())
+		game.battle.fc = strike_left_or_right(A2, D1, D2, D3)
+	else
+		game.battle.fc = strike_left_or_right(D2, A1, A2, A3)
+
+	if (has_no_strikers_and_strike_targets())
+		log("None.")
+
+	resume_strike()
+}
+
+function resume_strike() {
+	if (has_no_strikers_and_strike_targets())
+		goto_next_strike()
+	else if (game.battle.fc < 0 || game.battle.rc < 0)
+		game.state = "strike_left_right"
+	else
+		goto_strike_group()
+}
+
+function prompt_target_2(S1, T1, T3) {
+	view.who = game.battle.array[S1]
+	gen_action_lord(game.battle.array[T1])
+	gen_action_lord(game.battle.array[T3])
+}
+
+function prompt_left_right() {
+	view.prompt = `${format_strike_step()}: Strike left or right?`
+	if (is_attacker_step())
+		prompt_target_2(A2, D1, D3)
+	else
+		prompt_target_2(D2, A1, A3)
+}
+
+function action_left_right(lord) {
+	log(`Targeted L${lord}.`)
+	let pos = get_lord_array_position(lord)
+	if (game.battle.fc < 0)
+		game.battle.fc = pos
+	else
+		game.battle.rc = pos
+}
+
+states.strike_left_right = {
+	get inactive() {
+		return format_strike_step() + " \u2014 Strike"
+	},
+	prompt: prompt_left_right,
+	lord(lord) {
+		action_left_right(lord)
+		resume_strike()
+	},
+}
+
+states.assign_left_right = {
+	get inactive() {
+		return format_strike_step() + " \u2014 Strike"
+	},
+	prompt: prompt_left_right,
+	lord(lord) {
+		action_left_right(lord)
+		set_active_enemy()
+		goto_assign_hits()
+	},
+}
+
+function goto_strike_group() {
+	game.state = "strike_group"
+}
+
+function select_strike_group(pos) {
+	game.battle.strikers = create_strike_group(pos)
+	goto_strike_total_hits()
+}
+
+states.strike_group = {
+	get inactive() {
+		return format_strike_step() + " \u2014 Strike"
+	},
+	prompt() {
+		view.prompt = `${format_strike_step()}: Strike.`
+		if (has_garrison_strike()) {
+			view.actions.garrison = 1
+			if (!has_strike(D2))
+				view.prompt = `${format_strike_step()}: Strike with Garrison.`
+		}
+		for (let pos of current_strike_positions())
+			if (has_strike(pos))
+				gen_action_lord(game.battle.array[pos])
+	},
+	lord(lord) {
+		select_strike_group(get_lord_array_position(lord))
+	},
+	garrison() {
+		if (has_strike(D2))
+			select_strike_group(D2)
+		else
+			select_strike_group(-1)
+	},
+}
+
+// === BATTLE: TOTAL HITS (ROUND UP) ===
+
+function goto_strike_total_hits() {
+	let hits = 0
+	let xhits = 0
+
+	let slist = []
+
+	// Total hits
+	for (let pos of game.battle.strikers) {
+		if (game.battle.ah[pos] + game.battle.ahx[pos] > 0) {
+			slist.push(lord_name[game.battle.array[pos]])
+			hits += game.battle.ah[pos]
+			xhits += game.battle.ahx[pos]
+		}
+	}
+
+	// Round in favor of crossbow hits.
+	if (xhits & 1) {
+		hits = (hits >> 1)
+		xhits = (xhits >> 1) + 1
+	} else {
+		if (hits & 1)
+			hits = (hits >> 1) + 1
+		else
+			hits = (hits >> 1)
+		xhits = (xhits >> 1)
+	}
+
+	// Conceding side halves its total Hits, rounded up.
+	if (did_concede()) {
+		hits = (hits + 1) >> 1
+		xhits = (xhits + 1) >> 1
+	}
+
+	game.battle.hits = hits
+	game.battle.xhits = xhits
+
+	log_br()
+	log(slist.join(", "))
+
+	goto_strike_roll_walls()
+}
+
+// === BATTLE: ROLL WALLS ===
+
+function goto_strike_roll_walls() {
+	set_active_enemy()
+
+	if (game.battle.xhits > 0)
+		log_hits(game.battle.xhits, "Crossbow Hit")
+	if (game.battle.hits > 0)
+		log_hits(game.battle.hits, "Hit")
+
+	game.who = -2
+	goto_assign_hits()
+}
+
+function log_hits(total, name) {
+	if (total === 1)
+		logi(`${total} ${name}`)
+	else if (total > 1)
+		logi(`${total} ${name}s`)
+	else
+		logi(`No ${name}s`)
+}
+
+// === BATTLE: ASSIGN HITS TO UNITS / ROLL BY HIT / ROUT ===
+
+function goto_assign_hits() {
+	if (game.battle.hits + game.battle.xhits === 0)
+		return end_assign_hits()
+
+	if (has_no_strike_targets()) {
+		log("Lost " + format_hits() + ".")
+		return end_assign_hits()
+	}
+
+	if (is_attacker_step()) {
+		if (game.battle.fc < 0 && set_has(game.battle.strikers, A2))
+			return goto_assign_left_right()
+	} else {
+		if (game.battle.fc < 0 && set_has(game.battle.strikers, D2))
+			return goto_assign_left_right()
+	}
+
+	game.state = "assign_hits"
+}
+
+function goto_assign_left_right() {
+	set_active_enemy()
+	game.state = "assign_left_right"
+}
+
+function end_assign_hits() {
+	for (let pos of game.battle.strikers) {
+		game.battle.ah[pos] = 0
+		game.battle.ahx[pos] = 0
+	}
+	game.who = NOBODY
+	game.battle.strikers = 0
+	game.battle.hits = 0
+	game.battle.xhits = 0
+	set_active_enemy()
+	resume_strike()
+}
+
+function for_each_target(fn) {
+	if (is_defender_step() && has_garrison()) {
+		if (filled(A2))
+			fn(game.battle.array[A2])
+		return
+	}
+
+	let start = game.battle.strikers[0]
+
+	let target = find_strike_target(start)
+
+	fn(game.battle.array[target])
+
+	// If any striker flanks target, target must take all hits
+	for (let striker of game.battle.strikers)
+		if (flanks_position(striker, target))
+			return
+
+	// If other lord flanks all strikers, he may take hits instead
+	for (let flanker of ARRAY_FLANKS[target])
+		if (filled(flanker) && flanks_all_positions(flanker, game.battle.strikers))
+			fn(game.battle.array[flanker])
+}
+
+function prompt_hit_armored_forces() {
+	let has_armored = false
+	for_each_target(lord => {
+		if (get_lord_forces(lord, KNIGHTS) > 0) {
+			gen_action_knights(lord)
+			has_armored = true
+		}
+		if (get_lord_forces(lord, SERGEANTS) > 0) {
+			gen_action_sergeants(lord)
+			has_armored = true
+		}
+		if (get_lord_forces(lord, MEN_AT_ARMS) > 0) {
+			gen_action_men_at_arms(lord)
+			has_armored = true
+		}
+	})
+	return has_armored
+}
+
+function prompt_hit_unarmored_forces() {
+	for_each_target(lord => {
+		if (get_lord_forces(lord, LIGHT_HORSE) > 0)
+			gen_action_light_horse(lord)
+		if (get_lord_forces(lord, ASIATIC_HORSE) > 0)
+			gen_action_asiatic_horse(lord)
+		if (get_lord_forces(lord, MILITIA) > 0)
+			gen_action_militia(lord)
+		if (get_lord_forces(lord, SERFS) > 0)
+			gen_action_serfs(lord)
+	})
+}
+
+function prompt_hit_forces() {
+	for_each_target(lord => {
+		if (get_lord_forces(lord, KNIGHTS) > 0)
+			gen_action_knights(lord)
+		if (get_lord_forces(lord, SERGEANTS) > 0)
+			gen_action_sergeants(lord)
+		if (get_lord_forces(lord, LIGHT_HORSE) > 0)
+			gen_action_light_horse(lord)
+		if (get_lord_forces(lord, ASIATIC_HORSE) > 0)
+			gen_action_asiatic_horse(lord)
+		if (get_lord_forces(lord, MEN_AT_ARMS) > 0)
+			gen_action_men_at_arms(lord)
+		if (get_lord_forces(lord, MILITIA) > 0)
+			gen_action_militia(lord)
+		if (get_lord_forces(lord, SERFS) > 0)
+			gen_action_serfs(lord)
+	})
+}
+
+states.assign_hits = {
+	get inactive() {
+		return format_strike_step() + " \u2014 Assign " + format_hits()
+	},
+	prompt() {
+		view.prompt = `${format_strike_step()}: Assign ${format_hits()} to units.`
+
+		view.group = game.battle.strikers.map(p => game.battle.array[p])
+
+		prompt_hit_forces()
+	},
+	knights(lord) {
+		action_assign_hits(lord, KNIGHTS)
+	},
+	sergeants(lord) {
+		action_assign_hits(lord, SERGEANTS)
+	},
+	light_horse(lord) {
+		action_assign_hits(lord, LIGHT_HORSE)
+	},
+	asiatic_horse(lord) {
+		action_assign_hits(lord, ASIATIC_HORSE)
+	},
+	men_at_arms(lord) {
+		action_assign_hits(lord, MEN_AT_ARMS)
+	},
+	militia(lord) {
+		action_assign_hits(lord, MILITIA)
+	},
+	serfs(lord) {
+		action_assign_hits(lord, SERFS)
+	},
+}
+
+function rout_lord(lord) {
+	log(`L${lord} Routed.`)
+
+	let pos = get_lord_array_position(lord)
+
+	// Remove from battle array
+	game.battle.array[pos] = NOBODY
+
+	// Strike left or right or defender
+
+	if (pos >= A1 && pos <= A3) {
+		game.battle.fc = strike_left_or_right(D2, A1, A2, A3)
+	}
+
+	else if (pos >= D1 && pos <= D3) {
+		game.battle.fc = strike_left_or_right(A2, D1, D2, D3)
+		if (is_sa_without_rg())
+			game.battle.rc = strike_defender_row()
+	}
+}
+
+function rout_unit(lord, type) {
+	if (lord === GARRISON) {
+		if (type === KNIGHTS)
+			game.battle.garrison.knights--
+		if (type === MEN_AT_ARMS)
+			game.battle.garrison.men_at_arms--
+		if (game.battle.garrison.knights + game.battle.garrison.men_at_arms === 0) {
+			log("Garrison Routed.")
+			game.battle.garrison = 0
+		}
+	} else {
+		add_lord_forces(lord, type, -1)
+		add_lord_routed_forces(lord, type, 1)
+	}
+}
+
+function remove_serf(lord) {
+	add_lord_forces(lord, SERFS, -1)
+	game.pieces.smerdi++
+}
+
+function use_warrior_monks(lord, type) {
+	if (type === KNIGHTS) {
+		let bit = 1 << lord
+		if (game.battle.warrior_monks & bit) {
+			game.battle.warrior_monks ^= bit
+			return true
+		}
+	}
+	return false
+}
+
+function which_lord_capability(lord, list) {
+	for (let c of list)
+		if (lord_has_capability_card(lord, c))
+			return c
+	return -1
+}
+
+function assign_hit_roll(what, prot, extra) {
+	let die = roll_die()
+	if (die <= prot) {
+		logi(`${what} ${range(prot)}: ${MISS[die]}${extra}`)
+		return false
+	} else {
+		logi(`${what} ${range(prot)}: ${HIT[die]}${extra}`)
+		return true
+	}
+
+}
+
+function action_assign_hits(lord, type) {
+	let protection = FORCE_PROTECTION[type]
+	let evade = FORCE_EVADE[type]
+
+	if (game.who !== lord) {
+		game.who = lord
+		if (lord === GARRISON)
+			log("Garrison")
+		else
+			log(`L${lord}`)
+	}
+
+	let extra = ""
+
+	let crossbow = 0
+	if (is_armored_force(type) && game.battle.xhits > 0) {
+		extra += " (-2\xa0Crossbow)"
+		crossbow = 2
+	}
+
+	if (type === SERGEANTS || type === MEN_AT_ARMS) {
+		if (lord_has_capability(lord, AOW_TEUTONIC_HALBBRUDER)) {
+			extra += ` (+1\xa0C${which_lord_capability(lord, AOW_TEUTONIC_HALBBRUDER)})`
+			protection += 1
+		}
+	}
+
+	// Evade only in Battle Melee steps
+	if (evade > 0 && is_melee_step()) {
+		if (assign_hit_roll(FORCE_TYPE_NAME[type], evade, extra))
+			rout_unit(lord, type)
+	} else if (protection > 0) {
+		if (assign_hit_roll(FORCE_TYPE_NAME[type], protection - crossbow, extra)) {
+			if (use_warrior_monks(lord, type)) {
+				let monks = which_lord_capability(lord, AOW_TEUTONIC_WARRIOR_MONKS)
+				if (assign_hit_roll(`C${monks}`, protection - crossbow, extra))
+					rout_unit(lord, type)
+			} else {
+				rout_unit(lord, type)
+			}
+		}
+	} else {
+		logi(`${FORCE_TYPE_NAME[type]} removed`)
+		remove_serf(lord, type)
+	}
+
+	if (game.battle.xhits)
+		game.battle.xhits--
+	else
+		game.battle.hits--
+
+	if (!lord_has_unrouted_units(lord))
+		rout_lord(lord)
+
+	goto_assign_hits()
+}
+
+// === BATTLE: NEW ROUND ===
+
+function end_battle_round() {
+	if (game.battle.conceded) {
+		game.battle.loser = game.battle.conceded
+		end_battle()
+		return
+	}
+
+	set_active_attacker()
+	if (has_no_unrouted_forces()) {
+		game.battle.loser = game.active
+		end_battle()
+		return
+	}
+
+	set_active_defender()
+	if (has_no_unrouted_forces()) {
+		game.battle.loser = game.active
+		end_battle()
+		return
+	}
+
+	game.battle.round ++
+
+	game.battle.ambush = 0
+
+	set_active_attacker()
+	goto_concede()
+}
+
+// === ENDING THE BATTLE ===
+
+// Ending the Battle - optimized from rules as written
+//   Loser retreat / withdraw / remove
+//   Loser losses
+//   Loser service
+//   Victor losses
+//   Victor spoils
+
+// Ending the Storm
+//   Sack (loser removes lords)
+//   Victor losses
+//   Victor spoils
+
+function set_active_loser() {
+	set_active(game.battle.loser)
+}
+
+function set_active_victor() {
+	if (game.battle.loser === P1)
+		set_active(P2)
+	else
+		set_active(P1)
+}
+
+function end_battle() {
+	log_h4(`${game.battle.loser} Lost`)
+
+	game.battle.array = 0
+
+	goto_battle_withdraw()
+}
+
+// === ENDING THE STORM: SACK ===
+
+function award_spoils(n) {
+	add_spoils(PROV, n)
+	add_spoils(COIN, n)
+}
+
+function goto_sack() {
+	let here = game.battle.where
+
+	set_active_victor()
+
+	log(`${game.active} Sacked %${here}.`)
+
+	conquer_stronghold(game.battle.where)
+
+	remove_walls(game.battle.where)
+
+	if (here === LOC_NOVGOROD) {
+		if (game.pieces.veche_coin > 0) {
+			add_spoils(COIN, game.pieces.veche_coin)
+			log(`Awarded ${game.pieces.veche_coin} Coin from Veche.`)
+			game.pieces.veche_coin = 0
+		}
+		award_spoils(3)
+	}
+	else if (is_city(here))
+		award_spoils(2)
+	else if (is_fort(here))
+		award_spoils(1)
+	else if (is_bishopric(here))
+		award_spoils(2)
+	else if (is_castle(here))
+		award_spoils(1)
+
+	set_active_loser()
+	resume_sack()
+}
+
+function resume_sack() {
+	if (has_friendly_lord(game.battle.where))
+		game.state = "sack"
+	else
+		goto_battle_losses_loser()
+}
+
+states.sack = {
+	inactive: "Remove Lords",
+	prompt() {
+		let here = game.battle.where
+		view.prompt = `Sack: Remove all Lords at ${data.locales[here].name}.`
+		for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+			if (get_lord_locale(lord) === here)
+				gen_action_lord(lord)
+	},
+	lord(lord) {
+		transfer_assets_except_ships(lord)
+		if (can_ransom_lord_battle(lord)) {
+			goto_ransom(lord)
+		} else {
+			disband_lord(lord, true)
+			resume_sack()
+		}
+	},
+}
+
+function end_ransom_sack() {
+	resume_sack()
+}
+
+// === ENDING THE BATTLE: WITHDRAW ===
+
+function withdrawal_capacity_needed(here) {
+	let has_upper = 0
+	let has_other = 0
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+		if (get_lord_locale(lord) === here && is_lord_unbesieged(lord) && !is_lower_lord(lord)) {
+			if (is_upper_lord(lord))
+				has_upper++
+			else
+				has_other++
+		}
+	}
+	if (has_upper)
+		return 2
+	if (has_other)
+		return 1
+	return 0
+}
+
+function goto_battle_withdraw() {
+	set_active_loser()
+	game.spoils = 0
+	let here = game.battle.where
+	let wn = withdrawal_capacity_needed(here)
+	if (wn > 0 && can_withdraw(here, wn)) {
+		game.state = "battle_withdraw"
+	} else {
+		end_battle_withdraw()
+	}
+}
+
+function end_battle_withdraw() {
+	goto_retreat()
+}
+
+states.battle_withdraw = {
+	inactive: "Withdraw",
+	prompt() {
+		let here = game.battle.where
+		let capacity = stronghold_capacity(here)
+
+		view.prompt = "Battle: Select Lords to Withdraw into Stronghold."
+
+		// NOTE: Sallying lords are still flagged "besieged" and are thus already withdrawn!
+
+		if (capacity >= 1) {
+			for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+				if (get_lord_locale(lord) === here && !is_lower_lord(lord) && is_lord_unbesieged(lord)) {
+					if (is_upper_lord(lord)) {
+						if (capacity >= 2)
+							gen_action_lord(lord)
+					} else {
+						gen_action_lord(lord)
+					}
+				}
+			}
+		}
+
+		view.actions.end_withdraw = 1
+	},
+	lord(lord) {
+		push_undo()
+		let lower = get_lower_lord(lord)
+
+		log(`L${lord} Withdrew.`)
+		set_lord_besieged(lord, 1)
+
+		if (lower !== NOBODY) {
+			log(`L${lower} Withdrew.`)
+			set_lord_besieged(lower, 1)
+		}
+	},
+	end_withdraw() {
+		clear_undo()
+		end_battle_withdraw()
+	},
+}
+
+// === ENDING THE BATTLE: RETREAT ===
+
+function count_retreat_transport(type) {
+	let n = 0
+	for (let lord of game.battle.retreated)
+		n += count_lord_transport(lord, type)
+	return n
+}
+
+function count_retreat_assets(type) {
+	let n = 0
+	for (let lord of game.battle.retreated)
+		n += get_lord_assets(lord, type)
+	return n
+}
+
+function transfer_assets_except_ships(lord) {
+	add_spoils(PROV, get_lord_assets(lord, PROV))
+	add_spoils(COIN, get_lord_assets(lord, COIN))
+	add_spoils(CART, get_lord_assets(lord, CART))
+	set_lord_assets(lord, PROV, 0)
+	set_lord_assets(lord, COIN, 0)
+	set_lord_assets(lord, CART, 0)
+}
+
+function can_retreat_to(to) {
+	return !has_unbesieged_enemy_lord(to) && !is_unbesieged_enemy_stronghold(to)
+}
+
+function can_retreat() {
+	if (game.march) {
+		// Battle after March
+		if (is_attacker())
+			return can_retreat_to(game.march.from)
+		for (let [to, way] of data.locales[game.battle.where].ways)
+			if (way !== game.march.approach && can_retreat_to(to))
+				return true
+	} else {
+		// Battle after Sally
+		for (let to of data.locales[game.battle.where].adjacent)
+			if (can_retreat_to(to))
+				return true
+	}
+	return false
+}
+
+function goto_retreat() {
+	let here = game.battle.where
+	if (count_unbesieged_friendly_lords(here) > 0 && can_retreat()) {
+		game.battle.retreated = []
+		for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+			if (get_lord_locale(lord) === here && is_lord_unbesieged(lord))
+				set_add(game.battle.retreated, lord)
+		game.state = "retreat"
+	} else {
+		end_retreat()
+	}
+}
+
+function end_retreat() {
+	goto_battle_remove()
+}
+
+states.retreat = {
+	inactive: "Retreat",
+	prompt() {
+		view.prompt = "Battle: Retreat losing Lords."
+		view.group = game.battle.retreated
+		if (game.march) {
+			// after March
+			if (is_attacker()) {
+				gen_action_locale(game.march.from)
+			} else {
+				for (let [to, way] of data.locales[game.battle.where].ways)
+				if (way !== game.march.approach && can_retreat_to(to))
+					gen_action_locale(to)
+			}
+		} else {
+			// after Sally
+			for (let to of data.locales[game.battle.where].adjacent)
+				if (can_retreat_to(to))
+					gen_action_locale(to)
+		}
+	},
+	locale(to) {
+		push_undo()
+		if (game.march) {
+			if (is_attacker()) {
+				game.battle.retreat_to = to
+				game.battle.retreat_way = game.march.approach
+				retreat_1()
+			} else {
+				let ways = list_ways(game.battle.where, to)
+				if (ways.length > 2) {
+					game.battle.retreat_to = to
+					game.state = "retreat_way"
+				} else {
+					game.battle.retreat_to = to
+					game.battle.retreat_way = ways[1]
+					retreat_1()
+				}
+			}
+		} else {
+			let ways = list_ways(game.battle.where, to)
+			if (ways.length > 2) {
+				game.battle.retreat_to = to
+				game.state = "retreat_way"
+			} else {
+				game.battle.retreat_to = to
+				game.battle.retreat_way = ways[1]
+				retreat_1()
+			}
+		}
+	},
+}
+
+states.retreat_way = {
+	inactive: "Retreat",
+	prompt() {
+		view.prompt = `Retreat: Select Way.`
+		view.group = game.battle.retreated
+		let from = game.battle.where
+		let to = game.battle.retreat_to
+		let ways = list_ways(from, to)
+		for (let i = 1; i < ways.length; ++i)
+			gen_action_way(ways[i])
+	},
+	way(way) {
+		game.battle.retreat_way = way
+		retreat_1()
+	},
+}
+
+function retreat_1() {
+	// Retreated without having conceded the Field
+	if (did_not_concede()) {
+		for (let lord of game.battle.retreated)
+			transfer_assets_except_ships(lord)
+		retreat_2()
+	} else {
+		let way = game.battle.retreat_way
+		let transport = count_retreat_transport(data.ways[way].type)
+		let prov = count_retreat_assets(PROV)
+		if (prov > transport)
+			game.state = "retreat_laden"
+		else
+			retreat_2()
+	}
+}
+
+states.retreat_laden = {
+	inactive: "Retreat",
+	prompt() {
+		let to = game.battle.retreat_to
+		let way = game.battle.retreat_way
+		let transport = count_retreat_transport(data.ways[way].type)
+		let prov = count_retreat_assets(PROV)
+
+		if (prov > transport)
+			view.prompt = `Retreat: Hindered with ${prov} Provender and ${transport} Transport.`
+		else
+			view.prompt = `Retreat: Unladen.`
+		view.group = game.battle.retreated
+
+		if (prov > transport) {
+			view.prompt += " Discard Provender."
+			for (let lord of game.battle.retreated) {
+				if (get_lord_assets(lord, PROV) > 0)
+					gen_action_prov(lord)
+			}
+		} else {
+			gen_action_locale(to)
+			view.actions.retreat = 1
+		}
+	},
+	prov(lord) {
+		spoil_prov(lord)
+	},
+	locale(_) {
+		retreat_2()
+	},
+	retreat() {
+		retreat_2()
+	},
+}
+
+function retreat_2() {
+	let to = game.battle.retreat_to
+	let way = game.battle.retreat_way
+
+	if (data.ways[way].name)
+		log(`Retreated via W${way} to %${to}.`)
+	else
+		log(`Retreated to %${to}.`)
+
+	for (let lord of game.battle.retreated)
+		set_lord_locale(lord, to)
+
+	if (is_trade_route(to))
+		conquer_trade_route(to)
+
+	game.battle.retreat_to = 0
+	game.battle.retreat_way = 0
+	end_retreat()
+}
+
+// === ENDING THE BATTLE: REMOVE ===
+
+function goto_battle_remove() {
+	if (count_unbesieged_friendly_lords(game.battle.where) > 0)
+		game.state = "battle_remove"
+	else
+		goto_battle_losses_loser()
+}
+
+states.battle_remove = {
+	inactive: "Remove Lords",
+	prompt() {
+		view.prompt = "Battle: Remove losing Lords who cannot Retreat or Withdraw."
+		let here = game.battle.where
+		for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+			if (get_lord_locale(lord) === here && is_lord_unbesieged(lord))
+				gen_action_lord(lord)
+	},
+	lord(lord) {
+		transfer_assets_except_ships(lord)
+		if (can_ransom_lord_battle(lord)) {
+			goto_ransom(lord)
+		} else {
+			disband_lord(lord, true)
+			goto_battle_remove()
+		}
+	},
+}
+
+function end_ransom_battle_remove() {
+	goto_battle_remove()
+}
+
+// === ENDING THE BATTLE: LOSSES ===
+
+function has_battle_losses() {
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+		if (lord_has_routed_units(lord))
+			return true
+	return false
+}
+
+function goto_battle_losses_loser() {
+	clear_undo()
+	set_active_loser()
+	game.who = NOBODY
+	if (has_battle_losses())
+		if (game.active === P1)
+			log_h4("Teutonic Losses")
+		else
+			log_h4("Russian Losses")
+	resume_battle_losses()
+}
+
+function goto_battle_losses_victor() {
+	clear_undo()
+	set_active_victor()
+	game.who = NOBODY
+	if (has_battle_losses())
+		if (game.active === P1)
+			log_h4("Teutonic Losses")
+		else
+			log_h4("Russian Losses")
+	resume_battle_losses()
+}
+
+function resume_battle_losses() {
+	game.state = "battle_losses"
+	if (!has_battle_losses())
+		goto_battle_losses_remove()
+}
+
+function action_losses(lord, type) {
+	let protection = FORCE_PROTECTION[type]
+	let evade = FORCE_EVADE[type]
+	let target = Math.max(protection, evade)
+
+	// Losers in a Battle roll vs 1 if they did not concede
+	if (game.active === game.battle.loser && did_not_concede())
+		// unless they withdrow
+		if (is_lord_unbesieged(lord))
+			target = 1
+
+	if (game.who !== lord) {
+		log(`L${lord}`)
+		game.who = lord
+	}
+
+	let die = roll_die()
+	if (die <= target) {
+		logi(`${FORCE_TYPE_NAME[type]} ${range(target)}: ${MISS[die]}`)
+		add_lord_routed_forces(lord, type, -1)
+		add_lord_forces(lord, type, 1)
+	} else {
+		logi(`${FORCE_TYPE_NAME[type]} ${range(target)}: ${HIT[die]}`)
+		add_lord_routed_forces(lord, type, -1)
+	}
+
+	resume_battle_losses()
+}
+
+states.battle_losses = {
+	inactive: "Losses",
+	prompt() {
+		view.prompt = "Losses: Determine the fate of your Routed units."
+		for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+			if (is_lord_on_map(lord) && lord_has_routed_units(lord)) {
+				if (get_lord_routed_forces(lord, KNIGHTS) > 0)
+					gen_action_routed_knights(lord)
+				if (get_lord_routed_forces(lord, SERGEANTS) > 0)
+					gen_action_routed_sergeants(lord)
+				if (get_lord_routed_forces(lord, LIGHT_HORSE) > 0)
+					gen_action_routed_light_horse(lord)
+				if (get_lord_routed_forces(lord, ASIATIC_HORSE) > 0)
+					gen_action_routed_asiatic_horse(lord)
+				if (get_lord_routed_forces(lord, MEN_AT_ARMS) > 0)
+					gen_action_routed_men_at_arms(lord)
+				if (get_lord_routed_forces(lord, MILITIA) > 0)
+					gen_action_routed_militia(lord)
+				if (get_lord_routed_forces(lord, SERFS) > 0)
+					gen_action_routed_serfs(lord)
+			}
+		}
+	},
+	routed_knights(lord) {
+		action_losses(lord, KNIGHTS)
+	},
+	routed_sergeants(lord) {
+		action_losses(lord, SERGEANTS)
+	},
+	routed_light_horse(lord) {
+		action_losses(lord, LIGHT_HORSE)
+	},
+	routed_asiatic_horse(lord) {
+		action_losses(lord, ASIATIC_HORSE)
+	},
+	routed_men_at_arms(lord) {
+		action_losses(lord, MEN_AT_ARMS)
+	},
+	routed_militia(lord) {
+		action_losses(lord, MILITIA)
+	},
+	routed_serfs(lord) {
+		action_losses(lord, SERFS)
+	},
+}
+
+// === ENDING THE BATTLE: LOSSES (REMOVE LORDS) ===
+
+function goto_battle_losses_remove() {
+	game.state = "battle_losses_remove"
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+		if (is_lord_on_map(lord) && !lord_has_unrouted_units(lord))
+			return
+	end_battle_losses_remove()
+}
+
+function end_battle_losses_remove() {
+	game.who = NOBODY
+	if (game.active === game.battle.loser)
+		goto_battle_service()
+	else
+		goto_battle_spoils()
+}
+
+states.battle_losses_remove = {
+	inactive: "Remove Lords",
+	prompt() {
+		view.prompt = "Losses: Remove Lords who lost all their Forces."
+		for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+			if (is_lord_on_map(lord) && !lord_has_unrouted_units(lord))
+				gen_action_lord(lord)
+	},
+	lord(lord) {
+		set_delete(game.battle.retreated, lord)
+		if (game.active === game.battle.loser)
+			transfer_assets_except_ships(lord)
+		if (can_ransom_lord_battle(lord)) {
+			goto_ransom(lord)
+		} else {
+			disband_lord(lord, true)
+			goto_battle_losses_remove()
+		}
+	},
+}
+
+function end_ransom_battle_losses_remove() {
+	goto_battle_losses_remove()
+}
+
+// === ENDING THE BATTLE: SPOILS (VICTOR) ===
+
+function log_spoils() {
+	if (game.spoils[PROV] > 0)
+		logi(game.spoils[PROV] + " Provender")
+	if (game.spoils[COIN] > 0)
+		logi(game.spoils[COIN] + " Coin")
+	if (game.spoils[CART] > 0)
+		logi(game.spoils[CART] + " Cart")
+	if (game.spoils[SHIP] > 0)
+		logi(game.spoils[SHIP] + " Ship")
+}
+
+function find_lone_friendly_lord_at(loc) {
+	let who = NOBODY
+	let n = 0
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+		if (get_lord_locale(lord) === loc) {
+			who = lord
+			++n
+		}
+	}
+	if (n === 1)
+		return who
+	return NOBODY
+}
+
+function goto_battle_spoils() {
+	if (has_any_spoils() && has_friendly_lord(game.battle.where)) {
+		log_h4("Spoils")
+		log_spoils()
+		game.state = "battle_spoils"
+		game.who = find_lone_friendly_lord_at(game.battle.where)
+	} else {
+		end_battle_spoils()
+	}
+}
+
+function end_battle_spoils() {
+	game.who = NOBODY
+	game.spoils = 0
+	goto_battle_aftermath()
+}
+
+states.battle_spoils = {
+	inactive: "Spoils",
+	prompt() {
+		if (has_any_spoils()) {
+			view.prompt = "Spoils: Divide " + list_spoils() + "."
+			let here = game.battle.where
+			for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+				if (get_lord_locale(lord) === here)
+					prompt_select_lord(lord)
+			if (game.who !== NOBODY)
+				prompt_spoils()
+		} else {
+			view.prompt = "Spoils: All done."
+			view.actions.end_spoils = 1
+		}
+	},
+	lord: action_select_lord,
+	take_prov: take_spoils_prov,
+	take_coin: take_spoils_coin,
+	take_cart: take_spoils_cart,
+	end_spoils() {
+		clear_undo()
+		end_battle_spoils()
+	},
+}
+
+// === ENDING THE BATTLE: SERVICE (LOSER) ===
+
+function goto_battle_service() {
+	if (game.battle.retreated) {
+		log_h4("Service")
+		resume_battle_service()
+	} else {
+		end_battle_service()
+	}
+}
+
+function resume_battle_service() {
+	if (game.battle.retreated.length > 0)
+		game.state = "battle_service"
+	else
+		end_battle_service()
+}
+
+states.battle_service = {
+	inactive: "Service",
+	prompt() {
+		view.prompt = "Battle: Roll to shift Service of each Retreated Lord."
+		for (let lord of game.battle.retreated)
+			gen_action_service_bad(lord)
+	},
+	service_bad(lord) {
+		let die = roll_die()
+		if (die <= 2)
+			add_lord_service(lord, -1)
+		else if (die <= 4)
+			add_lord_service(lord, -2)
+		else if (die <= 6)
+			add_lord_service(lord, -3)
+		log(`L${lord} ${HIT[die]}, shifted to ${get_lord_service(lord)}.`)
+		set_delete(game.battle.retreated, lord)
+		resume_battle_service()
+	},
+}
+
+function end_battle_service() {
+	goto_battle_losses_victor()
+}
+
+// === ENDING THE BATTLE: AFTERMATH ===
+
+function goto_battle_aftermath() {
+	set_active(game.battle.attacker)
+
+	// Events
+	discard_events("hold")
+
+	// Recovery
+	spend_all_actions()
+
+	if (check_campaign_victory())
+		return
+
+	// Siege/Conquest
+	if (game.march) {
+		game.battle = 0
+		march_with_group_3()
+	} else {
+		game.battle = 0
+		resume_command()
+	}
+}
+
+// === CAMPAIGN: FEED ===
+
+function can_feed_from_shared(lord) {
+	let loc = get_lord_locale(lord)
+	return get_shared_assets(loc, PROV) > 0
+}
+
+function has_friendly_lord_who_must_feed() {
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+		if (is_lord_unfed(lord))
+			return true
+	return false
+}
+
+function can_lord_use_hillforts(lord) {
+	return is_lord_unfed(lord) && is_lord_unbesieged(lord) && is_in_livonia(get_lord_locale(lord))
+}
+
+function can_use_hillforts() {
+	if (game.active === TEUTONS) {
+		if (has_global_capability(AOW_TEUTONIC_HILLFORTS)) {
+			for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+				if (can_lord_use_hillforts(lord))
+					return true
+		}
+	}
+	return false
+}
+
+function goto_feed() {
+	log_br()
+
+	// Count how much food each lord needs
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+		if (get_lord_moved(lord)) {
+			if (count_lord_all_forces(lord) >= 7)
+				set_lord_unfed(lord, 2)
+			else
+				set_lord_unfed(lord, 1)
+		} else {
+			set_lord_unfed(lord, 0)
+		}
+	}
+
+	if (has_friendly_lord_who_must_feed()) {
+		if (can_use_hillforts())
+			game.state = "hillforts"
+		else
+			game.state = "feed"
+	} else {
+		end_feed()
+	}
+}
+
+states.hillforts = {
+	inactive: "Hillforts",
+	prompt() {
+		view.prompt = "Hillforts: Skip Feed of one Unbesieged Lord in Livonia."
+		for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+			if (can_lord_use_hillforts(lord))
+				gen_action_lord(lord)
+	},
+	lord(lord) {
+		push_undo()
+		log(`C${AOW_TEUTONIC_HILLFORTS} skipped L${lord}.`)
+		feed_lord_skip(lord)
+		if (has_friendly_lord_who_must_feed())
+			game.state = "feed"
+		else
+			end_feed()
+	},
+}
+
+states.feed = {
+	inactive: "Feed",
+	prompt() {
+		view.prompt = "Feed: You must Feed Lords who Moved or Fought."
+
+		let done = true
+
+		prompt_held_event()
+
+		// Feed from own mat
+		if (done) {
+			for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+				if (is_lord_unfed(lord)) {
+					if (get_lord_assets(lord, PROV) > 0) {
+						gen_action_prov(lord)
+						done = false
+					}
+				}
+			}
+		}
+
+		// Sharing
+		if (done) {
+			view.prompt = "Feed: You must Feed Lords with Shared Loot or Provender."
+			for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+				if (is_lord_unfed(lord) && can_feed_from_shared(lord)) {
+					gen_action_lord(lord)
+					done = false
+				}
+			}
+		}
+
+		// Unfed
+		if (done) {
+			view.prompt = "Feed: You must shift the Service of any Unfed Lords."
+			for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+				if (is_lord_unfed(lord)) {
+					gen_action_service_bad(lord)
+					done = false
+				}
+			}
+		}
+
+		// All done!
+		if (done) {
+			view.prompt = "Feed: All done."
+			view.actions.end_feed = 1
+		}
+	},
+	prov(lord) {
+		push_undo()
+		add_lord_assets(lord, PROV, -1)
+		feed_lord(lord)
+	},
+	lord(lord) {
+		push_undo()
+		game.who = lord
+		game.state = "feed_lord_shared"
+	},
+	service_bad(lord) {
+		push_undo()
+		add_lord_service(lord, -1)
+		log(`Unfed L${lord} to ${get_lord_service(lord)}.`)
+		set_lord_unfed(lord, 0)
+	},
+	end_feed() {
+		push_undo()
+		end_feed()
+	},
+	card: action_held_event,
+}
+
+function resume_feed_lord_shared() {
+	if (!is_lord_unfed(game.who) || !can_feed_from_shared(game.who)) {
+		game.who = NOBODY
+		game.state = "feed"
+	}
+}
+
+states.feed_lord_shared = {
+	inactive: "Feed",
+	prompt() {
+		view.prompt = `Feed: You must Feed ${lord_name[game.who]} with Shared Loot or Provender.`
+		let loc = get_lord_locale(game.who)
+		for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+			if (get_lord_locale(lord) === loc) {
+				if (get_lord_assets(lord, PROV) > 0)
+					gen_action_prov(lord)
+			}
+		}
+	},
+	prov(lord) {
+		push_undo()
+		add_lord_assets(lord, PROV, -1)
+		feed_lord(game.who)
+		resume_feed_lord_shared()
+	},
+}
+
+function end_feed() {
+	goto_pay()
+}
+
+// === LEVY & CAMPAIGN: PAY ===
+
+function can_pay_lord(lord) {
+	if (get_lord_service(lord) > 16)
+		return false
+	if (game.active === RUSSIANS) {
+		if (game.pieces.veche_coin > 0 && is_lord_unbesieged(lord))
+			return true
+	}
+	let loc = get_lord_locale(lord)
+	if (get_shared_assets(loc, COIN) > 0)
+		return true
+	return false
+}
+
+function has_friendly_lord_who_may_be_paid() {
+	if (game.active === TEUTONS) {
+		// Open a window to play Heinrich sees the Curia.
+		if (could_play_card(EVENT_TEUTONIC_HEINRICH_SEES_THE_CURIA) && can_play_heinrich_sees_the_curia())
+			return true
+	}
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+		if (is_lord_on_map(lord) && can_pay_lord(lord))
+			return true
+	return false
+}
+
+function goto_pay() {
+	log_br()
+	game.state = "pay"
+	game.who = NOBODY
+	if (!has_friendly_lord_who_may_be_paid())
+		end_pay()
+}
+
+function resume_pay() {
+	if (!can_pay_lord(game.who))
+		game.who = NOBODY
+}
+
+states.pay = {
+	inactive: "Pay",
+	prompt() {
+		for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+			if (is_lord_on_map(lord) && can_pay_lord(lord)) {
+				prompt_select_lord(lord)
+				prompt_select_service(lord)
+			}
+		}
+
+		prompt_held_event()
+
+		if (game.who === NOBODY) {
+			view.prompt = "Pay: You may Pay your Lords."
+		} else {
+
+			let here = get_lord_locale(game.who)
+
+			view.prompt = `Pay: You may Pay ${lord_name[game.who]} with Coin.`
+
+			if (game.active === RUSSIANS) {
+				if (game.pieces.veche_coin > 0 && is_lord_unbesieged(game.who))
+					view.actions.veche_coin = 1
+			}
+
+			for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+				if (get_lord_locale(lord) === here) {
+					if (get_lord_assets(lord, COIN) > 0)
+						gen_action_coin(lord)
+				}
+			}
+		}
+
+		view.actions.end_pay = 1
+	},
+	lord: action_select_lord,
+	service: action_select_lord,
+	coin(lord) {
+		push_undo_without_who()
+		log(`Paid L${game.who}.`)
+		add_lord_assets(lord, COIN, -1)
+		add_lord_service(game.who, 1)
+		resume_pay()
+	},
+	veche_coin() {
+		push_undo_without_who()
+		log(`Paid L${game.who} from Veche.`)
+		game.pieces.veche_coin--
+		add_lord_service(game.who, 1)
+		resume_pay()
+	},
+	end_pay() {
+		push_undo_without_who()
+		end_pay()
+	},
+	card: action_held_event,
+}
+
+function end_pay() {
+	// NOTE: We can combine Pay & Disband steps because disband is mandatory only.
+	game.who = NOBODY
+	goto_disband()
+}
+
+// === LEVY & CAMPAIGN: DISBAND ===
+
+function has_friendly_lord_who_must_disband() {
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+		if (is_lord_on_map(lord) && get_lord_service(lord) <= current_turn())
+			return true
+	return false
+}
+
+function goto_disband() {
+	game.state = "disband"
+	if (!has_friendly_lord_who_must_disband())
+		end_disband()
+}
+
+function disband_lord(lord, permanently = false) {
+	let here = get_lord_locale(lord)
+	let turn = current_turn()
+
+	if (permanently) {
+		log(`Removed L${lord}.`)
+		set_lord_locale(lord, NOWHERE)
+		set_lord_service(lord, NEVER)
+	} else if (get_lord_service(lord) < current_turn()) {
+		log(`Disbanded L${lord} beyond Service limit.`)
+		set_lord_locale(lord, NOWHERE)
+		set_lord_service(lord, NEVER)
+	} else {
+		if (is_levy_phase())
+			set_lord_cylinder_on_calendar(lord, turn + data.lords[lord].service)
+		else
+			set_lord_cylinder_on_calendar(lord, turn + data.lords[lord].service + 1)
+		set_lord_service(lord, NEVER)
+		log(`Disbanded L${lord} to ${get_lord_calendar(lord)}.`)
+	}
+
+	if (game.scenario === "Pleskau" || game.scenario === "Pleskau (Quickstart)") {
+		if (is_russian_lord(lord))
+			game.pieces.elr1 ++
+		else
+			game.pieces.elr2 ++
+	}
+
+	remove_lieutenant(lord)
+
+	// Smerdi - serfs go back to card
+	game.pieces.smerdi += get_lord_forces(lord, SERFS)
+
+	discard_lord_capability_n(lord, 0)
+	discard_lord_capability_n(lord, 1)
+	game.pieces.assets[lord] = 0
+	game.pieces.forces[lord] = 0
+	game.pieces.routed[lord] = 0
+
+	set_lord_besieged(lord, 0)
+	set_lord_moved(lord, 0)
+
+	for (let v of data.lords[lord].vassals)
+		game.pieces.vassals[v] = VASSAL_UNAVAILABLE
+}
+
+states.disband = {
+	inactive: "Disband",
+	prompt() {
+		view.prompt = "Disband: You must Disband Lords at their Service limit."
+
+		prompt_held_event()
+
+		let done = true
+		for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+			if (is_lord_on_map(lord) && get_lord_service(lord) <= current_turn()) {
+				gen_action_lord(lord)
+				gen_action_service_bad(lord)
+				done = false
+			}
+		}
+		if (done)
+			view.actions.end_disband = 1
+	},
+	service_bad(lord) {
+		this.lord(lord)
+	},
+	lord(lord) {
+		if (is_lord_besieged(lord) && can_ransom_lord_siege(lord)) {
+			clear_undo()
+			goto_ransom(lord)
+		} else {
+			push_undo()
+			disband_lord(lord)
+		}
+	},
+	end_disband() {
+		end_disband()
+	},
+	card: action_held_event,
+}
+
+function end_ransom_disband() {
+	// do nothing
+}
+
+function end_disband() {
+	clear_undo()
+
+	if (is_campaign_phase()) {
+		if (check_campaign_victory())
+			return
+	}
+
+	set_active_enemy()
+	if (is_campaign_phase()) {
+		if (is_active_command())
+			goto_remove_markers()
+		else
+			goto_feed()
+	} else {
+		if (game.active === P1)
+			goto_levy_muster()
+		else
+			goto_feed()
+	}
+}
+
+// === LEVY & CAMPAIGN: RANSOM ===
+
+function enemy_has_ransom() {
+	if (game.active === TEUTONS)
+		return has_global_capability(AOW_RUSSIAN_RANSOM)
+	else
+		return has_global_capability(AOW_TEUTONIC_RANSOM)
+}
+
+function can_ransom_lord_siege(lord) {
+	return enemy_has_ransom() && has_enemy_lord(get_lord_locale(lord))
+}
+
+function has_enemy_lord_in_battle() {
+	for (let lord = first_enemy_lord; lord <= last_enemy_lord; ++lord)
+		if (get_lord_moved(lord))
+			return true
+	return false
+}
+
+function can_ransom_lord_battle() {
+	return enemy_has_ransom() && has_enemy_lord_in_battle()
+}
+
+function goto_ransom(lord) {
+	clear_undo()
+	set_active_enemy()
+	push_state("ransom")
+	game.who = lord
+	game.count = data.lords[lord].service
+	if (is_teutonic_lord(lord))
+		log(`L${lord} C${AOW_RUSSIAN_RANSOM}.`)
+	else
+		log(`L${lord} C${AOW_TEUTONIC_RANSOM}.`)
+}
+
+function end_ransom() {
+	let here = get_lord_locale(game.who)
+	if (game.battle)
+		disband_lord(game.who, true)
+	else
+		disband_lord(game.who, false)
+	pop_state()
+
+	set_active_enemy()
+	switch (game.state) {
+		case "disband": return end_ransom_disband()
+		case "sack": return end_ransom_sack()
+		case "battle_remove": return end_ransom_battle_remove()
+		case "battle_losses_remove": return end_ransom_battle_losses_remove()
+	}
+}
+
+states.ransom = {
+	inactive: "Ransom",
+	prompt() {
+		if (game.active === TEUTONS)
+			view.prompt = `Ransom ${lord_name[game.who]}: Add ${game.count} Coin to a Teutonic Lord.`
+		else
+			view.prompt = `Ransom ${lord_name[game.who]}: Add ${game.count} Coin to a Russian Lord.`
+		if (game.battle) {
+			for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+				if (get_lord_fought(lord))
+					gen_action_lord(lord)
+		} else {
+			let here = get_lord_locale(game.who)
+			for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+				if (get_lord_locale(lord) === here)
+					gen_action_lord(lord)
+		}
+	},
+	lord(lord) {
+		add_lord_assets(lord, COIN, game.count)
+		end_ransom()
+	},
+}
+
+// === CAMPAIGN: REMOVE MARKERS ===
+
+function goto_remove_markers() {
+	clear_lords_moved()
+	goto_command_activation()
+}
+
+// === END CAMPAIGN: GROWTH ===
+
+function count_enemy_ravaged() {
+	let n = 0
+	for (let loc of game.pieces.ravaged)
+		if (is_friendly_territory(loc))
+			++n
+	return n
+}
+
+function goto_grow() {
+	game.count = count_enemy_ravaged() >> 1
+	log_br()
+	if (game.active === TEUTONS)
+		log("Teutonic Growth")
+	else
+		log("Russian Growth")
+	if (game.count === 0) {
+		logi("Nothing")
+		end_growth()
+	} else {
+		game.state = "growth"
+	}
+}
+
+function end_growth() {
+	set_active_enemy()
+	if (game.active === P2)
+		goto_grow()
+	else
+		goto_game_end()
+}
+
+states.growth = {
+	inactive: "Grow",
+	prompt() {
+		view.prompt = `Grow: Remove ${game.count} enemy Ravaged markers.`
+		if (game.count > 0) {
+			for (let loc of game.pieces.ravaged)
+				if (is_friendly_territory(loc))
+					gen_action_locale(loc)
+		} else {
+			view.actions.end_growth = 1
+		}
+	},
+	locale(loc) {
+		push_undo()
+		logi(`%${loc}`)
+		remove_ravaged_marker(loc)
+		game.count--
+	},
+	end_growth() {
+		clear_undo()
+		end_growth()
+	},
+}
+
+// === END CAMPAIGN: GAME END ===
+
+function check_campaign_victory_p1() {
+	for (let lord = first_p2_lord; lord <= last_p2_lord; ++lord)
+		if (is_lord_on_map(lord))
+			return false
+	return true
+}
+
+function check_campaign_victory_p2() {
+	for (let lord = first_p1_lord; lord <= last_p1_lord; ++lord)
+		if (is_lord_on_map(lord))
+			return false
+	return true
+}
+
+function check_campaign_victory() {
+	if (check_campaign_victory_p1()) {
+		goto_game_over(P1, `${P1} won a Campaign Victory!`)
+		return true
+	}
+	if (check_campaign_victory_p2()) {
+		goto_game_over(P2, `${P2} won a Campaign Victory!`)
+		return true
+	}
+	return false
+}
+
+function goto_end_campaign() {
+	log_h1("End Campaign")
+
+	set_active(P1)
+
+	if (current_turn() === 8 || current_turn() === 16) {
+		goto_grow()
+	} else {
+		goto_game_end()
+	}
+}
+
+function count_vp1() {
+	let vp = game.pieces.elr1 << 1
+	vp += game.pieces.castles1.length << 1
+	for (let loc of game.pieces.conquered)
+		if (is_p2_locale(loc))
+			vp += data.locales[loc].vp << 1
+	for (let loc of game.pieces.ravaged)
+		if (is_p2_locale(loc))
+			vp += 1
+	return vp
+}
+
+function count_vp2() {
+	let vp = game.pieces.elr2 << 1
+	vp += game.pieces.veche_vp << 1
+	vp += game.pieces.castles2.length << 1
+	for (let loc of game.pieces.conquered)
+		if (is_p1_locale(loc))
+			vp += data.locales[loc].vp << 1
+	for (let loc of game.pieces.ravaged)
+		if (is_p1_locale(loc))
+			vp += 1
+	return vp
+}
+
+function goto_game_end() {
+	// GAME END
+	if (current_turn() === scenario_last_turn[game.scenario]) {
+		let vp1 = count_vp1()
+		let vp2 = count_vp2()
+
+		if (game.scenario === "Watland") {
+			if (vp1 < 14)
+				goto_game_over(P2, `Russians won \u2014 Teutons had less than 7 VP.`)
+			else if (vp1 < vp2 * 2)
+				goto_game_over(P2, `Russians won \u2014 Teutons had less than double Russian VP.`)
+			else
+				goto_game_over(P1, `Teutons won with ${frac(vp1)} VP vs ${frac(vp2)} VP.`)
+			return
+		}
+
+		if (vp1 > vp2)
+			goto_game_over(P1, `${P1} won with ${frac(vp1)} VP vs ${frac(vp2)} VP.`)
+		else if (vp2 > vp1)
+			goto_game_over(P2, `${P2} won with ${frac(vp2)} VP vs ${frac(vp1)} VP.`)
+		else
+			goto_game_over("Draw", "The game ended in a draw.")
+	} else {
+		goto_plow_and_reap()
+	}
+}
+
+// === END CAMPAIGN: PLOW AND REAP ===
+
+function goto_plow_and_reap() {
+	let turn = current_turn()
+	end_plow_and_reap()
+}
+
+function end_plow_and_reap() {
+	goto_wastage()
+}
+
+// === END CAMPAIGN: WASTAGE ===
+
+function goto_wastage() {
+	clear_lords_moved()
+
+	let done = true
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+		if (check_lord_wastage(lord)) {
+			set_lord_moved(lord, 3)
+			done = false
+		}
+	}
+
+	if (done)
+		end_wastage()
+	else
+		game.state = "wastage"
+}
+
+function check_lord_wastage(lord) {
+	if (get_lord_assets(lord, PROV) > 1)
+		return true
+	if (get_lord_assets(lord, COIN) > 1)
+		return true
+	if (get_lord_assets(lord, CART) > 1)
+		return true
+	if (get_lord_assets(lord, SHIP) > 1)
+		return true
+	if (get_lord_capability(lord, 0) !== NOTHING && get_lord_capability(lord, 1) !== NOTHING)
+		return true
+	return false
+}
+
+function prompt_wastage(lord) {
+	if (get_lord_assets(lord, PROV) > 0)
+		gen_action_prov(lord)
+	if (get_lord_assets(lord, COIN) > 0)
+		gen_action_coin(lord)
+	if (get_lord_assets(lord, CART) > 0)
+		gen_action_cart(lord)
+	if (get_lord_assets(lord, SHIP) > 0)
+		gen_action_ship(lord)
+	for (let i = 0; i < 2; ++i) {
+		let c = get_lord_capability(lord, i)
+		if (c !== NOTHING)
+			gen_action_card(c)
+	}
+}
+
+function action_wastage(lord, type) {
+	push_undo()
+	set_lord_moved(lord, 0)
+	add_lord_assets(lord, type, -1)
+}
+
+function find_lord_with_capability_card(c) {
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+		if (lord_has_capability_card(lord, c))
+			return lord
+	return NOBODY
+}
+
+states.wastage = {
+	inactive: "Wastage",
+	prompt() {
+		let done = true
+		for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord) {
+			if (get_lord_moved(lord)) {
+				prompt_wastage(lord)
+				done = false
+			}
+		}
+		if (done) {
+			view.prompt = "Wastage: All done."
+			view.actions.end_wastage = 1
+		} else {
+			view.prompt = "Wastage: Discard one Asset or Capability from each affected Lord."
+		}
+	},
+	card(c) {
+		push_undo()
+		let lord = find_lord_with_capability_card(c)
+		set_lord_moved(lord, 0)
+		discard_lord_capability(lord, c)
+	},
+	prov(lord) { action_wastage(lord, PROV) },
+	coin(lord) { action_wastage(lord, COIN) },
+	cart(lord) { action_wastage(lord, CART) },
+	ship(lord) { action_wastage(lord, SHIP) },
+	end_wastage() {
+		end_wastage()
+	},
+}
+
+function end_wastage() {
+	push_undo()
+	goto_reset()
+}
+
+// === END CAMPAIGN: RESET (DISCARD ARTS OF WAR) ===
+
+function goto_reset() {
+	game.state = "reset"
+
+	// Unstack Lieutenants and Lower Lords
+	for (let lord = first_friendly_lord; lord <= last_friendly_lord; ++lord)
+		remove_lieutenant(lord)
+
+	// Remove all Serfs to the Smerdi card
+	if (game.active === RUSSIANS) {
+		for (let lord = first_p2_lord; lord <= last_p2_lord; ++lord)
+			set_lord_forces(lord, SERFS, 0)
+		if (has_global_capability(AOW_RUSSIAN_SMERDI))
+			game.pieces.smerdi = 6
+		else
+			game.pieces.smerdi = 0
+	}
+
+	// Discard "This Campaign" events from play.
+	discard_friendly_events("this_campaign")
+}
+
+states.reset = {
+	inactive: "Reset",
+	prompt() {
+		view.prompt = "Reset: You may discard any Arts of War cards desired."
+		if (game.active === P1) {
+			for (let c = first_p1_card; c <= last_p1_card; ++c)
+				if (can_discard_card(c))
+					gen_action_card(c)
+		}
+		if (game.active === P2) {
+			for (let c = first_p2_card; c <= last_p2_card; ++c)
+				if (can_discard_card(c))
+					gen_action_card(c)
+		}
+		view.actions.end_discard = 1
+	},
+	card(c) {
+		push_undo()
+		if (has_global_capability(c)) {
+			log(`Discarded C${c}.`)
+			discard_global_capability(c)
+		} else if (set_has(game.hand1, c)) {
+			log("Discarded Held card.")
+			set_delete(game.hand1, c)
+		} else if (set_has(game.hand2, c)) {
+			log("Discarded Held card.")
+			set_delete(game.hand2, c)
+		} else {
+			let lord = find_lord_with_capability_card(c)
+			if (lord !== NOBODY) {
+				discard_lord_capability(lord, c)
+			}
+		}
+	},
+	end_discard() {
+		end_reset()
+	},
+}
+
+function end_reset() {
+	clear_undo()
+	set_active_enemy()
+	if (game.active === P2)
+		goto_plow_and_reap()
+	else
+		goto_advance_campaign()
+}
+
+// === END CAMPAIGN: RESET (ADVANCE CAMPAIGN) ===
+
+function goto_advance_campaign() {
+	game.turn++
+
+	log_h1("Levy " + current_turn_name())
+
+	// First turns of late winter
+	if (current_turn() === 5 || current_turn() === 13)
+		goto_discard_crusade_late_winter()
+	else
+		goto_levy_arts_of_war()
+}
+
+// === GAME OVER ===
+
+function goto_game_over(result, victory) {
+	game.state = "game_over"
+	game.active = "None"
+	game.result = result
+	game.victory = victory
+	log_h1("Game Over")
+	log(game.victory)
+	return true
+}
+
+states.game_over = {
+	get inactive() {
+		return game.victory
+	},
+	prompt() {
+		view.prompt = game.victory
+	},
+}
+
+exports.resign = function (state, current) {
+	load_state(state)
+	if (game.state !== "game_over") {
+		for (let opponent of exports.roles) {
+			if (opponent !== current) {
+				goto_game_over(opponent, current + " resigned.")
+				break
+			}
+		}
+	}
+	return game
+}
+
+// === UNCOMMON TEMPLATE ===
+
+function log_br() {
+	if (game.log.length > 0 && game.log[game.log.length - 1] !== "")
+		game.log.push("")
+}
+
+function log(msg) {
+	game.log.push(msg)
+}
+
+function logevent(cap) {
+	game.log.push(`E${cap}.`)
+}
+
+function logcap(cap) {
+	game.log.push(`C${cap}.`)
+}
+
+function logi(msg) {
+	game.log.push(">" + msg)
+}
+
+function logii(msg) {
+	game.log.push(">>" + msg)
+}
+
+function log_h1(msg) {
+	log_br()
+	log(".h1 " + msg)
+	log_br()
+}
+
+function log_h2(msg) {
+	log_br()
+	if (game.active === TEUTONS)
+		log(".h2t " + msg)
+	else
+		log(".h2r " + msg)
+	log_br()
+}
+
+function log_h3(msg) {
+	log_br()
+	if (game.active === TEUTONS)
+		log(".h3t " + msg)
+	else
+		log(".h3r " + msg)
+	log_br()
+}
+
+function log_h4(msg) {
+	log_br()
+	log(".h4 " + msg)
+}
+
+function log_h5(msg) {
+	log_br()
+	log(".h5 " + msg)
+}
+
+function gen_action(action, argument) {
+	if (!(action in view.actions))
+		view.actions[action] = []
+	set_add(view.actions[action], argument)
+}
+
+function gen_action_card_if_held(c) {
+	if (has_card_in_hand(c))
+		gen_action_card(c)
+}
+
+function prompt_select_lord_on_calendar(lord) {
+	if (lord !== game.who) {
+		if (is_lord_on_calendar(lord))
+			gen_action_lord(lord)
+		else
+			gen_action_service(lord)
+	}
+}
+
+function prompt_select_lord(lord) {
+	if (lord !== game.who)
+		gen_action_lord(lord)
+}
+
+function prompt_select_service(lord) {
+	if (lord !== game.who)
+		gen_action_service(lord)
+}
+
+function action_select_lord(lord) {
+	if (game.who === lord)
+		game.who = NOBODY
+	else
+		game.who = lord
+}
+
+function gen_action_calendar(calendar) {
+	if (calendar < 0)
+		calendar = 0
+	if (calendar > 17)
+		calendar = 17
+	gen_action("calendar", calendar)
+}
+
+function gen_action_way(way) {
+	gen_action("way", way)
+}
+
+function gen_action_locale(locale) {
+	gen_action("locale", locale)
+}
+
+function gen_action_laden_march(locale) {
+	gen_action("laden_march", locale)
+}
+
+function gen_action_lord(lord) {
+	gen_action("lord", lord)
+}
+
+function gen_action_array(pos) {
+	gen_action("array", pos)
+}
+
+function gen_action_service(service) {
+	gen_action("service", service)
+}
+
+function gen_action_service_bad(service) {
+	gen_action("service_bad", service)
+}
+
+function gen_action_vassal(vassal) {
+	gen_action("vassal", vassal)
+}
+
+function gen_action_card(c) {
+	gen_action("card", c)
+}
+
+function gen_action_plan(lord) {
+	gen_action("plan", lord)
+}
+
+function gen_action_prov(lord) {
+	gen_action("prov", lord)
+}
+
+function gen_action_coin(lord) {
+	gen_action("coin", lord)
+}
+
+function gen_action_cart(lord) {
+	gen_action("cart", lord)
+}
+
+function gen_action_ship(lord) {
+	gen_action("ship", lord)
+}
+
+function gen_action_knights(lord) {
+	gen_action("knights", lord)
+}
+
+function gen_action_sergeants(lord) {
+	gen_action("sergeants", lord)
+}
+
+function gen_action_light_horse(lord) {
+	gen_action("light_horse", lord)
+}
+
+function gen_action_asiatic_horse(lord) {
+	gen_action("asiatic_horse", lord)
+}
+
+function gen_action_men_at_arms(lord) {
+	gen_action("men_at_arms", lord)
+}
+
+function gen_action_militia(lord) {
+	gen_action("militia", lord)
+}
+
+function gen_action_serfs(lord) {
+	gen_action("serfs", lord)
+}
+
+function gen_action_routed_knights(lord) {
+	gen_action("routed_knights", lord)
+}
+
+function gen_action_routed_sergeants(lord) {
+	gen_action("routed_sergeants", lord)
+}
+
+function gen_action_routed_light_horse(lord) {
+	gen_action("routed_light_horse", lord)
+}
+
+function gen_action_routed_asiatic_horse(lord) {
+	gen_action("routed_asiatic_horse", lord)
+}
+
+function gen_action_routed_men_at_arms(lord) {
+	gen_action("routed_men_at_arms", lord)
+}
+
+function gen_action_routed_militia(lord) {
+	gen_action("routed_militia", lord)
+}
+
+function gen_action_routed_serfs(lord) {
+	gen_action("routed_serfs", lord)
+}
+
+const P1_LORD_MASK = (1|2|4|8|16|32)
+const P2_LORD_MASK = (1|2|4|8|16|32) << 6
+
+exports.view = function (state, current) {
+	load_state(state)
+
+	view = {
+		prompt: null,
+		actions: null,
+		log: game.log,
+		reveal: 0,
+
+		scenario: (scenario_first_turn[game.scenario] << 5) + (scenario_last_turn[game.scenario]),
+		turn: game.turn,
+		events: game.events,
+		capabilities: game.capabilities,
+		pieces: game.pieces,
+		battle: game.battle,
+
+		held1: game.hand1.length,
+		held2: game.hand2.length,
+
+		command: game.command,
+		hand: null,
+		plan: null,
+	}
+
+	if (!game.hidden)
+		view.reveal = -1
+
+	if (current === P1) {
+		view.hand = game.hand1
+		view.plan = game.plan1
+		if (game.hidden)
+			view.reveal |= P1_LORD_MASK
+	}
+	if (current === P2) {
+		view.hand = game.hand2
+		view.plan = game.plan2
+		if (game.hidden)
+			view.reveal |= P2_LORD_MASK
+	}
+
+	if (game.battle) {
+		if (game.battle.array) {
+			for (let lord of game.battle.array)
+				if (lord !== NOBODY)
+					view.reveal |= (1 << lord)
+		}
+		for (let lord of game.battle.reserves)
+			view.reveal |= (1 << lord)
+	}
+
+	if (game.state === "game_over") {
+		view.prompt = game.victory
+	} else if (current === "Observer" || (game.active !== current && game.active !== BOTH)) {
+		let inactive = states[game.state].inactive || game.state
+		view.prompt = `Waiting for ${game.active} \u2014 ${inactive}.`
+	} else {
+		view.actions = {}
+		view.who = game.who
+		if (states[game.state])
+			states[game.state].prompt(current)
+		else
+			view.prompt = "Unknown state: " + game.state
+		if (view.actions.undo === undefined) {
+			if (game.undo && game.undo.length > 0)
+				view.actions.undo = 1
+			else
+				view.actions.undo = 0
+		}
+	}
+	return view
+}
+
+exports.action = function (state, current, action, arg) {
+	load_state(state)
+	// Object.seal(game) // XXX: don't allow adding properties
+	let S = states[game.state]
+	if (S && action in S) {
+		S[action](arg, current)
+	} else {
+		if (action === "undo" && game.undo && game.undo.length > 0)
+			pop_undo()
+		else
+			throw new Error("Invalid action: " + action)
+	}
+	return game
+}
+
+exports.is_checkpoint = function (a, b) {
+	return a.turn !== b.turn
+}
+
+// === COMMON TEMPLATE ===
+
+// Packed array of small numbers in one word
+
+function pack1_get(word, n) {
+	return (word >>> n) & 1
+}
+
+function pack2_get(word, n) {
+	n = n << 1
+	return (word >>> n) & 3
+}
+
+function pack4_get(word, n) {
+	n = n << 2
+	return (word >>> n) & 15
+}
+
+function pack1_set(word, n, x) {
+	return (word & ~(1 << n)) | (x << n)
+}
+
+function pack2_set(word, n, x) {
+	n = n << 1
+	return (word & ~(3 << n)) | (x << n)
+}
+
+function pack4_set(word, n, x) {
+	n = n << 2
+	return (word & ~(15 << n)) | (x << n)
+}
+
+// === COMMON LIBRARY ===
+
+function clear_undo() {
+	if (game.undo.length > 0)
+		game.undo = []
+}
+
+function push_undo_without_who() {
+	let save_who = game.who
+	game.who = NOBODY
+	push_undo()
+	game.who = save_who
+}
+
+function push_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() {
+	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
+}
+
+// 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_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_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_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_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_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, item) {
+	let a = 0
+	let b = (map.length >> 1) - 1
+	while (a <= b) {
+		let m = (a + b) >> 1
+		let x = map[m << 1]
+		if (item < x)
+			b = m - 1
+		else if (item > x)
+			a = m + 1
+		else {
+			array_remove_pair(map, m << 1)
+			return
+		}
+	}
+}