empire-cli 0.1.0

package/dist/state/game-state-manager.js

@@ -0,0 +1,122 @@
+// Game state creation, serialization, save/load to ~/.empire-cli/saves/
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { DEFAULT_TERRITORIES, DEFAULT_FACTIONS } from '../data/default-world-map.js';
+const SAVES_DIR = join(homedir(), '.empire-cli', 'saves');
+function ensureSavesDir() {
+    if (!existsSync(SAVES_DIR)) {
+        mkdirSync(SAVES_DIR, { recursive: true });
+    }
+}
+/**
+ * Create a fresh game state with default map and factions.
+ */
+export function newGame(playerFactionId) {
+    const territories = new Map(DEFAULT_TERRITORIES.map((t) => [t.id, { ...t }]));
+    const factions = new Map(DEFAULT_FACTIONS.map((f) => [f.id, { ...f, territories: [...f.territories] }]));
+    // Build initial armies from territory data
+    const armies = new Map();
+    let armyCounter = 1;
+    for (const territory of territories.values()) {
+        if (territory.owner && territory.armies > 0) {
+            const armyId = `army_start_${armyCounter++}`;
+            armies.set(armyId, {
+                id: armyId,
+                factionId: territory.owner,
+                units: territory.armies,
+                morale: 80,
+                territoryId: territory.id,
+            });
+        }
+    }
+    return {
+        turn: 1,
+        territories,
+        factions,
+        armies,
+        playerFactionId,
+        gameLog: ['A new empire rises. Your destiny awaits.'],
+        isOver: false,
+        winner: null,
+    };
+}
+/**
+ * Serialize GameState to JSON-compatible SaveData.
+ */
+export function toSaveData(state) {
+    return {
+        turn: state.turn,
+        territories: Object.fromEntries(state.territories),
+        factions: Object.fromEntries(state.factions),
+        armies: Object.fromEntries(state.armies),
+        playerFactionId: state.playerFactionId,
+        gameLog: state.gameLog.slice(-50), // keep last 50 entries
+        isOver: state.isOver,
+        winner: state.winner,
+        savedAt: new Date().toISOString(),
+    };
+}
+/**
+ * Deserialize SaveData back into a live GameState.
+ */
+export function fromSaveData(data) {
+    return {
+        turn: data.turn,
+        territories: new Map(Object.entries(data.territories)),
+        factions: new Map(Object.entries(data.factions)),
+        armies: new Map(Object.entries(data.armies)),
+        playerFactionId: data.playerFactionId,
+        gameLog: data.gameLog,
+        isOver: data.isOver,
+        winner: data.winner,
+    };
+}
+/**
+ * Save game to ~/.empire-cli/saves/<slot>.json
+ */
+export function saveGame(state, slot = 'autosave') {
+    ensureSavesDir();
+    const filePath = join(SAVES_DIR, `${slot}.json`);
+    const data = toSaveData(state);
+    writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+}
+/**
+ * Load game from ~/.empire-cli/saves/<slot>.json
+ * Returns null if save not found.
+ */
+export function loadGame(slot = 'autosave') {
+    ensureSavesDir();
+    const filePath = join(SAVES_DIR, `${slot}.json`);
+    if (!existsSync(filePath))
+        return null;
+    try {
+        const raw = readFileSync(filePath, 'utf-8');
+        const data = JSON.parse(raw);
+        return fromSaveData(data);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * List available save slots.
+ */
+export function listSaves() {
+    ensureSavesDir();
+    return readdirSync(SAVES_DIR)
+        .filter((f) => f.endsWith('.json'))
+        .map((f) => f.replace('.json', ''));
+}
+/**
+ * Check win condition: a faction owns all territories.
+ */
+export function checkWinCondition(state) {
+    const totalTerritories = state.territories.size;
+    for (const faction of state.factions.values()) {
+        if (faction.territories.length >= totalTerritories) {
+            return faction.id;
+        }
+    }
+    return null;
+}

package/dist/ui/display-helpers.d.ts

@@ -0,0 +1,8 @@
+import type { GameState } from '../game-types.js';
+export declare const ICONS: Record<string, string>;
+export declare function printLine(msg?: string): void;
+export declare function printSeparator(): void;
+export declare function printStatus(state: GameState): void;
+export declare function printHelp(): void;
+export declare function printMap(state: GameState): void;
+export declare function printTerritoryInfo(state: GameState, territoryName: string): void;

package/dist/ui/display-helpers.js

@@ -0,0 +1,80 @@
+// UI display helpers: icons, status, map, help text
+import chalk from 'chalk';
+export const ICONS = {
+    city: '🏰', forest: '🌲', mountain: '⛰️ ', plains: '🌾',
+    gold: '💰', food: '🍖', wood: '🪵', stone: '🪨',
+    army: '⚔️ ', skull: '💀', crown: '👑', shield: '🛡️ ',
+    flag: '🚩', peace: '🕊️ ', fire: '🔥',
+};
+export function printLine(msg = '') {
+    console.log(msg);
+}
+export function printSeparator() {
+    console.log(chalk.gray('─'.repeat(60)));
+}
+export function printStatus(state) {
+    const player = state.factions.get(state.playerFactionId);
+    const colorFn = chalk[player.color] ?? chalk.white;
+    printSeparator();
+    printLine(colorFn(`  ${ICONS.crown} ${player.name}  —  Turn ${state.turn}`));
+    printLine(`  ${ICONS.gold} ${chalk.yellow(player.gold)}  ${ICONS.food} ${chalk.green(player.food)}  ${ICONS.wood} ${chalk.blue(player.wood)}  ${ICONS.stone} ${chalk.gray(player.stone)}`);
+    printLine(`  ${ICONS.army} Armies: ${player.totalArmies}  |  ${ICONS.flag} Territories: ${player.territories.length}/${state.territories.size}`);
+    printSeparator();
+}
+export function printHelp() {
+    printLine(chalk.cyan('\n  Commands:'));
+    printLine('  look                        — show world map');
+    printLine('  info <territory>            — show territory details');
+    printLine('  status                      — show your resources');
+    printLine('  move <from> <to> [n]        — move n units between territories (all if omitted)');
+    printLine('  recruit <territory> <n>     — recruit n units (3💰 + 2🍖 each)');
+    printLine('  attack <from> <to>          — attack enemy territory from yours');
+    printLine('  next                        — end turn (enemies act after this)');
+    printLine('  save [slot]                 — save game');
+    printLine('  quit                        — exit game');
+    printLine('  help                        — show this help');
+    printLine('');
+}
+export function printMap(state) {
+    const playerId = state.playerFactionId;
+    printLine(chalk.cyan('\n  World Map:'));
+    printLine('');
+    for (const t of state.territories.values()) {
+        const ownerFaction = t.owner ? state.factions.get(t.owner) : null;
+        const ownerName = ownerFaction?.name ?? chalk.gray('Unclaimed');
+        const colorFn = ownerFaction ? (chalk[ownerFaction.color] ?? chalk.white) : chalk.gray;
+        const icon = ICONS[t.type] ?? '?';
+        const armies = t.armies > 0 ? ` ${ICONS.army} ${t.armies}` : '';
+        const yours = t.owner === playerId ? chalk.green(' ★') : '';
+        printLine(`  ${icon} ${colorFn(t.name.padEnd(14))} ${colorFn(ownerName)}${armies}${yours}`);
+        const adjNames = t.adjacentTo.map((id) => state.territories.get(id)?.name ?? id).join(', ');
+        printLine(chalk.gray(`     ↔ ${adjNames}`));
+    }
+    printLine('');
+}
+// Show detailed info about a specific territory
+export function printTerritoryInfo(state, territoryName) {
+    const t = [...state.territories.values()].find((t) => t.name.toLowerCase().includes(territoryName.toLowerCase()));
+    if (!t) {
+        printLine(chalk.red(`Territory "${territoryName}" not found.`));
+        return;
+    }
+    const ownerFaction = t.owner ? state.factions.get(t.owner) : null;
+    const colorFn = ownerFaction ? (chalk[ownerFaction.color] ?? chalk.white) : chalk.gray;
+    const icon = ICONS[t.type] ?? '';
+    const playerId = state.playerFactionId;
+    printLine(`\n  ${icon} ${colorFn(t.name)} (${t.type})`);
+    printLine(`  Owner: ${ownerFaction?.name ?? 'Unclaimed'}`);
+    printLine(`  ${ICONS.army} Armies: ${t.armies}`);
+    printLine(`  Resources/turn: ${ICONS.gold}${t.resources.gold} ${ICONS.food}${t.resources.food} ${ICONS.wood}${t.resources.wood} ${ICONS.stone}${t.resources.stone}`);
+    printLine(`  Neighbors:`);
+    for (const adjId of t.adjacentTo) {
+        const adj = state.territories.get(adjId);
+        const adjOwner = adj.owner ? state.factions.get(adj.owner)?.name ?? '?' : 'Unclaimed';
+        const adjIcon = ICONS[adj.type] ?? '';
+        const threat = adj.owner !== playerId && adj.armies > 0 ? chalk.red(` ${ICONS.army}${adj.armies}`) : '';
+        const friendly = adj.owner === playerId ? chalk.green(` ★`) : '';
+        printLine(`    → ${adjIcon} ${adj.name} — ${adjOwner}${friendly}${threat}`);
+    }
+    printLine('');
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "empire-cli",
+  "version": "0.1.0",
+  "description": "CLI strategy RPG with AI game master",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "empire-cli": "dist/index.js",
+    "empire": "dist/index.js"
+  },
+  "scripts": {
+    "start": "tsx src/index.ts",
+    "build": "tsc",
+    "dev": "tsx src/index.ts"
+  },
+  "keywords": ["cli", "game", "rpg", "strategy", "ai"],
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "@google/generative-ai": "^0.24.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "tsx": "^4.7.0",
+    "@types/node": "^20.0.0"
+  }
+}

package/src/data/default-world-map.ts

@@ -0,0 +1,137 @@
+// Default world map data: 8 territories, 4 starting factions
+// Map layout:
+//   [Northkeep] --- [Iron Hills]
+//        |              |
+//   [Greenwood] --- [Crossroads] --- [Desert Gate]
+//        |              |
+//   [Silver Bay] --- [Stonehaven]
+//                       |
+//                  [Dragon Peak]
+
+import type { Territory, Faction } from '../game-types.js';
+
+export const DEFAULT_TERRITORIES: Territory[] = [
+  {
+    id: 'northkeep',
+    name: 'Northkeep',
+    type: 'city',
+    owner: 'iron_legion',
+    armies: 3,
+    resources: { gold: 4, food: 2, wood: 1, stone: 2 },
+    adjacentTo: ['iron_hills', 'greenwood'],
+  },
+  {
+    id: 'iron_hills',
+    name: 'Iron Hills',
+    type: 'mountain',
+    owner: 'iron_legion',
+    armies: 2,
+    resources: { gold: 2, food: 1, wood: 0, stone: 4 },
+    adjacentTo: ['northkeep', 'crossroads'],
+  },
+  {
+    id: 'greenwood',
+    name: 'Greenwood',
+    type: 'forest',
+    owner: 'green_pact',
+    armies: 2,
+    resources: { gold: 1, food: 3, wood: 4, stone: 0 },
+    adjacentTo: ['northkeep', 'crossroads', 'silver_bay'],
+  },
+  {
+    id: 'crossroads',
+    name: 'Crossroads',
+    type: 'plains',
+    owner: null,
+    armies: 0,
+    resources: { gold: 2, food: 2, wood: 1, stone: 1 },
+    adjacentTo: ['iron_hills', 'greenwood', 'desert_gate', 'stonehaven'],
+  },
+  {
+    id: 'desert_gate',
+    name: 'Desert Gate',
+    type: 'plains',
+    owner: 'sand_empire',
+    armies: 2,
+    resources: { gold: 3, food: 1, wood: 0, stone: 2 },
+    adjacentTo: ['crossroads'],
+  },
+  {
+    id: 'silver_bay',
+    name: 'Silver Bay',
+    type: 'city',
+    owner: 'green_pact',
+    armies: 3,
+    resources: { gold: 5, food: 2, wood: 1, stone: 1 },
+    adjacentTo: ['greenwood', 'stonehaven'],
+  },
+  {
+    id: 'stonehaven',
+    name: 'Stonehaven',
+    type: 'mountain',
+    owner: 'sand_empire',
+    armies: 2,
+    resources: { gold: 2, food: 1, wood: 0, stone: 5 },
+    adjacentTo: ['crossroads', 'silver_bay', 'dragon_peak'],
+  },
+  {
+    id: 'dragon_peak',
+    name: 'Dragon Peak',
+    type: 'mountain',
+    owner: 'void_covenant',
+    armies: 4,
+    resources: { gold: 1, food: 0, wood: 0, stone: 6 },
+    adjacentTo: ['stonehaven'],
+  },
+];
+
+export const DEFAULT_FACTIONS: Faction[] = [
+  {
+    id: 'iron_legion',
+    name: 'Iron Legion',
+    personality: 'aggressive',
+    color: 'red',
+    territories: ['northkeep', 'iron_hills'],
+    gold: 20,
+    food: 10,
+    wood: 5,
+    stone: 15,
+    totalArmies: 5,
+  },
+  {
+    id: 'green_pact',
+    name: 'Green Pact',
+    personality: 'defensive',
+    color: 'green',
+    territories: ['greenwood', 'silver_bay'],
+    gold: 15,
+    food: 20,
+    wood: 25,
+    stone: 5,
+    totalArmies: 5,
+  },
+  {
+    id: 'sand_empire',
+    name: 'Sand Empire',
+    personality: 'mercantile',
+    color: 'yellow',
+    territories: ['desert_gate', 'stonehaven'],
+    gold: 30,
+    food: 8,
+    wood: 2,
+    stone: 10,
+    totalArmies: 4,
+  },
+  {
+    id: 'void_covenant',
+    name: 'Void Covenant',
+    personality: 'diplomatic',
+    color: 'magenta',
+    territories: ['dragon_peak'],
+    gold: 10,
+    food: 5,
+    wood: 2,
+    stone: 20,
+    totalArmies: 4,
+  },
+];

package/src/engine/ai-turn-processor.ts

@@ -0,0 +1,76 @@
+// AI faction turn processing — simple decision-making for enemy factions
+import type { GameState } from '../game-types.js';
+import { resolveCombat } from './combat-resolver.js';
+import { findArmyInTerritory, getUnitsInTerritory, applyCasualties } from './army-manager.js';
+
+export function runAiTurns(state: GameState): string[] {
+  const log: string[] = [];
+  for (const faction of state.factions.values()) {
+    if (faction.id === state.playerFactionId) continue;
+    if (faction.territories.length === 0) continue;
+
+    // Simple AI: recruit if has resources, then try to expand
+    // Recruit in first territory if affordable
+    if (faction.gold >= 6 && faction.food >= 4) {
+      const recruitTerrId = faction.territories[0];
+      const recruitTerr = state.territories.get(recruitTerrId);
+      if (recruitTerr) {
+        const units = Math.min(Math.floor(faction.gold / 3), Math.floor(faction.food / 2), 3);
+        if (units > 0) {
+          faction.gold -= units * 3;
+          faction.food -= units * 2;
+          faction.totalArmies += units;
+          recruitTerr.armies += units;
+          // Create/merge army record
+          const existing = findArmyInTerritory(faction.id, recruitTerrId, state.armies);
+          if (existing) { existing.units += units; }
+          else {
+            const id = `ai_army_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+            state.armies.set(id, { id, factionId: faction.id, units, morale: 80, territoryId: recruitTerrId });
+          }
+          log.push(`${faction.name} recruited ${units} units in ${recruitTerr.name}`);
+        }
+      }
+    }
+
+    // Try to attack one adjacent weak territory
+    for (const territoryId of [...faction.territories]) {
+      const territory = state.territories.get(territoryId)!;
+      for (const adjId of territory.adjacentTo) {
+        const adj = state.territories.get(adjId)!;
+        if (adj.owner === faction.id) continue;
+
+        const attackerUnits = getUnitsInTerritory(faction.id, territoryId, state.armies);
+        const defenderUnits = adj.armies;
+
+        if (attackerUnits < 2) continue;
+        if (attackerUnits < defenderUnits && faction.personality !== 'aggressive') continue;
+
+        const result = resolveCombat(attackerUnits, 80, defenderUnits, 80, adj.type);
+        log.push(`${faction.name} attacks ${adj.name} from ${territory.name}!`);
+
+        const attackerArmy = findArmyInTerritory(faction.id, territoryId, state.armies);
+        if (attackerArmy) applyCasualties(attackerArmy, result.attackerCasualties, faction, state.armies, territory);
+
+        if (result.captured) {
+          const oldOwner = adj.owner ? state.factions.get(adj.owner) : null;
+          if (oldOwner) {
+            oldOwner.territories = oldOwner.territories.filter((id) => id !== adjId);
+            const defArmy = findArmyInTerritory(adj.owner!, adjId, state.armies);
+            if (defArmy) applyCasualties(defArmy, result.defenderCasualties, oldOwner, state.armies, adj);
+          }
+          adj.owner = faction.id;
+          adj.armies = attackerArmy?.units ?? 0;
+          faction.territories.push(adjId);
+          log.push(`  → ${faction.name} captured ${adj.name}! ${ICONS_FIRE}`);
+        } else {
+          log.push(`  → Attack on ${adj.name} failed`);
+        }
+        return log; // one attack per faction per turn
+      }
+    }
+  }
+  return log;
+}
+
+const ICONS_FIRE = '🔥';

package/src/engine/army-manager.ts

@@ -0,0 +1,156 @@
+// Army recruitment, movement, and validation logic
+
+import type { Army, Faction, Territory, GameState } from '../game-types.js';
+import { canAfford, deductResources } from './resource-calculator.js';
+
+const RECRUIT_COST_PER_UNIT = { gold: 3, food: 2, wood: 0, stone: 0 };
+const DEFAULT_MORALE = 80;
+
+let armyIdCounter = 1;
+
+function generateArmyId(): string {
+  return `army_${Date.now()}_${armyIdCounter++}`;
+}
+
+/**
+ * Recruit new army units in a territory owned by the faction.
+ * Returns error message or null on success.
+ */
+export function recruitArmy(
+  faction: Faction,
+  territory: Territory,
+  units: number,
+  armies: Map<string, Army>
+): string | null {
+  if (territory.owner !== faction.id) {
+    return `${territory.name} is not owned by ${faction.name}.`;
+  }
+  if (units < 1) {
+    return 'Must recruit at least 1 unit.';
+  }
+
+  const totalCost = {
+    gold: RECRUIT_COST_PER_UNIT.gold * units,
+    food: RECRUIT_COST_PER_UNIT.food * units,
+  };
+
+  if (!canAfford(faction, totalCost)) {
+    return `Not enough resources. Need ${totalCost.gold} gold and ${totalCost.food} food.`;
+  }
+
+  deductResources(faction, totalCost);
+  faction.totalArmies += units;
+  territory.armies += units;
+
+  // Create or merge army in territory
+  const existingArmy = findArmyInTerritory(faction.id, territory.id, armies);
+  if (existingArmy) {
+    existingArmy.units += units;
+  } else {
+    const newArmy: Army = {
+      id: generateArmyId(),
+      factionId: faction.id,
+      units,
+      morale: DEFAULT_MORALE,
+      territoryId: territory.id,
+    };
+    armies.set(newArmy.id, newArmy);
+  }
+
+  return null;
+}
+
+/**
+ * Move an army from one territory to an adjacent territory.
+ * Returns error message or null on success.
+ */
+export function moveArmy(
+  army: Army,
+  fromTerritory: Territory,
+  toTerritory: Territory
+): string | null {
+  if (army.territoryId !== fromTerritory.id) {
+    return 'Army is not in the specified territory.';
+  }
+  if (!fromTerritory.adjacentTo.includes(toTerritory.id)) {
+    return `${toTerritory.name} is not adjacent to ${fromTerritory.name}.`;
+  }
+
+  // Move the army
+  fromTerritory.armies -= army.units;
+  toTerritory.armies += army.units;
+  army.territoryId = toTerritory.id;
+
+  return null;
+}
+
+/**
+ * Find any army belonging to a faction in a specific territory.
+ */
+export function findArmyInTerritory(
+  factionId: string,
+  territoryId: string,
+  armies: Map<string, Army>
+): Army | undefined {
+  for (const army of armies.values()) {
+    if (army.factionId === factionId && army.territoryId === territoryId) {
+      return army;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Get total units a faction has in a given territory.
+ */
+export function getUnitsInTerritory(
+  factionId: string,
+  territoryId: string,
+  armies: Map<string, Army>
+): number {
+  let total = 0;
+  for (const army of armies.values()) {
+    if (army.factionId === factionId && army.territoryId === territoryId) {
+      total += army.units;
+    }
+  }
+  return total;
+}
+
+/**
+ * Remove casualties from army after combat. Destroys army if no units remain.
+ */
+export function applyCasualties(
+  army: Army,
+  casualties: number,
+  faction: Faction,
+  armies: Map<string, Army>,
+  territory: Territory
+): void {
+  const actual = Math.min(casualties, army.units);
+  army.units -= actual;
+  faction.totalArmies -= actual;
+  territory.armies -= actual;
+
+  if (army.units <= 0) {
+    armies.delete(army.id);
+  }
+}
+
+/**
+ * Ensure an Army record exists for a faction in a territory.
+ * Fixes desync where territory.armies > 0 but no Army object exists.
+ */
+export function ensureArmyRecord(
+  factionId: string,
+  territory: Territory,
+  armies: Map<string, Army>
+): void {
+  if (territory.armies > 0 && territory.owner === factionId) {
+    const existing = findArmyInTerritory(factionId, territory.id, armies);
+    if (!existing) {
+      const id = `army_fix_${Date.now()}`;
+      armies.set(id, { id, factionId, units: territory.armies, morale: 80, territoryId: territory.id });
+    }
+  }
+}