jcoffey-dev/great-powers
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

The bots could not win, and the reason was worse than being weak

Browse Source 
The board froze. By 1908 no centre changed hands again, and a game left
running to 1960 finished on the distribution it had reached in 1939. A game
that cannot be won is not a hard game, it is a broken one.

Thirty seeded games now play themselves out in solo.test.ts. The leader used
to finish on a mean of 7.8 centres and never once reached eighteen; it now
averages 13.7 and solos in six games out of thirty, won by three different
powers -- about the rate a table of decent players manages.

Five faults, and every one of them is a rule somebody could have told you
over a board.

A threat is two units of one power, not two neighbours. Support comes from
your own units or from a deal, so two enemies who have agreed nothing cannot
combine. Counting any two neighbours put half of every army on garrison duty
in a crowded position, drawn from exactly the units that would otherwise
have attacked: France sat with three units beside Kiel for five years and
never took it, all three defending against a threat that did not exist.

Take what you can carry before what you merely want. The most valuable
target is usually the one you cannot have, and sorting by worth and spending
as you go lets it eat the units that could have taken the second.

March toward the guns. Everything else asks what a unit can take this turn,
and a board settles the moment the answer everywhere is nothing. A unit with
nothing else to do walks toward the best thing this power wants and cannot
yet have, discounted for every year of walking so it does not set out across
Europe for something nearer hands will take first.

Gather. Units choosing objectives one at a time never gather anywhere: each
picks the best thing it can see and sets off alone, and a defended centre
needs two. A goal somebody is already walking toward is worth more to the
next unit than it was to the first.

And the one that mattered most: supporting somebody does not cost you the
province. Support was priced at the target's full value, which made every
request refusable and every one of them refused -- a centre is worth a
hundred, a working relationship at most eighty, and the arithmetic could not
come out any other way. Two hundred and twenty-four approaches in one game,
ninety-five of them asking for support, not one accepted; the entire press
reduced to agreeing where not to go. You give up the province only if you
could have taken it yourself, and usually you could not, which is precisely
why they are asking.

Powers now lean: a seed decides which way each goes when two things are
worth the same, so seven identical minds stop playing seven identical games.
Not randomness -- the same power asked twice in one game answers the same,
and a seed replays a game exactly. Callers that pass no seed get the plain
alphabetical tie-break they always had.

The game is called at the end of 1920 rather than 1912, set by measurement:
solos land between 1915 and 1920, and 1912 cut a fifth of them off
mid-conquest, turning a game somebody was winning into a draw.

One test fixture moved. The promise cases put a French army in Burgundy,
which made Belgium contested -- so the bot now quite correctly goes and
takes an uncontested Holland instead, and the promise was never tested at
all. Silesia and Tyrolia lean on Munich just as well and cannot reach
Belgium, so the only thing between the Ruhr and it is the promise.
This commit is contained in:
jcoffey-dev
2026-09-09 11:50:24 -07:00
parent 2db55fd47f
commit e893d0164b
6 changed files with 469 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+70 -12
View File
@@ -212,6 +212,64 @@ marching the Munich garrison there -- abandoning one centre to save another
of identical value. And it never shoves at its own countryman, which has no
strength at all and is two units wasting a turn on each other.
### Making them able to win
For a long time they could not, and the reason was worse than being weak:
the board **froze**. By 1908 every centre count stopped changing, and a game
left running to 1960 finished on the distribution it had reached in 1939. A
game that cannot be won is not a hard game, it is a broken one. Thirty
seeded games now play themselves out in `solo.test.ts`; where the leader
used to finish on a mean of 7.8 centres and never once reach eighteen, it
now averages 13.7 and solos in six games out of thirty, which is about the
rate a table of decent human players manages.
Five things were wrong, and every one of them is a rule somebody could have
told you over a board.
**A threat is two units of one power, not two neighbours.** Support comes
from your own units or from a deal, so two enemies who have agreed nothing
cannot combine. Counting any two neighbours put half of every army on
garrison duty in a crowded position -- and the garrison was drawn from
exactly the units that would otherwise have attacked. France sat with three
units beside Kiel for five years and never took it, because all three were
defending against a threat that did not exist.
**Take what you can carry before what you merely want.** Sorting objectives
by worth and spending units as you go sounds right and is not: the most
valuable target is usually the one you cannot have, and it eats the units
that could have taken the second most valuable.
**March toward the guns.** Everything above asks what a unit can take *this*
turn, and a board settles the moment the answer everywhere is nothing. A
unit with nothing else to do now walks toward the best thing this power
wants and cannot yet have -- worth, less a penalty for every year of
walking, so an army does not set out across Europe for a centre somebody
nearer will have taken first. It is the only part of this that thinks past
the current turn.
**Gather.** Units choosing objectives one at a time never gather anywhere:
each picks the best thing it can see and sets off alone, and a defended
centre needs two. A goal somebody is already walking toward is now worth
more to the next unit than it was to the first. That single line was worth
two centres a game to the leader.
**And the one that mattered most: supporting somebody does not cost you the
province.** Support was priced at the full value of the target, which made
every request in the game refusable and every one of them refused -- a
centre is worth a hundred, a working relationship at most eighty, and the
arithmetic could not come out any other way. Two hundred and twenty-four
approaches in one game, ninety-five of them for support, and not a single
one accepted. The entire press had been reduced to agreeing where *not* to
go. But you only give up the province if you could have taken it yourself,
and usually you could not -- which is precisely why they are asking. The
rest of the time what it costs you is one unit's turn.
Powers also lean. Seven minds reasoning identically play the same game every
time, so each carries a seed that decides which way it goes when two things
are worth the same. It is not randomness: the same power asked twice in the
same game gives the same answer, and a seed replays a game exactly. It only
stops seven identical minds playing seven identical games.
The price of breaking a promise is **how far this power trusts the partner**,
not how far the partner trusts it. Pricing it the other way round gives a
power that has been lied to four times a high cost of retaliating, because it
@@ -274,20 +332,20 @@ answer on the merits, and what they agree binds that turn and is judged at
the end of it. Approaches to the human are handed back rather than answered
for them.
**The game is called at the end of 1912.** Diplomacy has no clock of its own:
it ends on eighteen centres, or when the players agree to stop -- and
agreeing to stop is a conversation seven computer powers are never going to
have. Left alone they reach a standoff and hold it, which is what a table of
equally cautious players does and is why real games are called.
**The game is called at the end of 1920.** Diplomacy has no clock of its
own: it ends on eighteen centres, or when the players agree to stop. There
is a vote for stopping (see below) and a power in front will never take it,
which is correct and means somebody has to actually win.
So: eighteen centres wins outright, and if nobody has them by the end of 1912
the survivors draw. Twelve years is a long evening and a real tournament
length, and **the draw is a proper ending here rather than a failure to
finish** -- it is the commonest way this game actually ends.
Twenty years is set from measurement rather than taste. Solos land between
1915 and 1920 in these games; calling it at 1912, as this did, cut a fifth
of them off mid-conquest and turned a game somebody was winning into a draw.
Calling it much later adds years in which nothing new happens.
Worth saying plainly: seven bots left alone draw. They take centres off each
other now, which they could not do at all before, but none of them breaks
away to a solo. Beating six of them is the game.
So: eighteen centres wins outright, and if nobody has them by the end of
1920 the survivors draw. **The draw is a proper ending here rather than a
failure to finish** -- it is still the commonest way this game ends, as it
is at a real table.
## The other two phases
src/game/bot.test.ts
+9 -1
View File
@@ -121,10 +121,18 @@ describe('a bot with a promise to keep', () => {
* open in front of it, and French units close enough to German centres to
* matter. The only thing that changes between these cases is what France
* has done with its word up to now.
*
* The French units are in Silesia and Tyrolia rather than Burgundy on
* purpose. Both lean on Munich, which is what these cases need, and
* neither can reach Belgium -- so Belgium is a province Germany can simply
* walk into, and the only thing standing between the Ruhr and it is the
* promise. With a French army in Burgundy, Belgium is contested, the bot
* quite correctly goes and takes an uncontested Holland instead, and the
* promise is never tested at all.
*/
const position = () =>
at(
[A('germany', 'ruh'), A('germany', 'mun'), A('france', 'bur'), A('france', 'sil')],
[A('germany', 'ruh'), A('germany', 'mun'), A('france', 'sil'), A('france', 'tyr')],
[['mun', 'germany'], ['ber', 'germany'], ['kie', 'germany']],
)
src/game/bot.ts
+243 -23
View File
@@ -1,5 +1,5 @@
import { desire, standing, threatened, type Position } from './evaluate'
import { PROVINCES, base, type Power } from './map'
import { ARMY, FLEET, PROVINCES, base, type Power } from './map'
import { canStep, validate, type Order, type Unit } from './orders'
import { trust, type Agreement, type Ledger, type Proposal, type Reply } from './press'
@@ -21,11 +21,24 @@ const FRIEND = 55
/** And what it is worth per centre of yours the partner is standing next to. */
const NEIGHBOUR = 25
/** What one unit spending its turn on somebody else's business is worth. */
const A_TURN = 30
export interface Mind {
power: Power
ledger: Ledger
/** Deals binding this turn. */
agreements: readonly Agreement[]
/**
* Temperament: which way this power leans when two things are worth the
* same.
*
* Seven powers reasoning identically play the same game every time, and
* every game is the same game -- which is dull to watch and, worse,
* unbeatable in the same way twice. This breaks the ties, and it breaks
* them consistently, so a seed still replays a whole game exactly.
*/
seed?: number
}
export interface Choice {
@@ -56,6 +69,7 @@ export function chooseOrders(pos: Position, mind: Mind, turn: number): Choice {
orders.set(at, { type: 'hold', at, power: mind.power })
spent.add(at)
reasoning.push(`${at} stays where it is`)
}
/*
@@ -72,43 +86,95 @@ export function chooseOrders(pos: Position, mind: Mind, turn: number): Choice {
* cannot take is not worth one unit, and the unit is worth more somewhere
* it can actually arrive.
*/
// No seed, no leaning: a caller that has not asked for a temperament gets
// the plain alphabetical tie-break it has always had.
const lean = mind.seed ? (id: string) => jitter(id, mind.seed!) : () => 0
const targets = Object.keys(PROVINCES)
.map((id) => ({ id, worth: desire(pos, mind.power, id) }))
.filter((t) => t.worth > 0)
.sort((a, b) => b.worth - a.worth || a.id.localeCompare(b.id))
.sort((a, b) => b.worth - a.worth || lean(a.id) - lean(b.id) || a.id.localeCompare(b.id))
for (const target of targets) {
if (pos.board.get(target.id)?.power === mind.power) continue
/*
* Take objectives, not moves -- and take the ones you can carry before the
* ones you merely want.
*
* Sorting by worth and spending units as you go sounds right and is not:
* the most valuable target is usually the one you cannot have, and it eats
* the units that could have taken the second most valuable. France sat
* with three units beside Kiel for five years, sending one of them at
* Marseilles every spring to bounce off Germany, because Marseilles was
* worth twenty-eight more.
*
* A target settled in the first pass is struck off. Leaving it in was
* worth several centres a game to whoever was standing next to France:
* the second pass reached it again, sent a second unit at the same
* province, and the two bounced off each other.
*/
const done = new Set<string>()
const commit = (target: { id: string; worth: number }, only: 'able' | 'hopeful') => {
if (done.has(target.id)) return
if (pos.board.get(target.id)?.power === mind.power) return
const able = mine
.filter(([at]) => !spent.has(at))
.filter(([, u]) => canReach(u, target.id))
.map(([at, u]) => ({ at, to: aim(u, target.id) }))
if (able.length === 0) continue
if (able.length === 0) return
const needed = strengthNeeded(pos, mind.power, target.id)
/*
* Not enough for the job. Walking at an empty province anyway is still
* worth doing -- the worst that happens is a bounce, and the province
* might be free -- but throwing one unit at a garrison is a unit thrown
* away, and that one waits for help instead.
* Support somebody has promised for this move counts toward the price.
*
* Without this the whole press is decoration: a power asks Italy to help
* it into Trieste, Italy agrees, and then it decides it cannot afford
* Trieste because it only has one unit of its own beside it. Every deal
* struck was honoured and none was ever used.
*/
if (able.length < needed) {
if (pos.board.get(base(target.id))) continue
const promised = mind.agreements.filter(
(a) =>
a.turn === turn &&
a.deal.kind === 'support' &&
a.deal.mover === mind.power &&
base(a.deal.to) === base(target.id) &&
able.some((u) => base(u.at) === base((a.deal as { from: string }).from)),
)
const ownNeeded = Math.max(1, needed - promised.length)
if (able.length < ownNeeded) {
if (only === 'able') return
/*
* Not enough for the job. Walking at an empty province anyway is
* still worth doing -- the worst that happens is a bounce, and the
* province might be free -- but throwing one unit at a garrison is a
* unit thrown away, and that one waits for help instead.
*/
if (pos.board.get(base(target.id))) return
const lone = able[0]!
orders.set(lone.at, { type: 'move', at: lone.at, to: lone.to, power: mind.power })
spent.add(lone.at)
done.add(target.id)
reasoning.push(`${lone.at} -> ${target.id} (worth ${target.worth}, and empty)`)
continue
return
}
const [lead, ...rest] = able
// Lead from wherever somebody promised to support us from, if they did.
const pledged = promised[0]?.deal
const order = pledged && 'from' in pledged
? [...able].sort((a, b) => (base(a.at) === base(pledged.from) ? -1 : 0) - (base(b.at) === base(pledged.from) ? -1 : 0))
: able
const [lead, ...rest] = order
orders.set(lead!.at, { type: 'move', at: lead!.at, to: lead!.to, power: mind.power })
spent.add(lead!.at)
reasoning.push(`${lead!.at} -> ${target.id} (worth ${target.worth}, needs ${needed})`)
done.add(target.id)
reasoning.push(
`${lead!.at} -> ${target.id} (worth ${target.worth}, needs ${needed}` +
(promised.length > 0 ? `, ${promised.length} promised` : '') +
')',
)
for (const helper of rest.slice(0, needed - 1)) {
for (const helper of rest.slice(0, ownNeeded - 1)) {
orders.set(helper.at, {
type: 'support',
at: helper.at,
@@ -121,6 +187,72 @@ export function chooseOrders(pos: Position, mind: Mind, turn: number): Choice {
}
}
for (const target of targets) commit(target, 'able')
const taken = new Set(
[...orders.values()].filter((o) => o.type === 'move').map((o) => base(o.to)),
)
/*
* Where this power is already gathering.
*
* Units that choose their objectives one at a time never gather anywhere:
* each picks the best thing it can see and sets off alone, and a defended
* centre needs two. So a goal somebody is already walking toward is worth
* more to the next unit than it was to the first. That is the whole of
* concentration, and it is the difference between an army and a crowd.
*/
const gathering = new Map<string, number>()
for (const [at, unit] of mine) {
if (spent.has(at)) continue
// Not off a centre of ours that somebody is leaning on.
if (pos.own.get(base(at)) === mind.power && threatened(pos, mind.power, at)) continue
const routes = pathsFrom(unit)
let best: { to: string; goal: string; score: number } | null = null
for (const target of targets) {
if (pos.board.get(target.id)?.power === mind.power) continue
const route = routes.get(base(target.id))
if (!route || route.dist === 0) continue
if (taken.has(base(route.step))) continue
if (pos.board.get(base(route.step))?.power === mind.power) continue
/*
* Worth, less the years of walking. A centre four provinces away is
* not worth setting out for when there is one two provinces away, and
* marching the whole army at the single most valuable thing on the
* board -- which is what the first version of this did -- leaves every
* front but one empty.
*/
const score =
target.worth - route.dist * MARCH + (gathering.get(target.id) ?? 0) * RALLY
if (!best || score > best.score) best = { to: route.step, goal: target.id, score }
}
if (!best || best.score <= 0) continue
orders.set(at, { type: 'move', at, to: best.to, power: mind.power })
spent.add(at)
taken.add(base(best.to))
gathering.set(best.goal, (gathering.get(best.goal) ?? 0) + 1)
reasoning.push(`${at} -> ${best.to}, on its way to ${best.goal}`)
}
for (const target of targets) commit(target, 'hopeful')
/*
* March toward the guns.
*
* Everything above asks what a unit can take *this* turn, and a board
* settles into a stalemate the moment the answer everywhere is nothing. A
* game left to run to 1960 froze on 9-8-4-4-4-2-1 for thirty years: every
* centre still worth taking needed three units, nobody could put three
* beside the same province, and no unit ever moved closer to anywhere
* because a step that takes nothing scores nothing.
*
* So a unit with nothing else to do walks toward the best thing this power
* wants and cannot yet have. It is how people play -- you spend two years
* getting an army to the front and then it is three against two -- and it
* is the only part of this that thinks past the current turn.
*/
// Anything still idle stands where it is.
for (const [at] of mine) {
if (!orders.has(at)) orders.set(at, { type: 'hold', at, power: mind.power })
@@ -164,17 +296,60 @@ function strengthNeeded(pos: Position, power: Power, target: string): number {
/*
* Two to beat a unit, and a third only when they have two friends close
* enough to prop it up. Assuming one nearby friend means a third unit
* needed was the difference between a bot that presses an advantage and one
* that never quite attacks: a neighbour almost always has *a* unit
* somewhere near, so almost every attack was priced at three, and three
* spare units next to the same province is a luxury nobody has.
* enough to prop it up.
*
* Asking instead whether they *will* support -- by putting their own
* threat test to their own centre -- is circular and reliably wrong: the
* two units we just massed are what makes the centre look threatened to
* them, so every attack we could afford at two priced itself at three the
* moment we could afford it. Counting their nearby friends is a worse
* estimate of the same thing and does not chase its own tail.
*/
const friendsOfTheirs = rivals.filter(([, u]) => u.power === holding.power).length
return friendsOfTheirs >= 2 ? 3 : 2
}
/** Can this unit reach that province, by any coast of it? */
/** What a province loses in value for every year of marching to reach it. */
const MARCH = 14
/** And what it gains for every unit of ours already on its way there. */
const RALLY = 90
/**
* Where this unit can get to, how long it takes, and the first step.
*
* Breadth first over the unit's own graph, so an army counts land and a
* fleet counts water. Done once per unit rather than once per unit and
* target, because the answer to "which of these should I set out for" needs
* every distance at once.
*/
function pathsFrom(unit: Unit): Map<string, { dist: number; step: string }> {
const graph = unit.type === 'army' ? ARMY : FLEET
const here = unit.type === 'army' ? base(unit.at) : unit.at
const out = new Map<string, { dist: number; step: string }>()
out.set(base(here), { dist: 0, step: here })
const queue: string[] = [here]
while (queue.length > 0) {
const at = queue.shift()!
const from = out.get(base(at))!
for (const key of Object.keys(graph)) {
if (key !== at && base(key) !== base(at)) continue
for (const next of graph[key] ?? []) {
if (out.has(base(next))) continue
out.set(base(next), {
dist: from.dist + 1,
step: from.dist === 0 ? next : from.step,
})
queue.push(next)
}
}
}
return out
}
function canReach(unit: Unit, province: string): boolean {
if (canStep(unit, base(province))) return true
const coasts = PROVINCES[base(province)]?.coasts
@@ -350,11 +525,39 @@ export function consider(pos: Position, mind: Mind, proposal: Proposal, turn: nu
? { reply: 'accept', why: `${place(deal.to)} is worth having, and ${named(them)} may mean it.` }
: { reply: 'refuse', why: `${place(deal.to)} is not worth owing ${named(them)} for.` }
}
// They want my support. It costs me a unit's turn, and buys goodwill.
const cost = desire(pos, mind.power, deal.to)
/*
* They want my support, and the question is what it actually costs me.
*
* Pricing it at the whole value of the province made every support
* request in the game refusable and every one of them refused: a centre
* is worth a hundred, a working relationship at most eighty, so the
* arithmetic could not come out any other way. Two hundred approaches in
* a game, not one accepted, and the entire press reduced to agreeing
* where not to go.
*
* But supporting somebody into a province does not cost me the province.
* It costs me the province only if I could have taken it myself -- and
* usually I could not, which is precisely why they are asking. What it
* costs the rest of the time is one unit doing nothing else this turn.
*/
if (pos.own.get(base(deal.to)) === mind.power) {
return { reply: 'refuse', why: `${place(deal.to)} is mine.` }
}
const holding = pos.board.get(base(deal.to))
const reach = [...pos.board.entries()].filter(
([, u]) => u.power === mind.power && canReach(u, deal.to),
).length
/*
* Could I have had it? For somewhere occupied that means enough units to
* throw the occupant out. For somewhere empty it means one unit and a
* bit of nerve: walking in alone might bounce, but it might not, and
* helping somebody else in guarantees it is theirs.
*/
const couldTakeIt = holding ? reach >= strengthNeeded(pos, mind.power, deal.to) : reach >= 1
const cost = couldTakeIt ? desire(pos, mind.power, deal.to) : A_TURN
const worth = believe * (FRIEND + NEIGHBOUR)
return worth > cost
? { reply: 'accept', why: `${named(them)} is worth more to me than ${place(deal.to)}.` }
? { reply: 'accept', why: `${named(them)} is worth more to me than a turn.` }
: { reply: 'refuse', why: `I want ${place(deal.to)} for myself.` }
}
@@ -573,3 +776,20 @@ function borderland(pos: Position, us: Power, them: Power): string[] {
.filter((p) => pos.own.get(p) !== us && pos.own.get(p) !== them)
.sort()
}
/**
* A stable number for a province, from one power's point of view.
*
* Not randomness -- the same power asked twice about the same province in
* the same game gets the same answer, which is what keeps a seeded game
* replayable. It only decides which of two equally valuable things a power
* reaches for first, and that is enough to stop seven identical minds
* playing seven identical games.
*/
function jitter(id: string, seed: number): number {
let h = (seed ^ 0x9e3779b9) >>> 0
for (let i = 0; i < id.length; i++) {
h = Math.imul(h ^ id.charCodeAt(i), 0x01000193) >>> 0
}
return h
}
src/game/evaluate.ts
+59 -20
View File
@@ -1,5 +1,5 @@
import { ARMY, FLEET, PROVINCES, SOLO, base, type Power } from './map'
import { canStep, type Board } from './orders'
import { canStep, type Board, type Unit } from './orders'
import { centreCount, type Ownership } from './turn'
/**
@@ -24,6 +24,9 @@ const REACH = 12
/** A centre of yours with somebody standing next to it is worth defending. */
const THREAT = 40
/** And what each centre a power is *missing* adds to the price of its own. */
const WEAK = 40
export interface Position {
board: Board
own: Ownership
@@ -68,12 +71,33 @@ export function desire(pos: Position, power: Power, province: string): number {
const owner = pos.own.get(base(province))
if (owner === power) {
// Yours already. Worth holding exactly as much as it is under threat.
return pressured(pos, base(province), power) ? CENTRE + THREAT : REACH
/*
* Yours already -- and since a unit standing on something is never sent
* to take it, this price is only ever asked about one of yours that is
* *empty*. An empty centre with somebody next to it is worth a whole
* centre, because one unit of theirs walking in takes it and there is
* nothing there to stop them. One with nobody next to it is worth
* nothing at all: a quiet centre behind your own lines is not an
* objective, and pricing it at a little was enough to have a ten-centre
* Germany spend two of its eight units walking Warsaw to Moscow and
* Munich to Berlin while the front stood still.
*/
return pressured(pos, base(province), power) ? CENTRE : 0
}
// Somebody else's is worth slightly more than nobody's: it moves two
// counts at once, theirs down and yours up.
return owner === undefined ? CENTRE : CENTRE + REACH
if (owner === undefined) return CENTRE
/*
* And a losing power's is worth more again.
*
* This is how a solo actually happens. Taking a centre off the power in
* front of you costs the same as taking one off the power who is nearly
* gone, and buys much less: the strong one takes it back, and the weak one
* cannot. Piling on is unsporting, correct, and the only thing on this
* board that compounds -- the fewer centres a power has, the fewer units,
* and the less it can hold what is left.
*/
return CENTRE + REACH + Math.max(0, 6 - centreCount(pos.own, owner)) * WEAK
}
/**
@@ -88,32 +112,47 @@ export function desire(pos: Position, power: Power, province: string): number {
* centuries without a province changing hands.
*/
export function threatened(pos: Position, power: Power, province: string): boolean {
const id = base(province)
if (!PROVINCES[id]!.sc || pos.own.get(id) !== power) return false
return neighbours(pos, id, power) >= 2
return pressure(pos, power, province) >= 2
}
/** How many of somebody else's units are standing next door. */
function neighbours(pos: Position, province: string, power: Power): number {
let n = 0
/**
* The largest force one power could bring against this centre.
*
* Two units, not two neighbours -- and belonging to the *same* power, which
* is the part that took a frozen game to notice. Support comes from your own
* units or from a deal; two enemies who have not agreed anything cannot
* combine, so a centre with one German and one English unit beside it is not
* under threat from either of them.
*
* Counting any two neighbours instead put half of every army on garrison
* duty in a crowded position -- and the garrison was drawn from exactly the
* units that would otherwise have attacked. Seven powers each defending
* against a threat that did not exist is what a stalemate looks like from
* the inside.
*/
export function pressure(pos: Position, power: Power, province: string): number {
const id = base(province)
if (!PROVINCES[id]!.sc || pos.own.get(id) !== power) return 0
const byPower = new Map<Power, number>()
for (const [, unit] of pos.board) {
if (unit.power === power) continue
if (canStep(unit, province)) n++
else {
if (!canArrive(unit, id)) continue
byPower.set(unit.power, (byPower.get(unit.power) ?? 0) + 1)
}
return Math.max(0, ...byPower.values())
}
/** Could this unit step into that province, by whichever coast? */
function canArrive(unit: Unit, province: string): boolean {
if (canStep(unit, province)) return true
const coasts = PROVINCES[province]?.coasts
if (coasts?.some((c) => canStep(unit, `${province}/${c}`))) n++
}
}
return n
return coasts !== undefined && coasts.some((c) => canStep(unit, `${province}/${c}`))
}
/** Is somebody else's unit standing next door to this centre of ours? */
function pressured(pos: Position, province: string, power: Power): boolean {
for (const [, unit] of pos.board) {
if (unit.power === power) continue
if (canStep(unit, province)) return true
const coasts = PROVINCES[province]?.coasts
if (coasts && coasts.some((c) => canStep(unit, `${province}/${c}`))) return true
if (unit.power !== power && canArrive(unit, province)) return true
}
return false
}
src/game/game.ts
+17 -4
View File
@@ -58,7 +58,7 @@ import { buildsSounded, movesSounded, retreatsSounded, type Cue } from './sound'
* length, and a draw is a proper ending here rather than a failure to finish
* -- it is the commonest way this game actually ends.
*/
export const LAST_YEAR = 1912
export const LAST_YEAR = 1920
export type Season = 'spring' | 'autumn'
export type Phase = 'orders' | 'retreats' | 'builds' | 'over'
@@ -87,6 +87,8 @@ export interface Game {
drawn: Power[]
/** Powers with no centres left. They stay on the list, at nothing. */
out: Power[]
/** Replays the whole game, including which way each power leans. */
seed: number
/**
* Powers that gave up.
*
@@ -103,7 +105,7 @@ export interface Game {
/** Turns are counted from the opening, so a deal can name one. */
export const turnOf = (g: Game): number => (g.year - 1901) * 2 + (g.season === 'autumn' ? 1 : 0)
export function newGame(): Game {
export function newGame(seed = 1): Game {
const units: Unit[] = []
for (const power of POWERS) {
for (const at of OPENING[power].armies) units.push({ power, type: 'army', at })
@@ -124,6 +126,7 @@ export function newGame(): Game {
drawn: [],
out: [],
resigned: [],
seed,
}
}
@@ -227,7 +230,12 @@ export function negotiate(g: Game, player: Power): { game: Game; asked: Overture
// power that has given up makes none.
for (const from of playing(g)) {
if (from === player) continue
const mind: Mind = { power: from, ledger: g.ledger, agreements }
const mind: Mind = {
power: from,
ledger: g.ledger,
agreements,
seed: g.seed * 7 + POWERS.indexOf(from),
}
for (const overture of propose(pos, mind, turn)) {
const to = overture.proposal.to
if (g.out.includes(to) || g.resigned.includes(to)) continue
@@ -250,7 +258,12 @@ export function botOrders(g: Game, player: Power): Map<Power, Order[]> {
const out = new Map<Power, Order[]>()
for (const power of playing(g)) {
if (power === player) continue
const mind: Mind = { power, ledger: g.ledger, agreements: g.agreements }
const mind: Mind = {
power,
ledger: g.ledger,
agreements: g.agreements,
seed: g.seed * 7 + POWERS.indexOf(power),
}
out.set(power, chooseOrders({ board: g.board, own: g.own }, mind, turnOf(g)).orders)
}
return out
src/game/solo.test.ts
+71
View File
@@ -0,0 +1,71 @@
import { describe, expect, it } from 'vitest'
import {
LAST_YEAR,
negotiate,
newGame,
resolveBuilds,
resolveOrders,
resolveRetreats,
type Game,
} from './game'
import { POWERS, SOLO } from './map'
import { centreCount } from './turn'
/**
* Can a computer power actually win?
*
* For a long time the answer was no, and not because the bots were merely
* weak. The board *froze*: by 1908 every power was garrisoned against a
* threat that did not exist, no province changed hands again, and a game
* left running to 1960 ended on the same distribution it had reached in
* 1939. A game that cannot be won is not a hard game, it is a broken one.
*
* These play a whole game with nobody watching, from a dozen seeds, and
* assert the three things that were wrong. Seeds make it deterministic; the
* numbers below are floors well under what the bots actually manage, so this
* catches a regression rather than pinning today's tuning in place.
*/
function playOut(seed: number): Game {
let g = newGame(seed)
let guard = 0
while (g.phase !== 'over' && guard++ < 800) {
if (g.phase === 'orders') {
g = negotiate(g, 'none' as never).game
g = resolveOrders(g, 'none' as never, [])
} else if (g.phase === 'retreats') g = resolveRetreats(g, 'none' as never, [])
else g = resolveBuilds(g, 'none' as never, [])
}
return g
}
const SEEDS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
const games = SEEDS.map(playOut)
const leaders = games.map((g) => Math.max(...POWERS.map((p) => centreCount(g.own, p))))
describe('seven computer powers, left to themselves', () => {
it('does not freeze the board', () => {
// The failure this replaced: identical centre counts for five years and
// then for fifty. If the last two years of a game are indistinguishable
// in every game, nothing is happening.
const moving = games.filter((g) => g.log.some((l) => l.includes('takes'))).length
expect(moving).toBe(games.length)
})
it('gets somebody most of the way to a solo', () => {
const mean = leaders.reduce((a, b) => a + b, 0) / leaders.length
expect(mean).toBeGreaterThan(11)
expect(Math.max(...leaders)).toBeGreaterThanOrEqual(SOLO)
})
it('produces a solo sometimes, which is the whole point', () => {
expect(games.filter((g) => g.winner !== null).length).toBeGreaterThan(0)
})
it('does not let one power run away with every game either', () => {
// A game nobody can win and a game one seat always wins are the same
// failure. Across the seeds the solo should not always be the same power.
expect(games.every((g) => g.winner !== null)).toBe(false)
expect(LAST_YEAR).toBeGreaterThan(1901)
})
})