Spaces:
Running
Running
| import { MAPS, BUILDINGS, TERRAIN, RESOURCES } from './data.js'; | |
| export const MAX_ACTIONS = 3; | |
| const SAVE_KEY = 'empire-web-save-v1'; | |
| const DEFAULT_MORALE = 80; | |
| const TERRAIN_BONUS = { plains: 1.0, forest: 1.2, mountain: 1.5, city: 1.3 }; | |
| const ACCEPT_RATES = { | |
| aggressive: [0.15, 0.20, 0.40], | |
| defensive: [0.50, 0.70, 0.50], | |
| mercantile: [0.40, 0.50, 0.80], | |
| diplomatic: [0.80, 0.85, 0.70], | |
| }; | |
| const TRADE_MARKUP = { aggressive: 1.5, defensive: 1.2, mercantile: 0.8, diplomatic: 1.0 }; | |
| const clone = (x) => JSON.parse(JSON.stringify(x)); | |
| const clamp0 = (n) => Math.max(0, n); | |
| export class Game { | |
| constructor() { | |
| this.state = null; | |
| this._handlers = new Set(); | |
| this._id = 0; | |
| } | |
| on(fn) { this._handlers.add(fn); return () => this._handlers.delete(fn); } | |
| emit(type = 'change', payload = null) { | |
| for (const fn of this._handlers) fn(this.state, type, payload); | |
| } | |
| commit(type = 'change', payload = null) { | |
| this.save(); | |
| this.emit(type, payload); | |
| } | |
| uid(prefix) { return `${prefix}_${Date.now().toString(36)}_${this._id++}`; } | |
| newGame({ mapId, factionId, identity }) { | |
| const map = MAPS[mapId] || MAPS.mainland; | |
| const territories = {}; | |
| for (const t of map.territories) { | |
| territories[t.id] = { ...clone(t), buildings: [] }; | |
| } | |
| const factions = {}; | |
| for (const f of map.factions) { | |
| const tpl = clone(f); | |
| factions[f.id] = { | |
| ...tpl, | |
| territories: tpl.territories.filter((id) => territories[id]), | |
| }; | |
| } | |
| for (const f of Object.values(factions)) { | |
| f.totalArmies = f.territories.reduce((s, id) => s + territories[id].armies, 0); | |
| } | |
| const faction = factions[factionId] || map.factions[0]; | |
| const ident = { | |
| leaderName: (identity?.leaderName || '').trim() || '君主', | |
| nationName: (identity?.nationName || '').trim() || faction.name, | |
| slogan: (identity?.slogan || '').trim() || '榮耀就在前方！', | |
| }; | |
| this.state = { | |
| version: 1, | |
| turn: 1, | |
| mapId: map.id, | |
| actionsLeft: MAX_ACTIONS, | |
| playerFactionId: faction.id, | |
| identity: ident, | |
| territories, | |
| factions, | |
| diplomacy: [], | |
| log: [], | |
| isOver: false, | |
| winner: null, | |
| stats: { battlesWon: 0, battlesLost: 0, recruited: 0, captured: 0 }, | |
| startedAt: Date.now(), | |
| }; | |
| this.addLog(`${ident.leaderName} 登基，成為 ${ident.nationName} 的君主。格言：「${ident.slogan}」`, 'story'); | |
| this.commit('new', { mapId: map.id, factionId: faction.id }); | |
| return this.state; | |
| } | |
| loadFromStorage() { | |
| try { | |
| const raw = localStorage.getItem(SAVE_KEY); | |
| if (!raw) return null; | |
| const data = JSON.parse(raw); | |
| if (!data || !data.territories || !data.factions) return null; | |
| for (const t of Object.values(data.territories)) { | |
| if (!Array.isArray(t.buildings)) t.buildings = []; | |
| if (!t.resources) t.resources = { gold: 0, food: 0, wood: 0, stone: 0 }; | |
| } | |
| for (const f of Object.values(data.factions)) { | |
| f.territories = (f.territories || []).filter((id) => data.territories[id]); | |
| f.totalArmies = f.territories.reduce((s, id) => s + data.territories[id].armies, 0); | |
| } | |
| if (!Array.isArray(data.log)) data.log = []; | |
| if (!Array.isArray(data.diplomacy)) data.diplomacy = []; | |
| if (!data.stats) data.stats = { battlesWon: 0, battlesLost: 0, recruited: 0, captured: 0 }; | |
| if (typeof data.actionsLeft !== 'number') data.actionsLeft = MAX_ACTIONS; | |
| this.state = data; | |
| this.emit('load'); | |
| return data; | |
| } catch { return null; } | |
| } | |
| hasSave() { | |
| try { return !!localStorage.getItem(SAVE_KEY); } catch { return false; } | |
| } | |
| save() { | |
| if (!this.state) return; | |
| try { localStorage.setItem(SAVE_KEY, JSON.stringify(this.state)); } catch {} | |
| } | |
| clearSave() { | |
| try { localStorage.removeItem(SAVE_KEY); } catch {} | |
| } | |
| get map() { return MAPS[this.state.mapId]; } | |
| get player() { return this.state.factions[this.state.playerFactionId]; } | |
| faction(id) { return this.state.factions[id] || null; } | |
| territory(id) { return this.state.territories[id] || null; } | |
| isPlayer(id) { return id === this.state.playerFactionId; } | |
| ownerName(id) { return id ? (this.faction(id)?.name || '未知') : '無主之地'; } | |
| ownedByPlayer(id) { return this.territory(id)?.owner === this.state.playerFactionId; } | |
| addLog(text, kind = 'info') { | |
| this.state.log.push({ turn: this.state.turn, text, kind }); | |
| if (this.state.log.length > 200) this.state.log = this.state.log.slice(-200); | |
| } | |
| syncArmies(fid) { | |
| const f = this.faction(fid); | |
| if (!f) return; | |
| f.totalArmies = this.factionTerritories(fid).reduce((sum, t) => sum + t.armies, 0); | |
| } | |
| playerTerritories() { | |
| return this.player.territories.map((id) => this.territory(id)).filter(Boolean); | |
| } | |
| factionTerritories(fid) { | |
| const f = this.faction(fid); | |
| return f ? f.territories.map((id) => this.territory(id)).filter(Boolean) : []; | |
| } | |
| income(fid = this.state.playerFactionId) { | |
| const out = { gold: 0, food: 0, wood: 0, stone: 0 }; | |
| for (const t of this.factionTerritories(fid)) { | |
| out.gold += t.resources.gold + (t.buildings.includes('market') ? 2 : 0); | |
| out.food += t.resources.food; | |
| out.wood += t.resources.wood; | |
| out.stone += t.resources.stone; | |
| } | |
| return out; | |
| } | |
| upkeep(fid = this.state.playerFactionId) { | |
| const units = this.factionTerritories(fid).reduce((s, t) => s + t.armies, 0); | |
| return { gold: 0, food: units, wood: 0, stone: 0 }; | |
| } | |
| recruitCost(tid) { | |
| const t = this.territory(tid); | |
| const gold = t?.buildings.includes('barracks') ? 2 : 3; | |
| return { gold, food: 2 }; | |
| } | |
| maxRecruit(tid) { | |
| const t = this.territory(tid); | |
| if (!t) return 0; | |
| const cost = this.recruitCost(tid); | |
| return Math.max(0, Math.min( | |
| Math.floor(this.player.gold / cost.gold), | |
| Math.floor(this.player.food / cost.food), | |
| )); | |
| } | |
| canAfford(cost) { | |
| return (this.player.gold >= (cost.gold || 0)) | |
| && (this.player.food >= (cost.food || 0)) | |
| && (this.player.wood >= (cost.wood || 0)) | |
| && (this.player.stone >= (cost.stone || 0)); | |
| } | |
| spend(cost) { | |
| for (const k of ['gold', 'food', 'wood', 'stone']) { | |
| if (cost[k]) this.player[k] = clamp0(this.player[k] - cost[k]); | |
| } | |
| } | |
| spendAction() { | |
| this.state.actionsLeft = Math.max(0, this.state.actionsLeft - 1); | |
| } | |
| get outOfActions() { return this.state.actionsLeft <= 0; } | |
| // ── Player orders ────────────────────────────────────────────────────────── | |
| recruit(tid, n) { | |
| const t = this.territory(tid); | |
| if (!t) return { ok: false, msg: '找不到該疆域。' }; | |
| if (t.owner !== this.state.playerFactionId) return { ok: false, msg: `你並不擁有 ${t.name}。` }; | |
| if (this.outOfActions) return { ok: false, msg: '本回合已無行動，請結束回合。' }; | |
| n = Math.floor(n); | |
| if (!n || n < 1) return { ok: false, msg: '至少徵募 1 名士兵。' }; | |
| const cost = this.recruitCost(tid); | |
| if (!this.canAfford({ gold: cost.gold * n, food: cost.food * n })) { | |
| return { ok: false, msg: `資源不足：需要 ${cost.gold * n} 金幣與 ${cost.food * n} 糧食。` }; | |
| } | |
| this.spend({ gold: cost.gold * n, food: cost.food * n }); | |
| t.armies += n; | |
| this.player.totalArmies += n; | |
| this.state.stats.recruited += n; | |
| this.spendAction(); | |
| this.addLog(`在 ${t.name} 徵募了 ${n} 名士兵。`, 'player'); | |
| this.commit('recruit', { tid, n }); | |
| return { ok: true, n, tid, cost, left: this.state.actionsLeft }; | |
| } | |
| move(fromId, toId, n) { | |
| const from = this.territory(fromId); | |
| const to = this.territory(toId); | |
| if (!from || !to) return { ok: false, msg: '找不到該疆域。' }; | |
| if (from.owner !== this.state.playerFactionId) return { ok: false, msg: `你並不擁有 ${from.name}。` }; | |
| if (to.owner !== this.state.playerFactionId) return { ok: false, msg: `你並未控制 ${to.name}。` }; | |
| if (!from.adjacentTo.includes(toId)) return { ok: false, msg: `${to.name} 與 ${from.name} 並不相鄰。` }; | |
| if (this.outOfActions) return { ok: false, msg: '本回合已無行動，請結束回合。' }; | |
| const movable = from.armies - 2; | |
| if (movable <= 0) return { ok: false, msg: `${from.name} 至少需留守 2 名士兵。` }; | |
| n = n == null ? movable : Math.floor(n); | |
| n = Math.min(n, movable); | |
| if (n < 1) return { ok: false, msg: '沒有可調動的士兵。' }; | |
| from.armies -= n; | |
| to.armies += n; | |
| this.spendAction(); | |
| this.addLog(`從 ${from.name} 調動 ${n} 名士兵前往 ${to.name}。`, 'player'); | |
| this.commit('move', { fromId, toId, n }); | |
| return { ok: true, n, fromId, toId, left: this.state.actionsLeft }; | |
| } | |
| resolveCombat(attackerUnits, defenderUnits, terrain, defenderTerritory) { | |
| const terrainBonus = TERRAIN_BONUS[terrain] ?? 1; | |
| const wallBonus = defenderTerritory?.buildings.includes('walls') ? 0.3 : 0; | |
| const totalDefBonus = terrainBonus + wallBonus; | |
| const attackPower = attackerUnits * (DEFAULT_MORALE / 100); | |
| const defensePower = defenderUnits * (DEFAULT_MORALE / 100) * totalDefBonus; | |
| const ratio = attackPower / (defensePower || 1); | |
| const log = []; | |
| log.push(`進攻戰力 ${attackPower.toFixed(1)}，防守戰力 ${defensePower.toFixed(1)}。`); | |
| log.push(`${TERRAIN[terrain]?.label || terrain}地形提供 ×${terrainBonus} 防禦。`); | |
| if (wallBonus > 0) log.push(`城牆額外提供 +${wallBonus} 防禦。`); | |
| let outcome; let attackerCasualties; let defenderCasualties; let captured = false; | |
| if (defenderUnits <= 0) { | |
| outcome = 'uncontested'; | |
| attackerCasualties = 0; | |
| defenderCasualties = 0; | |
| captured = true; | |
| log.push('前方沒有守軍阻擋。'); | |
| } else if (ratio >= 2.0) { | |
| outcome = 'decisive_victory'; | |
| attackerCasualties = Math.floor(attackerUnits * 0.1); | |
| defenderCasualties = defenderUnits; | |
| captured = true; | |
| log.push('壓倒性勝利！守軍全面潰散。'); | |
| } else if (ratio >= 1.2) { | |
| outcome = 'victory'; | |
| attackerCasualties = Math.floor(attackerUnits * 0.25); | |
| defenderCasualties = Math.floor(defenderUnits * 0.6); | |
| captured = true; | |
| log.push('勝利！疆域已落入你手。'); | |
| } else if (ratio >= 0.8) { | |
| outcome = 'pyrrhic_victory'; | |
| attackerCasualties = Math.floor(attackerUnits * 0.5); | |
| defenderCasualties = Math.floor(defenderUnits * 0.4); | |
| captured = ratio >= 1.0; | |
| log.push(captured ? '慘勝——戰場屬於你，但代價沉重。' : '血戰僵持，進攻方被迫撤退。'); | |
| } else { | |
| outcome = 'defeat'; | |
| attackerCasualties = Math.floor(attackerUnits * 0.6); | |
| defenderCasualties = Math.floor(defenderUnits * 0.15); | |
| captured = false; | |
| log.push('戰敗！攻勢在守軍面前崩潰。'); | |
| } | |
| log.push(`我軍傷亡 ${attackerCasualties}，敵軍傷亡 ${defenderCasualties}。`); | |
| return { outcome, attackerCasualties, defenderCasualties, captured, ratio, log }; | |
| } | |
| attack(fromId, toId, n) { | |
| const from = this.territory(fromId); | |
| const to = this.territory(toId); | |
| if (!from || !to) return { ok: false, msg: '找不到該疆域。' }; | |
| if (from.owner !== this.state.playerFactionId) return { ok: false, msg: `你並不擁有 ${from.name}。` }; | |
| if (to.owner === this.state.playerFactionId) return { ok: false, msg: `你已掌握 ${to.name}。` }; | |
| if (!from.adjacentTo.includes(toId)) return { ok: false, msg: `${to.name} 與 ${from.name} 並不相鄰。` }; | |
| if (this.outOfActions) return { ok: false, msg: '本回合已無行動，請結束回合。' }; | |
| if (from.armies < 1) return { ok: false, msg: `${from.name} 已無駐軍。` }; | |
| n = n == null ? from.armies : Math.floor(n); | |
| n = Math.min(Math.max(1, n), from.armies); | |
| if (n < 1) return { ok: false, msg: '至少派出 1 名士兵。' }; | |
| const defenderFactionId = to.owner; | |
| const defenderName = this.ownerName(defenderFactionId); | |
| const preDef = to.armies; | |
| const result = this.resolveCombat(n, preDef, to.type, to); | |
| const sent = n; | |
| const survivors = Math.max(0, sent - result.attackerCasualties); | |
| from.armies = Math.max(0, from.armies - sent); | |
| this.player.totalArmies = Math.max(0, this.player.totalArmies - result.attackerCasualties); | |
| let eliminated = null; | |
| if (result.captured) { | |
| if (defenderFactionId) { | |
| const old = this.faction(defenderFactionId); | |
| if (old) { | |
| to.armies = Math.max(0, to.armies - result.defenderCasualties); | |
| old.territories = old.territories.filter((id) => id !== toId); | |
| old.totalArmies = Math.max(0, old.totalArmies - result.defenderCasualties); | |
| if (old.territories.length === 0) { | |
| eliminated = old; | |
| this.addLog(`${old.name} 已從地圖上滅亡。`, 'critical'); | |
| } | |
| } | |
| } | |
| to.owner = this.state.playerFactionId; | |
| to.armies = survivors; | |
| this.player.territories.push(toId); | |
| this.state.stats.battlesWon += 1; | |
| this.state.stats.captured += 1; | |
| this.addLog(`你從 ${defenderName} 手中奪下 ${to.name}，${survivors} 名士兵倖存。`, 'victory'); | |
| } else { | |
| to.armies = Math.max(0, to.armies - result.defenderCasualties); | |
| if (defenderFactionId) { | |
| const old = this.faction(defenderFactionId); | |
| if (old) old.totalArmies = Math.max(0, old.totalArmies - result.defenderCasualties); | |
| } | |
| this.state.stats.battlesLost += 1; | |
| this.addLog(`對 ${to.name} 的攻勢失敗，損失 ${result.attackerCasualties} 名士兵。`, 'defeat'); | |
| } | |
| this.spendAction(); | |
| this.syncArmies(this.state.playerFactionId); | |
| const payload = { | |
| fromId, toId, sent, defenderUnits: preDef, defenderName, | |
| result, survivors, eliminated, | |
| }; | |
| const win = this.checkWinner(); | |
| if (win) this.finish(win); | |
| this.commit('battle', payload); | |
| return { ok: true, ...payload, win, left: this.state.actionsLeft }; | |
| } | |
| build(tid, type) { | |
| const t = this.territory(tid); | |
| const def = BUILDINGS[type]; | |
| if (!t || !def) return { ok: false, msg: '未知的建築。' }; | |
| if (t.owner !== this.state.playerFactionId) return { ok: false, msg: `你並不擁有 ${t.name}。` }; | |
| if (this.outOfActions) return { ok: false, msg: '本回合已無行動，請結束回合。' }; | |
| if (t.buildings.includes(type)) return { ok: false, msg: `${t.name} 已建有${def.label}。` }; | |
| if (!this.canAfford(def.cost)) { | |
| const need = Object.entries(def.cost).map(([k, v]) => `${v} ${RESOURCES[k].label}`).join('、'); | |
| return { ok: false, msg: `資源不足：需要 ${need}。` }; | |
| } | |
| this.spend(def.cost); | |
| t.buildings.push(type); | |
| this.spendAction(); | |
| this.addLog(`在 ${t.name} 建成${def.label}。`, 'player'); | |
| this.commit('build', { tid, type }); | |
| return { ok: true, tid, type, left: this.state.actionsLeft }; | |
| } | |
| // ── Diplomacy ───────────────────────────────────────────────────────────── | |
| relation(a, b) { | |
| const [fa, fb] = a < b ? [a, b] : [b, a]; | |
| return this.state.diplomacy.find((r) => r.factionA === fa && r.factionB === fb) || null; | |
| } | |
| relationStatus(a, b) { return this.relation(a, b)?.status || 'neutral'; } | |
| setRelation(a, b, status, turns, initiatedBy) { | |
| const [fa, fb] = a < b ? [a, b] : [b, a]; | |
| const idx = this.state.diplomacy.findIndex((r) => r.factionA === fa && r.factionB === fb); | |
| const rel = { factionA: fa, factionB: fb, status, turnsRemaining: turns, initiatedBy }; | |
| if (idx >= 0) this.state.diplomacy[idx] = rel; else this.state.diplomacy.push(rel); | |
| } | |
| otherFaction(fid) { | |
| const f = this.faction(fid); | |
| if (!f || f.id === this.state.playerFactionId) return null; | |
| return f; | |
| } | |
| proposeAlliance(fid) { | |
| const f = this.otherFaction(fid); | |
| if (!f) return { ok: false, msg: '無效的勢力。' }; | |
| if (this.outOfActions) return { ok: false, msg: '本回合已無行動，請結束回合。' }; | |
| const status = this.relationStatus(this.state.playerFactionId, fid); | |
| if (status === 'allied') return { ok: false, msg: '你們已是同盟。' }; | |
| let chance = (ACCEPT_RATES[f.personality] || [0.5])[0]; | |
| if (f.territories.length <= 1) chance += 0.3; | |
| this.spendAction(); | |
| if (Math.random() < chance) { | |
| this.setRelation(this.state.playerFactionId, fid, 'allied', -1, this.state.playerFactionId); | |
| this.addLog(`${f.name} 接受你的同盟提案。`, 'diplomacy'); | |
| this.commit('diplomacy'); | |
| return { ok: true, accepted: true, msg: `${f.name} 接受你的同盟提案。` }; | |
| } | |
| this.addLog(`${f.name} 拒絕你的同盟提案。`, 'diplomacy'); | |
| this.commit('diplomacy'); | |
| return { ok: true, accepted: false, msg: `${f.name} 拒絕了你的提案。` }; | |
| } | |
| proposePeace(fid) { | |
| const f = this.otherFaction(fid); | |
| if (!f) return { ok: false, msg: '無效的勢力。' }; | |
| if (this.outOfActions) return { ok: false, msg: '本回合已無行動，請結束回合。' }; | |
| const status = this.relationStatus(this.state.playerFactionId, fid); | |
| if (status === 'peace') return { ok: false, msg: '你們已處於停戰狀態。' }; | |
| if (status === 'allied') return { ok: false, msg: '同盟關係已約束雙方。' }; | |
| let chance = (ACCEPT_RATES[f.personality] || [0.5, 0.5])[1]; | |
| if (f.territories.length <= 1) chance += 0.3; | |
| const turns = 3 + Math.floor(Math.random() * 3); | |
| this.spendAction(); | |
| if (Math.random() < chance) { | |
| this.setRelation(this.state.playerFactionId, fid, 'peace', turns, this.state.playerFactionId); | |
| this.addLog(`與 ${f.name} 達成 ${turns} 回合停戰。`, 'diplomacy'); | |
| this.commit('diplomacy'); | |
| return { ok: true, accepted: true, turns, msg: `${f.name} 同意停戰 ${turns} 回合。` }; | |
| } | |
| this.addLog(`${f.name} 拒絕停戰。`, 'diplomacy'); | |
| this.commit('diplomacy'); | |
| return { ok: true, accepted: false, msg: `${f.name} 拒絕停戰。` }; | |
| } | |
| proposeTrade(fid, giveRes, giveAmount, getRes) { | |
| const f = this.otherFaction(fid); | |
| if (!f) return { ok: false, msg: '無效的勢力。' }; | |
| if (this.outOfActions) return { ok: false, msg: '本回合已無行動，請結束回合。' }; | |
| if (!['gold', 'food', 'wood', 'stone'].includes(giveRes) || !['gold', 'food', 'wood', 'stone'].includes(getRes)) { | |
| return { ok: false, msg: '無效的資源。' }; | |
| } | |
| if (giveRes === getRes) return { ok: false, msg: '請選擇兩種不同的資源。' }; | |
| giveAmount = Math.floor(giveAmount); | |
| if (!giveAmount || giveAmount < 1) return { ok: false, msg: '至少提供 1 單位資源。' }; | |
| if (this.player[giveRes] < giveAmount) return { ok: false, msg: `你只有 ${this.player[giveRes]} ${RESOURCES[giveRes].label}。` }; | |
| const chance = (ACCEPT_RATES[f.personality] || [0.5, 0.5, 0.5])[2]; | |
| const markup = TRADE_MARKUP[f.personality] || 1; | |
| const getAmount = Math.max(1, Math.round(giveAmount / markup)); | |
| if (f[getRes] < getAmount) return { ok: false, msg: `${f.name} 沒有足夠的${RESOURCES[getRes].label}。` }; | |
| this.spendAction(); | |
| if (Math.random() < chance) { | |
| this.player[giveRes] -= giveAmount; | |
| this.player[getRes] += getAmount; | |
| f[giveRes] += giveAmount; | |
| f[getRes] -= getAmount; | |
| this.addLog(`以 ${giveAmount} ${RESOURCES[giveRes].label} 向 ${f.name} 換得 ${getAmount} ${RESOURCES[getRes].label}。`, 'diplomacy'); | |
| this.commit('diplomacy'); | |
| return { ok: true, accepted: true, getAmount, msg: `${f.name} 接受交易：以 ${giveAmount} ${RESOURCES[giveRes].label} 換取 ${getAmount} ${RESOURCES[getRes].label}。` }; | |
| } | |
| this.addLog(`${f.name} 拒絕你的貿易提案。`, 'diplomacy'); | |
| this.commit('diplomacy'); | |
| return { ok: true, accepted: false, getAmount: 0, msg: `${f.name} 拒絕了這筆交易。` }; | |
| } | |
| getRelations() { | |
| return this.state.diplomacy.filter((r) => r.factionA === this.state.playerFactionId || r.factionB === this.state.playerFactionId); | |
| } | |
| relationWith(fid) { return this.relation(this.state.playerFactionId, fid); } | |
| // ── Turn cycle ──────────────────────────────────────────────────────────── | |
| endTurn() { | |
| if (this.state.isOver) return null; | |
| const report = { turn: this.state.turn, income: null, upkeep: null, net: null, aiLogs: [], diploLogs: [], starvation: [], playerBefore: null }; | |
| const player = this.player; | |
| // income & upkeep for every faction | |
| for (const f of Object.values(this.state.factions)) { | |
| if (f.territories.length === 0) continue; | |
| const inc = this.income(f.id); | |
| const up = this.upkeep(f.id); | |
| f.gold += inc.gold - up.gold; | |
| f.food += inc.food - up.food; | |
| f.wood += inc.wood - up.wood; | |
| f.stone += inc.stone - up.stone; | |
| if (f.food < 0) { | |
| f.food = 0; | |
| if (f.id === this.state.playerFactionId) report.starvation.push('糧倉已空，軍隊吃掉了最後的存糧。'); | |
| } | |
| if (f.gold < 0) f.gold = 0; | |
| if (f.id === this.state.playerFactionId) { | |
| report.income = inc; | |
| report.upkeep = up; | |
| report.net = { gold: inc.gold - up.gold, food: inc.food - up.food, wood: inc.wood, stone: inc.stone }; | |
| report.playerBefore = { gold: player.gold, food: player.food }; | |
| } | |
| } | |
| this.addLog(`第 ${this.state.turn} 回合結束。國庫收取 ${report.income.gold} 金幣、${report.income.food} 糧食、${report.income.wood} 木材、${report.income.stone} 石料。`, 'turn'); | |
| // AI factions act | |
| for (const f of Object.values(this.state.factions)) { | |
| if (f.id === this.state.playerFactionId) continue; | |
| if (f.territories.length === 0) continue; | |
| const logs = this.runAI(f); | |
| report.aiLogs.push(...logs); | |
| } | |
| // diplomacy countdown | |
| for (let i = this.state.diplomacy.length - 1; i >= 0; i--) { | |
| const rel = this.state.diplomacy[i]; | |
| if (rel.status === 'peace' && rel.turnsRemaining > 0) { | |
| rel.turnsRemaining -= 1; | |
| if (rel.turnsRemaining <= 0) { | |
| const a = this.faction(rel.factionA)?.name || rel.factionA; | |
| const b = this.faction(rel.factionB)?.name || rel.factionB; | |
| this.state.diplomacy.splice(i, 1); | |
| report.diploLogs.push(`${a} 與 ${b} 的停戰協議已到期。`); | |
| } | |
| } | |
| } | |
| report.aiLogs.forEach((l) => this.addLog(l, 'ai')); | |
| report.diploLogs.forEach((l) => this.addLog(l, 'diplomacy')); | |
| // player elimination | |
| if (player.territories.length === 0) { | |
| const winner = Object.values(this.state.factions).find((f) => f.territories.length > 0); | |
| this.finish(winner?.id || null); | |
| this.commit('turn', report); | |
| return report; | |
| } | |
| this.state.turn += 1; | |
| this.state.actionsLeft = MAX_ACTIONS; | |
| const win = this.checkWinner(); | |
| if (win) this.finish(win); | |
| for (const f of Object.values(this.state.factions)) this.syncArmies(f.id); | |
| this.commit('turn', report); | |
| return report; | |
| } | |
| runAI(faction) { | |
| const logs = []; | |
| const squadTerr = this.factionTerritories(faction.id)[0]; | |
| if (!squadTerr) return logs; | |
| // recruit | |
| if (faction.gold >= 6 && faction.food >= 4) { | |
| const n = Math.min(Math.floor(faction.gold / 3), Math.floor(faction.food / 2), 3); | |
| if (n > 0) { | |
| faction.gold -= n * 3; | |
| faction.food -= n * 2; | |
| squadTerr.armies += n; | |
| faction.totalArmies += n; | |
| logs.push(`${faction.name} 在 ${squadTerr.name} 徵募 ${n} 名士兵。`); | |
| } | |
| } | |
| // desperate alliances break | |
| if (faction.territories.length <= 1 && faction.gold < 5 && faction.personality === 'aggressive') { | |
| const rels = this.state.diplomacy.filter((r) => (r.factionA === faction.id || r.factionB === faction.id) && r.status === 'allied'); | |
| for (const r of rels) { | |
| this.state.diplomacy = this.state.diplomacy.filter((x) => x !== r); | |
| logs.push(`${faction.name} 在絕境中撕毀同盟。`); | |
| } | |
| } | |
| // attack one adjacent target | |
| for (const tid of [...faction.territories]) { | |
| const src = this.territory(tid); | |
| if (!src || src.armies < 2) continue; | |
| for (const adjId of src.adjacentTo) { | |
| const target = this.territory(adjId); | |
| if (!target || target.owner === faction.id) continue; | |
| if (target.owner) { | |
| const status = this.relationStatus(faction.id, target.owner); | |
| if (status === 'allied' || status === 'peace') continue; | |
| } | |
| if (src.armies < target.armies && faction.personality !== 'aggressive') continue; | |
| const pre = src.armies; | |
| const result = this.resolveCombat(pre, target.armies, target.type, target); | |
| src.armies = Math.max(0, pre - result.attackerCasualties); | |
| faction.totalArmies = Math.max(0, faction.totalArmies - result.attackerCasualties); | |
| logs.push(`${faction.name} 自 ${src.name} 進攻 ${target.name}（${pre} 對 ${target.armies}）。`); | |
| if (result.captured) { | |
| const oldOwnerId = target.owner; | |
| if (oldOwnerId) { | |
| const old = this.faction(oldOwnerId); | |
| target.armies = Math.max(0, target.armies - result.defenderCasualties); | |
| if (old) { | |
| old.territories = old.territories.filter((id) => id !== adjId); | |
| old.totalArmies = Math.max(0, old.totalArmies - result.defenderCasualties); | |
| if (old.territories.length === 0) { | |
| logs.push(`${old.name} 已從地圖上滅亡。`); | |
| if (old.id === this.state.playerFactionId) { | |
| target.owner = faction.id; | |
| target.armies = src.armies; | |
| src.armies = 0; | |
| faction.territories.push(adjId); | |
| this.addLog(`${faction.name} 占領了 ${target.name}。`, 'critical'); | |
| return logs; | |
| } | |
| } | |
| } | |
| } | |
| const survivors = src.armies; | |
| src.armies = 0; | |
| target.owner = faction.id; | |
| target.armies = survivors; | |
| faction.territories.push(adjId); | |
| logs.push(`${faction.name} 以 ${survivors} 名倖存者占領 ${target.name}。`); | |
| } else { | |
| target.armies = Math.max(0, target.armies - result.defenderCasualties); | |
| if (target.owner) { | |
| const old = this.faction(target.owner); | |
| if (old) old.totalArmies = Math.max(0, old.totalArmies - result.defenderCasualties); | |
| } | |
| logs.push(`${faction.name} 對 ${target.name} 的攻勢被擊退。`); | |
| } | |
| return logs; | |
| } | |
| } | |
| return logs; | |
| } | |
| checkWinner() { | |
| const total = Object.keys(this.state.territories).length; | |
| for (const f of Object.values(this.state.factions)) { | |
| if (f.territories.length >= total) return f.id; | |
| if (f.territories.length > 0) { | |
| const owned = Object.values(this.state.territories).filter((t) => t.owner === f.id).length; | |
| if (owned >= total) return f.id; | |
| } | |
| } | |
| return null; | |
| } | |
| finish(winnerId) { | |
| if (this.state.isOver) return; | |
| this.state.isOver = true; | |
| this.state.winner = winnerId; | |
| const name = winnerId ? this.faction(winnerId)?.name : null; | |
| this.addLog(winnerId === this.state.playerFactionId | |
| ? `勝利！${name} 統治了世界。` | |
| : `${name || '某個對手'} 征服了世界。`, 'critical'); | |
| } | |
| // forecast for attack modal | |
| forecast(fromId, toId, n) { | |
| const from = this.territory(fromId); | |
| const to = this.territory(toId); | |
| if (!from || !to) return null; | |
| const units = n == null ? from.armies : n; | |
| const terrainBonus = TERRAIN_BONUS[to.type] ?? 1; | |
| const wallBonus = to.buildings.includes('walls') ? 0.3 : 0; | |
| const atk = units * 0.8; | |
| const def = to.armies * 0.8 * (terrainBonus + wallBonus); | |
| const ratio = atk / (def || 1); | |
| let label = '絕望'; | |
| let tone = 'bad'; | |
| if (to.armies <= 0 || ratio >= 2) { label = '壓倒性'; tone = 'great'; } | |
| else if (ratio >= 1.2) { label = '有利'; tone = 'good'; } | |
| else if (ratio >= 1.0) { label = '勢均力敵'; tone = 'warn'; } | |
| else if (ratio >= 0.8) { label = '冒險'; tone = 'warn'; } | |
| else { label = '恐將失敗'; tone = 'bad'; } | |
| return { ratio, label, tone, atk, def, terrainBonus, wallBonus }; | |
| } | |
| factionStanding(fid) { | |
| const f = this.faction(fid); | |
| if (!f) return null; | |
| return { | |
| territories: f.territories.length, | |
| armies: this.factionTerritories(fid).reduce((s, t) => s + t.armies, 0), | |
| personality: f.personality, | |
| color: f.color, | |
| }; | |
| } | |
| } | |