446 lines
13 KiB
TypeScript
446 lines
13 KiB
TypeScript
import { jsonReplacer } from './utils';
|
|
import { readFileSync, existsSync, writeFileSync } from 'node:fs';
|
|
import { join } from 'node:path';
|
|
import { z } from 'zod';
|
|
|
|
const configPath = join(import.meta.dir, '..', 'config', 'config.json');
|
|
|
|
export interface GuildConfig {
|
|
studentRole?: string;
|
|
visitorRole?: string;
|
|
colorRoles: string[];
|
|
welcomeChannelId?: string;
|
|
welcomeMessage?: string;
|
|
feedbackChannelId?: string;
|
|
terminal?: {
|
|
channelId: string;
|
|
messageId: string;
|
|
};
|
|
moderation: {
|
|
cases: {
|
|
dmOnWarn: boolean;
|
|
logChannelId?: string;
|
|
autoTimeoutThreshold?: number;
|
|
};
|
|
};
|
|
}
|
|
|
|
const guildConfigCache = new Map<string, { config: GuildConfig; timestamp: number }>();
|
|
const CACHE_TTL_MS = 60000;
|
|
|
|
export async function getGuildConfig(guildId: string): Promise<GuildConfig> {
|
|
const cached = guildConfigCache.get(guildId);
|
|
if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
|
|
return cached.config;
|
|
}
|
|
|
|
try {
|
|
const { guildSettingsService } = await import('@shared/modules/guild-settings/guild-settings.service');
|
|
const dbSettings = await guildSettingsService.getSettings(guildId);
|
|
|
|
if (dbSettings) {
|
|
const config: GuildConfig = {
|
|
studentRole: dbSettings.studentRoleId,
|
|
visitorRole: dbSettings.visitorRoleId,
|
|
colorRoles: dbSettings.colorRoleIds ?? [],
|
|
welcomeChannelId: dbSettings.welcomeChannelId,
|
|
welcomeMessage: dbSettings.welcomeMessage,
|
|
feedbackChannelId: dbSettings.feedbackChannelId,
|
|
terminal: dbSettings.terminalChannelId ? {
|
|
channelId: dbSettings.terminalChannelId,
|
|
messageId: dbSettings.terminalMessageId ?? "",
|
|
} : undefined,
|
|
moderation: {
|
|
cases: {
|
|
dmOnWarn: dbSettings.moderationDmOnWarn ?? true,
|
|
logChannelId: dbSettings.moderationLogChannelId,
|
|
autoTimeoutThreshold: dbSettings.moderationAutoTimeoutThreshold,
|
|
},
|
|
},
|
|
};
|
|
|
|
guildConfigCache.set(guildId, { config, timestamp: Date.now() });
|
|
return config;
|
|
}
|
|
} catch (error) {
|
|
console.error("Failed to load guild config from database:", error);
|
|
}
|
|
|
|
return {
|
|
studentRole: undefined,
|
|
visitorRole: undefined,
|
|
colorRoles: [],
|
|
welcomeChannelId: undefined,
|
|
welcomeMessage: undefined,
|
|
feedbackChannelId: undefined,
|
|
terminal: undefined,
|
|
moderation: { cases: { dmOnWarn: true } },
|
|
};
|
|
}
|
|
|
|
export function invalidateGuildConfigCache(guildId: string) {
|
|
guildConfigCache.delete(guildId);
|
|
}
|
|
|
|
export interface LevelingConfig {
|
|
base: number;
|
|
exponent: number;
|
|
chat: {
|
|
cooldownMs: number;
|
|
minXp: number;
|
|
maxXp: number;
|
|
};
|
|
}
|
|
|
|
export interface EconomyConfig {
|
|
daily: {
|
|
amount: bigint;
|
|
streakBonus: bigint;
|
|
weeklyBonus: bigint;
|
|
cooldownMs: number;
|
|
};
|
|
transfers: {
|
|
allowSelfTransfer: boolean;
|
|
minAmount: bigint;
|
|
};
|
|
exam: {
|
|
multMin: number;
|
|
multMax: number;
|
|
};
|
|
}
|
|
|
|
export interface InventoryConfig {
|
|
maxStackSize: bigint;
|
|
maxSlots: number;
|
|
}
|
|
|
|
export interface LootdropConfig {
|
|
activityWindowMs: number;
|
|
minMessages: number;
|
|
spawnChance: number;
|
|
cooldownMs: number;
|
|
reward: {
|
|
min: number;
|
|
max: number;
|
|
currency: string;
|
|
};
|
|
}
|
|
|
|
export interface TriviaConfig {
|
|
entryFee: bigint;
|
|
rewardMultiplier: number;
|
|
timeoutSeconds: number;
|
|
cooldownMs: number;
|
|
categories: number[];
|
|
difficulty: 'easy' | 'medium' | 'hard' | 'random';
|
|
}
|
|
|
|
export interface ModerationConfig {
|
|
prune: {
|
|
maxAmount: number;
|
|
confirmThreshold: number;
|
|
batchSize: number;
|
|
batchDelayMs: number;
|
|
};
|
|
cases: {
|
|
dmOnWarn: boolean;
|
|
logChannelId?: string;
|
|
autoTimeoutThreshold?: number;
|
|
};
|
|
}
|
|
|
|
export interface GameConfigType {
|
|
leveling: LevelingConfig;
|
|
economy: EconomyConfig;
|
|
inventory: InventoryConfig;
|
|
commands: Record<string, boolean>;
|
|
lootdrop: LootdropConfig;
|
|
trivia: TriviaConfig;
|
|
moderation: ModerationConfig;
|
|
system: Record<string, unknown>;
|
|
studentRole: string;
|
|
visitorRole: string;
|
|
colorRoles: string[];
|
|
welcomeChannelId?: string;
|
|
welcomeMessage?: string;
|
|
feedbackChannelId?: string;
|
|
terminal?: {
|
|
channelId: string;
|
|
messageId: string;
|
|
};
|
|
}
|
|
|
|
export const config: GameConfigType = {} as GameConfigType;
|
|
|
|
const bigIntSchema = z.union([z.string(), z.number(), z.bigint()])
|
|
.refine((val) => {
|
|
try {
|
|
BigInt(val);
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}, { message: "Must be a valid integer" })
|
|
.transform((val) => BigInt(val));
|
|
|
|
const fileConfigSchema = z.object({
|
|
leveling: z.object({
|
|
base: z.number(),
|
|
exponent: z.number(),
|
|
chat: z.object({
|
|
cooldownMs: z.number(),
|
|
minXp: z.number(),
|
|
maxXp: z.number(),
|
|
})
|
|
}),
|
|
economy: z.object({
|
|
daily: z.object({
|
|
amount: bigIntSchema,
|
|
streakBonus: bigIntSchema,
|
|
weeklyBonus: bigIntSchema.default(50n),
|
|
cooldownMs: z.number(),
|
|
}),
|
|
transfers: z.object({
|
|
allowSelfTransfer: z.boolean(),
|
|
minAmount: bigIntSchema,
|
|
}),
|
|
exam: z.object({
|
|
multMin: z.number(),
|
|
multMax: z.number(),
|
|
})
|
|
}),
|
|
inventory: z.object({
|
|
maxStackSize: bigIntSchema,
|
|
maxSlots: z.number(),
|
|
}),
|
|
commands: z.record(z.string(), z.boolean()),
|
|
lootdrop: z.object({
|
|
activityWindowMs: z.number(),
|
|
minMessages: z.number(),
|
|
spawnChance: z.number(),
|
|
cooldownMs: z.number(),
|
|
reward: z.object({
|
|
min: z.number(),
|
|
max: z.number(),
|
|
currency: z.string(),
|
|
})
|
|
}),
|
|
studentRole: z.string(),
|
|
visitorRole: z.string(),
|
|
colorRoles: z.array(z.string()).default([]),
|
|
welcomeChannelId: z.string().optional(),
|
|
welcomeMessage: z.string().optional(),
|
|
feedbackChannelId: z.string().optional(),
|
|
terminal: z.object({
|
|
channelId: z.string(),
|
|
messageId: z.string()
|
|
}).optional(),
|
|
moderation: z.object({
|
|
prune: z.object({
|
|
maxAmount: z.number().default(100),
|
|
confirmThreshold: z.number().default(50),
|
|
batchSize: z.number().default(100),
|
|
batchDelayMs: z.number().default(1000)
|
|
}),
|
|
cases: z.object({
|
|
dmOnWarn: z.boolean().default(true),
|
|
logChannelId: z.string().optional(),
|
|
autoTimeoutThreshold: z.number().optional()
|
|
})
|
|
}).default({
|
|
prune: {
|
|
maxAmount: 100,
|
|
confirmThreshold: 50,
|
|
batchSize: 100,
|
|
batchDelayMs: 1000
|
|
},
|
|
cases: {
|
|
dmOnWarn: true
|
|
}
|
|
}),
|
|
trivia: z.object({
|
|
entryFee: bigIntSchema,
|
|
rewardMultiplier: z.number().min(0).max(10),
|
|
timeoutSeconds: z.number().min(5).max(300),
|
|
cooldownMs: z.number().min(0),
|
|
categories: z.array(z.number()).default([]),
|
|
difficulty: z.enum(['easy', 'medium', 'hard', 'random']).default('random'),
|
|
}).default({
|
|
entryFee: 50n,
|
|
rewardMultiplier: 1.8,
|
|
timeoutSeconds: 30,
|
|
cooldownMs: 60000,
|
|
categories: [],
|
|
difficulty: 'random'
|
|
}),
|
|
system: z.record(z.string(), z.any()).default({}),
|
|
});
|
|
|
|
type FileConfig = z.infer<typeof fileConfigSchema>;
|
|
|
|
function loadFromFile(): FileConfig | null {
|
|
if (!existsSync(configPath)) {
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
const raw = readFileSync(configPath, 'utf-8');
|
|
const rawConfig = JSON.parse(raw);
|
|
return fileConfigSchema.parse(rawConfig);
|
|
} catch (error) {
|
|
console.error("Failed to load config from file:", error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function applyFileConfig(fileConfig: FileConfig) {
|
|
Object.assign(config, {
|
|
leveling: fileConfig.leveling,
|
|
economy: fileConfig.economy,
|
|
inventory: fileConfig.inventory,
|
|
commands: fileConfig.commands,
|
|
lootdrop: fileConfig.lootdrop,
|
|
trivia: fileConfig.trivia,
|
|
moderation: fileConfig.moderation,
|
|
system: fileConfig.system,
|
|
studentRole: fileConfig.studentRole,
|
|
visitorRole: fileConfig.visitorRole,
|
|
colorRoles: fileConfig.colorRoles,
|
|
welcomeChannelId: fileConfig.welcomeChannelId,
|
|
welcomeMessage: fileConfig.welcomeMessage,
|
|
feedbackChannelId: fileConfig.feedbackChannelId,
|
|
terminal: fileConfig.terminal,
|
|
});
|
|
}
|
|
|
|
async function loadFromDatabase(): Promise<boolean> {
|
|
try {
|
|
const { gameSettingsService } = await import('@shared/modules/game-settings/game-settings.service');
|
|
const dbSettings = await gameSettingsService.getSettings();
|
|
|
|
if (dbSettings) {
|
|
Object.assign(config, {
|
|
leveling: {
|
|
...dbSettings.leveling,
|
|
},
|
|
economy: {
|
|
daily: {
|
|
...dbSettings.economy.daily,
|
|
amount: BigInt(dbSettings.economy.daily.amount),
|
|
streakBonus: BigInt(dbSettings.economy.daily.streakBonus),
|
|
weeklyBonus: BigInt(dbSettings.economy.daily.weeklyBonus),
|
|
},
|
|
transfers: {
|
|
...dbSettings.economy.transfers,
|
|
minAmount: BigInt(dbSettings.economy.transfers.minAmount),
|
|
},
|
|
exam: dbSettings.economy.exam,
|
|
},
|
|
inventory: {
|
|
...dbSettings.inventory,
|
|
maxStackSize: BigInt(dbSettings.inventory.maxStackSize),
|
|
},
|
|
commands: dbSettings.commands,
|
|
lootdrop: dbSettings.lootdrop,
|
|
trivia: {
|
|
...dbSettings.trivia,
|
|
entryFee: BigInt(dbSettings.trivia.entryFee),
|
|
},
|
|
moderation: dbSettings.moderation,
|
|
system: dbSettings.system,
|
|
});
|
|
console.log("🎮 Game config loaded from database.");
|
|
return true;
|
|
}
|
|
} catch (error) {
|
|
console.error("Failed to load game config from database:", error);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
export async function reloadConfig(): Promise<void> {
|
|
const dbLoaded = await loadFromDatabase();
|
|
|
|
if (!dbLoaded) {
|
|
const fileConfig = loadFromFile();
|
|
if (fileConfig) {
|
|
applyFileConfig(fileConfig);
|
|
console.log("📄 Game config loaded from file (database not available).");
|
|
} else {
|
|
console.warn("⚠️ No game config found in database or file. Using defaults.");
|
|
const { gameSettingsService } = await import('@shared/modules/game-settings/game-settings.service');
|
|
const defaults = gameSettingsService.getDefaults();
|
|
Object.assign(config, {
|
|
leveling: defaults.leveling,
|
|
economy: {
|
|
...defaults.economy,
|
|
daily: {
|
|
...defaults.economy.daily,
|
|
amount: BigInt(defaults.economy.daily.amount),
|
|
streakBonus: BigInt(defaults.economy.daily.streakBonus),
|
|
weeklyBonus: BigInt(defaults.economy.daily.weeklyBonus),
|
|
},
|
|
transfers: {
|
|
...defaults.economy.transfers,
|
|
minAmount: BigInt(defaults.economy.transfers.minAmount),
|
|
},
|
|
},
|
|
inventory: {
|
|
...defaults.inventory,
|
|
maxStackSize: BigInt(defaults.inventory.maxStackSize),
|
|
},
|
|
commands: defaults.commands,
|
|
lootdrop: defaults.lootdrop,
|
|
trivia: {
|
|
...defaults.trivia,
|
|
entryFee: BigInt(defaults.trivia.entryFee),
|
|
},
|
|
moderation: defaults.moderation,
|
|
system: defaults.system,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export function loadFileSync(): void {
|
|
const fileConfig = loadFromFile();
|
|
if (fileConfig) {
|
|
applyFileConfig(fileConfig);
|
|
console.log("📄 Game config loaded from file (sync).");
|
|
}
|
|
}
|
|
|
|
export const GameConfig = config;
|
|
|
|
export function saveConfig(newConfig: unknown) {
|
|
const validatedConfig = fileConfigSchema.parse(newConfig);
|
|
const jsonString = JSON.stringify(validatedConfig, jsonReplacer, 4);
|
|
writeFileSync(configPath, jsonString, 'utf-8');
|
|
applyFileConfig(validatedConfig);
|
|
console.log("🔄 Config saved to file.");
|
|
}
|
|
|
|
export function toggleCommand(commandName: string, enabled: boolean) {
|
|
const fileConfig = loadFromFile();
|
|
if (!fileConfig) {
|
|
console.error("Cannot toggle command: no file config available");
|
|
return;
|
|
}
|
|
|
|
const newConfig = {
|
|
...fileConfig,
|
|
commands: {
|
|
...fileConfig.commands,
|
|
[commandName]: enabled
|
|
}
|
|
};
|
|
saveConfig(newConfig);
|
|
}
|
|
|
|
export async function initializeConfig(): Promise<void> {
|
|
loadFileSync();
|
|
await reloadConfig();
|
|
}
|
|
|
|
loadFileSync();
|