fertig-classic-games/src/games/civilization/CivilizationGame.js

986 lines
38 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// Civilization (Civ II-lite) — main Phaser scene.
//
// Phases: setup -> playing -> over. Setup picks a leader character (the
// standard opponents double as civilizations), world size, rival count and
// difficulty. The engine (CivilizationLogic) is headless; this scene drives it
// and renders through CivilizationMapView. AI rivals play via CivilizationAI.
import * as Phaser from 'phaser';
import { GAME_WIDTH, GAME_HEIGHT, COLORS } from '../../config.js';
import { Button } from '../../ui/Button.js';
import { TextInput } from '../../ui/TextInput.js';
import { MusicPlayer } from '../../ui/MusicPlayer.js';
import { compileRules, turnToYear, formatYear } from './CivilizationRules.js';
import * as Logic from './CivilizationLogic.js';
import { runAITurn, respondToProposal } from './CivilizationAI.js';
import { CivilizationMapView } from './CivilizationMapView.js';
import { openCityScreen } from './CivilizationCityScreen.js';
import {
openTechScreen, openDiplomacyScreen, openSpaceshipScreen, showVictoryOverlay,
} from './CivilizationScreens.js';
const FONT = '"Julius Sans One"';
const SAVE_KEY = 'civilization-save';
const D = { hud: 30, modal: 60, toast: 80 };
export default class CivilizationGame extends Phaser.Scene {
constructor() { super('CivilizationGame'); }
init(data) {
this.gameDef = data.game ?? { slug: 'civilization', name: 'Civilization' };
this.state = null;
this.view = null;
this.phase = 'setup';
this.modalOpen = false;
this.busy = false;
this.endTurnFlashTween = null;
}
create() {
this.rules = compileRules(this.cache.json.get('civilization-rules'));
this.add.rectangle(GAME_WIDTH / 2, GAME_HEIGHT / 2, GAME_WIDTH, GAME_HEIGHT, 0x0a0d12)
.setDepth(-10);
this.hudRoot = this.add.container(0, 0).setDepth(D.hud);
this.modalRoot = this.add.container(0, 0).setDepth(D.modal);
this.toastRoot = this.add.container(0, 0).setDepth(D.toast);
this.setupRoot = null;
this.toasts = [];
this.keys = this.input.keyboard.addKeys('UP,DOWN,LEFT,RIGHT,Q,E,Z,C,W,A,S,D,B,F,G,I,M,N,O,R,T,SPACE,ENTER');
this.escHandler = () => this.onEscape();
this.input.keyboard.on('keydown-ESC', this.escHandler);
this.events.once('shutdown', () => {
this.input.keyboard.off('keydown-ESC', this.escHandler);
this.view?.destroy();
});
try {
const music = this.cache.json.get('music');
if (music?.tracks) this.music = new MusicPlayer(this, music.tracks);
} catch (_) { /* optional */ }
this.opponentsData = [];
fetch('data/opponents.json')
.then((r) => r.json())
.then((json) => { this.opponentsData = json.opponents ?? []; this.showSetup(); })
.catch(() => { this.opponentsData = []; this.showSetup(); });
}
onEscape() {
if (this.modalOpen) return; // modals close themselves
if (this.phase === 'playing') this.openMenu();
else this.scene.start('GameMenu');
}
// ===========================================================================
// Setup phase
showSetup() {
this.phase = 'setup';
this.setupRoot?.destroy(true);
this.setupRoot = this.add.container(0, 0).setDepth(10);
const root = this.setupRoot;
const cx = GAME_WIDTH / 2;
root.add(this.add.text(cx, 52, 'CIVILIZATION', {
fontFamily: 'Righteous', fontSize: '54px', color: COLORS.accentHex,
}).setOrigin(0.5));
root.add(this.add.text(cx, 100, 'Build an empire to stand the test of time', {
fontFamily: FONT, fontSize: '20px', color: COLORS.mutedHex,
}).setOrigin(0.5));
// --- leader pick grid
root.add(this.add.text(cx, 150, 'CHOOSE YOUR LEADER', {
fontFamily: FONT, fontSize: '24px', color: COLORS.textHex,
}).setOrigin(0.5));
const leaders = this.opponentsData.length ? this.opponentsData
: Array.from({ length: 8 }, (_, i) => ({ id: `leader${i}`, name: `Leader ${i + 1}`, spriteIndex: 0 }));
this.setupLeaders = leaders;
this.pickedLeader = this.pickedLeader ?? 0;
const perRow = 15;
const cell = 96;
const gridW = Math.min(leaders.length, perRow) * cell;
const gx = cx - gridW / 2 + cell / 2;
const gy = 214;
this.leaderMarks = [];
leaders.forEach((op, i) => {
const x = gx + (i % perRow) * cell;
const y = gy + Math.floor(i / perRow) * (cell + 18);
const ring = this.add.circle(x, y, 40, COLORS.panel)
.setStrokeStyle(3, i === this.pickedLeader ? COLORS.gold : COLORS.muted);
let face;
if (this.textures.exists('opponents')) {
face = this.add.image(x, y, 'opponents', op.spriteIndex ?? 0).setDisplaySize(72, 72);
const maskShape = this.make.graphics({ add: false });
maskShape.fillStyle(0xffffff);
maskShape.fillCircle(x, y, 36);
face.setMask(maskShape.createGeometryMask());
} else {
face = this.add.text(x, y, op.name[0], {
fontFamily: 'Righteous', fontSize: '34px', color: COLORS.textHex,
}).setOrigin(0.5);
}
const label = this.add.text(x, y + 52, op.name, {
fontFamily: FONT, fontSize: '14px',
color: i === this.pickedLeader ? COLORS.goldHex : COLORS.mutedHex,
}).setOrigin(0.5);
ring.setInteractive({ useHandCursor: true });
ring.on('pointerdown', () => {
this.pickedLeader = i;
this.leaderMarks.forEach((m, j) => {
m.ring.setStrokeStyle(3, j === i ? COLORS.gold : COLORS.muted);
m.label.setColor(j === i ? COLORS.goldHex : COLORS.mutedHex);
});
});
this.leaderMarks.push({ ring, label });
root.add([ring, face, label]);
});
const rowsUsed = Math.ceil(leaders.length / perRow);
let oy = gy + rowsUsed * (cell + 18) + 40;
// --- option rows
this.setupOpts = this.setupOpts ?? { sizeId: 'medium', opponents: 3, difficultyId: 'prince' };
const mkRow = (label, options, current, onPick) => {
root.add(this.add.text(cx - 560, oy, label, {
fontFamily: FONT, fontSize: '22px', color: COLORS.textHex,
}).setOrigin(0, 0.5));
const marks = [];
const startX = cx - 260;
options.forEach((opt, i) => {
const w = Math.max(90, opt.label.length * 13 + 30);
const x = startX + options.slice(0, i).reduce((a, o) => a + Math.max(90, o.label.length * 13 + 30) + 14, 0);
const rect = this.add.rectangle(x + w / 2, oy, w, 44, COLORS.panel)
.setStrokeStyle(2, opt.value === current ? COLORS.gold : COLORS.muted);
const txt = this.add.text(x + w / 2, oy, opt.label, {
fontFamily: FONT, fontSize: '19px',
color: opt.value === current ? COLORS.goldHex : COLORS.textHex,
}).setOrigin(0.5);
rect.setInteractive({ useHandCursor: true });
rect.on('pointerdown', () => {
onPick(opt.value);
marks.forEach((m, j) => {
m.rect.setStrokeStyle(2, options[j].value === opt.value ? COLORS.gold : COLORS.muted);
m.txt.setColor(options[j].value === opt.value ? COLORS.goldHex : COLORS.textHex);
});
});
marks.push({ rect, txt });
root.add([rect, txt]);
});
oy += 62;
};
mkRow('World Size',
this.rules.worldSizeList.map((w) => ({ label: `${w.name} (${w.cols}×${w.rows})`, value: w.id })),
this.setupOpts.sizeId, (v) => { this.setupOpts.sizeId = v; });
mkRow('Rival Civilizations',
[2, 3, 4, 5, 6, 7].map((n) => ({ label: `${n}`, value: n })),
this.setupOpts.opponents, (v) => { this.setupOpts.opponents = v; });
mkRow('Difficulty',
this.rules.difficultyList.map((d) => ({ label: d.name, value: d.id })),
this.setupOpts.difficultyId, (v) => { this.setupOpts.difficultyId = v; });
oy += 8;
const startBtn = new Button(this, cx - (this.hasSave() ? 160 : 0), oy + 20, 'BEGIN', () => {
this.startNewGame();
}, { width: 280, height: 64, fontSize: 30 });
root.add(startBtn);
if (this.hasSave()) {
const resumeBtn = new Button(this, cx + 160, oy + 20, 'RESUME GAME', () => {
this.resumeGame();
}, { width: 280, height: 64, fontSize: 26, variant: 'ghost' });
root.add(resumeBtn);
}
}
hasSave() {
try { return !!localStorage.getItem(SAVE_KEY); } catch (_) { return false; }
}
startNewGame() {
const { sizeId, opponents, difficultyId } = this.setupOpts;
const pool = this.setupLeaders;
const me = pool[this.pickedLeader];
const rivals = pool.filter((_, i) => i !== this.pickedLeader);
// Shuffle rivals with Math.random (game determinism starts at engine seed).
for (let i = rivals.length - 1; i > 0; i -= 1) {
const j = Math.floor(Math.random() * (i + 1));
[rivals[i], rivals[j]] = [rivals[j], rivals[i]];
}
const leaders = [me, ...rivals.slice(0, opponents)]
.map((op) => ({ id: op.id, name: op.name }));
const seed = (Date.now() % 1000000) + 1;
try {
this.state = Logic.createGame(this.rules, {
sizeId, seed, difficultyId, leaders, humanIndex: 0,
});
} catch (err) {
this.toast(`World generation failed — try again (${err.message})`);
return;
}
this.leaderPool = leaders;
this.beginPlaying();
}
resumeGame() {
try {
const state = Logic.deserialize(localStorage.getItem(SAVE_KEY));
if (!state) { this.toast('Saved game is from an old version'); localStorage.removeItem(SAVE_KEY); return; }
this.state = state;
this.beginPlaying(true);
} catch (_) {
this.toast('Could not load the save');
}
}
saveGame() {
try { localStorage.setItem(SAVE_KEY, Logic.serialize(this.state)); } catch (_) { /* full */ }
}
clearSave() {
try { localStorage.removeItem(SAVE_KEY); } catch (_) { /* noop */ }
}
// ===========================================================================
// Playing phase
beginPlaying(resumed = false) {
this.phase = 'playing';
this.setupRoot?.destroy(true);
this.setupRoot = null;
this.view = new CivilizationMapView(this, this.rules, this.state, {
onCityClick: (city) => this.onCityClick(city),
});
this.view.buildMinimap(16, GAME_HEIGHT - 260, 300);
this.buildHud();
this.bindPointer();
const human = this.state.civs[this.state.humanIndex];
const capital = Logic.civCities(this.state, human.id)[0];
const firstUnit = Logic.civUnits(this.state, human.id)[0];
const focus = capital ?? firstUnit;
if (focus) this.view.centerOn(focus.x, focus.y);
if (!resumed || this.state.current !== this.state.humanIndex) {
// Fresh games (and saves mid-AI-round) run up to the human turn.
this.runToHumanTurn();
} else {
this.startHumanTurn(false);
}
}
buildHud() {
this.hudRoot.removeAll(true);
const bar = this.add.rectangle(GAME_WIDTH / 2, 28, GAME_WIDTH, 56, COLORS.panel, 0.95)
.setStrokeStyle(1, COLORS.accent, 0.6);
this.hudRoot.add(bar);
this.hudText = this.add.text(20, 28, '', {
fontFamily: FONT, fontSize: '21px', color: COLORS.textHex,
}).setOrigin(0, 0.5);
this.hudRoot.add(this.hudText);
const mkBtn = (x, label, fn, w = 150) => {
const b = new Button(this, x, 28, label, fn, { width: w, height: 42, fontSize: 18 });
this.hudRoot.add(b);
return b;
};
mkBtn(GAME_WIDTH - 860, 'TECH', () => this.openTech());
mkBtn(GAME_WIDTH - 700, 'DIPLOMACY', () => this.openDiplomacy(), 170);
mkBtn(GAME_WIDTH - 530, 'SPACESHIP', () => this.openSpaceship(), 170);
mkBtn(GAME_WIDTH - 370, 'MENU', () => this.openMenu(), 120);
this.endTurnBtn = new Button(this, GAME_WIDTH - 210, 28, 'END TURN', () => this.onEndTurn(),
{ width: 180, height: 42, fontSize: 18, bg: COLORS.gold, textColor: COLORS.textDarkHex });
this.hudRoot.add(this.endTurnBtn);
// Right-side unit/terrain panel.
this.unitPanel = this.add.container(GAME_WIDTH - 300, 80);
const panelBg = this.add.rectangle(0, 0, 284, 240, COLORS.panel, 0.92)
.setOrigin(0, 0).setStrokeStyle(2, COLORS.accent, 0.7);
this.unitPanelText = this.add.text(14, 14, '', {
fontFamily: FONT, fontSize: '17px', color: COLORS.textHex,
wordWrap: { width: 256 }, lineSpacing: 5,
});
this.unitPanel.add([panelBg, this.unitPanelText]);
this.hudRoot.add(this.unitPanel);
this.hintText = this.add.text(GAME_WIDTH / 2, GAME_HEIGHT - 24,
'Arrows/QEZC move · B found city · R road · I irrigate · M mine · O fortress · F fortify · Space skip · N next · Enter end turn',
{ fontFamily: FONT, fontSize: '15px', color: COLORS.mutedHex }).setOrigin(0.5);
this.hudRoot.add(this.hintText);
this.refreshHud();
}
refreshHud() {
if (!this.state || this.phase !== 'playing') return;
const civ = this.state.civs[this.state.humanIndex];
const year = formatYear(turnToYear(this.state.turn, this.rules.yearCurve));
const gov = this.rules.governments[civ.government].name;
const research = civ.researching
? `${this.rules.techs[civ.researching].name} ${civ.beakers}/${Logic.currentResearchCost(this.rules, this.state, civ)}`
: '— pick research —';
this.hudText.setText(`${year} Gold: ${civ.gold} Science: ${research} ${gov}`);
this.refreshUnitPanel();
}
refreshUnitPanel() {
const unit = this.selectedUnit();
if (!unit) {
this.unitPanelText.setText(this.busy ? 'Rivals are moving…' : 'No unit selected.\nClick a unit or press N.');
return;
}
const def = this.rules.units[unit.type];
const terr = Logic.terrainAt(this.rules, this.state.world, unit.x, unit.y);
const idx = Logic.tileIndex(this.state.world, unit.x, unit.y);
const spec = this.state.world.special[idx] >= 0
? this.rules.specialList[this.state.world.special[idx]].name : null;
const lines = [
`${def.name}${unit.vet ? ' (V)' : ''}`,
`A${def.attack} D${def.defense} HP ${unit.hp}/${def.hp}`,
`Moves: ${(unit.mp / 3).toFixed(unit.mp % 3 ? 1 : 0)}`,
`Terrain: ${terr.name}${spec ? ` (${spec})` : ''}`,
];
if (unit.order?.kind === 'work') {
lines.push(`Working: ${this.rules.improvements[unit.order.imp].name}`);
}
if (unit.fortified) lines.push('Fortified');
this.unitPanelText.setText(lines.join('\n'));
}
// ---------------------------------------------------------------------------
// Pointer + keyboard input
bindPointer() {
let dragStart = null;
let dragged = false;
this.input.on('pointerdown', (pointer) => {
if (this.modalOpen || this.phase !== 'playing') return;
dragStart = { x: pointer.x, y: pointer.y, rx: this.view.root.x, ry: this.view.root.y };
dragged = false;
});
this.input.on('pointermove', (pointer) => {
if (!pointer.isDown || !dragStart || this.modalOpen) return;
const dx = pointer.x - dragStart.x;
const dy = pointer.y - dragStart.y;
if (Math.abs(dx) + Math.abs(dy) > 8) dragged = true;
if (dragged) {
this.view.root.x = dragStart.rx + dx;
this.view.root.y = dragStart.ry + dy;
this.view.clampPan();
}
});
this.input.on('pointerup', (pointer) => {
const wasDrag = dragged;
dragStart = null;
dragged = false;
if (wasDrag || this.modalOpen || this.phase !== 'playing' || this.busy) return;
if (pointer.y < 56 || pointer.y > GAME_HEIGHT - 44) return; // HUD bands
// Clicks that landed on any interactive object (buttons, minimap, city
// banners) are theirs, not the map's.
if (this.input.hitTestPointer(pointer).length > 0) return;
const tile = this.view.screenToTile(pointer.x, pointer.y);
if (tile) this.onTileClick(tile[0], tile[1]);
});
this.input.on('wheel', (pointer, objs, dx, dy) => {
if (this.modalOpen || this.phase !== 'playing') return;
this.view.zoomBy(dy > 0 ? -1 : 1, pointer.x, pointer.y);
});
}
onTileClick(c, r) {
const state = this.state;
const human = state.humanIndex;
const city = Logic.cityAt(state, c, r);
// Fortified units in a city are hidden on the map (see CivilizationMapView) —
// clicking the tile should open the city, not select an invisible unit.
const myUnits = Logic.unitsAt(state, c, r)
.filter((u) => u.civ === human && !(city && u.fortified));
const sel = this.selectedUnit();
// A movable selected unit clicking a different owned city is ambiguous —
// ask whether to move it in or just inspect the city.
if (city && city.civ === human && sel && sel.mp > 0 && state.current === human
&& (sel.x !== c || sel.y !== r)) {
this.confirmMoveOrInspectCity(sel, city, c, r);
return;
}
if (myUnits.length && (!sel || sel.x !== c || sel.y !== r)) {
this.selectUnit(myUnits[0]);
return;
}
if (myUnits.length && sel && sel.x === c && sel.y === r) {
// Cycle the stack.
const i = myUnits.indexOf(sel);
this.selectUnit(myUnits[(i + 1) % myUnits.length]);
return;
}
if (city && city.civ === human && !myUnits.length) {
this.onCityClick(city);
return;
}
// Move the selected unit toward the clicked tile.
if (sel) this.moveTo(sel, c, r);
}
moveTo(unit, c, r) {
if (this.state.current !== this.state.humanIndex) return;
if (Logic.cheb(unit.x, unit.y, c, r) === 1) {
this.tryStep(unit, c - unit.x, r - unit.y, true);
return;
}
const path = Logic.findPath(this.rules, this.state, unit, c, r);
if (!path) { this.toast('No route there'); return; }
this.view.showPath(path);
this.walkPath(unit, path);
}
confirmMoveOrInspectCity(unit, city, c, r) {
const name = this.rules.units[unit.type].name;
this.confirmDialog(`Move ${name} into ${city.name}, or inspect the city?`,
() => this.moveTo(unit, c, r),
() => this.onCityClick(city),
'MOVE', 'INSPECT');
}
onCityClick(city) {
if (city.civ !== this.state.humanIndex || this.modalOpen) return;
this.modalOpen = true;
openCityScreen(this, this.rules, this.state, city, () => {
this.modalOpen = false;
this.view.refresh();
this.refreshHud();
});
}
update() {
if (this.phase !== 'playing' || this.modalOpen || this.busy) return;
// Edge-of-keyboard panning.
const k = this.keys;
const pan = 14;
if (k.W.isDown) this.view.panBy(0, pan);
if (k.S.isDown && !k.S.shiftKey) this.view.panBy(0, -pan);
if (k.A.isDown) this.view.panBy(pan, 0);
if (k.D.isDown) this.view.panBy(-pan, 0);
if (this.state?.current !== this.state?.humanIndex) return;
const sel = this.selectedUnit();
const just = (key) => Phaser.Input.Keyboard.JustDown(key);
if (just(k.N)) this.selectNextUnit();
if (just(k.ENTER)) this.onEndTurn();
if (!sel) return;
if (just(k.UP)) this.tryStep(sel, 0, -1);
else if (just(k.DOWN)) this.tryStep(sel, 0, 1);
else if (just(k.LEFT)) this.tryStep(sel, -1, 0);
else if (just(k.RIGHT)) this.tryStep(sel, 1, 0);
else if (just(k.Q)) this.tryStep(sel, -1, -1);
else if (just(k.E)) this.tryStep(sel, 1, -1);
else if (just(k.Z)) this.tryStep(sel, -1, 1);
else if (just(k.C)) this.tryStep(sel, 1, 1);
else if (just(k.SPACE)) { sel.mp = 0; this.selectNextUnit(); }
else if (just(k.F)) { sel.fortified = true; sel.mp = 0; this.afterAction(); this.selectNextUnit(); }
else if (just(k.B)) this.tryFound(sel);
else if (just(k.R)) this.tryWork(sel, this.canRail(sel) ? 'railroad' : 'road');
else if (just(k.I)) this.tryWork(sel, 'irrigation');
else if (just(k.M)) this.tryWork(sel, 'mine');
else if (just(k.O)) this.tryWork(sel, 'fortress');
else if (just(k.T)) this.tryWork(sel, 'transform');
else if (just(k.G)) this.tryCaravan(sel);
}
canRail(unit) {
const bits = this.state.world.improvements[Logic.tileIndex(this.state.world, unit.x, unit.y)];
return (bits & Logic.IMP.ROAD) && this.state.civs[unit.civ].known.railroad;
}
selectedUnit() {
if (!this.state || this.selectedUnitId == null) return null;
const u = Logic.unitById(this.state, this.selectedUnitId);
if (!u || u.civ !== this.state.humanIndex) return null;
return u;
}
selectUnit(unit) {
this.selectedUnitId = unit?.id ?? null;
this.view.selectedUnitId = this.selectedUnitId;
this.view.showPath(null);
if (unit) this.view.centerOnIfOffscreen?.(unit.x, unit.y);
this.view.refresh();
this.refreshUnitPanel();
// Nothing left to move this turn — nudge the player toward End Turn.
const noneLeft = !unit && this.phase === 'playing' && !this.busy
&& this.state?.current === this.state?.humanIndex;
this.setEndTurnFlash(noneLeft);
}
setEndTurnFlash(on) {
if (on === !!this.endTurnFlashTween) return;
if (!on) {
this.endTurnFlashTween?.stop();
this.endTurnFlashTween = null;
this.endTurnBtn?.setAlpha(1);
return;
}
this.endTurnFlashTween = this.tweens.add({
targets: this.endTurnBtn,
alpha: 0.55,
duration: 550,
yoyo: true,
repeat: -1,
ease: 'Sine.easeInOut',
});
}
selectNextUnit() {
const units = Logic.civUnits(this.state, this.state.humanIndex)
.filter((u) => u.mp > 0 && !u.fortified && !u.sentry && !u.order && !u.carriedBy
&& this.rules.units[u.type].domain !== 'project');
if (!units.length) { this.selectUnit(null); return; }
const curIdx = units.findIndex((u) => u.id === this.selectedUnitId);
const next = units[(curIdx + 1) % units.length];
this.selectUnit(next);
this.view.centerOn(next.x, next.y);
}
tryStep(unit, dx, dy, animate = false) {
if (this.state.current !== this.state.humanIndex) return;
const from = [unit.x, unit.y];
const out = unit.carriedBy
? Logic.disembark(this.rules, this.state, unit, dx, dy)
: Logic.tryMove(this.rules, this.state, unit, dx, dy);
if (out.result === 'blocked' && out.needsWar !== undefined) {
this.confirmWar(out.needsWar, () => {
Logic.declareWar(this.rules, this.state, this.state.humanIndex, out.needsWar);
this.tryStep(unit, dx, dy, animate);
});
return;
}
if (out.result === 'invalid') return;
if (out.hut) this.toastHut(out.hut);
const finish = () => {
this.afterAction();
if (unit.mp <= 0 && this.state.units.includes(unit)) this.selectNextUnit();
if (!this.state.units.includes(unit)) this.selectNextUnit();
};
const combatEvents = this.collectNewCombatEvents();
if (combatEvents.length) {
this.busy = true;
this.view.animateCombat(combatEvents, () => { this.busy = false; finish(); });
return;
}
const moved = unit.x !== from[0] || unit.y !== from[1];
if (!animate || !moved) { finish(); return; }
this.animateMoveThen([from, [unit.x, unit.y]], finish);
}
walkPath(unit, path) {
// Resolve the whole turn's worth of movement instantly (combat, huts,
// etc. all need the real logic), then replay the tiles actually crossed
// as a smooth glide so the player sees continuous motion, not a snap.
// A combat step always ends the walk — the rest of the original path
// no longer applies once a fight breaks out.
const visited = [[unit.x, unit.y]];
let i = 0;
let hutEvent = null;
while (i < path.length && unit.mp > 0 && this.state.units.includes(unit) && !this.state.over) {
const [nx, ny] = path[i];
i += 1;
const out = Logic.tryMove(this.rules, this.state, unit,
Math.sign(nx - unit.x), Math.sign(ny - unit.y));
if (out.result === 'invalid' || out.result === 'blocked' || out.result === 'combat') break;
if (out.hut) hutEvent = out.hut;
visited.push([unit.x, unit.y]);
}
if (hutEvent) this.toastHut(hutEvent);
const finish = () => {
this.view.showPath(null);
this.afterAction();
if (!this.state.units.includes(unit) || unit.mp <= 0) this.selectNextUnit();
};
const combatEvents = this.collectNewCombatEvents();
if (combatEvents.length) {
// Walk the peaceful leg of the path first, then play the clash.
this.animateMoveThen(visited, () => {
this.busy = true;
this.view.animateCombat(combatEvents, () => { this.busy = false; finish(); });
});
return;
}
this.animateMoveThen(visited, finish);
}
// Picks up any 'combat' events pushed since the last time this ran
// (marking them consumed so they never replay), for the caller to animate.
collectNewCombatEvents() {
const found = [];
for (const e of this.state.events) {
if (e.type === 'combat' && !e.animated) { e.animated = true; found.push(e); }
}
return found;
}
// Glides the selected unit's marker smoothly across `tiles`
// ([[c,r], ...], already-resolved positions) over 1s, pauses 250ms at the
// destination, then invokes `finish`. Falls straight through to `finish`
// when there's nothing to animate (unit didn't actually move).
animateMoveThen(tiles, finish) {
if (tiles.length < 2) { finish(); return; }
this.view.refresh();
this.busy = true;
this.view.animateUnitAlong(tiles, 1000, 250, () => {
this.busy = false;
finish();
});
}
tryFound(unit) {
const def = this.rules.units[unit.type];
if (!def.flags.includes('settler')) return;
if (!Logic.canFoundCity(this.rules, this.state, unit.x, unit.y)) {
this.toast('Cannot found a city here');
return;
}
if (this.modalOpen) return;
const defaultName = Logic.peekCityName(this.rules, this.state, unit.civ);
this.promptCityName(defaultName, (name) => {
const city = Logic.foundCity(this.rules, this.state, unit, name);
if (city) {
this.toast(`${city.name} founded!`);
this.view.repaintTileAndNeighbors(city.x, city.y);
this.afterAction();
this.selectNextUnit();
}
});
}
promptCityName(defaultName, onConfirm) {
this.modalOpen = true;
const cx = GAME_WIDTH / 2;
const cy = GAME_HEIGHT / 2;
const root = this.add.container(0, 0).setDepth(D.modal);
const dim = this.add.rectangle(cx, cy, GAME_WIDTH, GAME_HEIGHT, 0x000000, 0.55).setInteractive();
const panel = this.add.rectangle(cx, cy, 560, 240, COLORS.panel).setStrokeStyle(2, COLORS.accent);
const title = this.add.text(cx, cy - 84, 'Found City', {
fontFamily: 'Righteous', fontSize: '26px', color: COLORS.accentHex,
}).setOrigin(0.5);
const label = this.add.text(cx, cy - 40, 'Name this city:', {
fontFamily: FONT, fontSize: '18px', color: COLORS.textHex,
}).setOrigin(0.5);
root.add([dim, panel, title, label]);
const input = new TextInput(this, cx, cy + 4, {
width: 380, height: 48, value: defaultName, maxLength: 24, autocomplete: 'off',
});
input.focus();
input.el.select();
const close = () => { input.destroy(); root.destroy(true); this.modalOpen = false; };
const confirm = () => {
const name = input.value.trim() || defaultName;
close();
onConfirm(name);
};
input.on('keydown', (e) => {
if (e.key === 'Enter') confirm();
else if (e.key === 'Escape') close();
});
const found = new Button(this, cx - 110, cy + 68, 'FOUND', confirm, { width: 180, height: 52 });
const cancel = new Button(this, cx + 110, cy + 68, 'CANCEL', close,
{ width: 180, height: 52, variant: 'ghost' });
root.add([found, cancel]);
}
tryWork(unit, impId) {
if (Logic.startWork(this.rules, this.state, unit, impId)) {
this.toast(`${this.rules.units[unit.type].name}: building ${this.rules.improvements[impId].name}`);
this.afterAction();
this.selectNextUnit();
} else {
this.toast(`Cannot build ${this.rules.improvements[impId]?.name ?? impId} here`);
}
}
tryCaravan(unit) {
const pair = Logic.canEstablishRoute(this.rules, this.state, unit);
if (!pair) { this.toast('Caravans need a city 8+ tiles from home'); return; }
const out = Logic.establishTradeRoute(this.rules, this.state, unit);
if (out) {
this.toast(`Trade route: ${out.from.name} ↔ ${out.to.name} (+${out.bonus} gold & beakers)`);
this.afterAction();
this.selectNextUnit();
}
}
afterAction() {
// Repaint tiles that may have changed (work orders complete on turn start,
// but roads from engineers etc. show up next refresh — cheap full check
// is unnecessary; unit/city layer + HUD is enough here).
this.view.refresh();
this.refreshHud();
if (this.state.over) this.onGameOver();
}
// ---------------------------------------------------------------------------
// Turn cycle
startHumanTurn(process = true) {
const human = this.state.humanIndex;
if (process) Logic.beginCivTurn(this.rules, this.state, human);
this.repaintFromEvents();
this.busy = false;
this.endTurnBtn?.setAlpha(1);
const civ = this.state.civs[human];
if (!civ.alive) { this.onGameOver(); return; }
// Research prompt.
if (!civ.researching && Logic.availableTechs(this.rules, civ).length) {
this.openTech();
}
this.presentAIProposals();
this.announceEvents();
this.view.refresh();
this.refreshHud();
this.selectNextUnit();
}
onEndTurn() {
if (this.busy || this.modalOpen || this.phase !== 'playing') return;
if (this.state.current !== this.state.humanIndex) return;
Logic.endCivTurn(this.rules, this.state, this.state.humanIndex);
this.saveGame();
this.runToHumanTurn();
}
runToHumanTurn() {
this.setEndTurnFlash(false);
this.busy = true;
this.endTurnBtn?.setAlpha(0.4);
this.refreshUnitPanel();
const stepCiv = () => {
if (this.phase !== 'playing') return;
if (this.state.over) { this.onGameOver(); return; }
if (!this.state.civs[this.state.humanIndex].alive) { this.onGameOver(); return; }
const cur = this.state.current;
if (cur === this.state.humanIndex) {
this.startHumanTurn(true);
return;
}
Logic.beginCivTurn(this.rules, this.state, cur);
const before = new Map(Logic.civUnits(this.state, cur).map((u) => [u.id, [u.x, u.y]]));
runAITurn(this.rules, this.state, cur);
Logic.endCivTurn(this.rules, this.state, cur);
// Resolve the whole civ's turn instantly (as ever). Combats play first,
// from whatever's still on screen from before this civ acted (no
// refresh yet, so a ghost can stand in for a unit that's already dead
// or already moved); then one refresh syncs everyone else, and the
// remaining units' start/end tiles are diffed and glided — same
// "resolve now, animate after" trick as the player's own moves, just
// via a before/after snapshot instead of a waypoint path.
const combatEvents = this.collectNewCombatEvents();
const visibleCombat = combatEvents.filter((e) => this.view.isTileVisible(e.ax, e.ay)
|| this.view.isTileVisible(e.x, e.y));
const combatUnitIds = new Set(combatEvents.flatMap((e) => [e.attackerId, e.defenderId]));
const moves = [];
for (const [id, from] of before) {
if (combatUnitIds.has(id)) continue;
const u = Logic.unitById(this.state, id);
if (!u || u.carriedBy) continue;
if (u.x !== from[0] || u.y !== from[1]) moves.push({ unitId: id, from, to: [u.x, u.y] });
}
const afterCombat = () => {
this.view.refresh();
this.refreshHud();
this.view.animateUnitsAlong(moves, 1000, 250, () => {
this.time.delayedCall(90, stepCiv);
});
};
if (visibleCombat.length) this.view.animateCombat(visibleCombat, afterCombat);
else afterCombat();
};
stepCiv();
}
// ---------------------------------------------------------------------------
// Events, proposals, toasts
// Terrain changes (work orders, founded cities' roads) arrive as engine
// events; repaint just those tiles instead of rebaking the world.
repaintFromEvents() {
for (const e of this.state.events) {
if (e.painted) continue;
e.painted = true;
if (e.type === 'workDone') {
this.view.repaintTileAndNeighbors(e.x, e.y);
} else if (e.type === 'cityFounded' || e.type === 'cityDestroyed') {
const city = Logic.cityById(this.state, e.cityId);
if (city) this.view.repaintTileAndNeighbors(city.x, city.y);
}
}
}
announceEvents() {
const human = this.state.humanIndex;
for (const e of this.state.events) {
if (e.announced) continue;
e.announced = true;
if (e.type === 'war' && e.b === human) {
this.toast(`${this.state.civs[e.a].name} declares WAR on you!`);
} else if (e.type === 'techDone' && e.civ === human) {
this.toast(`Research complete: ${this.rules.techs[e.tech].name}`);
} else if (e.type === 'cityCaptured' && (e.from === human || e.to === human)) {
this.toast(e.to === human ? `You captured ${e.name}!` : `${e.name} has fallen!`);
} else if (e.type === 'civEliminated') {
this.toast(`${this.state.civs[e.civ].name} has been destroyed`);
} else if (e.type === 'spaceshipLaunched') {
this.toast(`${this.state.civs[e.civ].name} launched a spaceship!`);
} else if (e.type === 'contact' && (e.a === human || e.b === human)) {
const other = e.a === human ? e.b : e.a;
this.toast(`You have made contact with ${this.state.civs[other].name}`);
}
}
}
presentAIProposals() {
const human = this.state.humanIndex;
const proposals = this.state.events.filter((e) => e.type === 'aiProposal' && e.to === human);
this.state.events = this.state.events.filter((e) => !(e.type === 'aiProposal' && e.to === human));
const next = () => {
const p = proposals.shift();
if (!p) return;
if (!Logic.canPropose(this.state, p.from, human, p.kind)) { next(); return; }
const from = this.state.civs[p.from];
this.confirmDialog(
`${from.name} proposes a ${p.kind === 'ceasefire' ? 'cease-fire' : p.kind}. Accept?`,
() => { Logic.applyTreaty(this.state, p.from, human, p.kind); this.refreshHud(); next(); },
() => next(),
);
};
next();
}
toastHut(hut) {
const msgs = {
gold: `You found ${hut.gold} gold in the hut!`,
tech: hut.tech ? `The tribe teaches you ${this.rules.techs[hut.tech].name}!` : 'A gift!',
unit: `A band of ${hut.unit} joins you!`,
ambushWon: 'Hostile tribe! Your unit fought them off.',
ambushLost: 'Hostile tribe! Your unit was lost!',
};
this.toast(msgs[hut.outcome] ?? 'An empty hut.');
}
toast(msg) {
const y = 90 + this.toasts.length * 40;
const t = this.add.text(GAME_WIDTH / 2, y, msg, {
fontFamily: FONT, fontSize: '20px', color: COLORS.textHex,
backgroundColor: '#1e1a12ee', padding: { x: 16, y: 7 },
}).setOrigin(0.5).setDepth(D.toast);
this.toastRoot.add(t);
this.toasts.push(t);
this.tweens.add({
targets: t, alpha: 0, delay: 2600, duration: 500,
onComplete: () => {
this.toasts = this.toasts.filter((x) => x !== t);
t.destroy();
},
});
}
confirmWar(civIdx, onYes) {
const name = this.state.civs[civIdx].name;
this.confirmDialog(`Attack ${name}? This means WAR!`, onYes, () => {});
}
confirmDialog(message, onYes, onNo, yesLabel = 'YES', noLabel = 'NO') {
this.modalOpen = true;
const root = this.add.container(0, 0).setDepth(D.modal);
const dim = this.add.rectangle(GAME_WIDTH / 2, GAME_HEIGHT / 2, GAME_WIDTH, GAME_HEIGHT, 0x000000, 0.55)
.setInteractive();
const panel = this.add.rectangle(GAME_WIDTH / 2, GAME_HEIGHT / 2, 640, 220, COLORS.panel)
.setStrokeStyle(2, COLORS.accent);
const txt = this.add.text(GAME_WIDTH / 2, GAME_HEIGHT / 2 - 40, message, {
fontFamily: FONT, fontSize: '24px', color: COLORS.textHex,
wordWrap: { width: 580 }, align: 'center',
}).setOrigin(0.5);
const close = (fn) => () => { root.destroy(true); this.modalOpen = false; fn?.(); };
const yes = new Button(this, GAME_WIDTH / 2 - 110, GAME_HEIGHT / 2 + 50, yesLabel, close(onYes),
{ width: 180, height: 52 });
const no = new Button(this, GAME_WIDTH / 2 + 110, GAME_HEIGHT / 2 + 50, noLabel, close(onNo),
{ width: 180, height: 52, variant: 'ghost' });
root.add([dim, panel, txt, yes, no]);
}
// ---------------------------------------------------------------------------
// Screens
openTech() {
if (this.modalOpen) return;
this.modalOpen = true;
openTechScreen(this, this.rules, this.state, () => {
this.modalOpen = false;
this.refreshHud();
});
}
openDiplomacy() {
if (this.modalOpen) return;
this.modalOpen = true;
openDiplomacyScreen(this, this.rules, this.state, this.opponentsData, respondToProposal, () => {
this.modalOpen = false;
this.view.refresh();
this.refreshHud();
});
}
openSpaceship() {
if (this.modalOpen) return;
this.modalOpen = true;
openSpaceshipScreen(this, this.rules, this.state, () => {
this.modalOpen = false;
this.refreshHud();
if (this.state.over) this.onGameOver();
});
}
openMenu() {
if (this.modalOpen) return;
this.modalOpen = true;
const root = this.add.container(0, 0).setDepth(D.modal);
const dim = this.add.rectangle(GAME_WIDTH / 2, GAME_HEIGHT / 2, GAME_WIDTH, GAME_HEIGHT, 0x000000, 0.55)
.setInteractive();
const panel = this.add.rectangle(GAME_WIDTH / 2, GAME_HEIGHT / 2, 460, 340, COLORS.panel)
.setStrokeStyle(2, COLORS.accent);
const title = this.add.text(GAME_WIDTH / 2, GAME_HEIGHT / 2 - 120, 'MENU', {
fontFamily: 'Righteous', fontSize: '32px', color: COLORS.accentHex,
}).setOrigin(0.5);
const close = () => { root.destroy(true); this.modalOpen = false; };
const resume = new Button(this, GAME_WIDTH / 2, GAME_HEIGHT / 2 - 50, 'RESUME', close,
{ width: 320, height: 56 });
const save = new Button(this, GAME_WIDTH / 2, GAME_HEIGHT / 2 + 20, 'SAVE GAME', () => {
this.saveGame();
this.toast('Game saved');
close();
}, { width: 320, height: 56, variant: 'ghost' });
const quit = new Button(this, GAME_WIDTH / 2, GAME_HEIGHT / 2 + 90, 'SAVE & QUIT', () => {
this.saveGame();
this.scene.start('GameMenu');
}, { width: 320, height: 56, variant: 'ghost' });
root.add([dim, panel, title, resume, save, quit]);
}
onGameOver() {
if (this.phase === 'over') return;
this.phase = 'over';
this.busy = false;
this.clearSave();
showVictoryOverlay(this, this.rules, this.state, this.opponentsData, () => {
this.scene.restart({ game: this.gameDef });
});
}
}