summaryrefslogtreecommitdiff
path: root/rules.js
diff options
context:
space:
mode:
Diffstat (limited to 'rules.js')
-rw-r--r--rules.js964
1 files changed, 787 insertions, 177 deletions
diff --git a/rules.js b/rules.js
index 4cbce82..bc6c618 100644
--- a/rules.js
+++ b/rules.js
@@ -6,30 +6,33 @@ const max = Math.max
const min = Math.min
const abs = Math.abs
+var states = {}
+var game = null
+var view = null
+
+let { hex_exists, hex_road, side_road, side_limit, hex_name, units, regions } = require("./data")
+
function debug_hexes3(n, list) {
console.log("--", n, "--")
+ list = list.map((x,i) => hex_exists[i] ? x : "")
for (let y = 0; y < hexh; ++y)
console.log("".padStart(y*2," ") + list.slice(y*hexw, (y+1)*hexw).map(x=>String(x).padStart(3, ' ')).join(" "))
}
function debug_hexes2(n, list) {
console.log("--", n, "--")
+ list = list.map((x,i) => hex_exists[i] ? x : "")
for (let y = 0; y < hexh; ++y)
console.log("".padStart(y*2," ") + list.slice(y*hexw, (y+1)*hexw).map(x=>String(x).padStart(3, ' ')).join(" "))
}
function debug_hexes(n, list) {
console.log("--", n, "--")
+ list = list.map((x,i) => hex_exists[i] ? x : "")
for (let y = 0; y < hexh; ++y)
- console.log("".padStart(y," ") + list.slice(y*hexw, (y+1)*hexw).join(""))
+ console.log("".padStart(y," ") + list.slice(y*hexw, (y+1)*hexw).map(x=>String(x).padStart(2, ' ')).join(""))
}
-var states = {}
-var game = null
-var view = null
-
-let { hex_road, side_road, side_limit, hex_name, units, regions } = require("./data")
-
// Card deck has 42 cards, of which 28 are supply cards, and 14 are dummy cards.
// Represent draw pile and hands as [ dummy_supply_count, real_supply_count ]
const REAL_SUPPLY_COUNT = 28
@@ -38,13 +41,14 @@ const DUMMY_SUPPLY_COUNT = 14
const hexw = 25
const hexh = 9
-const hexcount = hexw * hexh
-const sidecount = hexcount * 3
+const first_hex = 7
+const last_hex = 215
+
const hexdeploy = hexw * hexh
const hexnext = [ 1, hexw, hexw-1, -1, -hexw, -(hexw-1) ]
-const first_hex = 7
-const last_hex = 215
+const hexcount = last_hex + 1
+const sidecount = hexcount * 3
const AXIS = 'Axis'
const ALLIED = 'Allied'
@@ -92,7 +96,6 @@ function calc_distance_map(supply) {
let map = new Array(hexcount)
for (let x = 0; x < hexcount; ++x)
map[x] = calc_distance(supply, x)
- debug_hexes2(hex_name[supply], map)
return map
}
@@ -132,10 +135,26 @@ function find_unit(name) {
throw new Error("cannot find named block: " + name)
}
+function is_map_hex(x) {
+ return next >= first_hex && next <= last_hex && hex_exists[next] === 1
+}
+
+function is_hex_or_adjacent_to(x, where) {
+ if (x === where) return true
+ for (let s = 0; s < 6; ++s)
+ if (x === where + hexnext[s])
+ return true
+ return false
+}
+
function find_units(list) {
return list.map(name => find_unit(name))
}
+function unit_name(u) {
+ return units[u].name
+}
+
function unit_speed(u) {
return units[u].speed
}
@@ -233,6 +252,8 @@ function is_axis_unit(u) {
}
function is_axis_hex(x) {
+ if (!hex_exists[x])
+ return false
let has_axis = false, has_allied = false
for (let u = 0; u < units.length; ++u) {
if (unit_hex(u) === x) {
@@ -246,6 +267,8 @@ function is_axis_hex(x) {
}
function is_allied_hex(x) {
+ if (!hex_exists[x])
+ return false
let has_axis = false, has_allied = false
for (let u = 0; u < units.length; ++u) {
if (unit_hex(u) === x) {
@@ -259,6 +282,8 @@ function is_allied_hex(x) {
}
function is_battle_hex(x) {
+ if (!hex_exists[x])
+ return false
let has_axis = false, has_allied = false
for (let u = 0; u < units.length; ++u) {
if (unit_hex(u) === x) {
@@ -272,6 +297,8 @@ function is_battle_hex(x) {
}
function is_empty_hex(x) {
+ if (!hex_exists[x])
+ return false
let has_axis = false, has_allied = false
for (let u = 0; u < units.length; ++u) {
if (unit_hex(u) === x) {
@@ -285,6 +312,8 @@ function is_empty_hex(x) {
}
function has_axis_unit(x) {
+ if (!hex_exists[x])
+ return false
for (let u = 0; u < units.length; ++u)
if (unit_hex(u) === x)
if (is_axis_unit(u))
@@ -293,6 +322,8 @@ function has_axis_unit(x) {
}
function has_allied_unit(x) {
+ if (!hex_exists[x])
+ return false
for (let u = 0; u < units.length; ++u)
if (unit_hex(u) === x)
if (is_allied_unit(u))
@@ -312,6 +343,70 @@ function has_enemy_unit(x) {
return has_allied_unit(x)
}
+function claim_hexside_control(side) {
+ if (game.active === AXIS) {
+ set_add(game.axis_sides, side)
+ set_delete(game.allied_sides, side)
+ } else {
+ set_add(game.allied_sides, side)
+ set_delete(game.axis_sides, side)
+ }
+}
+
+function release_hex_control(a) {
+ // no longer a battle hex: release hexsides if possible
+ set_delete(game.axis_hexes, a)
+ set_delete(game.allied_hexes, a)
+ for (let s = 0; s < 6; ++s) {
+ let b = a + hexnext[s]
+ if (b >= first_hex && b <= last_hex && hex_exists[b]) {
+ if (!is_battle_hex(b)) {
+ let side = to_side_id(a, b)
+ set_delete(game.axis_sides, side)
+ set_delete(game.allied_sides, side)
+ }
+ }
+ }
+}
+
+function is_new_battle_hex(a) {
+ if (is_battle_hex(a))
+ return !set_has(game.axis_hexes) && !set_has(game.allied_hexes)
+ return false
+}
+
+function claim_hex_control_for_defender(a) {
+ // a new battle hex: claim hex and hexsides for defender
+
+ if (game.active === AXIS)
+ set_add(game.allied_hexes, a)
+ else
+ set_add(game.axis_hexes, a)
+
+ for (let s = 0; s < 6; ++s) {
+ let b = a + hexnext[s]
+ if (b >= first_hex && b <= last_hex && hex_exists[b]) {
+ let side = to_side_id(a, b)
+ if (side_limit[side] > 0) {
+ if (game.active === AXIS) {
+ if (!set_has(game.axis_sides, side))
+ set_add(game.allied_sides, side)
+ } else {
+ if (!set_has(game.allied_sides, side))
+ set_add(game.axis_sides, side)
+ }
+ }
+ }
+ }
+}
+
+function claim_stuff() {
+ for (let x = first_hex; x <= last_hex; ++x)
+ if (hex_exists[x])
+ if (is_new_battle_hex(x))
+ claim_hex_control_for_defender(x)
+}
+
// === SUPPLY NETWORK ===
function is_side_unit(side, u) {
@@ -338,6 +433,21 @@ function to_side(a, b, s) {
return b * 3 + s - 3
}
+function to_side_id(a, b) {
+ if (a > b) {
+ let c = b
+ b = a
+ a = c
+ }
+ if (a + hexnext[0] === b)
+ return a * 3 + 0
+ else if (a + hexnext[1] === b)
+ return a * 3 + 1
+ else if (a + hexnext[2] === b)
+ return a * 3 + 2
+ throw new Error("not a hexside " + a + " to " + b);
+}
+
function ind(d, msg, here, ...extra) {
console.log(new Array(d).fill("-").join("") + msg, here, "("+hex_name[here]+")", extra.join(" "))
}
@@ -347,8 +457,6 @@ var trace_total
var trace_highway
var trace_chain
-
-
function trace_supply_highway(here, d) {
trace_highway++
ind(d, "> highway", here)
@@ -528,6 +636,219 @@ function update_supply_networks() {
update_allied_supply_network()
}
+function clear_supply_networks() {
+ game.axis_supply = null
+ game.axis_supply_line = null
+ game.allied_supply = null
+ game.allied_supply_line = null
+}
+
+// === MOVEMENT ===
+
+const path_from = [ new Array(hexcount), new Array(hexcount), new Array(hexcount), null, new Array(hexcount) ]
+const path_cost = [ new Array(hexcount), new Array(hexcount), new Array(hexcount), null, new Array(hexcount) ]
+const path_valid = new Array(hexcount)
+const path_enemy = new Array(hexcount)
+
+function search_move(start, start_cost, start_road) {
+ // recon=4, forced march=+1, rommel bonus=+1
+ let limit = 6
+
+ path_enemy.fill(0)
+ for (let u = 0; u < units.length; ++u) {
+ if (is_enemy_unit(u)) {
+ let x = unit_hex(u)
+ if (x >= first_hex && x <= last_hex)
+ path_enemy[x] = 1
+ }
+ }
+
+ search_move_bfs(path_from[0], path_cost[0], start, start_cost, 0, limit)
+ if (start_road >= 1)
+ search_move_bfs(path_from[1], path_cost[1], start, start_cost, 1, limit + 1)
+ if (start_road >= 2)
+ search_move_bfs(path_from[2], path_cost[2], start, start_cost, 2, limit + 2)
+ if (start_road >= 4)
+ search_move_bfs(path_from[4], path_cost[4], start, start_cost, 4, limit + 4)
+
+ let grid = new Array(hexcount).fill('-')
+ for (let x = first_hex; x <= last_hex; ++x) {
+ for (let speed = 4; speed >= 1; --speed) {
+ if (path_cost[0][x] <= speed)
+ grid[x] = speed
+ if (path_cost[1][x] <= speed + 1)
+ grid[x] = speed
+ if (path_cost[2][x] <= speed + 2)
+ grid[x] = speed
+ if (path_cost[4][x] <= speed + 4)
+ grid[x] = speed
+ }
+ }
+ grid[start] = '@'
+
+ debug_hexes2("reach", path_cost[0])
+}
+
+// Breadth First Search
+function search_move_bfs(from, cost, start, start_cost, road, max_cost) {
+ let queue = [ start << 4 | start_cost ]
+
+ from.fill(0)
+ cost.fill(15)
+ cost[start] = start_cost
+
+ while (queue.length > 0) {
+ let item = queue.shift()
+ let here = item >> 4
+ let here_cost = item & 15
+ let next_cost = here_cost + 1
+
+ for (let s = 0; s < 6; ++s) {
+ let next = here + hexnext[s]
+
+ // can't go off-map
+ if (next < first_hex || next > last_hex || !hex_exists[next])
+ continue
+
+ // already seen
+ if (cost[next] < 15)
+ continue
+
+ let side = to_side(here, next, s)
+ let max_side = side_limit[side]
+
+ // can't cross this hexside
+ if (max_side === 0)
+ continue
+
+ // must stay on road for current bonus
+ if (side_road[side] < road)
+ continue
+
+ // check hexside limit
+ if (path_enemy[next] && (game.side_limit[side] | 0) >= max_side)
+ continue
+
+ from[next] = here
+ cost[next] = next_cost
+
+ // must stop
+ if (path_enemy[next])
+ continue
+
+ // enough movement allowance to keep going
+ if (next_cost < max_cost)
+ queue.push(next << 4 | next_cost)
+ }
+ }
+}
+
+function can_move_to(to, road, speed) {
+ // TODO: engagement & hexside limit
+ if (road >= 4 && path_cost[4][to] <= speed + 4)
+ return true
+ if (road >= 2 && path_cost[2][to] <= speed + 2)
+ return true
+ if (road >= 1 && path_cost[1][to] <= speed + 1)
+ return true
+ if (path_cost[0][to] <= speed)
+ return true
+ return false
+}
+
+function can_move_from(from, road, speed) {
+ // TODO: engagement & hexside limit
+ return can_move_to(from, road, speed)
+}
+
+function can_force_march_to(to, road, speed) {
+ if (road >= 4 && path_cost[4][to] <= speed + 5)
+ return true
+ if (road >= 2 && path_cost[2][to] <= speed + 3)
+ return true
+ if (road >= 1 && path_cost[1][to] <= speed + 2)
+ return true
+ if (path_cost[0][to] <= speed + 1)
+ return true
+ return false
+}
+
+function pick_path(to, road, speed) {
+ let next_cost = 15, next_road = 0
+ if (path_cost[0][to] <= speed) {
+ next_cost = path_cost[0][to]
+ next_road = 0
+ }
+ if (road >= 1 && path_cost[1][to] <= speed + 1) {
+ if (path_cost[1][to] <= next_cost) {
+ next_cost = path_cost[1][to]
+ next_road = 1
+ }
+ }
+ if (road >= 2 && path_cost[2][to] <= speed + 2) {
+ if (path_cost[2][to] <= next_cost) {
+ next_cost = path_cost[2][to]
+ next_road = 2
+ }
+ }
+ if (road >= 4 && path_cost[4][to] <= speed + 4) {
+ if (path_cost[4][to] <= next_cost) {
+ next_cost = path_cost[4][to]
+ next_road = 4
+ }
+ }
+ return next_road
+}
+
+function pay_movement_cost(to, this_road, speed) {
+}
+
+function neighbor_has_friendly_unit(here) {
+ for (let s = 0; s < 6; ++s) {
+ let next = here + hexnext[s]
+ if (next >= first_hex && next <= last_hex)
+ if (has_friendly_unit(next))
+ return true
+ }
+ return false
+}
+
+function for_each_hex_and_adjacent_hex(here, fn) {
+ fn(here)
+ for (let s = 0; s < 6; ++s) {
+ let next = here + hexnext[s]
+ if (next >= first_hex && next <= last_hex && hex_exists[next])
+ fn(next)
+ }
+}
+
+function for_each_friendly_unit_in_hex(x, fn) {
+ for (let u = 0; u < units.length; ++u)
+ if (is_friendly_unit(u) && unit_hex(u) === x)
+ fn(u)
+}
+
+function max_speed_of_friendly_unit_in_hex(from) {
+ let max = 0
+ for_each_friendly_unit_in_hex(from, u => {
+ let s = unit_speed(u)
+ if (s > max)
+ max = s
+ })
+ return max
+}
+
+function find_valid_regroup_destinations(from, rommel) {
+ let speed = max_speed_of_friendly_unit_in_hex(from)
+ if (speed > 0) {
+ search_move(from, 0, 4)
+ for (let x = first_hex; x <= last_hex; ++x)
+ if (!path_valid[x])
+ if (can_move_to(x, 4, speed + rommel))
+ path_valid[x] = 1
+ }
+}
+
// === TURN ===
// Supply check
@@ -551,8 +872,8 @@ function end_player_turn() {
function goto_player_turn() {
game.rommel = 0
- game.group_moves = []
- game.regroup_moves = []
+ game.from1 = game.from2 = 0
+ game.to1 = game.to2 = 0
goto_supply_check()
}
@@ -603,12 +924,24 @@ states.turn_option = {
function goto_move_phase() {
game.state = 'select_moves'
+ if (game.active === AXIS) {
+ // Automatically select Rommel Move for 1-move turn options
+ if (game.turn_option !== 'offensive' && game.turn_option !== 'blitz')
+ game.rommel = 1
+ }
}
states.select_moves = {
inactive: "move phase",
prompt() {
- view.prompt = `Make Moves (${game.turn_option})`
+ if (game.turn_option === 'offensive') {
+ if (game.from1)
+ view.prompt = `Designate second offensive move.`
+ else
+ view.prompt = `Designate first offensive move.`
+ } else {
+ view.prompt = `Designate ${game.turn_option} move.`
+ }
gen_action('group')
gen_action('regroup')
},
@@ -618,232 +951,418 @@ states.select_moves = {
},
regroup() {
push_undo()
- game.state = 'regroup_move'
+ game.state = 'regroup_move_command_point'
},
}
+function gen_rommel_move() {
+ if (game.active === AXIS)
+ view.actions.rommel = game.rommel ? 0 : 1
+}
+
states.group_move_from = {
inactive: "group move (from)",
prompt() {
view.prompt = `Group Move: Select hex to move from.`
- for (let x = first_hex; x <= last_hex; ++x)
+ gen_rommel_move()
+ for (let x = first_hex; x <= last_hex; ++x) {
+ if (x === game.from1 && !game.to1)
+ continue
if (has_friendly_unit(x))
gen_action_hex(x)
- if (game.active === AXIS && !game.rommel)
- gen_action('rommel')
+ }
},
rommel() {
push_undo()
- game.rommel = 1
+ if (game.from1 === 0)
+ game.rommel = 1
+ else
+ game.rommel = 2
},
hex(x) {
push_undo()
- game.group_moves.push(x)
- game.state = 'group_move_who'
+ if (game.from1 === 0)
+ game.from1 = x
+ else
+ game.from2 = x
+ if (game.turn_option === 'offensive' && !game.from2)
+ game.state = 'select_moves'
+ else
+ goto_move_who()
},
}
-states.group_move_who = {
- inactive: "group move (who)",
+states.regroup_move_command_point = {
+ inactive: "regroup move (command point)",
prompt() {
- view.prompt = `Group Move: Select unit to move.`
- for (let i = 0; i < game.group_moves.length; ++i) {
- let from = game.group_moves[i]
- for (let u = 0; u < units.length; ++u) {
- if (unit_hex(u) === from && !is_unit_moved(u))
- gen_action_unit(u)
+ view.prompt = `Regroup Move: Designate the command point hex.`
+ gen_rommel_move()
+ for (let x = first_hex; x <= last_hex; ++x) {
+ if (!is_enemy_hex(x)) {
+ if (has_friendly_unit(x) || neighbor_has_friendly_unit(x))
+ gen_action_hex(x)
}
}
- gen_action('end_move')
},
- next() {
- // TODO: end move
+ rommel() {
push_undo()
- game.state = 'select_moves'
+ if (game.from1 === 0)
+ game.rommel = 1
+ else
+ game.rommel = 2
},
- unit(u) {
+ hex(x) {
push_undo()
- game.selected = [ u ]
- game.state = 'group_move_to'
- game.move_used = 0
- game.move_road = 4 // HIGHWAY
+ if (game.from1 === 0)
+ game.from1 = x
+ else
+ game.from2 = x
+ game.state = 'regroup_move_destination'
},
}
-states.group_move_to = {
- inactive: "group move (to)",
+states.regroup_move_destination = {
+ inactive: "regroup move (destination)",
prompt() {
- view.prompt = `Group Move: Select where to move.`
- let u = game.selected[0]
- let from = unit_hex(u)
- if (game.move_used > 0)
- gen_action('stop')
-
- var t0, t1
- t0 = Date.now()
- //for (let i = 0; i < 100000; ++i)
- search_path_move_dfs(u, from, game.move_used, game.move_road)
- t1 = Date.now()
- console.log("DFS", (t1 - t0) / 1000)
-
- var a = path_from.toString()
-
- t0 = Date.now()
- //for (let i = 0; i < 100000; ++i)
- search_path_move_ucs(u, from, game.move_used, game.move_road)
- t1 = Date.now()
- console.log("DFS", (t1 - t0) / 1000)
-
- var b = path_from.toString()
- if (a !== b) {
- console.log(a)
- console.log(b)
- }
-
+ view.prompt = `Regroup Move: Select destination hex.`
+ gen_rommel_move()
+ let cp, rommel = false
+ if (game.from2 === 0)
+ cp = game.from1, rommel = (game.rommel === 1 ? 1 : 0)
+ else
+ cp = game.from2, rommel = (game.rommel === 2 ? 1 : 0)
+ path_valid.fill(0)
+ for_each_hex_and_adjacent_hex(cp, x => {
+ find_valid_regroup_destinations(x, rommel)
+ })
for (let x = first_hex; x <= last_hex; ++x)
- if (path_from[x] > 0)
+ if (path_valid[x])
gen_action_hex(x)
-
- view.path_from = path_from
+ },
+ rommel() {
+ push_undo()
+ if (game.from2 === 0)
+ game.rommel = 1
+ else
+ game.rommel = 2
},
hex(x) {
push_undo()
- let u = game.selected[0]
- set_unit_hex(u, x)
+ if (game.from2 === 0)
+ game.to1 = x
+ else
+ game.to2 = x
+ if (game.turn_option === 'offensive' && !game.from2)
+ game.state = 'select_moves'
+ else
+ goto_move_who()
},
- stop() {
+}
+
+function goto_move_who() {
+ if (game.rommel === 1) {
+ if (game.from1 && game.to1)
+ log(`Regroup move from ${game.from1} to ${game.to1} (Rommel).`)
+ else if (game.from1)
+ log(`Group move from ${game.from1} (Rommel).`)
+ } else {
+ if (game.from1 && game.to1)
+ log(`Regroup move from ${game.from1} to ${game.to1}.`)
+ else if (game.from1)
+ log(`Group move from ${game.from1}.`)
+ }
+ if (game.rommel === 2) {
+ if (game.from2 && game.to2)
+ log(`Regroup move from ${game.from2} to ${game.to2} (Rommel).`)
+ else if (game.from2)
+ log(`Group move from ${game.from2} (Rommel).`)
+ } else {
+ if (game.from2 && game.to2)
+ log(`Regroup move from ${game.from2} to ${game.to2}.`)
+ else if (game.from2)
+ log(`Group move from ${game.from2}.`)
+ }
+ game.state = 'move_who'
+}
+
+function gen_group_move_who(from) {
+ for_each_friendly_unit_in_hex(from, u => {
+ if (!is_unit_moved(u))
+ gen_action_unit(u)
+ })
+}
+
+function gen_regroup_move_who(command_point, destination, rommel) {
+ search_move(destination, 0, 4)
+ for_each_hex_and_adjacent_hex(command_point, x => {
+ if (x !== destination) {
+ for_each_friendly_unit_in_hex(x, u => {
+ if (!is_unit_moved(u) && can_move_from(x, 4, unit_speed(u) + rommel))
+ gen_action_unit(u)
+ })
+ }
+ })
+}
+
+states.move_who = {
+ inactive: "move (who)",
+ prompt() {
+ view.prompt = `Move: Select unit to move.`
+ if (game.from1) {
+ if (game.to1)
+ gen_regroup_move_who(game.from1, game.to1, game.rommel === 1 ? 1 : 0)
+ else
+ gen_group_move_who(game.from1)
+ }
+ if (game.from2) {
+ if (game.to2)
+ gen_regroup_move_who(game.from2, game.to2, game.rommel === 2 ? 1 : 0)
+ else
+ gen_group_move_who(game.from2)
+ }
+ // TODO: retreat
+ gen_action('retreat')
+ gen_action('end_move')
+ },
+ unit(who) {
push_undo()
- let u = game.selected[0]
- set_unit_moved(u)
- game.selected = []
- game.state = 'group_move_who'
+ game.selected = [ who ]
+ game.state = 'move_to'
+ game.move_used = 0
+ game.move_road = 4
+ },
+ end_move() {
+ clear_supply_networks()
}
}
-var path_cost = new Array(hexcount)
-var path_from = new Array(hexcount)
+function rommel_group_move_bonus(from) {
+ if (game.rommel === 1 && from === game.from1 && !game.to1)
+ return 1
+ if (game.rommel === 2 && from === game.from2 && !game.to2)
+ return 1
+ return 0
+}
-function pq_push(queue, hex, used, road) {
- for (let i = 0, n = queue.length; i < n; ++i)
- if (queue[i][1] > used)
- return queue.splice(i, 0, [hex, used, road, hex_name[hex]])
- queue.push([hex, used, road, hex_name[hex]])
+function print_path(who, from, to, road) {
+ let p = [ hex_name[to] ]
+ while (to && to !== from) {
+ to = path_from[road][to]
+ p.unshift(hex_name[to])
+ }
+ log(unit_name(who) + " moved " + p.join(", ") + ".")
}
-// Uniform Cost Search
-function search_path_move_ucs(who, start, start_used, start_road) {
- let speed = unit_speed(who) + HIGHWAY
- path_cost.fill(100)
- path_from.fill(0)
+function print_pathX(who, start, to, road) {
+ let from = path_from[road][to]
+ log(`M ${hex_name[from]} to ${hex_name[to]}`)
+ while (from && from !== start) {
+ to = from
+ from = path_from[road][from]
+ log(`M ${hex_name[from]} to ${hex_name[to]}`)
+ }
+}
- let queue = []
- pq_push(queue, start, start_used, start_road)
- path_cost[start] = start_used
+function apply_move(move, who, from, to) {
+ let speed = unit_speed(who) + (move === game.rommel ? 1 : 0)
+ let road = pick_path(to, game.move_road, speed)
- let n = 0
- while (queue.length > 0) {
- //console.log(queue)
- let [ here, here_used, here_road ] = queue.shift()
- ++n
+ print_path(who, unit_hex(who), to, road)
- // already seen this hex from a shorter path
- if (path_cost[here] < here_used)
- continue
+ game.move_road = road
+ game.move_used = path_cost[road][to]
- for (let s = 0; s < 6; ++s) {
- let next = here + hexnext[s]
+ set_unit_moved(who)
+ set_unit_hex(who, to)
- // can't go off-map
- if (next < first_hex || next > last_hex)
- continue
+ pay_movement_cost(to, game.move_road, speed)
- let side = to_side(here, next, s)
+ if (is_battle_hex(to)) {
+ let side = to_side_id(to, path_from[road][to])
- // can't cross this hexside
- if (side_limit[side] === 0)
- continue
+ log(`cross ${side} ${hex_name[to]}/${hex_name[path_from[road][to]]}`)
- let next_road = min(here_road, side_road[side])
- let road_cost = here_road - next_road
- let next_used = here_used + road_cost + 1
+ if (game.side_limit[side])
+ game.side_limit[side] = 2
+ else
+ game.side_limit[side] = 1
- // not enough movement allowance to reach
- if (next_used > speed)
- continue
+ claim_hexside_control(side)
+ if (is_new_battle_hex(to)) {
+ claim_hex_control_for_defender(to)
+ game.battles.push(to)
+ }
+ return true
+ }
- // a shorter path has already been found
- if (next_used >= path_cost[next])
- continue
+ if (game.move_used === speed + game.move_road)
+ return true
- ind(2, "path", next, next_used, next_road)
+ return false
+}
- path_from[next] = here
- path_cost[next] = next_used
+function unit_speed_1(who) {
+ return unit_speed(who) + (game.rommel === 1 ? 1 : 0)
+}
- // must stop
- if (has_enemy_unit(next))
- continue
+function unit_speed_2(who) {
+ return unit_speed(who) + (game.rommel === 2 ? 1 : 0)
+}
- pq_push(queue, next, next_used, next_road)
- }
- }
+function can_move_regroup_1(who, from, to) {
+ if (to === game.to1 && is_hex_or_adjacent_to(from, game.from1))
+ if (can_move_to(game.to1, 4, unit_speed_1(who)))
+ return true
+ return false
+}
- console.log("UCS VISITED", n)
+function can_move_regroup_2(who, from, to) {
+ if (to === game.to2 && is_hex_or_adjacent_to(from, game.from2))
+ if (can_move_to(game.to2, 4, unit_speed_2(who)))
+ return true
+ return false
}
-var search_n
-function search_path_move_dfs(who, start, start_used, start_road) {
- path_cost.fill(100)
- path_from.fill(0)
+function can_move_group_1(who, from, to) {
+ if (from === game.from1 && !game.to1)
+ if (can_move_to(to, game.move_road, unit_speed_1(who)))
+ return true
+ return false
+}
- ind(0, "?path", start, start_used, unit_speed(who))
- search_n = 1
- path_cost[start] = 0
- path_from[start] = 0
- search_path_move_rec(unit_speed(who) + HIGHWAY, start, start_used, start_road, 2)
- console.log("DFS VISITED", search_n)
+function can_move_group_2(who, from, to) {
+ if (from === game.from2 && !game.to2)
+ if (can_move_to(to, game.move_road, unit_speed_2(who)))
+ return true
+ return false
}
-function search_path_move_rec(speed, here, here_used, here_road, d) {
- ++search_n
- for (let s = 0; s < 6; ++s) {
- let next = here + hexnext[s]
+states.move_to = {
+ inactive: "move (to)",
+ prompt() {
+ view.prompt = `Move: Select where to move.`
+ let who = game.selected[0]
+ let from = unit_hex(who)
- // can't go off-map
- if (next < first_hex || next > last_hex)
- continue
+ search_move(from, 0, 4)
- let side = to_side(here, next, s)
+ if (from === game.from1 && !game.to1)
+ for (let to = first_hex; to <= last_hex; ++to)
+ if (to != from && hex_exists[to] && can_move_group_1(who, from, to))
+ gen_action_hex(to)
- // can't cross this hexside
- if (side_limit[side] === 0)
- continue
+ if (from === game.from2 && !game.to2)
+ for (let to = first_hex; to <= last_hex; ++to)
+ if (to != from && hex_exists[to] && can_move_group_2(who, from, to))
+ gen_action_hex(to)
- let next_road = min(here_road, side_road[side])
- let road_cost = here_road - next_road
- let next_used = here_used + road_cost + 1
+ if (can_move_regroup_1(who, from, game.to1))
+ gen_action_hex(game.to1)
- // not enough movement allowance to reach
- if (next_used > speed)
- continue
+ if (can_move_regroup_2(who, from, game.to2))
+ gen_action_hex(game.to2)
+ },
+ hex(to) {
+ push_undo()
+ let who = game.selected[0]
+ let from = unit_hex(who)
- // a shorter path has already been found
- if (next_used >= path_cost[next])
- continue
+ search_move(from, 0, 4)
- ind(d, "path", next, next_used, speed)
+ if (can_move_group_1(who, from, to)) {
+ log(`group moved ${who} to ${to}`)
+ game.move_from = from
+ if (apply_move(1, who, from, to))
+ stop_move(who)
+ else
+ game.state = 'group_move_to'
+ return
+ }
- path_from[next] = here
- path_cost[next] = next_used
+ if (can_move_group_2(who, from, to)) {
+ log(`group moved ${who} to ${to}`)
+ game.move_from = from
+ if (apply_move(2, who, from, to))
+ stop_move(who)
+ else
+ game.state = 'group_move_to'
+ return
+ }
- // must stop
- if (has_enemy_unit(next))
- continue
+ if (can_move_regroup_1(who, from, to)) {
+ log(`regrouped ${who} to ${to}`)
+ apply_move(1, who, from, to)
+ stop_move(who)
+ game.state = 'move_who'
+ return
+ }
- search_path_move_rec(speed, next, next_used, next_road, d+1)
+ if (can_move_regroup_2(who, from, to)) {
+ log(`regrouped ${who} to ${to}`)
+ apply_move(2, who, from, to)
+ stop_move(who)
+ game.state = 'move_who'
+ return
+ }
+ },
+}
+
+states.group_move_to = {
+ inactive: "group move (to)",
+ prompt() {
+ view.prompt = `Group Move: Select where to move.`
+ let who = game.selected[0]
+ let from = unit_hex(who)
+ if (game.move_used > 0)
+ gen_action('stop')
+
+ search_move(from, game.move_used, game.move_road)
+
+ if (game.move_from === game.from1 && !game.to1)
+ for (let to = first_hex; to <= last_hex; ++to)
+ if (to != from && hex_exists[to] && can_move_group_1(who, game.move_from, to))
+ gen_action_hex(to)
+
+ if (game.move_from === game.from2 && !game.to2)
+ for (let to = first_hex; to <= last_hex; ++to)
+ if (to != from && hex_exists[to] && can_move_group_2(who, game.move_from, to))
+ gen_action_hex(to)
+ },
+ hex(to) {
+ let who = game.selected[0]
+ let from = unit_hex(who)
+
+ search_move(from, game.move_used, game.move_road)
+
+ if (can_move_group_1(who, game.move_from, to)) {
+ log(`group continued ${who} to ${to}`)
+ if (apply_move(1, who, from, to))
+ stop_move(who)
+ return
+ }
+
+ if (can_move_group_2(who, game.move_from, to)) {
+ log(`group continued ${who} to ${to}`)
+ if (apply_move(2, who, from, to))
+ stop_move(who)
+ return
+ }
+ },
+ stop() {
+ let who = game.selected[0]
+ stop_move(who)
}
}
+function stop_move(who) {
+ set_unit_moved(who)
+ game.move_from = 0
+ game.move_road = 4
+ game.move_used = 0
+ game.selected = []
+ game.state = 'move_who'
+}
+
// === DEPLOYMENT ===
states.free_deployment = {
@@ -898,6 +1417,7 @@ states.free_deployment = {
game.selected.length = 0
},
next() {
+ clear_undo()
if (game.active === AXIS)
game.active = ALLIED
else
@@ -1358,12 +1878,14 @@ exports.setup = function (seed, scenario, options) {
log: [],
undo: [],
+ state: null,
phasing: AXIS,
active: AXIS,
selected: null,
scenario: scenario,
month: 0,
+ first_player_turn: AXIS,
draw_pile: [ DUMMY_SUPPLY_COUNT, REAL_SUPPLY_COUNT ],
axis_hand: [ 0, 0 ],
@@ -1374,7 +1896,34 @@ exports.setup = function (seed, scenario, options) {
axis_minefields: [],
allied_minefields: [],
- first_player_turn: AXIS,
+ // supply networks
+ axis_supply: null,
+ axis_supply_line: null,
+ allied_supply: null,
+ allied_supply_line: null,
+
+ // battle hexes (defender)
+ axis_hexes: [],
+ allied_hexes: [],
+
+ // hexside control (for battle hexes)
+ axis_sides: [],
+ allied_sides: [],
+
+ // current turn option and moves
+ turn_option: null,
+ side_limit: {},
+ battles: [],
+ rommel: 0,
+ from1: 0,
+ to1: 0,
+ from2: 0,
+ to2: 0,
+
+ // current group move state
+ move_from: 0,
+ move_used: 0,
+ move_road: 4,
}
setup(scenario)
@@ -1385,18 +1934,28 @@ exports.setup = function (seed, scenario, options) {
exports.view = function(state, current) {
game = state
- //update_supply_networks()
+ // update_supply_networks()
view = {
month: game.month,
units: game.units,
+ axis_hexes: game.axis_hexes,
+ allied_hexes: game.allied_hexes,
+ axis_sides: game.axis_sides,
+ allied_sides: game.allied_sides,
selected: game.selected,
- axis_supply: game.axis_supply,
- axis_supply_line: game.axis_supply_line,
- allied_supply: game.allied_supply,
- allied_supply_line: game.allied_supply_line,
+ // axis_supply: game.axis_supply,
+ // axis_supply_line: game.axis_supply_line,
+ // allied_supply: game.allied_supply,
+ // allied_supply_line: game.allied_supply_line,
}
+ if (game.rommel) view.rommel = game.rommel
+ if (game.from1) view.from1 = game.from1
+ if (game.from2) view.from2 = game.from2
+ if (game.to1) view.to1 = game.to1
+ if (game.to2) view.to2 = game.to2
+
return common_view(current)
}
@@ -1416,7 +1975,7 @@ function gen_action_hex(x) {
function random(n) {
// https://www.ams.org/journals/mcom/1999-68-225/S0025-5718-99-00996-5/S0025-5718-99-00996-5.pdf
- return (game.seed = game.seed * 185852 % 34359738337) % n
+ return (game.seed = game.seed * 200105 % 34359738337) % n
}
function shuffle(deck) {
@@ -1428,6 +1987,53 @@ function shuffle(deck) {
}
}
+// Sorted array treated as Set (for JSON)
+function set_index(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 m
+ }
+ return -1
+}
+
+function set_has(set, item) {
+ return set_index(set, item) >= 0
+}
+
+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
+ }
+ set.splice(a, 0, item)
+}
+
+function set_delete(set, item) {
+ let i = set_index(set, item)
+ if (i >= 0)
+ set.splice(i, 1)
+}
+
+function set_clear(set) {
+ set.length = 0
+}
+
function remove_from_array(array, item) {
let i = array.indexOf(item)
if (i >= 0)
@@ -1539,8 +2145,9 @@ exports.resign = function (state, current) {
exports.action = function (state, current, action, arg) {
game = state
+ // Object.seal(game) // XXX: don't allow adding properties
let S = states[game.state]
- if (action in S) {
+ if (S && action in S) {
S[action](arg, current)
} else {
if (action === 'undo' && game.undo && game.undo.length > 0)
@@ -1558,7 +2165,10 @@ function common_view(current) {
view.prompt = `Waiting for ${game.active} \u2014 ${inactive}...`
} else {
view.actions = {}
- states[game.state].prompt()
+ if (states[game.state])
+ states[game.state].prompt()
+ else
+ view.prompt = "Unknown state: " + game.state
if (game.undo && game.undo.length > 0)
view.actions.undo = 1
else