diff --git a/app/game-engine/src/turn/ai/generalAi/core.ts b/app/game-engine/src/turn/ai/generalAi/core.ts index 75dbe0ad..17740a19 100644 --- a/app/game-engine/src/turn/ai/generalAi/core.ts +++ b/app/game-engine/src/turn/ai/generalAi/core.ts @@ -238,7 +238,12 @@ export class GeneralAI { private devRate: Record | null = null; private categorizedCities = false; private categorizedGenerals = false; - private promotionPatches: Array<{ generalId: number; officerLevel: number; officerCity: number }> = []; + private promotionPatches: Array<{ + generalId: number; + officerLevel: number; + officerCity: number; + permission?: string; + }> = []; private promotionNationMeta: Record | null = null; private readonly initialGeneralMeta: Record; @@ -433,7 +438,7 @@ export class GeneralAI { } consumePromotionPatches(): { - generals: Array<{ generalId: number; officerLevel: number; officerCity: number }>; + generals: Array<{ generalId: number; officerLevel: number; officerCity: number; permission?: string }>; nationMeta: Record | null; } { const result = { @@ -1068,6 +1073,7 @@ export class GeneralAI { } const minChiefLevel = this.nation.level >= 6 ? 5 : this.nation.level >= 4 ? 7 : this.nation.level >= 2 ? 9 : 11; let chiefSet = readMetaNumber(asRecord(this.nation.meta), 'chief_set', 0); + const initialChiefSet = chiefSet; const generals = this.worldRef .listGenerals() .filter((candidate) => candidate.nationId === this.nation!.id) @@ -1080,12 +1086,102 @@ export class GeneralAI { }); const effectiveOfficerLevel = new Map(generals.map((candidate) => [candidate.id, candidate.officerLevel])); + let userChiefCount = 0; + const worldKillturn = readMetaNumber(asRecord(this.world.meta), 'killturn', 0); + const minUserKillturn = worldKillturn - Math.trunc(240 / this.turnTermMinutes); + const minNpcKillturn = 36; + + for (let chiefLevel = minChiefLevel; chiefLevel <= 12; chiefLevel += 1) { + const chief = this.chiefGenerals[chiefLevel]; + if (!chief) { + continue; + } + const penalty = asRecord(chief.penalty); + const killturn = readRequiredMetaNumber(asRecord(chief.meta), 'killturn', `generalId=${chief.id}`); + if (chief.npcState < 2 && killturn >= minUserKillturn && penalty.noAmbassador !== true) { + userChiefCount += 1; + chief.meta = { ...chief.meta, permission: 'ambassador' }; + this.promotionPatches.push({ + generalId: chief.id, + officerLevel: chief.officerLevel, + officerCity: readMetaNumber(asRecord(chief.meta), 'officer_city', 0), + permission: 'ambassador', + }); + } + } + + const minBelong = Math.min(readMetaNumber(asRecord(this.general.meta), 'belong', 0) - 1, 3); + const availableUserChiefCount = Object.values(this.userGenerals).filter((candidate) => { + const penalty = asRecord(candidate.penalty); + const killturn = readRequiredMetaNumber(asRecord(candidate.meta), 'killturn', `generalId=${candidate.id}`); + return ( + killturn >= minUserKillturn && + readMetaNumber(asRecord(candidate.meta), 'belong', 0) >= minBelong && + penalty.noChief !== true + ); + }).length; + + if (userChiefCount === 0 && availableUserChiefCount > 0 && (chiefSet & (1 << 11)) === 0) { + const userCandidates = Object.values(this.userGenerals).sort((left, right) => { + const leftPenalty = asRecord(left.penalty); + const rightPenalty = asRecord(right.penalty); + if ((leftPenalty.noChief === true) !== (rightPenalty.noChief === true)) { + return leftPenalty.noChief === true ? 1 : -1; + } + if ((leftPenalty.noAmbassador === true) !== (rightPenalty.noAmbassador === true)) { + return leftPenalty.noAmbassador === true ? 1 : -1; + } + return right.stats.leadership - left.stats.leadership; + }); + for (const candidate of userCandidates) { + const penalty = asRecord(candidate.penalty); + const killturn = readRequiredMetaNumber( + asRecord(candidate.meta), + 'killturn', + `generalId=${candidate.id}` + ); + if ( + penalty.noChief === true || + killturn < minUserKillturn || + readMetaNumber(asRecord(candidate.meta), 'belong', 0) < minBelong || + candidate.officerLevel > 4 + ) { + continue; + } + const permission = penalty.noAmbassador === true ? undefined : 'ambassador'; + candidate.officerLevel = 11; + candidate.meta = { + ...candidate.meta, + officer_city: 0, + ...(permission ? { permission } : {}), + }; + this.promotionPatches.push({ + generalId: candidate.id, + officerLevel: 11, + officerCity: 0, + ...(permission ? { permission } : {}), + }); + effectiveOfficerLevel.set(candidate.id, 11); + chiefSet |= 1 << 11; + userChiefCount += 1; + break; + } + } + for (let chiefLevel = 11; chiefLevel >= minChiefLevel; chiefLevel -= 1) { if ((chiefSet & (1 << chiefLevel)) !== 0 || this.general.officerLevel === chiefLevel) { continue; } const oldChief = generals.find((candidate) => candidate.officerLevel === chiefLevel); if (oldChief) { + const oldChiefKillturn = readRequiredMetaNumber( + asRecord(oldChief.meta), + 'killturn', + `generalId=${oldChief.id}` + ); + if (oldChief.npcState < 2 && oldChiefKillturn >= minChiefLevel) { + continue; + } const newChiefProbability = this.rng.nextBool(0.1) ? 1 : 0; // GeneralAI.php performs a second nextBool(0) call on the // rejection path. Preserve that consumption for the shared @@ -1095,7 +1191,7 @@ export class GeneralAI { } } const nextChief = generals.find((candidate) => { - if ((effectiveOfficerLevel.get(candidate.id) ?? candidate.officerLevel) > 4 || candidate.npcState < 2) { + if ((effectiveOfficerLevel.get(candidate.id) ?? candidate.officerLevel) > 4) { return false; } const killturn = readRequiredMetaNumber( @@ -1103,7 +1199,13 @@ export class GeneralAI { 'killturn', `generalId=${candidate.id}` ); - if (killturn < 36) { + if (candidate.npcState < 2 && killturn < minUserKillturn) { + return false; + } + if (candidate.npcState >= 2 && killturn < minNpcKillturn) { + return false; + } + if (asRecord(candidate.penalty).noChief === true) { return false; } if (chiefLevel !== 11 && chiefLevel % 2 === 0 && candidate.stats.strength < this.aiConst.chiefStatMin) { @@ -1116,6 +1218,9 @@ export class GeneralAI { ) { return false; } + if (candidate.npcState < 2 && userChiefCount >= 3) { + return false; + } return true; }); if (!nextChief) { @@ -1124,18 +1229,37 @@ export class GeneralAI { if (oldChief) { this.promotionPatches.push({ generalId: oldChief.id, officerLevel: 1, officerCity: 0 }); } - this.promotionPatches.push({ generalId: nextChief.id, officerLevel: chiefLevel, officerCity: 0 }); + const permission = + nextChief.npcState < 2 && asRecord(nextChief.penalty).noAmbassador !== true ? 'ambassador' : undefined; + if (nextChief.npcState < 2) { + userChiefCount += 1; + } + this.promotionPatches.push({ + generalId: nextChief.id, + officerLevel: chiefLevel, + officerCity: 0, + ...(permission ? { permission } : {}), + }); if (process.env.CORE_AI_TRACE_SEQUENCE === '1') { process.stdout.write( `AI_PROMOTION_TRACE ${JSON.stringify({ engine: 'core', mode: 'lord', actor: this.general.id, chiefLevel, picked: nextChief.id })}\n` ); } + nextChief.meta = { + ...nextChief.meta, + officer_city: 0, + ...(permission ? { permission } : {}), + }; effectiveOfficerLevel.set(nextChief.id, chiefLevel); chiefSet |= 1 << chiefLevel; } - if (this.promotionPatches.length > 0) { - this.promotionNationMeta = { ...this.nation.meta, chief_set: chiefSet }; + if (chiefSet !== initialChiefSet) { + this.promotionNationMeta = { + ...this.nation.meta, + ...(this.promotionNationMeta ?? {}), + chief_set: chiefSet, + }; } } diff --git a/app/game-engine/src/turn/reservedTurnHandler.ts b/app/game-engine/src/turn/reservedTurnHandler.ts index 395b8e99..ea21c4a5 100644 --- a/app/game-engine/src/turn/reservedTurnHandler.ts +++ b/app/game-engine/src/turn/reservedTurnHandler.ts @@ -1690,7 +1690,13 @@ export const createReservedTurnHandler = async (options: { const patch = { officerLevel: entry.officerLevel, ...(promotedGeneral - ? { meta: { ...promotedGeneral.meta, officer_city: entry.officerCity } } + ? { + meta: { + ...promotedGeneral.meta, + officer_city: entry.officerCity, + ...(entry.permission ? { permission: entry.permission } : {}), + }, + } : {}), }; patches.generals.push({ id: entry.generalId, patch }); diff --git a/app/game-engine/test/generalAiLegacyDecisionParity.test.ts b/app/game-engine/test/generalAiLegacyDecisionParity.test.ts index 95743cf4..82b76ed2 100644 --- a/app/game-engine/test/generalAiLegacyDecisionParity.test.ts +++ b/app/game-engine/test/generalAiLegacyDecisionParity.test.ts @@ -3,6 +3,7 @@ import type { City, General, Nation } from '@sammo-ts/logic'; import { createRefOrderedActionStack } from '@sammo-ts/logic/actionModules/bundle.js'; import { GeneralAI } from '../src/turn/ai/generalAi.js'; +import type { TurnGeneral } from '../src/turn/types.js'; import { calculateRecentWarTurn, resolveLegacyAiStats, @@ -23,10 +24,7 @@ import { doNPC전방발령, doNPC후방발령, } from '../src/turn/ai/generalAi/nation/assignments/npcAssignments.js'; -import { - do부대구출발령, - do부대후방발령, -} from '../src/turn/ai/generalAi/nation/assignments/troopAssignments.js'; +import { do부대구출발령, do부대후방발령 } from '../src/turn/ai/generalAi/nation/assignments/troopAssignments.js'; type Candidate = { action: string; @@ -397,6 +395,311 @@ const makeAi = ( } as unknown as GeneralAI; }; +const makePromotionGeneral = (overrides: Partial): TurnGeneral => ({ + ...baseGeneral(), + ...overrides, + stats: { ...baseGeneral().stats, ...overrides.stats }, + meta: { ...baseGeneral().meta, belong: 1, ...overrides.meta }, +}); + +const makePromotionAi = (options: { + ruler: TurnGeneral; + generals: TurnGeneral[]; + nation?: Partial; + userGenerals?: TurnGeneral[]; + chiefGenerals?: TurnGeneral[]; + npcWarGenerals?: TurnGeneral[]; + npcCivilGenerals?: TurnGeneral[]; + userWarGenerals?: TurnGeneral[]; + userCivilGenerals?: TurnGeneral[]; + rng?: ScriptedRng; + currentMonth?: number; +}): GeneralAI => { + const nation = { + ...baseNation(), + level: 1, + ...options.nation, + meta: { chief_set: 0, ...options.nation?.meta }, + }; + const asGeneralRecord = (entries: TurnGeneral[] = []): Record => + Object.fromEntries(entries.map((general) => [general.id, general])); + const asChiefRecord = (entries: TurnGeneral[] = []): Record => + Object.fromEntries(entries.map((general) => [general.officerLevel, general])); + + return Object.assign(Object.create(GeneralAI.prototype), { + general: options.ruler, + nation, + world: { + id: 1, + currentYear: 190, + currentMonth: options.currentMonth ?? 3, + tickSeconds: 600, + lastTurnTime: new Date('0190-03-01T00:00:00Z'), + meta: { killturn: 100 }, + }, + worldRef: { + listGenerals: () => options.generals, + }, + turnTermMinutes: 10, + aiConst: { chiefStatMin: 70 }, + rng: options.rng ?? makeRng(), + userGenerals: asGeneralRecord(options.userGenerals), + chiefGenerals: asChiefRecord(options.chiefGenerals), + npcWarGenerals: asGeneralRecord(options.npcWarGenerals), + npcCivilGenerals: asGeneralRecord(options.npcCivilGenerals), + userWarGenerals: asGeneralRecord(options.userWarGenerals), + userCivilGenerals: asGeneralRecord(options.userCivilGenerals), + promotionPatches: [], + promotionNationMeta: null, + }) as GeneralAI; +}; + +const chooseNpcPromotion = (ai: GeneralAI): void => + (ai as unknown as { chooseNpcPromotion: () => void }).chooseNpcPromotion(); + +const chooseNonLordPromotion = (ai: GeneralAI): void => + (ai as unknown as { chooseNonLordPromotion: () => void }).chooseNonLordPromotion(); + +describe('legacy NPC user-chief promotion parity', () => { + it('appoints the first active user as advisor when the NPC ruler tenure threshold is already met', () => { + const ruler = makePromotionGeneral({ + id: 1, + officerLevel: 12, + npcState: 2, + meta: { killturn: 100, belong: 2 }, + }); + const user = makePromotionGeneral({ + id: 2, + name: '신규유저', + npcState: 0, + stats: { leadership: 40, strength: 40, intelligence: 40 }, + meta: { killturn: 100, belong: 1 }, + }); + const ai = makePromotionAi({ + ruler, + generals: [ruler, user], + userGenerals: [user], + chiefGenerals: [ruler], + }); + + chooseNpcPromotion(ai); + + expect(ai.consumePromotionPatches()).toEqual({ + generals: [{ generalId: 2, officerLevel: 11, officerCity: 0, permission: 'ambassador' }], + nationMeta: expect.objectContaining({ chief_set: 1 << 11 }), + }); + }); + + it('waits for belong 3 before forcing a user over a stronger NPC under an established NPC ruler', () => { + const run = (belong: number) => { + const ruler = makePromotionGeneral({ + id: 1, + officerLevel: 12, + npcState: 2, + meta: { killturn: 100, belong: 4 }, + }); + const npc = makePromotionGeneral({ + id: 2, + name: '강한NPC', + npcState: 2, + stats: { leadership: 100, strength: 100, intelligence: 100 }, + meta: { killturn: 100, belong: 4 }, + }); + const user = makePromotionGeneral({ + id: 3, + name: '유저후보', + npcState: 0, + stats: { leadership: 80, strength: 80, intelligence: 80 }, + meta: { killturn: 100, belong }, + }); + const ai = makePromotionAi({ + ruler, + generals: [ruler, npc, user], + userGenerals: [user], + chiefGenerals: [ruler], + }); + chooseNpcPromotion(ai); + return ai.consumePromotionPatches().generals; + }; + + expect(run(1)).toEqual([{ generalId: 2, officerLevel: 11, officerCity: 0 }]); + expect(run(3)).toEqual([{ generalId: 3, officerLevel: 11, officerCity: 0, permission: 'ambassador' }]); + }); + + it('prefers an ambassador-eligible user over a higher-leadership no-ambassador user', () => { + const ruler = makePromotionGeneral({ + id: 1, + officerLevel: 12, + npcState: 2, + meta: { killturn: 100, belong: 2 }, + }); + const blockedAmbassador = makePromotionGeneral({ + id: 2, + npcState: 0, + stats: { leadership: 95, strength: 80, intelligence: 80 }, + meta: { killturn: 100, belong: 1 }, + penalty: { noAmbassador: true }, + }); + const eligible = makePromotionGeneral({ + id: 3, + npcState: 0, + stats: { leadership: 70, strength: 80, intelligence: 80 }, + meta: { killturn: 100, belong: 1 }, + }); + const ai = makePromotionAi({ + ruler, + generals: [ruler, blockedAmbassador, eligible], + userGenerals: [blockedAmbassador, eligible], + chiefGenerals: [ruler], + }); + + chooseNpcPromotion(ai); + + expect(ai.consumePromotionPatches().generals).toEqual([ + { generalId: 3, officerLevel: 11, officerCity: 0, permission: 'ambassador' }, + ]); + }); + + it('does not appoint a user carrying the no-chief penalty', () => { + const ruler = makePromotionGeneral({ + id: 1, + officerLevel: 12, + npcState: 2, + meta: { killturn: 100, belong: 2 }, + }); + const blocked = makePromotionGeneral({ + id: 2, + npcState: 0, + stats: { leadership: 100, strength: 100, intelligence: 100 }, + meta: { killturn: 100, belong: 1 }, + penalty: { noChief: true }, + }); + const ai = makePromotionAi({ + ruler, + generals: [ruler, blocked], + userGenerals: [blocked], + chiefGenerals: [ruler], + }); + + chooseNpcPromotion(ai); + + expect(ai.consumePromotionPatches()).toEqual({ generals: [], nationMeta: null }); + }); + + it('does not appoint a fourth user chief in the ordinary NPC-ruler fill pass', () => { + const ruler = makePromotionGeneral({ + id: 1, + officerLevel: 12, + npcState: 2, + meta: { killturn: 100, belong: 4 }, + }); + const existingChiefs = [11, 10, 9].map((officerLevel, index) => + makePromotionGeneral({ + id: index + 2, + npcState: 0, + officerLevel, + meta: { killturn: 100, belong: 4, officer_city: 0 }, + }) + ); + const candidate = makePromotionGeneral({ + id: 5, + npcState: 0, + stats: { leadership: 100, strength: 100, intelligence: 100 }, + meta: { killturn: 100, belong: 4 }, + }); + const ai = makePromotionAi({ + ruler, + generals: [ruler, ...existingChiefs, candidate], + nation: { level: 6 }, + userGenerals: [...existingChiefs, candidate], + chiefGenerals: [ruler, ...existingChiefs], + }); + + chooseNpcPromotion(ai); + + const promotion = ai.consumePromotionPatches(); + const result = promotion.generals; + expect(result.filter((entry) => entry.generalId === candidate.id)).toEqual([]); + expect(result).toHaveLength(3); + expect(promotion.nationMeta).toBeNull(); + expect(result).toEqual( + expect.arrayContaining( + existingChiefs.map((chief) => ({ + generalId: chief.id, + officerLevel: chief.officerLevel, + officerCity: 0, + permission: 'ambassador', + })) + ) + ); + }); + + it('lets an NPC non-ruler fill an open seat with a user immediately when no NPC pool exists', () => { + const actor = makePromotionGeneral({ + id: 1, + officerLevel: 10, + npcState: 2, + meta: { killturn: 100, belong: 4 }, + }); + const user = makePromotionGeneral({ + id: 2, + npcState: 0, + stats: { leadership: 40, strength: 40, intelligence: 40 }, + meta: { killturn: 100, belong: 1 }, + }); + const ai = makePromotionAi({ + ruler: actor, + generals: [actor, user], + userWarGenerals: [user], + chiefGenerals: [actor], + }); + + chooseNonLordPromotion(ai); + + expect(ai.consumePromotionPatches().generals).toEqual([{ generalId: 2, officerLevel: 11, officerCity: 0 }]); + }); + + it('runs automatic appointments only on the quarterly NPC nation turn', () => { + const run = (currentMonth: number) => { + const ruler = makePromotionGeneral({ + id: 1, + officerLevel: 12, + npcState: 2, + meta: { killturn: 100, belong: 2 }, + }); + const user = makePromotionGeneral({ + id: 2, + npcState: 0, + meta: { killturn: 100, belong: 1 }, + }); + const ai = makePromotionAi({ + ruler, + generals: [ruler, user], + userGenerals: [user], + chiefGenerals: [ruler], + currentMonth, + }); + Object.assign(ai as unknown as Record, { + updateInstance: () => undefined, + categorizeNationCities: () => undefined, + categorizeNationGeneral: () => undefined, + nationPolicy: { priority: [] }, + buildNationCandidate: (action: string, args: Record, reason: string) => ({ + action, + args, + reason, + }), + }); + + ai.chooseNationTurn({ action: '휴식', args: {} }); + return ai.consumePromotionPatches().generals; + }; + + expect(run(2)).toEqual([]); + expect(run(3)).toEqual([{ generalId: 2, officerLevel: 11, officerCity: 0, permission: 'ambassador' }]); + }); +}); + /** * Expected branches are extracted from ref/sam hwe/sammo/GeneralAI.php * at ng_compare@fe9ae978. These tests intentionally assert final command @@ -1082,8 +1385,7 @@ describe('legacy NPC AI final-decision parity', () => { nation: { rice: 100_000 }, generalActionModules: singleActionModuleStack({ eventHandlers: {}, - onCalcStat: (_context, statName, value) => - statName === 'leadership' ? Number(value) + 30 : value, + onCalcStat: (_context, statName, value) => (statName === 'leadership' ? Number(value) + 30 : value), }), }); ai.maxResourceActionAmount = 100_000; diff --git a/app/game-engine/test/npcGeneralDomesticTurn.test.ts b/app/game-engine/test/npcGeneralDomesticTurn.test.ts index 769cd8ed..2260a50a 100644 --- a/app/game-engine/test/npcGeneralDomesticTurn.test.ts +++ b/app/game-engine/test/npcGeneralDomesticTurn.test.ts @@ -299,4 +299,141 @@ describe('NPC 일반 내정 턴', () => { }) ); }); + + it('NPC 군주 국가턴에서 신규 유저의 수뇌 직책과 외교 권한을 월드 상태에 반영한다', async () => { + const buildGeneral = (overrides: Partial): TurnGeneral => { + const base: TurnGeneral = { + id: 1, + name: 'NPC군주', + nationId: 1, + cityId: 1, + troopId: 0, + stats: { leadership: 80, strength: 80, intelligence: 80 }, + turnTime: mockDate, + role: { + items: { horse: null, weapon: null, book: null, item: null }, + personality: null, + specialDomestic: null, + specialWar: null, + }, + triggerState: { flags: {}, counters: {}, modifiers: {}, meta: {} }, + meta: { killturn: 100, belong: 2 }, + officerLevel: 12, + experience: 0, + dedication: 0, + injury: 0, + gold: 2_000, + rice: 2_000, + crew: 0, + crewTypeId: 0, + train: 0, + atmos: 0, + age: 30, + npcState: 2, + }; + return { + ...base, + ...overrides, + stats: { ...base.stats, ...overrides.stats }, + meta: { ...base.meta, ...overrides.meta }, + }; + }; + const ruler = buildGeneral({}); + const user = buildGeneral({ + id: 2, + name: '신규유저', + npcState: 0, + officerLevel: 1, + meta: { killturn: 100, belong: 1 }, + }); + const city = { + id: 1, + name: '소성A', + nationId: 1, + level: 1, + state: 0, + population: 10_000, + populationMax: 20_000, + agriculture: 1_000, + agricultureMax: 2_000, + commerce: 1_000, + commerceMax: 2_000, + security: 1_000, + securityMax: 2_000, + supplyState: 1, + frontState: 0, + defence: 500, + defenceMax: 1_000, + wall: 500, + wallMax: 1_000, + meta: { trust: 98 }, + }; + const nation = { + id: 1, + name: 'NPC국가', + color: '#FF0000', + capitalCityId: 1, + chiefGeneralId: 1, + gold: 50_000, + rice: 50_000, + power: 0, + level: 1, + typeCode: 'che_def', + meta: { chief_set: 0 }, + }; + const snapshot: TurnWorldSnapshot = { + generals: [ruler, user], + cities: [city] as any, + nations: [nation] as any, + troops: [], + diplomacy: [], + events: [], + initialEvents: [], + map: MINIMAL_MAP as any, + scenarioConfig: { + stat: { total: 300, min: 10, max: 100, npcTotal: 150, npcMax: 50, npcMin: 10, chiefMin: 70 }, + iconPath: '', + map: {}, + const: { npcMessageFreqByDay: 144 }, + environment: { mapName: 'npc_domestic_map', unitSet: 'default' }, + }, + scenarioMeta: { startYear: 189 } as any, + unitSet: {} as any, + }; + const state: TurnWorldState = { + id: 1, + currentYear: 189, + currentMonth: 3, + tickSeconds: 600, + lastTurnTime: mockDate, + meta: { seed: 1, killturn: 100 }, + }; + const reservedTurnStore = new InMemoryReservedTurnStore(createMockPrisma() as any, { + maxGeneralTurns: 10, + maxNationTurns: 10, + }); + await reservedTurnStore.loadAll(); + const wrapper = { world: null as InMemoryTurnWorld | null }; + const handler = await createReservedTurnHandler({ + reservedTurns: reservedTurnStore, + scenarioConfig: snapshot.scenarioConfig, + scenarioMeta: snapshot.scenarioMeta, + map: MINIMAL_MAP as any, + unitSet: snapshot.unitSet, + getWorld: () => wrapper.world, + }); + const world = new InMemoryTurnWorld(state, snapshot, { + schedule: { entries: [{ startMinute: 0, tickMinutes: 10 }] }, + generalTurnHandler: handler, + }); + wrapper.world = world; + + world.executeGeneralTurn(ruler); + + expect(world.getGeneralById(user.id)).toMatchObject({ + officerLevel: 11, + meta: expect.objectContaining({ officer_city: 0, permission: 'ambassador' }), + }); + expect(world.getNationById(nation.id)?.meta).toMatchObject({ chief_set: 1 << 11 }); + }); });