362 lines
13 KiB
TypeScript
362 lines
13 KiB
TypeScript
import { createGamePostgresConnector, type InputJsonValue, type TurnEngineDatabaseClient } from '@sammo-ts/infra';
|
|
import { isRecord } from '@sammo-ts/common';
|
|
|
|
export interface ReservedTurnEntry {
|
|
action: string;
|
|
args: Record<string, unknown>;
|
|
}
|
|
|
|
export interface ReservedTurnStoreOptions {
|
|
databaseUrl: string;
|
|
maxGeneralTurns?: number;
|
|
maxNationTurns?: number;
|
|
}
|
|
|
|
export interface ReservedTurnStoreHandle {
|
|
store: InMemoryReservedTurnStore;
|
|
close(): Promise<void>;
|
|
}
|
|
|
|
const DEFAULT_TURN_ACTION = '휴식';
|
|
const DEFAULT_GENERAL_TURNS = 30;
|
|
const DEFAULT_NATION_TURNS = 12;
|
|
|
|
const asJson = (value: unknown): InputJsonValue => value as InputJsonValue;
|
|
|
|
const normalizeAction = (action: string | null | undefined): string =>
|
|
action && action.length > 0 ? action : DEFAULT_TURN_ACTION;
|
|
|
|
const normalizeArgs = (args: unknown): Record<string, unknown> => (isRecord(args) ? args : {});
|
|
|
|
const createDefaultEntry = (): ReservedTurnEntry => ({
|
|
action: DEFAULT_TURN_ACTION,
|
|
args: {},
|
|
});
|
|
|
|
const buildDefaultTurns = (length: number): ReservedTurnEntry[] => Array.from({ length }, () => createDefaultEntry());
|
|
|
|
const applyShift = (turns: ReservedTurnEntry[], amount: number): ReservedTurnEntry[] => {
|
|
if (amount === 0) {
|
|
return turns.slice();
|
|
}
|
|
if (amount > 0) {
|
|
const shift = Math.min(turns.length, amount);
|
|
const padding = Array.from({ length: shift }, () => createDefaultEntry());
|
|
const sliced = turns.slice(0, Math.max(0, turns.length - shift));
|
|
return padding.concat(sliced);
|
|
}
|
|
const shift = Math.min(turns.length, Math.abs(amount));
|
|
const padding = Array.from({ length: shift }, () => createDefaultEntry());
|
|
const sliced = turns.slice(shift);
|
|
return sliced.concat(padding);
|
|
};
|
|
|
|
const buildTurnListFromRows = (
|
|
rows: Array<{ turnIdx: number; actionCode: string; arg: unknown }>,
|
|
maxTurns: number
|
|
): ReservedTurnEntry[] => {
|
|
const result = buildDefaultTurns(maxTurns);
|
|
for (const row of rows) {
|
|
if (row.turnIdx < 0 || row.turnIdx >= maxTurns) {
|
|
continue;
|
|
}
|
|
result[row.turnIdx] = {
|
|
action: normalizeAction(row.actionCode),
|
|
args: normalizeArgs(row.arg),
|
|
};
|
|
}
|
|
return result;
|
|
};
|
|
|
|
const buildNationKey = (nationId: number, officerLevel: number): string => `${nationId}:${officerLevel}`;
|
|
|
|
type ReservedTurnDatabaseClient = Pick<TurnEngineDatabaseClient, 'generalTurn' | 'nationTurn'>;
|
|
|
|
export interface ReservedTurnChanges {
|
|
generalIds: number[];
|
|
generalInitializationIds: number[];
|
|
nationKeys: string[];
|
|
nationInitializationKeys: string[];
|
|
}
|
|
|
|
export class InMemoryReservedTurnStore {
|
|
private readonly generalTurns = new Map<number, ReservedTurnEntry[]>();
|
|
private readonly nationTurns = new Map<string, ReservedTurnEntry[]>();
|
|
private readonly dirtyGeneralIds = new Set<number>();
|
|
private readonly dirtyNationKeys = new Set<string>();
|
|
private readonly pendingGeneralInitializationIds = new Set<number>();
|
|
private readonly pendingNationInitializationKeys = new Set<string>();
|
|
private readonly maxGeneralTurns: number;
|
|
private readonly maxNationTurns: number;
|
|
|
|
constructor(
|
|
private readonly prisma: ReservedTurnDatabaseClient,
|
|
options: { maxGeneralTurns: number; maxNationTurns: number }
|
|
) {
|
|
this.maxGeneralTurns = options.maxGeneralTurns;
|
|
this.maxNationTurns = options.maxNationTurns;
|
|
}
|
|
|
|
async loadAll(): Promise<void> {
|
|
const [generalRows, nationRows] = await Promise.all([
|
|
this.prisma.generalTurn.findMany(),
|
|
this.prisma.nationTurn.findMany(),
|
|
]);
|
|
|
|
const generalGroups = new Map<number, typeof generalRows>();
|
|
for (const row of generalRows) {
|
|
const list = generalGroups.get(row.generalId);
|
|
if (list) {
|
|
list.push(row);
|
|
} else {
|
|
generalGroups.set(row.generalId, [row]);
|
|
}
|
|
}
|
|
for (const [generalId, rows] of generalGroups.entries()) {
|
|
this.generalTurns.set(generalId, buildTurnListFromRows(rows, this.maxGeneralTurns));
|
|
}
|
|
|
|
const nationGroups = new Map<string, typeof nationRows>();
|
|
for (const row of nationRows) {
|
|
const key = buildNationKey(row.nationId, row.officerLevel);
|
|
const list = nationGroups.get(key);
|
|
if (list) {
|
|
list.push(row);
|
|
} else {
|
|
nationGroups.set(key, [row]);
|
|
}
|
|
}
|
|
for (const [key, rows] of nationGroups.entries()) {
|
|
this.nationTurns.set(key, buildTurnListFromRows(rows, this.maxNationTurns));
|
|
}
|
|
}
|
|
|
|
async refreshGeneralTurns(generalId: number): Promise<void> {
|
|
if (this.dirtyGeneralIds.has(generalId)) {
|
|
return;
|
|
}
|
|
const rows = await this.prisma.generalTurn.findMany({
|
|
where: { generalId },
|
|
orderBy: [{ turnIdx: 'asc' }],
|
|
});
|
|
this.generalTurns.set(generalId, buildTurnListFromRows(rows, this.maxGeneralTurns));
|
|
}
|
|
|
|
async prefetchGeneralTurns(generalIds: number[]): Promise<void> {
|
|
const targetIds = Array.from(new Set(generalIds)).filter((generalId) => !this.dirtyGeneralIds.has(generalId));
|
|
if (targetIds.length === 0) {
|
|
return;
|
|
}
|
|
const rows = await this.prisma.generalTurn.findMany({
|
|
where: { generalId: { in: targetIds } },
|
|
orderBy: [{ generalId: 'asc' }, { turnIdx: 'asc' }],
|
|
});
|
|
const grouped = new Map<number, typeof rows>();
|
|
for (const row of rows) {
|
|
const list = grouped.get(row.generalId);
|
|
if (list) {
|
|
list.push(row);
|
|
} else {
|
|
grouped.set(row.generalId, [row]);
|
|
}
|
|
}
|
|
for (const generalId of targetIds) {
|
|
const list = grouped.get(generalId) ?? [];
|
|
this.generalTurns.set(generalId, buildTurnListFromRows(list, this.maxGeneralTurns));
|
|
}
|
|
}
|
|
|
|
async refreshNationTurns(nationId: number, officerLevel: number): Promise<void> {
|
|
const key = buildNationKey(nationId, officerLevel);
|
|
if (this.dirtyNationKeys.has(key) || this.pendingNationInitializationKeys.has(key)) {
|
|
return;
|
|
}
|
|
const rows = await this.prisma.nationTurn.findMany({
|
|
where: { nationId, officerLevel },
|
|
orderBy: [{ turnIdx: 'asc' }],
|
|
});
|
|
this.nationTurns.set(key, buildTurnListFromRows(rows, this.maxNationTurns));
|
|
}
|
|
|
|
getGeneralTurns(generalId: number): ReservedTurnEntry[] {
|
|
const current = this.generalTurns.get(generalId);
|
|
if (current) {
|
|
return current;
|
|
}
|
|
const created = buildDefaultTurns(this.maxGeneralTurns);
|
|
this.generalTurns.set(generalId, created);
|
|
return created;
|
|
}
|
|
|
|
getNationTurns(nationId: number, officerLevel: number): ReservedTurnEntry[] {
|
|
const key = buildNationKey(nationId, officerLevel);
|
|
const current = this.nationTurns.get(key);
|
|
if (current) {
|
|
return current;
|
|
}
|
|
const created = buildDefaultTurns(this.maxNationTurns);
|
|
this.nationTurns.set(key, created);
|
|
return created;
|
|
}
|
|
|
|
getGeneralTurn(generalId: number, turnIdx: number): ReservedTurnEntry {
|
|
const list = this.getGeneralTurns(generalId);
|
|
return list[turnIdx] ?? createDefaultEntry();
|
|
}
|
|
|
|
getNationTurn(nationId: number, officerLevel: number, turnIdx: number): ReservedTurnEntry {
|
|
const list = this.getNationTurns(nationId, officerLevel);
|
|
return list[turnIdx] ?? createDefaultEntry();
|
|
}
|
|
|
|
ensureGeneralTurns(generalId: number): void {
|
|
this.getGeneralTurns(generalId);
|
|
this.pendingGeneralInitializationIds.add(generalId);
|
|
}
|
|
|
|
replaceGeneralTurns(generalId: number, entry: ReservedTurnEntry): void {
|
|
this.generalTurns.set(
|
|
generalId,
|
|
Array.from({ length: this.maxGeneralTurns }, () => ({
|
|
action: normalizeAction(entry.action),
|
|
args: normalizeArgs(entry.args),
|
|
}))
|
|
);
|
|
this.pendingGeneralInitializationIds.delete(generalId);
|
|
this.dirtyGeneralIds.add(generalId);
|
|
}
|
|
|
|
ensureNationTurns(nationId: number, officerLevel: number): void {
|
|
const key = buildNationKey(nationId, officerLevel);
|
|
this.getNationTurns(nationId, officerLevel);
|
|
this.pendingNationInitializationKeys.add(key);
|
|
}
|
|
|
|
shiftGeneralTurns(generalId: number, amount: number): void {
|
|
const list = this.getGeneralTurns(generalId);
|
|
this.generalTurns.set(generalId, applyShift(list, amount));
|
|
this.dirtyGeneralIds.add(generalId);
|
|
}
|
|
|
|
shiftNationTurns(nationId: number, officerLevel: number, amount: number): void {
|
|
const key = buildNationKey(nationId, officerLevel);
|
|
const list = this.getNationTurns(nationId, officerLevel);
|
|
this.nationTurns.set(key, applyShift(list, amount));
|
|
this.dirtyNationKeys.add(key);
|
|
}
|
|
|
|
peekDirtyState(): ReservedTurnChanges {
|
|
return {
|
|
generalIds: Array.from(this.dirtyGeneralIds),
|
|
generalInitializationIds: Array.from(this.pendingGeneralInitializationIds),
|
|
nationKeys: Array.from(this.dirtyNationKeys),
|
|
nationInitializationKeys: Array.from(this.pendingNationInitializationKeys),
|
|
};
|
|
}
|
|
|
|
acknowledgeDirtyState(changes: ReservedTurnChanges): void {
|
|
for (const generalId of changes.generalIds) {
|
|
this.dirtyGeneralIds.delete(generalId);
|
|
}
|
|
for (const generalId of changes.generalInitializationIds) {
|
|
this.pendingGeneralInitializationIds.delete(generalId);
|
|
}
|
|
for (const key of changes.nationKeys) {
|
|
this.dirtyNationKeys.delete(key);
|
|
}
|
|
for (const key of changes.nationInitializationKeys) {
|
|
this.pendingNationInitializationKeys.delete(key);
|
|
}
|
|
}
|
|
|
|
async persistChanges(prisma: ReservedTurnDatabaseClient, changes: ReservedTurnChanges): Promise<void> {
|
|
for (const generalId of changes.generalIds) {
|
|
const turns = this.getGeneralTurns(generalId);
|
|
await prisma.generalTurn.deleteMany({ where: { generalId } });
|
|
await prisma.generalTurn.createMany({
|
|
data: turns.map((entry, turnIdx) => ({
|
|
generalId,
|
|
turnIdx,
|
|
actionCode: normalizeAction(entry.action),
|
|
arg: asJson(normalizeArgs(entry.args)),
|
|
})),
|
|
});
|
|
}
|
|
|
|
for (const generalId of changes.generalInitializationIds) {
|
|
if (changes.generalIds.includes(generalId)) {
|
|
continue;
|
|
}
|
|
const turns = this.getGeneralTurns(generalId);
|
|
await prisma.generalTurn.createMany({
|
|
data: turns.map((entry, turnIdx) => ({
|
|
generalId,
|
|
turnIdx,
|
|
actionCode: normalizeAction(entry.action),
|
|
arg: asJson(normalizeArgs(entry.args)),
|
|
})),
|
|
skipDuplicates: true,
|
|
});
|
|
}
|
|
|
|
for (const key of changes.nationKeys) {
|
|
const [nationIdRaw, officerLevelRaw] = key.split(':');
|
|
const nationId = Number(nationIdRaw);
|
|
const officerLevel = Number(officerLevelRaw);
|
|
const turns = this.getNationTurns(nationId, officerLevel);
|
|
await prisma.nationTurn.deleteMany({
|
|
where: { nationId, officerLevel },
|
|
});
|
|
await prisma.nationTurn.createMany({
|
|
data: turns.map((entry, turnIdx) => ({
|
|
nationId,
|
|
officerLevel,
|
|
turnIdx,
|
|
actionCode: normalizeAction(entry.action),
|
|
arg: asJson(normalizeArgs(entry.args)),
|
|
})),
|
|
});
|
|
}
|
|
|
|
for (const key of changes.nationInitializationKeys) {
|
|
if (changes.nationKeys.includes(key)) {
|
|
continue;
|
|
}
|
|
const [nationIdRaw, officerLevelRaw] = key.split(':');
|
|
const nationId = Number(nationIdRaw);
|
|
const officerLevel = Number(officerLevelRaw);
|
|
const turns = this.getNationTurns(nationId, officerLevel);
|
|
await prisma.nationTurn.createMany({
|
|
data: turns.map((entry, turnIdx) => ({
|
|
nationId,
|
|
officerLevel,
|
|
turnIdx,
|
|
actionCode: normalizeAction(entry.action),
|
|
arg: asJson(normalizeArgs(entry.args)),
|
|
})),
|
|
skipDuplicates: true,
|
|
});
|
|
}
|
|
}
|
|
|
|
async flushChanges(): Promise<void> {
|
|
const changes = this.peekDirtyState();
|
|
await this.persistChanges(this.prisma, changes);
|
|
this.acknowledgeDirtyState(changes);
|
|
}
|
|
}
|
|
|
|
export const createReservedTurnStore = async (options: ReservedTurnStoreOptions): Promise<ReservedTurnStoreHandle> => {
|
|
const connector = createGamePostgresConnector({ url: options.databaseUrl });
|
|
await connector.connect();
|
|
const store = new InMemoryReservedTurnStore(connector.prisma, {
|
|
maxGeneralTurns: options.maxGeneralTurns ?? DEFAULT_GENERAL_TURNS,
|
|
maxNationTurns: options.maxNationTurns ?? DEFAULT_NATION_TURNS,
|
|
});
|
|
await store.loadAll();
|
|
return {
|
|
store,
|
|
close: () => connector.disconnect(),
|
|
};
|
|
};
|