idlerpg.sh 0.1.0

package/dist/core/types.d.ts

@@ -0,0 +1,780 @@
+/**
+ * Core game type definitions
+ */
+/**
+ * Actor stats - the stats for a single character
+ * (Note: PlayerStats is kept as an alias for backward compatibility)
+ */
+export interface ActorStats {
+    level: number;
+    hp: number;
+    maxHp: number;
+    mp: number;
+    maxMp: number;
+    attack: number;
+    defense: number;
+    speed: number;
+    exp: number;
+    expToNextLevel: number;
+    gold: number;
+}
+export type PlayerStats = ActorStats;
+/**
+ * Actor character customization - similar to NPC traits
+ */
+export interface ActorCharacter {
+    backstory: string;
+    appearance: string;
+    personality: string;
+    motivation: string;
+    origin: string;
+    traits: string[];
+}
+export type PlayerCharacter = ActorCharacter;
+/**
+ * Actor status - whether they can participate in combat
+ */
+export type ActorStatus = 'active' | 'reserve' | 'injured' | 'dead';
+/**
+ * Actor role in the team - affects AI behavior and formation
+ */
+export type ActorRole = 'tank' | 'dps' | 'healer' | 'support' | 'balanced';
+/**
+ * AI settings for auto-battle behavior
+ */
+export interface ActorAISettings {
+    autoAttack: boolean;
+    useSkills: boolean;
+    targetPriority: 'nearest' | 'lowest_hp' | 'highest_damage' | 'random';
+    healThreshold: number;
+    retreatThreshold: number;
+}
+/**
+ * Actor (character) - represents a single playable character
+ * Multiple Actors form a Team
+ */
+export interface Actor {
+    id: string;
+    name: string;
+    stats: ActorStats;
+    position: Position;
+    equipment: Equipment;
+    inventory: InventoryItem[];
+    activeQuests: Quest[];
+    completedQuests: string[];
+    discoveredLocations: string[];
+    unlockedAffixes: string[];
+    createdAt: number;
+    playTime: number;
+    character?: ActorCharacter;
+    status: ActorStatus;
+    teamId?: string;
+    role: ActorRole;
+    aiSettings: ActorAISettings;
+}
+/**
+ * Legacy Player interface - kept for backward compatibility
+ * New code should use Actor interface
+ */
+export interface Player {
+    id: string;
+    name: string;
+    stats: PlayerStats;
+    position: Position;
+    equipment: Equipment;
+    inventory: InventoryItem[];
+    activeQuests: Quest[];
+    completedQuests: string[];
+    discoveredLocations: string[];
+    unlockedAffixes: string[];
+    createdAt: number;
+    playTime: number;
+    character?: PlayerCharacter;
+}
+/**
+ * Team formation - affects damage distribution
+ */
+export type TeamFormation = 'line' | 'wedge' | 'defensive' | 'spread';
+/**
+ * Formation effects configuration
+ * frontline: actor indices that are in front
+ * backline: actor indices that are protected
+ * damage: damage multiplier for each position (0=leader, 1-3=members)
+ */
+export interface FormationConfig {
+    frontline: number[];
+    backline: number[];
+    damage: number[];
+}
+/**
+ * Pre-defined formation effects
+ */
+export declare const FORMATION_EFFECTS: Record<TeamFormation, FormationConfig>;
+/**
+ * Team - a group of up to 4 active characters
+ */
+export interface Team {
+    id: string;
+    name: string;
+    activeMembers: string[];
+    reserveMembers: string[];
+    sharedInventory: InventoryItem[];
+    sharedGold: number;
+    position: Position;
+    currentLocation: CurrentLocation;
+    formation: TeamFormation;
+    strategy: StrategyStateMachine;
+    createdAt: number;
+    totalPlayTime: number;
+}
+/**
+ * Account-level statistics
+ */
+export interface AccountStats {
+    totalPlayTime: number;
+    actorsCreated: number;
+    teamsCreated: number;
+    totalDungeonsCleared: number;
+    totalEnemiesKilled: number;
+    totalGoldEarned: number;
+    totalDeaths: number;
+    highestActorLevel: number;
+}
+/**
+ * Global unlocks that persist across all actors/teams
+ */
+export interface GlobalUnlocks {
+    unlockedContinents: string[];
+    unlockedClasses: string[];
+    unlockedAffixes: string[];
+    achievements: string[];
+}
+/**
+ * Player Account - manages all actors and teams
+ * This is the top-level entity for a player's save data
+ */
+export interface PlayerAccount {
+    id: string;
+    accountName: string;
+    actors: Record<string, Actor>;
+    teams: Record<string, Team>;
+    activeTeamId: string | null;
+    accountStats: AccountStats;
+    settings: GameSettings;
+    globalUnlocks: GlobalUnlocks;
+    createdAt: number;
+    lastPlayedAt: number;
+}
+/**
+ * Entry in the turn order for team combat
+ */
+export interface CombatTurnEntry {
+    type: 'actor' | 'enemy';
+    id: string;
+    name: string;
+    speed: number;
+    isActive: boolean;
+}
+/**
+ * Team combat state - tracks HP for all team members
+ */
+export interface TeamCombatState {
+    isActive: boolean;
+    turn: number;
+    actorHp: Record<string, number>;
+    actorMp: Record<string, number>;
+    enemies: Enemy[];
+    turnOrder: CombatTurnEntry[];
+    currentTurnIndex: number;
+    combatType: 'mob' | 'elite' | 'boss' | 'ambush';
+    log: CombatLogEntry[];
+    startTime: number;
+    estimatedEndTime: number;
+}
+export interface Equipment {
+    weapon: Weapon | null;
+    armor: Armor | null;
+    accessory: Accessory | null;
+}
+export interface Weapon {
+    id: string;
+    name: string;
+    description: string;
+    lore?: string;
+    baseAttack: number;
+    durability: number;
+    maxDurability: number;
+    affixes: AppliedAffix[];
+    rarity: Rarity;
+    generatedByAI: boolean;
+}
+export interface Armor {
+    id: string;
+    name: string;
+    description: string;
+    baseDefense: number;
+    durability: number;
+    maxDurability: number;
+    affixes: AppliedAffix[];
+    rarity: Rarity;
+}
+export interface Accessory {
+    id: string;
+    name: string;
+    description: string;
+    effect: string;
+    affixes: AppliedAffix[];
+    rarity: Rarity;
+}
+export interface InventoryItem {
+    id: string;
+    type: 'weapon' | 'armor' | 'accessory' | 'consumable' | 'material' | 'affix_fragment';
+    name: string;
+    description: string;
+    quantity: number;
+    data?: unknown;
+}
+export type Rarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
+export type AffixType = 'prefix' | 'suffix' | 'legendary';
+export interface AffixDefinition {
+    id: string;
+    name: string;
+    description: string;
+    type: AffixType;
+    rarity: Rarity;
+    statModifiers?: Partial<StatModifiers>;
+    onHitEffects?: OnHitEffect[];
+    passiveEffects?: PassiveEffect[];
+    incompatibleWith?: string[];
+    requiresLevel?: number;
+    isBuiltIn: boolean;
+    pluginPath?: string;
+}
+export interface AppliedAffix {
+    definitionId: string;
+    name: string;
+    type: AffixType;
+    rarity: Rarity;
+}
+export interface StatModifiers {
+    attack: number;
+    defense: number;
+    speed: number;
+    maxHp: number;
+    maxMp: number;
+    critChance: number;
+    critDamage: number;
+    lifesteal: number;
+}
+export interface OnHitEffect {
+    type: 'damage' | 'heal' | 'status' | 'custom';
+    element?: 'fire' | 'ice' | 'lightning' | 'poison' | 'dark' | 'holy';
+    value: number;
+    chance: number;
+    duration?: number;
+}
+export interface PassiveEffect {
+    type: 'regen' | 'aura' | 'trigger' | 'custom';
+    description: string;
+    value: number;
+}
+export interface Position {
+    x: number;
+    y: number;
+    floor: number;
+}
+export type RoomType = 'empty' | 'combat' | 'shop' | 'treasure' | 'event' | 'boss' | 'rest' | 'town' | 'dungeon_entrance';
+export interface Room {
+    id: string;
+    type: RoomType;
+    position: Position;
+    name: string;
+    description: string;
+    isExplored: boolean;
+    isCleared: boolean;
+    connections: string[];
+    enemies?: Enemy[];
+    npcs?: NPC[];
+    items?: InventoryItem[];
+    events?: GameEvent[];
+}
+export type GameMapType = 'town' | 'dungeon';
+export interface GameMap {
+    id: string;
+    name: string;
+    type: GameMapType;
+    floor: number;
+    rooms: Map<string, Room>;
+    startRoomId: string;
+    bossRoomId?: string;
+    generatedAt: number;
+}
+export interface Enemy {
+    id: string;
+    name: string;
+    level: number;
+    hp: number;
+    maxHp: number;
+    attack: number;
+    defense: number;
+    speed: number;
+    expReward: number;
+    goldReward: number;
+    dropTable: DropTableEntry[];
+    abilities?: EnemyAbility[];
+    isBoss: boolean;
+}
+export interface DropTableEntry {
+    itemId: string;
+    chance: number;
+    quantity: {
+        min: number;
+        max: number;
+    };
+}
+export interface EnemyAbility {
+    name: string;
+    damage: number;
+    cooldown: number;
+    currentCooldown: number;
+    statusEffect?: string;
+}
+export type CombatStrategy = 'aggressive' | 'defensive' | 'balanced' | 'skill_focus';
+export interface CombatState {
+    isActive: boolean;
+    turn: number;
+    playerHp: number;
+    enemies: Enemy[];
+    log: CombatLogEntry[];
+    strategy: CombatStrategy;
+    startTime: number;
+    estimatedEndTime: number;
+}
+export interface CombatLogEntry {
+    timestamp: number;
+    message: string;
+    type: 'damage' | 'heal' | 'status' | 'system';
+}
+export type NPCType = 'merchant' | 'sage' | 'guard' | 'traveler' | 'blacksmith' | 'quest_giver';
+export interface NPC {
+    id: string;
+    name: string;
+    type: NPCType;
+    description: string;
+    systemPrompt: string;
+    dialogHistory: DialogEntry[];
+    inventory?: InventoryItem[];
+    quests?: string[];
+}
+export interface DialogEntry {
+    role: 'player' | 'npc';
+    content: string;
+    timestamp: number;
+}
+export type QuestType = 'explore' | 'combat' | 'collect' | 'dialog' | 'escort' | 'boss';
+export type QuestStatus = 'available' | 'active' | 'completed' | 'failed';
+export interface Quest {
+    id: string;
+    name: string;
+    description: string;
+    type: QuestType;
+    status: QuestStatus;
+    objectives: QuestObjective[];
+    rewards: QuestReward[];
+    timeLimit?: number;
+    startTime?: number;
+    targetLocation?: string;
+}
+export interface QuestObjective {
+    id: string;
+    description: string;
+    type: 'kill' | 'collect' | 'reach' | 'talk' | 'survive';
+    target: string;
+    required: number;
+    current: number;
+    isComplete: boolean;
+}
+export interface QuestReward {
+    type: 'exp' | 'gold' | 'item' | 'affix';
+    value: number | string;
+    quantity?: number;
+}
+export type EventType = 'combat_start' | 'combat_end' | 'item_found' | 'npc_encounter' | 'quest_update' | 'level_up' | 'affix_discovered' | 'travel_event' | 'random_encounter';
+export interface GameEvent {
+    id: string;
+    type: EventType;
+    title: string;
+    description: string;
+    choices?: EventChoice[];
+    timestamp: number;
+    processed: boolean;
+}
+export interface EventChoice {
+    id: string;
+    text: string;
+    consequence: string;
+    effect: EventEffect;
+}
+export interface EventEffect {
+    type: 'reward' | 'damage' | 'heal' | 'trigger_combat' | 'trigger_dialog' | 'none';
+    value?: number | string;
+}
+export type GamePhase = 'menu' | 'exploring' | 'traveling' | 'combat' | 'dialog' | 'inventory' | 'quest_log' | 'affix_workshop' | 'game_over';
+export interface GameState {
+    phase: GamePhase;
+    player: Player;
+    currentMap: GameMap;
+    currentRoom: Room;
+    combat?: CombatState;
+    activeDialog?: {
+        npc: NPC;
+        isStreaming: boolean;
+    };
+    pendingEvents: GameEvent[];
+    travelState?: TravelState;
+    gameTime: number;
+    lastUpdateTime: number;
+    isPaused: boolean;
+}
+export interface TravelState {
+    fromRoomId: string;
+    toRoomId: string;
+    startTime: number;
+    duration: number;
+    progress: number;
+    events: GameEvent[];
+}
+export interface SaveData {
+    version: string;
+    timestamp: number;
+    player: Player;
+    currentMapId: string;
+    currentRoomId: string;
+    discoveredMaps: string[];
+    gameTime: number;
+    settings: GameSettings;
+}
+export interface GameSettings {
+    language: string;
+    autoSave: boolean;
+    autoSaveInterval: number;
+    combatSpeed: number;
+    soundEnabled: boolean;
+}
+/**
+ * A continent containing multiple towns and dungeons
+ */
+export interface Continent {
+    id: string;
+    name: string;
+    description: string;
+    towns: Town[];
+    dungeons: Dungeon[];
+    connections: ContinentConnection[];
+    unlockedAt?: number;
+    imageUrl?: string;
+}
+/**
+ * Connection between continents (for future expansion)
+ */
+export interface ContinentConnection {
+    targetContinentId: string;
+    travelTime: number;
+    requiresItem?: string;
+    requiresQuestComplete?: string;
+}
+/**
+ * A town with various facilities
+ */
+export interface Town {
+    id: string;
+    name: string;
+    description: string;
+    continentId: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    facilities: TownFacility[];
+    npcs: string[];
+    unlockedAt?: number;
+    connectedTowns: TownConnection[];
+    connectedDungeons: string[];
+}
+/**
+ * Connection between towns
+ */
+export interface TownConnection {
+    targetTownId: string;
+    travelTime: number;
+    dangerLevel: number;
+}
+/**
+ * Facilities available in a town
+ */
+export interface TownFacility {
+    type: TownFacilityType;
+    name: string;
+    description: string;
+    npcId?: string;
+    isUnlocked: boolean;
+}
+export type TownFacilityType = 'inn' | 'shop' | 'blacksmith' | 'tavern' | 'guild' | 'temple' | 'bank' | 'arena';
+/**
+ * A dungeon with multiple levels
+ */
+export interface Dungeon {
+    id: string;
+    name: string;
+    description: string;
+    continentId: string;
+    nearestTownId: string;
+    difficulty: DungeonDifficulty;
+    recommendedLevel: number;
+    levels: DungeonLevel[];
+    hasBoss: boolean;
+    bossName?: string;
+    estimatedTime: number;
+    unlockedAt?: number;
+    rewards: DungeonReward[];
+    travelTimeFromTown: number;
+}
+export type DungeonDifficulty = 'easy' | 'normal' | 'hard' | 'nightmare' | 'legendary';
+export interface DungeonReward {
+    type: 'exp' | 'gold' | 'item' | 'affix' | 'unlock';
+    value: number | string;
+    chance: number;
+}
+/**
+ * A level within a dungeon
+ */
+export interface DungeonLevel {
+    levelNumber: number;
+    name?: string;
+    rooms: DungeonRoom[];
+    entranceRoomId: string;
+    exitRoomId: string;
+    bossRoomId?: string;
+    minEnemyLevel: number;
+    maxEnemyLevel: number;
+}
+/**
+ * A room within a dungeon level
+ */
+export interface DungeonRoom {
+    id: string;
+    type: DungeonRoomType;
+    name: string;
+    description: string;
+    connections: RoomConnection[];
+    content: DungeonRoomContent;
+    timeToTraverse: number;
+    isExplored: boolean;
+    isCleared: boolean;
+    position: {
+        x: number;
+        y: number;
+    };
+}
+export type DungeonRoomType = 'entrance' | 'exit' | 'dead_end' | 'safe_room' | 'combat' | 'elite' | 'boss' | 'ambush' | 'treasure' | 'fountain' | 'altar' | 'shop' | 'event' | 'encounter' | 'trap' | 'puzzle' | 'rest' | 'empty';
+export interface RoomConnection {
+    targetRoomId: string;
+    direction: 'north' | 'south' | 'east' | 'west' | 'up' | 'down';
+    isLocked: boolean;
+    keyRequired?: string;
+    isHidden: boolean;
+}
+export interface DungeonRoomContent {
+    enemies?: Enemy[];
+    items?: InventoryItem[];
+    event?: GameEvent;
+    npc?: NPC;
+    trap?: TrapData;
+    puzzle?: PuzzleData;
+    treasureChest?: TreasureChest;
+}
+export interface TrapData {
+    id: string;
+    name: string;
+    damage: number;
+    effect?: string;
+    disarmDifficulty: number;
+    isTriggered: boolean;
+    isDisarmed: boolean;
+}
+export interface PuzzleData {
+    id: string;
+    name: string;
+    description: string;
+    difficulty: number;
+    reward: InventoryItem | number;
+    isSolved: boolean;
+}
+export interface TreasureChest {
+    id: string;
+    rarity: Rarity;
+    isOpened: boolean;
+    isLocked: boolean;
+    keyRequired?: string;
+    contents: InventoryItem[];
+    goldAmount: number;
+}
+/**
+ * Complete strategy state machine for AI-controlled gameplay
+ */
+export interface StrategyStateMachine {
+    combat: CombatStrategyConfig;
+    exploration: ExplorationStrategy;
+    resource: ResourceStrategy;
+    encounter: EncounterStrategy;
+}
+/**
+ * Combat strategy configuration (renamed from CombatStrategy to avoid conflict)
+ */
+export interface CombatStrategyConfig {
+    targetPriority: TargetPriority[];
+    itemUsage: ItemUsageRule[];
+    retreatCondition: RetreatCondition;
+    skillPriority: string[];
+    focusTarget: 'highest_damage' | 'lowest_hp' | 'highest_threat' | 'random';
+}
+export type TargetPriority = 'healer' | 'ranged' | 'caster' | 'tank' | 'lowest_hp' | 'highest_damage' | 'boss' | 'minion';
+export interface ItemUsageRule {
+    itemType: 'health_potion' | 'mana_potion' | 'buff' | 'debuff' | 'revive';
+    condition: 'hp_below' | 'mp_below' | 'status_effect' | 'enemy_count' | 'turn_count';
+    threshold: number;
+    priority: number;
+}
+export interface RetreatCondition {
+    enabled: boolean;
+    hpThreshold: number;
+    partyWipeRisk: boolean;
+    bossExempt: boolean;
+}
+/**
+ * Exploration strategy for dungeon navigation
+ */
+export interface ExplorationStrategy {
+    roomPriority: RoomPriority[];
+    deadEndBehavior: DeadEndBehavior;
+    treasureHunting: boolean;
+    thoroughExploration: boolean;
+    avoidTraps: boolean;
+    avoidElites: boolean;
+    restThreshold: number;
+}
+export type RoomPriority = 'combat' | 'treasure' | 'event' | 'shop' | 'rest' | 'exit';
+export type DeadEndBehavior = 'retreat_immediately' | 'search_thoroughly' | 'rest_if_needed';
+/**
+ * Resource management strategy
+ */
+export interface ResourceStrategy {
+    hpThreshold: number;
+    hpAction: ResourceAction;
+    mpThreshold: number;
+    mpAction: ResourceAction;
+    goldReserve: number;
+    sellJunk: boolean;
+    repairThreshold: number;
+}
+export type ResourceAction = 'use_item' | 'rest' | 'retreat_to_town' | 'continue';
+/**
+ * Encounter strategy for NPCs and events
+ */
+export interface EncounterStrategy {
+    npcBehavior: NPCBehavior;
+    eventRiskTolerance: number;
+    acceptQuests: boolean;
+    shopBehavior: ShopBehavior;
+}
+export type NPCBehavior = 'always_talk' | 'quest_givers_only' | 'skip';
+export type ShopBehavior = 'buy_upgrades' | 'sell_only' | 'buy_consumables' | 'skip';
+/**
+ * Extended game phase for IdleRPG mechanics
+ */
+export type IdleGamePhase = 'in_town' | 'traveling' | 'in_dungeon' | 'combat' | 'returning' | 'resting' | 'shopping' | 'dialog';
+/**
+ * Current player location
+ */
+export interface CurrentLocation {
+    type: 'town' | 'dungeon' | 'traveling' | 'world_map';
+    continentId: string;
+    townId?: string;
+    dungeonId?: string;
+    levelNumber?: number;
+    roomId?: string;
+}
+/**
+ * Active dungeon exploration state
+ */
+export interface ActiveDungeonState {
+    dungeonId: string;
+    currentLevel: number;
+    currentRoomId: string;
+    strategy: StrategyStateMachine;
+    exploredRooms: string[];
+    clearedRooms: string[];
+    startTime: number;
+    elapsedTime: number;
+    lootCollected: InventoryItem[];
+    goldCollected: number;
+    expGained: number;
+    enemiesKilled: number;
+    floorsCleared: number;
+}
+/**
+ * Represents an action that takes real time to complete
+ */
+export interface TimeAction {
+    id: string;
+    type: TimeActionType;
+    description: string;
+    startTime: number;
+    duration: number;
+    progress: number;
+    isPaused: boolean;
+    canCancel: boolean;
+    onComplete?: string;
+    data?: Record<string, unknown>;
+}
+export type TimeActionType = 'travel' | 'combat' | 'combat_turn' | 'rest' | 'craft' | 'repair' | 'train' | 'explore_room' | 'search' | 'dialog';
+/**
+ * Extended save data for IdleRPG features
+ */
+export interface IdleSaveData extends SaveData {
+    currentLocation: CurrentLocation;
+    activeDungeon?: ActiveDungeonState;
+    strategy?: StrategyStateMachine;
+    worldState: WorldState;
+    statistics: GameStatistics;
+}
+/**
+ * World state tracking unlocks and progress
+ */
+export interface WorldState {
+    unlockedContinents: string[];
+    unlockedTowns: string[];
+    unlockedDungeons: string[];
+    clearedDungeons: string[];
+    completedQuests: string[];
+    discoveredNPCs: string[];
+    reputations: Record<string, number>;
+}
+/**
+ * Player statistics
+ */
+export interface GameStatistics {
+    totalPlayTime: number;
+    dungeonsCleared: number;
+    dungeonsAttempted: number;
+    enemiesKilled: number;
+    bossesKilled: number;
+    totalGoldEarned: number;
+    totalGoldSpent: number;
+    itemsCollected: number;
+    questsCompleted: number;
+    deathCount: number;
+    longestDungeonRun: number;
+    fastestBossClear: Record<string, number>;
+}
+//# sourceMappingURL=types.d.ts.map