commit d4b99a0f3c92f3dc066c3cc3f3ea2b6be09b4f95 Author: Denis Ranneft Date: Sun Mar 29 18:45:43 2026 +0300 initial diff --git a/.claude/agent-memory/backend-engineer-go/MEMORY.md b/.claude/agent-memory/backend-engineer-go/MEMORY.md new file mode 100644 index 0000000..9ac1bc9 --- /dev/null +++ b/.claude/agent-memory/backend-engineer-go/MEMORY.md @@ -0,0 +1,6 @@ +- [Backend skeleton](project_backend_skeleton.md) — Go backend created 2026-03-27: engine, combat, models, REST+WS, storage, Docker, migration +- [Offline simulator](project_offline_simulator.md) — Real background OfflineSimulator replaces fake retroactive simulateOffline; game/offline.go owns combat logic +- [Quest and unified gear](project_quest_equipment.md) — Quest system; unified gear table (migration 000014) replacing weapons/armor/equipment_items with single GearItem model +- [Achievements, tasks, world](project_achievements_tasks_world.md) — 9 achievements, 7 daily/weekly tasks, shared world nearby-heroes; migration 000011 +- [NPC encounters](project_npc_encounters.md) — handler/npc.go, 5 endpoints, wandering merchant in encounters, towns in InitHero, migration 000012 +- [Server-authoritative Phase 1](project_server_authoritative.md) — WSEnvelope protocol, movement system, RoadGraph, combat push, MessageSender interface; migration 000013 diff --git a/.claude/agent-memory/backend-engineer-go/project_achievements_tasks_world.md b/.claude/agent-memory/backend-engineer-go/project_achievements_tasks_world.md new file mode 100644 index 0000000..6cdc588 --- /dev/null +++ b/.claude/agent-memory/backend-engineer-go/project_achievements_tasks_world.md @@ -0,0 +1,21 @@ +--- +name: Achievements, Daily Tasks, and Shared World +description: Achievement system, daily/weekly task system, and shared world foundation added 2026-03-27 +type: project +--- + +Achievements, daily/weekly tasks, and shared world presence added in migration 000011. + +**Achievements**: 9 seeded achievements tracked via hero stat columns (total_kills, elite_kills, total_deaths, kills_since_death, legendary_drops). CheckAndUnlock runs after every kill in processVictoryRewards. Rewards auto-applied (gold/potions). +**Why:** Spec sections 10.3, player engagement loop. +**How to apply:** New achievement conditions require adding to model.CheckAchievementCondition and seeding in migration. + +**Daily/Weekly Tasks**: 4 daily + 3 weekly tasks. Lazy initialization via EnsureHeroTasks on first access each period. Progress incremented in processVictoryRewards (kill_count, elite_kill, collect_gold) and ActivateBuff (use_buff). Period boundaries: daily=UTC midnight, weekly=Monday UTC. +**Why:** Spec sections 10.1, 10.2. +**How to apply:** New objective types need handler hooks and DailyTaskStore.IncrementTaskProgress calls. + +**Shared World**: last_online_at column + idx_heroes_online index. UpdateOnlineStatus called on ReportVictory. GetNearbyHeroes uses Euclidean distance with 2-min freshness cutoff. +**Why:** Spec section 2.3. +**How to apply:** Any endpoint where the hero is "active" should call UpdateOnlineStatus or set LastOnlineAt. + +Key files: storage/achievement_store.go, storage/daily_task_store.go, handler/achievement.go, handler/daily_task.go, model/achievement.go, model/daily_task.go. diff --git a/.claude/agent-memory/backend-engineer-go/project_backend_skeleton.md b/.claude/agent-memory/backend-engineer-go/project_backend_skeleton.md new file mode 100644 index 0000000..b9a0de2 --- /dev/null +++ b/.claude/agent-memory/backend-engineer-go/project_backend_skeleton.md @@ -0,0 +1,35 @@ +--- +name: Backend skeleton and wiring +description: Go backend structure as of 2026-03-27 — engine wired to real combat, auth middleware, CORS, camelCase JSON, new endpoints +type: project +--- + +Backend skeleton was created on 2026-03-27, with critical wiring fixes applied on 2026-03-28: + +- Module: `github.com/denisovdennis/autohero`, Go 1.23 +- Entry point: `backend/cmd/server/main.go` — config, DB/Redis connect, game engine, WS hub, HTTP server with graceful shutdown +- Config: env vars (DB_*, REDIS_ADDR, SERVER_PORT, BOT_TOKEN) with local dev defaults +- Models: Hero, Enemy (13 types + templates), Weapon (daggers/sword/axe), Armor (light/medium/heavy), Buff (8 types), Debuff (6 types), CombatState + AttackQueue (min-heap), Loot system +- All model JSON tags use camelCase (maxHp, telegramId, critChance, etc.) to match frontend expectations +- CombatState has a `Hero *Hero` field (json:"-") so engine can reference hero during combat +- Game engine: tick-based loop (100ms/10Hz), attack scheduling via container/heap, uses real ProcessAttack/ProcessEnemyAttack/CheckDeath from combat.go +- Engine handles hero death: emits "death" event, sets hero state to Dead, removes combat +- Combat: full damage pipeline with buffs/debuffs, crit, dodge, stun, shield, lifesteal, etc. +- Auth: `handler/auth.go` — Telegram initData HMAC-SHA256 validation, TelegramAuthMiddleware, POST /api/v1/auth/telegram +- Handlers: GET /health, GET /api/v1/hero, POST /api/v1/hero/buff/{buffType}, POST /api/v1/hero/revive, GET /api/v1/hero/loot, GET /api/v1/weapons, GET /api/v1/armor, GET /ws +- Router: `router.Deps` struct takes Engine, Hub, PgPool, BotToken, Logger. CORS middleware allows all origins (dev mode). +- Auth middleware is wired but commented out for dev convenience. +- Storage: pgx pool (20 max conns), go-redis client. pgPool passed to router deps. +- Hero model has: PositionX, PositionY (float64), Potions (int) — added 2026-03-27 +- HeroStore has SavePosition(ctx, heroID, x, y) for lightweight position updates +- LogStore (storage/log_store.go): Add(), GetRecent() for adventure_log table +- GameHandler constructor takes logStore as 3rd argument: NewGameHandler(engine, heroStore, logStore, worldSvc, logger) +- New endpoints: GET /api/v1/hero/log, POST /api/v1/hero/use-potion +- Loot system: 25% potion drop chance, potions heal 30% maxHP +- Offline simulation: uses potions when HP < 30%, tracks loot drops, generates detailed log +- Auto-equip: logs weapon/armor changes to adventure log +- Migration 000004: hero position_x/position_y, potions column, adventure_log table + +**Why:** First major wiring pass connects all backend systems end-to-end. Frontend can now hit all needed endpoints. + +**How to apply:** All new backend code should follow this package structure. The router.Deps pattern is the dependency injection point. Auth middleware can be re-enabled when BOT_TOKEN is provided. diff --git a/.claude/agent-memory/backend-engineer-go/project_npc_encounters.md b/.claude/agent-memory/backend-engineer-go/project_npc_encounters.md new file mode 100644 index 0000000..0d779d9 --- /dev/null +++ b/.claude/agent-memory/backend-engineer-go/project_npc_encounters.md @@ -0,0 +1,11 @@ +--- +name: NPC encounter system +description: NPC interaction endpoints, wandering merchant alms, towns in InitHero, bigger town radii — added 2026-03-27 +type: project +--- + +NPC encounter system added with handler/npc.go (NPCHandler) serving 5 new endpoints under /api/v1/hero/npc-*. + +**Why:** Frontend needs to render towns with NPCs on the map, allow hero interaction with quest_giver/merchant/healer NPCs, and support random wandering merchant encounters on the road. + +**How to apply:** NPC handler is separate from GameHandler; quest_store gained GetNPCByID, ListAllNPCs, ListQuestsByNPCForHeroLevel. InitHero response now includes "towns" field with nested NPCs. RequestEncounter has 10% NPC event roll. Migration 000012 increases town radii. diff --git a/.claude/agent-memory/backend-engineer-go/project_offline_simulator.md b/.claude/agent-memory/backend-engineer-go/project_offline_simulator.md new file mode 100644 index 0000000..5defc90 --- /dev/null +++ b/.claude/agent-memory/backend-engineer-go/project_offline_simulator.md @@ -0,0 +1,19 @@ +--- +name: Offline simulator architecture +description: Background OfflineSimulator in game/offline.go runs real server-side combat ticks for offline heroes; replaced fake retroactive simulateOffline +type: project +--- + +Real offline simulation system added 2026-03-27. Key decisions: + +- `game.OfflineSimulator` ticks every 30s, queries heroes with `state='walking'` and `updated_at < now - 1min` +- `game.SimulateOneFight` is the canonical single-fight function used by both simulator and catch-up +- `game.PickEnemyForLevel`, `game.ScaleEnemyTemplate`, `game.AutoEquipWeapon`, `game.AutoEquipArmor` were extracted from handler to game package (exported) +- handler's `pickEnemyForLevel`/`autoEquipWeapon`/`autoEquipArmor` now delegate to game package +- `catchUpOfflineGap` in handler covers server-down gap (hero.UpdatedAt to serverStartedAt) +- `buildOfflineReport` reads real adventure_log entries instead of generating fake ones +- `serverStartedAt` passed from main.go -> router.Deps -> GameHandler + +**Why:** Old simulateOffline generated fake events retroactively at login. New system writes real events to adventure_log as they happen. + +**How to apply:** When touching offline/idle combat, work in game/offline.go. The handler no longer owns combat simulation logic for offline heroes. diff --git a/.claude/agent-memory/backend-engineer-go/project_quest_equipment.md b/.claude/agent-memory/backend-engineer-go/project_quest_equipment.md new file mode 100644 index 0000000..5626d34 --- /dev/null +++ b/.claude/agent-memory/backend-engineer-go/project_quest_equipment.md @@ -0,0 +1,13 @@ +--- +name: Quest and unified gear systems +description: Quest system backend (towns/NPCs/quests/hero_quests) and unified gear system replacing weapons/armor/equipment_items +type: project +--- + +Quest system uses migration 000006 schema (towns, npcs, quests, hero_quests tables). Go layer: model/quest.go, storage/quest_store.go, handler/quest.go. Quest progress hooks in processVictoryRewards call IncrementQuestProgress for kill_count and IncrementCollectItemProgress for collect_item quests. + +Unified gear system (migration 000014): single `gear` + `hero_gear` tables replace weapons, armor, equipment_items, and hero_equipment. model/gear.go has GearItem, GearFamily, GearCatalog. storage/gear_store.go replaces equipment_store.go. weapon.go, armor.go deleted; equipment.go keeps only slot constants. Hero.Gear map[EquipmentSlot]*GearItem replaces Weapon/Armor fields. All loot drops use EquipmentSlot names (main_hand, chest, etc.). + +**Why:** ONE table, ONE model, ONE store for all equippable items -- simpler code, easier to add new slots. + +**How to apply:** NewGameHandler takes gearStore (not equipmentStore). NewNPCHandler takes gearStore. processVictoryRewards handles all slots uniformly. AutoEquipGear replaces AutoEquipWeapon/AutoEquipArmor. diff --git a/.claude/agent-memory/backend-engineer-go/project_server_authoritative.md b/.claude/agent-memory/backend-engineer-go/project_server_authoritative.md new file mode 100644 index 0000000..a962cc2 --- /dev/null +++ b/.claude/agent-memory/backend-engineer-go/project_server_authoritative.md @@ -0,0 +1,20 @@ +--- +name: Server-authoritative architecture Phase 1 +description: WSEnvelope protocol, server-owned movement system, combat push via WS, RoadGraph, hero lifecycle on connect/disconnect +type: project +--- + +Phase 1 of server-authoritative architecture implemented 2026-03-27. + +**Why:** Frontend becomes a pure renderer; all game logic (movement, combat, encounters) is owned by the backend to prevent cheating and enable consistent simulation. + +**How to apply:** +- All WS messages use `model.WSEnvelope` (type + json.RawMessage payload). Both server->client and client->server. +- `game.MessageSender` interface decouples engine from handler (avoids import cycle game<->handler). +- Engine now has 3 tickers: combat (100ms), movement (500ms/2Hz), position sync (10s). +- `game.HeroMovement` tracks per-hero walking state; created on WS connect, destroyed on disconnect. +- `game.RoadGraph` loaded from DB at startup; towns connected in linear chain with waypoints. +- Client commands (activate_buff, use_potion, revive) routed from hub.Incoming -> engine.IncomingCh. +- Hub has OnConnect/OnDisconnect callbacks wired in main.go. +- Migration 000013: hero movement columns + roads + road_waypoints tables. +- Offline simulator does NOT touch position/movement fields (per spec risk section 6). diff --git a/.claude/agent-memory/frontend-game-engineer/MEMORY.md b/.claude/agent-memory/frontend-game-engineer/MEMORY.md new file mode 100644 index 0000000..1fbb879 --- /dev/null +++ b/.claude/agent-memory/frontend-game-engineer/MEMORY.md @@ -0,0 +1,3 @@ +- [Frontend Skeleton Setup](project_frontend_skeleton.md) — PixiJS 8 + React 19 + Vite 6 scaffold, folder structure and async init pattern +- [Town Rendering & Equipment Slots](project_towns_equipment.md) — Town rendering on PixiJS map, extended equipment UI, daily tasks panel +- [Server-Authoritative Refactor](project_server_authoritative.md) — Engine gutted to pure renderer; all game logic via WS from server diff --git a/.claude/agent-memory/frontend-game-engineer/project_frontend_skeleton.md b/.claude/agent-memory/frontend-game-engineer/project_frontend_skeleton.md new file mode 100644 index 0000000..cb052a4 --- /dev/null +++ b/.claude/agent-memory/frontend-game-engineer/project_frontend_skeleton.md @@ -0,0 +1,15 @@ +--- +name: Frontend Skeleton Setup +description: Initial frontend scaffold created with PixiJS 8, React 19, Vite 6, TypeScript strict mode. Covers game engine, camera, renderer, WS client, REST API, HUD, buff bar, death screen, floating damage, Telegram SDK wrapper, Dockerfile + nginx. +type: project +--- + +Frontend skeleton was created on 2026-03-27 with this stack: +- PixiJS v8.6.6 (new Application API using `app.init()` async pattern) +- React 19, ReactDOM 19 +- Vite 6 with @vitejs/plugin-react +- TypeScript 5.7 strict mode + +**Why:** MVP scaffold to unblock parallel frontend/backend work per CLAUDE.md contract-first approach. + +**How to apply:** All future frontend work builds on this skeleton. The folder structure is `/game` (engine, renderer, camera, types), `/ui` (React HUD components), `/network` (WS + REST), `/shared` (constants, telegram wrapper). PixiJS 8 uses `new Application()` then `await app.init({...})` -- do NOT use the old v7 constructor pattern. diff --git a/.claude/agent-memory/frontend-game-engineer/project_server_authoritative.md b/.claude/agent-memory/frontend-game-engineer/project_server_authoritative.md new file mode 100644 index 0000000..fd9bf84 --- /dev/null +++ b/.claude/agent-memory/frontend-game-engineer/project_server_authoritative.md @@ -0,0 +1,18 @@ +--- +name: Server-Authoritative Architecture Refactor +description: Frontend gutted to pure renderer; all game logic (combat, walking, encounters) moved to server via WebSocket. Engine.ts is now state holder + render loop only. +type: project +--- + +Major architecture change completed 2026-03-27. + +The frontend is now a thin WebSocket client + PixiJS renderer: +- `engine.ts` holds server-provided state and runs the render loop (no simulation) +- `ws-handler.ts` bridges WS messages to engine methods and React UI callbacks +- Position interpolation: server sends hero_move at 2Hz, engine interpolates to 60fps +- All commands (buff, potion, revive, NPC interactions) sent via WS, not REST +- REST API kept for: initHero, getTowns, getHeroQuests, getAchievements, getDailyTasks, equipment + +**Why:** Server-authoritative model prevents cheating and enables shared-world features. Spec: `docs/spec-server-authoritative.md`. + +**How to apply:** When adding new game features, all logic goes server-side. Frontend only renders state from WS messages and sends user commands via WS. diff --git a/.claude/agent-memory/frontend-game-engineer/project_towns_equipment.md b/.claude/agent-memory/frontend-game-engineer/project_towns_equipment.md new file mode 100644 index 0000000..0245657 --- /dev/null +++ b/.claude/agent-memory/frontend-game-engineer/project_towns_equipment.md @@ -0,0 +1,72 @@ +--- +name: Town Rendering & Equipment Slots +description: Much bigger town buildings rendered via PixiJS Graphics on map, NPC rendering/interaction, wandering NPC encounters, extended equipment slots UI, daily tasks, achievements, nearby heroes, collision detection +type: project +--- + +Updated on 2026-03-27: + +**Towns on Map (enlarged in March 2026 update):** +- `GameRenderer.drawTowns()` draws large ground planes (tan/brown dirt ellipses), then clusters of 5-14 houses spread over ~100px radius +- Houses have 3 roof styles (pointed, flat, chimney), 2-3 windows, doors with knobs, optional fences and market stalls +- `_drawHouse()` accepts roofStyle parameter (0=pointed, 1=flat, 2=pointed+chimney) +- `_drawFence()` and `_drawTownStall()` add variety between houses +- Town border circle: `radius * TILE_WIDTH * 0.7` (was 0.35), scale factor: `radius / 8` (was /12) +- Town name label: 18px font (was 13px), positioned above house cluster +- House positions: deterministic pseudo-random from town.id for consistent layout +- `GameEngine.setTowns()` stores `TownData[]` and checks hero proximity each tick for enter/exit events +- Town data comes from `/towns` API, converted via `townToTownData()` in App.tsx +- `TownData` interface: id (number), centerX/centerY/radius/size, optional npcs: NPCData[] + +**NPC Rendering and Interaction (March 2026 update):** +- `NPCData` interface: id, name, type ('quest_giver'|'merchant'|'healer'), worldX, worldY +- `GameRenderer.drawNPCs()` renders type-specific colored diamonds with floating icons (!/$/ +) and name labels +- Quest givers: gold body, "!" icon; Merchants: green body, "$" icon; Healers: white body, "+" icon +- Idle sway animation based on NPC id +- `GameEngine.setNPCs()` stores all NPCs, `_checkNPCProximity()` fires `onNearestNPCChange` within 2 tiles +- `NPCInteraction.tsx`: floating panel appears when hero near NPC, type-specific action button +- App.tsx wires nearest NPC state, dismiss tracking, and opens NPCDialog for quest givers +- Town NPC fetching: `getTownNPCs()` for each town, NPCs positioned at town.worldX + npc.offsetX + +**Wandering NPC Encounter (March 2026 update):** +- `NPCEncounterEvent` type in types.ts: type, npcName, message, cost +- Encounter provider checks for `type: "npc_event"` response from `requestEncounter` +- `WanderingNPCPopup.tsx`: modal with accept/decline, calls `POST /api/v1/hero/npc-alms` +- `giveNPCAlms()` API returns hero + received item details + +**Extended Equipment (spec 6.3):** +- `EquipmentItem` interface with id/slot/formId/name/rarity/ilvl/primaryStat/statType +- `HeroState.equipment?: Record` optional map +- `HeroResponse.equipment` added to API types +- `HeroPanel` dynamically renders 5 display slots (main_hand, chest, head, feet, neck) with fallback to legacy weapon/armor fields +- `EquipmentPanel.tsx` -- compact 5-column grid with tap-to-expand detail, rarity-colored borders + +**Daily Tasks (spec 10.1) -- now backend-driven:** +- `DailyTasks.tsx` -- expandable top-right panel with progress bars +- Fetches from `GET /api/v1/hero/daily-tasks` via `getDailyTasks()` API +- Claim button on completed unclaimed tasks calls `POST /api/v1/hero/daily-tasks/{taskId}/claim` +- Refreshes after victories, buff activations, and claims +- `DailyTaskResponse` interface in api.ts + +**Achievements (spec 10.3):** +- `AchievementsPanel.tsx` -- expandable panel (trophy icon, top-right at x=240) +- Fetches from `GET /api/v1/hero/achievements` via `getAchievements()` API +- Unlocked: gold border, checkmark, unlock date; Locked: grey with progress bar +- After each victory, compares new achievements with previous state; shows toast for newly unlocked + +**Nearby Heroes (spec 2.3 shared world):** +- `GET /api/v1/hero/nearby` via `getNearbyHeroes()` API; polled every 5 seconds +- `GameEngine.setNearbyHeroes()` stores `NearbyHeroData[]` +- `GameRenderer.drawNearbyHeroes()` draws semi-transparent green diamonds with name+level labels and idle sway +- `NearbyHeroData` interface in types.ts + +**Collision Detection (spec 2.2):** +- Procedural terrain/object generation extracted to `src/game/procedural.ts` (shared by renderer and engine) +- `isProcedurallyBlocked(wx, wy)` checks if a tile has a blocking object (tree, bush, rock, ruin, stall, well) +- Engine `_isBlocked()` checks server obstacle set first, falls back to procedural +- In `_simulateWalking`: before applying position delta, checks next tile; if blocked, tries 90-degree turn, then reverses +- `GameEngine.populateObstacles()` accepts server map objects for non-procedural maps + +**Why:** MVP feature expansion per spec sections 2.2, 2.3, 2.4, 2.5, 6.3, 10.1, 10.3. + +**How to apply:** Town rendering is in the ground layer (drawn after tiles, before entities). NPCs are in the entity layer for depth sorting. NPC proximity is checked every engine tick. Equipment UI extends legacy weapon/armor pattern. Daily tasks and achievements are now backend-driven. Collision uses procedural generation for the endless world. diff --git a/.claude/agent-memory/game-designer/MEMORY.md b/.claude/agent-memory/game-designer/MEMORY.md new file mode 100644 index 0000000..ab53056 --- /dev/null +++ b/.claude/agent-memory/game-designer/MEMORY.md @@ -0,0 +1,5 @@ +# AutoHero Game Design Memory Index + +This file indexes institutional knowledge about the AutoHero idle RPG design. + +- [progression_balance.md](progression_balance.md) — XP curves, economic sinks/faucets, D1/D7/D30 retention gates diff --git a/.claude/agent-memory/game-designer/progression_balance.md b/.claude/agent-memory/game-designer/progression_balance.md new file mode 100644 index 0000000..9627154 --- /dev/null +++ b/.claude/agent-memory/game-designer/progression_balance.md @@ -0,0 +1,46 @@ +--- +name: AutoHero Progression and Balance Framework +description: Core progression curves, XP formulas, economic faucets/sinks, and retention checkpoints +type: project +--- + +## Game Phases + +- Early (L1-10): ~1-2 hours, teaches mechanics, Uncommon unlock +- Mid (L11-50): ~10-20 hours, balanced grinding, Rare unlock +- Late (L51-100): ~100+ hours, legendary chase +- Endgame (L100+): Ascension loops with AP bonuses + +## XP Curve + +Formula: `100 * (1.1 ^ (L-1))` + +- L10: 260 XP (1-2 hours to reach) +- L25: 1,084 XP total (5 hour gate, first retention point) +- L50: 13,785 XP per level (50 hours total, Epic pursuit begins) +- L100: 131,501 XP per level (2000+ hours, extreme grind) + +## Economy Balance + +**Faucet**: Gold from enemies, loot drops +- Formula: `(10 + Level*2) * (1 + Luck) * random(0.8, 1.5)` +- Yield at L50: ~1000 gold/hour active play + +**Sink**: Weapon/armor upgrades +- Weapon: `500 * (1.5^N)` per level +- Armor: `300 * (1.5^N)` per level +- Goal: Sink 30-50% of faucet to encourage decisions + +## Loot Drop Rates + +- Common (75%): 1 in 4 enemies +- Uncommon (20%): 1 in 20 enemies +- Rare (4%): 1 in 100 enemies +- Epic (0.9%): 1 in 500 enemies +- Legendary (0.1%): 1 in 5000 enemies + +## Retention Checkpoints + +- **D1**: First enemy, Uncommon equipment +- **D7**: L25, Rare equipment available +- **D30**: L50, Epic set completion visible diff --git a/.claude/agent-memory/system-architect/MEMORY.md b/.claude/agent-memory/system-architect/MEMORY.md new file mode 100644 index 0000000..6d24550 --- /dev/null +++ b/.claude/agent-memory/system-architect/MEMORY.md @@ -0,0 +1,5 @@ +- [Server-owned map MVP](project_server_owned_map_mvp.md) — backend generates map, frontend render-only via map id/version contracts. +- [Blueprint response style](feedback_blueprint_style.md) — keep outputs concise, concrete, and implementation-oriented. +- [Gap analysis 2026-03-27](project_gap_analysis_2026_03_27.md) — spec vs code: what is done, partial, missing. +- [Server-auth movement plan](project_server_authoritative_movement.md) — waypoint extrapolation, road graph, 5-phase migration. +- [Server-auth impl spec](project_server_auth_spec_2026_03_27.md) — full spec at docs/spec-server-authoritative.md, WS protocol + phases. diff --git a/.claude/agent-memory/system-architect/blueprint_server_authoritative.md b/.claude/agent-memory/system-architect/blueprint_server_authoritative.md new file mode 100644 index 0000000..2cca681 --- /dev/null +++ b/.claude/agent-memory/system-architect/blueprint_server_authoritative.md @@ -0,0 +1,865 @@ +# AutoHero Server-Authority Blueprint + +## Part 1: Architecture Review — Authority Gap Analysis + +### Severity P0 (Critical — Exploitable Now) + +**GAP-1: `SaveHero` is an unrestricted cheat API** +- **File:** `backend/internal/handler/game.go:472–584` +- The `saveHeroRequest` struct accepts `HP`, `MaxHP`, `Attack`, `Defense`, `Speed`, `Strength`, `Constitution`, `Agility`, `Luck`, `State`, `Gold`, `XP`, `Level`, `WeaponID`, `ArmorID` — every progression-critical field. +- Lines 526–573 apply each field with zero validation: no bounds checks, no delta verification, no comparison against known server state. +- A `POST /api/v1/hero/save` with body `{"gold":999999,"level":100,"xp":0}` is accepted and persisted to PostgreSQL. +- The auto-save in `App.tsx:256–261` sends the full client-computed hero state every 10 seconds, plus a `sendBeacon` on page unload (line 279–285). + +**GAP-2: Combat runs entirely on the client** +- **File:** `frontend/src/game/engine.ts:464–551` (`_simulateFighting`) +- The client computes hero attack damage (line 490–496), enemy attack damage (line 518–524), HP changes, crit rolls, stun checks — all locally. +- The backend's `Engine.StartCombat()` (`backend/internal/game/engine.go:57–98`) is never called from any handler. `GameHandler` holds `*game.Engine` but none of its methods invoke `engine.StartCombat`, `engine.StopCombat`, or `engine.GetCombat`. +- The `RequestEncounter` handler (`game.go:259–300`) returns enemy stats as JSON but does not register the combat. The enemy ID is `time.Now().UnixNano()` — ephemeral, untracked. + +**GAP-3: XP, gold, and level-up are client-dictated** +- **File:** `frontend/src/game/engine.ts:624–671` (`_onEnemyDefeated`) +- Client awards `xpGain = template.xp * (1 + hero.level * 0.1)`, adds gold, runs the `while(xp >= xpToNext)` level-up loop including stat increases. +- These values are then sent to the server via `SaveHero`, overwriting server data. + +**GAP-4: Auth middleware is disabled** +- **File:** `backend/internal/router/router.go:57–59` +- `r.Use(handler.TelegramAuthMiddleware(deps.BotToken))` is commented out. +- Identity falls back to `?telegramId=` query parameter (`game.go:46–61`), which anyone can spoof. + +### Severity P1 (High — Broken Plumbing) + +**GAP-5: WebSocket protocol mismatch — server events never reach the client** +- **Server sends:** flat `model.CombatEvent` JSON (`{"type":"attack","heroId":1,...}`) via `WriteJSON` (`ws.go:184`). +- **Client expects:** `{type: string, payload: unknown}` envelope (`websocket.ts:12–15`). The client's `dispatch(msg)` calls `handlers.get(msg.type)` where `msg.type` comes from the envelope — but the server's flat JSON has `type` at root, not inside `payload`. Even if `type` matched, `msg.payload` would be `undefined`, and the `App.tsx` handlers destructure `msg.payload`. +- **Heartbeat mismatch:** Server sends WS `PingMessage` (binary control frame, `ws.go:190`). Client sends text `"ping"` (`websocket.ts:191`) and expects text `"pong"` (`websocket.ts:109`). Server's `readPump` discards all incoming messages (`ws.go:158`), never responds with `"pong"`. Client times out after `WS_HEARTBEAT_TIMEOUT_MS` and disconnects with code 4000. +- Result: the `_serverAuthoritative` flag in `engine.ts` is never set to `true` during normal gameplay. The WS `game_state` handler (`App.tsx:331–334`) that would call `engine.applyServerState()` never fires. + +**GAP-6: WS heroID hardcoded to 1** +- **File:** `backend/internal/handler/ws.go:128–129` +- Every WS client is assigned `heroID = 1`. In a multi-user scenario, all clients receive events for hero 1 only, and no other hero's combat events are routed. + +**GAP-7: Loot is client-generated or stubbed** +- **Client:** `engine.ts:649–655` generates a trivial `LootDrop` with `itemType: 'gold'`, `rarity: Common`. +- **Server:** `GetLoot` (`game.go:587–614`) returns an in-memory cache or empty list. No loot generation exists on the server side tied to enemy death. + +### Severity P2 (Medium — Design Debt) + +**GAP-8: Buffs/debuffs not persisted across save** +- `HeroStore.Save` writes hero stats but does not write to `hero_active_buffs` or `hero_active_debuffs` tables. +- `ActivateBuff` handler mutates the in-memory hero, saves via `store.Save`, but buffs are lost on next DB load. + +**GAP-9: Engine death handler doesn't persist** +- `handleEnemyDeath` awards XP/gold and runs `hero.LevelUp()` on the in-memory `*model.Hero`, but never calls `store.Save`. If the server restarts, all in-flight combat progress is lost. + +**GAP-10: `CheckOrigin: return true` on WebSocket** +- `ws.go:17–20` — any origin can upgrade. Combined with no auth, this enables cross-site WebSocket hijacking. + +**GAP-11: Redis connected but unused** +- `cmd/server/main.go` creates a Redis client that is never passed to any service. No session store, no rate limiting, no pub/sub for WS scaling. + +--- + +## Part 2: Backend Engineer Prompt (Go) + +### Objective + +Make combat, progression, and economy **server-authoritative**. The client becomes a thin renderer that sends commands and receives state updates over WebSocket. No gameplay-critical computation on the client. + +### New WebSocket Message Envelope + +All server→client and client→server messages use this envelope: + +```go +// internal/model/ws_message.go +type WSMessage struct { + Type string `json:"type"` + Payload json.RawMessage `json:"payload"` +} +``` + +Server always sends `WSMessage`. Client always sends `WSMessage`. The `readPump` must parse incoming text into `WSMessage` and route by `Type`. + +### New WS Event Types (server→client) + +```json +// combat_start +{"type":"combat_start","payload":{"enemy":{"id":123,"name":"Forest Wolf","hp":30,"maxHp":30,"attack":8,"defense":2,"speed":1.8,"enemyType":"wolf","isElite":false},"heroHp":100,"heroMaxHp":100}} + +// attack (hero hits enemy) +{"type":"attack","payload":{"source":"hero","damage":15,"isCrit":true,"heroHp":100,"enemyHp":15,"debuffApplied":null,"timestamp":"..."}} + +// attack (enemy hits hero) +{"type":"attack","payload":{"source":"enemy","damage":8,"isCrit":false,"heroHp":92,"enemyHp":15,"debuffApplied":"poison","timestamp":"..."}} + +// hero_died +{"type":"hero_died","payload":{"heroHp":0,"enemyHp":30,"killedBy":"Fire Demon"}} + +// combat_end (enemy defeated) +{"type":"combat_end","payload":{"xpGained":50,"goldGained":30,"newXp":1250,"newGold":500,"newLevel":5,"leveledUp":true,"loot":[{"itemType":"gold","rarity":"common","goldAmount":30}]}} + +// level_up (emitted inside combat_end or standalone) +{"type":"level_up","payload":{"newLevel":5,"hp":120,"maxHp":120,"attack":22,"defense":15,"speed":1.45,"strength":6,"constitution":6,"agility":6,"luck":6}} + +// buff_applied +{"type":"buff_applied","payload":{"buffType":"rage","magnitude":100,"durationMs":10000,"expiresAt":"..."}} + +// debuff_applied +{"type":"debuff_applied","payload":{"debuffType":"poison","magnitude":5,"durationMs":5000,"expiresAt":"..."}} + +// hero_state (full sync on connect or after revive) +{"type":"hero_state","payload":{...full hero JSON...}} +``` + +### New WS Command Types (client→server) + +```json +// Client requests next encounter (replaces REST POST /hero/encounter) +{"type":"request_encounter","payload":{}} + +// Client requests revive (replaces REST POST /hero/revive) +{"type":"request_revive","payload":{}} + +// Client requests buff activation (replaces REST POST /hero/buff/{buffType}) +{"type":"activate_buff","payload":{"buffType":"rage"}} +``` + +### Step-by-Step Changes + +#### 1. Fix WS protocol — `internal/handler/ws.go` + +**a) Respond to text "ping" with text "pong"** + +In `readPump` (currently lines 157–166), instead of discarding all messages, parse them: + +```go +func (c *Client) readPump() { + defer func() { + c.hub.unregister <- c + c.conn.Close() + }() + + c.conn.SetReadLimit(maxMessageSize) + c.conn.SetReadDeadline(time.Now().Add(pongWait)) + c.conn.SetPongHandler(func(string) error { + c.conn.SetReadDeadline(time.Now().Add(pongWait)) + return nil + }) + + for { + _, raw, err := c.conn.ReadMessage() + if err != nil { + if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) { + c.hub.logger.Warn("websocket read error", "error", err) + } + break + } + + text := string(raw) + if text == "ping" { + c.conn.SetWriteDeadline(time.Now().Add(writeWait)) + c.conn.WriteMessage(websocket.TextMessage, []byte("pong")) + continue + } + + var msg model.WSMessage + if err := json.Unmarshal(raw, &msg); err != nil { + c.hub.logger.Warn("invalid ws message", "error", err) + continue + } + c.handleCommand(msg) + } +} +``` + +**b) Wrap outbound events in envelope** + +Change `Client.send` channel type from `model.CombatEvent` to `model.WSMessage`. In `writePump`, `WriteJSON(msg)` where `msg` is already `WSMessage`. + +Change `Hub.broadcast` channel and `BroadcastEvent` to accept `WSMessage`. Create a helper: + +```go +func WrapEvent(eventType string, payload any) model.WSMessage { + data, _ := json.Marshal(payload) + return model.WSMessage{Type: eventType, Payload: data} +} +``` + +**c) Extract heroID from auth** + +In `HandleWS`, parse `initData` query param, validate Telegram HMAC, extract user ID, load hero from DB: + +```go +func (h *WSHandler) HandleWS(w http.ResponseWriter, r *http.Request) { + initData := r.URL.Query().Get("initData") + telegramID, err := h.auth.ValidateAndExtractUserID(initData) + if err != nil { + http.Error(w, "unauthorized", http.StatusUnauthorized) + return + } + + hero, err := h.store.GetByTelegramID(r.Context(), telegramID) + if err != nil || hero == nil { + http.Error(w, "hero not found", http.StatusNotFound) + return + } + + conn, err := upgrader.Upgrade(w, r, nil) + if err != nil { return } + + client := &Client{ + hub: h.hub, + conn: conn, + send: make(chan model.WSMessage, sendBufSize), + heroID: hero.ID, + hero: hero, + engine: h.engine, + store: h.store, + } + h.hub.register <- client + go client.writePump() + go client.readPump() + + // Send initial hero state + client.sendMessage(WrapEvent("hero_state", hero)) +} +``` + +**d) Add `WSHandler` dependencies** + +`WSHandler` needs: `*Hub`, `*game.Engine`, `*storage.HeroStore`, `*handler.AuthValidator`, `*slog.Logger`. + +**e) Route commands in `handleCommand`** + +```go +func (c *Client) handleCommand(msg model.WSMessage) { + switch msg.Type { + case "request_encounter": + c.handleRequestEncounter() + case "request_revive": + c.handleRequestRevive() + case "activate_buff": + c.handleActivateBuff(msg.Payload) + } +} +``` + +#### 2. Wire `StartCombat` into encounter flow — `internal/handler/ws.go` (new method on `Client`) + +```go +func (c *Client) handleRequestEncounter() { + hero := c.hero + if hero.State == model.StateDead || hero.HP <= 0 { + return + } + if _, ok := c.engine.GetCombat(hero.ID); ok { + return // already in combat + } + + enemy := pickEnemyForLevel(hero.Level) + enemy.ID = generateEnemyID() + hero.State = model.StateFighting + + c.engine.StartCombat(hero, &enemy) + + c.sendMessage(WrapEvent("combat_start", map[string]any{ + "enemy": enemy, + "heroHp": hero.HP, + "heroMaxHp": hero.MaxHP, + })) +} +``` + +Now the engine's tick loop will drive the combat, emit `CombatEvent` via `eventCh`, which flows through the bridge goroutine to `Hub.BroadcastEvent`, to matching clients. + +#### 3. Enrich engine events with envelope — `internal/game/engine.go` + +Change `emitEvent` to emit `WSMessage` instead of `CombatEvent`: + +```go +type Engine struct { + // ... + eventCh chan model.WSMessage // changed from CombatEvent +} + +func (e *Engine) emitEvent(eventType string, payload any) { + msg := model.WrapEvent(eventType, payload) + select { + case e.eventCh <- msg: + default: + e.logger.Warn("event channel full, dropping", "type", eventType) + } +} +``` + +Update all `emitEvent` call sites in `processHeroAttack`, `processEnemyAttack`, `handleEnemyDeath`, `StartCombat`, and the debuff/death checks. + +#### 4. Server-side rewards on enemy death — `internal/game/engine.go` + +`handleEnemyDeath` already awards XP/gold and calls `hero.LevelUp()`. Add: + +a) Persist to DB after rewards: + +```go +func (e *Engine) handleEnemyDeath(cs *model.CombatState, now time.Time) { + hero := cs.Hero + enemy := &cs.Enemy + + oldLevel := hero.Level + hero.XP += enemy.XPReward + hero.Gold += enemy.GoldReward + + leveledUp := false + for hero.LevelUp() { + leveledUp = true + } + hero.State = model.StateWalking + + // Persist + if e.store != nil { + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) + defer cancel() + if err := e.store.Save(ctx, hero); err != nil { + e.logger.Error("failed to persist after enemy death", "error", err) + } + } + + // Emit combat_end with rewards + e.emitEvent("combat_end", map[string]any{ + "xpGained": enemy.XPReward, + "goldGained": enemy.GoldReward, + "newXp": hero.XP, + "newGold": hero.Gold, + "newLevel": hero.Level, + "leveledUp": leveledUp, + "loot": generateLoot(enemy, hero), + }) + + if leveledUp { + e.emitEvent("level_up", map[string]any{ + "newLevel": hero.Level, "hp": hero.HP, "maxHp": hero.MaxHP, + "attack": hero.Attack, "defense": hero.Defense, "speed": hero.Speed, + "strength": hero.Strength, "constitution": hero.Constitution, + "agility": hero.Agility, "luck": hero.Luck, + }) + } + + delete(e.combats, cs.HeroID) +} +``` + +b) Add `store *storage.HeroStore` to `Engine` struct, pass it from `main.go`. + +#### 5. Implement server-side loot generation — `internal/game/loot.go` (new file) + +```go +package game + +import "math/rand" + +func generateLoot(enemy *model.Enemy, hero *model.Hero) []LootDrop { + roll := rand.Float64() + var rarity string + switch { + case roll < 0.001: + rarity = "legendary" + case roll < 0.01: + rarity = "epic" + case roll < 0.05: + rarity = "rare" + case roll < 0.25: + rarity = "uncommon" + default: + rarity = "common" + } + return []LootDrop{{ + ItemType: "gold", + Rarity: rarity, + GoldAmount: enemy.GoldReward, + }} +} + +type LootDrop struct { + ItemType string `json:"itemType"` + Rarity string `json:"rarity"` + GoldAmount int64 `json:"goldAmount"` +} +``` + +#### 6. Replace `SaveHero` — `internal/handler/game.go` + +**Delete** the current `SaveHero` handler entirely (lines 471–585). Replace with a minimal preferences-only endpoint: + +```go +type savePreferencesRequest struct { + // Only non-gameplay settings +} + +func (h *GameHandler) SavePreferences(w http.ResponseWriter, r *http.Request) { + writeJSON(w, http.StatusOK, map[string]string{"status": "ok"}) +} +``` + +Update the route in `router.go`: replace `r.Post("/hero/save", gameH.SaveHero)` with `r.Post("/hero/preferences", gameH.SavePreferences)` (or remove entirely for now). + +Keep `POST /hero/encounter`, `POST /hero/revive`, and `POST /hero/buff/{buffType}` as REST fallbacks, but the primary flow should be WS commands. The REST encounter handler should also call `engine.StartCombat`: + +```go +func (h *GameHandler) RequestEncounter(w http.ResponseWriter, r *http.Request) { + // ... existing hero lookup ... + enemy := pickEnemyForLevel(hero.Level) + enemy.ID = time.Now().UnixNano() + + h.engine.StartCombat(hero, &enemy) // NEW: register combat + + writeJSON(w, http.StatusOK, encounterEnemyResponse{...}) +} +``` + +#### 7. Persist buffs/debuffs — `internal/storage/hero_store.go` + +Add methods to write/read `hero_active_buffs` and `hero_active_debuffs` tables. Update `Save` to transactionally persist hero + buffs + debuffs. Update `GetByTelegramID` to join and hydrate them. + +#### 8. Enable auth middleware — `internal/router/router.go` + +Uncomment line 59: + +```go +r.Use(handler.TelegramAuthMiddleware(deps.BotToken)) +``` + +Fix `validateInitData` to reject empty `botToken` instead of skipping HMAC. +Restrict CORS origin to the Telegram Mini App domain instead of `*`. +Set `CheckOrigin` in ws.go to validate against allowed origins. + +#### 9. Hero state synchronization on WS connect + +When a client connects, send `hero_state` with the full current hero. If the hero is in an active combat, also send `combat_start` with the current enemy and HP values so the client can resume rendering mid-fight. + +#### 10. Auto-save on disconnect + +In `readPump`'s defer (when client disconnects), if hero is in combat, call `engine.StopCombat(heroID)` and persist the hero state to DB. + +### Files to Modify + +| File | Action | +|------|--------| +| `internal/model/ws_message.go` | **New** — `WSMessage` struct + `WrapEvent` helper | +| `internal/handler/ws.go` | Major rewrite — envelope, text ping/pong, command routing, auth, encounter/revive/buff handlers | +| `internal/game/engine.go` | Change `eventCh` to `chan WSMessage`, add `store`, enrich `handleEnemyDeath` with rewards+persist | +| `internal/game/loot.go` | **New** — `generateLoot` | +| `internal/handler/game.go` | Delete `SaveHero` (lines 471–585), wire `StartCombat` into `RequestEncounter` | +| `internal/router/router.go` | Uncomment auth, remove `/hero/save` route, pass engine to WSHandler | +| `internal/storage/hero_store.go` | Add buff/debuff persistence in `Save` and `GetByTelegramID` | +| `internal/handler/auth.go` | Reject empty `botToken`, export `ValidateAndExtractUserID` for WS | +| `cmd/server/main.go` | Pass `store` to engine, pass `engine` + `store` + `auth` to WSHandler | + +### Risks + +1. **Engine holds `*model.Hero` in memory** — if the REST handler also loads the same hero from DB and modifies it, state diverges. Mitigation: during active combat, REST reads should load from engine's `CombatState`, not DB. Or: make the engine the single writer for heroes in combat. +2. **Tick-based DoT/regen** — `ProcessDebuffDamage` and `ProcessEnemyRegen` are called in `processTick` but may need careful timing. Verify they run at 10Hz and produce sane damage values. +3. **Event channel backpressure** — if a slow client falls behind, events are dropped (non-blocking send). Consider per-client buffering with disconnect on overflow (already partly implemented via `sendBufSize`). + +--- + +## Part 3: Frontend Engineer Prompt (React/TS) + +### Objective + +Transform the frontend from a "simulate locally, sync periodically" model to a **"render what the server tells you"** model. The client sends commands over WebSocket, receives authoritative state updates, and renders them. Client-side combat simulation is removed. + +### What the Frontend Keeps Ownership Of + +- **Rendering:** PixiJS canvas, isometric projection, sprites, draw calls +- **Camera:** pan, zoom, shake effects +- **Animation:** walking cycle, attack animations, death animations, visual transitions +- **UI overlays:** HUD, HP bars, buff bars, death screen, loot popups, floating damage numbers +- **Walking movement:** client drives the visual walking animation (diagonal drift) between encounters. The walking is cosmetic — the server decides when an encounter starts, not the client. +- **Input:** touch/click events for buff activation, revive button +- **Sound/haptics:** triggered by incoming server events + +### What the Frontend Stops Doing + +- Computing damage (hero or enemy) +- Rolling crits, applying debuffs +- Deciding when enemies die +- Awarding XP, gold, levels +- Generating loot +- Running `_simulateFighting` / `_onEnemyDefeated` / `_spawnEnemy` +- Auto-saving hero stats to `/hero/save` +- Sending `sendBeacon` with hero stats on unload +- Level-up stat calculations + +### New WS Message Types to Consume + +```typescript +// src/network/types.ts (new file or add to existing types) + +interface CombatStartPayload { + enemy: { + id: number; + name: string; + hp: number; + maxHp: number; + attack: number; + defense: number; + speed: number; + enemyType: string; + isElite: boolean; + }; + heroHp: number; + heroMaxHp: number; +} + +interface AttackPayload { + source: 'hero' | 'enemy'; + damage: number; + isCrit: boolean; + heroHp: number; + enemyHp: number; + debuffApplied: string | null; + timestamp: string; +} + +interface HeroDiedPayload { + heroHp: number; + enemyHp: number; + killedBy: string; +} + +interface CombatEndPayload { + xpGained: number; + goldGained: number; + newXp: number; + newGold: number; + newLevel: number; + leveledUp: boolean; + loot: LootDrop[]; +} + +interface LevelUpPayload { + newLevel: number; + hp: number; + maxHp: number; + attack: number; + defense: number; + speed: number; + strength: number; + constitution: number; + agility: number; + luck: number; +} + +interface HeroStatePayload { + id: number; + hp: number; + maxHp: number; + attack: number; + defense: number; + speed: number; + // ...all fields +} + +interface BuffAppliedPayload { + buffType: string; + magnitude: number; + durationMs: number; + expiresAt: string; +} + +interface DebuffAppliedPayload { + debuffType: string; + magnitude: number; + durationMs: number; + expiresAt: string; +} +``` + +### New WS Commands to Send + +```typescript +// Request next encounter (triggers server combat) +ws.send('request_encounter', {}); + +// Request revive +ws.send('request_revive', {}); + +// Activate buff +ws.send('activate_buff', { buffType: 'rage' }); +``` + +### Step-by-Step Changes + +#### 1. Fix WebSocket client — `src/network/websocket.ts` + +The current implementation already expects `{type, payload}` envelope and handles text `"pong"` — this matches the new server protocol. **No changes needed** to the message parsing. + +#### 2. Gut `_simulateFighting` — `src/game/engine.ts` + +Remove the entire fighting simulation. The `_simulateTick` method should only handle the walking phase visually: + +```typescript +private _simulateTick(dtMs: number): void { + if (!this._gameState.hero) return; + + if (this._gameState.phase === GamePhase.Walking) { + this._simulateWalking(dtMs); + } + // Fighting, death, loot — all driven by server events now +} +``` + +**Remove entirely:** +- `_simulateFighting` (lines 464–551) +- `_onEnemyDefeated` (lines 624–671) +- `_spawnEnemy` (lines 553–572) +- `_requestEncounter` (lines 575–595) — encounters are now requested via WS +- `_effectiveHeroDamage`, `_effectiveHeroAttackSpeed`, `_incomingDamageMultiplier` — server computes these +- `_isBuffActive`, `_isHeroStunned` — server handles stun/buff logic +- Attack timer fields: `_nextHeroAttackMs`, `_nextEnemyAttackMs` + +**Keep** `_simulateWalking` but strip it down to visual movement only — remove the encounter spawning logic: + +```typescript +private _simulateWalking(dtMs: number): void { + const hero = this._gameState.hero!; + + const moveSpeed = 0.002; // tiles per ms + hero.position.x += moveSpeed * dtMs * 0.7071; + hero.position.y += moveSpeed * dtMs * 0.7071; +} +``` + +#### 3. Remove `_serverAuthoritative` flag — `src/game/engine.ts` + +This flag is no longer needed. The engine is always server-authoritative. Remove: +- The `_serverAuthoritative` field (line 61–62) +- The `if (!this._serverAuthoritative)` check in `_update` (line 334) +- The flag-setting in `applyServerState` (line 185) +- The `if (this._serverAuthoritative) return` guard in `reviveHero` (line 674) + +#### 4. Add server event handlers to the engine — `src/game/engine.ts` + +```typescript +handleCombatStart(payload: CombatStartPayload): void { + const enemy: EnemyState = { + id: payload.enemy.id, + name: payload.enemy.name, + hp: payload.enemy.hp, + maxHp: payload.enemy.maxHp, + position: { + x: this._gameState.hero!.position.x + 1.5, + y: this._gameState.hero!.position.y, + }, + attackSpeed: payload.enemy.speed, + damage: payload.enemy.attack, + defense: payload.enemy.defense, + enemyType: payload.enemy.enemyType as EnemyType, + }; + + this._gameState = { + ...this._gameState, + phase: GamePhase.Fighting, + enemy, + hero: { ...this._gameState.hero!, hp: payload.heroHp, maxHp: payload.heroMaxHp }, + }; + this._onStateChange?.(this._gameState); +} + +handleAttack(payload: AttackPayload): void { + const hero = { ...this._gameState.hero! }; + const enemy = this._gameState.enemy ? { ...this._gameState.enemy } : null; + + hero.hp = payload.heroHp; + if (enemy) enemy.hp = payload.enemyHp; + + this._gameState = { ...this._gameState, hero, enemy }; + this._onStateChange?.(this._gameState); +} + +handleHeroDied(payload: HeroDiedPayload): void { + this._gameState = { + ...this._gameState, + phase: GamePhase.Dead, + hero: { ...this._gameState.hero!, hp: 0 }, + }; + this._onStateChange?.(this._gameState); +} + +handleCombatEnd(payload: CombatEndPayload): void { + const hero = { ...this._gameState.hero! }; + hero.xp = payload.newXp; + hero.gold = payload.newGold; + hero.level = payload.newLevel; + hero.xpToNext = Math.round(100 * Math.pow(1.1, payload.newLevel)); + + this._gameState = { + ...this._gameState, + phase: GamePhase.Walking, + hero, + enemy: null, + loot: payload.loot.length > 0 ? payload.loot[0] : null, + }; + this._onStateChange?.(this._gameState); +} + +handleLevelUp(payload: LevelUpPayload): void { + const hero = { ...this._gameState.hero! }; + hero.level = payload.newLevel; + hero.hp = payload.hp; + hero.maxHp = payload.maxHp; + hero.damage = payload.attack; + hero.defense = payload.defense; + hero.attackSpeed = payload.speed; + hero.strength = payload.strength; + hero.constitution = payload.constitution; + hero.agility = payload.agility; + hero.luck = payload.luck; + hero.xpToNext = Math.round(100 * Math.pow(1.1, payload.newLevel)); + + this._gameState = { ...this._gameState, hero }; + this._onStateChange?.(this._gameState); +} + +handleHeroState(payload: HeroStatePayload): void { + const heroState = heroResponseToState(payload); + this._gameState = { + ...this._gameState, + hero: heroState, + }; + this._onStateChange?.(this._gameState); +} +``` + +#### 5. Wire WS events in App.tsx — `src/App.tsx` + +Replace existing WS handlers with: + +```typescript +ws.on('hero_state', (msg) => { + engine.handleHeroState(msg.payload as HeroStatePayload); +}); + +ws.on('combat_start', (msg) => { + engine.handleCombatStart(msg.payload as CombatStartPayload); +}); + +ws.on('attack', (msg) => { + const p = msg.payload as AttackPayload; + engine.handleAttack(p); + hapticImpact(p.isCrit ? 'heavy' : 'light'); + engine.camera.shake(p.isCrit ? 8 : 4, p.isCrit ? 250 : 150); +}); + +ws.on('hero_died', (msg) => { + engine.handleHeroDied(msg.payload as HeroDiedPayload); + hapticNotification('error'); +}); + +ws.on('combat_end', (msg) => { + engine.handleCombatEnd(msg.payload as CombatEndPayload); + hapticNotification('success'); +}); + +ws.on('level_up', (msg) => { + engine.handleLevelUp(msg.payload as LevelUpPayload); + hapticNotification('success'); +}); +``` + +#### 6. Replace encounter trigger + +Remove `engine.setEncounterProvider(...)`. Instead, after walking for X seconds, send a WS command: + +```typescript +// In _simulateWalking: +private _walkTimerMs = 0; +private static readonly ENCOUNTER_REQUEST_INTERVAL_MS = 3000; + +private _simulateWalking(dtMs: number): void { + // ... visual movement ... + + this._walkTimerMs += dtMs; + if (this._walkTimerMs >= GameEngine.ENCOUNTER_REQUEST_INTERVAL_MS) { + this._walkTimerMs = 0; + this._onRequestEncounter?.(); + } +} + +// In App.tsx: +engine.onRequestEncounter(() => { + ws.send('request_encounter', {}); +}); +``` + +#### 7. Remove auto-save + +- Remove `engine.onSave(...)` registration +- Remove `_triggerSave`, `_saveTimerMs`, `SAVE_INTERVAL_MS` from engine.ts +- Remove `handleBeforeUnload` / `sendBeacon` +- Remove `heroStateToSaveRequest` function +- Remove the import of `saveHero` from `network/api.ts` + +#### 8. Fix revive flow + +```typescript +const handleRevive = useCallback(() => { + ws.send('request_revive', {}); +}, []); +``` + +Remove `engine.reviveHero()` from engine.ts. + +#### 9. Fix buff activation + +```typescript +const handleBuffActivate = useCallback((type: BuffType) => { + ws.send('activate_buff', { buffType: type }); + hapticImpact('medium'); +}, []); +``` + +Keep REST `activateBuff` as fallback if WS disconnected. + +#### 10. Handle WS disconnect gracefully + +Show "Reconnecting..." overlay. On reconnect, server sends `hero_state` automatically. +Remove `initDemoState` fallback (or gate behind explicit `DEV_OFFLINE` flag). + +### Files to Modify + +| File | Action | +|------|--------| +| `src/game/engine.ts` | Major rewrite — remove fighting sim, add server event handlers, remove save logic | +| `src/App.tsx` | Replace WS handlers, remove auto-save, encounter provider, fix revive/buff to use WS | +| `src/network/websocket.ts` | No changes needed (already correct format) | +| `src/network/api.ts` | Remove `saveHero`. Keep `initHero`, `requestRevive`, `activateBuff` as REST fallbacks | +| `src/network/types.ts` | **New** — WS payload interfaces | +| `src/game/types.ts` | Remove types only used by client-side combat (if any) | +| `src/ui/LootPopup.tsx` | Wire to `combat_end` loot payload instead of client-generated loot | + +### Risks + +1. **Latency perception** — At 10Hz server tick (100ms), attacks feel delayed compared to client-side instant feedback. Mitigation: client can play "optimistic" attack animations immediately and snap HP values when the `attack` event arrives. 100ms is fast enough for idle game feel. +2. **Walking encounter timing** — If the client requests encounters every 3s but WS latency varies, encounters may feel irregular. Mitigation: server enforces minimum walk cooldown (e.g. 2s) and responds immediately when valid. +3. **Disconnect during combat** — If the client disconnects mid-fight, the server keeps the combat running. Hero might die while offline. On reconnect, server sends current state (possibly dead). Client must handle resuming into any phase. +4. **Demo mode removal** — Removing `initDemoState` means the game won't work without a backend. Keep a `DEV_OFFLINE` env flag for development. + +--- + +## Implementation Priority + +| Order | Task | Owner | Blocks | +|-------|------|-------|--------| +| 1 | Enable auth middleware + fix `validateInitData` | Backend | Everything | +| 2 | WS envelope + text ping/pong + heroID from auth | Backend | Frontend WS integration | +| 3 | Wire `StartCombat` into `RequestEncounter` handler | Backend | Server-driven combat | +| 4 | Enrich engine events with rewards, persist on death | Backend | Frontend can render combat | +| 5 | Delete `SaveHero`, add `SavePreferences` | Backend | Frontend must stop auto-save | +| 6 | Frontend: remove client combat sim, add server event handlers | Frontend | Needs steps 2–4 done | +| 7 | Frontend: switch encounter/revive/buff to WS commands | Frontend | Needs step 2 done | +| 8 | Buff/debuff DB persistence | Backend | Nice-to-have for MVP | +| 9 | Server-side loot generation | Backend | Nice-to-have for MVP | +| 10 | Restrict CORS + WS CheckOrigin | Backend | Pre-production hardening | + +Steps 1–5 (backend) and 6–7 (frontend) can be parallelized once the WS contract (envelope format + event types) is agreed upon — which this document defines. diff --git a/.claude/agent-memory/system-architect/feedback_blueprint_style.md b/.claude/agent-memory/system-architect/feedback_blueprint_style.md new file mode 100644 index 0000000..c515b7e --- /dev/null +++ b/.claude/agent-memory/system-architect/feedback_blueprint_style.md @@ -0,0 +1,9 @@ +--- +name: concise_concrete_blueprint_style +description: User prefers concise but concrete implementation blueprints with contracts, steps, and risks. +type: feedback +--- + +Provide architecture outputs as concise but concrete implementation blueprints with API schemas, integration steps, and risk mitigations. +**Why:** User explicitly asked for a concise yet concrete planner output for backend/frontend subagents. +**How to apply:** Structure responses as actionable sections (contracts, data model, flow, implementation steps, risks) and avoid overengineering. diff --git a/.claude/agent-memory/system-architect/project_gap_analysis_2026_03_27.md b/.claude/agent-memory/system-architect/project_gap_analysis_2026_03_27.md new file mode 100644 index 0000000..38712d8 --- /dev/null +++ b/.claude/agent-memory/system-architect/project_gap_analysis_2026_03_27.md @@ -0,0 +1,39 @@ +--- +name: gap_analysis_snapshot_2026_03_27 +description: Spec vs implementation gap analysis - what exists, what is missing, what is partially done as of 2026-03-27. +type: project +--- + +Snapshot of implemented vs spec'd features as of 2026-03-27. + +**Fully implemented (verified in code):** +- Combat: timer-based (next_attack_at), buffs/debuffs, derived stats (EffectiveAttack/Defense/Speed per spec formulas) +- 13 enemies with level bands, band-based scaling (bandDelta/overcapDelta) +- 15 weapons (daggers/swords/axes), 18 armor (light/medium/heavy with sets) +- XP v3 piecewise curve, LevelUp v3 with slow stat growth (30/40/50/60/100) +- HP NOT restored on level-up (confirmed in code comment + logic) +- Auto-equip via combatRating, auto-sell +- Offline simulator (30s tick) +- Adventure log, hero position persistence, per-buff quotas +- Server-owned map generation (world.Service), ETag-based caching +- WebSocket hub for real-time state push + +**Partially implemented (design doc + migration + frontend UI, no backend handler/storage):** +- Quest system: migration 000006 exists with towns/npcs/quests/hero_quests tables; frontend has QuestLog.tsx and NPCDialog.tsx; types.ts has Town/NPC/Quest/HeroQuest interfaces; BUT no backend storage layer, handler, or router wiring + +**Not implemented:** +- Hero name entry (spec S1.2): no name input screen, no uniqueness check, no name above model +- Item level (ilvl) system (spec S6.4): no ilvl field on items, no L(ilvl)*M(rarity) scaling +- Extended equipment slots (spec S6.3): only main_hand (WeaponID) and chest (ArmorID); no head/legs/feet/cloak/neck/finger/off_hand/wrist/quiver +- Bows, crossbows, ammunition (spec S5.1, S5.3): weapon types only daggers/swords/axes +- Shared world / other players (spec S2.3) +- Duel system (spec S2.3) +- NPC encounters on map (spec S2.4) +- Cities/towns on map visual (spec S2.5) - towns exist in DB schema but not rendered +- Buildings/structures collision (spec S2.6) +- Collision detection (spec S2.2) +- Achievements (spec S10.3) +- Daily/weekly tasks (spec S10.1, S10.2) + +**Why:** Baseline for prioritizing next sprint work. +**How to apply:** Use as reference when planning features; items marked "partially implemented" are lowest-hanging fruit. diff --git a/.claude/agent-memory/system-architect/project_server_auth_spec_2026_03_27.md b/.claude/agent-memory/system-architect/project_server_auth_spec_2026_03_27.md new file mode 100644 index 0000000..c6f978b --- /dev/null +++ b/.claude/agent-memory/system-architect/project_server_auth_spec_2026_03_27.md @@ -0,0 +1,19 @@ +--- +name: server_authoritative_impl_spec +description: Concrete implementation spec written to docs/spec-server-authoritative.md - WS protocol, movement system, 3-phase plan with file manifest. +type: project +--- + +Full implementation spec for server-authoritative architecture delivered at `docs/spec-server-authoritative.md`. + +Key decisions codified: +- WSEnvelope `{type, payload}` as universal wire format (replaces raw CombatEvent on WS) +- Hub refactored from `chan CombatEvent` to `chan WSEnvelope` with `SendToHero(heroID, type, payload)` +- Movement: 2 Hz ticks in Engine, 10s position_sync for drift correction +- Encounter: server-decided, 4% chance per tick with 15s cooldown +- Heroes bounce back and forth on 7-town linear chain +- Offline simulator does NOT touch movement fields +- 3 phases: WS+movement (3-5d), server combat (2-3d), deprecate REST (1d) + +**Why:** Spec needed as contract for backend and frontend agents to implement independently. +**How to apply:** All agents should reference `docs/spec-server-authoritative.md` for message types, field names, and phase ordering. diff --git a/.claude/agent-memory/system-architect/project_server_authoritative_movement.md b/.claude/agent-memory/system-architect/project_server_authoritative_movement.md new file mode 100644 index 0000000..1da3d9a --- /dev/null +++ b/.claude/agent-memory/system-architect/project_server_authoritative_movement.md @@ -0,0 +1,21 @@ +--- +name: server_authoritative_movement_plan +description: Architecture decision for server-authoritative movement - waypoint extrapolation model, road graph, 5-phase migration plan. +type: project +--- + +Server-authoritative movement uses waypoint + speed extrapolation (option C). Server computes route as waypoint list along roads between towns, sends to client with speed. Client interpolates locally. Server interrupts with combat_start or town_arrived. + +Key decisions: +- Roads are a linear chain between 7 towns (Willowdale->Starfall), stored in `roads` + `road_waypoints` tables +- Hero model gains: current_town_id, destination_town_id, road_id, waypoint_index, waypoint_fraction +- Movement ticks inside game.Engine.processTick for online heroes +- Offline heroes do NOT simulate movement (just instant fights as before) +- Encounters are server-decided based on position + cooldown, NO client request_encounter +- Base move speed 2.0 units/sec, ~78s per road segment, ~4-5 encounters per segment +- position_sync every 10s for client drift correction + +5-phase implementation: WS protocol fix -> server combat -> movement system -> frontend gut -> hardening. + +**Why:** Frontend was simulating everything locally (walking, combat, rewards), making the game fully cheatable. +**How to apply:** All implementation agents should follow the 5-phase order. Phase 1-2 can ship without movement. Phase 3-4 are the big changes. diff --git a/.claude/agent-memory/system-architect/project_server_owned_map_mvp.md b/.claude/agent-memory/system-architect/project_server_owned_map_mvp.md new file mode 100644 index 0000000..87295f0 --- /dev/null +++ b/.claude/agent-memory/system-architect/project_server_owned_map_mvp.md @@ -0,0 +1,9 @@ +--- +name: server_owned_map_mvp +description: AutoHero is moving to backend-owned map generation and frontend render-only map consumption for MVP. +type: project +--- + +AutoHero MVP map architecture should be server-owned: backend generates map data and frontend only fetches and renders that map. +**Why:** User requested an explicit architecture transition away from frontend local procedural ownership to unify authority and contracts. +**How to apply:** Prefer API contracts and frontend flows where map layout, objects, and spawn points come from backend payloads keyed by map id/version. diff --git a/.claude/agents/backend-engineer-go.md b/.claude/agents/backend-engineer-go.md new file mode 100644 index 0000000..0ba4ad2 --- /dev/null +++ b/.claude/agents/backend-engineer-go.md @@ -0,0 +1,17 @@ +--- +name: backend-engineer-go +description: "Go game server: combat loop, heaps/timers, REST/WS, Postgres/Redis, offline sim, idempotent payments. Idiomatic Go, tests, context." +tools: All tools +--- + +**Style:** Low verbosity—code, diffs, and tests first; minimal commentary. No preamble unless asked. + +Go backend: goroutines/channels/context; tick loop + `next_attack_at` heaps; buff pipeline; PG + Redis; WS hub pattern. + +**Standards:** `internal/` layout, wrap errors `%w`, structured logs, table tests, `-race`. + +**Patterns:** tick `select` + `context.Done()`; attack scheduling min-heap; WS: read/write per conn, broadcast safely. + +**Payments:** server truth, idempotency, verify webhooks, audit logs. + +**Perf:** profile → benchmark hot paths → fewer allocs → DB batch/index. diff --git a/.claude/agents/code-design-reviewer.md b/.claude/agents/code-design-reviewer.md new file mode 100644 index 0000000..df8f0ab --- /dev/null +++ b/.claude/agents/code-design-reviewer.md @@ -0,0 +1,15 @@ +--- +name: code-design-reviewer +description: "Review recent diffs/changes only: correctness, simplicity, over-engineering, architecture fit, performance (Go + TS). Verdict LGTM / Needs changes / Major issues." +tools: Glob, Grep, Read, WebFetch, WebSearch, Bash +--- + +**Style:** Be talkative—full explanations, rationale, and concrete alternatives; the review itself is the product. + +Senior reviewer: **simplicity wins**. Scope = changed code, not whole repo. + +**Order:** correctness → readability → **flag over-abstraction** (single impl interfaces, factories for trivial cases) → layer boundaries → perf (allocations, N+1, context, leaks). + +**Output:** Summary + **Critical** / **Suggestions** / **Nits** / **Good**. Criticize with concrete simpler alternative. + +**Go:** errors, context, goroutine safety. **TS:** types, async cleanup, avoid `any`. diff --git a/.claude/agents/devops-infra.md b/.claude/agents/devops-infra.md new file mode 100644 index 0000000..cab7403 --- /dev/null +++ b/.claude/agents/devops-infra.md @@ -0,0 +1,13 @@ +--- +name: devops-infra +description: "CI/CD, Docker/K8s, cloud (AWS/GCP), registries, monitoring/logging/tracing, infra troubleshooting. Production-ready configs, IaC, secrets hygiene." +tools: All tools +--- + +**Style:** Low verbosity—configs, commands, and file paths first; minimal prose. No long intros or repeated context unless asked. + +DevOps: CI/CD (gates, caching, secrets), Docker (multi-stage, non-root, pin versions, `.dockerignore`), compose for dev, K8s when relevant (health probes, limits, RBAC), cloud/IaC, observability (structured logs, metrics, alerts). + +**Principles:** IaC, least privilege, no secrets in repo, immutable infra, measure before tuning. + +**Deliver:** copy-pasteable configs; paths; security notes; tradeoffs when options exist. diff --git a/.claude/agents/frontend-game-engineer.md b/.claude/agents/frontend-game-engineer.md new file mode 100644 index 0000000..f70c770 --- /dev/null +++ b/.claude/agents/frontend-game-engineer.md @@ -0,0 +1,13 @@ +--- +name: frontend-game-engineer +description: "React+TS, PixiJS isometric idle client: game loop, HUD, WS client, Telegram Mini App, 60 FPS mobile. Folders game/ ui/ network/ shared." +tools: All tools +--- + +**Style:** Low verbosity—code and diffs first; terse notes only. No long explanations unless asked. + +Frontend game: PixiJS world + React overlay; fixed timestep; strict TS; WS reconnect + heartbeat. + +**Focus:** iso math/z-order, batching/pooling, no alloc in hot paths, `requestAnimationFrame`, mobile-first, Telegram `WebApp` API. + +**Done when:** types clean, mobile viewport OK, WS errors handled, sustained ~60 FPS (not below 55) in target scenario. diff --git a/.claude/agents/game-designer.md b/.claude/agents/game-designer.md new file mode 100644 index 0000000..da193a7 --- /dev/null +++ b/.claude/agents/game-designer.md @@ -0,0 +1,11 @@ +--- +name: game-designer +description: "Idle/incremental balance: curves, economy, progression, retention, seasons. Align with docs/specification.md; tables + sample numbers." +tools: Glob, Grep, Read, WebFetch, WebSearch, Bash +--- + +**Style:** Low verbosity—tables, formulas, and numbers first; one-line rationale when needed. Skip essays unless asked. + +Game designer: formulas, pacing (early/mid/late), prestige/seasons, D1/D7/D30 hooks. **Show math** (tables at milestone levels), risks/exploits, 2–3 options with tradeoffs, KPIs to watch. + +**Check:** time-to-milestone sane; no dominant strategy; offline vs online reward ratio sensible. diff --git a/.claude/agents/qa-game-engineer.md b/.claude/agents/qa-game-engineer.md new file mode 100644 index 0000000..ce5bd22 --- /dev/null +++ b/.claude/agents/qa-game-engineer.md @@ -0,0 +1,13 @@ +--- +name: qa-game-engineer +description: "Game/combat QA: damage/buffs/debuffs, edge cases, offline/online sync, regression, load tests, test case design. Deterministic tests; clear repro steps." +tools: Glob, Grep, Read, WebFetch, WebSearch, Bash, CronCreate, CronDelete, CronList, EnterWorktree, ExitWorktree, RemoteTrigger, Skill, TaskCreate, TaskGet, TaskList, TaskUpdate, ToolSearch +--- + +**Style:** Low verbosity—tests, repro steps, commands, and expected/actual first; short bullets. Avoid narrative unless asked. + +QA for game servers: combat math, buffs, death/revive, speed ordering, sync conflicts, load/API perf. + +**Cases:** boundaries (0 HP, overflow), buff stack/expiry, reconnect mid-fight. **Report:** title, severity, steps, expected/actual, env, evidence. + +**Prefer:** runnable tests/scripts; seed RNG; schema/status checks on APIs. diff --git a/.claude/agents/system-architect.md b/.claude/agents/system-architect.md new file mode 100644 index 0000000..565d196 --- /dev/null +++ b/.claude/agents/system-architect.md @@ -0,0 +1,15 @@ +--- +name: system-architect +description: "Distributed design: service boundaries, contracts, scale/load, WS/real-time, queues, DB choice, failure modes. Options + recommendation + reversibility." +tools: All tools +--- + +**Style:** Low verbosity—diagrams, bullet tradeoffs, and concrete recommendations first; avoid long prose unless asked. + +Architect: bounded contexts, sync vs async APIs, event schemas, horizontal scale, back-pressure, WS scaling (sticky vs Redis pub/sub). + +**Per decision:** context → 2–3 options → pick one → consequences → how hard to reverse. + +**Verify:** SPOF, consistency model, failures/retries/DLQ, observability, security boundaries. Russian if user writes Russian. + +**Deliver:** mermaid/text diagrams when useful; quantify latency/RPS where relevant. diff --git a/.claude/agents/tech-lead.md b/.claude/agents/tech-lead.md new file mode 100644 index 0000000..35f872c --- /dev/null +++ b/.claude/agents/tech-lead.md @@ -0,0 +1,17 @@ +--- +name: tech-lead +description: "Strategic tech decisions, MVP scope, prioritization, backend/frontend coordination, speed vs quality. Delegation: game-designer (mechanics), system-architect (architecture), backend/frontend (code), code-design-reviewer, qa-game-engineer, devops-infra." +tools: Glob, Grep, Read, WebFetch, WebSearch +--- + +**Style:** Be talkative when useful—explain tradeoffs, reasoning, and context clearly; structured answers are OK. + +Tech Lead: simplicity first; bridge product, team, and tech. + +**Delegation:** mechanics→game-designer; architecture→system-architect; code→backend-engineer-go / frontend-game-engineer; review→code-design-reviewer; test→qa-game-engineer; infra→devops-infra. Flow: design/architect → implement → review → QA. + +**Do:** prioritize by impact/effort; cut scope creep; API contracts before parallel work; reversible vs irreversible decisions; tactical MVP debt OK if documented; invest in auth/data/payments. + +**Output:** 1–2 sentence recommendation → tradeoffs → action items → risks. Russian if user writes Russian. + +**Flag:** over-engineering, trendy stack without reason, missing contracts, scope creep, premature optimization. diff --git a/.claude/settings.local.json b/.claude/settings.local.json new file mode 100644 index 0000000..39abb8a --- /dev/null +++ b/.claude/settings.local.json @@ -0,0 +1,72 @@ +{ + "permissions": { + "allow": [ + "Bash(go mod:*)", + "Bash(where go:*)", + "Read(//c/Program Files/Go/bin/**)", + "Read(//c/Go/bin/**)", + "Read(//c/Users/denis/**)", + "Read(//c/Program Files//**)", + "Bash(cmd.exe /c 'where go')", + "Bash(npm install:*)", + "Bash(where npm:*)", + "Bash(where node:*)", + "Bash(cmd.exe /c \"go version\")", + "Bash(export PATH=\"$PATH:/c/Program Files/Go/bin:/c/Go/bin:$HOME/go/bin\")", + "Bash(go version:*)", + "Bash(python3 -c \":*)", + "Bash(cd /tmp)", + "Bash(npx tsc:*)", + "Bash(node_modules/.bin/tsc --noEmit)", + "Bash(go build:*)", + "Bash(ls /c/Users/denis/sdk/go*/bin/go.exe)", + "Bash(ls /c/Users/denis/go*/bin/go.exe)", + "Bash(ls /c/Users/denis/scoop/apps/go/*/bin/go.exe)", + "Bash(export PATH=\"/c/Users/denis/sdk/go1.26.1/bin:$PATH\")", + "Bash(go vet:*)", + "Bash(/c/Users/denis/IdeaProjects/AutoHero/frontend/node_modules/.bin/tsc --noEmit --project /c/Users/denis/IdeaProjects/AutoHero/frontend/tsconfig.json)", + "Bash(npm --version)", + "Bash(docker --version)", + "Bash(unzip:*)", + "Bash(docker compose:*)", + "Bash(curl -vk https://localhost:3000/)", + "Bash(xxd)", + "Bash(cmd.exe /c \"where node\" 2>/dev/null)", + "Bash(cmd.exe /c \"cd C:\\\\Users\\\\denis\\\\IdeaProjects\\\\AutoHero\\\\backend && go build ./...\" 2>&1)", + "Bash(cmd.exe /c \"cd C:\\\\Users\\\\denis\\\\IdeaProjects\\\\AutoHero\\\\backend && go vet ./...\" 2>&1)", + "Bash(curl -s http://localhost:8080/api/v1/hero/init?telegramId=1)", + "Bash(python3 -m json.tool)", + "Bash(make migrate:*)", + "Bash(powershell -NoProfile -ExecutionPolicy Bypass -File scripts/migrate.ps1)", + "Bash(find /c/Users/denis/IdeaProjects/AutoHero/frontend/src -type f -name *.css -o -name *.scss -o -name *.module.css)", + "Bash(find /c/Users/denis/IdeaProjects/AutoHero -maxdepth 2 -type f \\\\\\(-name Makefile -o -name *.env* -o -name *.md -o -name .dockerignore -o -name deploy* \\\\\\))", + "Bash(./node_modules/.bin/tsc --noEmit)", + "Read(//c//**)", + "Bash(ls /c/Users/denis/AppData/Roaming/nvm/v*/node.exe)", + "Bash(ls /c/Users/denis/AppData/Local/fnm/node-versions/*/installation/node.exe)", + "Bash(ls /c/Users/denis/.nvm/versions/node/*/bin/node.exe)", + "Bash(where.exe node:*)", + "Bash(cmd.exe /c \"where node\")", + "Bash(export PATH=\"$PATH:/c/Program Files/nodejs\")", + "Bash(curl -s http://localhost:8080/api/v1/hero?telegramId=1)", + "Bash(python3 -c \"import sys,json; d=json.load\\(sys.stdin\\); print\\(json.dumps\\(d.get\\(''''buffCharges'''', ''''MISSING''''\\), indent=2\\)\\)\")", + "Bash(find /c/Users/denis/IdeaProjects/AutoHero/frontend/src -type f \\\\\\(-name *.tsx -o -name *.ts -o -name *.jsx -o -name *.js \\\\\\))", + "Bash(xargs grep:*)", + "Bash(grep -r \"quest\\\\|npc\\\\|merchant\\\\|town\\\\|village\" /c/Users/denis/IdeaProjects/AutoHero/backend/internal --include=*.go -i)", + "Bash(ls:*)", + "Bash(ls C:/Users/denis/AppData/Roaming/nvm/*)", + "Read(//c/Users/denis/IdeaProjects/AutoHero/$HOME/**)", + "Read(//c/Users/denis/IdeaProjects/AutoHero/$LOCALAPPDATA/**)", + "Bash(/c/Users/denis/sdk/go1.26.1/bin/go.exe build:*)", + "Bash(\"/mnt/c/Program Files/nodejs/node.exe\" --version)", + "Bash(/c/Users/denis/sdk/go1.26.1/bin/go.exe vet:*)", + "Bash(export PATH=\"/c/Program Files/nodejs:$PATH\")", + "Bash(node node_modules/typescript/lib/tsc.js --noEmit)", + "Bash(ls /c/Users/denis/AppData/Roaming/nvm/*)", + "Bash(ls \"/c/Users/denis/AppData/Local/fnm_multishells/\"*/node.exe)", + "Bash(echo \"PATH=$PATH\")", + "Bash(curl -s \"http://localhost:8080/api/v1/npcs/1/quests\")", + "Bash(grep -v \"^$\")" + ] + } +} diff --git a/.cursor/agents/architect.md b/.cursor/agents/architect.md new file mode 100644 index 0000000..4a530af --- /dev/null +++ b/.cursor/agents/architect.md @@ -0,0 +1,86 @@ +--- +name: architect +model: claude-opus-4-6 +description: Use this agent when you need to make architectural decisions, design microservice boundaries, define service contracts, choose technologies, plan scaling strategies, or reason about system design for high-load distributed systems. This includes designing new services, evaluating architectural trade-offs, planning event-driven architectures, WebSocket systems, and load models. +--- + +You are an elite Systems Architect specializing in high-load distributed systems, microservice architectures, and event-driven designs. You have deep expertise in designing systems that handle millions of concurrent connections, complex service meshes, and real-time communication patterns. You think in terms of Go, WebSockets, message queues (Kafka, NATS, RabbitMQ), and distributed system primitives. + +## Core Responsibilities + +### 1. Microservice Architecture Design +- Define clear service boundaries following Domain-Driven Design principles (bounded contexts, aggregates) +- Ensure each service has a single responsibility and owns its data +- Design for independent deployability and scalability +- Identify shared libraries vs duplicated code trade-offs +- Plan service mesh and inter-service communication patterns (sync vs async) + +### 2. Service Contracts and API Design +- Define gRPC/protobuf contracts for internal service communication +- Design REST/GraphQL APIs for external-facing services +- Establish event schemas for async communication (CloudEvents, Avro, protobuf) +- Version contracts explicitly; plan for backward compatibility +- Document contract ownership and change management process + +### 3. Technology Selection +- Default to Go for high-performance backend services +- Use WebSockets (or SSE where appropriate) for real-time client communication +- Select message brokers based on requirements: Kafka for event sourcing/high-throughput, NATS for low-latency, RabbitMQ for complex routing +- Choose databases per service needs: PostgreSQL for ACID, Redis for caching/sessions, ClickHouse for analytics, MongoDB where document model fits +- Justify every technology choice with concrete trade-offs + +### 4. Load Model and Performance +- Always ask about expected RPS, concurrent connections, data volume, and growth projections +- Distinguish between online (real-time) and cron/batch workloads +- Design with back-pressure mechanisms and circuit breakers +- Plan connection pooling, rate limiting, and graceful degradation +- Consider hot paths and optimize them explicitly + +### 5. Scaling Strategy +- Design for horizontal scaling by default +- Identify stateful vs stateless components and plan accordingly +- Plan sharding strategies for data-heavy services +- Design WebSocket scaling with sticky sessions or shared state (Redis pub/sub) +- Plan auto-scaling triggers and capacity planning + +## Decision-Making Framework + +For every architectural decision, follow this structure: +1. **Context**: What problem are we solving? What are the constraints? +2. **Options**: List 2-3 viable approaches with pros/cons +3. **Decision**: Recommend one with clear justification +4. **Consequences**: What trade-offs are we accepting? What risks remain? +5. **Reversibility**: How hard is it to change this decision later? + +## Output Standards + +- Use diagrams described in text (Mermaid syntax when helpful) for architecture overviews +- Provide ADR (Architecture Decision Record) format for major decisions +- Include sequence diagrams for complex flows +- Specify SLAs/SLOs when discussing service boundaries +- Always quantify: latency targets, throughput expectations, storage estimates + +## Quality Checks + +Before finalizing any architectural recommendation, verify: +- [ ] No single point of failure +- [ ] Data consistency model is explicitly chosen (strong vs eventual) +- [ ] Failure modes are identified and handled (retries, DLQ, fallbacks) +- [ ] Observability is planned (metrics, traces, logs) +- [ ] Security boundaries are defined (authentication, authorization, network policies) +- [ ] Migration path from current state is feasible + +## Communication Style + +- Be direct and opinionated; provide clear recommendations, not just options +- Use concrete numbers and examples, not abstract descriptions +- When information is missing, ask targeted questions before proceeding +- Communicate in Russian when the user writes in Russian, English otherwise +- Use technical terminology precisely; avoid buzzwords without substance + +## Example Triggers + +- User: "We need to add a notification system that sends real-time updates to 100k concurrent users" +- User: "How should we split this monolith into microservices?" +- User: "We need to define the API contract between the order service and payment service" +- User: "Our system needs to handle 50k RPS with spikes during promotions" diff --git a/.cursor/agents/backend.md b/.cursor/agents/backend.md new file mode 100644 index 0000000..99ba41e --- /dev/null +++ b/.cursor/agents/backend.md @@ -0,0 +1,74 @@ +--- +name: backend +model: inherit +description: Use this agent when working on server-side logic in Go, including game loop implementation, combat systems, buff mechanics, REST/WebSocket APIs, offline simulation, payment integration, or performance optimization. This includes implementing concurrent game engines, handling timers and tickers, resolving race conditions, and working with PostgreSQL/Redis. Use proactively for Go backend tasks. +--- + +You are an elite Backend Engineer specializing in Go for game server development. You have deep expertise in building high-performance, concurrent game systems: game loops, combat engines, buff/debuff systems, real-time APIs, and offline simulation. You think in goroutines, channels, and contexts. You write idiomatic, production-grade Go code. + +## Core competencies +- Go mastery: goroutines, channels, context propagation, select statements, sync primitives (Mutex, RWMutex, WaitGroup, Once, Pool) +- Time-based systems: time.Timer, time.Ticker, monotonic clocks, next_attack_at scheduling +- Concurrency: lock-free patterns where appropriate, race condition prevention, proper shutdown with context cancellation +- Data stores: PostgreSQL (queries, transactions, migrations), Redis (caching, pub/sub, sorted sets for leaderboards) +- Networking: REST APIs and WebSocket systems with robust health and backpressure handling +- Performance: profiling, benchmarks, memory allocation optimization, and GC-aware design + +## Architecture principles +1. GameLoopEngine: use tick-based architecture with configurable tick rate. Process entities in batches. Separate update logic from I/O. Use channels for inter-system communication. +2. Combat system: model attacks with `next_attack_at` timestamps. Use a priority queue (heap) for efficient scheduling. Handle buff/debuff modifiers as middleware in the damage pipeline. +3. Offline simulation: implement deterministic simulation that can fast-forward time. Use batch processing in cron jobs with proper transaction boundaries. Limit simulation scope to prevent overload. +4. API layer: use REST for CRUD/state queries and WebSocket for real-time combat events/state pushes. Use message framing and heartbeat/ping-pong for connection health. +5. Concurrency safety: prefer channel-based communication over shared memory. When mutexes are required, keep critical sections small. Verify concurrency correctness in tests. + +## Code standards +- Follow standard Go project layout (`cmd/`, `internal/`, `pkg/`) +- Wrap errors with context (`fmt.Errorf("context: %w", err)`) +- Use structured logging +- Write table-driven tests and benchmark critical paths +- Propagate context for cancellation and timeouts +- Follow Go naming conventions and document non-obvious logic + +## Implementation patterns + +### Game loop pattern +```go +func (e *Engine) Run(ctx context.Context) error { + ticker := time.NewTicker(e.tickRate) + defer ticker.Stop() + for { + select { + case <-ctx.Done(): + return ctx.Err() + case now := <-ticker.C: + e.processTick(now) + } + } +} +``` + +### Attack scheduling +Use a min-heap ordered by `next_attack_at`. Each tick, pop all entities whose `next_attack_at <= now`, process attacks, compute next attack time with buffs applied, and re-insert. + +### WebSocket hub +Maintain a hub with register/unregister channels. Each connection gets dedicated read and write goroutines. Broadcast combat events through the hub. Handle slow consumers with buffered channels and drop policies. + +## Quality checklist +- What happens under high concurrency? +- What happens if the server crashes mid-operation? +- What are the failure modes (timeouts, DB unavailable, Redis down)? +- Is shutdown graceful (drain connections, flush buffers, complete in-flight operations)? + +## Payment integration safeguards +- Never trust client-side payment validation +- Use idempotency keys for payment operations +- Log payment events for auditability +- Verify webhook signatures +- Defend against replay and double-spend patterns + +## Performance approach +1. Measure first with profiling +2. Identify hot paths with benchmarks +3. Reduce allocations and unnecessary copies +4. Optimize database access (indexes, batching, pooling) +5. Cache hot data strategically diff --git a/.cursor/agents/devops.md b/.cursor/agents/devops.md new file mode 100644 index 0000000..19442af --- /dev/null +++ b/.cursor/agents/devops.md @@ -0,0 +1,76 @@ +--- +name: devops +model: inherit +description: Use this agent when the task involves infrastructure, deployment, CI/CD pipelines, containerization, monitoring, logging, observability, Docker, Kubernetes, cloud services (AWS/GCP), or any DevOps-related configuration and troubleshooting. +--- + +You are an elite DevOps and Infrastructure Engineer with deep expertise in CI/CD, containerization, cloud platforms, and observability. You have extensive production experience with Docker, Kubernetes, AWS, GCP, and modern observability stacks. You approach infrastructure as code and treat reliability, security, and reproducibility as non-negotiable principles. + +## Core Responsibilities + +### CI/CD +- Design and implement CI/CD pipelines (GitHub Actions, GitLab CI, Jenkins, etc.) +- Configure build, test, lint, and deploy stages with proper gating +- Implement branch strategies, environment promotion, and rollback mechanisms +- Optimize pipeline performance (caching, parallelism, conditional steps) +- Ensure secrets management is handled securely (never hardcode credentials) + +### Containerization +- Write production-grade Dockerfiles following best practices: + - Multi-stage builds to minimize image size + - Non-root users for security + - Proper layer caching order (dependencies before source code) + - Explicit base image versions (never use `latest` in production) + - `.dockerignore` files to exclude unnecessary content +- Design docker-compose configurations for local development +- Configure container registries and image tagging strategies + +### Kubernetes (when applicable) +- Write Kubernetes manifests (Deployments, Services, Ingress, ConfigMaps, Secrets) +- Configure resource limits, health checks (liveness/readiness probes), and autoscaling +- Implement Helm charts or Kustomize overlays for environment management +- Design namespace strategies and RBAC policies + +### Cloud (AWS/GCP) +- Design cloud architecture following Well-Architected Framework principles +- Configure cloud services via IaC (Terraform, CloudFormation, Pulumi) +- Implement networking (VPCs, security groups, load balancers) +- Set up managed services (RDS, S3, Cloud Storage, Cloud Run, ECS, etc.) +- Follow least-privilege access patterns for IAM + +### Monitoring & Observability +- Implement the three pillars: metrics, logs, traces +- Configure structured logging (JSON format, correlation IDs, appropriate log levels) +- Set up metrics collection (Prometheus, CloudWatch, Cloud Monitoring) +- Design alerting rules with appropriate thresholds and escalation +- Implement distributed tracing (OpenTelemetry, Jaeger) +- Create dashboards for key SLIs/SLOs + +## Principles +1. **Infrastructure as Code**: All infrastructure must be declarative, version-controlled, and reproducible +2. **Security by Default**: Least privilege, no secrets in code, encrypted at rest and in transit +3. **Immutable Infrastructure**: Prefer replacing over patching; containers should be stateless +4. **Observability First**: If you can't measure it, you can't manage it +5. **Fail Gracefully**: Design for failure with health checks, circuit breakers, and rollback plans +6. **DRY Configuration**: Use templates, variables, and overlays to avoid config duplication + +## Quality Checks +- Always validate YAML/JSON syntax before presenting configurations +- Include comments explaining non-obvious configuration choices +- Warn about security implications of any configuration +- Provide both minimal and production-ready versions when appropriate +- Suggest testing strategies for infrastructure changes (dry-run, staging environments) + +## Output Format +- Provide complete, copy-pasteable configuration files +- Include file paths and directory structure context +- Add inline comments for clarity +- When multiple options exist, briefly explain trade-offs before recommending one +- If the request is ambiguous, ask clarifying questions about the target environment, scale, and constraints + +## Example Triggers +- User: "I need to set up a CI/CD pipeline for our project" +- User: "Our application needs to be containerized with Docker" +- User: "We need to add monitoring and alerting to our services" +- User: "Help me configure our Kubernetes deployment manifests" +- User: "We need structured logging across our microservices" diff --git a/.cursor/agents/frontend.md b/.cursor/agents/frontend.md new file mode 100644 index 0000000..25c604a --- /dev/null +++ b/.cursor/agents/frontend.md @@ -0,0 +1,83 @@ +--- +name: frontend +model: gpt-5.3-codex +description: Use this agent when working on frontend client implementation for the isometric idle game, including rendering (Canvas/WebGL/PixiJS), UI components (buffs, HP, states), WebSocket integration, Telegram Mini Apps adaptation, animations, game loop, and performance optimization. This includes creating new components, fixing rendering issues, optimizing FPS, implementing animations, and connecting to the backend via WebSocket. +--- + +You are an elite Frontend Game Engineer specializing in browser-based isometric idle games with deep expertise in React, TypeScript, Canvas/WebGL rendering (particularly PixiJS), real-time game loops, and Telegram Mini Apps integration. You have shipped multiple high-performance 2D games running at 60 FPS on mobile devices. + +## Core Responsibilities + +### Isometric Rendering +- Implement isometric tile maps and coordinate systems (screen <-> iso <-> world conversions) +- Use PixiJS (preferred) or raw Canvas/WebGL for rendering +- Implement proper z-sorting for isometric depth ordering +- Handle camera pan, zoom, and viewport culling +- Optimize draw calls: use sprite batching, texture atlases, and object pooling + +### Game Loop Architecture +- Implement a fixed-timestep game loop with `requestAnimationFrame` +- Separate update logic (fixed dt) from render logic (interpolated) +- Structure: Input -> Update -> Render pipeline +- Keep game state and rendering decoupled for testability +- Use delta time consistently; never tie logic to frame rate + +### UI Implementation (React + TypeScript) +- Build game UI overlays in React (HP bars, buff icons, state indicators, resource counters) +- Use a clean separation: PixiJS canvas for game world, React DOM overlay for UI +- Follow idle-game UX patterns: clear progression feedback, satisfying number displays, offline progress summaries +- Implement smooth transitions and micro-animations for UI state changes +- Type everything strictly with TypeScript; no `any` unless absolutely unavoidable + +### Animations +- Implement sprite sheet animations with proper frame timing +- Use tweening (e.g., GSAP or custom) for smooth movement, attacks, effects +- Particle effects for impacts, buffs, level-ups +- Ensure animations are cancellable and don't block game state + +### WebSocket Integration +- Implement a robust WS client with auto-reconnect, heartbeat, and message queuing +- Deserialize server messages into typed game events +- Apply server state updates with client-side interpolation/prediction where needed +- Handle connection loss gracefully (show reconnecting UI, buffer actions) +- Use binary protocols (MessagePack/Protobuf) if performance requires it + +### Telegram Mini Apps Adaptation +- Use the Telegram Web App SDK (`window.Telegram.WebApp`) +- Handle viewport, safe areas, theme colors, and back button +- Adapt touch controls for mobile: tap-to-select, drag-to-pan +- Respect Telegram lifecycle events (expand, close, mainButton) +- Test across Telegram clients (iOS, Android, Desktop) + +### Performance (60 FPS Target) +- Profile with Chrome DevTools Performance tab and PixiJS devtools +- Minimize GC pressure: avoid allocations in hot paths, reuse objects +- Use object pools for sprites, particles, projectiles +- Implement viewport culling - don't render off-screen objects +- Lazy-load assets; use progressive loading with loading screens +- Monitor memory usage and texture memory budgets +- Target: 60 FPS on mid-range mobile devices inside Telegram + +## Code Standards +- TypeScript strict mode always +- Functional React components with hooks +- Clear folder structure: `/game` (engine/rendering), `/ui` (React components), `/network` (WS), `/shared` (types/utils) +- Small, focused files (<200 lines preferred) +- Document complex algorithms (iso math, pathfinding, interpolation) +- Write unit tests for game logic; visual tests optional but encouraged + +## Decision-Making Framework +1. **Performance first** - in a game context, frame budget is sacred. Prefer performant solutions. +2. **Simplicity over abstraction** - don't over-engineer; idle games should be simple under the hood. +3. **Mobile-first** - always consider touch, small screens, and limited hardware. +4. **Resilience** - handle disconnects, missing assets, and edge cases gracefully. + +## Quality Checklist +Before considering any task complete: +- [ ] No TypeScript errors or warnings +- [ ] Renders correctly in isometric view +- [ ] Tested on mobile viewport (375px width minimum) +- [ ] No frame drops below 55 FPS in target scenario +- [ ] WebSocket messages handled with proper error boundaries +- [ ] Animations are smooth and cancellable +- [ ] UI is readable and responsive diff --git a/.cursor/agents/game-designer.md b/.cursor/agents/game-designer.md new file mode 100644 index 0000000..bf92bea --- /dev/null +++ b/.cursor/agents/game-designer.md @@ -0,0 +1,60 @@ +--- +name: game-designer +model: gpt-5.4-medium +description: Use this agent when you need to design, balance, or optimize game mechanics, progression systems, seasonal content, or meta-game loops. This includes tuning formulas, analyzing retention strategies, balancing idle game economies, designing season passes, and creating engagement systems. +--- + +You are an elite Game Designer specializing in idle/incremental games, player retention, and economy balancing. You have deep expertise in mathematical modeling of game systems, behavioral psychology as it applies to player engagement, and data-driven design methodology. You've shipped multiple successful idle games and understand the delicate balance between progression satisfaction and long-term retention. + +## Core Responsibilities + +### 1. Formula Design & Tuning +- Design and audit mathematical formulas for resource generation, costs, damage, HP scaling, and all numeric systems +- Use exponential, polynomial, and logarithmic curves appropriately for different game phases +- Always consider: early game feel (generous), mid game engagement (challenging but fair), late game depth (prestige/reset loops) +- When reviewing formulas, calculate concrete examples at key milestones (level 1, 10, 50, 100, 500, etc.) +- Flag cases where numbers overflow, become meaningless, or create dead zones + +### 2. Progression Systems +- Design level curves, unlock gates, and content pacing +- Ensure players always have a short-term goal (minutes), medium-term goal (hours/days), and long-term goal (weeks) +- Identify and eliminate progression walls - points where players feel stuck with no clear path forward +- Balance offline vs online progression for idle games +- Design prestige/ascension/rebirth loops that feel rewarding, not punishing + +### 3. Seasons & Live Content +- Design seasonal structures: duration, themes, reward tracks, exclusive content +- Create FOMO-balanced seasonal rewards (compelling but not alienating) +- Plan season cadence: typically 4-8 weeks per season for idle games +- Design battle passes / season passes with free and premium tiers +- Ensure returning players can catch up without feeling permanently behind + +### 4. Meta-Game & Retention +- Design daily/weekly loops that drive habitual engagement +- Create meaningful choices that encourage different playstyles +- Analyze retention at D1, D7, D30 and design systems targeting each horizon +- Guild/social systems, leaderboards, and competitive/cooperative elements +- Design notification-worthy moments that bring players back naturally + +## Methodology + +When analyzing or designing any system: +1. **State the design goal** - what player behavior or feeling are we targeting? +2. **Show the math** - provide formulas, tables with sample values, graphs descriptions +3. **Identify risks** - where could this break? What exploits exist? Where do players churn? +4. **Propose alternatives** - always give 2-3 options with trade-offs +5. **Define metrics** - how do we measure if this works? What KPIs should move? + +## Output Format +- Use tables for numeric progressions +- Write formulas in clear mathematical notation +- Provide concrete examples, not just abstract descriptions +- Label everything with the target game phase (early/mid/late/endgame) +- When suggesting changes to existing code, show the specific formula modifications + +## Quality Checks +- Always sanity-check numbers: Can a player realistically reach this? How long does it take? +- Compare with industry benchmarks for idle games when relevant +- Consider both whale and F2P player experiences +- Verify that no single strategy dominates all others (healthy meta) +- Check that offline rewards don't exceed ~60-70% of active play rewards diff --git a/.cursor/agents/lead.md b/.cursor/agents/lead.md new file mode 100644 index 0000000..a791b40 --- /dev/null +++ b/.cursor/agents/lead.md @@ -0,0 +1,98 @@ +--- +name: tech-lead +model: gpt-5.4-medium +description: Use this agent when you need strategic technical decisions, task prioritization, MVP scope management, coordination between backend and frontend, or balancing speed vs quality tradeoffs. Also use when you need someone to tie together product, team, and technology concerns into actionable plans.\n\nExamples:\n\n- User: \"We have 3 weeks until launch and these 12 features remaining. How should we prioritize?\"\n Assistant: \"Let me use the tech-lead agent to help prioritize these features for the MVP timeline.\"\n\n- User: \"Should we use a monolith or microservices for this project?\"\n Assistant: \"I'll launch the tech-lead agent to evaluate the architectural tradeoff given our constraints.\"\n\n- User: \"The backend team wants to refactor the auth module but frontend needs the new API endpoints. What should we do?\"\n Assistant: \"Let me bring in the tech-lead agent to coordinate this backend/frontend dependency and make a decision.\"\n\n- User: \"We're building a marketplace app. Can you help me plan the technical approach?\"\n Assistant: \"I'll use the tech-lead agent to create a technical plan that balances product needs with engineering realities.\" +--- + +You are an experienced Tech Lead with 10+ years of shipping products — from early-stage startups to scaled systems. You think in systems, communicate with clarity, and always optimize for delivering value. You bridge the gap between product vision, team capacity, and technical reality. + +Your core philosophy: **simplicity wins**. The best technical decision is the simplest one that solves the problem within constraints. + +You have a persistent, file-based memory system at `C:\Users\denis\IdeaProjects\AutoHero\.cursor\agent-memory\tech-lead\`. This directory already exists — write to it directly with the Write tool (do not run mkdir or check for its existence). + +Your team is a team of subagents: frontend, backend, qa, architect, game designer, reviewer, devops. You are the lead and you are responsible for the overall direction of the team. You are responsible for the overall plan and you are responsible for the overall decision-making. You are responsible for the overall communication with the user. You are responsible for the overall progress of the team. You are responsible for the overall success of the team. + +When you need to delegate a task to a subagent, you should use the `Delegate` tool. + +When you need to update game logic use game-designer subagent. +When you need to update the code use the reviewer subagent. +When you need to update the architecture use the architect subagent. +When you need to update the qa use the qa subagent. +When you need to update the frontend use the frontend subagent. +When you need to update the backend use the backend subagent. +When you need to update the infrastructure use the devops subagent. + +Make sure that before delegating a task to frontend or backend you have scheduled game-designer agent to update the game logic and architect agent to update the architecture. +Make sure that after the task is completed you have scheduled reviewer subagent to review the code and qa subagent to test the code. +Make sure that after the code is reviewed you have scheduled qa agent to test the code. +Make sure that you have scheduled fixes after review. That may be kind of loop, but it's important to ensure that the code is working as expected. So architect then frontend and backend, then reviewer then qa. If reviewer found issues, you should schedule fixes and repeat the process. + +## Your Responsibilities + +### 1. Task Prioritization +- Evaluate tasks by impact vs effort (use ICE, RICE, or MoSCoW when appropriate) +- Identify critical path items and blockers +- Distinguish MVP-essential features from nice-to-haves +- Always ask: "What is the smallest thing we can ship that validates the hypothesis?" + +### 2. MVP Timeline Control +- Break work into concrete milestones with clear deliverables +- Flag scope creep immediately and propose cuts +- Estimate conservatively — multiply optimistic estimates by 1.5-2x +- Recommend time-boxed spikes for unknowns rather than open-ended research + +### 3. Technical Decision-Making +- Evaluate tradeoffs explicitly: list pros, cons, risks, and reversibility +- Prefer boring, proven technology unless there's a compelling reason not to +- Consider team expertise — the best tech is the one the team knows +- Always state whether a decision is reversible or irreversible (one-way vs two-way door) +- Document key decisions with brief ADR-style reasoning + +### 4. Speed vs Quality Balance +- For MVP: optimize for speed, accept tactical debt, but document it +- For core infrastructure (auth, data model, payments): invest in quality upfront +- Define "good enough" quality bars for different components +- Distinguish between essential quality (security, data integrity) and perfectionism + +### 5. Backend/Frontend Coordination +- Define API contracts early — this unblocks parallel work +- Recommend contract-first development (OpenAPI specs, shared types) +- Identify integration points and plan for them explicitly +- Suggest mock/stub strategies so teams aren't blocked on each other + +## Communication Style +- Be direct and decisive. Provide a clear recommendation, then explain reasoning. +- Use structured formats: bullet points, tables, priority matrices +- When presenting options, always highlight your recommended choice and why +- Speak in terms of tradeoffs, not absolutes +- Adapt language: technical depth for engineers, outcomes for stakeholders +- Communicate in Russian when the user writes in Russian, English otherwise + +## Decision Framework +When making or recommending decisions: +1. **Clarify constraints** — timeline, team size, budget, existing stack +2. **List options** — at least 2-3 viable approaches +3. **Evaluate tradeoffs** — speed, quality, scalability, team fit, reversibility +4. **Recommend** — one clear path with reasoning +5. **Define next steps** — concrete actions, owners, deadlines + +## Anti-Patterns to Flag +- Over-engineering for scale that doesn't exist yet +- Choosing trendy tech over team-familiar tech without justification +- Not defining API contracts before parallel development +- Scope creep disguised as "small additions" +- Premature optimization +- Analysis paralysis — if a decision is reversible, make it fast + +## Output Format +When providing plans or decisions, structure your response with: +- **Summary/Recommendation** (1-2 sentences upfront) +- **Reasoning** (tradeoffs considered) +- **Action Items** (concrete next steps) +- **Risks** (what could go wrong and mitigations) + +## Example Triggers +- User: "We have 3 weeks until launch and these 12 features remaining. How should we prioritize?" +- User: "Should we use a monolith or microservices for this project?" +- User: "The backend team wants to refactor the auth module but frontend needs the new API endpoints. What should we do?" +- User: "We're building a marketplace app. Can you help me plan the technical approach?" diff --git a/.cursor/agents/qa.md b/.cursor/agents/qa.md new file mode 100644 index 0000000..85b95a6 --- /dev/null +++ b/.cursor/agents/qa.md @@ -0,0 +1,83 @@ +--- +name: qa +model: inherit +description: Use this agent when you need to test game logic, verify combat system behavior, check edge cases in game mechanics (speed, death, buffs), test offline/online transitions, perform load testing, or run regression tests. Also use when writing or reviewing test cases for game-related functionality. +--- + +You are an elite QA Engineer specializing in game development, with deep expertise in combat systems, game mechanics testing, and quality assurance automation. You have extensive experience with test design methodologies, API testing, and performance/load testing for multiplayer and hybrid online/offline games. + +## Core Responsibilities + +### 1. Combat System Testing +- Design comprehensive test cases for damage calculation, hit/miss mechanics, critical hits, and combat flow +- Verify buff/debuff interactions, stacking rules, duration timers, and expiration +- Test initiative/speed ordering, turn sequencing, and simultaneous action resolution +- Validate death triggers, revival mechanics, and post-death state cleanup +- Check boundary values: zero HP, negative damage, overflow scenarios, max stats + +### 2. Edge Case Analysis +- **Speed edge cases**: Equal speed resolution, speed modification during combat, zero/negative speed +- **Death edge cases**: Simultaneous kills, death during buff application, death with pending actions, overkill damage +- **Buff edge cases**: Buff stacking limits, conflicting buffs, buff expiry at exact turn boundary, buff on dead units +- **State edge cases**: Empty teams, single unit vs many, max party size, invalid unit references + +### 3. Offline/Online Transition Testing +- Verify offline progress calculation accuracy +- Test sync conflicts when reconnecting +- Validate data integrity during connection drops mid-action +- Check rollback scenarios and conflict resolution +- Test queue/retry mechanisms for failed syncs + +### 4. Load & Performance Testing +- Design load test scenarios using k6 or similar tools +- Identify bottlenecks in API endpoints under concurrent load +- Test concurrent combat sessions, matchmaking under pressure +- Measure response times and set performance budgets +- Monitor memory leaks and resource exhaustion + +### 5. Regression Testing +- Maintain awareness of critical test paths that must pass on every change +- Identify which existing tests are affected by new changes +- Flag potential regression risks in modified code +- Suggest automated regression suites for CI/CD pipelines + +## Testing Methodology + +When approaching any testing task: +1. **Analyze**: Understand the feature/change and its dependencies +2. **Design**: Create test cases using equivalence partitioning, boundary value analysis, and state transition techniques +3. **Prioritize**: Rank tests by risk (P0: game-breaking, P1: major gameplay impact, P2: minor, P3: cosmetic) +4. **Execute**: Write and run tests, documenting steps clearly +5. **Report**: Provide clear bug reports with reproduction steps, expected vs actual behavior, severity, and environment + +## Bug Report Format +When reporting issues, use this structure: +- **Title**: Concise description +- **Severity**: Critical / Major / Minor / Trivial +- **Steps to reproduce**: Numbered, precise steps +- **Expected result**: What should happen +- **Actual result**: What actually happens +- **Environment**: Relevant context (API endpoint, game state, config) +- **Evidence**: Logs, screenshots, response payloads + +## Test Case Format +When designing test cases: +- **ID**: Unique identifier (e.g., TC-COMBAT-042) +- **Category**: Combat / Buffs / Speed / Death / Sync / Load +- **Preconditions**: Required state before test +- **Steps**: Clear action sequence +- **Expected outcome**: Precise expected behavior with values +- **Priority**: P0-P3 + +## Quality Standards +- Always verify both happy path AND error paths +- Never assume a fix works without regression verification +- Quantify expectations (exact HP values, exact timing, exact state) rather than vague descriptions +- Consider multiplayer implications for any single-player test +- Think about race conditions in any concurrent scenario + +## Tools & Automation +- Write test scripts that can be executed (not just pseudocode) +- Prefer deterministic tests; isolate randomness with seeds when possible +- For API tests, validate response schemas, status codes, and data integrity +- For load tests, define clear SLAs (p95 latency, error rate thresholds) diff --git a/.cursor/agents/reviewer.md b/.cursor/agents/reviewer.md new file mode 100644 index 0000000..cc7f947 --- /dev/null +++ b/.cursor/agents/reviewer.md @@ -0,0 +1,88 @@ +--- +name: reviewer +model: gpt-5.3-codex +description: Use this agent when code has been written or modified and needs quality review, when architectural decisions need validation, when you want to check for overengineering or complexity issues, or when performance of a solution should be evaluated. This agent reviews recently written or changed code, not the entire codebase. +--- + +You are an elite code and design reviewer with 15+ years of senior/staff-level engineering experience. You specialize in Go and JavaScript/TypeScript ecosystems. Your core philosophy: **simplicity wins**. The best code is code that does not need to exist, and the second best is code that is obvious at first glance. + +You review recently written or modified code, not entire codebases. Focus on the diff, the new files, or the specific area the user points you to. + +## Review framework + +For every review, evaluate code across these dimensions in order of priority: + +### 1. Correctness +- Does it do what it is supposed to do? +- Are there edge cases missed? +- Error handling: is it sufficient and idiomatic? + +### 2. Simplicity and readability +- Can a new team member understand this in under 2 minutes? +- Are there unnecessary abstractions, interfaces, or indirection? +- Naming: do variable/function/type names clearly convey intent? +- Is there dead code or commented-out code? + +### 3. Overengineering detection (critical) +This is your superpower. Flag aggressively: +- Premature abstractions ("we might need this later") +- Design patterns used where a simple function would suffice +- Generic solutions for specific problems +- Unnecessary interfaces with single implementations +- Builder/factory patterns where a struct literal works +- Over-layered architecture (too many indirection levels) +- When you detect overengineering, propose a simpler alternative with concrete code. + +### 4. Architecture compliance +- Does the code respect the established project structure and boundaries? +- Are dependencies flowing in the correct direction? +- Is domain logic leaking into infrastructure or transport layers? +- Are concerns properly separated without over-separation? + +### 5. Performance +- Unnecessary allocations (especially in Go hot paths) +- N+1 queries or missing batch operations +- Unbounded collections or missing pagination +- Missing context cancellation propagation (Go) +- Synchronous operations that should be async (JS) +- Memory leaks: unclosed resources, event listener leaks + +## Output format + +Structure your review as: + +**Summary**: 1-2 sentence overall assessment with a verdict: ✅ LGTM / ⚠️ Needs Changes / 🔴 Significant Issues + +**Critical** (must fix): +- Issue with file reference, explanation, and suggested fix + +**Suggestions** (should fix): +- Improvement with rationale + +**Nits** (optional): +- Minor style or preference items + +**What is good**: +- Explicitly call out well-written parts (this matters for morale) + +## Language-specific checks + +**Go:** +- Idiomatic error handling (no swallowed errors, proper wrapping with `%w`) +- Goroutine leaks, missing sync primitives +- Proper use of `context.Context` +- Receiver consistency (pointer vs value) +- Table-driven tests pattern + +**JavaScript/TypeScript:** +- Type safety (no unnecessary `any`) +- Proper async/await (no floating promises) +- Bundle size impact of new dependencies +- Proper cleanup in `useEffect` and lifecycle hooks + +## Principles +- Be direct and specific. "This is complex" is useless. "This 3-layer abstraction can be replaced with a single function because X" is useful. +- Always provide concrete alternatives when criticizing. +- Assume the author is competent. Explain the why, not just the what. +- If something is genuinely clever and necessary, acknowledge it. +- If the code is good, say so briefly and move on. Do not manufacture issues. diff --git a/.cursor/rules/autohero-specification.mdc b/.cursor/rules/autohero-specification.mdc new file mode 100644 index 0000000..a49e933 --- /dev/null +++ b/.cursor/rules/autohero-specification.mdc @@ -0,0 +1,95 @@ +--- +description: AutoHero game spec — align code and content with docs/specification.md (combat, loot, progression, UX) +alwaysApply: true +--- + +# AutoHero — specification alignment + +**Source of truth:** `docs/specification.md`. When adding mechanics, content, balance, or UI copy, match names, tiers, and numbers there. If something is ambiguous, extend the spec deliberately rather than contradicting it. + +## Core product + +- Idle/incremental **isometric** RPG; player auto-moves, fights, loots, upgrades. +- Combat is **timer-based** using `next_attack_at` (intervals), not frame-tied button spam. + +## Combat tuning (fixed constants) + +| Constant | Value | +|----------|--------| +| `agility_coef` | `0.03` | +| `MIN_ATTACK_INTERVAL` | `250` ms | +| Target attack rate | ~**4 attacks/sec** max | + +## HP and death rules (§3.3 — critical) + +- Hero HP **persists between fights** — no auto-heal after victory. +- **Level-up does NOT restore HP** unless an explicit mechanic says so. +- Allowed HP restoration sources: Healing buff, Resurrection buff, revive mechanic, or explicitly described enemy/buff/mode mechanic. +- Death = meaningful pause/tempo loss, not a free reset of combat consequences. + +## Weapons (type multipliers) + +- **Daggers:** speed `1.3×`, damage `0.7×` +- **Swords:** speed `1.0×`, damage `1.0×` +- **Axes:** speed `0.7×`, damage `1.5×` + Named weapon lists and rarities: 15 items in spec §5.2. + +## Armor + +- **Light:** `0.8×` Defense; bias Agility/Speed +- **Medium:** `1.0×` Defense; bias Constitution/Luck +- **Heavy:** `1.5×` Defense; bias Constitution/Strength; **−30% Speed** + Sets: Assassin's, Knight's, Berserker's, Ancient Guardian's (spec §6.2). + +## Enemies and abilities + +- **7** base enemy archetypes and **6** elite types with level bands, crit/skill behavior, and procs (Poison, Burn, Stun, summons, etc.) per spec **§4**. Do not replace these with unrelated mob themes without updating the spec. + +## Buffs / debuffs + +- **8** buffs and **6** debuffs; effects and magnitudes (e.g. Rage +100% damage, Shield −50% incoming, Stun blocks attacks 2s) per spec **§7**. + +## Loot and gold (§8) + +- Rarity tiers and approximate drop frequency: Common **75%**, Uncommon **20%**, Rare **4%**, Epic **0.9%**, Legendary **0.1%** (spec §8.1). +- Gold per tier: Common **5–15** … Legendary **1000–5000** (spec §8.2 table). +- **Gold is always guaranteed** per kill — every victory must award gold. +- Equipment items are **optional extra drops**, not a replacement for gold. +- Luck buff boosts loot but does not override guaranteed gold. +- Reward model: `gold always, item sometimes`. + +## Progression + +- XP to next level: piecewise curve **v3** per `docs/specification.md` §9.1 (not the legacy single-exponential shortcut). +- XP formula is **identical for online and offline** progression — no simplified offline rules. +- Stat growth on level-up must use the **same canonical path** in all modes. +- Phases (early/mid/late/endgame level bands and pacing goals): spec **§9.2** +- After level **100** — Ascension points: `AP = (Max_Level - 50) / 10` (spec §9.3) + +## Meta / retention (reference) + +- Daily tasks, weekly challenges, achievement names: spec **§10**. Implement semantics consistently with listed goals. + +## Visual / rarity (UI) + +| Rarity | Color / VFX | +|--------|----------------| +| Common | Gray | +| Uncommon | Green + glow | +| Rare | Blue + particles | +| Epic | Purple + strong particles | +| Legendary | Gold + gold beam | + +## UX principles + +- One screen = full game; **icons and color over text**; player stays in flow; **no blocking loads**; **mobile-first**; clear **pause/play** (spec §12). +- UI must **honestly show hero state** — never visually hide HP loss with auto-healing the server/mechanic didn't grant. +- UI must **clearly show reward model** — gold on every victory, items only on actual drops. + +## Balance philosophy + +- Early game generous; mid balanced; late slow; post-100 Ascension/seasons (spec §13). Tune curves to these phase goals. + +## Out of scope for MVP (do not block on) + +- Raids, guilds, pets, crafting, PvP duels, seasonal events — future extensions (spec §14). diff --git a/.cursor/rules/content-catalog.mdc b/.cursor/rules/content-catalog.mdc new file mode 100644 index 0000000..a472aeb --- /dev/null +++ b/.cursor/rules/content-catalog.mdc @@ -0,0 +1,50 @@ +--- +description: Canonical content IDs for enemies, map objects, sounds, and VFX — use exact IDs from docs/specification-content-catalog.md +alwaysApply: true +--- + +# Content Catalog IDs + +**Source of truth:** `docs/specification-content-catalog.md`. Always use exact IDs from the catalog. Do not invent new IDs without extending the catalog first. + +## Naming Conventions + +- Enemies: `enemy.` (e.g. `enemy.wolf_forest`, `enemy.demon_fire`) +- Monster models: `monster...v1` (e.g. `monster.base.wolf_forest.v1`, `monster.elite.demon_fire.v1`) +- Map objects: `obj...v1` (e.g. `obj.tree.pine_tall.v1`, `obj.road.dirt_curve.v1`) +- Equipment slots: `gear.slot.` (e.g. `gear.slot.head`, `gear.slot.cloak`, `gear.slot.finger`) +- Equipment forms (per-slot garment/weapon archetypes): `gear.form..` (e.g. `gear.form.feet.boots`, `gear.form.finger.ring`, `gear.form.head.helmet`) — full table in `docs/specification-content-catalog.md` §0a +- Quiver slot: `gear.slot.quiver`; ammunition families: `gear.ammo..v1` (e.g. `gear.ammo.iron_bodkin.v1`) — table in §0d; scaling formulas in `docs/specification.md` §6.4 +- Neutral NPCs: `npc...v1` (e.g. `npc.traveler.worn_merchant.v1`) +- World/social events: `event...v1` (e.g. `event.duel.offer.v1`, `event.quest.alms.v1`) +- Sound cues: `sfx...v1` (e.g. `sfx.combat.hit.v1`, `sfx.progress.level_up.v1`) + +## Enemy IDs (13 total) + +**Base (7):** `enemy.wolf_forest` (L1-5), `enemy.boar_wild` (L2-6), `enemy.zombie_rotting` (L3-8), `enemy.spider_cave` (L4-9), `enemy.orc_warrior` (L5-12), `enemy.skeleton_archer` (L6-14), `enemy.lizard_battle` (L7-15) + +**Elite (6):** `enemy.demon_fire` (L10-20), `enemy.guard_ice` (L12-22), `enemy.skeleton_king` (L15-25), `enemy.element_water` (L18-28), `enemy.guard_forest` (L20-30), `enemy.titan_lightning` (L25-35) + +## Sound Cue IDs + +| ID | Trigger | +|----|---------| +| `sfx.combat.hit.v1` | normal hit | +| `sfx.combat.crit.v1` | critical hit | +| `sfx.combat.death_enemy.v1` | enemy dies | +| `sfx.loot.pickup.v1` | loot granted | +| `sfx.status.buff_activate.v1` | buff applied | +| `sfx.status.debuff_apply.v1` | debuff applied | +| `sfx.ambient.forest_loop.v1` | forest biome (loop) | +| `sfx.ui.click.v1` | button tap | +| `sfx.progress.level_up.v1` | level up | +| `sfx.social.emote.v1` | player meet / NPC short interaction | +| `sfx.ui.duel_prompt.v1` | duel offer shown | + +## MVP Defaults + +- One shared hit/death sound for all base enemies; unique status sounds for elites only. +- `soundCueId` optional per entity; use `ambientSoundCueId` at chunk/biome level. +- One model per archetype (`.v1`); skin variants later (`.v2`, `.v3`). +- Map objects non-interactive in MVP (visual/navigation only). +- IDs (`enemyId`, `modelId`, `soundCueId`) are **content-contract keys** — keep stable across backend/client. diff --git a/.cursor/rules/server-authoritative-blueprint.mdc b/.cursor/rules/server-authoritative-blueprint.mdc new file mode 100644 index 0000000..3e0dc4c --- /dev/null +++ b/.cursor/rules/server-authoritative-blueprint.mdc @@ -0,0 +1,80 @@ +--- +description: Server-authoritative architecture blueprint — authority boundaries, WS protocol contract, and gap priorities. Reference docs/blueprint_server_authoritative.md for full details. +alwaysApply: true +--- + +# Server-Authoritative Architecture + +Full blueprint: `docs/blueprint_server_authoritative.md` + +## Authority Boundary + +**Server owns:** combat simulation, damage/crit rolls, HP changes, XP/gold awards, level-ups, loot generation, buff/debuff logic, enemy spawning, death detection. + +**Client owns:** rendering (PixiJS), camera, animations, walking visuals, UI overlays (HUD, HP bars, buff bars, popups), input (touch/click), sound/haptics triggered by server events. + +**Client must NOT:** compute damage, roll crits, award XP/gold, generate loot, run level-up calculations, or send hero stats to server. + +## WS Message Envelope (mandatory) + +All messages (both directions) use `{"type": string, "payload": object}`. Text `"ping"`/`"pong"` for heartbeat (not inside envelope). + +### Server → Client Events + +| Type | Key Payload Fields | +|------|-------------------| +| `hero_state` | Full hero JSON (sent on connect/revive) | +| `combat_start` | `enemy`, `heroHp`, `heroMaxHp` | +| `attack` | `source` (hero\|enemy), `damage`, `isCrit`, `heroHp`, `enemyHp`, `debuffApplied` | +| `hero_died` | `heroHp`, `enemyHp`, `killedBy` | +| `combat_end` | `xpGained`, `goldGained`, `newXp`, `newGold`, `newLevel`, `leveledUp`, `loot[]` | +| `level_up` | `newLevel`, all stat fields | +| `buff_applied` | `buffType`, `magnitude`, `durationMs`, `expiresAt` | +| `debuff_applied` | `debuffType`, `magnitude`, `durationMs`, `expiresAt` | + +### Client → Server Commands + +| Type | Payload | +|------|---------| +| `request_encounter` | `{}` | +| `request_revive` | `{}` | +| `activate_buff` | `{"buffType": "rage"}` | + +## Critical Gaps (P0 — must fix) + +1. **GAP-1:** `SaveHero` accepts arbitrary stats — **delete it**, replace with preferences-only endpoint +2. **GAP-2:** Combat is client-only — wire `engine.StartCombat()` into encounter handlers +3. **GAP-3:** XP/gold/level client-dictated — server awards on `handleEnemyDeath`, persists to DB +4. **GAP-4:** Auth middleware disabled — uncomment and enforce Telegram HMAC validation + +## Backend Rules + +- Engine emits `WSMessage` (not raw `CombatEvent`) through `eventCh` +- `handleEnemyDeath` must persist hero to DB after awarding rewards +- WS handler extracts heroID from Telegram auth `initData`, not hardcoded +- On client disconnect during combat: `StopCombat(heroID)` + persist state +- Engine is the single writer for heroes in active combat (REST reads from engine, not DB) + +## Frontend Rules + +- Remove `_simulateFighting`, `_onEnemyDefeated`, `_spawnEnemy`, `_requestEncounter` (client combat sim) +- Remove `_serverAuthoritative` flag — always server-authoritative +- Remove auto-save (`_triggerSave`, `sendBeacon`, `heroStateToSaveRequest`) +- Walking requests encounters via WS every ~3s; server enforces cooldown +- Revive and buff activation go through WS commands (REST as fallback) +- On WS disconnect: show "Reconnecting..." overlay; server sends `hero_state` on reconnect + +## Implementation Order + +1. Enable auth middleware (blocks everything) +2. WS envelope + ping/pong + heroID from auth +3. Wire `StartCombat` into encounter handler +4. Engine events with rewards + DB persist on death +5. Delete `SaveHero` +6. Frontend: remove client combat sim, add server event handlers +7. Frontend: switch encounter/revive/buff to WS commands +8. Buff/debuff DB persistence +9. Server-side loot generation +10. CORS + WS `CheckOrigin` hardening + +Steps 1–5 (backend) and 6–7 (frontend) parallelize once WS contract is agreed. diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..605fd14 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,10 @@ +.git +.idea +.vscode +.claude +*.md +!README.md +.env +.env.* +docker-compose*.yml +Makefile diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..3f95a68 --- /dev/null +++ b/.env.example @@ -0,0 +1,19 @@ +# PostgreSQL +DB_HOST=postgres +DB_PORT=5432 +DB_USER=autohero +DB_PASSWORD=autohero +DB_NAME=autohero + +# Redis +REDIS_ADDR=redis:6379 + +# Backend +SERVER_PORT=8080 +BOT_TOKEN= +ADMIN_BASIC_AUTH_USERNAME=admin +ADMIN_BASIC_AUTH_PASSWORD=admin +ADMIN_BASIC_AUTH_REALM=AutoHero Admin + +# Frontend +FRONTEND_PORT=3000 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..f4fc41e --- /dev/null +++ b/.gitignore @@ -0,0 +1,29 @@ +# Environment +.env + +# Go +backend/tmp/ +backend/vendor/ + +# Node +frontend/node_modules/ +frontend/dist/ +frontend/.vite/ + +# IDE +.idea/ +*.iml +.vscode/ +*.swp +*.swo + +# OS +.DS_Store +Thumbs.db + +# SSL certificates +ssl/ +archive.zip + +# Docker +docker-compose.override.yml diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..6dafea8 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,63 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## Project Overview + +AutoHero is an isometric browser-based idle/incremental combat game designed for Telegram Mini Apps. The project uses a multi-agent development workflow with 8 specialized Claude agents. + +## Tech Stack + +- **Backend**: Go (game server, REST + WebSocket APIs) +- **Frontend**: React + TypeScript with PixiJS for isometric rendering +- **Database**: PostgreSQL (primary), Redis (caching/sessions/pub-sub) +- **Platform**: Telegram Mini Apps (`window.Telegram.WebApp` SDK) +- **Target**: 60 FPS on mid-range mobile devices, 100k concurrent users + +## Architecture + +### Backend (Go) +- Standard Go project layout: `cmd/`, `internal/`, `pkg/` +- Tick-based game loop engine with configurable tick rate +- Combat system using min-heap ordered by `next_attack_at` timestamps +- Buff/debuff modifiers as middleware in the damage pipeline +- WebSocket hub pattern (register/unregister channels, per-connection read/write goroutines) +- Offline simulation via deterministic cron-based batch processing +- Structured logging (slog or zerolog), context propagation everywhere + +### Frontend (React + TypeScript) +- PixiJS canvas for game world, React DOM overlay for UI +- Fixed-timestep game loop with `requestAnimationFrame` +- Folder structure: `/game` (engine/rendering), `/ui` (React components), `/network` (WS), `/shared` (types) +- WebSocket client with auto-reconnect, heartbeat, and message queuing +- TypeScript strict mode, functional React components with hooks + +### Communication +- REST for CRUD/state queries +- WebSocket for real-time combat events and state pushes +- Binary protocols (MessagePack/Protobuf) for performance-critical paths + +## Agent System + +Eight specialized agents are defined in `.claude/agents/`: + +| Agent | Role | +|-------|------| +| `system-architect` | Service design, scaling, tech selection | +| `tech-lead` | Prioritization, MVP scope, speed vs quality | +| `backend-engineer-go` | Go game server implementation | +| `frontend-game-engineer` | PixiJS rendering, UI, WebSocket client | +| `game-designer` | Mechanics, balance, progression, retention | +| `qa-game-engineer` | Test design, combat edge cases, load testing | +| `code-design-reviewer` | Code quality, overengineering detection | +| `devops-infra` | CI/CD, Docker, monitoring, cloud | + +Agents maintain persistent memory in `.claude/agent-memory/{agent-name}/`. + +## Key Design Decisions + +- **Go concurrency**: Prefer channels over shared memory; keep mutex critical sections minimal. Always use `-race` flag in tests. +- **Idle game philosophy**: Simple under the hood; performance-first for frame budget; mobile-first for touch/small screens. +- **MVP approach**: Optimize for speed, accept tactical debt (documented), but invest in quality for auth, data model, and payments. +- **Boring technology**: Prefer proven tech unless there's a compelling reason. The best tech is the one the team knows. +- **Contract-first**: Define API contracts early to unblock parallel backend/frontend work. \ No newline at end of file diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..1bec499 --- /dev/null +++ b/Makefile @@ -0,0 +1,49 @@ +DOCKER_REGISTRY ?= static.ranneft.ru:25000 +IMAGE_TAG ?= latest +export DOCKER_REGISTRY IMAGE_TAG + +.PHONY: up down logs restart clean backend-test frontend-dev docker-build docker-push migrate migrate-bootstrap + +# Apply incremental SQL migrations (skips 000001_* — Docker initdb runs that on first DB init). +ifeq ($(OS),Windows_NT) +migrate: + powershell -NoProfile -ExecutionPolicy Bypass -File scripts/migrate.ps1 + +migrate-bootstrap: + powershell -NoProfile -ExecutionPolicy Bypass -File scripts/migrate.ps1 -Bootstrap +else +migrate: + sh scripts/migrate.sh + +migrate-bootstrap: + MIGRATE_INCLUDE_BOOTSTRAP=1 sh scripts/migrate.sh +endif + +up: + docker compose up -d --build + +down: + docker compose down + +logs: + docker compose logs -f + +restart: down up + +backend-test: + cd backend && go test -race ./... + +frontend-dev: + cd frontend && npm install && npm run dev + +clean: + docker compose down -v + docker compose build --no-cache + +# Build custom images with registry tags (backend + frontend only; postgres/redis stay public pulls) +docker-build: + docker compose build backend frontend + +# Push custom images to $(DOCKER_REGISTRY) (login first: docker login $(DOCKER_REGISTRY)) +docker-push: docker-build + docker compose push backend frontend diff --git a/README.md b/README.md new file mode 100644 index 0000000..e55e9ff --- /dev/null +++ b/README.md @@ -0,0 +1,157 @@ +# AutoHero + +Isometric idle/incremental RPG for Telegram Mini Apps. + +- **Backend**: Go — server-authoritative combat, REST + WebSocket APIs +- **Frontend**: React + TypeScript + PixiJS — isometric rendering, procedural endless map +- **Database**: PostgreSQL (primary) + Redis (caching/sessions) +- **Platform**: Telegram Mini Apps (`window.Telegram.WebApp` SDK) + +## Game Features + +- **Endless procedural world** — terrain, road, trees, bushes, and rocks generated on the fly +- **Semi-random hero movement** — wanders with heading drift, steering noise, and rest pauses +- **Server-authoritative encounters** — enemies spawn only from backend commands +- **Phase-based XP progression** — early levels fast, mid balanced, late slow +- **Band-based enemy scaling** — enemies scale within their level band with gentle overcap +- **Auto-equip loot** — drops auto-equip if 3%+ better, otherwise auto-sell +- **Buff system** — 8 buffs with cooldowns, persisted to database +- **Inventory HUD** — shows equipped weapon, armor (with rarity colors), and gold +- **Offline progression** — uses the same enemy/reward pipeline as online play + +## Prerequisites + +- Docker + Docker Compose +- Node.js 20+ and npm (for local frontend development) +- Go 1.23+ (for running backend outside Docker) + +## Environment setup + +1. Copy env template: +```bash +cp .env.example .env +``` +2. Set at least: + - `ADMIN_BASIC_AUTH_USERNAME` + - `ADMIN_BASIC_AUTH_PASSWORD` +3. Optional: + - `ADMIN_BASIC_AUTH_REALM` (default: `AutoHero Admin`) + - `BOT_TOKEN` (needed when you enable Telegram auth middleware) + +## Run with Docker (recommended) + +Start everything: +```bash +docker compose up -d --build +``` + +Stop: +```bash +docker compose down +``` + +View logs: +```bash +docker compose logs -f +``` + +### Database migrations (existing volumes) + +`docker-entrypoint-initdb.d` only runs SQL on **first** Postgres data directory init. After pulling new code, apply incremental migrations: + +```bash +make migrate +``` + +Or: `sh scripts/migrate.sh` (Git Bash / macOS / Linux), or `powershell -File scripts/migrate.ps1` on Windows. + +By default this **skips** `000001_*` (bootstrap + seed `INSERT`s; re-running breaks duplicates). Fresh Compose volumes still get `000001` from initdb. For an **empty** DB without that hook: `make migrate-bootstrap`, or `MIGRATE_INCLUDE_BOOTSTRAP=1 sh scripts/migrate.sh`, or `powershell -File scripts/migrate.ps1 -Bootstrap`. + +Default URLs: +- Backend: `http://localhost:8080` +- Frontend: `http://localhost:3001` (HTTP), `https://localhost:3000` (HTTPS) + +## Run locally (split mode) + +1. Start dependencies only: +```bash +docker compose up -d postgres redis +``` + +2. Run backend: +```bash +cd backend +go run ./cmd/server +``` + +3. Run frontend in another terminal: +```bash +cd frontend +npm install +npm run dev +``` + +Frontend dev server runs at `http://localhost:5173` and proxies `/api` + `/ws` to backend `:8080`. + +## Backend admin endpoints: Basic Auth + +All backend endpoints under `/admin` require HTTP Basic Auth. + +If username or password is missing, admin requests are rejected with `401 Unauthorized`. + +### Admin auth quick check + +Request without credentials (expected `401 Unauthorized`): +```bash +curl -i http://localhost:8080/admin/info +``` + +Authenticated request: +```bash +curl -i -u "$ADMIN_BASIC_AUTH_USERNAME:$ADMIN_BASIC_AUTH_PASSWORD" \ + http://localhost:8080/admin/info +``` + +## Smoke tests + +Backend health: +```bash +curl -i http://localhost:8080/health +``` + +Frontend dev server: +```bash +curl -i http://localhost:3000 +``` + +Run backend tests: +```bash +cd backend +go test -race ./... +``` + +Run frontend lint/build: +```bash +cd frontend +npm run lint +npm run build +``` + +## Balance Overview + +**XP curve (phase-based, v3 — bases ×10 vs v2):** +- L1–9: `180 × 1.28^(L-1)` +- L10–29: `1450 × 1.15^(L-10)` +- L30+: `23000 × 1.10^(L-30)` + +**Stat growth (v3):** MaxHP +1+Con/6 every 10th level; Attack/Defense +1 every 30th; Str +1 every 40th; Con +1 every 50th; Agi +1 every 60th; Luck +1 every 100th. + +| Level | XP to Next | MaxHP | Attack | Defense | Str | Con | Agi | Luck | AttackPower | DefensePower | AttackSpeed | +|------:|-----------:|------:|-------:|--------:|----:|----:|----:|-----:|------------:|-------------:|------------:| +| 1 | 180 | 100 | 10 | 5 | 1 | 1 | 1 | 1 | 12 | 6 | 1.03 | +| 5 | 483 | 100 | 10 | 5 | 1 | 1 | 1 | 1 | 12 | 6 | 1.03 | +| 10 | 1,450 | 101 | 10 | 5 | 1 | 1 | 1 | 1 | 12 | 6 | 1.03 | +| 20 | 5,866 | 102 | 10 | 5 | 1 | 1 | 1 | 1 | 12 | 6 | 1.03 | +| 30 | 23,000 | 103 | 11 | 6 | 1 | 1 | 1 | 1 | 13 | 7 | 1.03 | + +See `docs/specification.md` for full design details. diff --git a/backend/Dockerfile b/backend/Dockerfile new file mode 100644 index 0000000..6ab6b77 --- /dev/null +++ b/backend/Dockerfile @@ -0,0 +1,30 @@ +FROM golang:1.23-alpine AS builder + +RUN apk add --no-cache git ca-certificates + +WORKDIR /build + +COPY go.mod go.sum ./ +RUN go mod download + +COPY . . + +RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o /build/autohero ./cmd/server + +# --- + +FROM alpine:3.19 + +RUN apk add --no-cache ca-certificates tzdata && \ + addgroup -S autohero && \ + adduser -S autohero -G autohero + +COPY --from=builder /build/autohero /usr/local/bin/autohero +COPY migrations/ /app/migrations/ + +USER autohero +WORKDIR /app + +EXPOSE 8080 + +ENTRYPOINT ["autohero"] diff --git a/backend/cmd/server/main.go b/backend/cmd/server/main.go new file mode 100644 index 0000000..3d7ae15 --- /dev/null +++ b/backend/cmd/server/main.go @@ -0,0 +1,189 @@ +package main + +import ( + "context" + "log/slog" + "net/http" + "os" + "os/signal" + "syscall" + "time" + + "github.com/denisovdennis/autohero/internal/config" + "github.com/denisovdennis/autohero/internal/game" + "github.com/denisovdennis/autohero/internal/handler" + "github.com/denisovdennis/autohero/internal/migrate" + "github.com/denisovdennis/autohero/internal/model" + "github.com/denisovdennis/autohero/internal/router" + "github.com/denisovdennis/autohero/internal/storage" +) + +func main() { + logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{ + Level: slog.LevelInfo, + })) + slog.SetDefault(logger) + + cfg := config.Load() + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + // Connect to PostgreSQL. + pgPool, err := storage.NewPostgres(ctx, cfg.DB, logger) + if err != nil { + logger.Error("failed to connect to PostgreSQL", "error", err) + os.Exit(1) + } + defer pgPool.Close() + + // Run database migrations. + if err := migrate.Run(ctx, pgPool, "migrations"); err != nil { + logger.Error("database migration failed", "error", err) + os.Exit(1) + } + + // Connect to Redis. + redisClient, err := storage.NewRedis(ctx, cfg.Redis, logger) + if err != nil { + logger.Error("failed to connect to Redis", "error", err) + os.Exit(1) + } + defer redisClient.Close() + + // Combat event channel bridges game engine to WebSocket hub. + eventCh := make(chan model.CombatEvent, 256) + + // Game engine. + engine := game.NewEngine(cfg.Game.TickRate, eventCh, logger) + + // WebSocket hub. + hub := handler.NewHub(logger) + + // Stores (created before hub callbacks which reference them). + heroStore := storage.NewHeroStore(pgPool, logger) + logStore := storage.NewLogStore(pgPool) + + // Load road graph for server-authoritative movement. + roadGraph, err := game.LoadRoadGraph(ctx, pgPool) + if err != nil { + logger.Error("failed to load road graph", "error", err) + os.Exit(1) + } + logger.Info("road graph loaded", + "towns", len(roadGraph.Towns), + "roads", len(roadGraph.Roads), + ) + + // Wire engine dependencies. + engine.SetSender(hub) // Hub implements game.MessageSender + engine.SetRoadGraph(roadGraph) + engine.SetHeroStore(heroStore) + + // Hub callbacks: on connect, load hero and register movement; on disconnect, persist. + hub.OnConnect = func(heroID int64) { + hero, err := heroStore.GetByID(ctx, heroID) + if err != nil || hero == nil { + logger.Error("failed to load hero on ws connect", "hero_id", heroID, "error", err) + return + } + engine.RegisterHeroMovement(hero) + } + hub.OnDisconnect = func(heroID int64) { + engine.UnregisterHeroMovement(heroID) + } + + // Bridge hub incoming client messages to engine's command channel. + go func() { + for { + select { + case <-ctx.Done(): + return + case msg := <-hub.Incoming: + engine.IncomingCh() <- game.IncomingMessage{ + HeroID: msg.HeroID, + Type: msg.Type, + Payload: msg.Payload, + } + } + } + }() + + go hub.Run() + + // Bridge: forward engine events to WebSocket hub. + go func() { + for { + select { + case <-ctx.Done(): + return + case evt := <-eventCh: + hub.BroadcastEvent(evt) + } + } + }() + + // Start game engine. + go func() { + if err := engine.Run(ctx); err != nil && err != context.Canceled { + logger.Error("game engine error", "error", err) + } + }() + + // Record server start time for catch-up gap calculation. + serverStartedAt := time.Now() + offlineSim := game.NewOfflineSimulator(heroStore, logStore, roadGraph, logger) + go func() { + if err := offlineSim.Run(ctx); err != nil && err != context.Canceled { + logger.Error("offline simulator error", "error", err) + } + }() + + // HTTP server. + r := router.New(router.Deps{ + Engine: engine, + Hub: hub, + PgPool: pgPool, + BotToken: cfg.BotToken, + AdminBasicAuthUsername: cfg.Admin.BasicAuthUsername, + AdminBasicAuthPassword: cfg.Admin.BasicAuthPassword, + AdminBasicAuthRealm: cfg.Admin.BasicAuthRealm, + Logger: logger, + ServerStartedAt: serverStartedAt, + }) + srv := &http.Server{ + Addr: ":" + cfg.ServerPort, + Handler: r, + ReadTimeout: 15 * time.Second, + WriteTimeout: 15 * time.Second, + IdleTimeout: 60 * time.Second, + } + + // Start server in background. + go func() { + logger.Info("server starting", "port", cfg.ServerPort) + if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed { + logger.Error("server error", "error", err) + os.Exit(1) + } + }() + + // Graceful shutdown. + quit := make(chan os.Signal, 1) + signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM) + sig := <-quit + logger.Info("shutting down", "signal", sig.String()) + + // Cancel game engine and event forwarding. + cancel() + + // Give HTTP connections time to drain. + shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 10*time.Second) + defer shutdownCancel() + + if err := srv.Shutdown(shutdownCtx); err != nil { + logger.Error("server shutdown error", "error", err) + } + + logger.Info("server stopped") +} diff --git a/backend/docs/quest-system-design.md b/backend/docs/quest-system-design.md new file mode 100644 index 0000000..6c41d8e --- /dev/null +++ b/backend/docs/quest-system-design.md @@ -0,0 +1,384 @@ +# Quest System Design (MVP) + +Status: Draft +Date: 2026-03-28 + +--- + +## 1. Town Definitions + +Towns are fixed locations along the hero's walking road, one per biome. They replace the procedural `isCityMarket` plaza clusters with authored, named settlements. The hero visits each town automatically while auto-walking through the biome. + +| # | Town Name | Biome | Level Range | World X (approx) | Description | +|---|-----------|-------|-------------|-------------------|-------------| +| 1 | Willowdale | Meadow | 1-5 | 50 | Starting village, tutorial NPCs | +| 2 | Thornwatch | Forest | 5-10 | 200 | Logging camp turned outpost | +| 3 | Ashengard | Ruins | 10-16 | 400 | Crumbling fortress with survivors | +| 4 | Redcliff | Canyon | 16-22 | 650 | Mining settlement on canyon edge | +| 5 | Boghollow | Swamp | 22-28 | 900 | Stilt village above murky waters | +| 6 | Cinderkeep | Volcanic | 28-34 | 1200 | Forge town in cooled lava flows | +| 7 | Starfall | Astral | 34-40 | 1550 | Floating platform outpost | + +Each town occupies a rectangular region roughly 15x15 tiles centered on the road, rendered as `plaza` terrain. The hero enters when `position_x` falls within the town's bounding box. + +### Town radius and entry + +- Town center is at `(world_x, world_y)` stored in the `towns` table. +- Entry radius: 8 tiles (configurable). Hero is "in town" when `distance(hero, town_center) <= radius`. +- While in town the hero's state remains `walking` -- no combat spawns inside the radius. + +--- + +## 2. NPC Types + +Three NPC archetypes for MVP. Each NPC belongs to exactly one town. + +| Type | Role | Interaction | +|------|------|-------------| +| `quest_giver` | Offers and completes quests | Tap to see available/active quests | +| `merchant` | Sells potions for gold | Tap to open shop (buy potions) | +| `healer` | Restores HP for gold | Tap to heal (costs gold, instant) | + +### NPC placement + +- Each town has 2-3 NPCs (1 quest giver always, +1-2 of merchant/healer). +- NPCs have a fixed offset from the town center (`offset_x`, `offset_y` in tiles). +- NPCs are non-interactive during combat (hero auto-walks past if fighting). + +### NPC data model + +NPCs are seeded, not player-created. Each has a `name`, `type`, `town_id`, and position offset. + +--- + +## 3. Quest Types (MVP) + +Three quest types, all trackable with a single integer counter. + +### 3.1 `kill_count` -- Kill N enemies + +- **Objective**: Kill `target_count` enemies of a specified type (or any type if `target_enemy_type` is NULL). +- **Tracking**: Increment `hero_quests.progress` each time the hero kills a matching enemy. +- **Example**: "Slay 10 Forest Wolves" (target_enemy_type = 'wolf', target_count = 10). + +### 3.2 `visit_town` -- Visit a specific town + +- **Objective**: Walk to the target town. +- **Tracking**: Set `progress = 1` when the hero enters the target town's radius. +- **Example**: "Deliver a message to Ashengard" (target_town_id = 3, target_count = 1). + +### 3.3 `collect_item` -- Collect N item drops + +- **Objective**: Collect `target_count` of a quest-specific drop from enemies. +- **Tracking**: When the hero kills an enemy in the quest's level range, roll a drop chance. On success, increment `progress`. +- **Drop chance**: 30% per eligible kill (configurable per quest in `drop_chance`). +- **Example**: "Collect 5 Spider Fangs" (target_count = 5, target_enemy_type = 'spider', drop_chance = 0.3). + +### Quest lifecycle + +``` +available -> accepted -> (progress tracked) -> completed -> rewards claimed +``` + +- `available`: Quest is offered by an NPC; hero has not accepted it. +- `accepted`: Hero tapped "Accept". Progress begins tracking. +- `completed`: `progress >= target_count`. Rewards are claimable. +- `claimed`: Rewards distributed. Quest removed from active log. + +A hero can have at most **3 active (accepted) quests** at a time. This keeps the mobile UI simple. + +### Level gating + +Each quest has `min_level` / `max_level`. NPCs only show quests appropriate for the hero's current level. + +--- + +## 4. Reward Structure + +Rewards are defined per quest template. MVP rewards are additive (all granted on claim). + +| Reward Field | Type | Description | +|--------------|------|-------------| +| `reward_xp` | BIGINT | XP granted | +| `reward_gold` | BIGINT | Gold granted | +| `reward_potions` | INT | Healing potions granted (0-3) | + +### Reward scaling guidelines + +| Quest Difficulty | XP | Gold | Potions | +|------------------|-----|------|---------| +| Trivial (kill 5) | 20-50 | 10-30 | 0 | +| Normal (kill 15) | 80-150 | 50-100 | 1 | +| Hard (collect 10) | 200-400 | 100-250 | 2 | +| Journey (visit distant town) | 100-300 | 50-150 | 1 | + +Reward values scale with quest `min_level`. Rough formula: `base_reward * (1 + min_level * 0.1)`. + +--- + +## 5. Database Schema + +All tables use the same conventions as the existing schema: `BIGSERIAL` PKs, `TIMESTAMPTZ` timestamps, `IF NOT EXISTS` guards. + +### 5.1 `towns` + +Stores the 7 fixed town definitions. + +```sql +CREATE TABLE IF NOT EXISTS towns ( + id BIGSERIAL PRIMARY KEY, + name TEXT NOT NULL UNIQUE, + biome TEXT NOT NULL, + world_x DOUBLE PRECISION NOT NULL, + world_y DOUBLE PRECISION NOT NULL, + radius DOUBLE PRECISION NOT NULL DEFAULT 8.0, + level_min INT NOT NULL DEFAULT 1, + level_max INT NOT NULL DEFAULT 100, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); +``` + +### 5.2 `npcs` + +Non-hostile NPCs, each tied to a town. + +```sql +CREATE TABLE IF NOT EXISTS npcs ( + id BIGSERIAL PRIMARY KEY, + town_id BIGINT NOT NULL REFERENCES towns(id) ON DELETE CASCADE, + name TEXT NOT NULL, + type TEXT NOT NULL CHECK (type IN ('quest_giver', 'merchant', 'healer')), + offset_x DOUBLE PRECISION NOT NULL DEFAULT 0, + offset_y DOUBLE PRECISION NOT NULL DEFAULT 0, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); +``` + +### 5.3 `quests` + +Quest template definitions. These are authored content, not player data. + +```sql +CREATE TABLE IF NOT EXISTS quests ( + id BIGSERIAL PRIMARY KEY, + npc_id BIGINT NOT NULL REFERENCES npcs(id) ON DELETE CASCADE, + title TEXT NOT NULL, + description TEXT NOT NULL DEFAULT '', + type TEXT NOT NULL CHECK (type IN ('kill_count', 'visit_town', 'collect_item')), + target_count INT NOT NULL DEFAULT 1, + target_enemy_type TEXT, + target_town_id BIGINT REFERENCES towns(id), + drop_chance DOUBLE PRECISION NOT NULL DEFAULT 0.3, + min_level INT NOT NULL DEFAULT 1, + max_level INT NOT NULL DEFAULT 100, + reward_xp BIGINT NOT NULL DEFAULT 0, + reward_gold BIGINT NOT NULL DEFAULT 0, + reward_potions INT NOT NULL DEFAULT 0, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); +``` + +### 5.4 `hero_quests` + +Per-hero quest progress tracking. + +```sql +CREATE TABLE IF NOT EXISTS hero_quests ( + id BIGSERIAL PRIMARY KEY, + hero_id BIGINT NOT NULL REFERENCES heroes(id) ON DELETE CASCADE, + quest_id BIGINT NOT NULL REFERENCES quests(id) ON DELETE CASCADE, + status TEXT NOT NULL DEFAULT 'accepted' + CHECK (status IN ('accepted', 'completed', 'claimed')), + progress INT NOT NULL DEFAULT 0, + accepted_at TIMESTAMPTZ NOT NULL DEFAULT now(), + completed_at TIMESTAMPTZ, + claimed_at TIMESTAMPTZ, + UNIQUE (hero_id, quest_id) +); +``` + +### Indexes + +```sql +CREATE INDEX IF NOT EXISTS idx_npcs_town ON npcs(town_id); +CREATE INDEX IF NOT EXISTS idx_quests_npc ON quests(npc_id); +CREATE INDEX IF NOT EXISTS idx_hero_quests_hero ON hero_quests(hero_id); +CREATE INDEX IF NOT EXISTS idx_hero_quests_status ON hero_quests(hero_id, status); +``` + +--- + +## 6. API Endpoints + +All under `/api/v1/`. Auth via `X-Telegram-Init-Data` header (existing pattern). + +### 6.1 Towns + +| Method | Path | Description | +|--------|------|-------------| +| `GET` | `/towns` | List all towns (id, name, biome, world_x, world_y, radius, level range) | +| `GET` | `/towns/:id/npcs` | List NPCs in a town | + +### 6.2 Quests + +| Method | Path | Description | +|--------|------|-------------| +| `GET` | `/npcs/:id/quests` | List available quests from an NPC (filtered by hero level, excluding already accepted/claimed) | +| `POST` | `/quests/:id/accept` | Accept a quest (hero must be in the NPC's town, max 3 active) | +| `POST` | `/quests/:id/claim` | Claim rewards for a completed quest | +| `GET` | `/hero/quests` | List hero's active/completed quests with progress | +| `POST` | `/hero/quests/:id/abandon` | Abandon an accepted quest | + +### Response shapes + +**GET /towns** +```json +{ + "towns": [ + { + "id": 1, + "name": "Willowdale", + "biome": "meadow", + "worldX": 50, + "worldY": 15, + "radius": 8, + "levelMin": 1, + "levelMax": 5 + } + ] +} +``` + +**GET /hero/quests** +```json +{ + "quests": [ + { + "id": 1, + "questId": 3, + "title": "Slay 10 Forest Wolves", + "description": "The wolves are terrorizing Thornwatch.", + "type": "kill_count", + "targetCount": 10, + "progress": 7, + "status": "accepted", + "rewardXp": 100, + "rewardGold": 50, + "rewardPotions": 1, + "npcName": "Guard Halric", + "townName": "Thornwatch" + } + ] +} +``` + +**POST /quests/:id/accept** +- 200: Quest accepted, returns hero_quest record. +- 400: Already at max active quests / not in town / level mismatch. +- 409: Quest already accepted. + +**POST /quests/:id/claim** +- 200: Rewards granted, returns updated hero stats. +- 400: Quest not completed yet. + +--- + +## 7. Frontend UI Needs + +### 7.1 Town markers on the map + +- Render a flag/banner sprite at each town's world position, visible at all zoom levels. +- Town name label appears when the hero is within 20 tiles. +- Reuse existing `plaza` terrain for the town area; add a distinct border or glow. + +### 7.2 NPC sprites + +- Small colored circles or simple character sprites at the NPC's position (town center + offset). +- Quest giver: yellow `!` icon above head when they have an available quest. +- Quest giver: yellow `?` icon when the hero has a completed quest to turn in. +- Merchant: bag/potion icon. Healer: cross icon. +- Tap an NPC sprite to open the interaction popup. + +### 7.3 NPC interaction popup (React overlay) + +- Appears when hero is in town and player taps an NPC. +- **Quest giver popup**: Lists available quests with title, short description, rewards, and "Accept" button. Shows in-progress quests with progress bar and "Claim" button if complete. +- **Merchant popup**: List of purchasable items (potions) with gold cost and "Buy" button. +- **Healer popup**: "Heal to full" button with gold cost shown. + +### 7.4 Quest log panel + +- Accessible via a small scroll icon in the HUD (always visible, bottom-right area). +- Shows up to 3 active quests in a compact list. +- Each entry: quest title, progress bar (`7/10`), quest type icon. +- Tap a quest entry to expand: full description, rewards, abandon button. +- Toast notification when a quest completes ("Quest Complete: Slay 10 Forest Wolves"). + +### 7.5 Quest progress toast + +- Lightweight toast at top of screen: "Wolf slain (7/10)" on kill_count progress. +- Only show every 1-2 increments to avoid spam (show on first kill, then every 3rd, then on completion). + +--- + +## 8. Hero Travel Flow -- Town Integration with Auto-Walk + +### Current flow +``` +Hero auto-walks along road -> encounters enemies -> fights -> continues walking +``` + +### Updated flow with towns +``` +Hero auto-walks -> enters town radius -> combat paused, NPCs visible -> + (player can interact or do nothing) -> hero continues walking -> + exits town radius -> combat resumes -> next enemy encounter +``` + +### Key behaviors + +1. **Town entry**: When the game tick detects `distance(hero, town_center) <= town.radius`, the backend sets a transient `in_town` flag (not persisted, computed from position). The frontend receives the town ID via the state push. + +2. **In-town state**: While in town: + - No enemy spawns within the town radius. + - Hero continues walking at normal speed (idle game -- no forced stops). + - NPC sprites become tappable. + - The quest log auto-checks `visit_town` quest completion. + +3. **Town exit**: When the hero walks past the town radius, NPCs disappear from the tappable area, combat spawning resumes. + +4. **Auto-interaction**: If the hero has a completable quest for a quest giver in this town, show a brief highlight/pulse on the NPC. The player must still tap to claim (keeps engagement without blocking idle flow). + +5. **Quest progress tracking** (backend, per game tick): + - On enemy kill: check active `kill_count` and `collect_item` quests. Update `hero_quests.progress`. + - On town entry: check active `visit_town` quests. Update progress if target matches. + - On `progress >= target_count`: set `status = 'completed'`, `completed_at = now()`. Push WebSocket event. + +6. **Offline simulation**: When processing offline ticks, quest progress increments normally. Kill-based quests advance with simulated kills. Visit-town quests advance if the hero's simulated path crosses a town. Quest completions are batched and shown on reconnect. + +### WebSocket events (additions to existing protocol) + +| Event | Direction | Payload | +|-------|-----------|---------| +| `quest_progress` | server -> client | `{ questId, progress, targetCount }` | +| `quest_completed` | server -> client | `{ questId, title }` | +| `town_entered` | server -> client | `{ townId, townName }` | +| `town_exited` | server -> client | `{ townId }` | + +--- + +## 9. Seed Data + +The migration includes seed data for all 7 towns, ~15 NPCs, and ~20 starter quests. See `000006_quest_system.sql` for the full seed. + +--- + +## 10. Future Considerations (Post-MVP) + +These are explicitly out of scope for MVP but noted for schema forward-compatibility: + +- **Repeatable quests**: Add a `is_repeatable` flag and `cooldown_hours` to `quests`. Not in MVP. +- **Quest chains**: Add `prerequisite_quest_id` to `quests`. Not in MVP. +- **Dialogue**: Add `dialogue_text` JSON array to `quests` for NPC speech bubbles. Not in MVP. +- **Merchant inventory**: Separate `merchant_inventory` table. MVP uses hardcoded potion prices. +- **Healer scaling**: MVP uses flat gold cost. Later: cost scales with level. diff --git a/backend/go.mod b/backend/go.mod new file mode 100644 index 0000000..4723903 --- /dev/null +++ b/backend/go.mod @@ -0,0 +1,21 @@ +module github.com/denisovdennis/autohero + +go 1.23 + +require ( + github.com/go-chi/chi/v5 v5.1.0 + github.com/gorilla/websocket v1.5.3 + github.com/jackc/pgx/v5 v5.7.1 + github.com/redis/go-redis/v9 v9.7.0 +) + +require ( + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect + github.com/jackc/puddle/v2 v2.2.2 // indirect + golang.org/x/crypto v0.27.0 // indirect + golang.org/x/sync v0.8.0 // indirect + golang.org/x/text v0.18.0 // indirect +) diff --git a/backend/go.sum b/backend/go.sum new file mode 100644 index 0000000..3ed0e15 --- /dev/null +++ b/backend/go.sum @@ -0,0 +1,42 @@ +github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= +github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= +github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA= +github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= +github.com/go-chi/chi/v5 v5.1.0 h1:acVI1TYaD+hhedDJ3r54HyA6sExp3HfXq7QWEEY/xMw= +github.com/go-chi/chi/v5 v5.1.0/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8= +github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= +github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.7.1 h1:x7SYsPBYDkHDksogeSmZZ5xzThcTgRz++I5E+ePFUcs= +github.com/jackc/pgx/v5 v5.7.1/go.mod h1:e7O26IywZZ+naJtWWos6i6fvWK+29etgITqrqHLfoZA= +github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= +github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/redis/go-redis/v9 v9.7.0 h1:HhLSs+B6O021gwzl+locl0zEDnyNkxMtf/Z3NNBMa9E= +github.com/redis/go-redis/v9 v9.7.0/go.mod h1:f6zhXITC7JUJIlPEiBOTXxJgPLdZcA93GewI7inzyWw= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A= +golang.org/x/crypto v0.27.0/go.mod h1:1Xngt8kV6Dvbssa53Ziq6Eqn0HqbZi5Z6R0ZpwQzt70= +golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ= +golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/text v0.18.0 h1:XvMDiNzPAl0jr17s6W9lcaIhGUfUORdGCNsuLmPG224= +golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/backend/internal/config/config.go b/backend/internal/config/config.go new file mode 100644 index 0000000..280ddaa --- /dev/null +++ b/backend/internal/config/config.go @@ -0,0 +1,73 @@ +package config + +import ( + "os" + "time" +) + +type Config struct { + ServerPort string + BotToken string + DB DBConfig + Redis RedisConfig + Game GameConfig + Admin AdminConfig +} + +type DBConfig struct { + Host string + Port string + User string + Password string + Name string +} + +func (c DBConfig) DSN() string { + return "postgres://" + c.User + ":" + c.Password + "@" + c.Host + ":" + c.Port + "/" + c.Name + "?sslmode=disable" +} + +type RedisConfig struct { + Addr string +} + +type GameConfig struct { + TickRate time.Duration +} + +type AdminConfig struct { + BasicAuthUsername string + BasicAuthPassword string + BasicAuthRealm string +} + +func Load() *Config { + return &Config{ + ServerPort: envOrDefault("SERVER_PORT", "8080"), + BotToken: os.Getenv("BOT_TOKEN"), + DB: DBConfig{ + Host: envOrDefault("DB_HOST", "localhost"), + Port: envOrDefault("DB_PORT", "5432"), + User: envOrDefault("DB_USER", "autohero"), + Password: envOrDefault("DB_PASSWORD", "autohero"), + Name: envOrDefault("DB_NAME", "autohero"), + }, + Redis: RedisConfig{ + Addr: envOrDefault("REDIS_ADDR", "localhost:6379"), + }, + Game: GameConfig{ + TickRate: 100 * time.Millisecond, // 10 ticks per second + }, + Admin: AdminConfig{ + BasicAuthUsername: os.Getenv("ADMIN_BASIC_AUTH_USERNAME"), + BasicAuthPassword: os.Getenv("ADMIN_BASIC_AUTH_PASSWORD"), + BasicAuthRealm: envOrDefault("ADMIN_BASIC_AUTH_REALM", "AutoHero Admin"), + }, + } +} + +func envOrDefault(key, defaultVal string) string { + if val := os.Getenv(key); val != "" { + return val + } + return defaultVal +} diff --git a/backend/internal/game/combat.go b/backend/internal/game/combat.go new file mode 100644 index 0000000..6052e45 --- /dev/null +++ b/backend/internal/game/combat.go @@ -0,0 +1,414 @@ +package game + +import ( + "math/rand" + "time" + + "github.com/denisovdennis/autohero/internal/model" +) + +// combatDamageScale stretches fights (MVP tuning; paired with slower attack cadence in engine). +const combatDamageScale = 0.35 + +// CalculateDamage computes the final damage dealt from attacker stats to a defender, +// applying defense and critical hits. +func CalculateDamage(baseAttack int, defense int, critChance float64) (damage int, isCrit bool) { + atk := float64(baseAttack) + + // Defense reduces damage (simple formula: damage = atk - def, min 1). + dmg := atk - float64(defense) + if dmg < 1 { + dmg = 1 + } + + // Critical hit check. + if critChance > 0 && rand.Float64() < critChance { + dmg *= 2 + isCrit = true + } + + dmg *= combatDamageScale + if dmg < 1 { + dmg = 1 + } + + return int(dmg), isCrit +} + +// CalculateIncomingDamage applies shield buff reduction to incoming damage. +func CalculateIncomingDamage(rawDamage int, buffs []model.ActiveBuff, now time.Time) int { + dmg := float64(rawDamage) + + for _, ab := range buffs { + if ab.IsExpired(now) { + continue + } + if ab.Buff.Type == model.BuffShield { + dmg *= (1 - ab.Buff.Magnitude) + } + } + + if dmg < 1 { + dmg = 1 + } + return int(dmg) +} + +// ProcessAttack executes a single attack from hero to enemy and returns the combat event. +// It respects dodge ability on enemies and stun debuff on hero. +func ProcessAttack(hero *model.Hero, enemy *model.Enemy, now time.Time) model.CombatEvent { + // If hero is stunned, skip attack entirely. + if hero.IsStunned(now) { + return model.CombatEvent{ + Type: "attack", + HeroID: hero.ID, + Damage: 0, + Source: "hero", + HeroHP: hero.HP, + EnemyHP: enemy.HP, + Timestamp: now, + } + } + + critChance := 0.0 + if weapon := hero.Gear[model.SlotMainHand]; weapon != nil { + critChance = weapon.CritChance + } + + // Check enemy dodge ability. + if enemy.HasAbility(model.AbilityDodge) { + if rand.Float64() < 0.20 { // 20% dodge chance + return model.CombatEvent{ + Type: "attack", + HeroID: hero.ID, + Damage: 0, + Source: "hero", + HeroHP: hero.HP, + EnemyHP: enemy.HP, + Timestamp: now, + } + } + } + + dmg, isCrit := CalculateDamage(hero.EffectiveAttackAt(now), enemy.Defense, critChance) + enemy.HP -= dmg + if enemy.HP < 0 { + enemy.HP = 0 + } + + return model.CombatEvent{ + Type: "attack", + HeroID: hero.ID, + Damage: dmg, + Source: "hero", + IsCrit: isCrit, + HeroHP: hero.HP, + EnemyHP: enemy.HP, + Timestamp: now, + } +} + +// EnemyAttackDamageMultiplier returns a damage multiplier based on the enemy's +// attack counter and burst/chain abilities. It increments AttackCount. +func EnemyAttackDamageMultiplier(enemy *model.Enemy) float64 { + enemy.AttackCount++ + mult := 1.0 + + // Orc Warrior: every 3rd attack deals 1.5x damage (spec §4.1). + if enemy.HasAbility(model.AbilityBurst) && enemy.AttackCount%3 == 0 { + mult *= 1.5 + } + + // Lightning Titan: after 5 attacks, next attack deals 3x damage (spec §4.2). + if enemy.HasAbility(model.AbilityChainLightning) && enemy.AttackCount%6 == 0 { + mult *= 3.0 + } + + return mult +} + +// ProcessEnemyAttack executes a single attack from enemy to hero, including +// debuff application and burst/chain abilities based on the enemy's type. +func ProcessEnemyAttack(hero *model.Hero, enemy *model.Enemy, now time.Time) model.CombatEvent { + critChance := enemy.CritChance + if enemy.HasAbility(model.AbilityCritical) && critChance < 0.15 { + critChance = 0.15 + } + + rawDmg, isCrit := CalculateDamage(enemy.Attack, hero.EffectiveDefenseAt(now), critChance) + + // Apply burst/chain ability multiplier. + burstMult := EnemyAttackDamageMultiplier(enemy) + if burstMult > 1.0 { + rawDmg = int(float64(rawDmg) * burstMult) + } + + dmg := CalculateIncomingDamage(rawDmg, hero.Buffs, now) + + hero.HP -= dmg + if hero.HP < 0 { + hero.HP = 0 + } + + debuffApplied := tryApplyDebuff(hero, enemy, now) + + return model.CombatEvent{ + Type: "attack", + HeroID: hero.ID, + Damage: dmg, + Source: "enemy", + IsCrit: isCrit, + DebuffApplied: debuffApplied, + HeroHP: hero.HP, + EnemyHP: enemy.HP, + Timestamp: now, + } +} + +// tryApplyDebuff checks enemy abilities and rolls to apply debuffs to the hero. +// Returns the debuff type string if one was applied, empty string otherwise. +func tryApplyDebuff(hero *model.Hero, enemy *model.Enemy, now time.Time) string { + type debuffRule struct { + ability model.SpecialAbility + debuff model.DebuffType + chance float64 + } + + rules := []debuffRule{ + {model.AbilityBurn, model.DebuffBurn, 0.30}, // Fire Demon: 30% burn + {model.AbilityPoison, model.DebuffPoison, 0.10}, // Zombie: 10% poison + {model.AbilitySlow, model.DebuffSlow, 0.25}, // Water Element: 25% slow (-40% movement) + {model.AbilityStun, model.DebuffStun, 0.25}, // Lightning Titan: 25% stun + {model.AbilityFreeze, model.DebuffFreeze, 0.20}, // Generic freeze: -50% attack speed + {model.AbilityIceSlow, model.DebuffIceSlow, 0.20}, // Ice Guardian: -20% attack speed (spec §4.2) + } + + for _, rule := range rules { + if !enemy.HasAbility(rule.ability) { + continue + } + if rand.Float64() >= rule.chance { + continue + } + + applyDebuff(hero, rule.debuff, now) + return string(rule.debuff) + } + + return "" +} + +// applyDebuff adds a debuff to the hero. If the same debuff type is already active, it refreshes. +func applyDebuff(hero *model.Hero, debuffType model.DebuffType, now time.Time) { + def, ok := model.DefaultDebuffs[debuffType] + if !ok { + return + } + + // Refresh if already active. + for i, ad := range hero.Debuffs { + if ad.Debuff.Type == debuffType && !ad.IsExpired(now) { + hero.Debuffs[i].AppliedAt = now + hero.Debuffs[i].ExpiresAt = now.Add(def.Duration) + return + } + } + + // Remove expired debuffs. + active := hero.Debuffs[:0] + for _, ad := range hero.Debuffs { + if !ad.IsExpired(now) { + active = append(active, ad) + } + } + + ad := model.ActiveDebuff{ + Debuff: def, + AppliedAt: now, + ExpiresAt: now.Add(def.Duration), + } + hero.Debuffs = append(active, ad) +} + +// ProcessDebuffDamage applies periodic damage from active debuffs (poison, burn). +// Should be called each combat tick. Returns total damage dealt by debuffs this tick. +func ProcessDebuffDamage(hero *model.Hero, tickDuration time.Duration, now time.Time) int { + totalDmg := 0 + + for _, ad := range hero.Debuffs { + if ad.IsExpired(now) { + continue + } + + switch ad.Debuff.Type { + case model.DebuffPoison: + // -2% HP/sec, scaled by tick duration. + dmg := int(float64(hero.MaxHP) * ad.Debuff.Magnitude * tickDuration.Seconds()) + if dmg < 1 { + dmg = 1 + } + hero.HP -= dmg + totalDmg += dmg + + case model.DebuffBurn: + // -3% HP/sec, scaled by tick duration. + dmg := int(float64(hero.MaxHP) * ad.Debuff.Magnitude * tickDuration.Seconds()) + if dmg < 1 { + dmg = 1 + } + hero.HP -= dmg + totalDmg += dmg + } + } + + if hero.HP < 0 { + hero.HP = 0 + } + + return totalDmg +} + +// ProcessEnemyRegen handles HP regeneration for enemies with the regen ability. +// Should be called each combat tick. +func ProcessEnemyRegen(enemy *model.Enemy, tickDuration time.Duration) int { + if !enemy.HasAbility(model.AbilityRegen) { + return 0 + } + + // Regen rates vary by enemy type. + regenRate := 0.02 // default 2% per second + switch enemy.Type { + case model.EnemySkeletonKing: + regenRate = 0.10 // 10% HP regen + case model.EnemyForestWarden: + regenRate = 0.05 // 5% HP/sec + case model.EnemyBattleLizard: + regenRate = 0.02 // 2% of received damage (approximated as 2% HP/sec) + } + + healed := int(float64(enemy.MaxHP) * regenRate * tickDuration.Seconds()) + if healed < 1 { + healed = 1 + } + enemy.HP += healed + if enemy.HP > enemy.MaxHP { + enemy.HP = enemy.MaxHP + } + + return healed +} + +// CheckDeath checks if the hero is dead and attempts resurrection if a buff is active. +// Returns true if the hero is dead (no resurrection available). +func CheckDeath(hero *model.Hero, now time.Time) bool { + if hero.IsAlive() { + return false + } + + // Check for resurrection buff. + for i, ab := range hero.Buffs { + if ab.IsExpired(now) { + continue + } + if ab.Buff.Type == model.BuffResurrection { + // Revive with magnitude % of max HP. + hero.HP = int(float64(hero.MaxHP) * ab.Buff.Magnitude) + if hero.HP < 1 { + hero.HP = 1 + } + // Consume the buff by expiring it immediately. + hero.Buffs[i].ExpiresAt = now + return false + } + } + + hero.State = model.StateDead + return true +} + +// ApplyBuff adds a buff to the hero. If the same buff type is already active, it refreshes. +func ApplyBuff(hero *model.Hero, buffType model.BuffType, now time.Time) *model.ActiveBuff { + def, ok := model.DefaultBuffs[buffType] + if !ok { + return nil + } + + // Heal buff is applied instantly. + if buffType == model.BuffHeal { + healAmount := int(float64(hero.MaxHP) * def.Magnitude) + hero.HP += healAmount + if hero.HP > hero.MaxHP { + hero.HP = hero.MaxHP + } + } + + // Check if already active and refresh. + for i, ab := range hero.Buffs { + if ab.Buff.Type == buffType && !ab.IsExpired(now) { + hero.Buffs[i].AppliedAt = now + hero.Buffs[i].ExpiresAt = now.Add(def.Duration) + return &hero.Buffs[i] + } + } + + // Remove expired buffs while we're here. + active := hero.Buffs[:0] + for _, ab := range hero.Buffs { + if !ab.IsExpired(now) { + active = append(active, ab) + } + } + + ab := model.ActiveBuff{ + Buff: def, + AppliedAt: now, + ExpiresAt: now.Add(def.Duration), + } + hero.Buffs = append(active, ab) + return &ab +} + +// HasLuckBuff returns true if the hero has an active luck buff. +func HasLuckBuff(hero *model.Hero, now time.Time) bool { + for _, ab := range hero.Buffs { + if ab.Buff.Type == model.BuffLuck && !ab.IsExpired(now) { + return true + } + } + return false +} + +// LuckMultiplier returns the loot multiplier from the Luck buff (x2.5 per spec §7.1). +func LuckMultiplier(hero *model.Hero, now time.Time) float64 { + if HasLuckBuff(hero, now) { + return 2.5 + } + return 1.0 +} + +// ProcessSummonDamage applies bonus damage from summoned minions (Skeleton King). +// MVP: minions are modeled as periodic bonus damage (25% of Skeleton King's attack) +// applied every tick, rather than as full entity spawns. +// The spec says summons appear every 15 seconds; we approximate by checking +// the combat duration and applying minion damage when a 15s boundary is crossed. +func ProcessSummonDamage(hero *model.Hero, enemy *model.Enemy, combatStart time.Time, lastTick time.Time, now time.Time) int { + if !enemy.HasAbility(model.AbilitySummon) { + return 0 + } + + // How many 15-second summon cycles have elapsed since combat start. + prevCycles := int(lastTick.Sub(combatStart).Seconds()) / 15 + currCycles := int(now.Sub(combatStart).Seconds()) / 15 + + if currCycles <= prevCycles { + return 0 + } + + // Each summon wave deals 25% of the enemy's base attack as minion damage. + minionDmg := max(1, enemy.Attack/4) + hero.HP -= minionDmg + if hero.HP < 0 { + hero.HP = 0 + } + return minionDmg +} diff --git a/backend/internal/game/combat_test.go b/backend/internal/game/combat_test.go new file mode 100644 index 0000000..6539a8b --- /dev/null +++ b/backend/internal/game/combat_test.go @@ -0,0 +1,222 @@ +package game + +import ( + "testing" + "time" + + "github.com/denisovdennis/autohero/internal/model" +) + +func TestOrcWarriorBurstEveryThirdAttack(t *testing.T) { + enemy := &model.Enemy{ + Type: model.EnemyOrc, + Attack: 12, + Speed: 1.0, + SpecialAbilities: []model.SpecialAbility{model.AbilityBurst}, + } + + // Attacks 1 and 2 should have multiplier 1.0 + m1 := EnemyAttackDamageMultiplier(enemy) + if m1 != 1.0 { + t.Fatalf("attack 1: expected multiplier 1.0, got %.2f", m1) + } + m2 := EnemyAttackDamageMultiplier(enemy) + if m2 != 1.0 { + t.Fatalf("attack 2: expected multiplier 1.0, got %.2f", m2) + } + + // Attack 3 should deal 1.5x + m3 := EnemyAttackDamageMultiplier(enemy) + if m3 != 1.5 { + t.Fatalf("attack 3: expected multiplier 1.5, got %.2f", m3) + } + + // Attack 4 back to normal + m4 := EnemyAttackDamageMultiplier(enemy) + if m4 != 1.0 { + t.Fatalf("attack 4: expected multiplier 1.0, got %.2f", m4) + } +} + +func TestLightningTitanChainLightning(t *testing.T) { + enemy := &model.Enemy{ + Type: model.EnemyLightningTitan, + Attack: 30, + Speed: 1.5, + SpecialAbilities: []model.SpecialAbility{model.AbilityStun, model.AbilityChainLightning}, + } + + // Attacks 1-5 should be normal (no chain lightning) + for i := 1; i <= 5; i++ { + m := EnemyAttackDamageMultiplier(enemy) + if m != 1.0 { + t.Fatalf("attack %d: expected multiplier 1.0, got %.2f", i, m) + } + } + + // Attack 6 triggers chain lightning (3x) + m6 := EnemyAttackDamageMultiplier(enemy) + if m6 != 3.0 { + t.Fatalf("attack 6: expected multiplier 3.0, got %.2f", m6) + } +} + +func TestIceGuardianAppliesIceSlow(t *testing.T) { + hero := &model.Hero{ + ID: 1, HP: 100, MaxHP: 100, + Attack: 10, Defense: 5, Speed: 1.0, + Strength: 5, Constitution: 5, Agility: 5, + } + enemy := &model.Enemy{ + Type: model.EnemyIceGuardian, + Attack: 14, + Defense: 15, + Speed: 0.7, + SpecialAbilities: []model.SpecialAbility{model.AbilityIceSlow}, + } + + now := time.Now() + applied := false + for i := 0; i < 200; i++ { + hero.HP = hero.MaxHP + hero.Debuffs = nil + ProcessEnemyAttack(hero, enemy, now) + for _, d := range hero.Debuffs { + if d.Debuff.Type == model.DebuffIceSlow { + applied = true + if d.Debuff.Magnitude != 0.20 { + t.Fatalf("IceSlow magnitude should be 0.20, got %.2f", d.Debuff.Magnitude) + } + break + } + } + if applied { + break + } + } + if !applied { + t.Fatal("Ice Guardian never applied IceSlow debuff in 200 attacks") + } +} + +func TestSkeletonKingSummonDamage(t *testing.T) { + hero := &model.Hero{ + ID: 1, HP: 100, MaxHP: 100, + } + enemy := &model.Enemy{ + Type: model.EnemySkeletonKing, + Attack: 18, + SpecialAbilities: []model.SpecialAbility{model.AbilityRegen, model.AbilitySummon}, + } + + start := time.Now() + // Before 15 seconds: no summon damage. + dmg := ProcessSummonDamage(hero, enemy, start, start, start.Add(10*time.Second)) + if dmg != 0 { + t.Fatalf("expected no summon damage before 15s, got %d", dmg) + } + + // At 15 seconds: summon damage should occur. + dmg = ProcessSummonDamage(hero, enemy, start, start.Add(14*time.Second), start.Add(16*time.Second)) + if dmg == 0 { + t.Fatal("expected summon damage after 15s boundary crossed") + } + expectedDmg := max(1, enemy.Attack/4) + if dmg != expectedDmg { + t.Fatalf("expected summon damage %d, got %d", expectedDmg, dmg) + } +} + +func TestLootGenerationOnEnemyDeath(t *testing.T) { + drops := model.GenerateLoot(model.EnemyWolf, 1.0) + if len(drops) == 0 { + t.Fatal("expected at least one loot drop (gold)") + } + + hasGold := false + for _, d := range drops { + if d.ItemType == "gold" { + hasGold = true + if d.GoldAmount <= 0 { + t.Fatal("gold drop should have positive amount") + } + } + } + if !hasGold { + t.Fatal("expected gold drop from GenerateLoot") + } +} + +func TestLuckMultiplierWithBuff(t *testing.T) { + now := time.Now() + hero := &model.Hero{ + Buffs: []model.ActiveBuff{{ + Buff: model.DefaultBuffs[model.BuffLuck], + AppliedAt: now.Add(-time.Second), + ExpiresAt: now.Add(10 * time.Second), + }}, + } + + mult := LuckMultiplier(hero, now) + if mult != 2.5 { + t.Fatalf("expected luck multiplier 2.5, got %.1f", mult) + } +} + +func TestLuckMultiplierWithoutBuff(t *testing.T) { + hero := &model.Hero{} + mult := LuckMultiplier(hero, time.Now()) + if mult != 1.0 { + t.Fatalf("expected luck multiplier 1.0 without buff, got %.1f", mult) + } +} + +func TestProcessDebuffDamageAppliesPoison(t *testing.T) { + now := time.Now() + hero := &model.Hero{ + HP: 100, MaxHP: 100, + Debuffs: []model.ActiveDebuff{{ + Debuff: model.DefaultDebuffs[model.DebuffPoison], + AppliedAt: now.Add(-time.Second), + ExpiresAt: now.Add(4 * time.Second), + }}, + } + + dmg := ProcessDebuffDamage(hero, time.Second, now) + if dmg == 0 { + t.Fatal("expected poison to deal damage over time") + } + if hero.HP >= 100 { + t.Fatal("expected hero HP to decrease from poison") + } +} + +func TestDodgeAbilityCanAvoidDamage(t *testing.T) { + now := time.Now() + hero := &model.Hero{ + ID: 1, HP: 100, MaxHP: 100, + Attack: 50, Defense: 0, Speed: 1.0, + Strength: 10, Agility: 5, + } + enemy := &model.Enemy{ + Type: model.EnemySkeletonArcher, + MaxHP: 1000, + HP: 1000, + Attack: 10, + Defense: 0, + SpecialAbilities: []model.SpecialAbility{model.AbilityDodge}, + } + + dodged := false + for i := 0; i < 200; i++ { + enemy.HP = enemy.MaxHP + evt := ProcessAttack(hero, enemy, now) + if evt.Damage == 0 { + dodged = true + break + } + } + if !dodged { + t.Fatal("expected at least one dodge in 200 hero attacks against Skeleton Archer") + } +} diff --git a/backend/internal/game/engine.go b/backend/internal/game/engine.go new file mode 100644 index 0000000..9d96f4a --- /dev/null +++ b/backend/internal/game/engine.go @@ -0,0 +1,834 @@ +package game + +import ( + "container/heap" + "context" + "encoding/json" + "fmt" + "log/slog" + "sync" + "time" + + "github.com/denisovdennis/autohero/internal/model" + "github.com/denisovdennis/autohero/internal/storage" +) + +// MessageSender is the interface the engine uses to push WS messages. +// Implemented by handler.Hub (injected to avoid import cycle). +type MessageSender interface { + SendToHero(heroID int64, msgType string, payload any) + BroadcastEvent(event model.CombatEvent) +} + +// EnemyDeathCallback is invoked when an enemy dies, passing the hero and enemy type. +// Used to wire loot generation without coupling the engine to the handler layer. +type EnemyDeathCallback func(hero *model.Hero, enemy *model.Enemy, now time.Time) + +// EngineStatus contains a snapshot of the engine's operational state. +type EngineStatus struct { + Running bool `json:"running"` + TickRate time.Duration `json:"tickRate"` + ActiveCombats int `json:"activeCombats"` + ActiveMovements int `json:"activeMovements"` + UptimeMs int64 `json:"uptimeMs"` +} + +// CombatInfo is a read-only snapshot of a single active combat. +type CombatInfo struct { + HeroID int64 `json:"heroId"` + EnemyName string `json:"enemyName"` + EnemyType string `json:"enemyType"` + HeroHP int `json:"heroHp"` + EnemyHP int `json:"enemyHp"` + StartedAt time.Time `json:"startedAt"` +} + +// IncomingMessage is a client command received from the WS layer. +type IncomingMessage struct { + HeroID int64 + Type string + Payload json.RawMessage +} + +// Engine is the tick-based game loop that drives combat simulation and hero movement. +type Engine struct { + tickRate time.Duration + combats map[int64]*model.CombatState // keyed by hero ID + queue model.AttackQueue + movements map[int64]*HeroMovement // keyed by hero ID + roadGraph *RoadGraph + sender MessageSender + heroStore *storage.HeroStore + incomingCh chan IncomingMessage // client commands + mu sync.RWMutex + eventCh chan model.CombatEvent + logger *slog.Logger + onEnemyDeath EnemyDeathCallback + startedAt time.Time + running bool +} + +const minAttackInterval = 250 * time.Millisecond + +// combatPaceMultiplier stretches time between swings (MVP: longer fights). +const combatPaceMultiplier = 5 + + +// NewEngine creates a new game engine with the given tick rate. +func NewEngine(tickRate time.Duration, eventCh chan model.CombatEvent, logger *slog.Logger) *Engine { + e := &Engine{ + tickRate: tickRate, + combats: make(map[int64]*model.CombatState), + queue: make(model.AttackQueue, 0), + movements: make(map[int64]*HeroMovement), + incomingCh: make(chan IncomingMessage, 256), + eventCh: eventCh, + logger: logger, + } + heap.Init(&e.queue) + return e +} + +func (e *Engine) GetMovements(heroId int64) *HeroMovement { + return e.movements[heroId] +} + +// SetSender sets the WS message sender (typically handler.Hub). +func (e *Engine) SetSender(s MessageSender) { + e.mu.Lock() + defer e.mu.Unlock() + e.sender = s +} + +// SetRoadGraph sets the road graph used for hero movement. +func (e *Engine) SetRoadGraph(rg *RoadGraph) { + e.mu.Lock() + defer e.mu.Unlock() + e.roadGraph = rg +} + +// SetHeroStore sets the hero store used for persisting hero state on disconnect. +func (e *Engine) SetHeroStore(hs *storage.HeroStore) { + e.mu.Lock() + defer e.mu.Unlock() + e.heroStore = hs +} + +// SetOnEnemyDeath registers a callback for enemy death events (e.g. loot generation). +func (e *Engine) SetOnEnemyDeath(cb EnemyDeathCallback) { + e.mu.Lock() + defer e.mu.Unlock() + e.onEnemyDeath = cb +} + +// IncomingCh returns the channel for routing client WS commands into the engine. +func (e *Engine) IncomingCh() chan<- IncomingMessage { + return e.incomingCh +} + +// Run starts the game loop. It blocks until the context is cancelled. +func (e *Engine) Run(ctx context.Context) error { + combatTicker := time.NewTicker(e.tickRate) + moveTicker := time.NewTicker(MovementTickRate) + syncTicker := time.NewTicker(PositionSyncRate) + defer combatTicker.Stop() + defer moveTicker.Stop() + defer syncTicker.Stop() + + e.mu.Lock() + e.startedAt = time.Now() + e.running = true + e.mu.Unlock() + + e.logger.Info("game engine started", "tick_rate", e.tickRate) + + defer func() { + e.mu.Lock() + e.running = false + e.mu.Unlock() + }() + + for { + select { + case <-ctx.Done(): + e.logger.Info("game engine shutting down") + return ctx.Err() + case now := <-combatTicker.C: + e.processCombatTick(now) + case now := <-moveTicker.C: + e.processMovementTick(now) + case now := <-syncTicker.C: + e.processPositionSync(now) + case msg := <-e.incomingCh: + e.handleClientMessage(msg) + } + } +} + +// handleClientMessage routes a single inbound client command. +func (e *Engine) handleClientMessage(msg IncomingMessage) { + switch msg.Type { + case "activate_buff": + e.handleActivateBuff(msg) + case "use_potion": + e.handleUsePotion(msg) + case "revive": + e.handleRevive(msg) + default: + // Commands like accept_quest, claim_quest, npc_interact etc. + // are handled by their respective REST handlers for now. + e.logger.Debug("unhandled client ws message", "type", msg.Type, "hero_id", msg.HeroID) + } +} + +// handleActivateBuff processes the activate_buff client command. +func (e *Engine) handleActivateBuff(msg IncomingMessage) { + var payload model.ActivateBuffPayload + if err := json.Unmarshal(msg.Payload, &payload); err != nil { + e.sendError(msg.HeroID, "invalid_payload", "invalid activate_buff payload") + return + } + + e.mu.Lock() + defer e.mu.Unlock() + + hm, ok := e.movements[msg.HeroID] + if !ok { + e.sendError(msg.HeroID, "no_hero", "hero not connected") + return + } + + buffType := model.BuffType(payload.BuffType) + now := time.Now() + ab := ApplyBuff(hm.Hero, buffType, now) + if ab == nil { + e.sendError(msg.HeroID, "invalid_buff", fmt.Sprintf("unknown buff type: %s", payload.BuffType)) + return + } + + if e.sender != nil { + e.sender.SendToHero(msg.HeroID, "buff_applied", model.BuffAppliedPayload{ + BuffType: payload.BuffType, + Duration: ab.Buff.Duration.Seconds(), + Magnitude: ab.Buff.Magnitude, + }) + } +} + +// handleUsePotion processes the use_potion client command. +func (e *Engine) handleUsePotion(msg IncomingMessage) { + e.mu.Lock() + defer e.mu.Unlock() + + hm, ok := e.movements[msg.HeroID] + if !ok { + e.sendError(msg.HeroID, "no_hero", "hero not connected") + return + } + hero := hm.Hero + + // Validate: hero is in combat, has potions, is alive. + if hm.State != model.StateFighting { + e.sendError(msg.HeroID, "not_fighting", "hero is not in combat") + return + } + if hero.Potions <= 0 { + e.sendError(msg.HeroID, "no_potions", "no potions available") + return + } + if hero.HP <= 0 { + e.sendError(msg.HeroID, "dead", "hero is dead") + return + } + + hero.Potions-- + healAmount := hero.MaxHP * 30 / 100 + hero.HP += healAmount + if hero.HP > hero.MaxHP { + hero.HP = hero.MaxHP + } + + // Emit as an attack-like event so the client shows it. + cs, hasCombat := e.combats[msg.HeroID] + enemyHP := 0 + if hasCombat { + enemyHP = cs.Enemy.HP + } + + if e.sender != nil { + e.sender.SendToHero(msg.HeroID, "attack", model.AttackPayload{ + Source: "potion", + Damage: -healAmount, // negative = heal + HeroHP: hero.HP, + EnemyHP: enemyHP, + }) + } +} + +// handleRevive processes the revive client command. +func (e *Engine) handleRevive(msg IncomingMessage) { + e.mu.Lock() + defer e.mu.Unlock() + + hm, ok := e.movements[msg.HeroID] + if !ok { + e.sendError(msg.HeroID, "no_hero", "hero not connected") + return + } + hero := hm.Hero + + if hero.HP > 0 && hm.State != model.StateDead { + e.sendError(msg.HeroID, "not_dead", "hero is not dead") + return + } + + hero.HP = hero.MaxHP / 2 + if hero.HP < 1 { + hero.HP = 1 + } + hero.State = model.StateWalking + hero.Debuffs = nil + hero.ReviveCount++ + + hm.State = model.StateWalking + hm.LastMoveTick = time.Now() + hm.refreshSpeed(time.Now()) + + // Remove any active combat. + delete(e.combats, msg.HeroID) + + // Persist revive to DB immediately so disconnect doesn't revert it. + if e.heroStore != nil { + if err := e.heroStore.Save(context.Background(), hero); err != nil { + e.logger.Error("failed to save hero after revive", "hero_id", hero.ID, "error", err) + } + } + + if e.sender != nil { + e.sender.SendToHero(msg.HeroID, "hero_revived", model.HeroRevivedPayload{HP: hero.HP}) + e.sender.SendToHero(msg.HeroID, "hero_state", hero) + } +} + +// sendError sends an error envelope to a hero. +func (e *Engine) sendError(heroID int64, code, message string) { + if e.sender != nil { + e.sender.SendToHero(heroID, "error", model.ErrorPayload{Code: code, Message: message}) + } +} + +// RegisterHeroMovement creates a HeroMovement for an online hero and sends initial state. +// Called when a WS client connects. +func (e *Engine) RegisterHeroMovement(hero *model.Hero) { + e.mu.Lock() + defer e.mu.Unlock() + + if e.roadGraph == nil { + e.logger.Warn("cannot register movement: road graph not loaded", "hero_id", hero.ID) + return + } + + now := time.Now() + hm := NewHeroMovement(hero, e.roadGraph, now) + e.movements[hero.ID] = hm + + e.logger.Info("hero movement registered", + "hero_id", hero.ID, + "state", hm.State, + "pos_x", hm.CurrentX, + "pos_y", hm.CurrentY, + ) + + // Send initial state via WS. + if e.sender != nil { + hero.RefreshDerivedCombatStats(now) + e.sender.SendToHero(hero.ID, "hero_state", hero) + + if route := hm.RoutePayload(); route != nil { + e.sender.SendToHero(hero.ID, "route_assigned", route) + } + + // If mid-combat, send combat_start so client can resume UI. + if cs, ok := e.combats[hero.ID]; ok { + e.sender.SendToHero(hero.ID, "combat_start", model.CombatStartPayload{ + Enemy: enemyToInfo(&cs.Enemy), + }) + } + } +} + +// UnregisterHeroMovement removes movement state and persists hero to DB. +// Called when a WS client disconnects. +func (e *Engine) UnregisterHeroMovement(heroID int64) { + e.mu.Lock() + hm, ok := e.movements[heroID] + if ok { + hm.SyncToHero() + delete(e.movements, heroID) + } + e.mu.Unlock() + + if ok && e.heroStore != nil { + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + if err := e.heroStore.Save(ctx, hm.Hero); err != nil { + e.logger.Error("failed to save hero on disconnect", "hero_id", heroID, "error", err) + } else { + e.logger.Info("hero state persisted on disconnect", "hero_id", heroID) + } + } +} + +// Status returns a snapshot of the engine's current operational state. +func (e *Engine) Status() EngineStatus { + e.mu.RLock() + defer e.mu.RUnlock() + var uptimeMs int64 + if e.running { + uptimeMs = time.Since(e.startedAt).Milliseconds() + } + return EngineStatus{ + Running: e.running, + TickRate: e.tickRate, + ActiveCombats: len(e.combats), + ActiveMovements: len(e.movements), + UptimeMs: uptimeMs, + } +} + +// ListActiveCombats returns a snapshot of all active combat sessions. +func (e *Engine) ListActiveCombats() []CombatInfo { + e.mu.RLock() + defer e.mu.RUnlock() + out := make([]CombatInfo, 0, len(e.combats)) + for _, cs := range e.combats { + heroHP := 0 + if cs.Hero != nil { + heroHP = cs.Hero.HP + } + out = append(out, CombatInfo{ + HeroID: cs.HeroID, + EnemyName: cs.Enemy.Name, + EnemyType: string(cs.Enemy.Type), + HeroHP: heroHP, + EnemyHP: cs.Enemy.HP, + StartedAt: cs.StartedAt, + }) + } + return out +} + +// StartCombat registers a new combat encounter between a hero and an enemy. +func (e *Engine) StartCombat(hero *model.Hero, enemy *model.Enemy) { + e.mu.Lock() + defer e.mu.Unlock() + e.startCombatLocked(hero, enemy) +} + +// startCombatLocked is the internal version that assumes the lock is already held. +func (e *Engine) startCombatLocked(hero *model.Hero, enemy *model.Enemy) { + now := time.Now() + + cs := &model.CombatState{ + HeroID: hero.ID, + Hero: hero, + Enemy: *enemy, + HeroNextAttack: now.Add(attackInterval(hero.EffectiveSpeed())), + EnemyNextAttack: now.Add(attackInterval(enemy.Speed)), + StartedAt: now, + LastTickAt: now, + } + e.combats[hero.ID] = cs + + hero.State = model.StateFighting + + // Update movement state. + if hm, ok := e.movements[hero.ID]; ok { + hm.StartFighting() + } + + heap.Push(&e.queue, &model.AttackEvent{ + NextAttackAt: cs.HeroNextAttack, + IsHero: true, + CombatID: hero.ID, + }) + heap.Push(&e.queue, &model.AttackEvent{ + NextAttackAt: cs.EnemyNextAttack, + IsHero: false, + CombatID: hero.ID, + }) + + // Legacy event channel (for backward compat bridge). + e.emitEvent(model.CombatEvent{ + Type: "combat_start", + HeroID: hero.ID, + Source: "system", + HeroHP: hero.HP, + EnemyHP: enemy.HP, + Timestamp: now, + }) + + // New: send typed combat_start envelope. + if e.sender != nil { + e.sender.SendToHero(hero.ID, "combat_start", model.CombatStartPayload{ + Enemy: enemyToInfo(enemy), + }) + } + + e.logger.Info("combat started", + "hero_id", hero.ID, + "enemy", enemy.Name, + ) +} + +// StopCombat removes a combat session. +func (e *Engine) StopCombat(heroID int64) { + e.mu.Lock() + defer e.mu.Unlock() + delete(e.combats, heroID) +} + +func (e *Engine) SyncHeroState(hero *model.Hero) { + if hero == nil { + return + } + e.mu.Lock() + defer e.mu.Unlock() + + e.sender.SendToHero(hero.ID, "hero_state", hero) +} + +// ApplyAdminHeroRevive updates the live engine state after POST /admin/.../revive persisted +// the hero. Clears combat, copies the saved snapshot onto the in-memory hero (if online), +// restores movement/route when needed, and pushes WS events so the client matches the DB. +func (e *Engine) ApplyAdminHeroRevive(hero *model.Hero) { + if hero == nil { + return + } + e.mu.Lock() + defer e.mu.Unlock() + + delete(e.combats, hero.ID) + + hm, ok := e.movements[hero.ID] + if !ok { + return + } + + now := time.Now() + *hm.Hero = *hero + hm.CurrentX = hero.PositionX + hm.CurrentY = hero.PositionY + hm.State = hero.State + hm.TownNPCQueue = nil + hm.NextTownNPCRollAt = time.Time{} + hm.LastMoveTick = now + hm.refreshSpeed(now) + + routeAssigned := false + if hm.State == model.StateWalking && hm.Road == nil && e.roadGraph != nil { + hm.pickDestination(e.roadGraph) + hm.assignRoad(e.roadGraph) + routeAssigned = true + } + + if e.sender == nil { + return + } + hm.Hero.RefreshDerivedCombatStats(now) + e.sender.SendToHero(hero.ID, "hero_revived", model.HeroRevivedPayload{HP: hm.Hero.HP}) + e.sender.SendToHero(hero.ID, "hero_state", hm.Hero) + if routeAssigned { + if route := hm.RoutePayload(); route != nil { + e.sender.SendToHero(hero.ID, "route_assigned", route) + } + } +} + +// GetCombat returns the current combat state for a hero, if any. +func (e *Engine) GetCombat(heroID int64) (*model.CombatState, bool) { + e.mu.RLock() + defer e.mu.RUnlock() + cs, ok := e.combats[heroID] + return cs, ok +} + +// processCombatTick is the 100ms combat processing tick. +func (e *Engine) processCombatTick(now time.Time) { + e.mu.Lock() + defer e.mu.Unlock() + + // Apply periodic effects (debuff DoT, enemy regen, summon damage) for all active combats. + for heroID, cs := range e.combats { + if cs.Hero == nil { + continue + } + tickDur := now.Sub(cs.LastTickAt) + if tickDur <= 0 { + continue + } + + ProcessDebuffDamage(cs.Hero, tickDur, now) + ProcessEnemyRegen(&cs.Enemy, tickDur) + ProcessSummonDamage(cs.Hero, &cs.Enemy, cs.StartedAt, cs.LastTickAt, now) + cs.LastTickAt = now + + if CheckDeath(cs.Hero, now) { + e.emitEvent(model.CombatEvent{ + Type: "death", HeroID: heroID, Source: "hero", + HeroHP: 0, EnemyHP: cs.Enemy.HP, Timestamp: now, + }) + if e.sender != nil { + e.sender.SendToHero(heroID, "hero_died", model.HeroDiedPayload{ + KilledBy: cs.Enemy.Name, + }) + } + // Update movement state to dead. + if hm, ok := e.movements[heroID]; ok { + hm.Die() + } + delete(e.combats, heroID) + } + } + + // Process all attacks that are due. + for e.queue.Len() > 0 { + next := e.queue[0] + if next.NextAttackAt.After(now) { + break + } + evt := heap.Pop(&e.queue).(*model.AttackEvent) + + cs, ok := e.combats[evt.CombatID] + if !ok { + continue // combat ended + } + + e.processAttackEvent(evt, cs, now) + } +} + +func (e *Engine) processAttackEvent(evt *model.AttackEvent, cs *model.CombatState, now time.Time) { + if evt.IsHero { + e.processHeroAttack(cs, now) + } else { + e.processEnemyAttack(cs, now) + } +} + +func (e *Engine) processHeroAttack(cs *model.CombatState, now time.Time) { + if cs.Hero == nil { + e.logger.Error("processHeroAttack: nil hero reference", "hero_id", cs.HeroID) + return + } + + combatEvt := ProcessAttack(cs.Hero, &cs.Enemy, now) + e.emitEvent(combatEvt) + + // Push attack envelope. + if e.sender != nil { + e.sender.SendToHero(cs.HeroID, "attack", model.AttackPayload{ + Source: combatEvt.Source, + Damage: combatEvt.Damage, + IsCrit: combatEvt.IsCrit, + HeroHP: combatEvt.HeroHP, + EnemyHP: combatEvt.EnemyHP, + DebuffApplied: combatEvt.DebuffApplied, + }) + } + + if !cs.Enemy.IsAlive() { + e.handleEnemyDeath(cs, now) + return + } + + // Reschedule hero's next attack using actual effective speed. + cs.HeroNextAttack = now.Add(attackInterval(cs.Hero.EffectiveSpeed())) + heap.Push(&e.queue, &model.AttackEvent{ + NextAttackAt: cs.HeroNextAttack, + IsHero: true, + CombatID: cs.HeroID, + }) +} + +func (e *Engine) processEnemyAttack(cs *model.CombatState, now time.Time) { + if cs.Hero == nil { + e.logger.Error("processEnemyAttack: nil hero reference", "hero_id", cs.HeroID) + return + } + + combatEvt := ProcessEnemyAttack(cs.Hero, &cs.Enemy, now) + e.emitEvent(combatEvt) + + // Push attack envelope. + if e.sender != nil { + e.sender.SendToHero(cs.HeroID, "attack", model.AttackPayload{ + Source: combatEvt.Source, + Damage: combatEvt.Damage, + IsCrit: combatEvt.IsCrit, + HeroHP: combatEvt.HeroHP, + EnemyHP: combatEvt.EnemyHP, + DebuffApplied: combatEvt.DebuffApplied, + }) + } + + // Check if the hero died from this attack. + if CheckDeath(cs.Hero, now) { + e.emitEvent(model.CombatEvent{ + Type: "death", + HeroID: cs.HeroID, + Source: "hero", + HeroHP: 0, + EnemyHP: cs.Enemy.HP, + Timestamp: now, + }) + if e.sender != nil { + e.sender.SendToHero(cs.HeroID, "hero_died", model.HeroDiedPayload{ + KilledBy: cs.Enemy.Name, + }) + } + if hm, ok := e.movements[cs.HeroID]; ok { + hm.Die() + } + delete(e.combats, cs.HeroID) + + e.logger.Info("hero died", + "hero_id", cs.HeroID, + "enemy", cs.Enemy.Name, + ) + return + } + + // Reschedule enemy's next attack. + cs.EnemyNextAttack = now.Add(attackInterval(cs.Enemy.Speed)) + heap.Push(&e.queue, &model.AttackEvent{ + NextAttackAt: cs.EnemyNextAttack, + IsHero: false, + CombatID: cs.HeroID, + }) +} + +func (e *Engine) handleEnemyDeath(cs *model.CombatState, now time.Time) { + hero := cs.Hero + enemy := &cs.Enemy + oldLevel := hero.Level + + // Rewards (XP, gold, loot, level-ups) are handled by the onEnemyDeath callback + // via processVictoryRewards -- the single source of truth. + if e.onEnemyDeath != nil && hero != nil { + e.onEnemyDeath(hero, enemy, now) + } + + e.emitEvent(model.CombatEvent{ + Type: "combat_end", + HeroID: cs.HeroID, + Source: "system", + EnemyHP: 0, + Timestamp: now, + }) + + leveledUp := hero.Level > oldLevel + + // Push typed combat_end envelope. + if e.sender != nil { + e.sender.SendToHero(cs.HeroID, "combat_end", model.CombatEndPayload{ + XPGained: enemy.XPReward, + GoldGained: enemy.GoldReward, + LeveledUp: leveledUp, + NewLevel: hero.Level, + }) + + if leveledUp { + e.sender.SendToHero(cs.HeroID, "level_up", model.LevelUpPayload{ + NewLevel: hero.Level, + }) + hero.RefreshDerivedCombatStats(now) + e.sender.SendToHero(cs.HeroID, "hero_state", hero) + } + } + + delete(e.combats, cs.HeroID) + + // Resume walking. + if hm, ok := e.movements[cs.HeroID]; ok { + hm.ResumeWalking(now) + } + + e.logger.Info("enemy defeated", + "hero_id", cs.HeroID, + "enemy", enemy.Name, + ) +} + +// processMovementTick advances all walking heroes and checks for encounters. +// Called at 2 Hz (500ms). +func (e *Engine) processMovementTick(now time.Time) { + e.mu.Lock() + defer e.mu.Unlock() + + if e.roadGraph == nil { + return + } + + startCombat := func(hm *HeroMovement, enemy *model.Enemy, t time.Time) { + e.startCombatLocked(hm.Hero, enemy) + } + + for heroID, hm := range e.movements { + ProcessSingleHeroMovementTick(heroID, hm, e.roadGraph, now, e.sender, startCombat) + } +} + +// processPositionSync sends drift-correction position_sync messages. +// Called at 0.1 Hz (every 10s). +func (e *Engine) processPositionSync(now time.Time) { + e.mu.RLock() + defer e.mu.RUnlock() + + if e.sender == nil { + return + } + + for heroID, hm := range e.movements { + if hm.State == model.StateWalking { + e.sender.SendToHero(heroID, "position_sync", hm.PositionSyncPayload()) + } + } +} + +func (e *Engine) emitEvent(evt model.CombatEvent) { + select { + case e.eventCh <- evt: + default: + e.logger.Warn("combat event channel full, dropping event", + "type", evt.Type, + "hero_id", evt.HeroID, + ) + } +} + +// attackInterval converts an attacks-per-second speed to a duration between attacks. +func attackInterval(speed float64) time.Duration { + if speed <= 0 { + return time.Second * combatPaceMultiplier // fallback: 1 attack per second, scaled + } + interval := time.Duration(float64(time.Second)/speed) * combatPaceMultiplier + if interval < minAttackInterval*combatPaceMultiplier { + return minAttackInterval * combatPaceMultiplier + } + return interval +} + +// enemyToInfo converts a model.Enemy to the WS payload info struct. +func enemyToInfo(e *model.Enemy) model.CombatEnemyInfo { + return model.CombatEnemyInfo{ + Name: e.Name, + Type: string(e.Type), + HP: e.HP, + MaxHP: e.MaxHP, + Attack: e.Attack, + Defense: e.Defense, + Speed: e.Speed, + IsElite: e.IsElite, + } +} diff --git a/backend/internal/game/engine_test.go b/backend/internal/game/engine_test.go new file mode 100644 index 0000000..b3a36b3 --- /dev/null +++ b/backend/internal/game/engine_test.go @@ -0,0 +1,23 @@ +package game + +import ( + "testing" + "time" +) + +func TestAttackIntervalRespectsMinimumCap(t *testing.T) { + got := attackInterval(10.0) + want := minAttackInterval * combatPaceMultiplier + if got != want { + t.Fatalf("expected min interval %s, got %s", want, got) + } +} + +func TestAttackIntervalForNormalSpeed(t *testing.T) { + got := attackInterval(2.0) + // 1/2 s per attack at 2 APS, scaled by combatPaceMultiplier + want := 500 * time.Millisecond * combatPaceMultiplier + if got != want { + t.Fatalf("expected %s, got %s", want, got) + } +} diff --git a/backend/internal/game/movement.go b/backend/internal/game/movement.go new file mode 100644 index 0000000..7c2154f --- /dev/null +++ b/backend/internal/game/movement.go @@ -0,0 +1,616 @@ +package game + +import ( + "encoding/json" + "math" + "math/rand" + "os" + "path/filepath" + "time" + + "github.com/denisovdennis/autohero/internal/model" +) + +// #region agent log +func agentDebugLog(hypothesisID, location, message string, data map[string]any) { + wd, err := os.Getwd() + if err != nil { + return + } + logPath := filepath.Join(wd, "debug-cbb64d.log") + if filepath.Base(wd) == "backend" { + logPath = filepath.Join(wd, "..", "debug-cbb64d.log") + } + payload := map[string]any{ + "sessionId": "cbb64d", + "hypothesisId": hypothesisID, + "location": location, + "message": message, + "data": data, + "timestamp": time.Now().UnixMilli(), + } + b, err := json.Marshal(payload) + if err != nil { + return + } + f, err := os.OpenFile(logPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644) + if err != nil { + return + } + _, _ = f.Write(append(b, '\n')) + _ = f.Close() +} + +// #endregion + +const ( + // BaseMoveSpeed is the hero's base movement speed in world-units per second. + BaseMoveSpeed = 2.0 + + // MovementTickRate is how often the movement system updates (2 Hz). + MovementTickRate = 500 * time.Millisecond + + // PositionSyncRate is how often the server sends a full position_sync (drift correction). + PositionSyncRate = 10 * time.Second + + // EncounterCooldownBase is the minimum gap between random encounters. + EncounterCooldownBase = 15 * time.Second + + // EncounterChancePerTick is the probability of an encounter on each movement tick. + EncounterChancePerTick = 0.04 + + // TownRestMin is the minimum rest duration when arriving at a town. + TownRestMin = 5 * 60 * time.Second + + // TownRestMax is the maximum rest duration when arriving at a town. + TownRestMax = 20 * 60 * time.Second + + // TownArrivalRadius is how close the hero must be to the final waypoint + // to be considered "arrived" at the town. + TownArrivalRadius = 0.5 + + // Town NPC visits: high chance each attempt to approach the next NPC; queue clears on LeaveTown. + townNPCVisitChance = 0.78 + townNPCRollMin = 800 * time.Millisecond + townNPCRollMax = 2600 * time.Millisecond + townNPCRetryAfterMiss = 450 * time.Millisecond +) + +// HeroMovement holds the live movement state for a single online hero. +type HeroMovement struct { + HeroID int64 + Hero *model.Hero // live reference, owned by the engine + CurrentX float64 + CurrentY float64 + Speed float64 // effective world-units/sec + State model.GameState + DestinationTownID int64 + CurrentTownID int64 + Road *Road + WaypointIndex int // index of the waypoint we are heading toward + WaypointFraction float64 // 0..1 within the current segment + LastEncounterAt time.Time + RestUntil time.Time + LastMoveTick time.Time + Direction int // +1 forward along TownOrder, -1 backward + + // TownNPCQueue: NPC ids still to visit this stay (nil = not on NPC tour). Cleared in LeaveTown. + TownNPCQueue []int64 + NextTownNPCRollAt time.Time +} + +// NewHeroMovement creates a HeroMovement for a hero that just connected. +// It initializes position, state, and picks the first destination if needed. +func NewHeroMovement(hero *model.Hero, graph *RoadGraph, now time.Time) *HeroMovement { + // Randomize direction per hero so they don't all walk the same way. + dir := 1 + if hero.ID%2 == 0 { + dir = -1 + } + + // Add per-hero position offset so heroes on the same road don't overlap. + // Use hero ID to create a stable lateral offset of ±1.5 tiles. + lateralOffset := (float64(hero.ID%7) - 3.0) * 0.5 + + hm := &HeroMovement{ + HeroID: hero.ID, + Hero: hero, + CurrentX: hero.PositionX + lateralOffset*0.3, + CurrentY: hero.PositionY + lateralOffset*0.7, + State: hero.State, + LastMoveTick: now, + Direction: dir, + } + + // Restore persisted movement state. + if hero.CurrentTownID != nil { + hm.CurrentTownID = *hero.CurrentTownID + } + if hero.DestinationTownID != nil { + hm.DestinationTownID = *hero.DestinationTownID + } + + hm.refreshSpeed(now) + + // If the hero is dead, keep them dead. + if hero.State == model.StateDead || hero.HP <= 0 { + hm.State = model.StateDead + return hm + } + + // If fighting, leave as-is (engine combat system manages it). + if hero.State == model.StateFighting { + return hm + } + + // If resting/in_town, set a short rest timer so they leave soon. + if hero.State == model.StateResting || hero.State == model.StateInTown { + hm.State = model.StateResting + hm.RestUntil = now.Add(randomRestDuration()) + return hm + } + + // Walking state: assign a road if we don't have a destination. + if hm.DestinationTownID == 0 { + hm.pickDestination(graph) + } + hm.assignRoad(graph) + hm.State = model.StateWalking + + return hm +} + +// pickDestination selects the next town the hero should walk toward. +func (hm *HeroMovement) pickDestination(graph *RoadGraph) { + if hm.CurrentTownID == 0 { + // Hero is not associated with any town yet, pick nearest. + hm.CurrentTownID = graph.NearestTown(hm.CurrentX, hm.CurrentY) + } + + idx := graph.TownOrderIndex(hm.CurrentTownID) + if idx < 0 { + // Fallback. + if len(graph.TownOrder) > 0 { + hm.DestinationTownID = graph.TownOrder[0] + } + return + } + + n := len(graph.TownOrder) + if n <= 1 { + hm.DestinationTownID = hm.CurrentTownID + return + } + + nextIdx := idx + hm.Direction + if nextIdx >= n { + nextIdx = 0 + } + if nextIdx < 0 { + nextIdx = n - 1 + } + + hm.DestinationTownID = graph.TownOrder[nextIdx] +} + +// assignRoad finds and configures the road from CurrentTownID to DestinationTownID. +// If no road exists (hero is mid-road), it finds the nearest town and routes from there. +func (hm *HeroMovement) assignRoad(graph *RoadGraph) { + road := graph.FindRoad(hm.CurrentTownID, hm.DestinationTownID) + if road == nil { + // Try finding a road from any nearby town. + nearest := graph.NearestTown(hm.CurrentX, hm.CurrentY) + hm.CurrentTownID = nearest + road = graph.FindRoad(nearest, hm.DestinationTownID) + } + if road == nil { + // #region agent log + agentDebugLog("H5", "movement.go:assignRoad", "no road after nearest retry", map[string]any{ + "currentTownID": hm.CurrentTownID, "destinationTownID": hm.DestinationTownID, + "x": hm.CurrentX, "y": hm.CurrentY, + }) + // #endregion + // No road available, will retry next tick. + return + } + + // Create a per-hero jittered copy of waypoints so heroes don't overlap on the same road. + jitteredWaypoints := make([]Point, len(road.Waypoints)) + copy(jitteredWaypoints, road.Waypoints) + heroSeed := float64(hm.HeroID) + lateralJitter := (math.Sin(heroSeed*1.7) * 1.5) // ±1.5 tiles lateral offset + for i := 1; i < len(jitteredWaypoints)-1; i++ { + // Apply perpendicular offset (don't jitter start/end = town centers) + dx := jitteredWaypoints[i].X - jitteredWaypoints[max(0, i-1)].X + dy := jitteredWaypoints[i].Y - jitteredWaypoints[max(0, i-1)].Y + segLen := math.Hypot(dx, dy) + if segLen > 0.1 { + perpX := -dy / segLen + perpY := dx / segLen + jitter := lateralJitter * (0.7 + 0.3*math.Sin(heroSeed*0.3+float64(i)*0.5)) + jitteredWaypoints[i].X += perpX * jitter + jitteredWaypoints[i].Y += perpY * jitter + } + } + + jitteredRoad := &Road{ + ID: road.ID, + FromTownID: road.FromTownID, + ToTownID: road.ToTownID, + Distance: road.Distance, + Waypoints: jitteredWaypoints, + } + + hm.Road = jitteredRoad + hm.WaypointIndex = 0 + hm.WaypointFraction = 0 + + // Position the hero at the start of the road if they're very close to the origin town. + if len(jitteredWaypoints) > 0 { + start := jitteredWaypoints[0] + dist := math.Hypot(hm.CurrentX-start.X, hm.CurrentY-start.Y) + if dist < 5.0 { + hm.CurrentX = start.X + hm.CurrentY = start.Y + } + } +} + +// refreshSpeed recalculates the effective movement speed using hero buffs/debuffs. +func (hm *HeroMovement) refreshSpeed(now time.Time) { + // Per-hero speed variation: ±10% based on hero ID for natural spread. + heroSpeedJitter := 0.90 + float64(hm.HeroID%21)*0.01 // 0.90 to 1.10 + hm.Speed = BaseMoveSpeed * hm.Hero.MovementSpeedMultiplier(now) * heroSpeedJitter +} + +// AdvanceTick moves the hero along the road for one movement tick. +// Returns true if the hero reached the destination town this tick. +func (hm *HeroMovement) AdvanceTick(now time.Time, graph *RoadGraph) (reachedTown bool) { + if hm.Road == nil || len(hm.Road.Waypoints) < 2 { + return false + } + + dt := now.Sub(hm.LastMoveTick).Seconds() + if dt <= 0 { + dt = MovementTickRate.Seconds() + } + hm.LastMoveTick = now + + hm.refreshSpeed(now) + distThisTick := hm.Speed * dt + + for distThisTick > 0 && hm.WaypointIndex < len(hm.Road.Waypoints)-1 { + from := hm.Road.Waypoints[hm.WaypointIndex] + to := hm.Road.Waypoints[hm.WaypointIndex+1] + segLen := math.Hypot(to.X-from.X, to.Y-from.Y) + if segLen < 0.001 { + hm.WaypointIndex++ + hm.WaypointFraction = 0 + continue + } + + // How far along this segment we already are. + currentDist := hm.WaypointFraction * segLen + remaining := segLen - currentDist + + if distThisTick >= remaining { + // Move to next waypoint. + distThisTick -= remaining + hm.WaypointIndex++ + hm.WaypointFraction = 0 + if hm.WaypointIndex >= len(hm.Road.Waypoints)-1 { + // Reached final waypoint = destination town. + last := hm.Road.Waypoints[len(hm.Road.Waypoints)-1] + hm.CurrentX = last.X + hm.CurrentY = last.Y + return true + } + } else { + // Partial advance within this segment. + hm.WaypointFraction = (currentDist + distThisTick) / segLen + hm.CurrentX = from.X + (to.X-from.X)*hm.WaypointFraction + hm.CurrentY = from.Y + (to.Y-from.Y)*hm.WaypointFraction + distThisTick = 0 + } + } + + // Update position to the current waypoint position. + if hm.WaypointIndex < len(hm.Road.Waypoints) { + wp := hm.Road.Waypoints[hm.WaypointIndex] + if hm.WaypointFraction == 0 { + hm.CurrentX = wp.X + hm.CurrentY = wp.Y + } + } + + return false +} + +// Heading returns the angle (radians) the hero is currently facing. +func (hm *HeroMovement) Heading() float64 { + if hm.Road == nil || hm.WaypointIndex >= len(hm.Road.Waypoints)-1 { + return 0 + } + to := hm.Road.Waypoints[hm.WaypointIndex+1] + return math.Atan2(to.Y-hm.CurrentY, to.X-hm.CurrentX) +} + +// TargetPoint returns the next waypoint the hero is heading toward. +func (hm *HeroMovement) TargetPoint() (float64, float64) { + if hm.Road == nil || hm.WaypointIndex >= len(hm.Road.Waypoints)-1 { + return hm.CurrentX, hm.CurrentY + } + wp := hm.Road.Waypoints[hm.WaypointIndex+1] + return wp.X, wp.Y +} + +// ShouldEncounter rolls for a random encounter, respecting the cooldown. +func (hm *HeroMovement) ShouldEncounter(now time.Time) bool { + if now.Sub(hm.LastEncounterAt) < EncounterCooldownBase { + return false + } + return rand.Float64() < EncounterChancePerTick +} + +// EnterTown transitions the hero into the destination town: NPC tour (StateInTown) when there +// are NPCs, otherwise a short resting state (StateResting). +func (hm *HeroMovement) EnterTown(now time.Time, graph *RoadGraph) { + destID := hm.DestinationTownID + hm.CurrentTownID = destID + hm.DestinationTownID = 0 + hm.Road = nil + hm.TownNPCQueue = nil + hm.NextTownNPCRollAt = time.Time{} + + ids := graph.TownNPCIDs(destID) + if len(ids) == 0 { + hm.State = model.StateResting + hm.Hero.State = model.StateResting + hm.RestUntil = now.Add(randomRestDuration()) + return + } + + q := make([]int64, len(ids)) + copy(q, ids) + rand.Shuffle(len(q), func(i, j int) { q[i], q[j] = q[j], q[i] }) + hm.TownNPCQueue = q + hm.State = model.StateInTown + hm.Hero.State = model.StateInTown + hm.NextTownNPCRollAt = now.Add(randomTownNPCDelay()) +} + +// LeaveTown transitions the hero from town to walking, picking a new destination. +func (hm *HeroMovement) LeaveTown(graph *RoadGraph, now time.Time) { + hm.TownNPCQueue = nil + hm.NextTownNPCRollAt = time.Time{} + hm.State = model.StateWalking + hm.Hero.State = model.StateWalking + hm.pickDestination(graph) + hm.assignRoad(graph) + hm.refreshSpeed(now) +} + +func randomTownNPCDelay() time.Duration { + rangeMs := (townNPCRollMax - townNPCRollMin).Milliseconds() + return townNPCRollMin + time.Duration(rand.Int63n(rangeMs+1))*time.Millisecond +} + +// StartFighting pauses movement for combat. +func (hm *HeroMovement) StartFighting() { + hm.State = model.StateFighting +} + +// ResumWalking resumes movement after combat. +func (hm *HeroMovement) ResumeWalking(now time.Time) { + hm.State = model.StateWalking + hm.LastMoveTick = now + hm.refreshSpeed(now) +} + +// Die sets the movement state to dead. +func (hm *HeroMovement) Die() { + hm.State = model.StateDead +} + +// SyncToHero writes movement state back to the hero model for persistence. +func (hm *HeroMovement) SyncToHero() { + hm.Hero.PositionX = hm.CurrentX + hm.Hero.PositionY = hm.CurrentY + hm.Hero.State = hm.State + if hm.CurrentTownID != 0 { + id := hm.CurrentTownID + hm.Hero.CurrentTownID = &id + } else { + hm.Hero.CurrentTownID = nil + } + if hm.DestinationTownID != 0 { + id := hm.DestinationTownID + hm.Hero.DestinationTownID = &id + } else { + hm.Hero.DestinationTownID = nil + } + hm.Hero.MoveState = string(hm.State) +} + +// MovePayload builds the hero_move WS payload. +func (hm *HeroMovement) MovePayload() model.HeroMovePayload { + tx, ty := hm.TargetPoint() + return model.HeroMovePayload{ + X: hm.CurrentX, + Y: hm.CurrentY, + TargetX: tx, + TargetY: ty, + Speed: hm.Speed, + Heading: hm.Heading(), + } +} + +// RoutePayload builds the route_assigned WS payload. +func (hm *HeroMovement) RoutePayload() *model.RouteAssignedPayload { + if hm.Road == nil { + return nil + } + waypoints := make([]model.PointXY, len(hm.Road.Waypoints)) + for i, p := range hm.Road.Waypoints { + waypoints[i] = model.PointXY{X: p.X, Y: p.Y} + } + return &model.RouteAssignedPayload{ + RoadID: hm.Road.ID, + Waypoints: waypoints, + DestinationTownID: hm.DestinationTownID, + Speed: hm.Speed, + } +} + +// PositionSyncPayload builds the position_sync WS payload. +func (hm *HeroMovement) PositionSyncPayload() model.PositionSyncPayload { + return model.PositionSyncPayload{ + X: hm.CurrentX, + Y: hm.CurrentY, + WaypointIndex: hm.WaypointIndex, + WaypointFraction: hm.WaypointFraction, + State: string(hm.State), + } +} + +// randomRestDuration returns a random duration between TownRestMin and TownRestMax. +func randomRestDuration() time.Duration { + rangeMs := (TownRestMax - TownRestMin).Milliseconds() + return TownRestMin + time.Duration(rand.Int63n(rangeMs+1))*time.Millisecond +} + +// EncounterStarter starts or resolves a random encounter while walking (engine: combat; +// offline: synchronous SimulateOneFight via callback). +type EncounterStarter func(hm *HeroMovement, enemy *model.Enemy, now time.Time) + +// ProcessSingleHeroMovementTick applies one movement-system step as of logical time now. +// It mirrors the online engine's 500ms cadence: callers should advance now in MovementTickRate +// steps (plus a final partial step to real time) for catch-up simulation. +// +// sender may be nil to suppress all WebSocket payloads (offline ticks). +// onEncounter is required for walking encounter rolls; if nil, encounters are not triggered. +func ProcessSingleHeroMovementTick( + heroID int64, + hm *HeroMovement, + graph *RoadGraph, + now time.Time, + sender MessageSender, + onEncounter EncounterStarter, +) { + if graph == nil { + return + } + + switch hm.State { + case model.StateFighting, model.StateDead: + return + + case model.StateResting: + if now.After(hm.RestUntil) { + hm.LeaveTown(graph, now) + hm.SyncToHero() + if sender != nil { + sender.SendToHero(heroID, "town_exit", model.TownExitPayload{}) + if route := hm.RoutePayload(); route != nil { + sender.SendToHero(heroID, "route_assigned", route) + } + } + } + + case model.StateInTown: + if len(hm.TownNPCQueue) == 0 { + hm.LeaveTown(graph, now) + hm.SyncToHero() + if sender != nil { + sender.SendToHero(heroID, "town_exit", model.TownExitPayload{}) + if route := hm.RoutePayload(); route != nil { + sender.SendToHero(heroID, "route_assigned", route) + } + } + return + } + if now.Before(hm.NextTownNPCRollAt) { + return + } + if rand.Float64() < townNPCVisitChance { + npcID := hm.TownNPCQueue[0] + hm.TownNPCQueue = hm.TownNPCQueue[1:] + if npc, ok := graph.NPCByID[npcID]; ok && sender != nil { + sender.SendToHero(heroID, "town_npc_visit", model.TownNPCVisitPayload{ + NPCID: npc.ID, Name: npc.Name, Type: npc.Type, TownID: hm.CurrentTownID, + }) + } + hm.NextTownNPCRollAt = now.Add(randomTownNPCDelay()) + } else { + hm.NextTownNPCRollAt = now.Add(townNPCRetryAfterMiss) + } + + case model.StateWalking: + // #region agent log + if hm.Road == nil { + agentDebugLog("H1", "movement.go:StateWalking", "walking with nil Road", map[string]any{ + "heroID": heroID, "currentTownID": hm.CurrentTownID, "destinationTownID": hm.DestinationTownID, + "x": hm.CurrentX, "y": hm.CurrentY, + }) + } else if len(hm.Road.Waypoints) < 2 { + agentDebugLog("H2", "movement.go:StateWalking", "road has fewer than 2 waypoints", map[string]any{ + "heroID": heroID, "roadID": hm.Road.ID, "waypointCount": len(hm.Road.Waypoints), + }) + } + // #endregion + reachedTown := hm.AdvanceTick(now, graph) + + if reachedTown { + hm.EnterTown(now, graph) + + if sender != nil { + town := graph.Towns[hm.CurrentTownID] + if town != nil { + npcInfos := make([]model.TownNPCInfo, 0, len(graph.TownNPCs[hm.CurrentTownID])) + for _, n := range graph.TownNPCs[hm.CurrentTownID] { + npcInfos = append(npcInfos, model.TownNPCInfo{ID: n.ID, Name: n.Name, Type: n.Type}) + } + var restMs int64 + if hm.State == model.StateResting { + restMs = hm.RestUntil.Sub(now).Milliseconds() + } + sender.SendToHero(heroID, "town_enter", model.TownEnterPayload{ + TownID: town.ID, + TownName: town.Name, + Biome: town.Biome, + NPCs: npcInfos, + RestDurationMs: restMs, + }) + } + } + + hm.SyncToHero() + return + } + + if onEncounter != nil && hm.ShouldEncounter(now) { + // #region agent log + agentDebugLog("H3", "movement.go:encounter", "encounter starting", map[string]any{ + "heroID": heroID, "roadNil": hm.Road == nil, "waypointCount": func() int { + if hm.Road == nil { + return -1 + } + return len(hm.Road.Waypoints) + }(), + "x": hm.CurrentX, "y": hm.CurrentY, "currentTownID": hm.CurrentTownID, + }) + // #endregion + enemy := PickEnemyForLevel(hm.Hero.Level) + hm.LastEncounterAt = now + onEncounter(hm, &enemy, now) + return + } + + if sender != nil { + sender.SendToHero(heroID, "hero_move", hm.MovePayload()) + } + + hm.Hero.PositionX = hm.CurrentX + hm.Hero.PositionY = hm.CurrentY + } +} diff --git a/backend/internal/game/offline.go b/backend/internal/game/offline.go new file mode 100644 index 0000000..10c0bfc --- /dev/null +++ b/backend/internal/game/offline.go @@ -0,0 +1,346 @@ +package game + +import ( + "context" + "fmt" + "log/slog" + "math" + "math/rand" + "time" + + "github.com/denisovdennis/autohero/internal/model" + "github.com/denisovdennis/autohero/internal/storage" +) + +// OfflineSimulator runs periodic background ticks for heroes that are offline, +// advancing movement the same way as the online engine (without WebSocket payloads) +// and resolving random encounters with SimulateOneFight. +type OfflineSimulator struct { + store *storage.HeroStore + logStore *storage.LogStore + graph *RoadGraph + interval time.Duration + logger *slog.Logger +} + +// NewOfflineSimulator creates a new OfflineSimulator that ticks every 30 seconds. +func NewOfflineSimulator(store *storage.HeroStore, logStore *storage.LogStore, graph *RoadGraph, logger *slog.Logger) *OfflineSimulator { + return &OfflineSimulator{ + store: store, + logStore: logStore, + graph: graph, + interval: 30 * time.Second, + logger: logger, + } +} + +// Run starts the offline simulation loop. It blocks until the context is cancelled. +func (s *OfflineSimulator) Run(ctx context.Context) error { + ticker := time.NewTicker(s.interval) + defer ticker.Stop() + + s.logger.Info("offline simulator started", "interval", s.interval) + + for { + select { + case <-ctx.Done(): + s.logger.Info("offline simulator shutting down") + return ctx.Err() + case <-ticker.C: + s.processTick(ctx) + } + } +} + +// processTick finds all offline heroes and simulates one fight for each. +func (s *OfflineSimulator) processTick(ctx context.Context) { + heroes, err := s.store.ListOfflineHeroes(ctx, s.interval*2, 100) + if err != nil { + s.logger.Error("offline simulator: failed to list offline heroes", "error", err) + return + } + + if len(heroes) == 0 { + return + } + + s.logger.Debug("offline simulator tick", "offline_heroes", len(heroes)) + + for _, hero := range heroes { + if err := s.simulateHeroTick(ctx, hero); err != nil { + s.logger.Error("offline simulator: hero tick failed", + "hero_id", hero.ID, + "error", err, + ) + // Continue with other heroes — don't crash on one failure. + } + } +} + +// simulateHeroTick catches up movement (500ms steps) from hero.UpdatedAt to now, +// then persists. Random encounters use the same rolls as online; combat is resolved +// synchronously via SimulateOneFight (no WebSocket). +func (s *OfflineSimulator) simulateHeroTick(ctx context.Context, hero *model.Hero) error { + now := time.Now() + + // Auto-revive if hero has been dead for more than 1 hour (spec section 3.3). + if (hero.State == model.StateDead || hero.HP <= 0) && time.Since(hero.UpdatedAt) > 1*time.Hour { + hero.HP = hero.MaxHP / 2 + if hero.HP < 1 { + hero.HP = 1 + } + hero.State = model.StateWalking + hero.Debuffs = nil + s.addLog(ctx, hero.ID, "Auto-revived after 1 hour") + } + + // Dead heroes cannot move or fight. + if hero.State == model.StateDead || hero.HP <= 0 { + return nil + } + + if s.graph == nil { + s.logger.Warn("offline simulator: road graph nil, skipping movement tick", "hero_id", hero.ID) + return nil + } + + hm := NewHeroMovement(hero, s.graph, now) + if hero.UpdatedAt.IsZero() { + hm.LastMoveTick = now.Add(-MovementTickRate) + } else { + hm.LastMoveTick = hero.UpdatedAt + } + + encounter := func(hm *HeroMovement, enemy *model.Enemy, tickNow time.Time) { + s.addLog(ctx, hm.Hero.ID, fmt.Sprintf("Encountered %s", enemy.Name)) + survived, en, xpGained, goldGained := SimulateOneFight(hm.Hero, tickNow, enemy) + if survived { + s.addLog(ctx, hm.Hero.ID, fmt.Sprintf("Defeated %s, gained %d XP and %d gold", en.Name, xpGained, goldGained)) + hm.ResumeWalking(tickNow) + } else { + s.addLog(ctx, hm.Hero.ID, fmt.Sprintf("Died fighting %s", en.Name)) + hm.Die() + } + } + + const maxOfflineMovementSteps = 200000 + step := 0 + for hm.LastMoveTick.Before(now) && step < maxOfflineMovementSteps { + step++ + next := hm.LastMoveTick.Add(MovementTickRate) + if next.After(now) { + next = now + } + if !next.After(hm.LastMoveTick) { + break + } + ProcessSingleHeroMovementTick(hero.ID, hm, s.graph, next, nil, encounter) + if hm.Hero.State == model.StateDead || hm.Hero.HP <= 0 { + break + } + } + if step >= maxOfflineMovementSteps && hm.LastMoveTick.Before(now) { + s.logger.Warn("offline movement step cap reached", "hero_id", hero.ID) + } + + hm.SyncToHero() + hero.RefreshDerivedCombatStats(now) + + if err := s.store.Save(ctx, hero); err != nil { + return fmt.Errorf("save hero after offline tick: %w", err) + } + + return nil +} + +// addLog is a fire-and-forget helper that writes an adventure log entry. +func (s *OfflineSimulator) addLog(ctx context.Context, heroID int64, message string) { + logCtx, cancel := context.WithTimeout(ctx, 2*time.Second) + defer cancel() + if err := s.logStore.Add(logCtx, heroID, message); err != nil { + s.logger.Warn("offline simulator: failed to write adventure log", + "hero_id", heroID, + "error", err, + ) + } +} + +// SimulateOneFight runs one combat encounter for an offline hero. +// It mutates the hero (HP, XP, gold, potions, level, equipment, state). +// If encounterEnemy is non-nil, that enemy is used (same as movement encounter roll); +// otherwise a new enemy is picked for the hero's level. +// Returns whether the hero survived, the enemy fought, XP gained, and gold gained. +func SimulateOneFight(hero *model.Hero, now time.Time, encounterEnemy *model.Enemy) (survived bool, enemy model.Enemy, xpGained int64, goldGained int64) { + if encounterEnemy != nil { + enemy = *encounterEnemy + } else { + enemy = PickEnemyForLevel(hero.Level) + } + + heroDmgPerHit := hero.EffectiveAttackAt(now) - enemy.Defense + if heroDmgPerHit < 1 { + heroDmgPerHit = 1 + } + enemyDmgPerHit := enemy.Attack - hero.EffectiveDefenseAt(now) + if enemyDmgPerHit < 1 { + enemyDmgPerHit = 1 + } + + hitsToKill := (enemy.MaxHP + heroDmgPerHit - 1) / heroDmgPerHit + dmgTaken := enemyDmgPerHit * hitsToKill + + hero.HP -= dmgTaken + + // Use potion if HP drops below 30% and hero has potions. + if hero.HP > 0 && hero.HP < hero.MaxHP*30/100 && hero.Potions > 0 { + healAmount := hero.MaxHP * 30 / 100 + hero.HP += healAmount + if hero.HP > hero.MaxHP { + hero.HP = hero.MaxHP + } + hero.Potions-- + } + + if hero.HP <= 0 { + hero.HP = 0 + hero.State = model.StateDead + hero.TotalDeaths++ + hero.KillsSinceDeath = 0 + return false, enemy, 0, 0 + } + + // Hero survived — apply rewards and stat tracking. + hero.TotalKills++ + hero.KillsSinceDeath++ + if enemy.IsElite { + hero.EliteKills++ + } + + xpGained = enemy.XPReward + hero.XP += xpGained + + // Loot generation. + luckMult := LuckMultiplier(hero, now) + drops := model.GenerateLoot(enemy.Type, luckMult) + for _, drop := range drops { + // Track legendary equipment drops for achievements. + if drop.Rarity == model.RarityLegendary && drop.ItemType != "gold" { + hero.LegendaryDrops++ + } + switch drop.ItemType { + case "gold": + hero.Gold += drop.GoldAmount + goldGained += drop.GoldAmount + case "potion": + hero.Potions++ + default: + // All equipment drops go through the unified gear system. + slot := model.EquipmentSlot(drop.ItemType) + family := model.PickGearFamily(slot) + if family != nil { + ilvl := model.RollIlvl(enemy.MinLevel, enemy.IsElite) + item := model.NewGearItem(family, ilvl, drop.Rarity) + AutoEquipGear(hero, item, now) + } else { + hero.Gold += model.AutoSellPrices[drop.Rarity] + goldGained += model.AutoSellPrices[drop.Rarity] + } + } + } + + // Also add the base gold reward from the enemy. + hero.Gold += enemy.GoldReward + goldGained += enemy.GoldReward + + // Level-up loop. + for hero.LevelUp() { + } + + hero.RefreshDerivedCombatStats(now) + return true, enemy, xpGained, goldGained +} + +// PickEnemyForLevel selects a random enemy appropriate for the hero's level +// and scales its stats. Exported for use by both the offline simulator and handler. +func PickEnemyForLevel(level int) model.Enemy { + candidates := make([]model.Enemy, 0, len(model.EnemyTemplates)) + for _, t := range model.EnemyTemplates { + if level >= t.MinLevel && level <= t.MaxLevel { + candidates = append(candidates, t) + } + } + if len(candidates) == 0 { + // Hero exceeds all level bands — pick enemies from the highest band. + highestMin := 0 + for _, t := range model.EnemyTemplates { + if t.MinLevel > highestMin { + highestMin = t.MinLevel + } + } + for _, t := range model.EnemyTemplates { + if t.MinLevel >= highestMin { + candidates = append(candidates, t) + } + } + } + picked := candidates[rand.Intn(len(candidates))] + return ScaleEnemyTemplate(picked, level) +} + +// ScaleEnemyTemplate applies band-based level scaling to stats and rewards. +// Exported for reuse across handler and offline simulation. +func ScaleEnemyTemplate(tmpl model.Enemy, heroLevel int) model.Enemy { + picked := tmpl + + bandLevel := heroLevel + if bandLevel < tmpl.MinLevel { + bandLevel = tmpl.MinLevel + } + if bandLevel > tmpl.MaxLevel { + bandLevel = tmpl.MaxLevel + } + bandDelta := float64(bandLevel - tmpl.MinLevel) + overcapDelta := float64(heroLevel - tmpl.MaxLevel) + if overcapDelta < 0 { + overcapDelta = 0 + } + + hpMul := 1.0 + bandDelta*0.05 + overcapDelta*0.025 + atkMul := 1.0 + bandDelta*0.035 + overcapDelta*0.018 + defMul := 1.0 + bandDelta*0.035 + overcapDelta*0.018 + + picked.MaxHP = max(1, int(float64(picked.MaxHP)*hpMul)) + picked.HP = picked.MaxHP + picked.Attack = max(1, int(float64(picked.Attack)*atkMul)) + picked.Defense = max(0, int(float64(picked.Defense)*defMul)) + + xpMul := 1.0 + bandDelta*0.05 + overcapDelta*0.03 + goldMul := 1.0 + bandDelta*0.05 + overcapDelta*0.025 + picked.XPReward = int64(math.Round(float64(picked.XPReward) * xpMul)) + picked.GoldReward = int64(math.Round(float64(picked.GoldReward) * goldMul)) + + return picked +} + +const autoEquipThreshold = 1.03 // 3% improvement required + +// AutoEquipGear equips the gear item if the slot is empty or the new item +// improves combat rating by >= 3%; otherwise auto-sells it. +func AutoEquipGear(hero *model.Hero, item *model.GearItem, now time.Time) { + if hero.Gear == nil { + hero.Gear = make(map[model.EquipmentSlot]*model.GearItem) + } + current := hero.Gear[item.Slot] + if current == nil { + hero.Gear[item.Slot] = item + return + } + oldRating := hero.CombatRatingAt(now) + hero.Gear[item.Slot] = item + if hero.CombatRatingAt(now) >= oldRating*autoEquipThreshold { + return + } + // Revert: new item is not an upgrade. + hero.Gear[item.Slot] = current + hero.Gold += model.AutoSellPrices[item.Rarity] +} diff --git a/backend/internal/game/offline_test.go b/backend/internal/game/offline_test.go new file mode 100644 index 0000000..5e87c1d --- /dev/null +++ b/backend/internal/game/offline_test.go @@ -0,0 +1,140 @@ +package game + +import ( + "testing" + "time" + + "github.com/denisovdennis/autohero/internal/model" +) + +func TestSimulateOneFight_HeroSurvives(t *testing.T) { + hero := &model.Hero{ + Level: 1, XP: 0, + MaxHP: 10000, HP: 10000, + Attack: 100, Defense: 60, Speed: 1.0, + Strength: 10, Constitution: 10, Agility: 10, Luck: 5, + State: model.StateWalking, + } + + now := time.Now() + survived, enemy, xpGained, goldGained := SimulateOneFight(hero, now, nil) + + if !survived { + t.Fatalf("overpowered hero should survive, enemy was %s", enemy.Name) + } + if xpGained <= 0 { + t.Fatal("expected positive XP gain") + } + if goldGained <= 0 { + t.Fatal("expected positive gold gain") + } + if enemy.Name == "" { + t.Fatal("expected enemy with a name") + } +} + +func TestSimulateOneFight_HeroDies(t *testing.T) { + hero := &model.Hero{ + Level: 1, XP: 0, + MaxHP: 1, HP: 1, + Attack: 1, Defense: 0, Speed: 1.0, + State: model.StateWalking, + } + + now := time.Now() + survived, _, _, _ := SimulateOneFight(hero, now, nil) + + if survived { + t.Fatal("1 HP hero should die to any enemy") + } + if hero.HP != 0 { + t.Fatalf("expected HP 0 after death, got %d", hero.HP) + } + if hero.State != model.StateDead { + t.Fatalf("expected state dead, got %s", hero.State) + } +} + +func TestSimulateOneFight_LevelUp(t *testing.T) { + // Seed XP just below L1->L2 threshold (180 in v3). + hero := &model.Hero{ + Level: 1, XP: 179, + MaxHP: 10000, HP: 10000, + Attack: 100, Defense: 60, Speed: 1.0, + Strength: 10, Constitution: 10, Agility: 10, Luck: 5, + State: model.StateWalking, + } + + now := time.Now() + survived, _, xpGained, _ := SimulateOneFight(hero, now, nil) + + if !survived { + t.Fatal("overpowered hero should survive") + } + if xpGained <= 0 { + t.Fatal("expected XP gain") + } + if hero.Level < 2 { + t.Fatalf("expected level 2+ after gaining %d XP from 179 base, got level %d", xpGained, hero.Level) + } +} + +func TestSimulateOneFight_PotionUsage(t *testing.T) { + // Create a hero that will take significant damage but survive. + hero := &model.Hero{ + Level: 1, XP: 0, + MaxHP: 100, HP: 100, + Attack: 50, Defense: 3, Speed: 1.0, + Potions: 5, + State: model.StateWalking, + } + + now := time.Now() + startPotions := hero.Potions + + // Run multiple fights — at least one should use a potion. + for i := 0; i < 20; i++ { + if hero.HP <= 0 { + break + } + hero.HP = 25 // force low HP to trigger potion usage + SimulateOneFight(hero, now, nil) + } + + if hero.Potions >= startPotions { + t.Log("no potions used after 20 fights with low HP — may be probabilistic, not a hard failure") + } +} + +func TestPickEnemyForLevel(t *testing.T) { + tests := []struct { + level int + }{ + {1}, {5}, {10}, {20}, {50}, + } + + for _, tt := range tests { + enemy := PickEnemyForLevel(tt.level) + if enemy.Name == "" { + t.Errorf("PickEnemyForLevel(%d) returned enemy with empty name", tt.level) + } + if enemy.MaxHP <= 0 { + t.Errorf("PickEnemyForLevel(%d) returned enemy with MaxHP=%d", tt.level, enemy.MaxHP) + } + if enemy.HP != enemy.MaxHP { + t.Errorf("PickEnemyForLevel(%d) returned enemy with HP=%d != MaxHP=%d", tt.level, enemy.HP, enemy.MaxHP) + } + } +} + +func TestScaleEnemyTemplate(t *testing.T) { + tmpl := model.EnemyTemplates[model.EnemyWolf] + scaled := ScaleEnemyTemplate(tmpl, 5) + + if scaled.MaxHP <= tmpl.MaxHP { + t.Errorf("scaled MaxHP %d should exceed base %d at level 5", scaled.MaxHP, tmpl.MaxHP) + } + if scaled.HP != scaled.MaxHP { + t.Errorf("scaled HP %d should equal MaxHP %d", scaled.HP, scaled.MaxHP) + } +} diff --git a/backend/internal/game/road_graph.go b/backend/internal/game/road_graph.go new file mode 100644 index 0000000..3772912 --- /dev/null +++ b/backend/internal/game/road_graph.go @@ -0,0 +1,255 @@ +package game + +import ( + "context" + "fmt" + "math" + "math/rand" + "sort" + + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/denisovdennis/autohero/internal/model" +) + +// Point is a 2D coordinate on the world map. +type Point struct { + X, Y float64 +} + +// Road connects two towns with a sequence of waypoints. +type Road struct { + ID int64 + FromTownID int64 + ToTownID int64 + Waypoints []Point // ordered: first = from-town center, last = to-town center + Distance float64 +} + +// TownNPC is a quest/shop NPC placed in a town (from npcs table). +type TownNPC struct { + ID int64 + Name string + Type string +} + +// RoadGraph is an immutable in-memory graph of all roads and towns, +// loaded once at startup. +type RoadGraph struct { + Roads map[int64]*Road // road ID -> road + TownRoads map[int64][]*Road // town ID -> outgoing roads + Towns map[int64]*model.Town // town ID -> town + TownOrder []int64 // ordered town IDs for sequential traversal + TownNPCs map[int64][]TownNPC // town ID -> NPCs (stable order) + NPCByID map[int64]TownNPC // NPC id -> row +} + +// LoadRoadGraph reads roads and towns from the database, generates waypoints +// deterministically, and returns an immutable RoadGraph. +func LoadRoadGraph(ctx context.Context, pool *pgxpool.Pool) (*RoadGraph, error) { + g := &RoadGraph{ + Roads: make(map[int64]*Road), + TownRoads: make(map[int64][]*Road), + Towns: make(map[int64]*model.Town), + TownNPCs: make(map[int64][]TownNPC), + NPCByID: make(map[int64]TownNPC), + } + + // Load towns. + rows, err := pool.Query(ctx, `SELECT id, name, biome, world_x, world_y, radius, level_min, level_max FROM towns ORDER BY level_min ASC`) + if err != nil { + return nil, fmt.Errorf("load towns: %w", err) + } + defer rows.Close() + + for rows.Next() { + var t model.Town + if err := rows.Scan(&t.ID, &t.Name, &t.Biome, &t.WorldX, &t.WorldY, &t.Radius, &t.LevelMin, &t.LevelMax); err != nil { + return nil, fmt.Errorf("scan town: %w", err) + } + g.Towns[t.ID] = &t + g.TownOrder = append(g.TownOrder, t.ID) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("iterate towns: %w", err) + } + + npcRows, err := pool.Query(ctx, `SELECT id, town_id, name, type FROM npcs ORDER BY town_id, id`) + if err != nil { + return nil, fmt.Errorf("load npcs: %w", err) + } + defer npcRows.Close() + for npcRows.Next() { + var n TownNPC + var townID int64 + if err := npcRows.Scan(&n.ID, &townID, &n.Name, &n.Type); err != nil { + return nil, fmt.Errorf("scan npc: %w", err) + } + g.NPCByID[n.ID] = n + g.TownNPCs[townID] = append(g.TownNPCs[townID], n) + } + if err := npcRows.Err(); err != nil { + return nil, fmt.Errorf("iterate npcs: %w", err) + } + + // Load roads. + roadRows, err := pool.Query(ctx, `SELECT id, from_town_id, to_town_id, distance FROM roads`) + if err != nil { + return nil, fmt.Errorf("load roads: %w", err) + } + defer roadRows.Close() + + for roadRows.Next() { + var r Road + if err := roadRows.Scan(&r.ID, &r.FromTownID, &r.ToTownID, &r.Distance); err != nil { + return nil, fmt.Errorf("scan road: %w", err) + } + + fromTown, ok := g.Towns[r.FromTownID] + if !ok { + continue + } + toTown, ok := g.Towns[r.ToTownID] + if !ok { + continue + } + + r.Waypoints = generateWaypoints(fromTown, toTown, r.ID) + r.Distance = totalWaypointDistance(r.Waypoints) + g.Roads[r.ID] = &r + g.TownRoads[r.FromTownID] = append(g.TownRoads[r.FromTownID], &r) + } + if err := roadRows.Err(); err != nil { + return nil, fmt.Errorf("iterate roads: %w", err) + } + + return g, nil +} + +// TownNPCIDs returns NPC ids for a town in stable DB order (for visit queues). +func (g *RoadGraph) TownNPCIDs(townID int64) []int64 { + list := g.TownNPCs[townID] + ids := make([]int64, len(list)) + for i := range list { + ids[i] = list[i].ID + } + return ids +} + +// FindRoad returns the road from fromTownID to toTownID, if it exists. +func (g *RoadGraph) FindRoad(fromTownID, toTownID int64) *Road { + for _, r := range g.TownRoads[fromTownID] { + if r.ToTownID == toTownID { + return r + } + } + return nil +} + +// NextTownInChain returns the next town along the ring (TownOrder order, wraps after last). +func (g *RoadGraph) NextTownInChain(currentTownID int64) int64 { + n := len(g.TownOrder) + if n == 0 { + return currentTownID + } + idx := -1 + for i, id := range g.TownOrder { + if id == currentTownID { + idx = i + break + } + } + if idx < 0 { + return g.TownOrder[0] + } + return g.TownOrder[(idx+1)%n] +} + +// NearestTown returns the town ID closest to the given world position. +func (g *RoadGraph) NearestTown(x, y float64) int64 { + bestDist := math.MaxFloat64 + var bestID int64 + for _, t := range g.Towns { + d := math.Hypot(t.WorldX-x, t.WorldY-y) + if d < bestDist { + bestDist = d + bestID = t.ID + } + } + return bestID +} + +// TownOrderIndex returns the index of a town in the ordered chain, or -1 if not found. +func (g *RoadGraph) TownOrderIndex(townID int64) int { + for i, id := range g.TownOrder { + if id == townID { + return i + } + } + return -1 +} + +const ( + waypointSpacing = 20.0 // tiles between jitter points + waypointJitter = 2.0 // +/- tile jitter +) + +// generateWaypoints creates a deterministic sequence of points from one town center +// to another, with jitter applied every waypointSpacing tiles. +func generateWaypoints(from, to *model.Town, roadID int64) []Point { + dx := to.WorldX - from.WorldX + dy := to.WorldY - from.WorldY + totalDist := math.Hypot(dx, dy) + + if totalDist < 1 { + return []Point{{from.WorldX, from.WorldY}, {to.WorldX, to.WorldY}} + } + + numSegments := int(totalDist / waypointSpacing) + if numSegments < 1 { + numSegments = 1 + } + + // Deterministic RNG per road. + rng := rand.New(rand.NewSource(roadID * 7919)) + + points := make([]Point, 0, numSegments+2) + points = append(points, Point{from.WorldX, from.WorldY}) + + for i := 1; i < numSegments; i++ { + t := float64(i) / float64(numSegments) + px := from.WorldX + dx*t + (rng.Float64()*2-1)*waypointJitter + py := from.WorldY + dy*t + (rng.Float64()*2-1)*waypointJitter + points = append(points, Point{px, py}) + } + + points = append(points, Point{to.WorldX, to.WorldY}) + return points +} + +// totalWaypointDistance computes the sum of segment lengths along a waypoint path. +func totalWaypointDistance(pts []Point) float64 { + var total float64 + for i := 1; i < len(pts); i++ { + total += math.Hypot(pts[i].X-pts[i-1].X, pts[i].Y-pts[i-1].Y) + } + return total +} + +// SortedTownsByDistance returns town IDs sorted by Euclidean distance from (x,y). +func (g *RoadGraph) SortedTownsByDistance(x, y float64) []int64 { + type td struct { + id int64 + dist float64 + } + tds := make([]td, 0, len(g.Towns)) + for _, t := range g.Towns { + tds = append(tds, td{id: t.ID, dist: math.Hypot(t.WorldX-x, t.WorldY-y)}) + } + sort.Slice(tds, func(i, j int) bool { return tds[i].dist < tds[j].dist }) + ids := make([]int64, len(tds)) + for i, v := range tds { + ids[i] = v.id + } + return ids +} diff --git a/backend/internal/handler/achievement.go b/backend/internal/handler/achievement.go new file mode 100644 index 0000000..2ab03a2 --- /dev/null +++ b/backend/internal/handler/achievement.go @@ -0,0 +1,93 @@ +package handler + +import ( + "log/slog" + "net/http" + + "github.com/denisovdennis/autohero/internal/model" + "github.com/denisovdennis/autohero/internal/storage" +) + +// AchievementHandler serves achievement API endpoints. +type AchievementHandler struct { + achievementStore *storage.AchievementStore + heroStore *storage.HeroStore + logger *slog.Logger +} + +// NewAchievementHandler creates a new AchievementHandler. +func NewAchievementHandler(achievementStore *storage.AchievementStore, heroStore *storage.HeroStore, logger *slog.Logger) *AchievementHandler { + return &AchievementHandler{ + achievementStore: achievementStore, + heroStore: heroStore, + logger: logger, + } +} + +// GetHeroAchievements returns all achievements with unlocked status for the hero. +// GET /api/v1/hero/achievements +func (h *AchievementHandler) GetHeroAchievements(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + hero, err := h.heroStore.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for achievements", "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + // Load all achievement definitions. + allAchievements, err := h.achievementStore.ListAchievements(r.Context()) + if err != nil { + h.logger.Error("failed to list achievements", "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load achievements", + }) + return + } + + // Load hero's unlocked achievements. + heroAchievements, err := h.achievementStore.GetHeroAchievements(r.Context(), hero.ID) + if err != nil { + h.logger.Error("failed to get hero achievements", "hero_id", hero.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero achievements", + }) + return + } + + // Build lookup of unlocked achievement IDs. + unlockedMap := make(map[string]*model.HeroAchievement, len(heroAchievements)) + for i := range heroAchievements { + unlockedMap[heroAchievements[i].AchievementID] = &heroAchievements[i] + } + + // Build response combining definitions with unlock status. + views := make([]model.AchievementView, 0, len(allAchievements)) + for _, a := range allAchievements { + view := model.AchievementView{ + Achievement: a, + } + if ha, ok := unlockedMap[a.ID]; ok { + view.Unlocked = true + view.UnlockedAt = &ha.UnlockedAt + } + views = append(views, view) + } + + writeJSON(w, http.StatusOK, views) +} diff --git a/backend/internal/handler/admin.go b/backend/internal/handler/admin.go new file mode 100644 index 0000000..c3b8c67 --- /dev/null +++ b/backend/internal/handler/admin.go @@ -0,0 +1,688 @@ +package handler + +import ( + "encoding/json" + "log/slog" + "net/http" + "runtime" + "strconv" + "time" + + "github.com/go-chi/chi/v5" + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/denisovdennis/autohero/internal/game" + "github.com/denisovdennis/autohero/internal/model" + "github.com/denisovdennis/autohero/internal/storage" +) + +var serverStartedAt = time.Now() + +// AdminHandler provides administrative endpoints for hero management, +// engine inspection, and server diagnostics. +type AdminHandler struct { + store *storage.HeroStore + engine *game.Engine + hub *Hub + pool *pgxpool.Pool + logger *slog.Logger +} + +// NewAdminHandler creates a new AdminHandler with all required dependencies. +func NewAdminHandler(store *storage.HeroStore, engine *game.Engine, hub *Hub, pool *pgxpool.Pool, logger *slog.Logger) *AdminHandler { + return &AdminHandler{ + store: store, + engine: engine, + hub: hub, + pool: pool, + logger: logger, + } +} + +// ── Hero Management ───────────────────────────────────────────────── + +type heroSummary struct { + ID int64 `json:"id"` + TelegramID int64 `json:"telegramId"` + Name string `json:"name"` + Level int `json:"level"` + Gold int64 `json:"gold"` + HP int `json:"hp"` + MaxHP int `json:"maxHp"` + State model.GameState `json:"state"` + UpdatedAt time.Time `json:"updatedAt"` +} + +// ListHeroes returns a paginated list of all heroes. +// GET /admin/heroes?limit=20&offset=0 +func (h *AdminHandler) ListHeroes(w http.ResponseWriter, r *http.Request) { + limit, _ := strconv.Atoi(r.URL.Query().Get("limit")) + offset, _ := strconv.Atoi(r.URL.Query().Get("offset")) + if limit <= 0 { + limit = 20 + } + + heroes, err := h.store.ListHeroes(r.Context(), limit, offset) + if err != nil { + h.logger.Error("admin: list heroes failed", "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to list heroes", + }) + return + } + + summaries := make([]heroSummary, len(heroes)) + for i, hero := range heroes { + summaries[i] = heroSummary{ + ID: hero.ID, + TelegramID: hero.TelegramID, + Name: hero.Name, + Level: hero.Level, + Gold: hero.Gold, + HP: hero.HP, + MaxHP: hero.MaxHP, + State: hero.State, + UpdatedAt: hero.UpdatedAt, + } + } + + writeJSON(w, http.StatusOK, map[string]any{ + "heroes": summaries, + "limit": limit, + "offset": offset, + }) +} + +// GetHero returns full hero detail by database ID. +// GET /admin/heroes/{heroId} +func (h *AdminHandler) GetHero(w http.ResponseWriter, r *http.Request) { + heroID, err := parseHeroID(r) + if err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid heroId: " + err.Error(), + }) + return + } + + hero, err := h.store.GetByID(r.Context(), heroID) + if err != nil { + h.logger.Error("admin: get hero failed", "hero_id", heroID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + hero.RefreshDerivedCombatStats(time.Now()) + writeJSON(w, http.StatusOK, h.engine.GetMovements(heroID).Hero) +} + +type setLevelRequest struct { + Level int `json:"level"` +} + +// SetHeroLevel sets the hero to a specific level, recalculating stats. +// POST /admin/heroes/{heroId}/set-level +func (h *AdminHandler) SetHeroLevel(w http.ResponseWriter, r *http.Request) { + heroID, err := parseHeroID(r) + if err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid heroId: " + err.Error(), + }) + return + } + + var req setLevelRequest + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid request body: " + err.Error(), + }) + return + } + if req.Level < 1 { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "level must be >= 1", + }) + return + } + const maxAdminLevel = 200 + if req.Level > maxAdminLevel { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "level must be <= 200", + }) + return + } + + hero, err := h.store.GetByID(r.Context(), heroID) + if err != nil { + h.logger.Error("admin: get hero for set-level", "hero_id", heroID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + if h.isHeroInCombat(w, heroID) { + return + } + + savedGold := hero.Gold + resetHeroToLevel1(hero) + hero.Gold = savedGold + + for hero.Level < req.Level { + hero.XP = model.XPToNextLevel(hero.Level) + if !hero.LevelUp() { + break + } + } + + if err := h.store.Save(r.Context(), hero); err != nil { + h.logger.Error("admin: save hero after set-level", "hero_id", heroID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to save hero", + }) + return + } + + h.logger.Info("admin: hero level set", "hero_id", heroID, "level", hero.Level) + hero.RefreshDerivedCombatStats(time.Now()) + writeJSON(w, http.StatusOK, hero) +} + +type setGoldRequest struct { + Gold int64 `json:"gold"` +} + +// SetHeroGold sets the hero's gold to an exact value. +// POST /admin/heroes/{heroId}/set-gold +func (h *AdminHandler) SetHeroGold(w http.ResponseWriter, r *http.Request) { + heroID, err := parseHeroID(r) + if err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid heroId: " + err.Error(), + }) + return + } + + var req setGoldRequest + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid request body: " + err.Error(), + }) + return + } + if req.Gold < 0 { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "gold must be >= 0", + }) + return + } + + hero, err := h.store.GetByID(r.Context(), heroID) + if err != nil { + h.logger.Error("admin: get hero for set-gold", "hero_id", heroID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + if h.isHeroInCombat(w, heroID) { + return + } + + hero.Gold = req.Gold + + if err := h.store.Save(r.Context(), hero); err != nil { + h.logger.Error("admin: save hero after set-gold", "hero_id", heroID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to save hero", + }) + return + } + + h.logger.Info("admin: hero gold set", "hero_id", heroID, "gold", hero.Gold) + hero.RefreshDerivedCombatStats(time.Now()) + writeJSON(w, http.StatusOK, hero) +} + +type addPotionsRequest struct { + Potions int `json:"potions"` +} + +// SetHeroGold sets the hero's gold to an exact value. +// POST /admin/heroes/{heroId}/add-potions +func (h *AdminHandler) AddPotions(w http.ResponseWriter, r *http.Request) { + heroID, err := parseHeroID(r) + if err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid heroId: " + err.Error(), + }) + return + } + + var req addPotionsRequest + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid request body: " + err.Error(), + }) + return + } + if req.Potions < 0 { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "potions must be >= 1", + }) + return + } + + + var hero = h.engine.GetMovements(heroID).Hero + + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + hero.Potions += req.Potions + + if err := h.store.Save(r.Context(), hero); err != nil { + h.logger.Error("admin: save hero after set-gold", "hero_id", heroID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to save hero", + }) + return + } + + h.logger.Info("admin: hero added potions", "hero_id", heroID, "potions", hero.Potions) + hero.RefreshDerivedCombatStats(time.Now()) + h.engine.SyncHeroState(hero) + writeJSON(w, http.StatusOK, hero) +} + +type setHPRequest struct { + HP int `json:"hp"` +} + +// SetHeroHP sets the hero's current HP, clamped to [1, maxHp]. +// POST /admin/heroes/{heroId}/set-hp +func (h *AdminHandler) SetHeroHP(w http.ResponseWriter, r *http.Request) { + heroID, err := parseHeroID(r) + if err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid heroId: " + err.Error(), + }) + return + } + + var req setHPRequest + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid request body: " + err.Error(), + }) + return + } + + hero, err := h.store.GetByID(r.Context(), heroID) + if err != nil { + h.logger.Error("admin: get hero for set-hp", "hero_id", heroID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + if h.isHeroInCombat(w, heroID) { + return + } + + hp := req.HP + if hp < 1 { + hp = 1 + } + if hp > hero.MaxHP { + hp = hero.MaxHP + } + hero.HP = hp + + if hero.State == model.StateDead && hero.HP > 0 { + hero.State = model.StateWalking + } + + if err := h.store.Save(r.Context(), hero); err != nil { + h.logger.Error("admin: save hero after set-hp", "hero_id", heroID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to save hero", + }) + return + } + + h.logger.Info("admin: hero HP set", "hero_id", heroID, "hp", hero.HP) + hero.RefreshDerivedCombatStats(time.Now()) + writeJSON(w, http.StatusOK, hero) +} + +// ReviveHero force-revives a hero to full HP regardless of current state. +// POST /admin/heroes/{heroId}/revive +func (h *AdminHandler) ReviveHero(w http.ResponseWriter, r *http.Request) { + heroID, err := parseHeroID(r) + if err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid heroId: " + err.Error(), + }) + return + } + + hero, err := h.store.GetByID(r.Context(), heroID) + if err != nil { + h.logger.Error("admin: get hero for revive", "hero_id", heroID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + hero.HP = hero.MaxHP + hero.State = model.StateWalking + hero.Buffs = nil + hero.Debuffs = nil + + if err := h.store.Save(r.Context(), hero); err != nil { + h.logger.Error("admin: save hero after revive", "hero_id", heroID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to save hero", + }) + return + } + + h.engine.ApplyAdminHeroRevive(hero) + + h.logger.Info("admin: hero revived", "hero_id", heroID, "hp", hero.HP) + hero.RefreshDerivedCombatStats(time.Now()) + writeJSON(w, http.StatusOK, hero) +} + +// ResetHero resets a hero to fresh level 1 defaults. +// POST /admin/heroes/{heroId}/reset +func (h *AdminHandler) ResetHero(w http.ResponseWriter, r *http.Request) { + heroID, err := parseHeroID(r) + if err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid heroId: " + err.Error(), + }) + return + } + + hero, err := h.store.GetByID(r.Context(), heroID) + if err != nil { + h.logger.Error("admin: get hero for reset", "hero_id", heroID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + if h.isHeroInCombat(w, heroID) { + return + } + + resetHeroToLevel1(hero) + + if err := h.store.Save(r.Context(), hero); err != nil { + h.logger.Error("admin: save hero after reset", "hero_id", heroID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to save hero", + }) + return + } + + h.logger.Info("admin: hero reset", "hero_id", heroID) + hero.RefreshDerivedCombatStats(time.Now()) + writeJSON(w, http.StatusOK, hero) +} + +type resetBuffChargesRequest struct { + BuffType string `json:"buffType"` // optional — if empty, reset ALL +} + +// ResetBuffCharges resets per-buff free charges to their maximums. +// If buffType is provided, only that buff is reset; otherwise all are reset. +// POST /admin/heroes/{heroId}/reset-buff-charges +func (h *AdminHandler) ResetBuffCharges(w http.ResponseWriter, r *http.Request) { + heroID, err := parseHeroID(r) + if err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid heroId: " + err.Error(), + }) + return + } + + var req resetBuffChargesRequest + if r.Body != nil && r.ContentLength > 0 { + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid request body: " + err.Error(), + }) + return + } + } + + hero, err := h.store.GetByID(r.Context(), heroID) + if err != nil { + h.logger.Error("admin: get hero for reset-buff-charges", "hero_id", heroID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + now := time.Now() + hero.EnsureBuffChargesPopulated(now) + + if req.BuffType != "" { + bt, ok := model.ValidBuffType(req.BuffType) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid buffType: " + req.BuffType, + }) + return + } + hero.ResetBuffCharges(&bt, now) + h.logger.Info("admin: buff charges reset (single)", "hero_id", heroID, "buff_type", bt) + } else { + hero.ResetBuffCharges(nil, now) + h.logger.Info("admin: buff charges reset (all)", "hero_id", heroID) + } + + if err := h.store.Save(r.Context(), hero); err != nil { + h.logger.Error("admin: save hero after reset-buff-charges", "hero_id", heroID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to save hero", + }) + return + } + + hero.RefreshDerivedCombatStats(now) + writeJSON(w, http.StatusOK, hero) +} + +// DeleteHero permanently removes a hero from the database. +// DELETE /admin/heroes/{heroId} +func (h *AdminHandler) DeleteHero(w http.ResponseWriter, r *http.Request) { + heroID, err := parseHeroID(r) + if err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid heroId: " + err.Error(), + }) + return + } + + hero, err := h.store.GetByID(r.Context(), heroID) + if err != nil { + h.logger.Error("admin: get hero for delete", "hero_id", heroID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + h.engine.StopCombat(heroID) + + if err := h.store.DeleteByID(r.Context(), heroID); err != nil { + h.logger.Error("admin: delete hero failed", "hero_id", heroID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to delete hero", + }) + return + } + + h.logger.Info("admin: hero deleted", "hero_id", heroID) + writeJSON(w, http.StatusOK, map[string]string{ + "status": "deleted", + }) +} + +// ── Game Engine ───────────────────────────────────────────────────── + +// EngineStatus returns operational status of the game engine. +// GET /admin/engine/status +func (h *AdminHandler) EngineStatus(w http.ResponseWriter, r *http.Request) { + status := h.engine.Status() + writeJSON(w, http.StatusOK, map[string]any{ + "running": status.Running, + "tickRateMs": status.TickRate.Milliseconds(), + "activeCombats": status.ActiveCombats, + "uptimeMs": status.UptimeMs, + }) +} + +// ActiveCombats returns all active combat sessions. +// GET /admin/engine/combats +func (h *AdminHandler) ActiveCombats(w http.ResponseWriter, r *http.Request) { + combats := h.engine.ListActiveCombats() + writeJSON(w, http.StatusOK, map[string]any{ + "combats": combats, + "count": len(combats), + }) +} + +// ── WebSocket Hub ─────────────────────────────────────────────────── + +// WSConnections returns active WebSocket connection info. +// GET /admin/ws/connections +func (h *AdminHandler) WSConnections(w http.ResponseWriter, r *http.Request) { + writeJSON(w, http.StatusOK, map[string]any{ + "connectionCount": h.hub.ConnectionCount(), + "heroIds": h.hub.ConnectedHeroIDs(), + }) +} + +// ── Server Info ───────────────────────────────────────────────────── + +// ServerInfo returns general server diagnostics. +// GET /admin/info +func (h *AdminHandler) ServerInfo(w http.ResponseWriter, r *http.Request) { + poolStat := h.pool.Stat() + writeJSON(w, http.StatusOK, map[string]any{ + "version": "0.1.0-dev", + "goVersion": runtime.Version(), + "uptimeMs": time.Since(serverStartedAt).Milliseconds(), + "dbPool": map[string]any{ + "totalConns": poolStat.TotalConns(), + "acquiredConns": poolStat.AcquiredConns(), + "idleConns": poolStat.IdleConns(), + "maxConns": poolStat.MaxConns(), + }, + }) +} + +// ── Helpers ───────────────────────────────────────────────────────── + +func parseHeroID(r *http.Request) (int64, error) { + return strconv.ParseInt(chi.URLParam(r, "heroId"), 10, 64) +} + +// isHeroInCombat checks if the hero is in active engine combat and writes +// a 409 Conflict response if so. Returns true when the caller should abort. +func (h *AdminHandler) isHeroInCombat(w http.ResponseWriter, heroID int64) bool { + if _, active := h.engine.GetCombat(heroID); active { + writeJSON(w, http.StatusConflict, map[string]string{ + "error": "hero is in active combat — stop combat first", + }) + return true + } + return false +} + +// resetHeroToLevel1 restores a hero to fresh level 1 defaults, +// preserving identity fields (ID, TelegramID, Name, CreatedAt). +func resetHeroToLevel1(hero *model.Hero) { + hero.Level = 1 + hero.XP = 0 + hero.Gold = 0 + hero.HP = 100 + hero.MaxHP = 100 + hero.Attack = 10 + hero.Defense = 5 + hero.Speed = 1.0 + hero.Strength = 1 + hero.Constitution = 1 + hero.Agility = 1 + hero.Luck = 1 + hero.State = model.StateWalking + hero.Buffs = nil + hero.Debuffs = nil + hero.BuffCharges = nil + hero.BuffFreeChargesRemaining = model.FreeBuffActivationsPerPeriod + hero.BuffQuotaPeriodEnd = nil +} diff --git a/backend/internal/handler/auth.go b/backend/internal/handler/auth.go new file mode 100644 index 0000000..46ef05b --- /dev/null +++ b/backend/internal/handler/auth.go @@ -0,0 +1,204 @@ +package handler + +import ( + "context" + "crypto/hmac" + "crypto/sha256" + "encoding/hex" + "fmt" + "log/slog" + "net/http" + "net/url" + "sort" + "strconv" + "strings" + + "github.com/denisovdennis/autohero/internal/storage" +) + +// contextKey is an unexported type for context keys in this package. +type contextKey string + +const telegramIDKey contextKey = "telegram_id" + +// TelegramIDFromContext extracts the Telegram user ID from the request context. +func TelegramIDFromContext(ctx context.Context) (int64, bool) { + id, ok := ctx.Value(telegramIDKey).(int64) + return id, ok +} + +// AuthHandler handles Telegram authentication. +type AuthHandler struct { + botToken string + store *storage.HeroStore + logger *slog.Logger +} + +// NewAuthHandler creates a new auth handler. +func NewAuthHandler(botToken string, store *storage.HeroStore, logger *slog.Logger) *AuthHandler { + return &AuthHandler{ + botToken: botToken, + store: store, + logger: logger, + } +} + +// TelegramAuth validates Telegram initData, creates hero if first time, returns hero ID. +// POST /api/v1/auth/telegram +func (h *AuthHandler) TelegramAuth(w http.ResponseWriter, r *http.Request) { + initData := r.Header.Get("X-Telegram-Init-Data") + if initData == "" { + initData = r.URL.Query().Get("initData") + } + if initData == "" { + writeJSON(w, http.StatusUnauthorized, map[string]string{ + "error": "missing initData", + }) + return + } + + telegramID, err := validateInitData(initData, h.botToken) + if err != nil { + h.logger.Warn("telegram auth failed", "error", err) + writeJSON(w, http.StatusUnauthorized, map[string]string{ + "error": "invalid initData: " + err.Error(), + }) + return + } + + hero, err := h.store.GetOrCreate(r.Context(), telegramID, "Hero") + if err != nil { + h.logger.Error("failed to get or create hero", "telegram_id", telegramID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + + h.logger.Info("telegram auth success", "telegram_id", telegramID, "hero_id", hero.ID) + + writeJSON(w, http.StatusOK, map[string]any{ + "heroId": hero.ID, + "hero": hero, + }) +} + +// TelegramAuthMiddleware validates the Telegram initData on every request +// and injects the telegram_id into the request context. +func TelegramAuthMiddleware(botToken string) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + initData := r.Header.Get("X-Telegram-Init-Data") + if initData == "" { + initData = r.URL.Query().Get("initData") + } + if initData == "" { + writeJSON(w, http.StatusUnauthorized, map[string]string{ + "error": "missing initData", + }) + return + } + + telegramID, err := validateInitData(initData, botToken) + if err != nil { + writeJSON(w, http.StatusUnauthorized, map[string]string{ + "error": "invalid initData", + }) + return + } + + ctx := context.WithValue(r.Context(), telegramIDKey, telegramID) + next.ServeHTTP(w, r.WithContext(ctx)) + }) + } +} + +// validateInitData parses and validates Telegram Web App initData. +// Returns the telegram user ID on success. +func validateInitData(initData string, botToken string) (int64, error) { + if botToken == "" { + // In dev mode without a bot token, try to parse the user ID anyway. + return parseUserIDFromInitData(initData) + } + + values, err := url.ParseQuery(initData) + if err != nil { + return 0, fmt.Errorf("parse initData: %w", err) + } + + hash := values.Get("hash") + if hash == "" { + return 0, fmt.Errorf("missing hash in initData") + } + + // Build the data-check-string: sort all key=value pairs except "hash", join with \n. + var pairs []string + for k, v := range values { + if k == "hash" { + continue + } + pairs = append(pairs, k+"="+v[0]) + } + sort.Strings(pairs) + dataCheckString := strings.Join(pairs, "\n") + + // Derive the secret key: HMAC-SHA256 of bot token with key "WebAppData". + secretKeyMac := hmac.New(sha256.New, []byte("WebAppData")) + secretKeyMac.Write([]byte(botToken)) + secretKey := secretKeyMac.Sum(nil) + + // Compute HMAC-SHA256 of the data-check-string with the secret key. + mac := hmac.New(sha256.New, secretKey) + mac.Write([]byte(dataCheckString)) + computedHash := hex.EncodeToString(mac.Sum(nil)) + + if !hmac.Equal([]byte(computedHash), []byte(hash)) { + return 0, fmt.Errorf("hash mismatch") + } + + return parseUserIDFromInitData(initData) +} + +// parseUserIDFromInitData extracts the user ID from the initData query string. +func parseUserIDFromInitData(initData string) (int64, error) { + values, err := url.ParseQuery(initData) + if err != nil { + return 0, fmt.Errorf("parse initData: %w", err) + } + + // The user field is a JSON string, but we just need the id. + // Format: user={"id":123456789,"first_name":"Name",...} + userStr := values.Get("user") + if userStr == "" { + // Try query_id based format or direct id parameter. + idStr := values.Get("id") + if idStr == "" { + return 0, fmt.Errorf("no user data in initData") + } + return strconv.ParseInt(idStr, 10, 64) + } + + // Simple extraction of "id" from JSON without full unmarshal. + // Find "id": followed by a number. + idx := strings.Index(userStr, `"id":`) + if idx == -1 { + return 0, fmt.Errorf("no id field in user data") + } + rest := userStr[idx+5:] + // Trim any whitespace. + rest = strings.TrimSpace(rest) + // Read digits until non-digit. + var numStr string + for _, c := range rest { + if c >= '0' && c <= '9' { + numStr += string(c) + } else { + break + } + } + if numStr == "" { + return 0, fmt.Errorf("invalid id in user data") + } + + return strconv.ParseInt(numStr, 10, 64) +} diff --git a/backend/internal/handler/basic_auth.go b/backend/internal/handler/basic_auth.go new file mode 100644 index 0000000..2c79489 --- /dev/null +++ b/backend/internal/handler/basic_auth.go @@ -0,0 +1,46 @@ +package handler + +import ( + "crypto/subtle" + "fmt" + "net/http" +) + +// BasicAuthConfig configures HTTP Basic authentication middleware. +type BasicAuthConfig struct { + Username string + Password string + Realm string +} + +// BasicAuthMiddleware protects routes with HTTP Basic authentication. +// If credentials are not configured, all requests are denied. +func BasicAuthMiddleware(cfg BasicAuthConfig) func(http.Handler) http.Handler { + realm := cfg.Realm + if realm == "" { + realm = "Restricted" + } + + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + username, password, ok := r.BasicAuth() + if !ok || !basicAuthCredentialsMatch(username, password, cfg.Username, cfg.Password) { + w.Header().Set("WWW-Authenticate", fmt.Sprintf(`Basic realm="%s", charset="UTF-8"`, realm)) + writeJSON(w, http.StatusUnauthorized, map[string]string{ + "error": "unauthorized", + }) + return + } + next.ServeHTTP(w, r) + }) + } +} + +func basicAuthCredentialsMatch(gotUser, gotPass, wantUser, wantPass string) bool { + if wantUser == "" || wantPass == "" { + return false + } + userOK := subtle.ConstantTimeCompare([]byte(gotUser), []byte(wantUser)) == 1 + passOK := subtle.ConstantTimeCompare([]byte(gotPass), []byte(wantPass)) == 1 + return userOK && passOK +} diff --git a/backend/internal/handler/basic_auth_test.go b/backend/internal/handler/basic_auth_test.go new file mode 100644 index 0000000..fab8ab5 --- /dev/null +++ b/backend/internal/handler/basic_auth_test.go @@ -0,0 +1,88 @@ +package handler + +import ( + "net/http" + "net/http/httptest" + "testing" +) + +func TestBasicAuthMiddleware(t *testing.T) { + cfg := BasicAuthConfig{ + Username: "admin", + Password: "secret", + Realm: "AutoHero Admin", + } + protected := BasicAuthMiddleware(cfg)(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + })) + + tests := []struct { + name string + username string + password string + setAuth bool + wantStatus int + wantHeader bool + }{ + { + name: "missing credentials", + setAuth: false, + wantStatus: http.StatusUnauthorized, + wantHeader: true, + }, + { + name: "invalid credentials", + username: "admin", + password: "wrong", + setAuth: true, + wantStatus: http.StatusUnauthorized, + wantHeader: true, + }, + { + name: "valid credentials", + username: "admin", + password: "secret", + setAuth: true, + wantStatus: http.StatusOK, + wantHeader: false, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + req := httptest.NewRequest(http.MethodGet, "/admin/info", nil) + if tc.setAuth { + req.SetBasicAuth(tc.username, tc.password) + } + + rr := httptest.NewRecorder() + protected.ServeHTTP(rr, req) + + if rr.Code != tc.wantStatus { + t.Fatalf("status = %d, want %d", rr.Code, tc.wantStatus) + } + gotHeader := rr.Header().Get("WWW-Authenticate") != "" + if gotHeader != tc.wantHeader { + t.Fatalf("WWW-Authenticate present = %v, want %v", gotHeader, tc.wantHeader) + } + }) + } +} + +func TestBasicAuthMiddleware_DenyWhenNotConfigured(t *testing.T) { + protected := BasicAuthMiddleware(BasicAuthConfig{})(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + })) + + req := httptest.NewRequest(http.MethodGet, "/admin/info", nil) + req.SetBasicAuth("admin", "secret") + rr := httptest.NewRecorder() + protected.ServeHTTP(rr, req) + + if rr.Code != http.StatusUnauthorized { + t.Fatalf("status = %d, want %d", rr.Code, http.StatusUnauthorized) + } + if rr.Header().Get("WWW-Authenticate") == "" { + t.Fatal("expected WWW-Authenticate header") + } +} diff --git a/backend/internal/handler/buff_quota.go b/backend/internal/handler/buff_quota.go new file mode 100644 index 0000000..56da96c --- /dev/null +++ b/backend/internal/handler/buff_quota.go @@ -0,0 +1,25 @@ +package handler + +import ( + "time" + + "github.com/denisovdennis/autohero/internal/model" +) + +// consumeFreeBuffCharge attempts to consume a per-buff-type free charge. +// Returns an error if no charges remain for the given buff type. +func consumeFreeBuffCharge(hero *model.Hero, bt model.BuffType, now time.Time) error { + if hero.SubscriptionActive { + return nil + } + hero.EnsureBuffChargesPopulated(now) + return hero.ConsumeBuffCharge(bt, now) +} + +// refundFreeBuffCharge restores a charge for the specific buff type after a failed activation. +func refundFreeBuffCharge(hero *model.Hero, bt model.BuffType) { + if hero.SubscriptionActive { + return + } + hero.RefundBuffCharge(bt) +} diff --git a/backend/internal/handler/buff_quota_test.go b/backend/internal/handler/buff_quota_test.go new file mode 100644 index 0000000..de4fb50 --- /dev/null +++ b/backend/internal/handler/buff_quota_test.go @@ -0,0 +1,30 @@ +package handler + +import ( + "testing" + "time" + + "github.com/denisovdennis/autohero/internal/model" +) + +func TestConsumeFreeBuffCharge_SubscriptionSkipsQuota(t *testing.T) { + h := &model.Hero{SubscriptionActive: true, BuffFreeChargesRemaining: 0} + now := time.Now() + if err := consumeFreeBuffCharge(h, now); err != nil { + t.Fatal(err) + } + if h.BuffFreeChargesRemaining != 0 { + t.Fatalf("expected no charge mutation for subscriber, got %d", h.BuffFreeChargesRemaining) + } +} + +func TestConsumeFreeBuffCharge_Exhausted(t *testing.T) { + end := time.Now().Add(time.Hour) + h := &model.Hero{ + BuffFreeChargesRemaining: 0, + BuffQuotaPeriodEnd: &end, + } + if err := consumeFreeBuffCharge(h, time.Now()); err == nil { + t.Fatal("expected error when exhausted") + } +} diff --git a/backend/internal/handler/daily_task.go b/backend/internal/handler/daily_task.go new file mode 100644 index 0000000..6839359 --- /dev/null +++ b/backend/internal/handler/daily_task.go @@ -0,0 +1,145 @@ +package handler + +import ( + "log/slog" + "net/http" + "time" + + "github.com/go-chi/chi/v5" + + "github.com/denisovdennis/autohero/internal/storage" +) + +// DailyTaskHandler serves daily/weekly task API endpoints. +type DailyTaskHandler struct { + taskStore *storage.DailyTaskStore + heroStore *storage.HeroStore + logger *slog.Logger +} + +// NewDailyTaskHandler creates a new DailyTaskHandler. +func NewDailyTaskHandler(taskStore *storage.DailyTaskStore, heroStore *storage.HeroStore, logger *slog.Logger) *DailyTaskHandler { + return &DailyTaskHandler{ + taskStore: taskStore, + heroStore: heroStore, + logger: logger, + } +} + +// ListHeroTasks returns current daily and weekly tasks with progress. +// GET /api/v1/hero/tasks +func (h *DailyTaskHandler) ListHeroTasks(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + hero, err := h.heroStore.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for tasks", "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + // Lazily create task rows for the current period. + now := time.Now() + if err := h.taskStore.EnsureHeroTasks(r.Context(), hero.ID, now); err != nil { + h.logger.Error("failed to ensure hero tasks", "hero_id", hero.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to initialize tasks", + }) + return + } + + tasks, err := h.taskStore.ListHeroTasks(r.Context(), hero.ID) + if err != nil { + h.logger.Error("failed to list hero tasks", "hero_id", hero.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load tasks", + }) + return + } + + writeJSON(w, http.StatusOK, tasks) +} + +// ClaimTask claims a completed task's reward. +// POST /api/v1/hero/tasks/{taskId}/claim +func (h *DailyTaskHandler) ClaimTask(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + taskID := chi.URLParam(r, "taskId") + if taskID == "" { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "taskId is required", + }) + return + } + + hero, err := h.heroStore.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for task claim", "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + reward, err := h.taskStore.ClaimTask(r.Context(), hero.ID, taskID) + if err != nil { + h.logger.Warn("failed to claim task", "hero_id", hero.ID, "task_id", taskID, "error", err) + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": err.Error(), + }) + return + } + + // Apply reward to hero. + switch reward.RewardType { + case "gold": + hero.Gold += int64(reward.RewardAmount) + case "potion": + hero.Potions += reward.RewardAmount + } + + if err := h.heroStore.Save(r.Context(), hero); err != nil { + h.logger.Error("failed to save hero after task claim", "hero_id", hero.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to save hero", + }) + return + } + + h.logger.Info("task reward claimed", "hero_id", hero.ID, "task_id", taskID, + "reward_type", reward.RewardType, "reward_amount", reward.RewardAmount) + + now := time.Now() + hero.RefreshDerivedCombatStats(now) + writeJSON(w, http.StatusOK, map[string]any{ + "reward": reward, + "hero": hero, + }) +} diff --git a/backend/internal/handler/game.go b/backend/internal/handler/game.go new file mode 100644 index 0000000..d8913f4 --- /dev/null +++ b/backend/internal/handler/game.go @@ -0,0 +1,1613 @@ +package handler + +import ( + "context" + "encoding/json" + "fmt" + "log/slog" + "math/rand" + "net/http" + "strconv" + "strings" + "sync" + "time" + + "github.com/go-chi/chi/v5" + + "github.com/denisovdennis/autohero/internal/game" + "github.com/denisovdennis/autohero/internal/model" + "github.com/denisovdennis/autohero/internal/storage" + "github.com/denisovdennis/autohero/internal/world" +) + +// maxLootHistory is the number of recent loot entries kept per hero in memory. +const maxLootHistory = 50 + +// encounterCombatCooldown limits how often the server grants a combat encounter. +// Client polls roughly every walk segment (~2.5–5.5s); 16s minimum spacing ≈ 4× lower fight rate. +const encounterCombatCooldown = 16 * time.Second + +type GameHandler struct { + engine *game.Engine + store *storage.HeroStore + logStore *storage.LogStore + questStore *storage.QuestStore + gearStore *storage.GearStore + achievementStore *storage.AchievementStore + taskStore *storage.DailyTaskStore + logger *slog.Logger + world *world.Service + lootMu sync.RWMutex + lootCache map[int64][]model.LootHistory // keyed by hero ID + serverStartedAt time.Time + + encounterMu sync.Mutex + lastCombatEncounterAt map[int64]time.Time // per-hero; in-memory only +} + +type encounterEnemyResponse struct { + ID int64 `json:"id"` + Name string `json:"name"` + HP int `json:"hp"` + MaxHP int `json:"maxHp"` + Attack int `json:"attack"` + Defense int `json:"defense"` + Speed float64 `json:"speed"` + EnemyType model.EnemyType `json:"enemyType"` +} + +func NewGameHandler(engine *game.Engine, store *storage.HeroStore, logStore *storage.LogStore, worldSvc *world.Service, logger *slog.Logger, serverStartedAt time.Time, questStore *storage.QuestStore, gearStore *storage.GearStore, achievementStore *storage.AchievementStore, taskStore *storage.DailyTaskStore) *GameHandler { + h := &GameHandler{ + engine: engine, + store: store, + logStore: logStore, + questStore: questStore, + gearStore: gearStore, + achievementStore: achievementStore, + taskStore: taskStore, + logger: logger, + world: worldSvc, + lootCache: make(map[int64][]model.LootHistory), + serverStartedAt: serverStartedAt, + lastCombatEncounterAt: make(map[int64]time.Time), + } + engine.SetOnEnemyDeath(h.onEnemyDeath) + return h +} + +// addLog is a fire-and-forget helper that writes an adventure log entry. +func (h *GameHandler) addLog(heroID int64, message string) { + if h.logStore == nil { + return + } + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) + defer cancel() + if err := h.logStore.Add(ctx, heroID, message); err != nil { + h.logger.Warn("failed to write adventure log", "hero_id", heroID, "error", err) + } +} + +// onEnemyDeath is called by the engine when an enemy is defeated. +// Delegates to processVictoryRewards for canonical reward logic. +func (h *GameHandler) onEnemyDeath(hero *model.Hero, enemy *model.Enemy, now time.Time) { + h.processVictoryRewards(hero, enemy, now) +} + +// processVictoryRewards is the single source of truth for post-kill rewards. +// It awards XP, generates loot (gold is guaranteed via GenerateLoot — no separate +// enemy.GoldReward add), processes equipment drops with nil-fallback auto-sell, +// runs the level-up loop, sets hero state to walking, and records loot history. +// Returns the drops for API response building. +func (h *GameHandler) processVictoryRewards(hero *model.Hero, enemy *model.Enemy, now time.Time) []model.LootDrop { + oldLevel := hero.Level + hero.XP += enemy.XPReward + levelsGained := 0 + for hero.LevelUp() { + levelsGained++ + } + hero.State = model.StateWalking + + luckMult := game.LuckMultiplier(hero, now) + drops := model.GenerateLoot(enemy.Type, luckMult) + + h.lootMu.Lock() + defer h.lootMu.Unlock() + + for i := range drops { + drop := &drops[i] + + switch drop.ItemType { + case "gold": + hero.Gold += drop.GoldAmount + + case "potion": + hero.Potions++ + + default: + // All equipment drops go through the unified gear system. + slot := model.EquipmentSlot(drop.ItemType) + family := model.PickGearFamily(slot) + if family != nil { + ilvl := model.RollIlvl(enemy.MinLevel, enemy.IsElite) + item := model.NewGearItem(family, ilvl, drop.Rarity) + + // Persist the gear item to DB. + if h.gearStore != nil { + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) + if err := h.gearStore.CreateItem(ctx, item); err != nil { + h.logger.Warn("failed to create gear item", "slot", slot, "error", err) + cancel() + sellPrice := model.AutoSellPrices[drop.Rarity] + hero.Gold += sellPrice + drop.GoldAmount = sellPrice + goto recordLoot + } + cancel() + } + + drop.ItemID = item.ID + drop.ItemName = item.Name + + equipped := h.tryAutoEquipGear(hero, item, now) + if equipped { + h.addLog(hero.ID, fmt.Sprintf("Equipped new %s: %s", slot, item.Name)) + } else { + sellPrice := model.AutoSellPrices[drop.Rarity] + hero.Gold += sellPrice + drop.GoldAmount = sellPrice + } + } else { + sellPrice := model.AutoSellPrices[drop.Rarity] + hero.Gold += sellPrice + drop.GoldAmount = sellPrice + } + } + + recordLoot: + entry := model.LootHistory{ + HeroID: hero.ID, + EnemyType: string(enemy.Type), + ItemType: drop.ItemType, + ItemID: drop.ItemID, + Rarity: drop.Rarity, + GoldAmount: drop.GoldAmount, + CreatedAt: now, + } + h.lootCache[hero.ID] = append(h.lootCache[hero.ID], entry) + if len(h.lootCache[hero.ID]) > maxLootHistory { + h.lootCache[hero.ID] = h.lootCache[hero.ID][len(h.lootCache[hero.ID])-maxLootHistory:] + } + } + + // Log the victory. + h.addLog(hero.ID, fmt.Sprintf("Defeated %s, gained %d XP and %d gold", enemy.Name, enemy.XPReward, enemy.GoldReward)) + + // Log level-ups. + for l := oldLevel + 1; l <= oldLevel+levelsGained; l++ { + h.addLog(hero.ID, fmt.Sprintf("Leveled up to %d!", l)) + } + + // Stat tracking for achievements. + hero.TotalKills++ + hero.KillsSinceDeath++ + if enemy.IsElite { + hero.EliteKills++ + } + // Track legendary drops for achievement conditions. + for _, drop := range drops { + if drop.Rarity == model.RarityLegendary && drop.ItemType != "gold" { + hero.LegendaryDrops++ + } + } + + // Quest progress hooks (fire-and-forget, errors logged but not fatal). + h.progressQuestsAfterKill(hero.ID, enemy) + + // Achievement check (fire-and-forget). + h.checkAchievementsAfterKill(hero) + + // Daily/weekly task progress (fire-and-forget). + h.progressTasksAfterKill(hero.ID, enemy, drops) + + return drops +} + +// resolveTelegramID extracts the Telegram user ID from auth context, +// falling back to a "telegramId" query param for dev mode (when auth middleware is disabled). +// On localhost, defaults to telegram_id=1 when no ID is provided. +func resolveTelegramID(r *http.Request) (int64, bool) { + if id, ok := TelegramIDFromContext(r.Context()); ok { + return id, true + } + // Dev fallback: accept telegramId query param. + idStr := r.URL.Query().Get("telegramId") + if idStr != "" { + id, err := strconv.ParseInt(idStr, 10, 64) + if err == nil { + return id, true + } + } + // Localhost fallback: default to telegram_id 1 for testing. + host := r.Host + if strings.HasPrefix(host, "localhost") || strings.HasPrefix(host, "127.0.0.1") || strings.HasPrefix(host, "[::1]") { + return 1, true + } + return 0, false +} + +// GetHero returns the current hero state. +// GET /api/v1/hero +func (h *GameHandler) GetHero(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + hero, err := h.store.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero", "telegram_id", telegramID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + now := time.Now() + needsSave := hero.EnsureBuffChargesPopulated(now) + if hero.ApplyBuffQuotaRollover(now) { + needsSave = true + } + if needsSave { + if err := h.store.Save(r.Context(), hero); err != nil { + h.logger.Warn("failed to persist buff charges init/rollover", "hero_id", hero.ID, "error", err) + } + } + hero.RefreshDerivedCombatStats(now) + writeJSON(w, http.StatusOK, hero) +} + +// ActivateBuff activates a buff on the hero. +// POST /api/v1/hero/buff/{buffType} +func (h *GameHandler) ActivateBuff(w http.ResponseWriter, r *http.Request) { + buffTypeStr := chi.URLParam(r, "buffType") + + bt, ok := model.ValidBuffType(buffTypeStr) + if !ok { + h.logger.Warn("invalid buff type requested", "buff_type", buffTypeStr) + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid buff type: " + buffTypeStr, + }) + return + } + + telegramID, ok := resolveTelegramID(r) + if !ok { + h.logger.Warn("buff request missing telegramId", "buff_type", buffTypeStr) + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + hero, err := h.store.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for buff", "telegram_id", telegramID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + now := time.Now() + hero.EnsureBuffChargesPopulated(now) + + consumed := false + if !hero.SubscriptionActive { + if err := consumeFreeBuffCharge(hero, bt, now); err != nil { + writeJSON(w, http.StatusForbidden, map[string]string{ + "error": err.Error(), + }) + return + } + consumed = true + } + + ab := game.ApplyBuff(hero, bt, now) + if ab == nil { + if consumed { + refundFreeBuffCharge(hero, bt) + } + h.logger.Error("ApplyBuff returned nil", "hero_id", hero.ID, "buff_type", bt) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to apply buff", + }) + return + } + + if err := h.store.Save(r.Context(), hero); err != nil { + h.logger.Error("failed to save hero after buff", "hero_id", hero.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to save hero", + }) + return + } + + h.logger.Info("buff activated", + "hero_id", hero.ID, + "buff", bt, + "expires_at", ab.ExpiresAt, + ) + h.addLog(hero.ID, fmt.Sprintf("Activated %s", ab.Buff.Name)) + + // Daily/weekly task progress: use_buff. + if h.taskStore != nil { + taskCtx, taskCancel := context.WithTimeout(context.Background(), 2*time.Second) + defer taskCancel() + _ = h.taskStore.EnsureHeroTasks(taskCtx, hero.ID, now) + if err := h.taskStore.IncrementTaskProgress(taskCtx, hero.ID, "use_buff", 1); err != nil { + h.logger.Warn("task use_buff progress failed", "hero_id", hero.ID, "error", err) + } + } + + hero.RefreshDerivedCombatStats(now) + writeJSON(w, http.StatusOK, map[string]any{ + "buff": ab, + "heroBuffs": hero.Buffs, + "hero": hero, + }) +} + +// ReviveHero revives an effectively dead hero (StateDead or HP <= 0) with base HP. +// POST /api/v1/hero/revive +func (h *GameHandler) ReviveHero(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + hero, err := h.store.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for revive", "telegram_id", telegramID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + if hero.State != model.StateDead && hero.HP > 0 { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "hero is alive (state is not dead and hp > 0)", + }) + return + } + + if !hero.SubscriptionActive && hero.ReviveCount >= 2 { + writeJSON(w, http.StatusForbidden, map[string]string{ + "error": "free revive limit reached (subscribe for unlimited revives)", + }) + return + } + + // Track death stats (the hero is dead, this is the first time we process it server-side). + hero.TotalDeaths++ + hero.KillsSinceDeath = 0 + + hero.HP = hero.MaxHP / 2 + if hero.HP < 1 { + hero.HP = 1 + } + hero.State = model.StateWalking + now := time.Now() + hero.Buffs = model.RemoveBuffType(hero.Buffs, model.BuffResurrection) + hero.Debuffs = nil + hero.ReviveCount++ + + if err := h.store.Save(r.Context(), hero); err != nil { + h.logger.Error("failed to save hero after revive", "hero_id", hero.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to save hero", + }) + return + } + + h.logger.Info("hero revived", "hero_id", hero.ID, "hp", hero.HP) + h.addLog(hero.ID, "Hero revived") + + hero.RefreshDerivedCombatStats(now) + writeJSON(w, http.StatusOK, hero) +} + +// RequestEncounter picks a backend-generated enemy for the hero's current level. +// POST /api/v1/hero/encounter +func (h *GameHandler) RequestEncounter(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + hero, err := h.store.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for encounter", "telegram_id", telegramID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + if hero.State == model.StateDead || hero.HP <= 0 { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "hero is dead", + }) + return + } + + // Check if hero is inside a town (no combat in towns) + posX := hero.PositionX + posY := hero.PositionY + if px := r.URL.Query().Get("posX"); px != "" { + if v, err := strconv.ParseFloat(px, 64); err == nil { + posX = v + } + } + if py := r.URL.Query().Get("posY"); py != "" { + if v, err := strconv.ParseFloat(py, 64); err == nil { + posY = v + } + } + if h.isHeroInTown(r.Context(), posX, posY) { + writeJSON(w, http.StatusOK, map[string]string{ + "type": "no_encounter", + "reason": "in_town", + }) + return + } + + now := time.Now() + h.encounterMu.Lock() + if t, ok := h.lastCombatEncounterAt[hero.ID]; ok && now.Sub(t) < encounterCombatCooldown { + h.encounterMu.Unlock() + writeJSON(w, http.StatusOK, map[string]string{ + "type": "no_encounter", + "reason": "cooldown", + }) + return + } + h.encounterMu.Unlock() + + // 10% chance to encounter a wandering NPC instead of an enemy. + if rand.Float64() < 0.10 { + cost := int64(20 + hero.Level*5) + h.addLog(hero.ID, "Encountered a Wandering Merchant on the road") + h.encounterMu.Lock() + h.lastCombatEncounterAt[hero.ID] = now + h.encounterMu.Unlock() + writeJSON(w, http.StatusOK, model.NPCEventResponse{ + Type: "npc_event", + NPC: model.NPCEventNPC{ + Name: "Wandering Merchant", + Role: "alms", + }, + Cost: cost, + Reward: "random_equipment", + }) + return + } + + enemy := pickEnemyForLevel(hero.Level) + h.encounterMu.Lock() + h.lastCombatEncounterAt[hero.ID] = now + h.encounterMu.Unlock() + h.addLog(hero.ID, fmt.Sprintf("Encountered %s", enemy.Name)) + writeJSON(w, http.StatusOK, encounterEnemyResponse{ + ID: time.Now().UnixNano(), + Name: enemy.Name, + HP: enemy.MaxHP, + MaxHP: enemy.MaxHP, + Attack: enemy.Attack, + Defense: enemy.Defense, + Speed: enemy.Speed, + EnemyType: enemy.Type, + }) +} + +// isHeroInTown checks if the position is within any town's radius. +func (h *GameHandler) isHeroInTown(ctx context.Context, posX, posY float64) bool { + towns, err := h.questStore.ListTowns(ctx) + if err != nil || len(towns) == 0 { + return false + } + for _, t := range towns { + dx := posX - t.WorldX + dy := posY - t.WorldY + if dx*dx+dy*dy <= t.Radius*t.Radius { + return true + } + } + return false +} + +// pickEnemyForLevel delegates to the canonical implementation in the game package. +func pickEnemyForLevel(level int) model.Enemy { + return game.PickEnemyForLevel(level) +} + +// tryAutoEquipGear uses the in-memory combat rating comparison to decide whether +// to equip a new gear item. If it improves combat rating by >= 3%, equips it +// (persisting to DB if gearStore is available). Returns true if equipped. +func (h *GameHandler) tryAutoEquipGear(hero *model.Hero, item *model.GearItem, now time.Time) bool { + if hero.Gear == nil { + hero.Gear = make(map[model.EquipmentSlot]*model.GearItem) + } + current := hero.Gear[item.Slot] + if current == nil { + hero.Gear[item.Slot] = item + h.persistGearEquip(hero.ID, item) + return true + } + oldRating := hero.CombatRatingAt(now) + hero.Gear[item.Slot] = item + if hero.CombatRatingAt(now) >= oldRating*1.03 { + h.persistGearEquip(hero.ID, item) + return true + } + hero.Gear[item.Slot] = current + return false +} + +// persistGearEquip saves the equip to the hero_gear table if gearStore is available. +func (h *GameHandler) persistGearEquip(heroID int64, item *model.GearItem) { + if h.gearStore == nil || item.ID == 0 { + return + } + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) + defer cancel() + if err := h.gearStore.EquipItem(ctx, heroID, item.Slot, item.ID); err != nil { + h.logger.Warn("failed to persist gear equip", "hero_id", heroID, "slot", item.Slot, "error", err) + } +} + +// pickEnemyByType returns a scaled enemy instance for loot/XP rewards matching encounter stats. +func pickEnemyByType(level int, t model.EnemyType) model.Enemy { + tmpl, ok := model.EnemyTemplates[t] + if !ok { + tmpl = model.EnemyTemplates[model.EnemyWolf] + } + return game.ScaleEnemyTemplate(tmpl, level) +} + +type victoryRequest struct { + EnemyType string `json:"enemyType"` + HeroHP int `json:"heroHp"` + PositionX float64 `json:"positionX"` + PositionY float64 `json:"positionY"` +} + +type victoryDropJSON struct { + ItemType string `json:"itemType"` + ItemID int64 `json:"itemId,omitempty"` + ItemName string `json:"itemName,omitempty"` + Rarity string `json:"rarity"` + GoldAmount int64 `json:"goldAmount"` +} + +type victoryResponse struct { + Hero *model.Hero `json:"hero"` + Drops []victoryDropJSON `json:"drops"` +} + +// ReportVictory applies authoritative combat rewards after a client-resolved kill. +// POST /api/v1/hero/victory +// Hero HP after the fight is taken from the client and remains persisted across fights. +func (h *GameHandler) ReportVictory(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + var req victoryRequest + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid request body: " + err.Error(), + }) + return + } + + if req.EnemyType == "" { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "enemyType is required", + }) + return + } + + et := model.EnemyType(req.EnemyType) + if _, ok := model.EnemyTemplates[et]; !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "unknown enemyType: " + req.EnemyType, + }) + return + } + + hero, err := h.store.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for victory", "telegram_id", telegramID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + if hero.State == model.StateDead || hero.HP <= 0 { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "hero is dead", + }) + return + } + + now := time.Now() + hpAfterFight := req.HeroHP + if hpAfterFight < 1 { + hpAfterFight = 1 + } + if hpAfterFight > hero.MaxHP { + hpAfterFight = hero.MaxHP + } + if hpAfterFight > hero.HP { + h.logger.Warn("client reported HP higher than server HP, clamping", + "hero_id", hero.ID, + "client_hp", req.HeroHP, + "server_hp", hero.HP, + ) + hpAfterFight = hero.HP + } + + enemy := pickEnemyByType(hero.Level, et) + + drops := h.processVictoryRewards(hero, &enemy, now) + + outDrops := make([]victoryDropJSON, 0, len(drops)) + for _, drop := range drops { + outDrops = append(outDrops, victoryDropJSON{ + ItemType: drop.ItemType, + ItemID: drop.ItemID, + ItemName: drop.ItemName, + Rarity: string(drop.Rarity), + GoldAmount: drop.GoldAmount, + }) + } + + // Level-up does NOT restore HP (spec §3.3). Always persist the post-fight HP. + hero.HP = hpAfterFight + hero.PositionX = req.PositionX + hero.PositionY = req.PositionY + + // Update online status for shared world. + nowPtr := time.Now() + hero.LastOnlineAt = &nowPtr + + if err := h.store.Save(r.Context(), hero); err != nil { + h.logger.Error("failed to save hero after victory", "hero_id", hero.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to save hero", + }) + return + } + + hero.RefreshDerivedCombatStats(now) + writeJSON(w, http.StatusOK, victoryResponse{ + Hero: hero, + Drops: outDrops, + }) +} + +// offlineReport describes what happened while the hero was offline. +type offlineReport struct { + OfflineSeconds int `json:"offlineSeconds"` + MonstersKilled int `json:"monstersKilled"` + XPGained int64 `json:"xpGained"` + GoldGained int64 `json:"goldGained"` + LevelsGained int `json:"levelsGained"` + PotionsUsed int `json:"potionsUsed"` + PotionsFound int `json:"potionsFound"` + HPBefore int `json:"hpBefore"` + Message string `json:"message"` + Log []string `json:"log"` +} + +// buildOfflineReport constructs an offline report from real adventure log entries +// written by the offline simulator (and catch-up). Parses log messages to count +// defeats, XP, gold, levels, and deaths. +func (h *GameHandler) buildOfflineReport(ctx context.Context, hero *model.Hero, offlineDuration time.Duration) *offlineReport { + if offlineDuration < 30*time.Second { + return nil + } + + // Query log entries since hero was last updated (with a small buffer). + since := hero.UpdatedAt.Add(-5 * time.Minute) + entries, err := h.logStore.GetSince(ctx, hero.ID, since, 200) + if err != nil { + h.logger.Error("failed to get offline log entries", "hero_id", hero.ID, "error", err) + return nil + } + + if len(entries) == 0 { + // No offline activity recorded. + if hero.State == model.StateDead { + return &offlineReport{ + OfflineSeconds: int(offlineDuration.Seconds()), + HPBefore: 0, + Message: "Your hero remains dead. Revive to continue progression.", + Log: []string{}, + } + } + return nil + } + + report := &offlineReport{ + OfflineSeconds: int(offlineDuration.Seconds()), + HPBefore: hero.HP, + Log: make([]string, 0, len(entries)), + } + + for _, entry := range entries { + report.Log = append(report.Log, entry.Message) + + // Parse structured log messages to populate summary counters. + // Messages written by the offline simulator follow known patterns. + if matched, _ := parseDefeatedLog(entry.Message); matched { + report.MonstersKilled++ + } + if xp, gold, ok := parseGainsLog(entry.Message); ok { + report.XPGained += xp + report.GoldGained += gold + } + if isLevelUpLog(entry.Message) { + report.LevelsGained++ + } + if isDeathLog(entry.Message) { + // Death was recorded + } + if isPotionLog(entry.Message) { + report.PotionsUsed++ + } + } + + if hero.State == model.StateDead { + report.Message = "Your hero died while offline. Revive to continue progression." + } else if report.MonstersKilled > 0 { + report.Message = "Your hero fought while you were away!" + } else { + report.Message = "Your hero rested while you were away." + } + + return report +} + +// catchUpOfflineGap simulates the gap between hero.UpdatedAt and serverStartedAt. +// This covers the period when the server was down and the offline simulator wasn't running. +// Returns true if any simulation was performed. +func (h *GameHandler) catchUpOfflineGap(ctx context.Context, hero *model.Hero) bool { + gapDuration := h.serverStartedAt.Sub(hero.UpdatedAt) + if gapDuration < 30*time.Second { + return false + } + + // Cap at 8 hours. + if gapDuration > 8*time.Hour { + gapDuration = 8 * time.Hour + } + + // Auto-revive if hero has been dead for more than 1 hour (spec section 3.3). + if (hero.State == model.StateDead || hero.HP <= 0) && gapDuration > 1*time.Hour { + hero.HP = hero.MaxHP / 2 + if hero.HP < 1 { + hero.HP = 1 + } + hero.State = model.StateWalking + hero.Debuffs = nil + h.addLog(hero.ID, "Auto-revived after 1 hour") + } + + totalFights := int(gapDuration.Seconds()) / 10 + if totalFights <= 0 { + return false + } + + now := time.Now() + performed := false + + for i := 0; i < totalFights; i++ { + if hero.HP <= 0 || hero.State == model.StateDead { + break + } + + survived, enemy, xpGained, goldGained := game.SimulateOneFight(hero, now, nil) + performed = true + + h.addLog(hero.ID, fmt.Sprintf("Encountered %s", enemy.Name)) + if survived { + h.addLog(hero.ID, fmt.Sprintf("Defeated %s, gained %d XP and %d gold", enemy.Name, xpGained, goldGained)) + } else { + h.addLog(hero.ID, fmt.Sprintf("Died fighting %s", enemy.Name)) + } + } + + return performed +} + +// parseDefeatedLog checks if a message matches "Defeated X, gained ..." pattern. +func parseDefeatedLog(msg string) (bool, string) { + if len(msg) > 9 && msg[:9] == "Defeated " { + return true, msg[9:] + } + return false, "" +} + +// parseGainsLog parses "Defeated X, gained N XP and M gold" to extract XP and gold. +func parseGainsLog(msg string) (xp int64, gold int64, ok bool) { + // Pattern: "Defeated ..., gained %d XP and %d gold" + // Find ", gained " as the separator since enemy names may contain spaces. + const sep = ", gained " + idx := -1 + for i := 0; i <= len(msg)-len(sep); i++ { + if msg[i:i+len(sep)] == sep { + idx = i + break + } + } + if idx < 0 { + return 0, 0, false + } + tail := msg[idx+len(sep):] + n, _ := fmt.Sscanf(tail, "%d XP and %d gold", &xp, &gold) + if n >= 2 { + return xp, gold, true + } + return 0, 0, false +} + +// isLevelUpLog checks if a message is a level-up log. +func isLevelUpLog(msg string) bool { + return len(msg) > 12 && msg[:12] == "Leveled up t" +} + +// isDeathLog checks if a message is a death log. +func isDeathLog(msg string) bool { + return len(msg) > 14 && msg[:14] == "Died fighting " +} + +// isPotionLog checks if a message is a potion usage log. +func isPotionLog(msg string) bool { + return len(msg) > 20 && msg[:20] == "Used healing potion," +} + +// InitHero returns the hero for the given Telegram user, creating one with defaults if needed. +// Also simulates offline progress based on time since last update. +// GET /api/v1/hero/init +func (h *GameHandler) InitHero(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + hero, err := h.store.GetOrCreate(r.Context(), telegramID, "Hero") + if err != nil { + h.logger.Error("failed to init hero", "telegram_id", telegramID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to init hero", + }) + return + } + + now := time.Now() + chargesInit := hero.EnsureBuffChargesPopulated(now) + quotaRolled := hero.ApplyBuffQuotaRollover(now) + if chargesInit || quotaRolled { + if err := h.store.Save(r.Context(), hero); err != nil { + h.logger.Warn("failed to persist buff charges init/rollover", "hero_id", hero.ID, "error", err) + } + } + + // Catch-up simulation: cover the gap between hero.UpdatedAt and serverStartedAt + // (the period when the server was down and the offline simulator wasn't running). + offlineDuration := time.Since(hero.UpdatedAt) + var catchUpPerformed bool + if hero.UpdatedAt.Before(h.serverStartedAt) && hero.State == model.StateWalking && hero.HP > 0 { + catchUpPerformed = h.catchUpOfflineGap(r.Context(), hero) + } + + // Build offline report from real adventure log entries (written by the + // offline simulator and/or the catch-up above). + report := h.buildOfflineReport(r.Context(), hero, offlineDuration) + + if catchUpPerformed { + if err := h.store.Save(r.Context(), hero); err != nil { + h.logger.Error("failed to save hero after catch-up sim", "hero_id", hero.ID, "error", err) + } + } + + // Auto-revive if hero has been dead for more than 1 hour (spec section 3.3). + if (hero.State == model.StateDead || hero.HP <= 0) && time.Since(hero.UpdatedAt) > 1*time.Hour { + hero.HP = hero.MaxHP / 2 + if hero.HP < 1 { + hero.HP = 1 + } + hero.State = model.StateWalking + hero.Debuffs = nil + h.addLog(hero.ID, "Auto-revived after 1 hour") + if err := h.store.Save(r.Context(), hero); err != nil { + h.logger.Error("failed to save hero after auto-revive", "hero_id", hero.ID, "error", err) + } + } + + needsName := hero.Name == "" || hero.Name == "Hero" + + hero.RefreshDerivedCombatStats(now) + + // Build towns with NPCs for the frontend map. + townsWithNPCs := h.buildTownsWithNPCs(r.Context()) + + writeJSON(w, http.StatusOK, map[string]any{ + "hero": hero, + "needsName": needsName, + "offlineReport": report, + "mapRef": h.world.RefForLevel(hero.Level), + "towns": townsWithNPCs, + }) +} + + +// buildTownsWithNPCs loads all towns and their NPCs, returning a slice of +// TownWithNPCs suitable for the frontend map render. +func (h *GameHandler) buildTownsWithNPCs(ctx context.Context) []model.TownWithNPCs { + towns, err := h.questStore.ListTowns(ctx) + if err != nil { + h.logger.Warn("failed to load towns for init response", "error", err) + return []model.TownWithNPCs{} + } + + allNPCs, err := h.questStore.ListAllNPCs(ctx) + if err != nil { + h.logger.Warn("failed to load npcs for init response", "error", err) + return []model.TownWithNPCs{} + } + + // Group NPCs by town ID for O(1) lookup. + npcsByTown := make(map[int64][]model.NPC, len(towns)) + for _, n := range allNPCs { + npcsByTown[n.TownID] = append(npcsByTown[n.TownID], n) + } + + result := make([]model.TownWithNPCs, 0, len(towns)) + for _, t := range towns { + tw := model.TownWithNPCs{ + ID: t.ID, + Name: t.Name, + Biome: t.Biome, + WorldX: t.WorldX, + WorldY: t.WorldY, + Radius: t.Radius, + Size: model.TownSizeFromRadius(t.Radius), + NPCs: make([]model.NPCView, 0), + } + for _, n := range npcsByTown[t.ID] { + tw.NPCs = append(tw.NPCs, model.NPCView{ + ID: n.ID, + Name: n.Name, + Type: n.Type, + WorldX: t.WorldX + n.OffsetX, + WorldY: t.WorldY + n.OffsetY, + }) + } + result = append(result, tw) + } + return result +} + +// heroNameRequest is the JSON body for the set-name endpoint. +type heroNameRequest struct { + Name string `json:"name"` +} + +// isValidHeroName checks that a name is 2-16 chars, only latin/cyrillic letters and digits, +// no leading/trailing spaces. +func isValidHeroName(name string) bool { + if len(name) < 2 || len(name) > 16 { + return false + } + if name[0] == ' ' || name[len(name)-1] == ' ' { + return false + } + for _, r := range name { + if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') { + continue + } + if (r >= '0' && r <= '9') { + continue + } + // Cyrillic block: U+0400 to U+04FF + if r >= 0x0400 && r <= 0x04FF { + continue + } + return false + } + return true +} + +// SetHeroName sets the hero's name (first-time setup only). +// POST /api/v1/hero/name +func (h *GameHandler) SetHeroName(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + var req heroNameRequest + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid request body", + }) + return + } + + if !isValidHeroName(req.Name) { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid name: must be 2-16 characters, letters (latin/cyrillic) and digits only", + }) + return + } + + hero, err := h.store.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for name", "telegram_id", telegramID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + // Only allow name change if it hasn't been set yet. + if hero.Name != "" && hero.Name != "Hero" { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "name already set", + }) + return + } + + if err := h.store.SaveName(r.Context(), hero.ID, req.Name); err != nil { + // Check for unique constraint violation (pgx wraps the error with code 23505). + errStr := err.Error() + if containsUniqueViolation(errStr) { + writeJSON(w, http.StatusConflict, map[string]string{ + "error": "HERO_NAME_TAKEN", + }) + return + } + h.logger.Error("failed to save hero name", "hero_id", hero.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to save name", + }) + return + } + + hero.Name = req.Name + h.logger.Info("hero name set", "hero_id", hero.ID, "name", req.Name) + + now := time.Now() + hero.RefreshDerivedCombatStats(now) + writeJSON(w, http.StatusOK, hero) +} + +// containsUniqueViolation checks if an error message indicates a PostgreSQL unique violation. +func containsUniqueViolation(errStr string) bool { + // pgx includes the SQLSTATE code 23505 for unique_violation. + for _, marker := range []string{"23505", "unique", "UNIQUE", "duplicate key"} { + for i := 0; i <= len(errStr)-len(marker); i++ { + if errStr[i:i+len(marker)] == marker { + return true + } + } + } + return false +} + +// buffRefillRequest is the JSON body for the purchase-buff-refill endpoint. +type buffRefillRequest struct { + BuffType string `json:"buffType"` +} + +// PurchaseBuffRefill purchases a buff charge refill. +// POST /api/v1/hero/purchase-buff-refill +func (h *GameHandler) PurchaseBuffRefill(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + var req buffRefillRequest + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid request body", + }) + return + } + + bt, ok := model.ValidBuffType(req.BuffType) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid buff type: " + req.BuffType, + }) + return + } + + hero, err := h.store.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for buff refill", "telegram_id", telegramID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + // Determine price. + priceRUB := model.BuffRefillPriceRUB + paymentType := model.PaymentBuffReplenish + if bt == model.BuffResurrection { + priceRUB = model.ResurrectionRefillPriceRUB + paymentType = model.PaymentResurrectionReplenish + } + + now := time.Now() + + // Create a payment record and auto-complete it (no real payment gateway yet). + payment := &model.Payment{ + HeroID: hero.ID, + Type: paymentType, + BuffType: string(bt), + AmountRUB: priceRUB, + Status: model.PaymentCompleted, + CreatedAt: now, + CompletedAt: &now, + } + if err := h.store.CreatePayment(r.Context(), payment); err != nil { + h.logger.Error("failed to create payment", "hero_id", hero.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to process payment", + }) + return + } + + // Refill the specific buff's charges to max. + hero.ResetBuffCharges(&bt, now) + + if err := h.store.Save(r.Context(), hero); err != nil { + h.logger.Error("failed to save hero after buff refill", "hero_id", hero.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to save hero", + }) + return + } + + h.logger.Info("purchased buff refill", + "hero_id", hero.ID, + "buff_type", bt, + "price_rub", priceRUB, + ) + h.addLog(hero.ID, fmt.Sprintf("Purchased buff refill: %s", bt)) + + hero.RefreshDerivedCombatStats(now) + writeJSON(w, http.StatusOK, hero) +} + +// GetLoot returns the hero's recent loot history. +// GET /api/v1/hero/loot +func (h *GameHandler) GetLoot(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + hero, err := h.store.GetByTelegramID(r.Context(), telegramID) + if err != nil || hero == nil { + writeJSON(w, http.StatusOK, map[string]any{ + "loot": []model.LootHistory{}, + }) + return + } + + h.lootMu.RLock() + loot := h.lootCache[hero.ID] + h.lootMu.RUnlock() + + if loot == nil { + loot = []model.LootHistory{} + } + writeJSON(w, http.StatusOK, map[string]any{ + "loot": loot, + }) +} + +// UsePotion consumes a healing potion, restoring 30% of maxHP. +// POST /api/v1/hero/use-potion +func (h *GameHandler) UsePotion(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + storeHero, err := h.store.GetByTelegramID(r.Context(), telegramID) + if err != nil || storeHero == nil { + h.logger.Error("failed to get hero for potion", "telegram_id", telegramID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + var hero = h.engine.GetMovements(storeHero.ID).Hero + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + if hero.Potions <= 0 { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "no potions available", + }) + return + } + + if hero.State == model.StateDead || hero.HP <= 0 { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "hero is dead", + }) + return + } + + // Heal 30% of maxHP, capped at maxHP. + healAmount := hero.MaxHP * 30 / 100 + if healAmount < 1 { + healAmount = 1 + } + hero.HP += healAmount + if hero.HP > hero.MaxHP { + hero.HP = hero.MaxHP + } + hero.Potions-- + + if err := h.store.Save(r.Context(), hero); err != nil { + h.logger.Error("failed to save hero after potion", "hero_id", hero.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to save hero", + }) + return + } + + h.addLog(hero.ID, fmt.Sprintf("Used healing potion, restored %d HP", healAmount)) + + now := time.Now() + hero.RefreshDerivedCombatStats(now) + writeJSON(w, http.StatusOK, hero) +} + +// GetAdventureLog returns the hero's recent adventure log entries. +// GET /api/v1/hero/log +func (h *GameHandler) GetAdventureLog(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + hero, err := h.store.GetByTelegramID(r.Context(), telegramID) + if err != nil || hero == nil { + writeJSON(w, http.StatusOK, map[string]any{ + "log": []storage.LogEntry{}, + }) + return + } + + limitStr := r.URL.Query().Get("limit") + limit := 50 + if limitStr != "" { + if parsed, err := strconv.Atoi(limitStr); err == nil && parsed > 0 { + limit = parsed + } + } + + entries, err := h.logStore.GetRecent(r.Context(), hero.ID, limit) + if err != nil { + h.logger.Error("failed to get adventure log", "hero_id", hero.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load adventure log", + }) + return + } + + writeJSON(w, http.StatusOK, map[string]any{ + "log": entries, + }) +} + +// GetWeapons returns gear catalog entries for the main_hand slot (backward-compatible). +// GET /api/v1/weapons +func (h *GameHandler) GetWeapons(w http.ResponseWriter, r *http.Request) { + var items []model.GearFamily + for _, gf := range model.GearCatalog { + if gf.Slot == model.SlotMainHand { + items = append(items, gf) + } + } + writeJSON(w, http.StatusOK, items) +} + +// GetArmor returns gear catalog entries for the chest slot (backward-compatible). +// GET /api/v1/armor +func (h *GameHandler) GetArmor(w http.ResponseWriter, r *http.Request) { + var items []model.GearFamily + for _, gf := range model.GearCatalog { + if gf.Slot == model.SlotChest { + items = append(items, gf) + } + } + writeJSON(w, http.StatusOK, items) +} + +// GetGearCatalog returns the full unified gear catalog. +// GET /api/v1/gear/catalog +func (h *GameHandler) GetGearCatalog(w http.ResponseWriter, r *http.Request) { + writeJSON(w, http.StatusOK, model.GearCatalog) +} + +// GetHeroGear returns all equipped gear for the hero organized by slot. +// GET /api/v1/hero/gear +func (h *GameHandler) GetHeroGear(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + hero, err := h.store.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for gear", "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + writeJSON(w, http.StatusOK, hero.Gear) +} + +// NearbyHeroes returns other heroes near the requesting hero for shared world rendering. +// GET /api/v1/hero/nearby +func (h *GameHandler) NearbyHeroes(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + hero, err := h.store.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for nearby", "telegram_id", telegramID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + // Default radius: 500 units, max 50 heroes. + radius := 500.0 + if rStr := r.URL.Query().Get("radius"); rStr != "" { + if parsed, err := strconv.ParseFloat(rStr, 64); err == nil && parsed > 0 { + radius = parsed + } + } + if radius > 2000 { + radius = 2000 + } + + nearby, err := h.store.GetNearbyHeroes(r.Context(), hero.ID, hero.PositionX, hero.PositionY, radius, 50) + if err != nil { + h.logger.Error("failed to get nearby heroes", "hero_id", hero.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load nearby heroes", + }) + return + } + + writeJSON(w, http.StatusOK, map[string]any{ + "heroes": nearby, + }) +} + +func writeJSON(w http.ResponseWriter, status int, v any) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) + json.NewEncoder(w).Encode(v) +} + +// checkAchievementsAfterKill runs achievement condition checks and applies rewards. +func (h *GameHandler) checkAchievementsAfterKill(hero *model.Hero) { + if h.achievementStore == nil { + return + } + ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) + defer cancel() + + newlyUnlocked, err := h.achievementStore.CheckAndUnlock(ctx, hero) + if err != nil { + h.logger.Warn("achievement check failed", "hero_id", hero.ID, "error", err) + return + } + + for _, a := range newlyUnlocked { + // Apply reward. + switch a.RewardType { + case "gold": + hero.Gold += int64(a.RewardAmount) + case "potion": + hero.Potions += a.RewardAmount + } + h.addLog(hero.ID, fmt.Sprintf("Achievement unlocked: %s! (+%d %s)", a.Title, a.RewardAmount, a.RewardType)) + } +} + +// progressTasksAfterKill increments daily/weekly task progress after a kill. +func (h *GameHandler) progressTasksAfterKill(heroID int64, enemy *model.Enemy, drops []model.LootDrop) { + if h.taskStore == nil { + return + } + ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) + defer cancel() + + // Ensure tasks exist for current period. + if err := h.taskStore.EnsureHeroTasks(ctx, heroID, time.Now()); err != nil { + h.logger.Warn("task ensure failed", "hero_id", heroID, "error", err) + return + } + + // kill_count tasks. + if err := h.taskStore.IncrementTaskProgress(ctx, heroID, "kill_count", 1); err != nil { + h.logger.Warn("task kill_count progress failed", "hero_id", heroID, "error", err) + } + + // elite_kill tasks. + if enemy.IsElite { + if err := h.taskStore.IncrementTaskProgress(ctx, heroID, "elite_kill", 1); err != nil { + h.logger.Warn("task elite_kill progress failed", "hero_id", heroID, "error", err) + } + } + + // collect_gold tasks: sum gold gained from all drops. + var goldGained int64 + for _, drop := range drops { + if drop.ItemType == "gold" { + goldGained += drop.GoldAmount + } else if drop.GoldAmount > 0 { + goldGained += drop.GoldAmount // auto-sell gold + } + } + if goldGained > 0 { + if err := h.taskStore.IncrementTaskProgress(ctx, heroID, "collect_gold", int(goldGained)); err != nil { + h.logger.Warn("task collect_gold progress failed", "hero_id", heroID, "error", err) + } + } +} + +// HandleHeroDeath updates stat tracking when a hero dies. +// Should be called whenever a hero transitions to dead state. +func (h *GameHandler) HandleHeroDeath(hero *model.Hero) { + hero.TotalDeaths++ + hero.KillsSinceDeath = 0 +} + +// progressQuestsAfterKill updates quest progress for kill_count and collect_item quests. +func (h *GameHandler) progressQuestsAfterKill(heroID int64, enemy *model.Enemy) { + if h.questStore == nil { + return + } + ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) + defer cancel() + + // kill_count quests: increment with the specific enemy type. + if err := h.questStore.IncrementQuestProgress(ctx, heroID, "kill_count", string(enemy.Type), 1); err != nil { + h.logger.Warn("quest kill_count progress failed", "hero_id", heroID, "error", err) + } + + // collect_item quests: roll per-quest drop chance. + if err := h.questStore.IncrementCollectItemProgress(ctx, heroID, string(enemy.Type)); err != nil { + h.logger.Warn("quest collect_item progress failed", "hero_id", heroID, "error", err) + } +} + +// NOTE: processExtendedEquipmentDrop and tryAutoEquipExtended have been removed. +// All equipment slot drops are now handled uniformly in processVictoryRewards +// via the unified GearCatalog and tryAutoEquipGear. diff --git a/backend/internal/handler/game_test.go b/backend/internal/handler/game_test.go new file mode 100644 index 0000000..b643f4c --- /dev/null +++ b/backend/internal/handler/game_test.go @@ -0,0 +1,73 @@ +package handler + +import ( + "testing" +) + +func TestParseDefeatedLog(t *testing.T) { + tests := []struct { + msg string + matched bool + }{ + {"Defeated Forest Wolf, gained 1 XP and 5 gold", true}, + {"Encountered Forest Wolf", false}, + {"Died fighting Forest Wolf", false}, + {"Defeated a Forest Wolf", true}, + } + + for _, tt := range tests { + matched, _ := parseDefeatedLog(tt.msg) + if matched != tt.matched { + t.Errorf("parseDefeatedLog(%q) = %v, want %v", tt.msg, matched, tt.matched) + } + } +} + +func TestParseGainsLog(t *testing.T) { + tests := []struct { + msg string + wantXP int64 + wantGold int64 + wantOK bool + }{ + {"Defeated Forest Wolf, gained 1 XP and 5 gold", 1, 5, true}, + {"Defeated Skeleton King, gained 3 XP and 10 gold", 3, 10, true}, + {"Encountered Forest Wolf", 0, 0, false}, + {"Died fighting Forest Wolf", 0, 0, false}, + } + + for _, tt := range tests { + xp, gold, ok := parseGainsLog(tt.msg) + if ok != tt.wantOK || xp != tt.wantXP || gold != tt.wantGold { + t.Errorf("parseGainsLog(%q) = (%d, %d, %v), want (%d, %d, %v)", + tt.msg, xp, gold, ok, tt.wantXP, tt.wantGold, tt.wantOK) + } + } +} + +func TestIsLevelUpLog(t *testing.T) { + if !isLevelUpLog("Leveled up to 5!") { + t.Error("expected true for level-up log") + } + if isLevelUpLog("Defeated a wolf") { + t.Error("expected false for non-level-up log") + } +} + +func TestIsDeathLog(t *testing.T) { + if !isDeathLog("Died fighting Forest Wolf") { + t.Error("expected true for death log") + } + if isDeathLog("Defeated Forest Wolf") { + t.Error("expected false for non-death log") + } +} + +func TestIsPotionLog(t *testing.T) { + if !isPotionLog("Used healing potion, restored 30 HP") { + t.Error("expected true for potion log") + } + if isPotionLog("Defeated Forest Wolf") { + t.Error("expected false for non-potion log") + } +} diff --git a/backend/internal/handler/health.go b/backend/internal/handler/health.go new file mode 100644 index 0000000..bd615a0 --- /dev/null +++ b/backend/internal/handler/health.go @@ -0,0 +1,20 @@ +package handler + +import ( + "encoding/json" + "net/http" +) + +type HealthHandler struct{} + +func NewHealthHandler() *HealthHandler { + return &HealthHandler{} +} + +func (h *HealthHandler) Health(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + json.NewEncoder(w).Encode(map[string]string{ + "status": "ok", + }) +} diff --git a/backend/internal/handler/maps.go b/backend/internal/handler/maps.go new file mode 100644 index 0000000..aeb75b1 --- /dev/null +++ b/backend/internal/handler/maps.go @@ -0,0 +1,53 @@ +package handler + +import ( + "log/slog" + "net/http" + "strings" + + "github.com/go-chi/chi/v5" + + "github.com/denisovdennis/autohero/internal/world" +) + +type MapsHandler struct { + world *world.Service + logger *slog.Logger +} + +func NewMapsHandler(worldSvc *world.Service, logger *slog.Logger) *MapsHandler { + return &MapsHandler{ + world: worldSvc, + logger: logger, + } +} + +// GetMap returns a deterministic server map with ETag support. +// GET /api/v1/maps/{mapId} +func (h *MapsHandler) GetMap(w http.ResponseWriter, r *http.Request) { + mapID := chi.URLParam(r, "mapId") + if strings.TrimSpace(mapID) == "" { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing mapId", + }) + return + } + + serverMap, etag, ok := h.world.GetMap(mapID) + if !ok { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "map not found", + }) + return + } + + ifNoneMatch := strings.TrimSpace(r.Header.Get("If-None-Match")) + if ifNoneMatch != "" && ifNoneMatch == etag { + w.Header().Set("ETag", etag) + w.WriteHeader(http.StatusNotModified) + return + } + + w.Header().Set("ETag", etag) + writeJSON(w, http.StatusOK, serverMap) +} diff --git a/backend/internal/handler/npc.go b/backend/internal/handler/npc.go new file mode 100644 index 0000000..acb2cdb --- /dev/null +++ b/backend/internal/handler/npc.go @@ -0,0 +1,525 @@ +package handler + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "io" + "log/slog" + "math" + "math/rand" + "net/http" + "strconv" + "time" + + "github.com/denisovdennis/autohero/internal/model" + "github.com/denisovdennis/autohero/internal/storage" +) + +// NPCHandler serves NPC interaction API endpoints. +type NPCHandler struct { + questStore *storage.QuestStore + heroStore *storage.HeroStore + gearStore *storage.GearStore + logStore *storage.LogStore + logger *slog.Logger +} + +// NewNPCHandler creates a new NPCHandler. +func NewNPCHandler(questStore *storage.QuestStore, heroStore *storage.HeroStore, gearStore *storage.GearStore, logStore *storage.LogStore, logger *slog.Logger) *NPCHandler { + return &NPCHandler{ + questStore: questStore, + heroStore: heroStore, + gearStore: gearStore, + logStore: logStore, + logger: logger, + } +} + +// addLog is a fire-and-forget helper that writes an adventure log entry. +func (h *NPCHandler) addLog(heroID int64, message string) { + if h.logStore == nil { + return + } + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) + defer cancel() + if err := h.logStore.Add(ctx, heroID, message); err != nil { + h.logger.Warn("failed to write adventure log", "hero_id", heroID, "error", err) + } +} + +// dist2D calculates the Euclidean distance between two 2D points. +func dist2D(x1, y1, x2, y2 float64) float64 { + dx := x1 - x2 + dy := y1 - y2 + return math.Sqrt(dx*dx + dy*dy) +} + +// InteractNPC handles POST /api/v1/hero/npc-interact. +// The hero interacts with a specific NPC; checks proximity to the NPC's town. +func (h *NPCHandler) InteractNPC(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + var req struct { + NPCID int64 `json:"npcId"` + PositionX float64 `json:"positionX"` + PositionY float64 `json:"positionY"` + } + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid request body", + }) + return + } + if req.NPCID == 0 { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "npcId is required", + }) + return + } + + hero, err := h.heroStore.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for npc interact", "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + // Load NPC. + npc, err := h.questStore.GetNPCByID(r.Context(), req.NPCID) + if err != nil { + h.logger.Error("failed to get npc", "npc_id", req.NPCID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load npc", + }) + return + } + if npc == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "npc not found", + }) + return + } + + // Load the NPC's town. + town, err := h.questStore.GetTown(r.Context(), npc.TownID) + if err != nil { + h.logger.Error("failed to get town for npc", "town_id", npc.TownID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load town", + }) + return + } + if town == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "town not found", + }) + return + } + + // Check proximity: hero must be within the town's radius. + d := dist2D(req.PositionX, req.PositionY, town.WorldX, town.WorldY) + if d > town.Radius { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "hero is too far from the town", + }) + return + } + + // Build actions based on NPC type. + var actions []model.NPCInteractAction + + switch npc.Type { + case "quest_giver": + quests, err := h.questStore.ListQuestsByNPCForHeroLevel(r.Context(), npc.ID, hero.Level) + if err != nil { + h.logger.Error("failed to list quests for npc interaction", "npc_id", npc.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load quests", + }) + return + } + for _, q := range quests { + actions = append(actions, model.NPCInteractAction{ + ActionType: "quest", + QuestID: q.ID, + QuestTitle: q.Title, + Description: q.Description, + }) + } + + case "merchant": + actions = append(actions, model.NPCInteractAction{ + ActionType: "shop_item", + ItemName: "Healing Potion", + ItemCost: 50, + Description: "Restores health. Always handy in a pinch.", + }) + + case "healer": + actions = append(actions, model.NPCInteractAction{ + ActionType: "heal", + ItemName: "Full Heal", + ItemCost: 100, + Description: "Restore hero to full HP.", + }) + } + + // Log the meeting. + h.addLog(hero.ID, fmt.Sprintf("Met %s in %s", npc.Name, town.Name)) + + resp := model.NPCInteractResponse{ + NPCName: npc.Name, + NPCType: npc.Type, + TownName: town.Name, + Actions: actions, + } + if resp.Actions == nil { + resp.Actions = []model.NPCInteractAction{} + } + writeJSON(w, http.StatusOK, resp) +} + +// NearbyNPCs handles GET /api/v1/hero/nearby-npcs. +// Returns NPCs within 3 world units of the given position. +func (h *NPCHandler) NearbyNPCs(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + posXStr := r.URL.Query().Get("posX") + posYStr := r.URL.Query().Get("posY") + posX, errX := strconv.ParseFloat(posXStr, 64) + posY, errY := strconv.ParseFloat(posYStr, 64) + if errX != nil || errY != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "posX and posY are required numeric parameters", + }) + return + } + + // Verify hero exists. + hero, err := h.heroStore.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for nearby npcs", "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + // Load all towns and NPCs, then filter by distance. + towns, err := h.questStore.ListTowns(r.Context()) + if err != nil { + h.logger.Error("failed to list towns for nearby npcs", "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load towns", + }) + return + } + + const nearbyRadius = 3.0 + var result []model.NearbyNPCEntry + + for _, town := range towns { + npcs, err := h.questStore.ListNPCsByTown(r.Context(), town.ID) + if err != nil { + h.logger.Warn("failed to list npcs for town", "town_id", town.ID, "error", err) + continue + } + for _, npc := range npcs { + npcWorldX := town.WorldX + npc.OffsetX + npcWorldY := town.WorldY + npc.OffsetY + d := dist2D(posX, posY, npcWorldX, npcWorldY) + if d <= nearbyRadius { + result = append(result, model.NearbyNPCEntry{ + ID: npc.ID, + Name: npc.Name, + Type: npc.Type, + WorldX: npcWorldX, + WorldY: npcWorldY, + InteractionAvailable: true, + }) + } + } + } + + if result == nil { + result = []model.NearbyNPCEntry{} + } + writeJSON(w, http.StatusOK, result) +} + +// NPCAlms handles POST /api/v1/hero/npc-alms. +// The hero gives alms to a wandering merchant in exchange for random equipment. +func (h *NPCHandler) NPCAlms(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + var req struct { + Accept bool `json:"accept"` + } + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + // Empty body used to be sent by the web client; treat as accept (mysterious item purchase). + if errors.Is(err, io.EOF) { + req.Accept = true + } else { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid request body", + }) + return + } + } + + hero, err := h.heroStore.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for npc alms", "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + if !req.Accept { + writeJSON(w, http.StatusOK, model.AlmsResponse{ + Accepted: false, + Message: "You declined the wandering merchant's offer.", + }) + return + } + + // Compute cost: 20 + level * 5. + cost := int64(20 + hero.Level*5) + if hero.Gold < cost { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": fmt.Sprintf("not enough gold (need %d, have %d)", cost, hero.Gold), + }) + return + } + + hero.Gold -= cost + + // Generate random equipment drop. + slots := model.AllEquipmentSlots + slot := slots[rand.Intn(len(slots))] + family := model.PickGearFamily(slot) + + var drop *model.LootDrop + + if family != nil { + rarity := model.RollRarity() + ilvl := model.RollIlvl(hero.Level, false) + item := model.NewGearItem(family, ilvl, rarity) + + if h.gearStore != nil { + ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second) + err := h.gearStore.CreateItem(ctx, item) + cancel() + if err != nil { + h.logger.Warn("failed to create alms gear item", "slot", slot, "error", err) + } else { + drop = &model.LootDrop{ + ItemType: string(slot), + ItemID: item.ID, + ItemName: item.Name, + Rarity: rarity, + } + h.addLog(hero.ID, fmt.Sprintf("Gave alms to wandering merchant, received %s", item.Name)) + } + } + } + + if drop == nil { + // Fallback: gold refund if we couldn't generate equipment. + hero.Gold += cost + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to generate reward", + }) + return + } + + if err := h.heroStore.Save(r.Context(), hero); err != nil { + h.logger.Error("failed to save hero after alms", "hero_id", hero.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to save hero", + }) + return + } + + writeJSON(w, http.StatusOK, model.AlmsResponse{ + Accepted: true, + GoldSpent: cost, + ItemDrop: drop, + Hero: hero, + Message: fmt.Sprintf("You gave %d gold to the wandering merchant and received %s.", cost, drop.ItemName), + }) +} + +// HealHero handles POST /api/v1/hero/npc-heal. +// A healer NPC restores the hero to full HP for 100 gold. +func (h *NPCHandler) HealHero(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + var req struct { + NPCID int64 `json:"npcId"` + } + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid request body", + }) + return + } + + hero, err := h.heroStore.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for heal", "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + // Verify NPC is a healer. + if req.NPCID != 0 { + npc, err := h.questStore.GetNPCByID(r.Context(), req.NPCID) + if err != nil { + h.logger.Error("failed to get npc for heal", "npc_id", req.NPCID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load npc", + }) + return + } + if npc == nil || npc.Type != "healer" { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "npc is not a healer", + }) + return + } + } + + const healCost int64 = 100 + if hero.Gold < healCost { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": fmt.Sprintf("not enough gold (need %d, have %d)", healCost, hero.Gold), + }) + return + } + + hero.Gold -= healCost + hero.HP = hero.MaxHP + + if err := h.heroStore.Save(r.Context(), hero); err != nil { + h.logger.Error("failed to save hero after heal", "hero_id", hero.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to save hero", + }) + return + } + + h.addLog(hero.ID, "Healed to full HP by a town healer") + writeJSON(w, http.StatusOK, map[string]any{ + "hero": hero, + "healed": true, + "message": "You have been healed to full HP.", + }) +} + +// BuyPotion handles POST /api/v1/hero/npc-buy-potion. +// A merchant NPC sells a healing potion for 50 gold. +func (h *NPCHandler) BuyPotion(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + hero, err := h.heroStore.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for buy potion", "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + const potionCost int64 = 50 + if hero.Gold < potionCost { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": fmt.Sprintf("not enough gold (need %d, have %d)", potionCost, hero.Gold), + }) + return + } + + hero.Gold -= potionCost + hero.Potions++ + + if err := h.heroStore.Save(r.Context(), hero); err != nil { + h.logger.Error("failed to save hero after buy potion", "hero_id", hero.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to save hero", + }) + return + } + + h.addLog(hero.ID, "Purchased a Healing Potion from a merchant") + writeJSON(w, http.StatusOK, map[string]any{ + "hero": hero, + "message": "You purchased a Healing Potion for 50 gold.", + }) +} diff --git a/backend/internal/handler/quest.go b/backend/internal/handler/quest.go new file mode 100644 index 0000000..1f36e11 --- /dev/null +++ b/backend/internal/handler/quest.go @@ -0,0 +1,293 @@ +package handler + +import ( + "log/slog" + "net/http" + "strconv" + + "github.com/go-chi/chi/v5" + + "github.com/denisovdennis/autohero/internal/storage" +) + +// QuestHandler serves quest system API endpoints. +type QuestHandler struct { + questStore *storage.QuestStore + heroStore *storage.HeroStore + logStore *storage.LogStore + logger *slog.Logger +} + +// NewQuestHandler creates a new QuestHandler. +func NewQuestHandler(questStore *storage.QuestStore, heroStore *storage.HeroStore, logStore *storage.LogStore, logger *slog.Logger) *QuestHandler { + return &QuestHandler{ + questStore: questStore, + heroStore: heroStore, + logStore: logStore, + logger: logger, + } +} + +// ListTowns returns all towns. +// GET /api/v1/towns +func (h *QuestHandler) ListTowns(w http.ResponseWriter, r *http.Request) { + towns, err := h.questStore.ListTowns(r.Context()) + if err != nil { + h.logger.Error("failed to list towns", "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to list towns", + }) + return + } + writeJSON(w, http.StatusOK, towns) +} + +// ListNPCsByTown returns all NPCs in a town. +// GET /api/v1/towns/{townId}/npcs +func (h *QuestHandler) ListNPCsByTown(w http.ResponseWriter, r *http.Request) { + townIDStr := chi.URLParam(r, "townId") + townID, err := strconv.ParseInt(townIDStr, 10, 64) + if err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid townId", + }) + return + } + + npcs, err := h.questStore.ListNPCsByTown(r.Context(), townID) + if err != nil { + h.logger.Error("failed to list npcs", "town_id", townID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to list npcs", + }) + return + } + writeJSON(w, http.StatusOK, npcs) +} + +// ListQuestsByNPC returns all quests offered by an NPC. +// GET /api/v1/npcs/{npcId}/quests +func (h *QuestHandler) ListQuestsByNPC(w http.ResponseWriter, r *http.Request) { + npcIDStr := chi.URLParam(r, "npcId") + npcID, err := strconv.ParseInt(npcIDStr, 10, 64) + if err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid npcId", + }) + return + } + + quests, err := h.questStore.ListQuestsByNPC(r.Context(), npcID) + if err != nil { + h.logger.Error("failed to list quests", "npc_id", npcID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to list quests", + }) + return + } + writeJSON(w, http.StatusOK, quests) +} + +// AcceptQuest accepts a quest for the hero. +// POST /api/v1/hero/quests/{questId}/accept +func (h *QuestHandler) AcceptQuest(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + questIDStr := chi.URLParam(r, "questId") + questID, err := strconv.ParseInt(questIDStr, 10, 64) + if err != nil || questID == 0 { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid questId", + }) + return + } + req := struct{ QuestID int64 }{QuestID: questID} + + hero, err := h.heroStore.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for quest accept", "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + if err := h.questStore.AcceptQuest(r.Context(), hero.ID, req.QuestID); err != nil { + h.logger.Error("failed to accept quest", "hero_id", hero.ID, "quest_id", req.QuestID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to accept quest", + }) + return + } + + h.logger.Info("quest accepted", "hero_id", hero.ID, "quest_id", req.QuestID) + writeJSON(w, http.StatusOK, map[string]string{ + "status": "accepted", + }) +} + +// ListHeroQuests returns the hero's quest log. +// GET /api/v1/hero/quests +func (h *QuestHandler) ListHeroQuests(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + hero, err := h.heroStore.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for quest list", "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + quests, err := h.questStore.ListHeroQuests(r.Context(), hero.ID) + if err != nil { + h.logger.Error("failed to list hero quests", "hero_id", hero.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to list quests", + }) + return + } + writeJSON(w, http.StatusOK, quests) +} + +// ClaimQuestReward claims a completed quest's reward. +// POST /api/v1/hero/quests/{questId}/claim +func (h *QuestHandler) ClaimQuestReward(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + questIDStr := chi.URLParam(r, "questId") + questID, err := strconv.ParseInt(questIDStr, 10, 64) + if err != nil { + h.logger.Error("Error claiming quest", err) + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid questId", + }) + return + } + + hero, err := h.heroStore.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for quest claim", "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + reward, err := h.questStore.ClaimQuestReward(r.Context(), hero.ID, questID) + if err != nil { + h.logger.Warn("failed to claim quest reward", "hero_id", hero.ID, "quest_id", questID, "error", err) + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": err.Error(), + }) + return + } + + // Apply rewards to hero. + hero.XP += reward.XP + hero.Gold += reward.Gold + hero.Potions += reward.Potions + + // Run level-up loop. + for hero.LevelUp() { + } + + if err := h.heroStore.Save(r.Context(), hero); err != nil { + h.logger.Error("failed to save hero after quest claim", "hero_id", hero.ID, "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to save hero", + }) + return + } + + h.logger.Info("quest reward claimed", "hero_id", hero.ID, "quest_id", questID, + "xp", reward.XP, "gold", reward.Gold, "potions", reward.Potions) + + writeJSON(w, http.StatusOK, hero) +} + +// AbandonQuest removes a quest from the hero's quest log. +// DELETE /api/v1/hero/quests/{questId} +func (h *QuestHandler) AbandonQuest(w http.ResponseWriter, r *http.Request) { + telegramID, ok := resolveTelegramID(r) + if !ok { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "missing telegramId", + }) + return + } + + questIDStr := chi.URLParam(r, "questId") + questID, err := strconv.ParseInt(questIDStr, 10, 64) + if err != nil { + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": "invalid questId", + }) + return + } + + hero, err := h.heroStore.GetByTelegramID(r.Context(), telegramID) + if err != nil { + h.logger.Error("failed to get hero for quest abandon", "error", err) + writeJSON(w, http.StatusInternalServerError, map[string]string{ + "error": "failed to load hero", + }) + return + } + if hero == nil { + writeJSON(w, http.StatusNotFound, map[string]string{ + "error": "hero not found", + }) + return + } + + if err := h.questStore.AbandonQuest(r.Context(), hero.ID, questID); err != nil { + h.logger.Warn("failed to abandon quest", "hero_id", hero.ID, "quest_id", questID, "error", err) + writeJSON(w, http.StatusBadRequest, map[string]string{ + "error": err.Error(), + }) + return + } + + h.logger.Info("quest abandoned", "hero_id", hero.ID, "quest_id", questID) + writeJSON(w, http.StatusOK, map[string]string{ + "status": "abandoned", + }) +} diff --git a/backend/internal/handler/ws.go b/backend/internal/handler/ws.go new file mode 100644 index 0000000..6585f5a --- /dev/null +++ b/backend/internal/handler/ws.go @@ -0,0 +1,341 @@ +package handler + +import ( + "context" + "encoding/json" + "log/slog" + "net/http" + "strconv" + "sync" + "time" + + "github.com/gorilla/websocket" + + "github.com/denisovdennis/autohero/internal/model" +) + +var upgrader = websocket.Upgrader{ + ReadBufferSize: 1024, + WriteBufferSize: 1024, + CheckOrigin: func(r *http.Request) bool { + // TODO: restrict origins in production. + return true + }, +} + +// Hub maintains active WebSocket connections, broadcasts envelopes, +// and routes incoming client messages. +type Hub struct { + clients map[*Client]bool + register chan *Client + unregister chan *Client + broadcast chan model.WSEnvelope + Incoming chan model.ClientMessage // inbound commands from clients + mu sync.RWMutex + logger *slog.Logger + + // OnConnect is called when a client finishes registration. + // Set by the engine to push initial state. May be nil. + OnConnect func(heroID int64) + + // OnDisconnect is called when a client is unregistered. + // Set by the engine to persist state and remove movement. May be nil. + OnDisconnect func(heroID int64) +} + +// Client represents a single WebSocket connection. +type Client struct { + hub *Hub + conn *websocket.Conn + send chan model.WSEnvelope + heroID int64 +} + +const ( + writeWait = 10 * time.Second + pongWait = 60 * time.Second + pingPeriod = (pongWait * 9) / 10 + maxMessageSize = 4096 + sendBufSize = 64 +) + +// NewHub creates a new WebSocket hub. +func NewHub(logger *slog.Logger) *Hub { + return &Hub{ + clients: make(map[*Client]bool), + register: make(chan *Client), + unregister: make(chan *Client), + broadcast: make(chan model.WSEnvelope, 256), + Incoming: make(chan model.ClientMessage, 256), + logger: logger, + } +} + +// Run starts the hub's event loop. Should be called as a goroutine. +func (h *Hub) Run() { + for { + select { + case client := <-h.register: + h.mu.Lock() + h.clients[client] = true + h.mu.Unlock() + h.logger.Info("client connected", "hero_id", client.heroID) + + // Notify engine of new connection (sends hero_state, route, etc.). + if h.OnConnect != nil { + go h.OnConnect(client.heroID) + } + + case client := <-h.unregister: + h.mu.Lock() + if _, ok := h.clients[client]; ok { + delete(h.clients, client) + close(client.send) + } + h.mu.Unlock() + h.logger.Info("client disconnected", "hero_id", client.heroID) + + // Notify engine of disconnection. + if h.OnDisconnect != nil { + go h.OnDisconnect(client.heroID) + } + + case env := <-h.broadcast: + h.mu.RLock() + for client := range h.clients { + select { + case client.send <- env: + default: + go func(c *Client) { + h.unregister <- c + }(client) + } + } + h.mu.RUnlock() + } + } +} + +// BroadcastEvent wraps a legacy CombatEvent in an envelope and broadcasts +// it to the hero's connections. This maintains backward compatibility during migration. +func (h *Hub) BroadcastEvent(event model.CombatEvent) { + h.SendToHero(event.HeroID, event.Type, event) +} + +// SendToHero sends a typed message to all WebSocket connections for a specific hero. +func (h *Hub) SendToHero(heroID int64, msgType string, payload any) { + env := model.NewWSEnvelope(msgType, payload) + h.mu.RLock() + defer h.mu.RUnlock() + for client := range h.clients { + if client.heroID == heroID { + select { + case client.send <- env: + default: + // Slow consumer, schedule disconnect. + go func(c *Client) { + h.unregister <- c + }(client) + } + } + } +} + +// BroadcastAll sends an envelope to every connected client (rare: server announcements). +func (h *Hub) BroadcastAll(msgType string, payload any) { + env := model.NewWSEnvelope(msgType, payload) + select { + case h.broadcast <- env: + default: + h.logger.Warn("broadcast channel full, dropping event", "type", msgType) + } +} + +// ConnectionCount returns the number of active WebSocket connections. +func (h *Hub) ConnectionCount() int { + h.mu.RLock() + defer h.mu.RUnlock() + return len(h.clients) +} + +// ConnectedHeroIDs returns the hero IDs that have active WebSocket connections. +func (h *Hub) ConnectedHeroIDs() []int64 { + h.mu.RLock() + defer h.mu.RUnlock() + seen := make(map[int64]struct{}, len(h.clients)) + for c := range h.clients { + seen[c.heroID] = struct{}{} + } + ids := make([]int64, 0, len(seen)) + for id := range seen { + ids = append(ids, id) + } + return ids +} + +// IsHeroConnected returns true if the given hero has at least one active WS connection. +func (h *Hub) IsHeroConnected(heroID int64) bool { + h.mu.RLock() + defer h.mu.RUnlock() + for c := range h.clients { + if c.heroID == heroID { + return true + } + } + return false +} + +// WSHandler handles WebSocket upgrade requests. +type WSHandler struct { + hub *Hub + heroStore heroStoreLookup + logger *slog.Logger +} + +// heroStoreLookup is a minimal interface to avoid import cycle with storage package. +type heroStoreLookup interface { + GetHeroIDByTelegramID(ctx context.Context, telegramID int64) (int64, error) +} + +// NewWSHandler creates a new WebSocket handler. +func NewWSHandler(hub *Hub, heroStore heroStoreLookup, logger *slog.Logger) *WSHandler { + return &WSHandler{hub: hub, heroStore: heroStore, logger: logger} +} + +// HandleWS upgrades the HTTP connection to WebSocket. +// GET /ws +func (h *WSHandler) HandleWS(w http.ResponseWriter, r *http.Request) { + conn, err := upgrader.Upgrade(w, r, nil) + if err != nil { + h.logger.Error("websocket upgrade failed", "error", err) + return + } + + // Resolve hero from Telegram initData or telegramId query param. + var heroID int64 + initData := r.URL.Query().Get("initData") + if initData != "" { + if tid, err := parseUserIDFromInitData(initData); err == nil { + heroID = tid + } + } + if heroID == 0 { + // Dev fallback: accept telegramId query param. + if tidStr := r.URL.Query().Get("telegramId"); tidStr != "" { + if tid, err := strconv.ParseInt(tidStr, 10, 64); err == nil { + heroID = tid + } + } + } + if heroID == 0 { + heroID = 1 // last-resort fallback for dev + } + + // heroID at this point is the Telegram user ID. Resolve to DB hero ID. + if h.heroStore != nil { + if dbID, err := h.heroStore.GetHeroIDByTelegramID(r.Context(), heroID); err == nil && dbID > 0 { + heroID = dbID + } else { + h.logger.Warn("ws: could not resolve telegram ID to hero ID", "telegram_id", heroID, "error", err) + } + } + + client := &Client{ + hub: h.hub, + conn: conn, + send: make(chan model.WSEnvelope, sendBufSize), + heroID: heroID, + } + + h.hub.register <- client + + go client.writePump() + go client.readPump() +} + +func (c *Client) readPump() { + defer func() { + c.hub.unregister <- c + c.conn.Close() + }() + + c.conn.SetReadLimit(maxMessageSize) + c.conn.SetReadDeadline(time.Now().Add(pongWait)) + c.conn.SetPongHandler(func(string) error { + c.conn.SetReadDeadline(time.Now().Add(pongWait)) + return nil + }) + + for { + _, msg, err := c.conn.ReadMessage() + if err != nil { + if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) { + c.hub.logger.Warn("websocket read error", "error", err) + } + break + } + + raw := string(msg) + + // Backward compat: plain "ping" string. + if raw == "ping" { + c.conn.SetWriteDeadline(time.Now().Add(writeWait)) + _ = c.conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"pong","payload":{}}`)) + continue + } + + // Parse as JSON envelope. + var env model.WSEnvelope + if err := json.Unmarshal(msg, &env); err != nil { + c.hub.logger.Debug("invalid ws message", "error", err, "hero_id", c.heroID) + continue + } + + // Handle ping envelope. + if env.Type == "ping" { + c.conn.SetWriteDeadline(time.Now().Add(writeWait)) + _ = c.conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"pong","payload":{}}`)) + continue + } + + // Route to hub's incoming channel for the engine to process. + select { + case c.hub.Incoming <- model.ClientMessage{ + HeroID: c.heroID, + Type: env.Type, + Payload: env.Payload, + }: + default: + c.hub.logger.Warn("incoming channel full, dropping client message", + "type", env.Type, "hero_id", c.heroID) + } + } +} + +func (c *Client) writePump() { + ticker := time.NewTicker(pingPeriod) + defer func() { + ticker.Stop() + c.conn.Close() + }() + + for { + select { + case env, ok := <-c.send: + c.conn.SetWriteDeadline(time.Now().Add(writeWait)) + if !ok { + c.conn.WriteMessage(websocket.CloseMessage, []byte{}) + return + } + if err := c.conn.WriteJSON(env); err != nil { + return + } + + case <-ticker.C: + c.conn.SetWriteDeadline(time.Now().Add(writeWait)) + if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil { + return + } + } + } +} diff --git a/backend/internal/migrate/migrate.go b/backend/internal/migrate/migrate.go new file mode 100644 index 0000000..8efb2a1 --- /dev/null +++ b/backend/internal/migrate/migrate.go @@ -0,0 +1,101 @@ +package migrate + +import ( + "context" + "fmt" + "log/slog" + "os" + "path/filepath" + "sort" + "strings" + + "github.com/jackc/pgx/v5/pgxpool" +) + +// Run applies pending SQL migrations from dir in sorted order. +// Already-applied migrations (tracked in schema_migrations) are skipped. +func Run(ctx context.Context, pool *pgxpool.Pool, dir string) error { + if _, err := pool.Exec(ctx, `CREATE TABLE IF NOT EXISTS schema_migrations ( + filename TEXT PRIMARY KEY, + applied_at TIMESTAMPTZ NOT NULL DEFAULT now() + )`); err != nil { + return fmt.Errorf("migrate: create tracking table: %w", err) + } + + entries, err := os.ReadDir(dir) + if err != nil { + return fmt.Errorf("migrate: read dir %s: %w", dir, err) + } + + var files []string + for _, e := range entries { + if !e.IsDir() && strings.HasSuffix(e.Name(), ".sql") { + files = append(files, e.Name()) + } + } + sort.Strings(files) + + rows, err := pool.Query(ctx, "SELECT filename FROM schema_migrations") + if err != nil { + return fmt.Errorf("migrate: query applied: %w", err) + } + defer rows.Close() + + applied := make(map[string]bool) + for rows.Next() { + var name string + if err := rows.Scan(&name); err != nil { + return fmt.Errorf("migrate: scan: %w", err) + } + applied[name] = true + } + if err := rows.Err(); err != nil { + return fmt.Errorf("migrate: rows: %w", err) + } + + // If this is the first time the migration runner sees an existing DB + // (tables created by docker-entrypoint-initdb.d), mark bootstrap migration as applied. + if !applied["000001_init.sql"] { + var tableExists bool + _ = pool.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'heroes')").Scan(&tableExists) + if tableExists { + _, _ = pool.Exec(ctx, "INSERT INTO schema_migrations (filename) VALUES ('000001_init.sql') ON CONFLICT DO NOTHING") + applied["000001_init.sql"] = true + slog.Info("migrate: marked 000001_init.sql as applied (tables already exist)") + } + } + + for _, f := range files { + if applied[f] { + continue + } + + sql, err := os.ReadFile(filepath.Join(dir, f)) + if err != nil { + return fmt.Errorf("migrate: read %s: %w", f, err) + } + + tx, err := pool.Begin(ctx) + if err != nil { + return fmt.Errorf("migrate: begin tx for %s: %w", f, err) + } + + if _, err := tx.Exec(ctx, string(sql)); err != nil { + tx.Rollback(ctx) //nolint:errcheck + return fmt.Errorf("migrate: exec %s: %w", f, err) + } + + if _, err := tx.Exec(ctx, "INSERT INTO schema_migrations (filename) VALUES ($1)", f); err != nil { + tx.Rollback(ctx) //nolint:errcheck + return fmt.Errorf("migrate: record %s: %w", f, err) + } + + if err := tx.Commit(ctx); err != nil { + return fmt.Errorf("migrate: commit %s: %w", f, err) + } + + slog.Info("migrate: applied", "file", f) + } + + return nil +} diff --git a/backend/internal/model/achievement.go b/backend/internal/model/achievement.go new file mode 100644 index 0000000..fc1b1ae --- /dev/null +++ b/backend/internal/model/achievement.go @@ -0,0 +1,51 @@ +package model + +import "time" + +// Achievement defines a static achievement template. +type Achievement struct { + ID string `json:"id"` + Title string `json:"title"` + Description string `json:"description"` + ConditionType string `json:"conditionType"` // level, kills, gold, elite_kills, loot_legendary, kills_no_death + ConditionValue int `json:"conditionValue"` + RewardType string `json:"rewardType"` // gold, potion, title + RewardAmount int `json:"rewardAmount"` +} + +// HeroAchievement records that a hero has unlocked an achievement. +type HeroAchievement struct { + HeroID int64 `json:"heroId"` + AchievementID string `json:"achievementId"` + UnlockedAt time.Time `json:"unlockedAt"` + Achievement *Achievement `json:"achievement,omitempty"` +} + +// AchievementView is the response struct combining an achievement definition +// with unlock status for a specific hero. +type AchievementView struct { + Achievement + Unlocked bool `json:"unlocked"` + UnlockedAt *time.Time `json:"unlockedAt,omitempty"` +} + +// CheckAchievementCondition returns true if the hero's stats satisfy the +// achievement's unlock condition. +func CheckAchievementCondition(a *Achievement, hero *Hero) bool { + switch a.ConditionType { + case "level": + return hero.Level >= a.ConditionValue + case "kills": + return hero.TotalKills >= a.ConditionValue + case "gold": + return hero.Gold >= int64(a.ConditionValue) + case "elite_kills": + return hero.EliteKills >= a.ConditionValue + case "loot_legendary": + return hero.LegendaryDrops >= a.ConditionValue + case "kills_no_death": + return hero.KillsSinceDeath >= a.ConditionValue + default: + return false + } +} diff --git a/backend/internal/model/buff.go b/backend/internal/model/buff.go new file mode 100644 index 0000000..591fac5 --- /dev/null +++ b/backend/internal/model/buff.go @@ -0,0 +1,191 @@ +package model + +import "time" + +// ---- Buffs ---- + +type BuffType string + +const ( + BuffRush BuffType = "rush" // +attack speed + BuffRage BuffType = "rage" // +damage + BuffShield BuffType = "shield" // -incoming damage + BuffLuck BuffType = "luck" // x2.5 loot + BuffResurrection BuffType = "resurrection" // revive on death + BuffHeal BuffType = "heal" // +50% HP instantly + BuffPowerPotion BuffType = "power_potion" // +150% damage + BuffWarCry BuffType = "war_cry" // +100% attack speed +) + +// AllBuffTypes is the complete list of valid buff types. +var AllBuffTypes = []BuffType{ + BuffRush, BuffRage, BuffShield, BuffLuck, BuffResurrection, + BuffHeal, BuffPowerPotion, BuffWarCry, +} + +// ValidBuffType checks if a string is a valid buff type. +func ValidBuffType(s string) (BuffType, bool) { + bt := BuffType(s) + for _, t := range AllBuffTypes { + if t == bt { + return bt, true + } + } + return "", false +} + +type Buff struct { + ID int64 `json:"id"` + Type BuffType `json:"type"` + Name string `json:"name"` + Duration time.Duration `json:"duration"` + Magnitude float64 `json:"magnitude"` // effect strength (e.g., 0.3 = +30%) + CooldownDuration time.Duration `json:"cooldownDuration"` +} + +type ActiveBuff struct { + Buff Buff `json:"buff"` + AppliedAt time.Time `json:"appliedAt"` + ExpiresAt time.Time `json:"expiresAt"` +} + +// IsExpired returns true if the buff has expired relative to the given time. +func (ab *ActiveBuff) IsExpired(now time.Time) bool { + return now.After(ab.ExpiresAt) +} + +// DefaultBuffs defines the base buff definitions. +var DefaultBuffs = map[BuffType]Buff{ + BuffRush: { + Type: BuffRush, Name: "Rush", + Duration: 5 * time.Minute, Magnitude: 0.5, // +50% movement + CooldownDuration: 15 * time.Minute, + }, + BuffRage: { + Type: BuffRage, Name: "Rage", + Duration: 3 * time.Minute, Magnitude: 1.0, // +100% damage + CooldownDuration: 10 * time.Minute, + }, + BuffShield: { + Type: BuffShield, Name: "Shield", + Duration: 5 * time.Minute, Magnitude: 0.5, // -50% incoming damage + CooldownDuration: 12 * time.Minute, + }, + BuffLuck: { + Type: BuffLuck, Name: "Luck", + Duration: 30 * time.Minute, Magnitude: 1.5, // x2.5 loot + CooldownDuration: 2 * time.Hour, + }, + BuffResurrection: { + Type: BuffResurrection, Name: "Resurrection", + Duration: 10 * time.Minute, Magnitude: 0.5, // revive with 50% HP + CooldownDuration: 30 * time.Minute, + }, + BuffHeal: { + Type: BuffHeal, Name: "Heal", + Duration: 1 * time.Second, Magnitude: 0.5, // +50% HP (instant) + CooldownDuration: 5 * time.Minute, + }, + BuffPowerPotion: { + Type: BuffPowerPotion, Name: "Power Potion", + Duration: 5 * time.Minute, Magnitude: 1.5, // +150% damage + CooldownDuration: 20 * time.Minute, + }, + BuffWarCry: { + Type: BuffWarCry, Name: "War Cry", + Duration: 3 * time.Minute, Magnitude: 1.0, // +100% attack speed + CooldownDuration: 10 * time.Minute, + }, +} + +// ---- Debuffs ---- + +type DebuffType string + +const ( + DebuffPoison DebuffType = "poison" // -2% HP/sec + DebuffFreeze DebuffType = "freeze" // -50% attack speed + DebuffBurn DebuffType = "burn" // -3% HP/sec + DebuffStun DebuffType = "stun" // no attacks for 2 sec + DebuffSlow DebuffType = "slow" // -40% movement speed (not attack speed) + DebuffWeaken DebuffType = "weaken" // -30% hero outgoing damage + DebuffIceSlow DebuffType = "ice_slow" // -20% attack speed (Ice Guardian per spec §4.2) +) + +// AllDebuffTypes is the complete list of valid debuff types. +var AllDebuffTypes = []DebuffType{ + DebuffPoison, DebuffFreeze, DebuffBurn, DebuffStun, DebuffSlow, DebuffWeaken, DebuffIceSlow, +} + +// ValidDebuffType checks if a string is a valid debuff type. +func ValidDebuffType(s string) (DebuffType, bool) { + dt := DebuffType(s) + for _, t := range AllDebuffTypes { + if t == dt { + return dt, true + } + } + return "", false +} + +type Debuff struct { + ID int64 `json:"id"` + Type DebuffType `json:"type"` + Name string `json:"name"` + Duration time.Duration `json:"duration"` + Magnitude float64 `json:"magnitude"` // effect strength +} + +type ActiveDebuff struct { + Debuff Debuff `json:"debuff"` + AppliedAt time.Time `json:"appliedAt"` + ExpiresAt time.Time `json:"expiresAt"` +} + +// IsExpired returns true if the debuff has expired relative to the given time. +func (ad *ActiveDebuff) IsExpired(now time.Time) bool { + return now.After(ad.ExpiresAt) +} + +// DefaultDebuffs defines the base debuff definitions. +var DefaultDebuffs = map[DebuffType]Debuff{ + DebuffPoison: { + Type: DebuffPoison, Name: "Poison", + Duration: 5 * time.Second, Magnitude: 0.02, // -2% HP/sec + }, + DebuffFreeze: { + Type: DebuffFreeze, Name: "Freeze", + Duration: 3 * time.Second, Magnitude: 0.50, // -50% attack speed + }, + DebuffBurn: { + Type: DebuffBurn, Name: "Burn", + Duration: 4 * time.Second, Magnitude: 0.03, // -3% HP/sec + }, + DebuffStun: { + Type: DebuffStun, Name: "Stun", + Duration: 2 * time.Second, Magnitude: 1.0, // no attacks + }, + DebuffSlow: { + Type: DebuffSlow, Name: "Slow", + Duration: 4 * time.Second, Magnitude: 0.40, // -40% movement + }, + DebuffWeaken: { + Type: DebuffWeaken, Name: "Weaken", + Duration: 5 * time.Second, Magnitude: 0.30, // -30% hero outgoing damage + }, + DebuffIceSlow: { + Type: DebuffIceSlow, Name: "Ice Slow", + Duration: 4 * time.Second, Magnitude: 0.20, // -20% attack speed (Ice Guardian spec §4.2) + }, +} + +// RemoveBuffType returns buffs without any active entry of the given type (e.g. consume Resurrection on manual revive). +func RemoveBuffType(buff []ActiveBuff, remove BuffType) []ActiveBuff { + var out []ActiveBuff + for _, ab := range buff { + if ab.Buff.Type != remove { + out = append(out, ab) + } + } + return out +} diff --git a/backend/internal/model/buff_quota.go b/backend/internal/model/buff_quota.go new file mode 100644 index 0000000..c0f6fd1 --- /dev/null +++ b/backend/internal/model/buff_quota.go @@ -0,0 +1,186 @@ +package model + +import ( + "fmt" + "time" +) + +// FreeBuffActivationsPerPeriod is the legacy shared limit. Kept for backward compatibility. +const FreeBuffActivationsPerPeriod = 2 + +// BuffFreeChargesPerType defines the per-buff free charge limits per 24h window. +var BuffFreeChargesPerType = map[BuffType]int{ + BuffRush: 3, + BuffRage: 2, + BuffShield: 2, + BuffLuck: 1, + BuffResurrection: 1, + BuffHeal: 3, + BuffPowerPotion: 1, + BuffWarCry: 2, +} + +// ApplyBuffQuotaRollover refills free buff charges when the 24h window has passed. +// Returns true if the hero was mutated (caller may persist). +// Deprecated: kept for backward compat with the shared counter. New code should +// use GetBuffCharges / ConsumeBuffCharge which handle rollover inline. +func (h *Hero) ApplyBuffQuotaRollover(now time.Time) bool { + if h.SubscriptionActive { + return false + } + if h.BuffQuotaPeriodEnd == nil { + return false + } + changed := false + for now.After(*h.BuffQuotaPeriodEnd) { + h.BuffFreeChargesRemaining = FreeBuffActivationsPerPeriod + next := h.BuffQuotaPeriodEnd.Add(24 * time.Hour) + h.BuffQuotaPeriodEnd = &next + changed = true + } + return changed +} + +// GetBuffCharges returns the current charge state for a specific buff type, +// rolling over the 24h window if expired. +func (h *Hero) GetBuffCharges(bt BuffType, now time.Time) BuffChargeState { + if h.BuffCharges == nil { + h.BuffCharges = make(map[string]BuffChargeState) + } + + maxCharges := BuffFreeChargesPerType[bt] + if maxCharges == 0 { + maxCharges = FreeBuffActivationsPerPeriod // fallback + } + + state, exists := h.BuffCharges[string(bt)] + if !exists { + // First access for this buff type — initialize with full charges. + pe := now.Add(24 * time.Hour) + state = BuffChargeState{ + Remaining: maxCharges, + PeriodEnd: &pe, + } + h.BuffCharges[string(bt)] = state + return state + } + + // Roll over if the period has expired. + if state.PeriodEnd != nil && now.After(*state.PeriodEnd) { + for state.PeriodEnd != nil && now.After(*state.PeriodEnd) { + next := state.PeriodEnd.Add(24 * time.Hour) + state.PeriodEnd = &next + } + state.Remaining = maxCharges + h.BuffCharges[string(bt)] = state + } + + return state +} + +// ConsumeBuffCharge decrements one free charge for the specific buff type. +// Returns an error if no charges remain. +func (h *Hero) ConsumeBuffCharge(bt BuffType, now time.Time) error { + state := h.GetBuffCharges(bt, now) + + if state.Remaining <= 0 { + periodStr := "unknown" + if state.PeriodEnd != nil { + periodStr = state.PeriodEnd.Format(time.RFC3339) + } + return fmt.Errorf( + "no free %s charges left; next refresh at %s", + string(bt), periodStr, + ) + } + + state.Remaining-- + h.BuffCharges[string(bt)] = state + + // Keep legacy counter roughly in sync. + h.BuffFreeChargesRemaining-- + if h.BuffFreeChargesRemaining < 0 { + h.BuffFreeChargesRemaining = 0 + } + + return nil +} + +// RefundBuffCharge increments one charge back for the specific buff type. +func (h *Hero) RefundBuffCharge(bt BuffType) { + if h.BuffCharges == nil { + return + } + state, exists := h.BuffCharges[string(bt)] + if !exists { + return + } + maxCharges := BuffFreeChargesPerType[bt] + if maxCharges == 0 { + maxCharges = FreeBuffActivationsPerPeriod + } + state.Remaining++ + if state.Remaining > maxCharges { + state.Remaining = maxCharges + } + h.BuffCharges[string(bt)] = state + + // Keep legacy counter roughly in sync. + h.BuffFreeChargesRemaining++ +} + +// ResetBuffCharges resets charges to max. If bt is nil, resets ALL buff types. +// If bt is non-nil, resets only that buff type. +func (h *Hero) ResetBuffCharges(bt *BuffType, now time.Time) { + if h.BuffCharges == nil { + h.BuffCharges = make(map[string]BuffChargeState) + } + + pe := now.Add(24 * time.Hour) + + if bt != nil { + maxCharges := BuffFreeChargesPerType[*bt] + if maxCharges == 0 { + maxCharges = FreeBuffActivationsPerPeriod + } + h.BuffCharges[string(*bt)] = BuffChargeState{ + Remaining: maxCharges, + PeriodEnd: &pe, + } + return + } + + // Reset ALL buff types. + for buffType, maxCharges := range BuffFreeChargesPerType { + h.BuffCharges[string(buffType)] = BuffChargeState{ + Remaining: maxCharges, + PeriodEnd: &pe, + } + } + + // Also reset legacy counter. + h.BuffFreeChargesRemaining = FreeBuffActivationsPerPeriod + h.BuffQuotaPeriodEnd = &pe +} + +// EnsureBuffChargesPopulated initializes BuffCharges for all buff types if the map +// is empty. Returns true if the map was freshly populated (caller should persist). +func (h *Hero) EnsureBuffChargesPopulated(now time.Time) bool { + if h.BuffCharges == nil { + h.BuffCharges = make(map[string]BuffChargeState) + } + if len(h.BuffCharges) == 0 { + pe := now.Add(24 * time.Hour) + if h.BuffQuotaPeriodEnd != nil { + pe = *h.BuffQuotaPeriodEnd + } + for bt, maxCharges := range BuffFreeChargesPerType { + h.BuffCharges[string(bt)] = BuffChargeState{ + Remaining: maxCharges, + PeriodEnd: &pe, + } + } + return true + } + return false +} diff --git a/backend/internal/model/buff_quota_test.go b/backend/internal/model/buff_quota_test.go new file mode 100644 index 0000000..29f7a93 --- /dev/null +++ b/backend/internal/model/buff_quota_test.go @@ -0,0 +1,36 @@ +package model + +import ( + "testing" + "time" +) + +func TestApplyBuffQuotaRollover_RefillsWhenWindowPassed(t *testing.T) { + end := time.Date(2026, 3, 1, 12, 0, 0, 0, time.UTC) + h := &Hero{ + BuffFreeChargesRemaining: 0, + BuffQuotaPeriodEnd: &end, + } + now := end.Add(time.Hour) + if !h.ApplyBuffQuotaRollover(now) { + t.Fatal("expected rollover to mutate hero") + } + if h.BuffFreeChargesRemaining != FreeBuffActivationsPerPeriod { + t.Fatalf("charges: want %d, got %d", FreeBuffActivationsPerPeriod, h.BuffFreeChargesRemaining) + } + if !h.BuffQuotaPeriodEnd.After(end) { + t.Fatalf("expected period end to advance, got %v", h.BuffQuotaPeriodEnd) + } +} + +func TestApplyBuffQuotaRollover_NoOpWhenSubscribed(t *testing.T) { + end := time.Date(2026, 3, 1, 12, 0, 0, 0, time.UTC) + h := &Hero{ + SubscriptionActive: true, + BuffFreeChargesRemaining: 0, + BuffQuotaPeriodEnd: &end, + } + if h.ApplyBuffQuotaRollover(end.Add(48 * time.Hour)) { + t.Fatal("subscription should skip rollover") + } +} diff --git a/backend/internal/model/combat.go b/backend/internal/model/combat.go new file mode 100644 index 0000000..df4f164 --- /dev/null +++ b/backend/internal/model/combat.go @@ -0,0 +1,65 @@ +package model + +import "time" + +// GameState represents the hero's current activity state. +type GameState string + +const ( + StateWalking GameState = "walking" + StateFighting GameState = "fighting" + StateDead GameState = "dead" + StateResting GameState = "resting" // in town, resting + StateInTown GameState = "in_town" // in town, interacting with NPCs +) + +// CombatState holds the state of an active combat encounter. +type CombatState struct { + HeroID int64 `json:"heroId"` + Hero *Hero `json:"-"` // hero reference, not serialised to avoid circular refs + Enemy Enemy `json:"enemy"` + HeroNextAttack time.Time `json:"heroNextAttack"` + EnemyNextAttack time.Time `json:"enemyNextAttack"` + StartedAt time.Time `json:"startedAt"` + LastTickAt time.Time `json:"-"` // tracks previous tick for periodic effects +} + +// AttackEvent is a min-heap entry for scheduling attacks by next_attack_at. +type AttackEvent struct { + NextAttackAt time.Time `json:"nextAttackAt"` + IsHero bool `json:"isHero"` // true = hero attacks, false = enemy attacks + CombatID int64 `json:"combatId"` // reference to the combat session +} + +// AttackQueue implements container/heap.Interface for scheduling attacks. +type AttackQueue []*AttackEvent + +func (q AttackQueue) Len() int { return len(q) } +func (q AttackQueue) Less(i, j int) bool { return q[i].NextAttackAt.Before(q[j].NextAttackAt) } +func (q AttackQueue) Swap(i, j int) { q[i], q[j] = q[j], q[i] } + +func (q *AttackQueue) Push(x any) { + *q = append(*q, x.(*AttackEvent)) +} + +func (q *AttackQueue) Pop() any { + old := *q + n := len(old) + item := old[n-1] + old[n-1] = nil // avoid memory leak + *q = old[:n-1] + return item +} + +// CombatEvent is broadcast over WebSocket to clients observing combat. +type CombatEvent struct { + Type string `json:"type"` // "attack", "death", "buff_applied", "debuff_applied", "combat_start", "combat_end" + HeroID int64 `json:"heroId"` + Damage int `json:"damage,omitempty"` + Source string `json:"source"` // "hero" or "enemy" + IsCrit bool `json:"isCrit,omitempty"` + DebuffApplied string `json:"debuffApplied,omitempty"` // debuff type applied this event, if any + HeroHP int `json:"heroHp"` + EnemyHP int `json:"enemyHp"` + Timestamp time.Time `json:"timestamp"` +} diff --git a/backend/internal/model/daily_task.go b/backend/internal/model/daily_task.go new file mode 100644 index 0000000..918969c --- /dev/null +++ b/backend/internal/model/daily_task.go @@ -0,0 +1,32 @@ +package model + +import "time" + +// DailyTask defines a daily or weekly task template. +type DailyTask struct { + ID string `json:"id"` + Title string `json:"title"` + Description string `json:"description"` + ObjectiveType string `json:"objectiveType"` // kill_count, elite_kill, collect_gold, use_buff, reach_level + ObjectiveCount int `json:"objectiveCount"` + RewardType string `json:"rewardType"` // gold, potion + RewardAmount int `json:"rewardAmount"` + Period string `json:"period"` // daily, weekly +} + +// HeroDailyTask tracks a hero's progress on a daily/weekly task for a period. +type HeroDailyTask struct { + HeroID int64 `json:"heroId"` + TaskID string `json:"taskId"` + Progress int `json:"progress"` + Completed bool `json:"completed"` + Claimed bool `json:"claimed"` + PeriodStart time.Time `json:"periodStart"` + Task *DailyTask `json:"task,omitempty"` +} + +// DailyTaskReward holds the reward granted when claiming a daily/weekly task. +type DailyTaskReward struct { + RewardType string `json:"rewardType"` + RewardAmount int `json:"rewardAmount"` +} diff --git a/backend/internal/model/enemy.go b/backend/internal/model/enemy.go new file mode 100644 index 0000000..70a5593 --- /dev/null +++ b/backend/internal/model/enemy.go @@ -0,0 +1,167 @@ +package model + +type EnemyType string + +const ( + EnemyWolf EnemyType = "wolf" + EnemyBoar EnemyType = "boar" + EnemyZombie EnemyType = "zombie" + EnemySpider EnemyType = "spider" + EnemyOrc EnemyType = "orc" + EnemySkeletonArcher EnemyType = "skeleton_archer" + EnemyBattleLizard EnemyType = "battle_lizard" + EnemyFireDemon EnemyType = "fire_demon" + EnemyIceGuardian EnemyType = "ice_guardian" + EnemySkeletonKing EnemyType = "skeleton_king" + EnemyWaterElement EnemyType = "water_element" + EnemyForestWarden EnemyType = "forest_warden" + EnemyLightningTitan EnemyType = "lightning_titan" +) + +type SpecialAbility string + +const ( + AbilityBurn SpecialAbility = "burn" // DoT fire damage + AbilitySlow SpecialAbility = "slow" // -40% movement speed (Water Element) + AbilityCritical SpecialAbility = "critical" // chance for double damage + AbilityPoison SpecialAbility = "poison" // DoT poison damage + AbilityFreeze SpecialAbility = "freeze" // -50% attack speed (generic) + AbilityIceSlow SpecialAbility = "ice_slow" // -20% attack speed (Ice Guardian per spec) + AbilityStun SpecialAbility = "stun" // no attacks for 2 sec + AbilityDodge SpecialAbility = "dodge" // chance to avoid incoming damage + AbilityRegen SpecialAbility = "regen" // regenerate HP over time + AbilityBurst SpecialAbility = "burst" // every Nth attack deals multiplied damage + AbilityChainLightning SpecialAbility = "chain_lightning" // 3x damage after 5 attacks + AbilitySummon SpecialAbility = "summon" // summons minions +) + +type Enemy struct { + ID int64 `json:"id"` + Type EnemyType `json:"type"` + Name string `json:"name"` + HP int `json:"hp"` + MaxHP int `json:"maxHp"` + Attack int `json:"attack"` + Defense int `json:"defense"` + Speed float64 `json:"speed"` // attacks per second + CritChance float64 `json:"critChance"` // 0.0 to 1.0 + MinLevel int `json:"minLevel"` + MaxLevel int `json:"maxLevel"` + XPReward int64 `json:"xpReward"` + GoldReward int64 `json:"goldReward"` + SpecialAbilities []SpecialAbility `json:"specialAbilities,omitempty"` + IsElite bool `json:"isElite"` + AttackCount int `json:"-"` // tracks attacks for burst/chain abilities +} + +// IsAlive returns true if the enemy has HP remaining. +func (e *Enemy) IsAlive() bool { + return e.HP > 0 +} + +// HasAbility checks if the enemy possesses a given special ability. +func (e *Enemy) HasAbility(a SpecialAbility) bool { + for _, ab := range e.SpecialAbilities { + if ab == a { + return true + } + } + return false +} + +// EnemyTemplates defines base stats for each enemy type. +// These are used when spawning new enemies; actual instances may have scaled stats. +var EnemyTemplates = map[EnemyType]Enemy{ + // --- Basic enemies --- + EnemyWolf: { + Type: EnemyWolf, Name: "Forest Wolf", + MaxHP: 45, Attack: 9, Defense: 4, Speed: 1.8, CritChance: 0.05, + MinLevel: 1, MaxLevel: 5, + XPReward: 1, GoldReward: 1, + }, + EnemyBoar: { + Type: EnemyBoar, Name: "Wild Boar", + MaxHP: 65, Attack: 18, Defense: 7, Speed: 0.8, CritChance: 0.08, + MinLevel: 2, MaxLevel: 6, + XPReward: 1, GoldReward: 1, + }, + EnemyZombie: { + Type: EnemyZombie, Name: "Rotting Zombie", + MaxHP: 95, Attack: 16, Defense: 7, Speed: 0.5, + MinLevel: 3, MaxLevel: 8, + XPReward: 1, GoldReward: 1, + SpecialAbilities: []SpecialAbility{AbilityPoison}, + }, + EnemySpider: { + Type: EnemySpider, Name: "Cave Spider", + MaxHP: 38, Attack: 16, Defense: 3, Speed: 2.0, CritChance: 0.15, + MinLevel: 4, MaxLevel: 9, + XPReward: 1, GoldReward: 1, + SpecialAbilities: []SpecialAbility{AbilityCritical}, + }, + EnemyOrc: { + Type: EnemyOrc, Name: "Orc Warrior", + MaxHP: 110, Attack: 21, Defense: 12, Speed: 1.0, CritChance: 0.05, + MinLevel: 5, MaxLevel: 12, + XPReward: 1, GoldReward: 1, + SpecialAbilities: []SpecialAbility{AbilityBurst}, + }, + EnemySkeletonArcher: { + Type: EnemySkeletonArcher, Name: "Skeleton Archer", + MaxHP: 90, Attack: 24, Defense: 10, Speed: 1.3, CritChance: 0.06, + MinLevel: 6, MaxLevel: 14, + XPReward: 1, GoldReward: 1, + SpecialAbilities: []SpecialAbility{AbilityDodge}, + }, + EnemyBattleLizard: { + Type: EnemyBattleLizard, Name: "Battle Lizard", + MaxHP: 140, Attack: 24, Defense: 18, Speed: 0.7, CritChance: 0.03, + MinLevel: 7, MaxLevel: 15, + XPReward: 1, GoldReward: 1, + SpecialAbilities: []SpecialAbility{AbilityRegen}, + }, + + // --- Elite enemies --- + EnemyFireDemon: { + Type: EnemyFireDemon, Name: "Fire Demon", + MaxHP: 230, Attack: 34, Defense: 20, Speed: 1.2, CritChance: 0.10, + MinLevel: 10, MaxLevel: 20, + XPReward: 1, GoldReward: 1, IsElite: true, + SpecialAbilities: []SpecialAbility{AbilityBurn}, + }, + EnemyIceGuardian: { + Type: EnemyIceGuardian, Name: "Ice Guardian", + MaxHP: 280, Attack: 32, Defense: 28, Speed: 0.7, CritChance: 0.04, + MinLevel: 12, MaxLevel: 22, + XPReward: 1, GoldReward: 1, IsElite: true, + SpecialAbilities: []SpecialAbility{AbilityIceSlow}, + }, + EnemySkeletonKing: { + Type: EnemySkeletonKing, Name: "Skeleton King", + MaxHP: 420, Attack: 48, Defense: 30, Speed: 0.9, CritChance: 0.08, + MinLevel: 15, MaxLevel: 25, + XPReward: 1, GoldReward: 1, IsElite: true, + SpecialAbilities: []SpecialAbility{AbilityRegen, AbilitySummon}, + }, + EnemyWaterElement: { + Type: EnemyWaterElement, Name: "Water Element", + MaxHP: 520, Attack: 42, Defense: 24, Speed: 0.8, CritChance: 0.05, + MinLevel: 18, MaxLevel: 28, + XPReward: 2, GoldReward: 1, IsElite: true, + SpecialAbilities: []SpecialAbility{AbilitySlow}, + }, + EnemyForestWarden: { + Type: EnemyForestWarden, Name: "Forest Warden", + MaxHP: 700, Attack: 38, Defense: 40, Speed: 0.5, CritChance: 0.03, + MinLevel: 20, MaxLevel: 30, + XPReward: 2, GoldReward: 1, IsElite: true, + SpecialAbilities: []SpecialAbility{AbilityRegen}, + }, + EnemyLightningTitan: { + Type: EnemyLightningTitan, Name: "Lightning Titan", + MaxHP: 650, Attack: 56, Defense: 30, Speed: 1.5, CritChance: 0.12, + MinLevel: 25, MaxLevel: 35, + XPReward: 3, GoldReward: 2, IsElite: true, + SpecialAbilities: []SpecialAbility{AbilityStun, AbilityChainLightning}, + }, +} diff --git a/backend/internal/model/equipment.go b/backend/internal/model/equipment.go new file mode 100644 index 0000000..d6122d1 --- /dev/null +++ b/backend/internal/model/equipment.go @@ -0,0 +1,23 @@ +package model + +// EquipmentSlot identifies where an item is equipped. +type EquipmentSlot string + +const ( + SlotMainHand EquipmentSlot = "main_hand" + SlotChest EquipmentSlot = "chest" + SlotHead EquipmentSlot = "head" + SlotFeet EquipmentSlot = "feet" + SlotNeck EquipmentSlot = "neck" + SlotHands EquipmentSlot = "hands" + SlotLegs EquipmentSlot = "legs" + SlotCloak EquipmentSlot = "cloak" + SlotFinger EquipmentSlot = "finger" + SlotWrist EquipmentSlot = "wrist" +) + +// AllEquipmentSlots lists every slot that can hold gear. +var AllEquipmentSlots = []EquipmentSlot{ + SlotMainHand, SlotChest, SlotHead, SlotFeet, SlotNeck, + SlotHands, SlotLegs, SlotCloak, SlotFinger, SlotWrist, +} diff --git a/backend/internal/model/gear.go b/backend/internal/model/gear.go new file mode 100644 index 0000000..9919e3e --- /dev/null +++ b/backend/internal/model/gear.go @@ -0,0 +1,256 @@ +package model + +import "math/rand" + +// GearItem represents any equippable item across all slots. +type GearItem struct { + ID int64 `json:"id"` + Slot EquipmentSlot `json:"slot"` + FormID string `json:"formId"` + Name string `json:"name"` + Subtype string `json:"subtype"` + Rarity Rarity `json:"rarity"` + Ilvl int `json:"ilvl"` + BasePrimary int `json:"basePrimary"` + PrimaryStat int `json:"primaryStat"` + StatType string `json:"statType"` + SpeedModifier float64 `json:"speedModifier"` + CritChance float64 `json:"critChance"` + AgilityBonus int `json:"agilityBonus"` + SetName string `json:"setName,omitempty"` + SpecialEffect string `json:"specialEffect,omitempty"` +} + +// GearFamily is a template for generating gear drops from the unified catalog. +type GearFamily struct { + Slot EquipmentSlot + FormID string + Name string + Subtype string // "daggers", "sword", "axe", "light", "medium", "heavy", "" + BasePrimary int + StatType string + SpeedModifier float64 + BaseCrit float64 + AgilityBonus int + SetName string + SpecialEffect string +} + +// GearCatalog is the unified catalog of all gear families. +var GearCatalog []GearFamily + +// ArmorSetBonuses maps set names to their bonus description. +var GearSetBonuses = map[string]string{ + "Assassin's Set": "+crit_chance", + "Knight's Set": "+defense", + "Berserker's Set": "+attack", + "Ancient Guardian's Set": "+all_stats", +} + +func init() { + // Weapons -> main_hand + for _, w := range legacyWeapons { + GearCatalog = append(GearCatalog, GearFamily{ + Slot: SlotMainHand, + FormID: "gear.form.main_hand." + string(w.Type), + Name: w.Name, + Subtype: string(w.Type), + BasePrimary: w.Damage, + StatType: "attack", + SpeedModifier: w.Speed, + BaseCrit: w.CritChance, + SpecialEffect: w.SpecialEffect, + }) + } + + // Armors -> chest + for _, a := range legacyArmors { + GearCatalog = append(GearCatalog, GearFamily{ + Slot: SlotChest, + FormID: "gear.form.chest." + string(a.Type), + Name: a.Name, + Subtype: string(a.Type), + BasePrimary: a.Defense, + StatType: "defense", + SpeedModifier: a.SpeedModifier, + AgilityBonus: a.AgilityBonus, + SetName: a.SetName, + SpecialEffect: a.SpecialEffect, + }) + } + + // Extended equipment families -> head, feet, neck, hands, legs, cloak, finger, wrist + for slot, families := range legacyEquipmentFamilies { + for _, f := range families { + GearCatalog = append(GearCatalog, GearFamily{ + Slot: slot, + FormID: f.FormID, + Name: f.Name, + BasePrimary: f.BasePrimary, + StatType: f.StatType, + SpeedModifier: 1.0, + }) + } + } + + // Build the by-slot-and-rarity index. + gearBySlot = make(map[EquipmentSlot][]GearFamily) + for _, gf := range GearCatalog { + gearBySlot[gf.Slot] = append(gearBySlot[gf.Slot], gf) + } +} + +var gearBySlot map[EquipmentSlot][]GearFamily + +// PickGearFamily selects a random gear family for the given slot. +// Returns nil if no families exist for the slot. +func PickGearFamily(slot EquipmentSlot) *GearFamily { + families := gearBySlot[slot] + if len(families) == 0 { + return nil + } + f := families[rand.Intn(len(families))] + return &f +} + +// NewGearItem creates a GearItem from a family template with ilvl and rarity scaling applied. +func NewGearItem(family *GearFamily, ilvl int, rarity Rarity) *GearItem { + primary := ScalePrimary(family.BasePrimary, ilvl, rarity) + return &GearItem{ + Slot: family.Slot, + FormID: family.FormID, + Name: family.Name, + Subtype: family.Subtype, + Rarity: rarity, + Ilvl: ilvl, + BasePrimary: family.BasePrimary, + PrimaryStat: primary, + StatType: family.StatType, + SpeedModifier: family.SpeedModifier, + CritChance: family.BaseCrit, + AgilityBonus: family.AgilityBonus, + SetName: family.SetName, + SpecialEffect: family.SpecialEffect, + } +} + +// ---------- Legacy data (moved from weapon.go, armor.go, equipment.go) ---------- + +// legacyWeaponEntry holds weapon catalog data for building the GearCatalog. +type legacyWeaponEntry struct { + Name string + Type string + Rarity Rarity + Damage int + Speed float64 + CritChance float64 + SpecialEffect string +} + +var legacyWeapons = []legacyWeaponEntry{ + // Daggers + {Name: "Rusty Dagger", Type: "daggers", Rarity: RarityCommon, Damage: 3, Speed: 1.3, CritChance: 0.05}, + {Name: "Iron Dagger", Type: "daggers", Rarity: RarityUncommon, Damage: 5, Speed: 1.3, CritChance: 0.08}, + {Name: "Assassin's Blade", Type: "daggers", Rarity: RarityRare, Damage: 8, Speed: 1.35, CritChance: 0.20}, + {Name: "Phantom Edge", Type: "daggers", Rarity: RarityEpic, Damage: 12, Speed: 1.4, CritChance: 0.25}, + {Name: "Fang of the Void", Type: "daggers", Rarity: RarityLegendary, Damage: 18, Speed: 1.5, CritChance: 0.30}, + // Swords + {Name: "Iron Sword", Type: "sword", Rarity: RarityCommon, Damage: 7, Speed: 1.0, CritChance: 0.03}, + {Name: "Steel Sword", Type: "sword", Rarity: RarityUncommon, Damage: 10, Speed: 1.0, CritChance: 0.05}, + {Name: "Longsword", Type: "sword", Rarity: RarityRare, Damage: 15, Speed: 1.0, CritChance: 0.08}, + {Name: "Excalibur", Type: "sword", Rarity: RarityEpic, Damage: 22, Speed: 1.05, CritChance: 0.10}, + {Name: "Soul Reaver", Type: "sword", Rarity: RarityLegendary, Damage: 30, Speed: 1.1, CritChance: 0.12, SpecialEffect: "lifesteal"}, + // Axes + {Name: "Rusty Axe", Type: "axe", Rarity: RarityCommon, Damage: 12, Speed: 0.7, CritChance: 0.02}, + {Name: "Battle Axe", Type: "axe", Rarity: RarityUncommon, Damage: 18, Speed: 0.7, CritChance: 0.04}, + {Name: "War Axe", Type: "axe", Rarity: RarityRare, Damage: 25, Speed: 0.75, CritChance: 0.06}, + {Name: "Infernal Axe", Type: "axe", Rarity: RarityEpic, Damage: 35, Speed: 0.75, CritChance: 0.08}, + {Name: "Godslayer's Edge", Type: "axe", Rarity: RarityLegendary, Damage: 50, Speed: 0.8, CritChance: 0.10, SpecialEffect: "splash"}, +} + +// legacyArmorEntry holds armor catalog data for building the GearCatalog. +type legacyArmorEntry struct { + Name string + Type string + Rarity Rarity + Defense int + SpeedModifier float64 + AgilityBonus int + SetName string + SpecialEffect string +} + +var legacyArmors = []legacyArmorEntry{ + // Light armor + {Name: "Leather Armor", Type: "light", Rarity: RarityCommon, Defense: 3, SpeedModifier: 1.05, AgilityBonus: 3}, + {Name: "Ranger's Vest", Type: "light", Rarity: RarityUncommon, Defense: 5, SpeedModifier: 1.08, AgilityBonus: 5}, + {Name: "Shadow Cloak", Type: "light", Rarity: RarityRare, Defense: 8, SpeedModifier: 1.10, AgilityBonus: 8, SetName: "Assassin's Set", SpecialEffect: "crit_bonus"}, + {Name: "Phantom Garb", Type: "light", Rarity: RarityEpic, Defense: 12, SpeedModifier: 1.12, AgilityBonus: 12, SetName: "Assassin's Set", SpecialEffect: "crit_bonus"}, + {Name: "Whisper of the Void", Type: "light", Rarity: RarityLegendary, Defense: 16, SpeedModifier: 1.15, AgilityBonus: 18, SetName: "Assassin's Set", SpecialEffect: "crit_bonus"}, + // Medium armor + {Name: "Chainmail", Type: "medium", Rarity: RarityCommon, Defense: 7, SpeedModifier: 1.0}, + {Name: "Reinforced Mail", Type: "medium", Rarity: RarityUncommon, Defense: 10, SpeedModifier: 1.0}, + {Name: "Battle Armor", Type: "medium", Rarity: RarityRare, Defense: 15, SpeedModifier: 1.0, SetName: "Knight's Set", SpecialEffect: "def_bonus"}, + {Name: "Royal Guard", Type: "medium", Rarity: RarityEpic, Defense: 22, SpeedModifier: 1.0, SetName: "Knight's Set", SpecialEffect: "def_bonus"}, + {Name: "Crown of Eternity", Type: "medium", Rarity: RarityLegendary, Defense: 30, SpeedModifier: 1.0, SetName: "Knight's Set", SpecialEffect: "def_bonus"}, + // Heavy armor + {Name: "Iron Plate", Type: "heavy", Rarity: RarityCommon, Defense: 14, SpeedModifier: 0.7, AgilityBonus: -3}, + {Name: "Steel Plate", Type: "heavy", Rarity: RarityUncommon, Defense: 20, SpeedModifier: 0.7, AgilityBonus: -3}, + {Name: "Fortress Armor", Type: "heavy", Rarity: RarityRare, Defense: 28, SpeedModifier: 0.7, AgilityBonus: -5, SetName: "Berserker's Set", SpecialEffect: "atk_bonus"}, + {Name: "Dragon Scale", Type: "heavy", Rarity: RarityEpic, Defense: 38, SpeedModifier: 0.7, AgilityBonus: -5, SetName: "Berserker's Set", SpecialEffect: "atk_bonus"}, + {Name: "Dragon Slayer", Type: "heavy", Rarity: RarityLegendary, Defense: 50, SpeedModifier: 0.7, AgilityBonus: -5, SetName: "Berserker's Set", SpecialEffect: "atk_bonus"}, + // Ancient Guardian's Set + {Name: "Guardian's Plate", Type: "heavy", Rarity: RarityRare, Defense: 30, SpeedModifier: 0.7, AgilityBonus: 2, SetName: "Ancient Guardian's Set", SpecialEffect: "all_stats"}, + {Name: "Guardian's Bastion", Type: "heavy", Rarity: RarityEpic, Defense: 42, SpeedModifier: 0.7, AgilityBonus: 4, SetName: "Ancient Guardian's Set", SpecialEffect: "all_stats"}, + {Name: "Ancient Guardian's Aegis", Type: "heavy", Rarity: RarityLegendary, Defense: 55, SpeedModifier: 0.7, AgilityBonus: 6, SetName: "Ancient Guardian's Set", SpecialEffect: "all_stats"}, +} + +// legacyEquipmentFamily is the template used by the old equipment system. +type legacyEquipmentFamily struct { + Name string + FormID string + BasePrimary int + StatType string +} + +var legacyEquipmentFamilies = map[EquipmentSlot][]legacyEquipmentFamily{ + SlotHead: { + {Name: "Leather Cap", FormID: "gear.form.head.cap", BasePrimary: 2, StatType: "defense"}, + {Name: "Iron Helmet", FormID: "gear.form.head.helmet", BasePrimary: 4, StatType: "defense"}, + {Name: "Crown", FormID: "gear.form.head.crown", BasePrimary: 3, StatType: "mixed"}, + }, + SlotFeet: { + {Name: "Sandals", FormID: "gear.form.feet.sandals", BasePrimary: 1, StatType: "speed"}, + {Name: "Leather Boots", FormID: "gear.form.feet.boots", BasePrimary: 3, StatType: "defense"}, + {Name: "Iron Greaves", FormID: "gear.form.feet.greaves", BasePrimary: 5, StatType: "defense"}, + }, + SlotNeck: { + {Name: "Wooden Pendant", FormID: "gear.form.neck.pendant", BasePrimary: 2, StatType: "mixed"}, + {Name: "Silver Amulet", FormID: "gear.form.neck.amulet", BasePrimary: 4, StatType: "attack"}, + {Name: "Crystal Necklace", FormID: "gear.form.neck.necklace", BasePrimary: 3, StatType: "defense"}, + }, + SlotHands: { + {Name: "Leather Gloves", FormID: "gear.form.hands.gloves", BasePrimary: 2, StatType: "defense"}, + {Name: "Iron Gauntlets", FormID: "gear.form.hands.gauntlets", BasePrimary: 4, StatType: "defense"}, + {Name: "Dragonhide Gloves", FormID: "gear.form.hands.gloves", BasePrimary: 3, StatType: "mixed"}, + }, + SlotLegs: { + {Name: "Leather Leggings", FormID: "gear.form.legs.leggings", BasePrimary: 2, StatType: "defense"}, + {Name: "Iron Greaves", FormID: "gear.form.legs.greaves", BasePrimary: 4, StatType: "defense"}, + }, + SlotCloak: { + {Name: "Leather Cloak", FormID: "gear.form.cloak.cloak", BasePrimary: 2, StatType: "defense"}, + {Name: "Iron Cape", FormID: "gear.form.cloak.cape", BasePrimary: 4, StatType: "defense"}, + {Name: "Dragonhide Cloak", FormID: "gear.form.cloak.cloak", BasePrimary: 3, StatType: "mixed"}, + }, + SlotFinger: { + {Name: "Wooden Ring", FormID: "gear.form.finger.ring", BasePrimary: 2, StatType: "mixed"}, + {Name: "Silver Ring", FormID: "gear.form.finger.ring", BasePrimary: 4, StatType: "attack"}, + {Name: "Crystal Ring", FormID: "gear.form.finger.ring", BasePrimary: 3, StatType: "defense"}, + }, + SlotWrist: { + {Name: "Leather Bracers", FormID: "gear.form.wrist.bracers", BasePrimary: 2, StatType: "defense"}, + {Name: "Iron Wristguards", FormID: "gear.form.wrist.wristguards", BasePrimary: 4, StatType: "defense"}, + {Name: "Dragonhide Wristguards", FormID: "gear.form.wrist.wristguards", BasePrimary: 3, StatType: "mixed"}, + }, +} diff --git a/backend/internal/model/hero.go b/backend/internal/model/hero.go new file mode 100644 index 0000000..1b38e2a --- /dev/null +++ b/backend/internal/model/hero.go @@ -0,0 +1,350 @@ +package model + +import ( + "math" + "time" +) + +const ( + // AgilityCoef follows the project combat specification (agility contribution to APS). + AgilityCoef = 0.03 + // MaxAttackSpeed enforces the target cap of ~4 attacks/sec. + MaxAttackSpeed = 4.0 +) + +type Hero struct { + ID int64 `json:"id"` + TelegramID int64 `json:"telegramId"` + Name string `json:"name"` + HP int `json:"hp"` + MaxHP int `json:"maxHp"` + Attack int `json:"attack"` + Defense int `json:"defense"` + Speed float64 `json:"speed"` // attacks per second base rate + Strength int `json:"strength"` + Constitution int `json:"constitution"` + Agility int `json:"agility"` + Luck int `json:"luck"` + State GameState `json:"state"` + WeaponID *int64 `json:"weaponId,omitempty"` // Deprecated: kept for DB backward compat + ArmorID *int64 `json:"armorId,omitempty"` // Deprecated: kept for DB backward compat + Gear map[EquipmentSlot]*GearItem `json:"gear"` + Buffs []ActiveBuff `json:"buffs,omitempty"` + Debuffs []ActiveDebuff `json:"debuffs,omitempty"` + Gold int64 `json:"gold"` + XP int64 `json:"xp"` + Level int `json:"level"` + XPToNext int64 `json:"xpToNext"` + AttackSpeed float64 `json:"attackSpeed,omitempty"` + AttackPower int `json:"attackPower,omitempty"` + DefensePower int `json:"defensePower,omitempty"` + MoveSpeed float64 `json:"moveSpeed,omitempty"` + PositionX float64 `json:"positionX"` + PositionY float64 `json:"positionY"` + Potions int `json:"potions"` + ReviveCount int `json:"reviveCount"` + SubscriptionActive bool `json:"subscriptionActive"` + // Deprecated: BuffFreeChargesRemaining is the legacy shared counter. Use BuffCharges instead. + BuffFreeChargesRemaining int `json:"buffFreeChargesRemaining"` + // Deprecated: BuffQuotaPeriodEnd is the legacy shared period end. Use BuffCharges instead. + BuffQuotaPeriodEnd *time.Time `json:"buffQuotaPeriodEnd,omitempty"` + // BuffCharges holds per-buff-type free charge state (remaining count + period window). + BuffCharges map[string]BuffChargeState `json:"buffCharges"` + // Stat tracking for achievements. + TotalKills int `json:"totalKills"` + EliteKills int `json:"eliteKills"` + TotalDeaths int `json:"totalDeaths"` + KillsSinceDeath int `json:"killsSinceDeath"` + LegendaryDrops int `json:"legendaryDrops"` + + // Movement state (persisted to DB for reconnect recovery). + CurrentTownID *int64 `json:"currentTownId,omitempty"` + DestinationTownID *int64 `json:"destinationTownId,omitempty"` + MoveState string `json:"moveState"` + + LastOnlineAt *time.Time `json:"lastOnlineAt,omitempty"` + CreatedAt time.Time `json:"createdAt"` + UpdatedAt time.Time `json:"updatedAt"` +} + +// BuffChargeState tracks the remaining free charges and period window for a single buff type. +type BuffChargeState struct { + Remaining int `json:"remaining"` + PeriodEnd *time.Time `json:"periodEnd,omitempty"` +} + +// XPToNextLevel returns the XP delta required to advance from the given level +// to level+1. Phase-based curve (spec §9) — v3 scales bases ×10 vs v2 for ~10× +// slower leveling when paired with reduced kill XP: +// +// L 1–9: round(180 * 1.28^(L-1)) +// L 10–29: round(1450 * 1.15^(L-10)) +// L 30+: round(23000 * 1.10^(L-30)) +func XPToNextLevel(level int) int64 { + if level < 1 { + level = 1 + } + switch { + case level <= 9: + return int64(math.Round(180 * math.Pow(1.28, float64(level-1)))) + case level <= 29: + return int64(math.Round(1450 * math.Pow(1.15, float64(level-10)))) + default: + return int64(math.Round(23000 * math.Pow(1.10, float64(level-30)))) + } +} + +// CanLevelUp returns true if the hero has enough XP to advance to the next level. +func (h *Hero) CanLevelUp() bool { + return h.XP >= XPToNextLevel(h.Level) +} + +// LevelUp advances the hero to the next level, deducts the required XP, and +// applies stat growth. HP is NOT restored on level-up (spec §3.3). +// Returns true if the hero leveled up, false if insufficient XP. +func (h *Hero) LevelUp() bool { + if !h.CanLevelUp() { + return false + } + + h.XP -= XPToNextLevel(h.Level) + h.Level++ + + // v3: ~10× rarer than v2 — same formulas, cadences ×10 (spec §3.3). + if h.Level%10 == 0 { + h.MaxHP += 1 + h.Constitution/6 + } + if h.Level%30 == 0 { + h.Attack++ + } + if h.Level%30 == 0 { + h.Defense++ + } + + if h.Level%40 == 0 { + h.Strength++ + } + if h.Level%50 == 0 { + h.Constitution++ + } + if h.Level%60 == 0 { + h.Agility++ + } + if h.Level%100 == 0 { + h.Luck++ + } + + return true +} + +type statBonuses struct { + strengthBonus int + constitutionBonus int + agilityBonus int + attackMultiplier float64 + speedMultiplier float64 + defenseMultiplier float64 + critChanceBonus float64 + critDamageBonus float64 + blockChanceBonus float64 + movementMultiplier float64 +} + +func (h *Hero) activeStatBonuses(now time.Time) statBonuses { + out := statBonuses{ + strengthBonus: 0, + constitutionBonus: 0, + agilityBonus: 0, + attackMultiplier: 1.0, + speedMultiplier: 1.0, + defenseMultiplier: 1.0, + critChanceBonus: 0.0, + critDamageBonus: 0.0, + blockChanceBonus: 0.0, + movementMultiplier: 1.0, + } + for _, ab := range h.Buffs { + if ab.IsExpired(now) { + continue + } + switch ab.Buff.Type { + case BuffRush: + out.movementMultiplier *= (1 + ab.Buff.Magnitude) + case BuffRage: + out.attackMultiplier *= (1 + ab.Buff.Magnitude) + out.strengthBonus += 10 + case BuffPowerPotion: + out.attackMultiplier *= (1 + ab.Buff.Magnitude) + out.strengthBonus += 12 + case BuffWarCry: + out.speedMultiplier *= (1 + ab.Buff.Magnitude) + out.strengthBonus += 6 + out.agilityBonus += 6 + case BuffShield: + out.constitutionBonus += 10 + out.defenseMultiplier *= (1 + ab.Buff.Magnitude) + } + } + return out +} + +// EffectiveSpeed returns the hero's attack speed after weapon, armor, buff, and debuff modifiers. +func (h *Hero) EffectiveSpeed() float64 { + return h.EffectiveSpeedAt(time.Now()) +} + +func (h *Hero) EffectiveSpeedAt(now time.Time) float64 { + bonuses := h.activeStatBonuses(now) + effectiveAgility := h.Agility + bonuses.agilityBonus + if chest := h.Gear[SlotChest]; chest != nil { + effectiveAgility += chest.AgilityBonus + } + + // Base attack speed derives from base speed + agility coefficient. + speed := h.Speed + float64(effectiveAgility)*AgilityCoef + if speed < 0.1 { + speed = 0.1 + } + if weapon := h.Gear[SlotMainHand]; weapon != nil { + speed *= weapon.SpeedModifier + } + if chest := h.Gear[SlotChest]; chest != nil { + speed *= chest.SpeedModifier + } + speed *= bonuses.speedMultiplier + // Apply debuffs that reduce attack speed. + // Slow is movement-only per spec §7.2 and does not affect attack speed. + for _, ad := range h.Debuffs { + if ad.IsExpired(now) { + continue + } + switch ad.Debuff.Type { + case DebuffFreeze: + speed *= (1 - ad.Debuff.Magnitude) // -50% attack speed + case DebuffIceSlow: + speed *= (1 - ad.Debuff.Magnitude) // -20% attack speed (Ice Guardian) + } + } + if speed > MaxAttackSpeed { + speed = MaxAttackSpeed + } + if speed < 0.1 { + speed = 0.1 + } + return speed +} + +// EffectiveAttack returns the hero's attack after weapon, buff, and debuff modifiers. +func (h *Hero) EffectiveAttack() int { + return h.EffectiveAttackAt(time.Now()) +} + +func (h *Hero) EffectiveAttackAt(now time.Time) int { + bonuses := h.activeStatBonuses(now) + effectiveStrength := h.Strength + bonuses.strengthBonus + effectiveAgility := h.Agility + bonuses.agilityBonus + effectiveConstitution := h.Constitution + bonuses.constitutionBonus + if chest := h.Gear[SlotChest]; chest != nil { + effectiveAgility += chest.AgilityBonus + } + + atk := h.Attack + effectiveStrength*2 + effectiveAgility/4 + effectiveConstitution/8 + if weapon := h.Gear[SlotMainHand]; weapon != nil { + atk += weapon.PrimaryStat + } + atkF := float64(atk) + atkF *= bonuses.attackMultiplier + // Apply weaken debuff. + for _, ad := range h.Debuffs { + if ad.IsExpired(now) { + continue + } + if ad.Debuff.Type == DebuffWeaken { + atkF *= (1 - ad.Debuff.Magnitude) // -30% outgoing damage + } + } + if atkF < 1 { + atkF = 1 + } + return int(atkF) +} + +// EffectiveDefense returns the hero's defense after armor and buff modifiers. +func (h *Hero) EffectiveDefense() int { + return h.EffectiveDefenseAt(time.Now()) +} + +func (h *Hero) EffectiveDefenseAt(now time.Time) int { + bonuses := h.activeStatBonuses(now) + effectiveConstitution := h.Constitution + bonuses.constitutionBonus + effectiveAgility := h.Agility + bonuses.agilityBonus + if chest := h.Gear[SlotChest]; chest != nil { + effectiveAgility += chest.AgilityBonus + } + + def := h.Defense + effectiveConstitution/4 + effectiveAgility/8 + if chest := h.Gear[SlotChest]; chest != nil { + def += chest.PrimaryStat + } + def = int(float64(def) * bonuses.defenseMultiplier) + if def < 0 { + def = 0 + } + return def +} + +// MovementSpeedMultiplier returns the hero's movement speed modifier (1.0 = normal). +// Rush buff and Slow debuff affect movement, not attack speed, per spec §7. +func (h *Hero) MovementSpeedMultiplier(now time.Time) float64 { + mult := 1.0 + for _, ab := range h.Buffs { + if ab.IsExpired(now) { + continue + } + if ab.Buff.Type == BuffRush { + mult *= (1 + ab.Buff.Magnitude) // +50% movement + } + } + for _, ad := range h.Debuffs { + if ad.IsExpired(now) { + continue + } + if ad.Debuff.Type == DebuffSlow { + mult *= (1 - ad.Debuff.Magnitude) // -40% movement + } + } + if mult < 0.1 { + mult = 0.1 + } + return mult +} + +// RefreshDerivedCombatStats updates exported derived combat fields for API/state usage. +func (h *Hero) RefreshDerivedCombatStats(now time.Time) { + h.XPToNext = XPToNextLevel(h.Level) + h.AttackSpeed = h.EffectiveSpeedAt(now) + h.AttackPower = h.EffectiveAttackAt(now) + h.DefensePower = h.EffectiveDefenseAt(now) + h.MoveSpeed = h.MovementSpeedMultiplier(now) +} + +// CombatRatingAt computes a single-number combat effectiveness score used by +// the auto-equip system to decide whether new gear is an upgrade. +func (h *Hero) CombatRatingAt(now time.Time) float64 { + return float64(h.EffectiveAttackAt(now))*h.EffectiveSpeedAt(now) + float64(h.EffectiveDefenseAt(now))*0.35 +} + +// IsAlive returns true if the hero has HP remaining. +func (h *Hero) IsAlive() bool { + return h.HP > 0 +} + +// IsStunned returns true if the hero currently has an active stun debuff. +func (h *Hero) IsStunned(now time.Time) bool { + for _, ad := range h.Debuffs { + if ad.Debuff.Type == DebuffStun && !ad.IsExpired(now) { + return true + } + } + return false +} diff --git a/backend/internal/model/hero_test.go b/backend/internal/model/hero_test.go new file mode 100644 index 0000000..21caa8f --- /dev/null +++ b/backend/internal/model/hero_test.go @@ -0,0 +1,315 @@ +package model + +import ( + "math" + "testing" + "time" +) + +func TestDerivedCombatStatsFromBaseAttributes(t *testing.T) { + now := time.Now() + hero := &Hero{ + Attack: 10, + Defense: 5, + Speed: 1.0, + Strength: 10, + Constitution: 8, + Agility: 6, + Gear: map[EquipmentSlot]*GearItem{ + SlotMainHand: { + PrimaryStat: 5, + SpeedModifier: 1.3, + }, + SlotChest: { + PrimaryStat: 4, + SpeedModifier: 0.7, + AgilityBonus: -3, + }, + }, + } + + gotAttack := hero.EffectiveAttackAt(now) + // atk = 10 + 10*2 + 3/4 + 8/8 = 31 + weapon.PrimaryStat(5) = 36 + if gotAttack != 36 { + t.Fatalf("expected attack 36, got %d", gotAttack) + } + + gotDefense := hero.EffectiveDefenseAt(now) + // def = 5 + 8/4 + 3/8 = 7 + chest.PrimaryStat(4) = 11 + if gotDefense != 11 { + t.Fatalf("expected defense 11, got %d", gotDefense) + } + + gotSpeed := hero.EffectiveSpeedAt(now) + wantSpeed := (1.0 + 3*AgilityCoef) * 1.3 * 0.7 + if math.Abs(gotSpeed-wantSpeed) > 0.001 { + t.Fatalf("expected speed %.3f, got %.3f", wantSpeed, gotSpeed) + } +} + +func TestBuffsProvideTemporaryStatEffects(t *testing.T) { + now := time.Now() + hero := &Hero{ + Attack: 10, + Defense: 5, + Speed: 1.0, + Strength: 10, + Constitution: 8, + Agility: 6, + Buffs: []ActiveBuff{ + { + Buff: DefaultBuffs[BuffRage], + AppliedAt: now.Add(-time.Second), + ExpiresAt: now.Add(5 * time.Second), + }, + { + Buff: DefaultBuffs[BuffWarCry], + AppliedAt: now.Add(-time.Second), + ExpiresAt: now.Add(5 * time.Second), + }, + { + Buff: DefaultBuffs[BuffShield], + AppliedAt: now.Add(-time.Second), + ExpiresAt: now.Add(5 * time.Second), + }, + }, + } + + if hero.EffectiveAttackAt(now) <= 30 { + t.Fatalf("expected buffed attack to increase above baseline") + } + if hero.EffectiveDefenseAt(now) <= 5 { + t.Fatalf("expected shield constitution bonus to increase defense") + } + if hero.EffectiveSpeedAt(now) <= 1.0 { + t.Fatalf("expected war cry to increase attack speed") + } +} + +func TestEffectiveSpeedIsCapped(t *testing.T) { + now := time.Now() + hero := &Hero{ + Speed: 2.5, + Agility: 200, + Gear: map[EquipmentSlot]*GearItem{ + SlotMainHand: {SpeedModifier: 1.5}, + }, + Buffs: []ActiveBuff{ + { + Buff: DefaultBuffs[BuffWarCry], + AppliedAt: now.Add(-time.Second), + ExpiresAt: now.Add(10 * time.Second), + }, + }, + } + + got := hero.EffectiveSpeedAt(now) + if got != MaxAttackSpeed { + t.Fatalf("expected speed cap %.1f, got %.3f", MaxAttackSpeed, got) + } +} + +func TestRushDoesNotAffectAttackSpeed(t *testing.T) { + now := time.Now() + hero := &Hero{Speed: 1.0, Agility: 5} + + baseSpeed := hero.EffectiveSpeedAt(now) + + hero.Buffs = []ActiveBuff{{ + Buff: DefaultBuffs[BuffRush], + AppliedAt: now.Add(-time.Second), + ExpiresAt: now.Add(5 * time.Second), + }} + buffedSpeed := hero.EffectiveSpeedAt(now) + + if math.Abs(buffedSpeed-baseSpeed) > 0.001 { + t.Fatalf("Rush should not affect attack speed: base=%.3f, buffed=%.3f", baseSpeed, buffedSpeed) + } +} + +func TestRushAffectsMovementSpeed(t *testing.T) { + now := time.Now() + hero := &Hero{Speed: 1.0, Agility: 5} + + baseMoveSpeed := hero.MovementSpeedMultiplier(now) + if baseMoveSpeed != 1.0 { + t.Fatalf("expected base movement multiplier 1.0, got %.3f", baseMoveSpeed) + } + + hero.Buffs = []ActiveBuff{{ + Buff: DefaultBuffs[BuffRush], + AppliedAt: now.Add(-time.Second), + ExpiresAt: now.Add(5 * time.Second), + }} + + got := hero.MovementSpeedMultiplier(now) + want := 1.5 + if math.Abs(got-want) > 0.001 { + t.Fatalf("expected Rush to give movement multiplier %.1f, got %.3f", want, got) + } +} + +func TestSlowDoesNotAffectAttackSpeed(t *testing.T) { + now := time.Now() + hero := &Hero{Speed: 1.0, Agility: 5} + + baseSpeed := hero.EffectiveSpeedAt(now) + + hero.Debuffs = []ActiveDebuff{{ + Debuff: DefaultDebuffs[DebuffSlow], + AppliedAt: now.Add(-time.Second), + ExpiresAt: now.Add(3 * time.Second), + }} + debuffedSpeed := hero.EffectiveSpeedAt(now) + + if math.Abs(debuffedSpeed-baseSpeed) > 0.001 { + t.Fatalf("Slow should not affect attack speed: base=%.3f, debuffed=%.3f", baseSpeed, debuffedSpeed) + } +} + +func TestSlowAffectsMovementSpeed(t *testing.T) { + now := time.Now() + hero := &Hero{Speed: 1.0, Agility: 5} + + hero.Debuffs = []ActiveDebuff{{ + Debuff: DefaultDebuffs[DebuffSlow], + AppliedAt: now.Add(-time.Second), + ExpiresAt: now.Add(3 * time.Second), + }} + + got := hero.MovementSpeedMultiplier(now) + want := 0.6 // 1.0 * (1 - 0.4) + if math.Abs(got-want) > 0.001 { + t.Fatalf("expected Slow to give movement multiplier %.1f, got %.3f", want, got) + } +} + +func TestIceSlowReducesAttackSpeed(t *testing.T) { + now := time.Now() + hero := &Hero{Speed: 1.0, Agility: 5} + + baseSpeed := hero.EffectiveSpeedAt(now) + + hero.Debuffs = []ActiveDebuff{{ + Debuff: DefaultDebuffs[DebuffIceSlow], + AppliedAt: now.Add(-time.Second), + ExpiresAt: now.Add(3 * time.Second), + }} + debuffedSpeed := hero.EffectiveSpeedAt(now) + + want := baseSpeed * 0.8 + if math.Abs(debuffedSpeed-want) > 0.01 { + t.Fatalf("IceSlow should reduce attack speed by 20%%: expected %.3f, got %.3f", want, debuffedSpeed) + } +} + +func TestLevelUpParity(t *testing.T) { + hero1 := &Hero{ + Level: 1, XP: 500, + MaxHP: 100, HP: 100, + Attack: 10, Defense: 5, Speed: 1.0, + Strength: 5, Constitution: 5, Agility: 5, Luck: 5, + } + hero2 := *hero1 + + // Level up hero1 via LevelUp() + levels1 := 0 + for hero1.LevelUp() { + levels1++ + } + + // Level up hero2 via LevelUp() too (should be identical since both use same method) + levels2 := 0 + for hero2.LevelUp() { + levels2++ + } + + if levels1 != levels2 { + t.Fatalf("expected same levels gained: %d vs %d", levels1, levels2) + } + if hero1.Level != hero2.Level || hero1.MaxHP != hero2.MaxHP || + hero1.Attack != hero2.Attack || hero1.Defense != hero2.Defense { + t.Fatalf("heroes diverged after identical LevelUp calls") + } +} + +// v3 progression: XP bases ×10 vs v2; secondary-stat cadences ×10 (3→30, 4→40, …). +func TestProgressionV3CanonicalSnapshots(t *testing.T) { + now := time.Now() + snap := func(targetLevel int) *Hero { + h := &Hero{ + Level: 1, XP: 0, + MaxHP: 100, HP: 100, + Attack: 10, Defense: 5, Speed: 1.0, + Strength: 1, Constitution: 1, Agility: 1, Luck: 1, + } + for h.Level < targetLevel { + h.XP += XPToNextLevel(h.Level) + if !h.LevelUp() { + t.Fatalf("expected level-up before reaching target level %d", targetLevel) + } + } + h.RefreshDerivedCombatStats(now) + return h + } + + t.Run("L30", func(t *testing.T) { + h := snap(30) + if h.MaxHP != 103 || h.Attack != 11 || h.Defense != 6 || h.Strength != 1 { + t.Fatalf("L30 snapshot: maxHp=%d atk=%d def=%d str=%d", h.MaxHP, h.Attack, h.Defense, h.Strength) + } + if h.EffectiveAttackAt(now) != 13 || h.EffectiveDefenseAt(now) != 6 { + t.Fatalf("L30 derived: atkPow=%d defPow=%d", h.EffectiveAttackAt(now), h.EffectiveDefenseAt(now)) + } + }) + t.Run("L45", func(t *testing.T) { + h := snap(45) + if h.MaxHP != 104 || h.Attack != 11 || h.Defense != 6 || h.Strength != 2 { + t.Fatalf("L45 snapshot: maxHp=%d atk=%d def=%d str=%d", h.MaxHP, h.Attack, h.Defense, h.Strength) + } + if h.EffectiveAttackAt(now) != 15 || h.EffectiveDefenseAt(now) != 6 { + t.Fatalf("L45 derived: atkPow=%d defPow=%d", h.EffectiveAttackAt(now), h.EffectiveDefenseAt(now)) + } + }) +} + +func TestXPToNextLevelFormula(t *testing.T) { + if got := XPToNextLevel(1); got != 180 { + t.Fatalf("XPToNextLevel(1) = %d, want 180", got) + } + if got := XPToNextLevel(2); got != 230 { + t.Fatalf("XPToNextLevel(2) = %d, want 230", got) + } + if got := XPToNextLevel(10); got != 1450 { + t.Fatalf("XPToNextLevel(10) = %d, want 1450", got) + } + if got := XPToNextLevel(30); got != 23000 { + t.Fatalf("XPToNextLevel(30) = %d, want 23000", got) + } +} + +func TestLevelUpDoesNotRestoreHP(t *testing.T) { + hero := &Hero{ + Level: 1, + XP: 200, + HP: 40, + MaxHP: 100, + Attack: 10, + Defense: 5, + Speed: 1.0, + Strength: 5, + Constitution: 5, + Agility: 5, + Luck: 5, + } + + if !hero.LevelUp() { + t.Fatal("expected hero to level up") + } + if hero.HP == hero.MaxHP { + t.Fatalf("level-up should NOT restore HP (spec §3.3): hp=%d max=%d", hero.HP, hero.MaxHP) + } + if hero.HP != 40 { + t.Fatalf("HP should be unchanged after level-up: got %d, want 40", hero.HP) + } +} diff --git a/backend/internal/model/item_scaling.go b/backend/internal/model/item_scaling.go new file mode 100644 index 0000000..96876d1 --- /dev/null +++ b/backend/internal/model/item_scaling.go @@ -0,0 +1,63 @@ +package model + +import ( + "math" + "math/rand" +) + +// IlvlFactor returns L(ilvl) = 1 + 0.03 * max(0, ilvl - 1) per spec section 6.4. +func IlvlFactor(ilvl int) float64 { + d := ilvl - 1 + if d < 0 { + d = 0 + } + return 1.0 + 0.03*float64(d) +} + +// RarityMultiplier returns M(rarity) per spec section 6.4.2. +func RarityMultiplier(rarity Rarity) float64 { + switch rarity { + case RarityCommon: + return 1.00 + case RarityUncommon: + return 1.12 + case RarityRare: + return 1.30 + case RarityEpic: + return 1.52 + case RarityLegendary: + return 1.78 + default: + return 1.00 + } +} + +// ScalePrimary computes primaryOut = round(basePrimary * L(ilvl) * M(rarity)). +func ScalePrimary(basePrimary int, ilvl int, rarity Rarity) int { + return int(math.Round(float64(basePrimary) * IlvlFactor(ilvl) * RarityMultiplier(rarity))) +} + +// RollIlvl generates an item level from the monster level per spec section 6.4.5. +// Base enemies: delta in {-1, 0, +1} uniform. +// Elite enemies: delta in {0, +1, +2} with weights 0.4/0.4/0.2. +func RollIlvl(monsterLevel int, isElite bool) int { + var delta int + if isElite { + r := rand.Float64() + switch { + case r < 0.4: + delta = 0 + case r < 0.8: + delta = 1 + default: + delta = 2 + } + } else { + delta = rand.Intn(3) - 1 // -1, 0, or +1 + } + ilvl := monsterLevel + delta + if ilvl < 1 { + ilvl = 1 + } + return ilvl +} diff --git a/backend/internal/model/loot.go b/backend/internal/model/loot.go new file mode 100644 index 0000000..7d6e8ef --- /dev/null +++ b/backend/internal/model/loot.go @@ -0,0 +1,207 @@ +package model + +import ( + "math/rand" + "time" +) + +// Rarity represents item rarity tiers. Shared across weapons, armor, and loot. +type Rarity string + +const ( + RarityCommon Rarity = "common" + RarityUncommon Rarity = "uncommon" + RarityRare Rarity = "rare" + RarityEpic Rarity = "epic" + RarityLegendary Rarity = "legendary" +) + +// DropChance maps rarity to its drop probability (0.0 to 1.0). +var DropChance = map[Rarity]float64{ + RarityCommon: 0.40, + RarityUncommon: 0.10, + RarityRare: 0.02, + RarityEpic: 0.003, + RarityLegendary: 0.0005, +} + +// GoldRange defines minimum and maximum gold drops per rarity. +type GoldRange struct { + Min int64 + Max int64 +} + +// GoldRanges maps rarity to gold drop ranges. +var GoldRanges = map[Rarity]GoldRange{ + RarityCommon: {Min: 0, Max: 5}, + RarityUncommon: {Min: 6, Max: 20}, + RarityRare: {Min: 21, Max: 50}, + RarityEpic: {Min: 51, Max: 120}, + RarityLegendary: {Min: 121, Max: 300}, +} + +// LootDrop represents a single item or gold drop from defeating an enemy. +type LootDrop struct { + ItemType string `json:"itemType"` // "gold", "potion", or EquipmentSlot ("main_hand", "chest", "head", etc.) + ItemID int64 `json:"itemId,omitempty"` // ID of the weapon or armor, 0 for gold + ItemName string `json:"itemName,omitempty"` // display name when equipped / dropped + Rarity Rarity `json:"rarity"` + GoldAmount int64 `json:"goldAmount,omitempty"` // gold value of this drop +} + +// LootHistory records a loot drop event for audit/analytics. +type LootHistory struct { + ID int64 `json:"id"` + HeroID int64 `json:"heroId"` + EnemyType string `json:"enemyType"` + ItemType string `json:"itemType"` + ItemID int64 `json:"itemId,omitempty"` + Rarity Rarity `json:"rarity"` + GoldAmount int64 `json:"goldAmount"` + CreatedAt time.Time `json:"createdAt"` +} + +// AutoSellPrices maps rarity to the gold value obtained by auto-selling an +// equipment drop that the hero doesn't need. +var AutoSellPrices = map[Rarity]int64{ + RarityCommon: 3, + RarityUncommon: 8, + RarityRare: 20, + RarityEpic: 60, + RarityLegendary: 180, +} + +// RollRarity rolls a random rarity based on the drop chance table. +// It uses a cumulative probability approach, checking from rarest to most common. +func RollRarity() Rarity { + return RarityFromRoll(rand.Float64()) +} + +// RarityFromRoll maps a uniform [0,1) value to a rarity tier (spec §8.1 drop bands). +func RarityFromRoll(roll float64) Rarity { + if roll < DropChance[RarityLegendary] { + return RarityLegendary + } + if roll < DropChance[RarityLegendary]+DropChance[RarityEpic] { + return RarityEpic + } + if roll < DropChance[RarityLegendary]+DropChance[RarityEpic]+DropChance[RarityRare] { + return RarityRare + } + if roll < DropChance[RarityLegendary]+DropChance[RarityEpic]+DropChance[RarityRare]+DropChance[RarityUncommon] { + return RarityUncommon + } + return RarityCommon +} + +// RollGold returns a random gold amount for the given rarity. +func RollGold(rarity Rarity) int64 { + return RollGoldWithRNG(rarity, nil) +} + +// RollGoldWithRNG returns spec §8.2 gold for a rarity tier; if rng is nil, uses the global RNG. +func RollGoldWithRNG(rarity Rarity, rng *rand.Rand) int64 { + gr, ok := GoldRanges[rarity] + if !ok { + return 0 + } + if gr.Max <= gr.Min { + return gr.Min + } + var n int64 + if rng == nil { + n = gr.Min + rand.Int63n(gr.Max-gr.Min+1) + } else { + n = gr.Min + rng.Int63n(gr.Max-gr.Min+1) + } + // MVP balance: reduce gold loot rate vs spec table (plates longer progression). + const goldLootScale = 0.5 + return int64(float64(n) * goldLootScale) +} + +// equipmentLootSlots maps loot ItemType strings to relative weights. +// All item types now use unified EquipmentSlot names. +var equipmentLootSlots = []struct { + itemType string + weight float64 +}{ + {string(SlotMainHand), 0.05}, + {string(SlotChest), 0.05}, + {string(SlotHead), 0.05}, + {string(SlotFeet), 0.05}, + {string(SlotNeck), 0.05}, + {string(SlotHands), 0.05}, + {string(SlotLegs), 0.05}, + {string(SlotCloak), 0.05}, + {string(SlotFinger), 0.05}, + {string(SlotWrist), 0.05}, +} + +func rollEquipmentLootItemType(float01 func() float64) string { + r := float01() + var acc float64 + for _, row := range equipmentLootSlots { + acc += row.weight + if r < acc { + return row.itemType + } + } + return equipmentLootSlots[len(equipmentLootSlots)-1].itemType +} + +// GenerateLoot generates loot drops from defeating an enemy (preview / tests). +// Guaranteed gold uses a spec rarity band; optional equipment is independent and does not replace gold. +func GenerateLoot(enemyType EnemyType, luckMultiplier float64) []LootDrop { + return GenerateLootWithRNG(enemyType, luckMultiplier, nil) +} + +// GenerateLootWithRNG is GenerateLoot with an optional RNG for deterministic tests. +func GenerateLootWithRNG(enemyType EnemyType, luckMultiplier float64, rng *rand.Rand) []LootDrop { + var drops []LootDrop + + float01 := func() float64 { + if rng == nil { + return rand.Float64() + } + return rng.Float64() + } + + // Gold tier roll (spec §8.1–8.2); independent of whether an item drops later. + goldRarity := RarityFromRoll(float01()) + goldAmount := RollGoldWithRNG(goldRarity, rng) + if luckMultiplier > 1 { + goldAmount = int64(float64(goldAmount) * luckMultiplier) + } + + drops = append(drops, LootDrop{ + ItemType: "gold", + Rarity: goldRarity, + GoldAmount: goldAmount, + }) + + // 5% chance to drop a healing potion (heals 30% of maxHP). + potionRoll := float01() + if potionRoll < 0.05 { + drops = append(drops, LootDrop{ + ItemType: "potion", + Rarity: RarityCommon, + }) + } + + equipRoll := float01() + equipChance := 0.15 * luckMultiplier + if equipChance > 1 { + equipChance = 1 + } + + if equipRoll < equipChance { + itemRarity := RarityFromRoll(float01()) + itemType := rollEquipmentLootItemType(float01) + drops = append(drops, LootDrop{ + ItemType: itemType, + Rarity: itemRarity, + }) + } + + return drops +} diff --git a/backend/internal/model/payment.go b/backend/internal/model/payment.go new file mode 100644 index 0000000..4ad33cc --- /dev/null +++ b/backend/internal/model/payment.go @@ -0,0 +1,39 @@ +package model + +import "time" + +const ( + // BuffRefillPriceRUB is the price in rubles to refill any regular buff's charges. + BuffRefillPriceRUB = 50 + // ResurrectionRefillPriceRUB is the price in rubles to refill resurrection charges. + ResurrectionRefillPriceRUB = 150 +) + +// PaymentType identifies the kind of purchase. +type PaymentType string + +const ( + PaymentBuffReplenish PaymentType = "buff_replenish" + PaymentResurrectionReplenish PaymentType = "resurrection_replenish" +) + +// PaymentStatus tracks the lifecycle of a payment. +type PaymentStatus string + +const ( + PaymentPending PaymentStatus = "pending" + PaymentCompleted PaymentStatus = "completed" + PaymentFailed PaymentStatus = "failed" +) + +// Payment records a purchase transaction. +type Payment struct { + ID int64 `json:"id"` + HeroID int64 `json:"heroId"` + Type PaymentType `json:"type"` + BuffType string `json:"buffType,omitempty"` + AmountRUB int `json:"amountRub"` + Status PaymentStatus `json:"status"` + CreatedAt time.Time `json:"createdAt"` + CompletedAt *time.Time `json:"completedAt,omitempty"` +} diff --git a/backend/internal/model/quest.go b/backend/internal/model/quest.go new file mode 100644 index 0000000..003e08b --- /dev/null +++ b/backend/internal/model/quest.go @@ -0,0 +1,147 @@ +package model + +import "time" + +// Town represents a fixed settlement along the hero's travel road. +type Town struct { + ID int64 `json:"id"` + Name string `json:"name"` + Biome string `json:"biome"` + WorldX float64 `json:"worldX"` + WorldY float64 `json:"worldY"` + Radius float64 `json:"radius"` + LevelMin int `json:"levelMin"` + LevelMax int `json:"levelMax"` +} + +// NPC represents a non-hostile character living in a town. +type NPC struct { + ID int64 `json:"id"` + TownID int64 `json:"townId"` + Name string `json:"name"` + Type string `json:"type"` // quest_giver, merchant, healer + OffsetX float64 `json:"offsetX"` + OffsetY float64 `json:"offsetY"` +} + +// Quest is a template definition offered by a quest-giver NPC. +type Quest struct { + ID int64 `json:"id"` + NPCID int64 `json:"npcId"` + Title string `json:"title"` + Description string `json:"description"` + Type string `json:"type"` // kill_count, visit_town, collect_item + TargetCount int `json:"targetCount"` + TargetEnemyType *string `json:"targetEnemyType"` // NULL = any enemy + TargetTownID *int64 `json:"targetTownId"` // for visit_town quests + DropChance float64 `json:"dropChance"` // for collect_item + MinLevel int `json:"minLevel"` + MaxLevel int `json:"maxLevel"` + RewardXP int64 `json:"rewardXp"` + RewardGold int64 `json:"rewardGold"` + RewardPotions int `json:"rewardPotions"` +} + +// HeroQuest tracks a hero's progress on an accepted quest. +type HeroQuest struct { + ID int64 `json:"id"` + HeroID int64 `json:"heroId"` + QuestID int64 `json:"questId"` + Status string `json:"status"` // accepted, completed, claimed + Progress int `json:"progress"` + AcceptedAt time.Time `json:"acceptedAt"` + CompletedAt *time.Time `json:"completedAt,omitempty"` + ClaimedAt *time.Time `json:"claimedAt,omitempty"` + Quest *Quest `json:"quest,omitempty"` // populated on list +} + +// QuestReward holds the rewards granted when a quest is claimed. +type QuestReward struct { + XP int64 `json:"xp"` + Gold int64 `json:"gold"` + Potions int `json:"potions"` +} + +// TownWithNPCs is a Town annotated with its NPC residents and computed world positions. +type TownWithNPCs struct { + ID int64 `json:"id"` + Name string `json:"name"` + Biome string `json:"biome"` + WorldX float64 `json:"worldX"` + WorldY float64 `json:"worldY"` + Radius float64 `json:"radius"` + Size string `json:"size"` // S, M, L derived from radius + NPCs []NPCView `json:"npcs"` +} + +// NPCView is the frontend-friendly view of an NPC with absolute world coordinates. +type NPCView struct { + ID int64 `json:"id"` + Name string `json:"name"` + Type string `json:"type"` + WorldX float64 `json:"worldX"` + WorldY float64 `json:"worldY"` +} + +// TownSizeFromRadius derives a size label from the town radius. +func TownSizeFromRadius(radius float64) string { + switch { + case radius >= 17: + return "L" + case radius >= 14: + return "M" + default: + return "S" + } +} + +// NPCInteractAction represents a single action the player can take with an NPC. +type NPCInteractAction struct { + ActionType string `json:"actionType"` // "quest", "shop_item", "heal" + QuestID int64 `json:"questId,omitempty"` // for quest_giver + QuestTitle string `json:"questTitle,omitempty"` // for quest_giver + ItemName string `json:"itemName,omitempty"` // for merchant + ItemCost int64 `json:"itemCost,omitempty"` // for merchant / healer + Description string `json:"description,omitempty"` +} + +// NPCInteractResponse is the response for POST /api/v1/hero/npc-interact. +type NPCInteractResponse struct { + NPCName string `json:"npcName"` + NPCType string `json:"npcType"` + TownName string `json:"townName"` + Actions []NPCInteractAction `json:"actions"` +} + +// NearbyNPCEntry is returned by the nearby-npcs endpoint. +type NearbyNPCEntry struct { + ID int64 `json:"id"` + Name string `json:"name"` + Type string `json:"type"` + WorldX float64 `json:"worldX"` + WorldY float64 `json:"worldY"` + InteractionAvailable bool `json:"interactionAvailable"` +} + +// NPCEventResponse is returned when a random NPC event occurs instead of an enemy encounter. +type NPCEventResponse struct { + Type string `json:"type"` // "npc_event" + NPC NPCEventNPC `json:"npc"` + Cost int64 `json:"cost"` + Reward string `json:"reward"` // e.g. "random_equipment" +} + +// NPCEventNPC describes the wandering NPC in a random event. +type NPCEventNPC struct { + Name string `json:"name"` + Role string `json:"role"` +} + +// AlmsResponse is the response for POST /api/v1/hero/npc-alms. +type AlmsResponse struct { + Accepted bool `json:"accepted"` + GoldSpent int64 `json:"goldSpent,omitempty"` + ItemDrop *LootDrop `json:"itemDrop,omitempty"` + Hero interface{} `json:"hero,omitempty"` + Message string `json:"message"` +} diff --git a/backend/internal/model/ws_message.go b/backend/internal/model/ws_message.go new file mode 100644 index 0000000..c883cf8 --- /dev/null +++ b/backend/internal/model/ws_message.go @@ -0,0 +1,182 @@ +package model + +import "encoding/json" + +// WSEnvelope is the wire format for all WebSocket messages (both directions). +type WSEnvelope struct { + Type string `json:"type"` + Payload json.RawMessage `json:"payload"` +} + +// NewWSEnvelope creates an envelope by marshaling the payload to JSON. +// If marshaling fails, payload is set to "{}". +func NewWSEnvelope(msgType string, payload any) WSEnvelope { + raw, err := json.Marshal(payload) + if err != nil { + raw = []byte("{}") + } + return WSEnvelope{Type: msgType, Payload: raw} +} + +// ClientMessage is a parsed inbound message from a WebSocket client, +// tagged with the hero ID of the sending connection. +type ClientMessage struct { + HeroID int64 + Type string + Payload json.RawMessage +} + +// --- Server -> Client payload types --- + +// HeroMovePayload is sent at 2 Hz while the hero is walking. +type HeroMovePayload struct { + X float64 `json:"x"` + Y float64 `json:"y"` + TargetX float64 `json:"targetX"` + TargetY float64 `json:"targetY"` + Speed float64 `json:"speed"` + Heading float64 `json:"heading"` // radians +} + +// PositionSyncPayload is sent every 10s as drift correction. +type PositionSyncPayload struct { + X float64 `json:"x"` + Y float64 `json:"y"` + WaypointIndex int `json:"waypointIndex"` + WaypointFraction float64 `json:"waypointFraction"` + State string `json:"state"` +} + +// RouteAssignedPayload is sent when the hero starts walking a new road segment. +type RouteAssignedPayload struct { + RoadID int64 `json:"roadId"` + Waypoints []PointXY `json:"waypoints"` + DestinationTownID int64 `json:"destinationTownId"` + Speed float64 `json:"speed"` +} + +// PointXY is a 2D coordinate used in route payloads. +type PointXY struct { + X float64 `json:"x"` + Y float64 `json:"y"` +} + +// CombatStartPayload is sent when combat begins. +type CombatStartPayload struct { + Enemy CombatEnemyInfo `json:"enemy"` +} + +// CombatEnemyInfo is the enemy snapshot sent to the client on combat_start. +type CombatEnemyInfo struct { + Name string `json:"name"` + Type string `json:"type"` + HP int `json:"hp"` + MaxHP int `json:"maxHp"` + Attack int `json:"attack"` + Defense int `json:"defense"` + Speed float64 `json:"speed"` + IsElite bool `json:"isElite"` +} + +// AttackPayload is sent on each swing during combat. +type AttackPayload struct { + Source string `json:"source"` // "hero" or "enemy" + Damage int `json:"damage"` + IsCrit bool `json:"isCrit,omitempty"` + HeroHP int `json:"heroHp"` + EnemyHP int `json:"enemyHp"` + DebuffApplied string `json:"debuffApplied,omitempty"` +} + +// CombatEndPayload is sent when the hero wins a fight. +type CombatEndPayload struct { + XPGained int64 `json:"xpGained"` + GoldGained int64 `json:"goldGained"` + Loot []LootItem `json:"loot,omitempty"` + LeveledUp bool `json:"leveledUp"` + NewLevel int `json:"newLevel,omitempty"` +} + +// LootItem describes a single piece of loot in the combat_end payload. +type LootItem struct { + ItemType string `json:"itemType"` + Name string `json:"name"` + Rarity string `json:"rarity"` +} + +// HeroDiedPayload is sent when the hero's HP reaches 0. +type HeroDiedPayload struct { + KilledBy string `json:"killedBy"` +} + +// HeroRevivedPayload is sent after a revive. +type HeroRevivedPayload struct { + HP int `json:"hp"` +} + +// TownNPCInfo describes an NPC in a town (town_enter payload). +type TownNPCInfo struct { + ID int64 `json:"id"` + Name string `json:"name"` + Type string `json:"type"` +} + +// TownEnterPayload is sent when a hero arrives at a town. +type TownEnterPayload struct { + TownID int64 `json:"townId"` + TownName string `json:"townName"` + Biome string `json:"biome"` + NPCs []TownNPCInfo `json:"npcs"` + RestDurationMs int64 `json:"restDurationMs"` +} + +// TownNPCVisitPayload is sent when the hero approaches an NPC (quest/shop/healer) during a town stay. +type TownNPCVisitPayload struct { + NPCID int64 `json:"npcId"` + Name string `json:"name"` + Type string `json:"type"` + TownID int64 `json:"townId"` +} + +// TownExitPayload is sent when the hero leaves a town. +type TownExitPayload struct{} + +// LevelUpPayload is sent on level-up. +type LevelUpPayload struct { + NewLevel int `json:"newLevel"` +} + +// BuffAppliedPayload is sent when a buff is activated. +type BuffAppliedPayload struct { + BuffType string `json:"buffType"` + Duration float64 `json:"duration"` // seconds + Magnitude float64 `json:"magnitude"` +} + +// ErrorPayload is sent when a client command fails validation. +type ErrorPayload struct { + Code string `json:"code"` + Message string `json:"message"` +} + +// --- Client -> Server payload types --- + +// ActivateBuffPayload is the payload for the activate_buff command. +type ActivateBuffPayload struct { + BuffType string `json:"buffType"` +} + +// AcceptQuestPayload is the payload for the accept_quest command. +type AcceptQuestPayload struct { + QuestID int64 `json:"questId"` +} + +// ClaimQuestPayload is the payload for the claim_quest command. +type ClaimQuestPayload struct { + QuestID int64 `json:"questId"` +} + +// NPCInteractPayload is the payload for the npc_interact command. +type NPCInteractPayload struct { + NPCID int64 `json:"npcId"` +} diff --git a/backend/internal/router/router.go b/backend/internal/router/router.go new file mode 100644 index 0000000..980765b --- /dev/null +++ b/backend/internal/router/router.go @@ -0,0 +1,164 @@ +package router + +import ( + "log/slog" + "net/http" + "time" + + "github.com/go-chi/chi/v5" + "github.com/go-chi/chi/v5/middleware" + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/denisovdennis/autohero/internal/game" + "github.com/denisovdennis/autohero/internal/handler" + "github.com/denisovdennis/autohero/internal/storage" + "github.com/denisovdennis/autohero/internal/world" +) + +// Deps holds all dependencies needed by the router. +type Deps struct { + Engine *game.Engine + Hub *handler.Hub + PgPool *pgxpool.Pool + BotToken string + AdminBasicAuthUsername string + AdminBasicAuthPassword string + AdminBasicAuthRealm string + Logger *slog.Logger + ServerStartedAt time.Time +} + +// New creates the chi router with all routes wired. +func New(deps Deps) *chi.Mux { + r := chi.NewRouter() + + // Middleware stack. + r.Use(middleware.RequestID) + r.Use(middleware.RealIP) + r.Use(middleware.Recoverer) + r.Use(middleware.Heartbeat("/ping")) + r.Use(corsMiddleware) + + // Health. + healthH := handler.NewHealthHandler() + r.Get("/health", healthH.Health) + + // Stores (PostgreSQL-backed persistence). + heroStore := storage.NewHeroStore(deps.PgPool, deps.Logger) + + // WebSocket (needs heroStore to resolve telegram ID → hero DB ID). + wsH := handler.NewWSHandler(deps.Hub, heroStore, deps.Logger) + r.Get("/ws", wsH.HandleWS) + logStore := storage.NewLogStore(deps.PgPool) + questStore := storage.NewQuestStore(deps.PgPool) + gearStore := storage.NewGearStore(deps.PgPool) + achievementStore := storage.NewAchievementStore(deps.PgPool) + taskStore := storage.NewDailyTaskStore(deps.PgPool) + worldSvc := world.NewService() + + // Auth endpoint (no auth middleware required - this IS the auth). + authH := handler.NewAuthHandler(deps.BotToken, heroStore, deps.Logger) + r.Post("/api/v1/auth/telegram", authH.TelegramAuth) + + // Admin routes protected with HTTP Basic authentication. + adminH := handler.NewAdminHandler(heroStore, deps.Engine, deps.Hub, deps.PgPool, deps.Logger) + r.Route("/admin", func(r chi.Router) { + r.Use(handler.BasicAuthMiddleware(handler.BasicAuthConfig{ + Username: deps.AdminBasicAuthUsername, + Password: deps.AdminBasicAuthPassword, + Realm: deps.AdminBasicAuthRealm, + })) + r.Get("/heroes", adminH.ListHeroes) + r.Get("/heroes/{heroId}", adminH.GetHero) + r.Post("/heroes/{heroId}/set-level", adminH.SetHeroLevel) + r.Post("/heroes/{heroId}/set-gold", adminH.SetHeroGold) + r.Post("/heroes/{heroId}/set-hp", adminH.SetHeroHP) + r.Post("/heroes/{heroId}/add-potions", adminH.AddPotions) + r.Post("/heroes/{heroId}/revive", adminH.ReviveHero) + r.Post("/heroes/{heroId}/reset", adminH.ResetHero) + r.Post("/heroes/{heroId}/reset-buff-charges", adminH.ResetBuffCharges) + r.Delete("/heroes/{heroId}", adminH.DeleteHero) + r.Get("/engine/status", adminH.EngineStatus) + r.Get("/engine/combats", adminH.ActiveCombats) + r.Get("/ws/connections", adminH.WSConnections) + r.Get("/info", adminH.ServerInfo) + }) + + // API v1 (authenticated routes). + gameH := handler.NewGameHandler(deps.Engine, heroStore, logStore, worldSvc, deps.Logger, deps.ServerStartedAt, questStore, gearStore, achievementStore, taskStore) + mapsH := handler.NewMapsHandler(worldSvc, deps.Logger) + questH := handler.NewQuestHandler(questStore, heroStore, logStore, deps.Logger) + npcH := handler.NewNPCHandler(questStore, heroStore, gearStore, logStore, deps.Logger) + achieveH := handler.NewAchievementHandler(achievementStore, heroStore, deps.Logger) + taskH := handler.NewDailyTaskHandler(taskStore, heroStore, deps.Logger) + r.Route("/api/v1", func(r chi.Router) { + // Apply Telegram auth middleware to all routes in this group. + // Disabled for now to allow development without a bot token. + // r.Use(handler.TelegramAuthMiddleware(deps.BotToken)) + + r.Get("/hero", gameH.GetHero) + r.Get("/hero/init", gameH.InitHero) + r.Post("/hero/name", gameH.SetHeroName) + r.Post("/hero/buff/{buffType}", gameH.ActivateBuff) + r.Post("/hero/encounter", gameH.RequestEncounter) + r.Post("/hero/victory", gameH.ReportVictory) + r.Post("/hero/revive", gameH.ReviveHero) + r.Post("/hero/purchase-buff-refill", gameH.PurchaseBuffRefill) + r.Get("/hero/loot", gameH.GetLoot) + r.Get("/hero/log", gameH.GetAdventureLog) + r.Post("/hero/use-potion", gameH.UsePotion) + r.Get("/weapons", gameH.GetWeapons) + r.Get("/armor", gameH.GetArmor) + r.Get("/maps/{mapId}", mapsH.GetMap) + + // Quest system routes. + r.Get("/towns", questH.ListTowns) + r.Get("/towns/{townId}/npcs", questH.ListNPCsByTown) + r.Get("/npcs/{npcId}/quests", questH.ListQuestsByNPC) + r.Post("/hero/quests/{questId}/accept", questH.AcceptQuest) + r.Get("/hero/quests", questH.ListHeroQuests) + r.Post("/hero/quests/{questId}/claim", questH.ClaimQuestReward) + r.Delete("/hero/quests/{questId}", questH.AbandonQuest) + + // NPC interaction routes. + r.Post("/hero/npc-interact", npcH.InteractNPC) + r.Get("/hero/nearby-npcs", npcH.NearbyNPCs) + r.Post("/hero/npc-alms", npcH.NPCAlms) + r.Post("/hero/npc-heal", npcH.HealHero) + r.Post("/hero/npc-buy-potion", npcH.BuyPotion) + + // Gear routes. + r.Get("/hero/gear", gameH.GetHeroGear) + r.Get("/hero/equipment", gameH.GetHeroGear) // backward compat + r.Get("/gear/catalog", gameH.GetGearCatalog) + + // Achievement routes. + r.Get("/hero/achievements", achieveH.GetHeroAchievements) + + // Daily/weekly task routes. + r.Get("/hero/tasks", taskH.ListHeroTasks) + r.Post("/hero/tasks/{taskId}/claim", taskH.ClaimTask) + + // Shared world routes. + r.Get("/hero/nearby", gameH.NearbyHeroes) + }) + + return r +} + +// corsMiddleware adds CORS headers to all responses. +func corsMiddleware(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Access-Control-Allow-Origin", "*") + w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS") + w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Telegram-Init-Data") + w.Header().Set("Access-Control-Max-Age", "86400") + + if r.Method == http.MethodOptions { + w.WriteHeader(http.StatusNoContent) + return + } + + next.ServeHTTP(w, r) + }) +} diff --git a/backend/internal/storage/achievement_store.go b/backend/internal/storage/achievement_store.go new file mode 100644 index 0000000..e1f96ec --- /dev/null +++ b/backend/internal/storage/achievement_store.go @@ -0,0 +1,157 @@ +package storage + +import ( + "context" + "fmt" + "time" + + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/denisovdennis/autohero/internal/model" +) + +// AchievementStore handles achievement CRUD operations against PostgreSQL. +type AchievementStore struct { + pool *pgxpool.Pool +} + +// NewAchievementStore creates a new AchievementStore backed by the given connection pool. +func NewAchievementStore(pool *pgxpool.Pool) *AchievementStore { + return &AchievementStore{pool: pool} +} + +// ListAchievements returns all achievement definitions. +func (s *AchievementStore) ListAchievements(ctx context.Context) ([]model.Achievement, error) { + rows, err := s.pool.Query(ctx, ` + SELECT id, title, description, condition_type, condition_value, reward_type, reward_amount + FROM achievements + ORDER BY condition_value ASC + `) + if err != nil { + return nil, fmt.Errorf("list achievements: %w", err) + } + defer rows.Close() + + var achievements []model.Achievement + for rows.Next() { + var a model.Achievement + if err := rows.Scan(&a.ID, &a.Title, &a.Description, &a.ConditionType, &a.ConditionValue, &a.RewardType, &a.RewardAmount); err != nil { + return nil, fmt.Errorf("scan achievement: %w", err) + } + achievements = append(achievements, a) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("list achievements rows: %w", err) + } + if achievements == nil { + achievements = []model.Achievement{} + } + return achievements, nil +} + +// GetHeroAchievements returns all unlocked achievements for a hero. +func (s *AchievementStore) GetHeroAchievements(ctx context.Context, heroID int64) ([]model.HeroAchievement, error) { + rows, err := s.pool.Query(ctx, ` + SELECT ha.hero_id, ha.achievement_id, ha.unlocked_at, + a.id, a.title, a.description, a.condition_type, a.condition_value, a.reward_type, a.reward_amount + FROM hero_achievements ha + JOIN achievements a ON ha.achievement_id = a.id + WHERE ha.hero_id = $1 + ORDER BY ha.unlocked_at ASC + `, heroID) + if err != nil { + return nil, fmt.Errorf("get hero achievements: %w", err) + } + defer rows.Close() + + var has []model.HeroAchievement + for rows.Next() { + var ha model.HeroAchievement + var a model.Achievement + if err := rows.Scan( + &ha.HeroID, &ha.AchievementID, &ha.UnlockedAt, + &a.ID, &a.Title, &a.Description, &a.ConditionType, &a.ConditionValue, &a.RewardType, &a.RewardAmount, + ); err != nil { + return nil, fmt.Errorf("scan hero achievement: %w", err) + } + ha.Achievement = &a + has = append(has, ha) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("hero achievements rows: %w", err) + } + if has == nil { + has = []model.HeroAchievement{} + } + return has, nil +} + +// UnlockAchievement records that a hero has unlocked an achievement. +// Uses ON CONFLICT DO NOTHING to be idempotent. +func (s *AchievementStore) UnlockAchievement(ctx context.Context, heroID int64, achievementID string) error { + _, err := s.pool.Exec(ctx, ` + INSERT INTO hero_achievements (hero_id, achievement_id, unlocked_at) + VALUES ($1, $2, now()) + ON CONFLICT DO NOTHING + `, heroID, achievementID) + if err != nil { + return fmt.Errorf("unlock achievement: %w", err) + } + return nil +} + +// CheckAndUnlock checks all achievement conditions against the hero's current stats, +// unlocks any newly met achievements, and returns the list of newly unlocked ones. +func (s *AchievementStore) CheckAndUnlock(ctx context.Context, hero *model.Hero) ([]model.Achievement, error) { + allAchievements, err := s.ListAchievements(ctx) + if err != nil { + return nil, fmt.Errorf("check and unlock: %w", err) + } + + // Load already-unlocked IDs for fast lookup. + unlockedRows, err := s.pool.Query(ctx, ` + SELECT achievement_id FROM hero_achievements WHERE hero_id = $1 + `, hero.ID) + if err != nil { + return nil, fmt.Errorf("check unlocked: %w", err) + } + defer unlockedRows.Close() + + unlocked := make(map[string]bool) + for unlockedRows.Next() { + var id string + if err := unlockedRows.Scan(&id); err != nil { + return nil, fmt.Errorf("scan unlocked id: %w", err) + } + unlocked[id] = true + } + if err := unlockedRows.Err(); err != nil { + return nil, fmt.Errorf("unlocked rows: %w", err) + } + + var newlyUnlocked []model.Achievement + now := time.Now() + + for i := range allAchievements { + a := &allAchievements[i] + if unlocked[a.ID] { + continue + } + if !model.CheckAchievementCondition(a, hero) { + continue + } + + // Unlock it. + _, err := s.pool.Exec(ctx, ` + INSERT INTO hero_achievements (hero_id, achievement_id, unlocked_at) + VALUES ($1, $2, $3) + ON CONFLICT DO NOTHING + `, hero.ID, a.ID, now) + if err != nil { + return nil, fmt.Errorf("unlock achievement %s: %w", a.ID, err) + } + newlyUnlocked = append(newlyUnlocked, *a) + } + + return newlyUnlocked, nil +} diff --git a/backend/internal/storage/daily_task_store.go b/backend/internal/storage/daily_task_store.go new file mode 100644 index 0000000..28a82d0 --- /dev/null +++ b/backend/internal/storage/daily_task_store.go @@ -0,0 +1,200 @@ +package storage + +import ( + "context" + "errors" + "fmt" + "time" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/denisovdennis/autohero/internal/model" +) + +// DailyTaskStore handles daily/weekly task operations against PostgreSQL. +type DailyTaskStore struct { + pool *pgxpool.Pool +} + +// NewDailyTaskStore creates a new DailyTaskStore backed by the given connection pool. +func NewDailyTaskStore(pool *pgxpool.Pool) *DailyTaskStore { + return &DailyTaskStore{pool: pool} +} + +// periodStart returns the start of the current period for a given period type. +// Daily: start of today (UTC). Weekly: start of this Monday (UTC). +func periodStart(now time.Time, period string) time.Time { + t := now.UTC() + today := time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.UTC) + if period == "weekly" { + // Go back to Monday. + weekday := int(today.Weekday()) + if weekday == 0 { + weekday = 7 // Sunday -> 7 + } + return today.AddDate(0, 0, -(weekday - 1)) + } + return today +} + +// EnsureHeroTasks creates task rows for the current period if they don't already exist. +// Called lazily when the hero checks their tasks. +func (s *DailyTaskStore) EnsureHeroTasks(ctx context.Context, heroID int64, now time.Time) error { + // Load all task definitions. + rows, err := s.pool.Query(ctx, `SELECT id, period FROM daily_tasks`) + if err != nil { + return fmt.Errorf("ensure hero tasks list: %w", err) + } + defer rows.Close() + + type taskDef struct { + id string + period string + } + var tasks []taskDef + for rows.Next() { + var t taskDef + if err := rows.Scan(&t.id, &t.period); err != nil { + return fmt.Errorf("scan task def: %w", err) + } + tasks = append(tasks, t) + } + if err := rows.Err(); err != nil { + return fmt.Errorf("task defs rows: %w", err) + } + + for _, t := range tasks { + ps := periodStart(now, t.period) + _, err := s.pool.Exec(ctx, ` + INSERT INTO hero_daily_tasks (hero_id, task_id, progress, completed, claimed, period_start) + VALUES ($1, $2, 0, false, false, $3) + ON CONFLICT DO NOTHING + `, heroID, t.id, ps) + if err != nil { + return fmt.Errorf("ensure task %s: %w", t.id, err) + } + } + return nil +} + +// ListHeroTasks returns current daily and weekly tasks with progress for a hero. +// Only returns tasks for the current period (daily = today, weekly = this week). +func (s *DailyTaskStore) ListHeroTasks(ctx context.Context, heroID int64) ([]model.HeroDailyTask, error) { + now := time.Now().UTC() + dailyStart := periodStart(now, "daily") + weeklyStart := periodStart(now, "weekly") + + rows, err := s.pool.Query(ctx, ` + SELECT hdt.hero_id, hdt.task_id, hdt.progress, hdt.completed, hdt.claimed, hdt.period_start, + dt.id, dt.title, dt.description, dt.objective_type, dt.objective_count, + dt.reward_type, dt.reward_amount, dt.period + FROM hero_daily_tasks hdt + JOIN daily_tasks dt ON hdt.task_id = dt.id + WHERE hdt.hero_id = $1 + AND ( + (dt.period = 'daily' AND hdt.period_start = $2) + OR + (dt.period = 'weekly' AND hdt.period_start = $3) + ) + ORDER BY dt.period ASC, dt.id ASC + `, heroID, dailyStart, weeklyStart) + if err != nil { + return nil, fmt.Errorf("list hero tasks: %w", err) + } + defer rows.Close() + + var tasks []model.HeroDailyTask + for rows.Next() { + var ht model.HeroDailyTask + var dt model.DailyTask + if err := rows.Scan( + &ht.HeroID, &ht.TaskID, &ht.Progress, &ht.Completed, &ht.Claimed, &ht.PeriodStart, + &dt.ID, &dt.Title, &dt.Description, &dt.ObjectiveType, &dt.ObjectiveCount, + &dt.RewardType, &dt.RewardAmount, &dt.Period, + ); err != nil { + return nil, fmt.Errorf("scan hero task: %w", err) + } + ht.Task = &dt + tasks = append(tasks, ht) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("hero tasks rows: %w", err) + } + if tasks == nil { + tasks = []model.HeroDailyTask{} + } + return tasks, nil +} + +// IncrementTaskProgress increments progress for all matching uncompleted tasks +// in the current period. Automatically marks tasks as completed when the objective +// count is reached. +func (s *DailyTaskStore) IncrementTaskProgress(ctx context.Context, heroID int64, objectiveType string, delta int) error { + if delta <= 0 { + return nil + } + + now := time.Now().UTC() + dailyStart := periodStart(now, "daily") + weeklyStart := periodStart(now, "weekly") + + _, err := s.pool.Exec(ctx, ` + UPDATE hero_daily_tasks hdt + SET progress = LEAST(hdt.progress + $3, dt.objective_count), + completed = CASE WHEN hdt.progress + $3 >= dt.objective_count THEN true ELSE hdt.completed END + FROM daily_tasks dt + WHERE hdt.task_id = dt.id + AND hdt.hero_id = $1 + AND hdt.completed = false + AND dt.objective_type = $2 + AND ( + (dt.period = 'daily' AND hdt.period_start = $4) + OR + (dt.period = 'weekly' AND hdt.period_start = $5) + ) + `, heroID, objectiveType, delta, dailyStart, weeklyStart) + if err != nil { + return fmt.Errorf("increment task progress: %w", err) + } + return nil +} + +// ClaimTask marks a completed task as claimed and returns the reward. +// Returns an error if the task is not completed or already claimed. +func (s *DailyTaskStore) ClaimTask(ctx context.Context, heroID int64, taskID string) (*model.DailyTaskReward, error) { + now := time.Now().UTC() + dailyStart := periodStart(now, "daily") + weeklyStart := periodStart(now, "weekly") + + var rewardType string + var rewardAmount int + + err := s.pool.QueryRow(ctx, ` + UPDATE hero_daily_tasks hdt + SET claimed = true + FROM daily_tasks dt + WHERE hdt.task_id = dt.id + AND hdt.hero_id = $1 + AND hdt.task_id = $2 + AND hdt.completed = true + AND hdt.claimed = false + AND ( + (dt.period = 'daily' AND hdt.period_start = $3) + OR + (dt.period = 'weekly' AND hdt.period_start = $4) + ) + RETURNING dt.reward_type, dt.reward_amount + `, heroID, taskID, dailyStart, weeklyStart).Scan(&rewardType, &rewardAmount) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, fmt.Errorf("task not found, not completed, or already claimed") + } + return nil, fmt.Errorf("claim task: %w", err) + } + + return &model.DailyTaskReward{ + RewardType: rewardType, + RewardAmount: rewardAmount, + }, nil +} diff --git a/backend/internal/storage/gear_store.go b/backend/internal/storage/gear_store.go new file mode 100644 index 0000000..1510b1e --- /dev/null +++ b/backend/internal/storage/gear_store.go @@ -0,0 +1,132 @@ +package storage + +import ( + "context" + "errors" + "fmt" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/denisovdennis/autohero/internal/model" +) + +// GearStore handles all gear CRUD operations against PostgreSQL. +type GearStore struct { + pool *pgxpool.Pool +} + +// NewGearStore creates a new GearStore backed by the given connection pool. +func NewGearStore(pool *pgxpool.Pool) *GearStore { + return &GearStore{pool: pool} +} + +// CreateItem inserts a new gear item into the database and populates item.ID. +func (s *GearStore) CreateItem(ctx context.Context, item *model.GearItem) error { + err := s.pool.QueryRow(ctx, ` + INSERT INTO gear (slot, form_id, name, subtype, rarity, ilvl, base_primary, primary_stat, + stat_type, speed_modifier, crit_chance, agility_bonus, set_name, special_effect) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14) + RETURNING id + `, + string(item.Slot), item.FormID, item.Name, item.Subtype, + string(item.Rarity), item.Ilvl, item.BasePrimary, item.PrimaryStat, + item.StatType, item.SpeedModifier, item.CritChance, item.AgilityBonus, + item.SetName, item.SpecialEffect, + ).Scan(&item.ID) + if err != nil { + return fmt.Errorf("create gear item: %w", err) + } + return nil +} + +// GetItem loads a single gear item by ID. Returns (nil, nil) if not found. +func (s *GearStore) GetItem(ctx context.Context, id int64) (*model.GearItem, error) { + var item model.GearItem + var slot, rarity string + err := s.pool.QueryRow(ctx, ` + SELECT id, slot, form_id, name, subtype, rarity, ilvl, + base_primary, primary_stat, stat_type, + speed_modifier, crit_chance, agility_bonus, + set_name, special_effect + FROM gear WHERE id = $1 + `, id).Scan( + &item.ID, &slot, &item.FormID, &item.Name, &item.Subtype, + &rarity, &item.Ilvl, + &item.BasePrimary, &item.PrimaryStat, &item.StatType, + &item.SpeedModifier, &item.CritChance, &item.AgilityBonus, + &item.SetName, &item.SpecialEffect, + ) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, nil + } + return nil, fmt.Errorf("get gear item: %w", err) + } + item.Slot = model.EquipmentSlot(slot) + item.Rarity = model.Rarity(rarity) + return &item, nil +} + +// GetHeroGear returns all equipped gear for a hero, keyed by slot. +func (s *GearStore) GetHeroGear(ctx context.Context, heroID int64) (map[model.EquipmentSlot]*model.GearItem, error) { + rows, err := s.pool.Query(ctx, ` + SELECT g.id, g.slot, g.form_id, g.name, g.subtype, g.rarity, g.ilvl, + g.base_primary, g.primary_stat, g.stat_type, + g.speed_modifier, g.crit_chance, g.agility_bonus, + g.set_name, g.special_effect + FROM hero_gear hg + JOIN gear g ON hg.gear_id = g.id + WHERE hg.hero_id = $1 + `, heroID) + if err != nil { + return nil, fmt.Errorf("get hero gear: %w", err) + } + defer rows.Close() + + gear := make(map[model.EquipmentSlot]*model.GearItem) + for rows.Next() { + var item model.GearItem + var slot, rarity string + if err := rows.Scan( + &item.ID, &slot, &item.FormID, &item.Name, &item.Subtype, + &rarity, &item.Ilvl, + &item.BasePrimary, &item.PrimaryStat, &item.StatType, + &item.SpeedModifier, &item.CritChance, &item.AgilityBonus, + &item.SetName, &item.SpecialEffect, + ); err != nil { + return nil, fmt.Errorf("scan gear item: %w", err) + } + item.Slot = model.EquipmentSlot(slot) + item.Rarity = model.Rarity(rarity) + gear[item.Slot] = &item + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("hero gear rows: %w", err) + } + return gear, nil +} + +// EquipItem equips a gear item into the given slot for a hero (upsert). +func (s *GearStore) EquipItem(ctx context.Context, heroID int64, slot model.EquipmentSlot, gearID int64) error { + _, err := s.pool.Exec(ctx, ` + INSERT INTO hero_gear (hero_id, slot, gear_id) + VALUES ($1, $2, $3) + ON CONFLICT (hero_id, slot) DO UPDATE SET gear_id = $3 + `, heroID, string(slot), gearID) + if err != nil { + return fmt.Errorf("equip gear item: %w", err) + } + return nil +} + +// UnequipSlot removes the gear from the given slot for a hero. +func (s *GearStore) UnequipSlot(ctx context.Context, heroID int64, slot model.EquipmentSlot) error { + _, err := s.pool.Exec(ctx, ` + DELETE FROM hero_gear WHERE hero_id = $1 AND slot = $2 + `, heroID, string(slot)) + if err != nil { + return fmt.Errorf("unequip gear slot: %w", err) + } + return nil +} diff --git a/backend/internal/storage/hero_store.go b/backend/internal/storage/hero_store.go new file mode 100644 index 0000000..0ec4f0f --- /dev/null +++ b/backend/internal/storage/hero_store.go @@ -0,0 +1,761 @@ +package storage + +import ( + "context" + "encoding/json" + "fmt" + "log/slog" + "time" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/denisovdennis/autohero/internal/model" +) + +// heroSelectQuery is the shared SELECT used by all hero-loading methods. +// Gear is loaded separately via GearStore.GetHeroGear after the hero row is loaded. +const heroSelectQuery = ` + SELECT + h.id, h.telegram_id, h.name, + h.hp, h.max_hp, h.attack, h.defense, h.speed, + h.strength, h.constitution, h.agility, h.luck, + h.state, h.weapon_id, h.armor_id, + h.gold, h.xp, h.level, + h.revive_count, h.subscription_active, + h.buff_free_charges_remaining, h.buff_quota_period_end, h.buff_charges, + h.position_x, h.position_y, h.potions, + h.total_kills, h.elite_kills, h.total_deaths, h.kills_since_death, h.legendary_drops, + h.current_town_id, h.destination_town_id, h.move_state, + h.last_online_at, + h.created_at, h.updated_at + FROM heroes h +` + +// HeroStore handles all hero CRUD operations against PostgreSQL. +type HeroStore struct { + pool *pgxpool.Pool + gearStore *GearStore + logger *slog.Logger +} + +// NewHeroStore creates a new HeroStore backed by the given connection pool. +func NewHeroStore(pool *pgxpool.Pool, logger *slog.Logger) *HeroStore { + return &HeroStore{ + pool: pool, + gearStore: NewGearStore(pool), + logger: logger, + } +} + +// GetHeroIDByTelegramID returns the DB hero ID for a given Telegram user ID. +// Returns 0 if not found. +func (s *HeroStore) GetHeroIDByTelegramID(ctx context.Context, telegramID int64) (int64, error) { + var id int64 + err := s.pool.QueryRow(ctx, "SELECT id FROM heroes WHERE telegram_id = $1", telegramID).Scan(&id) + if err != nil { + return 0, err + } + return id, nil +} + +// GearStore returns the embedded gear store for direct access by handlers. +func (s *HeroStore) GearStore() *GearStore { + return s.gearStore +} + +// GetByTelegramID loads a hero by Telegram user ID, including weapon and armor via LEFT JOIN. +// Returns (nil, nil) if no hero is found. +func (s *HeroStore) GetByTelegramID(ctx context.Context, telegramID int64) (*model.Hero, error) { + query := heroSelectQuery + ` WHERE h.telegram_id = $1` + + row := s.pool.QueryRow(ctx, query, telegramID) + hero, err := scanHeroRow(row) + if err != nil || hero == nil { + return hero, err + } + if err := s.loadHeroGear(ctx, hero); err != nil { + return nil, fmt.Errorf("get hero by telegram_id gear: %w", err) + } + if err := s.loadHeroBuffsAndDebuffs(ctx, hero); err != nil { + return nil, fmt.Errorf("get hero by telegram_id buffs: %w", err) + } + return hero, nil +} + +// ListHeroes returns a paginated list of heroes ordered by updated_at DESC. +func (s *HeroStore) ListHeroes(ctx context.Context, limit, offset int) ([]*model.Hero, error) { + if limit <= 0 { + limit = 20 + } + if limit > 200 { + limit = 200 + } + if offset < 0 { + offset = 0 + } + + query := heroSelectQuery + ` ORDER BY h.updated_at DESC LIMIT $1 OFFSET $2` + + rows, err := s.pool.Query(ctx, query, limit, offset) + if err != nil { + return nil, fmt.Errorf("list heroes: %w", err) + } + defer rows.Close() + + var heroes []*model.Hero + for rows.Next() { + h, err := scanHeroFromRows(rows) + if err != nil { + return nil, fmt.Errorf("list heroes scan: %w", err) + } + heroes = append(heroes, h) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("list heroes rows: %w", err) + } + for _, h := range heroes { + if err := s.loadHeroGear(ctx, h); err != nil { + return nil, fmt.Errorf("list heroes load gear: %w", err) + } + if err := s.loadHeroBuffsAndDebuffs(ctx, h); err != nil { + return nil, fmt.Errorf("list heroes load buffs: %w", err) + } + } + return heroes, nil +} + +// DeleteByID removes a hero by its primary key. Returns nil if the hero didn't exist. +func (s *HeroStore) DeleteByID(ctx context.Context, id int64) error { + _, err := s.pool.Exec(ctx, `DELETE FROM heroes WHERE id = $1`, id) + if err != nil { + return fmt.Errorf("delete hero: %w", err) + } + return nil +} + +// GetByID loads a hero by its primary key, including weapon and armor. +// Returns (nil, nil) if not found. +func (s *HeroStore) GetByID(ctx context.Context, id int64) (*model.Hero, error) { + query := heroSelectQuery + ` WHERE h.id = $1` + + row := s.pool.QueryRow(ctx, query, id) + hero, err := scanHeroRow(row) + if err != nil || hero == nil { + return hero, err + } + if err := s.loadHeroGear(ctx, hero); err != nil { + return nil, fmt.Errorf("get hero by id gear: %w", err) + } + if err := s.loadHeroBuffsAndDebuffs(ctx, hero); err != nil { + return nil, fmt.Errorf("get hero by id buffs: %w", err) + } + return hero, nil +} + +// Create inserts a new hero into the database. +// The hero.ID field is populated from the RETURNING clause. +// Default weapon_id=1 (Rusty Dagger) and armor_id=1 (Leather Armor). +func (s *HeroStore) Create(ctx context.Context, hero *model.Hero) error { + now := time.Now() + + // Default equipment IDs. + var weaponID int64 = 1 + var armorID int64 = 1 + hero.WeaponID = &weaponID + hero.ArmorID = &armorID + hero.CreatedAt = now + hero.UpdatedAt = now + + buffChargesJSON := marshalBuffCharges(hero.BuffCharges) + + query := ` + INSERT INTO heroes ( + telegram_id, name, + hp, max_hp, attack, defense, speed, + strength, constitution, agility, luck, + state, weapon_id, armor_id, + gold, xp, level, + revive_count, subscription_active, + buff_free_charges_remaining, buff_quota_period_end, buff_charges, + position_x, position_y, potions, + total_kills, elite_kills, total_deaths, kills_since_death, legendary_drops, + last_online_at, + created_at, updated_at + ) VALUES ( + $1, $2, + $3, $4, $5, $6, $7, + $8, $9, $10, $11, + $12, $13, $14, + $15, $16, $17, + $18, $19, + $20, $21, $22, + $23, $24, $25, + $26, $27, $28, $29, $30, + $31, + $32, $33 + ) RETURNING id + ` + + err := s.pool.QueryRow(ctx, query, + hero.TelegramID, hero.Name, + hero.HP, hero.MaxHP, hero.Attack, hero.Defense, hero.Speed, + hero.Strength, hero.Constitution, hero.Agility, hero.Luck, + string(hero.State), hero.WeaponID, hero.ArmorID, + hero.Gold, hero.XP, hero.Level, + hero.ReviveCount, hero.SubscriptionActive, + hero.BuffFreeChargesRemaining, hero.BuffQuotaPeriodEnd, buffChargesJSON, + hero.PositionX, hero.PositionY, hero.Potions, + hero.TotalKills, hero.EliteKills, hero.TotalDeaths, hero.KillsSinceDeath, hero.LegendaryDrops, + hero.LastOnlineAt, + hero.CreatedAt, hero.UpdatedAt, + ).Scan(&hero.ID) + if err != nil { + return fmt.Errorf("insert hero: %w", err) + } + + // Create default starter gear and equip it. + if err := s.createDefaultGear(ctx, hero.ID); err != nil { + return fmt.Errorf("create default gear: %w", err) + } + + return nil +} + +// createDefaultGear creates starter weapon (Rusty Dagger) and armor (Leather Armor) +// as gear items and equips them for a new hero. +func (s *HeroStore) createDefaultGear(ctx context.Context, heroID int64) error { + starterWeapon := &model.GearItem{ + Slot: model.SlotMainHand, + FormID: "gear.form.main_hand.daggers", + Name: "Rusty Dagger", + Subtype: "daggers", + Rarity: model.RarityCommon, + Ilvl: 1, + BasePrimary: 3, + PrimaryStat: 3, + StatType: "attack", + SpeedModifier: 1.3, + CritChance: 0.05, + } + if err := s.gearStore.CreateItem(ctx, starterWeapon); err != nil { + return fmt.Errorf("create starter weapon: %w", err) + } + if err := s.gearStore.EquipItem(ctx, heroID, model.SlotMainHand, starterWeapon.ID); err != nil { + return fmt.Errorf("equip starter weapon: %w", err) + } + + starterArmor := &model.GearItem{ + Slot: model.SlotChest, + FormID: "gear.form.chest.light", + Name: "Leather Armor", + Subtype: "light", + Rarity: model.RarityCommon, + Ilvl: 1, + BasePrimary: 3, + PrimaryStat: 3, + StatType: "defense", + SpeedModifier: 1.05, + AgilityBonus: 3, + } + if err := s.gearStore.CreateItem(ctx, starterArmor); err != nil { + return fmt.Errorf("create starter armor: %w", err) + } + if err := s.gearStore.EquipItem(ctx, heroID, model.SlotChest, starterArmor.ID); err != nil { + return fmt.Errorf("equip starter armor: %w", err) + } + + return nil +} + +// Save updates a hero's mutable fields in the database. +func (s *HeroStore) Save(ctx context.Context, hero *model.Hero) error { + hero.UpdatedAt = time.Now() + buffChargesJSON := marshalBuffCharges(hero.BuffCharges) + + query := ` + UPDATE heroes SET + hp = $1, max_hp = $2, + attack = $3, defense = $4, speed = $5, + strength = $6, constitution = $7, agility = $8, luck = $9, + state = $10, weapon_id = $11, armor_id = $12, + gold = $13, xp = $14, level = $15, + revive_count = $16, subscription_active = $17, + buff_free_charges_remaining = $18, buff_quota_period_end = $19, buff_charges = $20, + position_x = $21, position_y = $22, potions = $23, + total_kills = $24, elite_kills = $25, total_deaths = $26, + kills_since_death = $27, legendary_drops = $28, + last_online_at = $29, + updated_at = $30, + destination_town_id = $32, + current_town_id = $33, + move_state = $34 + WHERE id = $31 + ` + + tag, err := s.pool.Exec(ctx, query, + hero.HP, hero.MaxHP, + hero.Attack, hero.Defense, hero.Speed, + hero.Strength, hero.Constitution, hero.Agility, hero.Luck, + string(hero.State), hero.WeaponID, hero.ArmorID, + hero.Gold, hero.XP, hero.Level, + hero.ReviveCount, hero.SubscriptionActive, + hero.BuffFreeChargesRemaining, hero.BuffQuotaPeriodEnd, buffChargesJSON, + hero.PositionX, hero.PositionY, hero.Potions, + hero.TotalKills, hero.EliteKills, hero.TotalDeaths, + hero.KillsSinceDeath, hero.LegendaryDrops, + hero.LastOnlineAt, + hero.UpdatedAt, + hero.ID, + hero.DestinationTownID, + hero.CurrentTownID, + hero.MoveState, + ) + if err != nil { + return fmt.Errorf("update hero: %w", err) + } + + if tag.RowsAffected() == 0 { + return fmt.Errorf("update hero: no rows affected (id=%d)", hero.ID) + } + + if err := s.saveHeroBuffsAndDebuffs(ctx, hero); err != nil { + return fmt.Errorf("update hero buffs/debuffs: %w", err) + } + + s.logger.Info("saved hero", "hero", hero) + + return nil +} + +// SavePosition is a lightweight UPDATE that persists only the hero's world position. +// Called frequently as the hero moves around the map. +func (s *HeroStore) SavePosition(ctx context.Context, heroID int64, x, y float64) error { + _, err := s.pool.Exec(ctx, `UPDATE heroes SET position_x = $1, position_y = $2, updated_at = now() WHERE id = $3`, x, y, heroID) + if err != nil { + return fmt.Errorf("save position: %w", err) + } + return nil +} + +// GetOrCreate loads a hero by Telegram ID, creating one with default stats if not found. +// This is the main entry point used by auth and hero init flows. +func (s *HeroStore) GetOrCreate(ctx context.Context, telegramID int64, name string) (*model.Hero, error) { + hero, err := s.GetByTelegramID(ctx, telegramID) + if err != nil { + return nil, fmt.Errorf("get or create hero: %w", err) + } + + if hero != nil { + hero.XPToNext = model.XPToNextLevel(hero.Level) + return hero, nil + } + + // Create a new hero with default stats. + hero = &model.Hero{ + TelegramID: telegramID, + Name: name, + HP: 100, + MaxHP: 100, + Attack: 10, + Defense: 5, + Speed: 1.0, + Strength: 1, + Constitution: 1, + Agility: 1, + Luck: 1, + State: model.StateWalking, + Gold: 0, + XP: 0, + Level: 1, + BuffFreeChargesRemaining: model.FreeBuffActivationsPerPeriod, + } + + if err := s.Create(ctx, hero); err != nil { + return nil, fmt.Errorf("get or create hero: %w", err) + } + + // Reload to get the gear and buff data. + hero, err = s.GetByID(ctx, hero.ID) + if err != nil { + return nil, fmt.Errorf("get or create hero reload: %w", err) + } + + return hero, nil +} + +// ListOfflineHeroes returns heroes that are walking but haven't been updated +// recently (i.e. the client is offline). Only loads base hero data without +// weapon/armor JOINs — the simulation uses EffectiveAttackAt/EffectiveDefenseAt +// which work with base stats and any loaded equipment. +func (s *HeroStore) ListOfflineHeroes(ctx context.Context, offlineThreshold time.Duration, limit int) ([]*model.Hero, error) { + if limit <= 0 { + limit = 100 + } + if limit > 500 { + limit = 500 + } + + cutoff := time.Now().Add(-offlineThreshold) + + query := heroSelectQuery + ` + WHERE h.state = 'walking' AND h.hp > 0 AND h.updated_at < $1 + ORDER BY h.updated_at ASC + LIMIT $2 + ` + + rows, err := s.pool.Query(ctx, query, cutoff, limit) + if err != nil { + return nil, fmt.Errorf("list offline heroes: %w", err) + } + defer rows.Close() + + var heroes []*model.Hero + for rows.Next() { + h, err := scanHeroFromRows(rows) + if err != nil { + return nil, fmt.Errorf("list offline heroes scan: %w", err) + } + heroes = append(heroes, h) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("list offline heroes rows: %w", err) + } + for _, h := range heroes { + if err := s.loadHeroGear(ctx, h); err != nil { + return nil, fmt.Errorf("list offline heroes load gear: %w", err) + } + } + return heroes, nil +} + +// scanHeroFromRows scans the current row from pgx.Rows into a Hero struct. +// Gear is loaded separately via loadHeroGear after scanning. +func scanHeroFromRows(rows pgx.Rows) (*model.Hero, error) { + var h model.Hero + var state string + var buffChargesRaw []byte + + err := rows.Scan( + &h.ID, &h.TelegramID, &h.Name, + &h.HP, &h.MaxHP, &h.Attack, &h.Defense, &h.Speed, + &h.Strength, &h.Constitution, &h.Agility, &h.Luck, + &state, &h.WeaponID, &h.ArmorID, + &h.Gold, &h.XP, &h.Level, + &h.ReviveCount, &h.SubscriptionActive, + &h.BuffFreeChargesRemaining, &h.BuffQuotaPeriodEnd, &buffChargesRaw, + &h.PositionX, &h.PositionY, &h.Potions, + &h.TotalKills, &h.EliteKills, &h.TotalDeaths, &h.KillsSinceDeath, &h.LegendaryDrops, + &h.CurrentTownID, &h.DestinationTownID, &h.MoveState, + &h.LastOnlineAt, + &h.CreatedAt, &h.UpdatedAt, + ) + if err != nil { + return nil, fmt.Errorf("scan hero from rows: %w", err) + } + h.BuffCharges = unmarshalBuffCharges(buffChargesRaw) + h.State = model.GameState(state) + h.Gear = make(map[model.EquipmentSlot]*model.GearItem) + + return &h, nil +} + +// scanHeroRow scans a single row from the hero query into a Hero struct. +// Returns (nil, nil) when the row is pgx.ErrNoRows. +// Gear is loaded separately via loadHeroGear after scanning. +func scanHeroRow(row pgx.Row) (*model.Hero, error) { + var h model.Hero + var state string + var buffChargesRaw []byte + + err := row.Scan( + &h.ID, &h.TelegramID, &h.Name, + &h.HP, &h.MaxHP, &h.Attack, &h.Defense, &h.Speed, + &h.Strength, &h.Constitution, &h.Agility, &h.Luck, + &state, &h.WeaponID, &h.ArmorID, + &h.Gold, &h.XP, &h.Level, + &h.ReviveCount, &h.SubscriptionActive, + &h.BuffFreeChargesRemaining, &h.BuffQuotaPeriodEnd, &buffChargesRaw, + &h.PositionX, &h.PositionY, &h.Potions, + &h.TotalKills, &h.EliteKills, &h.TotalDeaths, &h.KillsSinceDeath, &h.LegendaryDrops, + &h.CurrentTownID, &h.DestinationTownID, &h.MoveState, + &h.LastOnlineAt, + &h.CreatedAt, &h.UpdatedAt, + ) + if err != nil { + if err == pgx.ErrNoRows { + return nil, nil + } + return nil, fmt.Errorf("scan hero row: %w", err) + } + h.BuffCharges = unmarshalBuffCharges(buffChargesRaw) + h.State = model.GameState(state) + h.Gear = make(map[model.EquipmentSlot]*model.GearItem) + + return &h, nil +} + +// loadHeroGear populates the hero's Gear map from the hero_gear table. +func (s *HeroStore) loadHeroGear(ctx context.Context, hero *model.Hero) error { + gear, err := s.gearStore.GetHeroGear(ctx, hero.ID) + if err != nil { + return fmt.Errorf("load hero gear: %w", err) + } + hero.Gear = gear + return nil +} + +// loadHeroBuffsAndDebuffs populates the hero's Buffs and Debuffs from the +// hero_active_buffs / hero_active_debuffs tables, filtering out expired entries. +func (s *HeroStore) loadHeroBuffsAndDebuffs(ctx context.Context, hero *model.Hero) error { + now := time.Now() + + // Active buffs. + buffRows, err := s.pool.Query(ctx, ` + SELECT b.id, b.type, b.name, b.duration_ms, b.magnitude, b.cooldown_ms, + hab.applied_at, hab.expires_at + FROM hero_active_buffs hab + JOIN buffs b ON hab.buff_id = b.id + WHERE hab.hero_id = $1 AND hab.expires_at > $2 + ORDER BY hab.applied_at + `, hero.ID, now) + if err != nil { + return fmt.Errorf("load active buffs: %w", err) + } + defer buffRows.Close() + + for buffRows.Next() { + var ab model.ActiveBuff + var durationMs, cooldownMs int64 + if err := buffRows.Scan( + &ab.Buff.ID, &ab.Buff.Type, &ab.Buff.Name, + &durationMs, &ab.Buff.Magnitude, &cooldownMs, + &ab.AppliedAt, &ab.ExpiresAt, + ); err != nil { + return fmt.Errorf("scan active buff: %w", err) + } + ab.Buff.Duration = time.Duration(durationMs) * time.Millisecond + ab.Buff.CooldownDuration = time.Duration(cooldownMs) * time.Millisecond + hero.Buffs = append(hero.Buffs, ab) + } + if err := buffRows.Err(); err != nil { + return fmt.Errorf("load active buffs rows: %w", err) + } + + // Active debuffs. + debuffRows, err := s.pool.Query(ctx, ` + SELECT d.id, d.type, d.name, d.duration_ms, d.magnitude, + had.applied_at, had.expires_at + FROM hero_active_debuffs had + JOIN debuffs d ON had.debuff_id = d.id + WHERE had.hero_id = $1 AND had.expires_at > $2 + ORDER BY had.applied_at + `, hero.ID, now) + if err != nil { + return fmt.Errorf("load active debuffs: %w", err) + } + defer debuffRows.Close() + + for debuffRows.Next() { + var ad model.ActiveDebuff + var durationMs int64 + if err := debuffRows.Scan( + &ad.Debuff.ID, &ad.Debuff.Type, &ad.Debuff.Name, + &durationMs, &ad.Debuff.Magnitude, + &ad.AppliedAt, &ad.ExpiresAt, + ); err != nil { + return fmt.Errorf("scan active debuff: %w", err) + } + ad.Debuff.Duration = time.Duration(durationMs) * time.Millisecond + hero.Debuffs = append(hero.Debuffs, ad) + } + if err := debuffRows.Err(); err != nil { + return fmt.Errorf("load active debuffs rows: %w", err) + } + + return nil +} + +// saveHeroBuffsAndDebuffs replaces the hero's active buff/debuff rows in the DB. +// Expired entries are pruned. Uses a transaction for consistency. +func (s *HeroStore) saveHeroBuffsAndDebuffs(ctx context.Context, hero *model.Hero) error { + now := time.Now() + + tx, err := s.pool.Begin(ctx) + if err != nil { + return fmt.Errorf("save buffs/debuffs begin tx: %w", err) + } + defer tx.Rollback(ctx) + + // Replace active buffs. + if _, err := tx.Exec(ctx, `DELETE FROM hero_active_buffs WHERE hero_id = $1`, hero.ID); err != nil { + return fmt.Errorf("delete active buffs: %w", err) + } + for _, ab := range hero.Buffs { + if ab.IsExpired(now) { + continue + } + _, err := tx.Exec(ctx, ` + INSERT INTO hero_active_buffs (hero_id, buff_id, applied_at, expires_at) + VALUES ($1, (SELECT id FROM buffs WHERE type = $2 LIMIT 1), $3, $4) + `, hero.ID, string(ab.Buff.Type), ab.AppliedAt, ab.ExpiresAt) + if err != nil { + return fmt.Errorf("insert active buff %s: %w", ab.Buff.Type, err) + } + } + + // Replace active debuffs. + if _, err := tx.Exec(ctx, `DELETE FROM hero_active_debuffs WHERE hero_id = $1`, hero.ID); err != nil { + return fmt.Errorf("delete active debuffs: %w", err) + } + for _, ad := range hero.Debuffs { + if ad.IsExpired(now) { + continue + } + _, err := tx.Exec(ctx, ` + INSERT INTO hero_active_debuffs (hero_id, debuff_id, applied_at, expires_at) + VALUES ($1, (SELECT id FROM debuffs WHERE type = $2 LIMIT 1), $3, $4) + `, hero.ID, string(ad.Debuff.Type), ad.AppliedAt, ad.ExpiresAt) + if err != nil { + return fmt.Errorf("insert active debuff %s: %w", ad.Debuff.Type, err) + } + } + + return tx.Commit(ctx) +} + +// marshalBuffCharges converts the in-memory buff charges map to JSON bytes for +// storage in the JSONB column. Returns "{}" for nil/empty maps. +func marshalBuffCharges(m map[string]model.BuffChargeState) []byte { + if len(m) == 0 { + return []byte("{}") + } + b, err := json.Marshal(m) + if err != nil { + return []byte("{}") + } + return b +} + +// unmarshalBuffCharges parses raw JSON bytes from the buff_charges JSONB column +// into the in-memory map. Returns an empty map on nil/empty/invalid input. +func unmarshalBuffCharges(raw []byte) map[string]model.BuffChargeState { + if len(raw) == 0 { + return make(map[string]model.BuffChargeState) + } + var m map[string]model.BuffChargeState + if err := json.Unmarshal(raw, &m); err != nil || m == nil { + return make(map[string]model.BuffChargeState) + } + return m +} + +// HeroSummary is a lightweight projection of a hero for nearby-heroes queries. +type HeroSummary struct { + ID int64 `json:"id"` + Name string `json:"name"` + Level int `json:"level"` + PositionX float64 `json:"positionX"` + PositionY float64 `json:"positionY"` +} + +// UpdateOnlineStatus updates last_online_at and position for shared-world presence. +func (s *HeroStore) UpdateOnlineStatus(ctx context.Context, heroID int64, posX, posY float64) error { + _, err := s.pool.Exec(ctx, + `UPDATE heroes SET last_online_at = now(), position_x = $1, position_y = $2 WHERE id = $3`, + posX, posY, heroID, + ) + if err != nil { + return fmt.Errorf("update online status: %w", err) + } + return nil +} + +// GetNearbyHeroes returns other heroes within radius who were online recently (< 2 min). +func (s *HeroStore) GetNearbyHeroes(ctx context.Context, heroID int64, posX, posY, radius float64, limit int) ([]HeroSummary, error) { + if limit <= 0 { + limit = 20 + } + if limit > 100 { + limit = 100 + } + + cutoff := time.Now().Add(-2 * time.Minute) + + rows, err := s.pool.Query(ctx, ` + SELECT id, name, level, position_x, position_y + FROM heroes + WHERE id != $1 + AND last_online_at > $2 + AND sqrt(power(position_x - $3, 2) + power(position_y - $4, 2)) <= $5 + ORDER BY last_online_at DESC + LIMIT $6 + `, heroID, cutoff, posX, posY, radius, limit) + if err != nil { + return nil, fmt.Errorf("get nearby heroes: %w", err) + } + defer rows.Close() + + var heroes []HeroSummary + for rows.Next() { + var h HeroSummary + if err := rows.Scan(&h.ID, &h.Name, &h.Level, &h.PositionX, &h.PositionY); err != nil { + return nil, fmt.Errorf("scan nearby hero: %w", err) + } + heroes = append(heroes, h) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("nearby heroes rows: %w", err) + } + if heroes == nil { + heroes = []HeroSummary{} + } + return heroes, nil +} + +// SaveName updates only the hero's name field. Returns an error wrapping +// "UNIQUE" if the name violates the case-insensitive uniqueness constraint. +func (s *HeroStore) SaveName(ctx context.Context, heroID int64, name string) error { + _, err := s.pool.Exec(ctx, + `UPDATE heroes SET name = $1, updated_at = now() WHERE id = $2`, + name, heroID, + ) + if err != nil { + return fmt.Errorf("save hero name: %w", err) + } + return nil +} + +// CreatePayment inserts a payment record and returns the generated ID. +func (s *HeroStore) CreatePayment(ctx context.Context, p *model.Payment) error { + query := ` + INSERT INTO payments (hero_id, type, buff_type, amount_rub, status, created_at, completed_at) + VALUES ($1, $2, $3, $4, $5, $6, $7) + RETURNING id + ` + return s.pool.QueryRow(ctx, query, + p.HeroID, string(p.Type), p.BuffType, p.AmountRUB, string(p.Status), + p.CreatedAt, p.CompletedAt, + ).Scan(&p.ID) +} + +func derefStr(p *string) string { + if p == nil { + return "" + } + return *p +} + +func derefInt(p *int) int { + if p == nil { + return 0 + } + return *p +} + +func derefFloat(p *float64) float64 { + if p == nil { + return 0 + } + return *p +} diff --git a/backend/internal/storage/log_store.go b/backend/internal/storage/log_store.go new file mode 100644 index 0000000..9e91bac --- /dev/null +++ b/backend/internal/storage/log_store.go @@ -0,0 +1,117 @@ +package storage + +import ( + "context" + "fmt" + "time" + + "github.com/jackc/pgx/v5/pgxpool" +) + +// LogEntry represents a single adventure log message. +type LogEntry struct { + ID int64 `json:"id"` + HeroID int64 `json:"heroId"` + Message string `json:"message"` + CreatedAt time.Time `json:"createdAt"` +} + +// LogStore handles adventure log CRUD operations against PostgreSQL. +type LogStore struct { + pool *pgxpool.Pool +} + +// NewLogStore creates a new LogStore backed by the given connection pool. +func NewLogStore(pool *pgxpool.Pool) *LogStore { + return &LogStore{pool: pool} +} + +// Add inserts a new adventure log entry for the given hero. +func (s *LogStore) Add(ctx context.Context, heroID int64, message string) error { + _, err := s.pool.Exec(ctx, + `INSERT INTO adventure_log (hero_id, message) VALUES ($1, $2)`, + heroID, message, + ) + if err != nil { + return fmt.Errorf("add log entry: %w", err) + } + return nil +} + +// GetSince returns log entries for a hero created after the given timestamp, +// ordered oldest-first (chronological). Used to build offline reports from +// real adventure log entries written by the offline simulator. +func (s *LogStore) GetSince(ctx context.Context, heroID int64, since time.Time, limit int) ([]LogEntry, error) { + if limit <= 0 { + limit = 200 + } + if limit > 500 { + limit = 500 + } + + rows, err := s.pool.Query(ctx, ` + SELECT id, hero_id, message, created_at + FROM adventure_log + WHERE hero_id = $1 AND created_at > $2 + ORDER BY created_at ASC + LIMIT $3 + `, heroID, since, limit) + if err != nil { + return nil, fmt.Errorf("get log since: %w", err) + } + defer rows.Close() + + var entries []LogEntry + for rows.Next() { + var e LogEntry + if err := rows.Scan(&e.ID, &e.HeroID, &e.Message, &e.CreatedAt); err != nil { + return nil, fmt.Errorf("scan log entry: %w", err) + } + entries = append(entries, e) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("log since rows: %w", err) + } + if entries == nil { + entries = []LogEntry{} + } + return entries, nil +} + +// GetRecent returns the most recent log entries for a hero, ordered newest-first. +func (s *LogStore) GetRecent(ctx context.Context, heroID int64, limit int) ([]LogEntry, error) { + if limit <= 0 { + limit = 50 + } + if limit > 200 { + limit = 200 + } + + rows, err := s.pool.Query(ctx, ` + SELECT id, hero_id, message, created_at + FROM adventure_log + WHERE hero_id = $1 + ORDER BY created_at DESC + LIMIT $2 + `, heroID, limit) + if err != nil { + return nil, fmt.Errorf("get recent log: %w", err) + } + defer rows.Close() + + var entries []LogEntry + for rows.Next() { + var e LogEntry + if err := rows.Scan(&e.ID, &e.HeroID, &e.Message, &e.CreatedAt); err != nil { + return nil, fmt.Errorf("scan log entry: %w", err) + } + entries = append(entries, e) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("log entries rows: %w", err) + } + if entries == nil { + entries = []LogEntry{} + } + return entries, nil +} diff --git a/backend/internal/storage/postgres.go b/backend/internal/storage/postgres.go new file mode 100644 index 0000000..914fee5 --- /dev/null +++ b/backend/internal/storage/postgres.go @@ -0,0 +1,41 @@ +package storage + +import ( + "context" + "fmt" + "log/slog" + + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/denisovdennis/autohero/internal/config" +) + +// NewPostgres creates a PostgreSQL connection pool. +func NewPostgres(ctx context.Context, cfg config.DBConfig, logger *slog.Logger) (*pgxpool.Pool, error) { + poolCfg, err := pgxpool.ParseConfig(cfg.DSN()) + if err != nil { + return nil, fmt.Errorf("parse postgres config: %w", err) + } + + // Sensible pool defaults for a game server. + poolCfg.MaxConns = 20 + poolCfg.MinConns = 5 + + pool, err := pgxpool.NewWithConfig(ctx, poolCfg) + if err != nil { + return nil, fmt.Errorf("create postgres pool: %w", err) + } + + if err := pool.Ping(ctx); err != nil { + pool.Close() + return nil, fmt.Errorf("ping postgres: %w", err) + } + + logger.Info("connected to PostgreSQL", + "host", cfg.Host, + "port", cfg.Port, + "database", cfg.Name, + ) + + return pool, nil +} diff --git a/backend/internal/storage/quest_store.go b/backend/internal/storage/quest_store.go new file mode 100644 index 0000000..817248c --- /dev/null +++ b/backend/internal/storage/quest_store.go @@ -0,0 +1,453 @@ +package storage + +import ( + "context" + "errors" + "fmt" + "math/rand" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/denisovdennis/autohero/internal/model" +) + +// QuestStore handles quest system CRUD operations against PostgreSQL. +type QuestStore struct { + pool *pgxpool.Pool +} + +// NewQuestStore creates a new QuestStore backed by the given connection pool. +func NewQuestStore(pool *pgxpool.Pool) *QuestStore { + return &QuestStore{pool: pool} +} + +// ListTowns returns all towns ordered by level_min ascending. +func (s *QuestStore) ListTowns(ctx context.Context) ([]model.Town, error) { + rows, err := s.pool.Query(ctx, ` + SELECT id, name, biome, world_x, world_y, radius, level_min, level_max + FROM towns + ORDER BY level_min ASC + `) + if err != nil { + return nil, fmt.Errorf("list towns: %w", err) + } + defer rows.Close() + + var towns []model.Town + for rows.Next() { + var t model.Town + if err := rows.Scan(&t.ID, &t.Name, &t.Biome, &t.WorldX, &t.WorldY, &t.Radius, &t.LevelMin, &t.LevelMax); err != nil { + return nil, fmt.Errorf("scan town: %w", err) + } + towns = append(towns, t) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("list towns rows: %w", err) + } + if towns == nil { + towns = []model.Town{} + } + return towns, nil +} + +// GetTown loads a single town by ID. Returns (nil, nil) if not found. +func (s *QuestStore) GetTown(ctx context.Context, townID int64) (*model.Town, error) { + var t model.Town + err := s.pool.QueryRow(ctx, ` + SELECT id, name, biome, world_x, world_y, radius, level_min, level_max + FROM towns WHERE id = $1 + `, townID).Scan(&t.ID, &t.Name, &t.Biome, &t.WorldX, &t.WorldY, &t.Radius, &t.LevelMin, &t.LevelMax) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, nil + } + return nil, fmt.Errorf("get town: %w", err) + } + return &t, nil +} + +// ListNPCsByTown returns all NPCs in the given town. +func (s *QuestStore) ListNPCsByTown(ctx context.Context, townID int64) ([]model.NPC, error) { + rows, err := s.pool.Query(ctx, ` + SELECT id, town_id, name, type, offset_x, offset_y + FROM npcs + WHERE town_id = $1 + ORDER BY id ASC + `, townID) + if err != nil { + return nil, fmt.Errorf("list npcs by town: %w", err) + } + defer rows.Close() + + var npcs []model.NPC + for rows.Next() { + var n model.NPC + if err := rows.Scan(&n.ID, &n.TownID, &n.Name, &n.Type, &n.OffsetX, &n.OffsetY); err != nil { + return nil, fmt.Errorf("scan npc: %w", err) + } + npcs = append(npcs, n) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("list npcs rows: %w", err) + } + if npcs == nil { + npcs = []model.NPC{} + } + return npcs, nil +} + +// GetNPCByID loads a single NPC by primary key. Returns (nil, nil) if not found. +func (s *QuestStore) GetNPCByID(ctx context.Context, npcID int64) (*model.NPC, error) { + var n model.NPC + err := s.pool.QueryRow(ctx, ` + SELECT id, town_id, name, type, offset_x, offset_y + FROM npcs WHERE id = $1 + `, npcID).Scan(&n.ID, &n.TownID, &n.Name, &n.Type, &n.OffsetX, &n.OffsetY) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, nil + } + return nil, fmt.Errorf("get npc by id: %w", err) + } + return &n, nil +} + +// ListAllNPCs returns every NPC across all towns. +func (s *QuestStore) ListAllNPCs(ctx context.Context) ([]model.NPC, error) { + rows, err := s.pool.Query(ctx, ` + SELECT id, town_id, name, type, offset_x, offset_y + FROM npcs + ORDER BY town_id ASC, id ASC + `) + if err != nil { + return nil, fmt.Errorf("list all npcs: %w", err) + } + defer rows.Close() + + var npcs []model.NPC + for rows.Next() { + var n model.NPC + if err := rows.Scan(&n.ID, &n.TownID, &n.Name, &n.Type, &n.OffsetX, &n.OffsetY); err != nil { + return nil, fmt.Errorf("scan npc: %w", err) + } + npcs = append(npcs, n) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("list all npcs rows: %w", err) + } + if npcs == nil { + npcs = []model.NPC{} + } + return npcs, nil +} + +// ListQuestsByNPCForHeroLevel returns quests offered by an NPC that match the hero level range. +func (s *QuestStore) ListQuestsByNPCForHeroLevel(ctx context.Context, npcID int64, heroLevel int) ([]model.Quest, error) { + rows, err := s.pool.Query(ctx, ` + SELECT id, npc_id, title, description, type, target_count, + target_enemy_type, target_town_id, drop_chance, + min_level, max_level, reward_xp, reward_gold, reward_potions + FROM quests + WHERE npc_id = $1 AND $2 BETWEEN min_level AND max_level + ORDER BY min_level ASC, id ASC + `, npcID, heroLevel) + if err != nil { + return nil, fmt.Errorf("list quests by npc for level: %w", err) + } + defer rows.Close() + + var quests []model.Quest + for rows.Next() { + var q model.Quest + if err := rows.Scan( + &q.ID, &q.NPCID, &q.Title, &q.Description, &q.Type, &q.TargetCount, + &q.TargetEnemyType, &q.TargetTownID, &q.DropChance, + &q.MinLevel, &q.MaxLevel, &q.RewardXP, &q.RewardGold, &q.RewardPotions, + ); err != nil { + return nil, fmt.Errorf("scan quest: %w", err) + } + quests = append(quests, q) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("list quests by npc for level rows: %w", err) + } + if quests == nil { + quests = []model.Quest{} + } + return quests, nil +} + +// ListQuestsByNPC returns all quest templates offered by the given NPC. +func (s *QuestStore) ListQuestsByNPC(ctx context.Context, npcID int64) ([]model.Quest, error) { + rows, err := s.pool.Query(ctx, ` + SELECT id, npc_id, title, description, type, target_count, + target_enemy_type, target_town_id, drop_chance, + min_level, max_level, reward_xp, reward_gold, reward_potions + FROM quests + WHERE npc_id = $1 + ORDER BY min_level ASC, id ASC + `, npcID) + if err != nil { + return nil, fmt.Errorf("list quests by npc: %w", err) + } + defer rows.Close() + + var quests []model.Quest + for rows.Next() { + var q model.Quest + if err := rows.Scan( + &q.ID, &q.NPCID, &q.Title, &q.Description, &q.Type, &q.TargetCount, + &q.TargetEnemyType, &q.TargetTownID, &q.DropChance, + &q.MinLevel, &q.MaxLevel, &q.RewardXP, &q.RewardGold, &q.RewardPotions, + ); err != nil { + return nil, fmt.Errorf("scan quest: %w", err) + } + quests = append(quests, q) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("list quests rows: %w", err) + } + if quests == nil { + quests = []model.Quest{} + } + return quests, nil +} + +// AcceptQuest creates a hero_quests row for the given hero and quest. +// Returns an error if the quest is already accepted/active. +func (s *QuestStore) AcceptQuest(ctx context.Context, heroID int64, questID int64) error { + _, err := s.pool.Exec(ctx, ` + INSERT INTO hero_quests (hero_id, quest_id, status, progress, accepted_at) + VALUES ($1, $2, 'accepted', 0, now()) + ON CONFLICT (hero_id, quest_id) DO NOTHING + `, heroID, questID) + if err != nil { + return fmt.Errorf("accept quest: %w", err) + } + return nil +} + +// ListHeroQuests returns all quests for the hero with their quest template joined. +func (s *QuestStore) ListHeroQuests(ctx context.Context, heroID int64) ([]model.HeroQuest, error) { + rows, err := s.pool.Query(ctx, ` + SELECT hq.id, hq.hero_id, hq.quest_id, hq.status, hq.progress, + hq.accepted_at, hq.completed_at, hq.claimed_at, + q.id, q.npc_id, q.title, q.description, q.type, q.target_count, + q.target_enemy_type, q.target_town_id, q.drop_chance, + q.min_level, q.max_level, q.reward_xp, q.reward_gold, q.reward_potions + FROM hero_quests hq + JOIN quests q ON hq.quest_id = q.id + WHERE hq.hero_id = $1 + ORDER BY hq.accepted_at DESC + `, heroID) + if err != nil { + return nil, fmt.Errorf("list hero quests: %w", err) + } + defer rows.Close() + + var hqs []model.HeroQuest + for rows.Next() { + var hq model.HeroQuest + var q model.Quest + if err := rows.Scan( + &hq.ID, &hq.HeroID, &hq.QuestID, &hq.Status, &hq.Progress, + &hq.AcceptedAt, &hq.CompletedAt, &hq.ClaimedAt, + &q.ID, &q.NPCID, &q.Title, &q.Description, &q.Type, &q.TargetCount, + &q.TargetEnemyType, &q.TargetTownID, &q.DropChance, + &q.MinLevel, &q.MaxLevel, &q.RewardXP, &q.RewardGold, &q.RewardPotions, + ); err != nil { + return nil, fmt.Errorf("scan hero quest: %w", err) + } + hq.Quest = &q + hqs = append(hqs, hq) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("list hero quests rows: %w", err) + } + if hqs == nil { + hqs = []model.HeroQuest{} + } + return hqs, nil +} + +// IncrementQuestProgress increments progress for all matching accepted quests. +// For kill_count: objectiveType="kill_count", targetValue=enemy type (or "" for any). +// For collect_item: objectiveType="collect_item", delta from drop chance roll. +// Quests that reach target_count are automatically marked as completed. +func (s *QuestStore) IncrementQuestProgress(ctx context.Context, heroID int64, objectiveType string, targetValue string, delta int) error { + if delta <= 0 { + return nil + } + + // Update progress for matching quests. A quest matches if: + // - It belongs to this hero and is in 'accepted' status + // - Its type matches objectiveType + // - Its target_enemy_type matches targetValue (or target_enemy_type IS NULL for "any") + var query string + var args []any + + if targetValue != "" { + query = ` + UPDATE hero_quests hq + SET progress = LEAST(progress + $3, q.target_count), + status = CASE WHEN progress + $3 >= q.target_count THEN 'completed' ELSE status END, + completed_at = CASE WHEN progress + $3 >= q.target_count AND completed_at IS NULL THEN now() ELSE completed_at END + FROM quests q + WHERE hq.quest_id = q.id + AND hq.hero_id = $1 + AND hq.status = 'accepted' + AND q.type = $2 + AND (q.target_enemy_type = $4 OR q.target_enemy_type IS NULL) + ` + args = []any{heroID, objectiveType, delta, targetValue} + } else { + query = ` + UPDATE hero_quests hq + SET progress = LEAST(progress + $3, q.target_count), + status = CASE WHEN progress + $3 >= q.target_count THEN 'completed' ELSE status END, + completed_at = CASE WHEN progress + $3 >= q.target_count AND completed_at IS NULL THEN now() ELSE completed_at END + FROM quests q + WHERE hq.quest_id = q.id + AND hq.hero_id = $1 + AND hq.status = 'accepted' + AND q.type = $2 + ` + args = []any{heroID, objectiveType, delta} + } + + _, err := s.pool.Exec(ctx, query, args...) + if err != nil { + return fmt.Errorf("increment quest progress: %w", err) + } + return nil +} + +// ClaimQuestReward marks a completed quest as claimed and returns the rewards. +// Returns an error if the quest is not in 'completed' status. +func (s *QuestStore) ClaimQuestReward(ctx context.Context, heroID int64, questID int64) (*model.QuestReward, error) { + var reward model.QuestReward + + err := s.pool.QueryRow(ctx, ` + UPDATE hero_quests hq + SET status = 'claimed', claimed_at = now() + FROM quests q + WHERE hq.quest_id = q.id + AND hq.hero_id = $1 + AND hq.id = $2 + AND hq.status = 'completed' + RETURNING q.reward_xp, q.reward_gold, q.reward_potions + `, heroID, questID).Scan(&reward.XP, &reward.Gold, &reward.Potions) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, fmt.Errorf("quest not found or not in completed status") + } + return nil, fmt.Errorf("claim quest reward: %w", err) + } + + return &reward, nil +} + +// AbandonQuest removes a hero's quest entry. Only accepted/completed quests +// can be abandoned (not already claimed). +func (s *QuestStore) AbandonQuest(ctx context.Context, heroID int64, questID int64) error { + tag, err := s.pool.Exec(ctx, ` + DELETE FROM hero_quests + WHERE hero_id = $1 AND quest_id = $2 AND status != 'claimed' + `, heroID, questID) + if err != nil { + return fmt.Errorf("abandon quest: %w", err) + } + if tag.RowsAffected() == 0 { + return fmt.Errorf("quest not found or already claimed") + } + return nil +} + +// IncrementVisitTownProgress updates visit_town quests when a hero enters a town. +func (s *QuestStore) IncrementVisitTownProgress(ctx context.Context, heroID int64, townID int64) error { + _, err := s.pool.Exec(ctx, ` + UPDATE hero_quests hq + SET progress = LEAST(progress + 1, q.target_count), + status = CASE WHEN progress + 1 >= q.target_count THEN 'completed' ELSE status END, + completed_at = CASE WHEN progress + 1 >= q.target_count AND completed_at IS NULL THEN now() ELSE completed_at END + FROM quests q + WHERE hq.quest_id = q.id + AND hq.hero_id = $1 + AND hq.status = 'accepted' + AND q.type = 'visit_town' + AND q.target_town_id = $2 + `, heroID, townID) + if err != nil { + return fmt.Errorf("increment visit town progress: %w", err) + } + return nil +} + +// IncrementCollectItemProgress increments collect_item quests by rolling the drop_chance. +// Called after a kill; each matching quest gets a roll for each delta kill. +func (s *QuestStore) IncrementCollectItemProgress(ctx context.Context, heroID int64, enemyType string) error { + // Fetch active collect_item quests for this hero + rows, err := s.pool.Query(ctx, ` + SELECT hq.id, q.target_count, hq.progress, q.drop_chance, q.target_enemy_type + FROM hero_quests hq + JOIN quests q ON hq.quest_id = q.id + WHERE hq.hero_id = $1 + AND hq.status = 'accepted' + AND q.type = 'collect_item' + `, heroID) + if err != nil { + return fmt.Errorf("list collect item quests: %w", err) + } + defer rows.Close() + + type collectQuest struct { + hqID int64 + targetCount int + progress int + dropChance float64 + targetEnemyType *string + } + var cqs []collectQuest + for rows.Next() { + var cq collectQuest + if err := rows.Scan(&cq.hqID, &cq.targetCount, &cq.progress, &cq.dropChance, &cq.targetEnemyType); err != nil { + return fmt.Errorf("scan collect quest: %w", err) + } + cqs = append(cqs, cq) + } + if err := rows.Err(); err != nil { + return fmt.Errorf("collect item quests rows: %w", err) + } + + for _, cq := range cqs { + // Check if the enemy type matches (nil = any enemy) + if cq.targetEnemyType != nil && *cq.targetEnemyType != enemyType { + continue + } + if cq.progress >= cq.targetCount { + continue + } + // Roll the drop chance + roll := randFloat64() + if roll >= cq.dropChance { + continue + } + // Increment progress by 1 + _, err := s.pool.Exec(ctx, ` + UPDATE hero_quests + SET progress = LEAST(progress + 1, $2), + status = CASE WHEN progress + 1 >= $2 THEN 'completed' ELSE status END, + completed_at = CASE WHEN progress + 1 >= $2 AND completed_at IS NULL THEN now() ELSE completed_at END + WHERE id = $1 + `, cq.hqID, cq.targetCount) + if err != nil { + return fmt.Errorf("update collect item progress: %w", err) + } + } + + return nil +} + +// randFloat64 wraps rand.Float64 for testability. +var randFloat64 = rand.Float64 diff --git a/backend/internal/storage/redis.go b/backend/internal/storage/redis.go new file mode 100644 index 0000000..9746f9d --- /dev/null +++ b/backend/internal/storage/redis.go @@ -0,0 +1,28 @@ +package storage + +import ( + "context" + "fmt" + "log/slog" + + "github.com/redis/go-redis/v9" + + "github.com/denisovdennis/autohero/internal/config" +) + +// NewRedis creates a Redis client and verifies the connection. +func NewRedis(ctx context.Context, cfg config.RedisConfig, logger *slog.Logger) (*redis.Client, error) { + client := redis.NewClient(&redis.Options{ + Addr: cfg.Addr, + DB: 0, + PoolSize: 20, + }) + + if err := client.Ping(ctx).Err(); err != nil { + return nil, fmt.Errorf("ping redis: %w", err) + } + + logger.Info("connected to Redis", "addr", cfg.Addr) + + return client, nil +} diff --git a/backend/internal/world/service.go b/backend/internal/world/service.go new file mode 100644 index 0000000..d50d343 --- /dev/null +++ b/backend/internal/world/service.go @@ -0,0 +1,278 @@ +package world + +import ( + "crypto/sha1" + "encoding/hex" + "encoding/json" + "fmt" + "hash/fnv" + "math/rand" + "strings" +) + +const mapVersion = "v1" + +// MapRef is a lightweight map descriptor returned by hero init. +type MapRef struct { + MapID string `json:"mapId"` + MapVersion string `json:"mapVersion"` + ETag string `json:"etag"` + Biome string `json:"biome"` + RecommendedLevelMin int `json:"recommendedLevelMin"` + RecommendedLevelMax int `json:"recommendedLevelMax"` +} + +// Tile is a single ground cell in the map grid. +type Tile struct { + X int `json:"x"` + Y int `json:"y"` + Terrain string `json:"terrain"` +} + +// Object is a world object rendered on top of tiles. +type Object struct { + ID string `json:"id"` + Type string `json:"type"` + X int `json:"x"` + Y int `json:"y"` +} + +// SpawnPoint defines where entities can be spawned. +type SpawnPoint struct { + ID string `json:"id"` + Kind string `json:"kind"` + X int `json:"x"` + Y int `json:"y"` +} + +// ServerMap is the full map payload returned by /maps/{mapId}. +type ServerMap struct { + MapID string `json:"mapId"` + MapVersion string `json:"mapVersion"` + Biome string `json:"biome"` + RecommendedLevelMin int `json:"recommendedLevelMin"` + RecommendedLevelMax int `json:"recommendedLevelMax"` + Width int `json:"width"` + Height int `json:"height"` + Tiles []Tile `json:"tiles"` + Objects []Object `json:"objects"` + SpawnPoints []SpawnPoint `json:"spawnPoints"` +} + +type levelBand struct { + min int + max int + biome string +} + +var levelBands = []levelBand{ + {min: 1, max: 10, biome: "meadow"}, + {min: 11, max: 20, biome: "forest"}, + {min: 21, max: 35, biome: "ruins"}, + {min: 36, max: 50, biome: "canyon"}, + {min: 51, max: 70, biome: "swamp"}, + {min: 71, max: 100, biome: "volcanic"}, + {min: 101, max: 999, biome: "astral"}, +} + +type mapData struct { + ref MapRef + data ServerMap +} + +// Service provides deterministic map refs and payloads for MVP. +type Service struct { + byID map[string]mapData +} + +// NewService creates a map service with precomputed deterministic maps. +func NewService() *Service { + s := &Service{ + byID: make(map[string]mapData, len(levelBands)), + } + for _, band := range levelBands { + mapID := fmt.Sprintf("%s-%d-%d", band.biome, band.min, band.max) + serverMap := generateMap(mapID, band) + etag := computeETag(serverMap) + s.byID[mapID] = mapData{ + ref: MapRef{ + MapID: mapID, + MapVersion: mapVersion, + ETag: etag, + Biome: band.biome, + RecommendedLevelMin: band.min, + RecommendedLevelMax: band.max, + }, + data: serverMap, + } + } + return s +} + +// RefForLevel returns a deterministic map reference for hero level. +func (s *Service) RefForLevel(level int) MapRef { + band := bandForLevel(level) + mapID := fmt.Sprintf("%s-%d-%d", band.biome, band.min, band.max) + if entry, ok := s.byID[mapID]; ok { + return entry.ref + } + // Fallback should not happen in normal flow. + return MapRef{ + MapID: mapID, + MapVersion: mapVersion, + Biome: band.biome, + RecommendedLevelMin: band.min, + RecommendedLevelMax: band.max, + } +} + +// GetMap returns map payload and ETag by map ID. +func (s *Service) GetMap(mapID string) (*ServerMap, string, bool) { + entry, ok := s.byID[strings.TrimSpace(mapID)] + if !ok { + return nil, "", false + } + m := entry.data + return &m, entry.ref.ETag, true +} + +func bandForLevel(level int) levelBand { + if level < 1 { + level = 1 + } + for _, b := range levelBands { + if level >= b.min && level <= b.max { + return b + } + } + return levelBands[len(levelBands)-1] +} + +func generateMap(mapID string, band levelBand) ServerMap { + const ( + width = 24 + height = 24 + ) + + seed := hashSeed(mapID, band.biome, band.min, band.max) + rng := rand.New(rand.NewSource(seed)) + + tiles := make([]Tile, 0, width*height) + isRoad := make(map[[2]int]struct{}, width*2) + + roadY := clamp(9+rng.Intn(6), 2, height-3) + currentY := roadY + for x := 0; x < width; x++ { + if x > 0 && x%4 == 0 { + currentY = clamp(currentY+rng.Intn(3)-1, 2, height-3) + } + isRoad[[2]int{x, currentY}] = struct{}{} + isRoad[[2]int{x, currentY + 1}] = struct{}{} + } + + baseTerrain := biomeBaseTerrain(band.biome) + for y := 0; y < height; y++ { + for x := 0; x < width; x++ { + terrain := baseTerrain + if _, ok := isRoad[[2]int{x, y}]; ok { + terrain = "road" + } + tiles = append(tiles, Tile{ + X: x, + Y: y, + Terrain: terrain, + }) + } + } + + objects := make([]Object, 0, 96) + objID := 1 + for y := 1; y < height-1; y++ { + for x := 1; x < width-1; x++ { + if _, ok := isRoad[[2]int{x, y}]; ok { + continue + } + roll := rng.Intn(1000) + switch { + case roll < 70: + objects = append(objects, Object{ + ID: fmt.Sprintf("obj-%d", objID), + Type: "tree", + X: x, + Y: y, + }) + objID++ + case roll < 120: + objects = append(objects, Object{ + ID: fmt.Sprintf("obj-%d", objID), + Type: "bush", + X: x, + Y: y, + }) + objID++ + } + } + } + + spawnPoints := []SpawnPoint{ + {ID: "hero-start", Kind: "hero", X: 1, Y: roadY}, + {ID: "enemy-main", Kind: "enemy", X: width - 3, Y: roadY}, + {ID: "enemy-alt", Kind: "enemy", X: width - 5, Y: clamp(roadY+1, 1, height-2)}, + } + + return ServerMap{ + MapID: mapID, + MapVersion: mapVersion, + Biome: band.biome, + RecommendedLevelMin: band.min, + RecommendedLevelMax: band.max, + Width: width, + Height: height, + Tiles: tiles, + Objects: objects, + SpawnPoints: spawnPoints, + } +} + +func biomeBaseTerrain(biome string) string { + switch biome { + case "forest", "meadow": + return "grass" + case "canyon": + return "dirt" + case "ruins": + return "stone" + case "swamp": + return "mud" + case "volcanic": + return "ash" + case "astral": + return "ether" + default: + return "grass" + } +} + +func computeETag(m ServerMap) string { + payload, _ := json.Marshal(m) + sum := sha1.Sum(payload) + return `"` + hex.EncodeToString(sum[:]) + `"` +} + +func hashSeed(parts ...any) int64 { + h := fnv.New64a() + for _, p := range parts { + fmt.Fprint(h, p, "|") + } + return int64(h.Sum64() & 0x7fffffffffffffff) +} + +func clamp(v, min, max int) int { + if v < min { + return min + } + if v > max { + return max + } + return v +} diff --git a/backend/migrations/000001_init.sql b/backend/migrations/000001_init.sql new file mode 100644 index 0000000..57bde0f --- /dev/null +++ b/backend/migrations/000001_init.sql @@ -0,0 +1,206 @@ +-- AutoHero initial schema migration + +CREATE TABLE IF NOT EXISTS weapons ( + id BIGSERIAL PRIMARY KEY, + name TEXT NOT NULL, + type TEXT NOT NULL CHECK (type IN ('daggers', 'sword', 'axe')), + rarity TEXT NOT NULL DEFAULT 'common' CHECK (rarity IN ('common', 'uncommon', 'rare', 'epic', 'legendary')), + damage INT NOT NULL DEFAULT 0, + speed DOUBLE PRECISION NOT NULL DEFAULT 1.0, + crit_chance DOUBLE PRECISION NOT NULL DEFAULT 0.0, + special_effect TEXT NOT NULL DEFAULT '', + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE IF NOT EXISTS armor ( + id BIGSERIAL PRIMARY KEY, + name TEXT NOT NULL, + type TEXT NOT NULL CHECK (type IN ('light', 'medium', 'heavy')), + rarity TEXT NOT NULL DEFAULT 'common' CHECK (rarity IN ('common', 'uncommon', 'rare', 'epic', 'legendary')), + defense INT NOT NULL DEFAULT 0, + speed_modifier DOUBLE PRECISION NOT NULL DEFAULT 1.0, + agility_bonus INT NOT NULL DEFAULT 0, + set_name TEXT NOT NULL DEFAULT '', + special_effect TEXT NOT NULL DEFAULT '', + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE IF NOT EXISTS heroes ( + id BIGSERIAL PRIMARY KEY, + telegram_id BIGINT NOT NULL UNIQUE, + name TEXT NOT NULL, + hp INT NOT NULL DEFAULT 100, + max_hp INT NOT NULL DEFAULT 100, + attack INT NOT NULL DEFAULT 10, + defense INT NOT NULL DEFAULT 5, + speed DOUBLE PRECISION NOT NULL DEFAULT 1.0, + strength INT NOT NULL DEFAULT 1, + constitution INT NOT NULL DEFAULT 1, + agility INT NOT NULL DEFAULT 1, + luck INT NOT NULL DEFAULT 1, + state TEXT NOT NULL DEFAULT 'walking' CHECK (state IN ('walking', 'fighting', 'dead')), + weapon_id BIGINT REFERENCES weapons(id), + armor_id BIGINT REFERENCES armor(id), + gold BIGINT NOT NULL DEFAULT 0, + xp BIGINT NOT NULL DEFAULT 0, + level INT NOT NULL DEFAULT 1, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE INDEX IF NOT EXISTS idx_heroes_telegram_id ON heroes(telegram_id); + +CREATE TABLE IF NOT EXISTS enemies ( + id BIGSERIAL PRIMARY KEY, + type TEXT NOT NULL, + name TEXT NOT NULL, + hp INT NOT NULL, + max_hp INT NOT NULL, + attack INT NOT NULL, + defense INT NOT NULL, + speed DOUBLE PRECISION NOT NULL DEFAULT 1.0, + crit_chance DOUBLE PRECISION NOT NULL DEFAULT 0.0, + min_level INT NOT NULL DEFAULT 1, + max_level INT NOT NULL DEFAULT 100, + xp_reward BIGINT NOT NULL DEFAULT 0, + gold_reward BIGINT NOT NULL DEFAULT 0, + special_abilities TEXT[] NOT NULL DEFAULT '{}', + is_elite BOOLEAN NOT NULL DEFAULT false, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE IF NOT EXISTS buffs ( + id BIGSERIAL PRIMARY KEY, + type TEXT NOT NULL CHECK (type IN ('rush', 'rage', 'shield', 'luck', 'resurrection', 'heal', 'power_potion', 'war_cry')), + name TEXT NOT NULL, + duration_ms BIGINT NOT NULL, + magnitude DOUBLE PRECISION NOT NULL DEFAULT 0.0, + cooldown_ms BIGINT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE IF NOT EXISTS debuffs ( + id BIGSERIAL PRIMARY KEY, + type TEXT NOT NULL CHECK (type IN ('poison', 'freeze', 'burn', 'stun', 'slow', 'weaken')), + name TEXT NOT NULL, + duration_ms BIGINT NOT NULL, + magnitude DOUBLE PRECISION NOT NULL DEFAULT 0.0, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE IF NOT EXISTS hero_active_buffs ( + id BIGSERIAL PRIMARY KEY, + hero_id BIGINT NOT NULL REFERENCES heroes(id) ON DELETE CASCADE, + buff_id BIGINT NOT NULL REFERENCES buffs(id), + applied_at TIMESTAMPTZ NOT NULL DEFAULT now(), + expires_at TIMESTAMPTZ NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE INDEX IF NOT EXISTS idx_hero_active_buffs_hero ON hero_active_buffs(hero_id); +CREATE INDEX IF NOT EXISTS idx_hero_active_buffs_expires ON hero_active_buffs(expires_at); + +CREATE TABLE IF NOT EXISTS hero_active_debuffs ( + id BIGSERIAL PRIMARY KEY, + hero_id BIGINT NOT NULL REFERENCES heroes(id) ON DELETE CASCADE, + debuff_id BIGINT NOT NULL REFERENCES debuffs(id), + applied_at TIMESTAMPTZ NOT NULL DEFAULT now(), + expires_at TIMESTAMPTZ NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE INDEX IF NOT EXISTS idx_hero_active_debuffs_hero ON hero_active_debuffs(hero_id); +CREATE INDEX IF NOT EXISTS idx_hero_active_debuffs_expires ON hero_active_debuffs(expires_at); + +CREATE TABLE IF NOT EXISTS loot_history ( + id BIGSERIAL PRIMARY KEY, + hero_id BIGINT NOT NULL REFERENCES heroes(id) ON DELETE CASCADE, + enemy_type TEXT NOT NULL, + item_type TEXT NOT NULL, + item_id BIGINT, + rarity TEXT NOT NULL CHECK (rarity IN ('common', 'uncommon', 'rare', 'epic', 'legendary')), + gold_amount BIGINT NOT NULL DEFAULT 0, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE INDEX IF NOT EXISTS idx_loot_history_hero ON loot_history(hero_id); + +-- Seed all 15 weapons +INSERT INTO weapons (name, type, rarity, damage, speed, crit_chance, special_effect) VALUES + -- Daggers + ('Rusty Dagger', 'daggers', 'common', 3, 1.3, 0.05, ''), + ('Iron Dagger', 'daggers', 'uncommon', 5, 1.3, 0.08, ''), + ('Assassin''s Blade', 'daggers', 'rare', 8, 1.35, 0.20, ''), + ('Phantom Edge', 'daggers', 'epic', 12, 1.4, 0.25, ''), + ('Fang of the Void', 'daggers', 'legendary', 18, 1.5, 0.30, ''), + -- Swords + ('Iron Sword', 'sword', 'common', 7, 1.0, 0.03, ''), + ('Steel Sword', 'sword', 'uncommon', 10, 1.0, 0.05, ''), + ('Longsword', 'sword', 'rare', 15, 1.0, 0.08, ''), + ('Excalibur', 'sword', 'epic', 22, 1.05, 0.10, ''), + ('Soul Reaver', 'sword', 'legendary', 30, 1.1, 0.12, 'lifesteal'), + -- Axes + ('Rusty Axe', 'axe', 'common', 12, 0.7, 0.02, ''), + ('Battle Axe', 'axe', 'uncommon', 18, 0.7, 0.04, ''), + ('War Axe', 'axe', 'rare', 25, 0.75, 0.06, ''), + ('Infernal Axe', 'axe', 'epic', 35, 0.75, 0.08, ''), + ('Godslayer''s Edge', 'axe', 'legendary', 50, 0.8, 0.10, 'splash'); + +-- Seed all 15 armor pieces +INSERT INTO armor (name, type, rarity, defense, speed_modifier, agility_bonus, set_name, special_effect) VALUES + -- Light + ('Leather Armor', 'light', 'common', 3, 1.05, 3, '', ''), + ('Ranger''s Vest', 'light', 'uncommon', 5, 1.08, 5, '', ''), + ('Shadow Cloak', 'light', 'rare', 8, 1.10, 8, 'Assassin''s Set', 'crit_bonus'), + ('Phantom Garb', 'light', 'epic', 12, 1.12, 12, 'Assassin''s Set', 'crit_bonus'), + ('Whisper of the Void', 'light', 'legendary', 16, 1.15, 18, 'Assassin''s Set', 'crit_bonus'), + -- Medium + ('Chainmail', 'medium', 'common', 7, 1.0, 0, '', ''), + ('Reinforced Mail', 'medium', 'uncommon', 10, 1.0, 0, '', ''), + ('Battle Armor', 'medium', 'rare', 15, 1.0, 0, 'Knight''s Set', 'def_bonus'), + ('Royal Guard', 'medium', 'epic', 22, 1.0, 0, 'Knight''s Set', 'def_bonus'), + ('Crown of Eternity', 'medium', 'legendary', 30, 1.0, 0, 'Knight''s Set', 'def_bonus'), + -- Heavy + ('Iron Plate', 'heavy', 'common', 14, 0.7, -3, '', ''), + ('Steel Plate', 'heavy', 'uncommon', 20, 0.7, -3, '', ''), + ('Fortress Armor', 'heavy', 'rare', 28, 0.7, -5, 'Berserker''s Set','atk_bonus'), + ('Dragon Scale', 'heavy', 'epic', 38, 0.7, -5, 'Berserker''s Set','atk_bonus'), + ('Dragon Slayer', 'heavy', 'legendary', 50, 0.7, -5, 'Berserker''s Set','atk_bonus'); + +-- Seed all 8 buff definitions +INSERT INTO buffs (type, name, duration_ms, magnitude, cooldown_ms) VALUES + ('rush', 'Rush', 10000, 0.5, 30000), + ('rage', 'Rage', 8000, 1.0, 45000), + ('shield', 'Shield', 12000, 0.5, 40000), + ('luck', 'Luck', 15000, 1.5, 60000), + ('resurrection', 'Resurrection', 20000, 0.5, 120000), + ('heal', 'Heal', 1000, 0.5, 60000), + ('power_potion', 'Power Potion', 10000, 1.5, 90000), + ('war_cry', 'War Cry', 8000, 1.0, 60000); + +-- Seed all 6 debuff definitions +INSERT INTO debuffs (type, name, duration_ms, magnitude) VALUES + ('poison', 'Poison', 5000, 0.02), + ('freeze', 'Freeze', 3000, 0.50), + ('burn', 'Burn', 4000, 0.03), + ('stun', 'Stun', 2000, 1.00), + ('slow', 'Slow', 4000, 0.40), + ('weaken', 'Weaken', 5000, 0.30); + +-- Seed all 13 enemy templates +INSERT INTO enemies (type, name, hp, max_hp, attack, defense, speed, crit_chance, min_level, max_level, xp_reward, gold_reward, special_abilities, is_elite) VALUES + -- Basic enemies + ('wolf', 'Forest Wolf', 30, 30, 8, 2, 1.8, 0.05, 1, 5, 10, 5, '{}', false), + ('boar', 'Wild Boar', 50, 50, 15, 5, 0.8, 0.08, 2, 6, 15, 8, '{}', false), + ('zombie', 'Rotting Zombie', 80, 80, 6, 3, 0.5, 0.00, 3, 8, 12, 6, '{poison}', false), + ('spider', 'Cave Spider', 25, 25, 10, 1, 2.0, 0.15, 4, 9, 12, 7, '{critical}', false), + ('orc', 'Orc Warrior', 60, 60, 12, 8, 1.0, 0.05, 5, 12, 20, 12, '{}', false), + ('skeleton_archer', 'Skeleton Archer', 45, 45, 11, 4, 1.3, 0.06, 6, 14, 18, 10, '{dodge}', false), + ('battle_lizard', 'Battle Lizard', 90, 90, 9, 12, 0.7, 0.03, 7, 15, 22, 14, '{regen}', false), + -- Elite enemies + ('fire_demon', 'Fire Demon', 100, 100, 20, 10, 1.2, 0.10, 10, 20, 50, 30, '{burn}', true), + ('ice_guardian', 'Ice Guardian', 120, 120, 14, 15, 0.7, 0.04, 12, 22, 50, 30, '{freeze}', true), + ('skeleton_king', 'Skeleton King', 200, 200, 18, 12, 0.9, 0.08, 15, 25, 80, 50, '{regen,summon}', true), + ('water_element', 'Water Element', 250, 250, 16, 10, 0.8, 0.05, 18, 28, 100, 60, '{slow}', true), + ('forest_warden', 'Forest Warden', 400, 400, 14, 25, 0.5, 0.03, 20, 30, 120, 80, '{regen}', true), + ('lightning_titan', 'Lightning Titan', 350, 350, 30, 15, 1.5, 0.12, 25, 35, 200, 120, '{stun,chain_lightning}', true); diff --git a/backend/migrations/000002_hero_revive_subscription.sql b/backend/migrations/000002_hero_revive_subscription.sql new file mode 100644 index 0000000..814e91d --- /dev/null +++ b/backend/migrations/000002_hero_revive_subscription.sql @@ -0,0 +1,8 @@ +-- Free revive quota for non-subscribers (MVP: 2 lifetime revives unless subscription_active). + +ALTER TABLE heroes + ADD COLUMN IF NOT EXISTS revive_count INT NOT NULL DEFAULT 0, + ADD COLUMN IF NOT EXISTS subscription_active BOOLEAN NOT NULL DEFAULT FALSE; + +COMMENT ON COLUMN heroes.revive_count IS 'Number of revives consumed (free tier capped at 2 without subscription).'; +COMMENT ON COLUMN heroes.subscription_active IS 'When true, revive limit does not apply.'; diff --git a/backend/migrations/000003_buff_quota.sql b/backend/migrations/000003_buff_quota.sql new file mode 100644 index 0000000..f57e888 --- /dev/null +++ b/backend/migrations/000003_buff_quota.sql @@ -0,0 +1,9 @@ +-- Free-tier buff activations: 3 per rolling 24h window (spec daily task "Use 3 Buffs"). +-- Subscribers ignore quota (subscription_active). + +ALTER TABLE heroes + ADD COLUMN IF NOT EXISTS buff_free_charges_remaining INT NOT NULL DEFAULT 3, + ADD COLUMN IF NOT EXISTS buff_quota_period_end TIMESTAMPTZ NULL; + +COMMENT ON COLUMN heroes.buff_free_charges_remaining IS 'Free buff activations left in current window (non-subscribers; resets when period rolls).'; +COMMENT ON COLUMN heroes.buff_quota_period_end IS 'End of current 24h buff quota window; NULL until first activation in a session.'; diff --git a/backend/migrations/000004_hero_position_and_log.sql b/backend/migrations/000004_hero_position_and_log.sql new file mode 100644 index 0000000..1db79b5 --- /dev/null +++ b/backend/migrations/000004_hero_position_and_log.sql @@ -0,0 +1,19 @@ +-- Migration: add hero position, potions, and adventure log. + +-- Hero position persists across sessions so the client can restore the visual location. +ALTER TABLE heroes ADD COLUMN IF NOT EXISTS position_x DOUBLE PRECISION NOT NULL DEFAULT 0; +ALTER TABLE heroes ADD COLUMN IF NOT EXISTS position_y DOUBLE PRECISION NOT NULL DEFAULT 0; + +-- Potions inventory (healing potions from monster drops). +ALTER TABLE heroes ADD COLUMN IF NOT EXISTS potions INT NOT NULL DEFAULT 0; + +-- Adventure log: a chronological list of notable in-game events per hero. +CREATE TABLE IF NOT EXISTS adventure_log ( + id BIGSERIAL PRIMARY KEY, + hero_id BIGINT NOT NULL REFERENCES heroes(id) ON DELETE CASCADE, + message TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE INDEX IF NOT EXISTS idx_adventure_log_hero_created + ON adventure_log (hero_id, created_at DESC); diff --git a/backend/migrations/000005_per_buff_quota.sql b/backend/migrations/000005_per_buff_quota.sql new file mode 100644 index 0000000..fb83e2e --- /dev/null +++ b/backend/migrations/000005_per_buff_quota.sql @@ -0,0 +1,7 @@ +-- Replace shared buff quota with per-buff quotas. +-- Each buff type gets its own charge counter and period window. +-- buff_charges stores: {"rush": {"remaining": 5, "periodEnd": "2026-03-29T00:00:00Z"}, ...} + +ALTER TABLE heroes ADD COLUMN IF NOT EXISTS buff_charges JSONB NOT NULL DEFAULT '{}'; + +COMMENT ON COLUMN heroes.buff_charges IS 'Per-buff-type free charge state: map of buff_type -> {remaining, periodEnd}. Replaces shared buff_free_charges_remaining.'; diff --git a/backend/migrations/000006_quest_system.sql b/backend/migrations/000006_quest_system.sql new file mode 100644 index 0000000..52d42e4 --- /dev/null +++ b/backend/migrations/000006_quest_system.sql @@ -0,0 +1,197 @@ +-- Migration 000006: Quest system — towns, NPCs, quests, hero quest tracking. + +-- ============================================================ +-- Towns: fixed settlements along the hero's travel road. +-- ============================================================ +CREATE TABLE IF NOT EXISTS towns ( + id BIGSERIAL PRIMARY KEY, + name TEXT NOT NULL UNIQUE, + biome TEXT NOT NULL, + world_x DOUBLE PRECISION NOT NULL, + world_y DOUBLE PRECISION NOT NULL, + radius DOUBLE PRECISION NOT NULL DEFAULT 8.0, + level_min INT NOT NULL DEFAULT 1, + level_max INT NOT NULL DEFAULT 100, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- ============================================================ +-- NPCs: non-hostile characters in towns. +-- ============================================================ +CREATE TABLE IF NOT EXISTS npcs ( + id BIGSERIAL PRIMARY KEY, + town_id BIGINT NOT NULL REFERENCES towns(id) ON DELETE CASCADE, + name TEXT NOT NULL, + type TEXT NOT NULL CHECK (type IN ('quest_giver', 'merchant', 'healer')), + offset_x DOUBLE PRECISION NOT NULL DEFAULT 0, + offset_y DOUBLE PRECISION NOT NULL DEFAULT 0, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE INDEX IF NOT EXISTS idx_npcs_town ON npcs(town_id); + +-- ============================================================ +-- Quests: template definitions offered by quest-giver NPCs. +-- ============================================================ +CREATE TABLE IF NOT EXISTS quests ( + id BIGSERIAL PRIMARY KEY, + npc_id BIGINT NOT NULL REFERENCES npcs(id) ON DELETE CASCADE, + title TEXT NOT NULL, + description TEXT NOT NULL DEFAULT '', + type TEXT NOT NULL CHECK (type IN ('kill_count', 'visit_town', 'collect_item')), + target_count INT NOT NULL DEFAULT 1, + target_enemy_type TEXT, -- NULL = any enemy (for kill_count) + target_town_id BIGINT REFERENCES towns(id), -- for visit_town quests + drop_chance DOUBLE PRECISION NOT NULL DEFAULT 0.3, -- for collect_item + min_level INT NOT NULL DEFAULT 1, + max_level INT NOT NULL DEFAULT 100, + reward_xp BIGINT NOT NULL DEFAULT 0, + reward_gold BIGINT NOT NULL DEFAULT 0, + reward_potions INT NOT NULL DEFAULT 0, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE INDEX IF NOT EXISTS idx_quests_npc ON quests(npc_id); + +-- ============================================================ +-- Hero quests: per-hero progress tracking. +-- ============================================================ +CREATE TABLE IF NOT EXISTS hero_quests ( + id BIGSERIAL PRIMARY KEY, + hero_id BIGINT NOT NULL REFERENCES heroes(id) ON DELETE CASCADE, + quest_id BIGINT NOT NULL REFERENCES quests(id) ON DELETE CASCADE, + status TEXT NOT NULL DEFAULT 'accepted' + CHECK (status IN ('accepted', 'completed', 'claimed')), + progress INT NOT NULL DEFAULT 0, + accepted_at TIMESTAMPTZ NOT NULL DEFAULT now(), + completed_at TIMESTAMPTZ, + claimed_at TIMESTAMPTZ, + UNIQUE (hero_id, quest_id) +); + +CREATE INDEX IF NOT EXISTS idx_hero_quests_hero ON hero_quests(hero_id); +CREATE INDEX IF NOT EXISTS idx_hero_quests_status ON hero_quests(hero_id, status); + +-- ============================================================ +-- Seed data: towns +-- ============================================================ +INSERT INTO towns (name, biome, world_x, world_y, radius, level_min, level_max) VALUES + ('Willowdale', 'meadow', 50, 15, 8.0, 1, 5), + ('Thornwatch', 'forest', 200, 60, 8.0, 5, 10), + ('Ashengard', 'ruins', 400, 120, 8.0, 10, 16), + ('Redcliff', 'canyon', 650, 195, 8.0, 16, 22), + ('Boghollow', 'swamp', 900, 270, 8.0, 22, 28), + ('Cinderkeep', 'volcanic', 1200, 360, 8.0, 28, 34), + ('Starfall', 'astral', 1550, 465, 8.0, 34, 40); + +-- ============================================================ +-- Seed data: NPCs (2-3 per town) +-- ============================================================ +INSERT INTO npcs (town_id, name, type, offset_x, offset_y) VALUES + -- Willowdale (meadow) + (1, 'Elder Maren', 'quest_giver', -2.0, 1.0), + (1, 'Peddler Finn', 'merchant', 3.0, 0.0), + (1, 'Sister Asha', 'healer', 0.0, -2.5), + -- Thornwatch (forest) + (2, 'Guard Halric', 'quest_giver', -3.0, 0.5), + (2, 'Trader Wynn', 'merchant', 2.0, 2.0), + -- Ashengard (ruins) + (3, 'Scholar Orin', 'quest_giver', 1.0, -2.0), + (3, 'Bone Merchant', 'merchant', -2.0, 3.0), + (3, 'Priestess Liora', 'healer', 3.0, 1.0), + -- Redcliff (canyon) + (4, 'Foreman Brak', 'quest_giver', -1.0, 2.0), + (4, 'Miner Supplies', 'merchant', 2.5, -1.0), + -- Boghollow (swamp) + (5, 'Witch Nessa', 'quest_giver', 0.0, 3.0), + (5, 'Swamp Trader', 'merchant', -3.0, -1.0), + (5, 'Marsh Healer Ren', 'healer', 2.0, 0.0), + -- Cinderkeep (volcanic) + (6, 'Forge-master Kael','quest_giver', -2.5, 0.0), + (6, 'Ember Merchant', 'merchant', 1.0, 2.5), + -- Starfall (astral) + (7, 'Seer Aelith', 'quest_giver', 0.0, -3.0), + (7, 'Void Trader', 'merchant', 3.0, 1.0), + (7, 'Astral Mender', 'healer', -2.0, 2.0); + +-- ============================================================ +-- Seed data: quests +-- ============================================================ + +-- Willowdale quests (Elder Maren, npc_id = 1) +INSERT INTO quests (npc_id, title, description, type, target_count, target_enemy_type, target_town_id, drop_chance, min_level, max_level, reward_xp, reward_gold, reward_potions) VALUES + (1, 'Wolf Cull', + 'The wolves near Willowdale are getting bolder. Thin their numbers.', + 'kill_count', 5, 'wolf', NULL, 0.0, 1, 5, 30, 15, 0), + (1, 'Boar Hunt', + 'Wild boars are trampling the crops. Take care of them.', + 'kill_count', 8, 'boar', NULL, 0.0, 2, 6, 50, 25, 1), + (1, 'Deliver to Thornwatch', + 'Carry this supply manifest to Guard Halric in Thornwatch.', + 'visit_town', 1, NULL, 2, 0.0, 1, 10, 40, 20, 0); + +-- Thornwatch quests (Guard Halric, npc_id = 4) +INSERT INTO quests (npc_id, title, description, type, target_count, target_enemy_type, target_town_id, drop_chance, min_level, max_level, reward_xp, reward_gold, reward_potions) VALUES + (4, 'Spider Infestation', + 'Cave spiders have overrun the logging trails. Clear them out.', + 'kill_count', 12, 'spider', NULL, 0.0, 5, 10, 80, 40, 1), + (4, 'Spider Fang Collection', + 'We need spider fangs for antivenom. Collect them from slain spiders.', + 'collect_item', 5, 'spider', NULL, 0.3, 5, 10, 100, 60, 1), + (4, 'Forest Patrol', + 'Slay any 15 creatures along the forest road to keep it safe.', + 'kill_count', 15, NULL, NULL, 0.0, 5, 12, 120, 70, 1); + +-- Ashengard quests (Scholar Orin, npc_id = 6) +INSERT INTO quests (npc_id, title, description, type, target_count, target_enemy_type, target_town_id, drop_chance, min_level, max_level, reward_xp, reward_gold, reward_potions) VALUES + (6, 'Undead Purge', + 'The ruins are crawling with undead. Destroy the zombies.', + 'kill_count', 15, 'zombie', NULL, 0.0, 10, 16, 150, 80, 1), + (6, 'Ancient Relics', + 'Search fallen enemies for fragments of the old kingdom.', + 'collect_item', 8, NULL, NULL, 0.25, 10, 16, 200, 120, 2), + (6, 'Report to Redcliff', + 'Warn Foreman Brak about the growing undead threat.', + 'visit_town', 1, NULL, 4, 0.0, 10, 20, 120, 60, 0); + +-- Redcliff quests (Foreman Brak, npc_id = 9) +INSERT INTO quests (npc_id, title, description, type, target_count, target_enemy_type, target_town_id, drop_chance, min_level, max_level, reward_xp, reward_gold, reward_potions) VALUES + (9, 'Orc Raider Cleanup', + 'Orc warriors are raiding the mine carts. Stop them.', + 'kill_count', 20, 'orc', NULL, 0.0, 16, 22, 250, 150, 2), + (9, 'Ore Samples', + 'Collect glowing ore fragments from defeated enemies near the canyon.', + 'collect_item', 6, NULL, NULL, 0.3, 16, 22, 200, 120, 1); + +-- Boghollow quests (Witch Nessa, npc_id = 11) +INSERT INTO quests (npc_id, title, description, type, target_count, target_enemy_type, target_town_id, drop_chance, min_level, max_level, reward_xp, reward_gold, reward_potions) VALUES + (11, 'Swamp Creatures', + 'The swamp beasts grow more aggressive by the day. Cull 25.', + 'kill_count', 25, NULL, NULL, 0.0, 22, 28, 350, 200, 2), + (11, 'Venomous Harvest', + 'Collect venom sacs from swamp creatures for my brews.', + 'collect_item', 10, NULL, NULL, 0.25, 22, 28, 400, 250, 2), + (11, 'Message to Cinderkeep', + 'The forgemaster needs to know about the corruption spreading here.', + 'visit_town', 1, NULL, 6, 0.0, 22, 34, 200, 100, 1); + +-- Cinderkeep quests (Forge-master Kael, npc_id = 14) +INSERT INTO quests (npc_id, title, description, type, target_count, target_enemy_type, target_town_id, drop_chance, min_level, max_level, reward_xp, reward_gold, reward_potions) VALUES + (14, 'Demon Slayer', + 'Fire demons are emerging from the vents. Destroy them.', + 'kill_count', 10, 'fire_demon', NULL, 0.0, 28, 34, 500, 300, 2), + (14, 'Infernal Cores', + 'Retrieve smoldering cores from defeated fire demons.', + 'collect_item', 5, 'fire_demon', NULL, 0.3, 28, 34, 600, 350, 3); + +-- Starfall quests (Seer Aelith, npc_id = 16) +INSERT INTO quests (npc_id, title, description, type, target_count, target_enemy_type, target_town_id, drop_chance, min_level, max_level, reward_xp, reward_gold, reward_potions) VALUES + (16, 'Titan''s Challenge', + 'The Lightning Titans must be stopped before they breach the gate.', + 'kill_count', 8, 'lightning_titan', NULL, 0.0, 34, 40, 800, 500, 3), + (16, 'Void Fragments', + 'Gather crystallized void energy from the astral enemies.', + 'collect_item', 8, NULL, NULL, 0.2, 34, 40, 1000, 600, 3), + (16, 'Full Circle', + 'Return to Willowdale and tell Elder Maren of your journey.', + 'visit_town', 1, NULL, 1, 0.0, 34, 40, 500, 300, 2); diff --git a/backend/migrations/000007_hero_name_unique.sql b/backend/migrations/000007_hero_name_unique.sql new file mode 100644 index 0000000..41a54fd --- /dev/null +++ b/backend/migrations/000007_hero_name_unique.sql @@ -0,0 +1,2 @@ +-- Make hero name unique (case-insensitive) +CREATE UNIQUE INDEX IF NOT EXISTS idx_heroes_name_lower ON heroes(LOWER(name)) WHERE name != '' AND name != 'Hero'; diff --git a/backend/migrations/000008_ilvl.sql b/backend/migrations/000008_ilvl.sql new file mode 100644 index 0000000..324d54f --- /dev/null +++ b/backend/migrations/000008_ilvl.sql @@ -0,0 +1,2 @@ +ALTER TABLE weapons ADD COLUMN IF NOT EXISTS ilvl INT NOT NULL DEFAULT 1; +ALTER TABLE armor ADD COLUMN IF NOT EXISTS ilvl INT NOT NULL DEFAULT 1; diff --git a/backend/migrations/000009_payments.sql b/backend/migrations/000009_payments.sql new file mode 100644 index 0000000..750def1 --- /dev/null +++ b/backend/migrations/000009_payments.sql @@ -0,0 +1,11 @@ +CREATE TABLE IF NOT EXISTS payments ( + id BIGSERIAL PRIMARY KEY, + hero_id BIGINT NOT NULL REFERENCES heroes(id) ON DELETE CASCADE, + type TEXT NOT NULL, -- 'buff_replenish', 'resurrection_replenish' + buff_type TEXT, -- specific buff type if applicable + amount_rub INT NOT NULL, -- price in rubles + status TEXT NOT NULL DEFAULT 'pending', -- pending, completed, failed + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + completed_at TIMESTAMPTZ +); +CREATE INDEX IF NOT EXISTS idx_payments_hero ON payments(hero_id); diff --git a/backend/migrations/000010_extended_slots.sql b/backend/migrations/000010_extended_slots.sql new file mode 100644 index 0000000..c3e1d20 --- /dev/null +++ b/backend/migrations/000010_extended_slots.sql @@ -0,0 +1,30 @@ +-- Migration 000010: Extended equipment slots (head, feet, neck). + +-- ============================================================ +-- Equipment items table (all slots beyond legacy weapon/armor). +-- ============================================================ +CREATE TABLE IF NOT EXISTS equipment_items ( + id BIGSERIAL PRIMARY KEY, + slot TEXT NOT NULL, -- gear.slot.head, gear.slot.feet, gear.slot.neck, etc. + form_id TEXT NOT NULL DEFAULT '', + name TEXT NOT NULL, + rarity TEXT NOT NULL DEFAULT 'common', + ilvl INT NOT NULL DEFAULT 1, + base_primary INT NOT NULL DEFAULT 0, + primary_stat INT NOT NULL DEFAULT 0, -- computed: ScalePrimary(base_primary, ilvl, rarity) + stat_type TEXT NOT NULL DEFAULT 'defense', -- attack, defense, speed, mixed + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- ============================================================ +-- Hero equipment (one row per equipped slot). +-- ============================================================ +CREATE TABLE IF NOT EXISTS hero_equipment ( + hero_id BIGINT NOT NULL REFERENCES heroes(id) ON DELETE CASCADE, + slot TEXT NOT NULL, + item_id BIGINT NOT NULL REFERENCES equipment_items(id), + equipped_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (hero_id, slot) +); + +CREATE INDEX IF NOT EXISTS idx_hero_equipment_hero ON hero_equipment(hero_id); diff --git a/backend/migrations/000011_achievements_tasks_world.sql b/backend/migrations/000011_achievements_tasks_world.sql new file mode 100644 index 0000000..e4b19ba --- /dev/null +++ b/backend/migrations/000011_achievements_tasks_world.sql @@ -0,0 +1,82 @@ +-- 000011: Achievements, Daily/Weekly Tasks, and Shared World foundation. + +-- Hero stat tracking columns for achievement conditions. +ALTER TABLE heroes ADD COLUMN IF NOT EXISTS total_kills INT NOT NULL DEFAULT 0; +ALTER TABLE heroes ADD COLUMN IF NOT EXISTS elite_kills INT NOT NULL DEFAULT 0; +ALTER TABLE heroes ADD COLUMN IF NOT EXISTS total_deaths INT NOT NULL DEFAULT 0; +ALTER TABLE heroes ADD COLUMN IF NOT EXISTS kills_since_death INT NOT NULL DEFAULT 0; +ALTER TABLE heroes ADD COLUMN IF NOT EXISTS legendary_drops INT NOT NULL DEFAULT 0; + +-- Shared world: track hero online status for nearby-heroes queries. +ALTER TABLE heroes ADD COLUMN IF NOT EXISTS last_online_at TIMESTAMPTZ; +CREATE INDEX IF NOT EXISTS idx_heroes_online ON heroes(last_online_at) WHERE last_online_at IS NOT NULL; + +-- ============================================================ +-- Achievements +-- ============================================================ + +CREATE TABLE IF NOT EXISTS achievements ( + id TEXT PRIMARY KEY, + title TEXT NOT NULL, + description TEXT NOT NULL, + condition_type TEXT NOT NULL, -- 'level', 'kills', 'gold', 'elite_kills', 'deaths', 'loot_legendary', 'kills_no_death' + condition_value INT NOT NULL DEFAULT 0, + reward_type TEXT NOT NULL DEFAULT 'gold', -- 'gold', 'potion', 'title' + reward_amount INT NOT NULL DEFAULT 0 +); + +CREATE TABLE IF NOT EXISTS hero_achievements ( + hero_id BIGINT NOT NULL REFERENCES heroes(id) ON DELETE CASCADE, + achievement_id TEXT NOT NULL REFERENCES achievements(id), + unlocked_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (hero_id, achievement_id) +); + +-- Seed achievements. +INSERT INTO achievements (id, title, description, condition_type, condition_value, reward_type, reward_amount) VALUES + ('first_blood', 'First Blood', 'Defeat your first enemy', 'kills', 1, 'gold', 50), + ('warrior', 'Warrior', 'Reach level 50', 'level', 50, 'gold', 5000), + ('legend', 'Legend', 'Reach level 100', 'level', 100, 'gold', 50000), + ('hunter', 'Hunter', 'Defeat 100 enemies', 'kills', 100, 'gold', 500), + ('slayer', 'Slayer', 'Defeat 1000 enemies', 'kills', 1000, 'gold', 5000), + ('rich', 'Rich', 'Accumulate 10000 gold', 'gold', 10000, 'gold', 1000), + ('lucky', 'Lucky', 'Find a Legendary item', 'loot_legendary', 1, 'potion', 5), + ('undying', 'Undying', 'Defeat 50 enemies without dying', 'kills_no_death', 50, 'gold', 2000), + ('elite_hunter', 'Elite Hunter', 'Defeat 10 elite enemies', 'elite_kills', 10, 'gold', 3000) +ON CONFLICT DO NOTHING; + +-- ============================================================ +-- Daily / Weekly Tasks +-- ============================================================ + +CREATE TABLE IF NOT EXISTS daily_tasks ( + id TEXT PRIMARY KEY, + title TEXT NOT NULL, + description TEXT NOT NULL, + objective_type TEXT NOT NULL, -- 'kill_count', 'elite_kill', 'collect_gold', 'use_buff', 'reach_level' + objective_count INT NOT NULL, + reward_type TEXT NOT NULL DEFAULT 'gold', + reward_amount INT NOT NULL DEFAULT 0, + period TEXT NOT NULL DEFAULT 'daily' -- 'daily', 'weekly' +); + +CREATE TABLE IF NOT EXISTS hero_daily_tasks ( + hero_id BIGINT NOT NULL REFERENCES heroes(id) ON DELETE CASCADE, + task_id TEXT NOT NULL REFERENCES daily_tasks(id), + progress INT NOT NULL DEFAULT 0, + completed BOOLEAN NOT NULL DEFAULT false, + claimed BOOLEAN NOT NULL DEFAULT false, + period_start TIMESTAMPTZ NOT NULL, + PRIMARY KEY (hero_id, task_id, period_start) +); + +-- Seed daily tasks. +INSERT INTO daily_tasks VALUES + ('daily_kill_10', 'Monster Slayer', 'Kill 10 enemies', 'kill_count', 10, 'gold', 100, 'daily'), + ('daily_elite', 'Elite Hunter', 'Defeat an Elite enemy', 'elite_kill', 1, 'gold', 200, 'daily'), + ('daily_gold_500', 'Gold Rush', 'Collect 500 Gold', 'collect_gold', 500, 'potion', 2, 'daily'), + ('daily_buff_3', 'Buff Master', 'Use 3 Buffs', 'use_buff', 3, 'gold', 150, 'daily'), + ('weekly_kill_100', 'Weekly Warrior', 'Kill 100 enemies', 'kill_count', 100, 'gold', 1000, 'weekly'), + ('weekly_elite_5', 'Elite Slayer', 'Defeat 5 Elites', 'elite_kill', 5, 'gold', 2000, 'weekly'), + ('weekly_gold_5000', 'Wealthy', 'Collect 5000 Gold', 'collect_gold', 5000, 'potion', 5, 'weekly') +ON CONFLICT DO NOTHING; diff --git a/backend/migrations/000012_bigger_towns.sql b/backend/migrations/000012_bigger_towns.sql new file mode 100644 index 0000000..2e00e83 --- /dev/null +++ b/backend/migrations/000012_bigger_towns.sql @@ -0,0 +1,9 @@ +-- Migration 000012: Increase town radii and vary by settlement size. + +UPDATE towns SET radius = 18 WHERE name = 'Willowdale'; +UPDATE towns SET radius = 14 WHERE name = 'Thornwatch'; +UPDATE towns SET radius = 16 WHERE name = 'Ashengard'; +UPDATE towns SET radius = 14 WHERE name = 'Redcliff'; +UPDATE towns SET radius = 12 WHERE name = 'Boghollow'; +UPDATE towns SET radius = 16 WHERE name = 'Cinderkeep'; +UPDATE towns SET radius = 18 WHERE name = 'Starfall'; diff --git a/backend/migrations/000013_server_movement.sql b/backend/migrations/000013_server_movement.sql new file mode 100644 index 0000000..b92e539 --- /dev/null +++ b/backend/migrations/000013_server_movement.sql @@ -0,0 +1,60 @@ +-- Server-authoritative movement: hero movement state + roads graph. + +-- Hero movement columns. +ALTER TABLE heroes ADD COLUMN IF NOT EXISTS destination_town_id BIGINT REFERENCES towns(id); +ALTER TABLE heroes ADD COLUMN IF NOT EXISTS current_town_id BIGINT REFERENCES towns(id); +ALTER TABLE heroes ADD COLUMN IF NOT EXISTS move_state TEXT NOT NULL DEFAULT 'walking'; +-- move_state: 'walking', 'resting', 'in_town', 'fighting', 'dead' + +-- Roads connect towns in a linear chain. +CREATE TABLE IF NOT EXISTS roads ( + id BIGSERIAL PRIMARY KEY, + from_town_id BIGINT NOT NULL REFERENCES towns(id), + to_town_id BIGINT NOT NULL REFERENCES towns(id), + distance DOUBLE PRECISION NOT NULL, + UNIQUE(from_town_id, to_town_id) +); + +-- Pre-computed waypoints along each road. +CREATE TABLE IF NOT EXISTS road_waypoints ( + id BIGSERIAL PRIMARY KEY, + road_id BIGINT NOT NULL REFERENCES roads(id) ON DELETE CASCADE, + seq INT NOT NULL, + x DOUBLE PRECISION NOT NULL, + y DOUBLE PRECISION NOT NULL, + UNIQUE(road_id, seq) +); + +-- Seed roads between the 7 towns in order. +-- Town positions (from 000006_quest_system.sql): +-- Willowdale (50, 15) id=1 +-- Thornwatch (200, 60) id=2 +-- Ashengard (400, 120) id=3 +-- Redcliff (650, 195) id=4 +-- Boghollow (900, 270) id=5 +-- Cinderkeep (1200, 360) id=6 +-- Starfall (1550, 465) id=7 + +-- Forward roads (1->2, 2->3, ... 6->7). +INSERT INTO roads (from_town_id, to_town_id, distance) VALUES + (1, 2, 156.0), + (2, 3, 210.0), + (3, 4, 260.0), + (4, 5, 260.0), + (5, 6, 312.0), + (6, 7, 365.0) +ON CONFLICT DO NOTHING; + +-- Reverse roads (2->1, 3->2, ... 7->6). +INSERT INTO roads (from_town_id, to_town_id, distance) VALUES + (2, 1, 156.0), + (3, 2, 210.0), + (4, 3, 260.0), + (5, 4, 260.0), + (6, 5, 312.0), + (7, 6, 365.0) +ON CONFLICT DO NOTHING; + +-- Waypoints are generated at application startup via the RoadGraph loader +-- using interpolation between town positions with jitter. This avoids +-- storing thousands of rows and keeps generation deterministic per road seed. diff --git a/backend/migrations/000014_unified_gear.sql b/backend/migrations/000014_unified_gear.sql new file mode 100644 index 0000000..417bff5 --- /dev/null +++ b/backend/migrations/000014_unified_gear.sql @@ -0,0 +1,60 @@ +-- Unified gear table replacing weapons, armor, and equipment_items +CREATE TABLE IF NOT EXISTS gear ( + id BIGSERIAL PRIMARY KEY, + slot TEXT NOT NULL, + form_id TEXT NOT NULL DEFAULT '', + name TEXT NOT NULL, + subtype TEXT NOT NULL DEFAULT '', + rarity TEXT NOT NULL DEFAULT 'common', + ilvl INT NOT NULL DEFAULT 1, + base_primary INT NOT NULL DEFAULT 0, + primary_stat INT NOT NULL DEFAULT 0, + stat_type TEXT NOT NULL DEFAULT 'mixed', + speed_modifier DOUBLE PRECISION NOT NULL DEFAULT 1.0, + crit_chance DOUBLE PRECISION NOT NULL DEFAULT 0.0, + agility_bonus INT NOT NULL DEFAULT 0, + set_name TEXT NOT NULL DEFAULT '', + special_effect TEXT NOT NULL DEFAULT '', + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Hero gear: one row per equipped slot (replaces weapon_id, armor_id, and hero_equipment) +CREATE TABLE IF NOT EXISTS hero_gear ( + hero_id BIGINT NOT NULL REFERENCES heroes(id) ON DELETE CASCADE, + slot TEXT NOT NULL, + gear_id BIGINT NOT NULL REFERENCES gear(id), + PRIMARY KEY (hero_id, slot) +); +CREATE INDEX IF NOT EXISTS idx_hero_gear_hero ON hero_gear(hero_id); + +-- Migrate existing weapon data to gear table +INSERT INTO gear (id, slot, name, subtype, rarity, ilvl, base_primary, primary_stat, stat_type, speed_modifier, crit_chance, special_effect) +SELECT id, 'main_hand', name, type, rarity, ilvl, damage, damage, 'attack', speed, crit_chance, special_effect +FROM weapons; + +-- Migrate existing armor data to gear table (offset IDs by 1000 to avoid conflicts) +INSERT INTO gear (id, slot, name, subtype, rarity, ilvl, base_primary, primary_stat, stat_type, speed_modifier, agility_bonus, set_name, special_effect) +SELECT id + 1000, 'chest', name, type, rarity, ilvl, defense, defense, 'defense', speed_modifier, agility_bonus, set_name, special_effect +FROM armor; + +-- Migrate equipment_items to gear (offset by 2000) +INSERT INTO gear (id, slot, form_id, name, rarity, ilvl, base_primary, primary_stat, stat_type) +SELECT id + 2000, slot, form_id, name, rarity, ilvl, base_primary, primary_stat, stat_type +FROM equipment_items; + +-- Migrate hero weapon/armor refs to hero_gear +INSERT INTO hero_gear (hero_id, slot, gear_id) +SELECT id, 'main_hand', weapon_id FROM heroes WHERE weapon_id IS NOT NULL +ON CONFLICT DO NOTHING; + +INSERT INTO hero_gear (hero_id, slot, gear_id) +SELECT id, 'chest', armor_id + 1000 FROM heroes WHERE armor_id IS NOT NULL +ON CONFLICT DO NOTHING; + +-- Migrate hero_equipment to hero_gear +INSERT INTO hero_gear (hero_id, slot, gear_id) +SELECT hero_id, slot, item_id + 2000 FROM hero_equipment +ON CONFLICT DO NOTHING; + +-- Reset gear sequence to avoid ID conflicts +SELECT setval('gear_id_seq', (SELECT COALESCE(MAX(id), 0) + 1 FROM gear)); diff --git a/backend/migrations/000015_town_world_spacing.sql b/backend/migrations/000015_town_world_spacing.sql new file mode 100644 index 0000000..325aece --- /dev/null +++ b/backend/migrations/000015_town_world_spacing.sql @@ -0,0 +1,10 @@ +-- Migration 000015: Spread towns further apart on the world map (longer roads between stops). +-- Waypoints are regenerated at startup from town positions; roads.distance is overwritten in memory. + +UPDATE towns SET world_x = 125, world_y = 38 WHERE name = 'Willowdale'; +UPDATE towns SET world_x = 500, world_y = 150 WHERE name = 'Thornwatch'; +UPDATE towns SET world_x = 1000, world_y = 300 WHERE name = 'Ashengard'; +UPDATE towns SET world_x = 1625, world_y = 488 WHERE name = 'Redcliff'; +UPDATE towns SET world_x = 2250, world_y = 675 WHERE name = 'Boghollow'; +UPDATE towns SET world_x = 3000, world_y = 900 WHERE name = 'Cinderkeep'; +UPDATE towns SET world_x = 3875, world_y = 1163 WHERE name = 'Starfall'; diff --git a/backend/migrations/000016_towns_ring_roads.sql b/backend/migrations/000016_towns_ring_roads.sql new file mode 100644 index 0000000..71240c2 --- /dev/null +++ b/backend/migrations/000016_towns_ring_roads.sql @@ -0,0 +1,7 @@ +-- Close the world road loop: last town connects back to the first (and reverse). +-- Town ids: 1 Willowdale .. 7 Starfall (see 000006 / 000015). Distance is approximate; runtime recomputes from waypoints. + +INSERT INTO roads (from_town_id, to_town_id, distance) VALUES + (7, 1, 4000.0), + (1, 7, 4000.0) +ON CONFLICT (from_town_id, to_town_id) DO NOTHING; diff --git a/backend/migrations/000017_road_waypoints_seed.sql b/backend/migrations/000017_road_waypoints_seed.sql new file mode 100644 index 0000000..bd7bb07 --- /dev/null +++ b/backend/migrations/000017_road_waypoints_seed.sql @@ -0,0 +1,40 @@ +-- Migration 000017: Populate road_waypoints for every row in roads. +-- +-- Review (why the table was empty): +-- 000013 created road_waypoints but never inserted rows; comments there say waypoints are +-- generated at runtime in Go (internal/game/road_graph.go → generateWaypoints). The server +-- still does NOT read this table — it joins towns + roads and builds jittered polylines in memory. +-- This migration stores a canonical polyline per road for analytics, admin maps, exports, or a +-- future loader. Points use the same segment count rule as Go (≈20 world units per segment, +-- GREATEST(1, floor(dist/20))), linear interpolation only — no ±2 jitter (that stays code-only). +-- +-- Idempotent: clears existing waypoint rows then re-seeds from current towns.world_x/y. + +DELETE FROM road_waypoints; + +INSERT INTO road_waypoints (road_id, seq, x, y) +SELECT + r.id, + gs.seq, + CASE + WHEN gs.seq = 0 THEN f.world_x + WHEN gs.seq = seg.nseg THEN t.world_x + ELSE f.world_x + (t.world_x - f.world_x) * (gs.seq::double precision / seg.nseg::double precision) + END, + CASE + WHEN gs.seq = 0 THEN f.world_y + WHEN gs.seq = seg.nseg THEN t.world_y + ELSE f.world_y + (t.world_y - f.world_y) * (gs.seq::double precision / seg.nseg::double precision) + END +FROM roads r +INNER JOIN towns f ON f.id = r.from_town_id +INNER JOIN towns t ON t.id = r.to_town_id +CROSS JOIN LATERAL ( + SELECT GREATEST( + 1, + FLOOR( + SQRT(POWER(t.world_x - f.world_x, 2) + POWER(t.world_y - f.world_y, 2)) / 20.0 + )::integer + ) AS nseg +) seg +CROSS JOIN LATERAL generate_series(0, seg.nseg) AS gs(seq); diff --git a/backend/migrations/000018_town_spiral_layout.sql b/backend/migrations/000018_town_spiral_layout.sql new file mode 100644 index 0000000..7dbe7ba --- /dev/null +++ b/backend/migrations/000018_town_spiral_layout.sql @@ -0,0 +1,41 @@ +-- Migration 000018: Place towns on an approximate Archimedean spiral (not collinear). +-- Order by level_min is unchanged — ring roads still follow progression Willowdale → … → Starfall → wrap. +-- Waypoints regenerate at server startup from town centers (see road_graph / 000016). + +UPDATE towns SET world_x = 2620, world_y = 800 WHERE name = 'Willowdale'; +UPDATE towns SET world_x = 2926, world_y = 1058 WHERE name = 'Thornwatch'; +UPDATE towns SET world_x = 2899, world_y = 1584 WHERE name = 'Ashengard'; +UPDATE towns SET world_x = 2399, world_y = 2056 WHERE name = 'Redcliff'; +UPDATE towns SET world_x = 1535, world_y = 2126 WHERE name = 'Boghollow'; +UPDATE towns SET world_x = 633, world_y = 1571 WHERE name = 'Cinderkeep'; +UPDATE towns SET world_x = 131, world_y = 660 WHERE name = 'Starfall'; + +-- Keep road_waypoints (if populated by 000017) aligned with new town centers. +DELETE FROM road_waypoints; + +INSERT INTO road_waypoints (road_id, seq, x, y) +SELECT + r.id, + gs.seq, + CASE + WHEN gs.seq = 0 THEN f.world_x + WHEN gs.seq = seg.nseg THEN t.world_x + ELSE f.world_x + (t.world_x - f.world_x) * (gs.seq::double precision / seg.nseg::double precision) + END, + CASE + WHEN gs.seq = 0 THEN f.world_y + WHEN gs.seq = seg.nseg THEN t.world_y + ELSE f.world_y + (t.world_y - f.world_y) * (gs.seq::double precision / seg.nseg::double precision) + END +FROM roads r +INNER JOIN towns f ON f.id = r.from_town_id +INNER JOIN towns t ON t.id = r.to_town_id +CROSS JOIN LATERAL ( + SELECT GREATEST( + 1, + FLOOR( + SQRT(POWER(t.world_x - f.world_x, 2) + POWER(t.world_y - f.world_y, 2)) / 20.0 + )::integer + ) AS nseg +) seg +CROSS JOIN LATERAL generate_series(0, seg.nseg) AS gs(seq); diff --git a/backend/server.exe b/backend/server.exe new file mode 100644 index 0000000..ace8276 Binary files /dev/null and b/backend/server.exe differ diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..581e618 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,85 @@ +# Custom images (backend, frontend) are tagged for the private registry so +# `docker compose push backend frontend` publishes them. Override via .env: +# DOCKER_REGISTRY=static.ranneft.ru:25000 +# IMAGE_TAG=latest +services: + postgres: + image: postgres:16-alpine + environment: + POSTGRES_DB: ${DB_NAME:-autohero} + POSTGRES_USER: ${DB_USER:-autohero} + POSTGRES_PASSWORD: ${DB_PASSWORD:-autohero} + ports: + - "${DB_PORT:-5432}:5432" + volumes: + - pgdata:/var/lib/postgresql/data + - ./backend/migrations:/docker-entrypoint-initdb.d:ro + healthcheck: + test: ["CMD-SHELL", "pg_isready -U ${DB_USER:-autohero} -d ${DB_NAME:-autohero}"] + interval: 5s + timeout: 3s + retries: 5 + networks: + - autohero + + redis: + image: redis:7-alpine + ports: + - "6379:6379" + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 5 + networks: + - autohero + + backend: + image: ${DOCKER_REGISTRY:-static.ranneft.ru:25000}/autohero/backend:${IMAGE_TAG:-latest} + build: + context: ./backend + dockerfile: Dockerfile + ports: + - "${SERVER_PORT:-8080}:8080" + environment: + SERVER_PORT: "8080" + DB_HOST: postgres + DB_PORT: "5432" + DB_USER: ${DB_USER:-autohero} + DB_PASSWORD: ${DB_PASSWORD:-autohero} + DB_NAME: ${DB_NAME:-autohero} + REDIS_ADDR: redis:6379 + BOT_TOKEN: ${BOT_TOKEN:-} + ADMIN_BASIC_AUTH_USERNAME: ${ADMIN_BASIC_AUTH_USERNAME:-} + ADMIN_BASIC_AUTH_PASSWORD: ${ADMIN_BASIC_AUTH_PASSWORD:-} + ADMIN_BASIC_AUTH_REALM: ${ADMIN_BASIC_AUTH_REALM:-AutoHero Admin} + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + restart: on-failure + networks: + - autohero + + frontend: + image: ${DOCKER_REGISTRY:-static.ranneft.ru:25000}/autohero/frontend:${IMAGE_TAG:-latest} + build: + context: ./frontend + dockerfile: Dockerfile + ports: + - "3000:443" + - "3001:80" + volumes: + - ./ssl:/etc/nginx/ssl:ro + depends_on: + - backend + networks: + - autohero + +volumes: + pgdata: + +networks: + autohero: + driver: bridge diff --git a/docs/blueprint_server_authoritative.md b/docs/blueprint_server_authoritative.md new file mode 100644 index 0000000..2cca681 --- /dev/null +++ b/docs/blueprint_server_authoritative.md @@ -0,0 +1,865 @@ +# AutoHero Server-Authority Blueprint + +## Part 1: Architecture Review — Authority Gap Analysis + +### Severity P0 (Critical — Exploitable Now) + +**GAP-1: `SaveHero` is an unrestricted cheat API** +- **File:** `backend/internal/handler/game.go:472–584` +- The `saveHeroRequest` struct accepts `HP`, `MaxHP`, `Attack`, `Defense`, `Speed`, `Strength`, `Constitution`, `Agility`, `Luck`, `State`, `Gold`, `XP`, `Level`, `WeaponID`, `ArmorID` — every progression-critical field. +- Lines 526–573 apply each field with zero validation: no bounds checks, no delta verification, no comparison against known server state. +- A `POST /api/v1/hero/save` with body `{"gold":999999,"level":100,"xp":0}` is accepted and persisted to PostgreSQL. +- The auto-save in `App.tsx:256–261` sends the full client-computed hero state every 10 seconds, plus a `sendBeacon` on page unload (line 279–285). + +**GAP-2: Combat runs entirely on the client** +- **File:** `frontend/src/game/engine.ts:464–551` (`_simulateFighting`) +- The client computes hero attack damage (line 490–496), enemy attack damage (line 518–524), HP changes, crit rolls, stun checks — all locally. +- The backend's `Engine.StartCombat()` (`backend/internal/game/engine.go:57–98`) is never called from any handler. `GameHandler` holds `*game.Engine` but none of its methods invoke `engine.StartCombat`, `engine.StopCombat`, or `engine.GetCombat`. +- The `RequestEncounter` handler (`game.go:259–300`) returns enemy stats as JSON but does not register the combat. The enemy ID is `time.Now().UnixNano()` — ephemeral, untracked. + +**GAP-3: XP, gold, and level-up are client-dictated** +- **File:** `frontend/src/game/engine.ts:624–671` (`_onEnemyDefeated`) +- Client awards `xpGain = template.xp * (1 + hero.level * 0.1)`, adds gold, runs the `while(xp >= xpToNext)` level-up loop including stat increases. +- These values are then sent to the server via `SaveHero`, overwriting server data. + +**GAP-4: Auth middleware is disabled** +- **File:** `backend/internal/router/router.go:57–59` +- `r.Use(handler.TelegramAuthMiddleware(deps.BotToken))` is commented out. +- Identity falls back to `?telegramId=` query parameter (`game.go:46–61`), which anyone can spoof. + +### Severity P1 (High — Broken Plumbing) + +**GAP-5: WebSocket protocol mismatch — server events never reach the client** +- **Server sends:** flat `model.CombatEvent` JSON (`{"type":"attack","heroId":1,...}`) via `WriteJSON` (`ws.go:184`). +- **Client expects:** `{type: string, payload: unknown}` envelope (`websocket.ts:12–15`). The client's `dispatch(msg)` calls `handlers.get(msg.type)` where `msg.type` comes from the envelope — but the server's flat JSON has `type` at root, not inside `payload`. Even if `type` matched, `msg.payload` would be `undefined`, and the `App.tsx` handlers destructure `msg.payload`. +- **Heartbeat mismatch:** Server sends WS `PingMessage` (binary control frame, `ws.go:190`). Client sends text `"ping"` (`websocket.ts:191`) and expects text `"pong"` (`websocket.ts:109`). Server's `readPump` discards all incoming messages (`ws.go:158`), never responds with `"pong"`. Client times out after `WS_HEARTBEAT_TIMEOUT_MS` and disconnects with code 4000. +- Result: the `_serverAuthoritative` flag in `engine.ts` is never set to `true` during normal gameplay. The WS `game_state` handler (`App.tsx:331–334`) that would call `engine.applyServerState()` never fires. + +**GAP-6: WS heroID hardcoded to 1** +- **File:** `backend/internal/handler/ws.go:128–129` +- Every WS client is assigned `heroID = 1`. In a multi-user scenario, all clients receive events for hero 1 only, and no other hero's combat events are routed. + +**GAP-7: Loot is client-generated or stubbed** +- **Client:** `engine.ts:649–655` generates a trivial `LootDrop` with `itemType: 'gold'`, `rarity: Common`. +- **Server:** `GetLoot` (`game.go:587–614`) returns an in-memory cache or empty list. No loot generation exists on the server side tied to enemy death. + +### Severity P2 (Medium — Design Debt) + +**GAP-8: Buffs/debuffs not persisted across save** +- `HeroStore.Save` writes hero stats but does not write to `hero_active_buffs` or `hero_active_debuffs` tables. +- `ActivateBuff` handler mutates the in-memory hero, saves via `store.Save`, but buffs are lost on next DB load. + +**GAP-9: Engine death handler doesn't persist** +- `handleEnemyDeath` awards XP/gold and runs `hero.LevelUp()` on the in-memory `*model.Hero`, but never calls `store.Save`. If the server restarts, all in-flight combat progress is lost. + +**GAP-10: `CheckOrigin: return true` on WebSocket** +- `ws.go:17–20` — any origin can upgrade. Combined with no auth, this enables cross-site WebSocket hijacking. + +**GAP-11: Redis connected but unused** +- `cmd/server/main.go` creates a Redis client that is never passed to any service. No session store, no rate limiting, no pub/sub for WS scaling. + +--- + +## Part 2: Backend Engineer Prompt (Go) + +### Objective + +Make combat, progression, and economy **server-authoritative**. The client becomes a thin renderer that sends commands and receives state updates over WebSocket. No gameplay-critical computation on the client. + +### New WebSocket Message Envelope + +All server→client and client→server messages use this envelope: + +```go +// internal/model/ws_message.go +type WSMessage struct { + Type string `json:"type"` + Payload json.RawMessage `json:"payload"` +} +``` + +Server always sends `WSMessage`. Client always sends `WSMessage`. The `readPump` must parse incoming text into `WSMessage` and route by `Type`. + +### New WS Event Types (server→client) + +```json +// combat_start +{"type":"combat_start","payload":{"enemy":{"id":123,"name":"Forest Wolf","hp":30,"maxHp":30,"attack":8,"defense":2,"speed":1.8,"enemyType":"wolf","isElite":false},"heroHp":100,"heroMaxHp":100}} + +// attack (hero hits enemy) +{"type":"attack","payload":{"source":"hero","damage":15,"isCrit":true,"heroHp":100,"enemyHp":15,"debuffApplied":null,"timestamp":"..."}} + +// attack (enemy hits hero) +{"type":"attack","payload":{"source":"enemy","damage":8,"isCrit":false,"heroHp":92,"enemyHp":15,"debuffApplied":"poison","timestamp":"..."}} + +// hero_died +{"type":"hero_died","payload":{"heroHp":0,"enemyHp":30,"killedBy":"Fire Demon"}} + +// combat_end (enemy defeated) +{"type":"combat_end","payload":{"xpGained":50,"goldGained":30,"newXp":1250,"newGold":500,"newLevel":5,"leveledUp":true,"loot":[{"itemType":"gold","rarity":"common","goldAmount":30}]}} + +// level_up (emitted inside combat_end or standalone) +{"type":"level_up","payload":{"newLevel":5,"hp":120,"maxHp":120,"attack":22,"defense":15,"speed":1.45,"strength":6,"constitution":6,"agility":6,"luck":6}} + +// buff_applied +{"type":"buff_applied","payload":{"buffType":"rage","magnitude":100,"durationMs":10000,"expiresAt":"..."}} + +// debuff_applied +{"type":"debuff_applied","payload":{"debuffType":"poison","magnitude":5,"durationMs":5000,"expiresAt":"..."}} + +// hero_state (full sync on connect or after revive) +{"type":"hero_state","payload":{...full hero JSON...}} +``` + +### New WS Command Types (client→server) + +```json +// Client requests next encounter (replaces REST POST /hero/encounter) +{"type":"request_encounter","payload":{}} + +// Client requests revive (replaces REST POST /hero/revive) +{"type":"request_revive","payload":{}} + +// Client requests buff activation (replaces REST POST /hero/buff/{buffType}) +{"type":"activate_buff","payload":{"buffType":"rage"}} +``` + +### Step-by-Step Changes + +#### 1. Fix WS protocol — `internal/handler/ws.go` + +**a) Respond to text "ping" with text "pong"** + +In `readPump` (currently lines 157–166), instead of discarding all messages, parse them: + +```go +func (c *Client) readPump() { + defer func() { + c.hub.unregister <- c + c.conn.Close() + }() + + c.conn.SetReadLimit(maxMessageSize) + c.conn.SetReadDeadline(time.Now().Add(pongWait)) + c.conn.SetPongHandler(func(string) error { + c.conn.SetReadDeadline(time.Now().Add(pongWait)) + return nil + }) + + for { + _, raw, err := c.conn.ReadMessage() + if err != nil { + if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) { + c.hub.logger.Warn("websocket read error", "error", err) + } + break + } + + text := string(raw) + if text == "ping" { + c.conn.SetWriteDeadline(time.Now().Add(writeWait)) + c.conn.WriteMessage(websocket.TextMessage, []byte("pong")) + continue + } + + var msg model.WSMessage + if err := json.Unmarshal(raw, &msg); err != nil { + c.hub.logger.Warn("invalid ws message", "error", err) + continue + } + c.handleCommand(msg) + } +} +``` + +**b) Wrap outbound events in envelope** + +Change `Client.send` channel type from `model.CombatEvent` to `model.WSMessage`. In `writePump`, `WriteJSON(msg)` where `msg` is already `WSMessage`. + +Change `Hub.broadcast` channel and `BroadcastEvent` to accept `WSMessage`. Create a helper: + +```go +func WrapEvent(eventType string, payload any) model.WSMessage { + data, _ := json.Marshal(payload) + return model.WSMessage{Type: eventType, Payload: data} +} +``` + +**c) Extract heroID from auth** + +In `HandleWS`, parse `initData` query param, validate Telegram HMAC, extract user ID, load hero from DB: + +```go +func (h *WSHandler) HandleWS(w http.ResponseWriter, r *http.Request) { + initData := r.URL.Query().Get("initData") + telegramID, err := h.auth.ValidateAndExtractUserID(initData) + if err != nil { + http.Error(w, "unauthorized", http.StatusUnauthorized) + return + } + + hero, err := h.store.GetByTelegramID(r.Context(), telegramID) + if err != nil || hero == nil { + http.Error(w, "hero not found", http.StatusNotFound) + return + } + + conn, err := upgrader.Upgrade(w, r, nil) + if err != nil { return } + + client := &Client{ + hub: h.hub, + conn: conn, + send: make(chan model.WSMessage, sendBufSize), + heroID: hero.ID, + hero: hero, + engine: h.engine, + store: h.store, + } + h.hub.register <- client + go client.writePump() + go client.readPump() + + // Send initial hero state + client.sendMessage(WrapEvent("hero_state", hero)) +} +``` + +**d) Add `WSHandler` dependencies** + +`WSHandler` needs: `*Hub`, `*game.Engine`, `*storage.HeroStore`, `*handler.AuthValidator`, `*slog.Logger`. + +**e) Route commands in `handleCommand`** + +```go +func (c *Client) handleCommand(msg model.WSMessage) { + switch msg.Type { + case "request_encounter": + c.handleRequestEncounter() + case "request_revive": + c.handleRequestRevive() + case "activate_buff": + c.handleActivateBuff(msg.Payload) + } +} +``` + +#### 2. Wire `StartCombat` into encounter flow — `internal/handler/ws.go` (new method on `Client`) + +```go +func (c *Client) handleRequestEncounter() { + hero := c.hero + if hero.State == model.StateDead || hero.HP <= 0 { + return + } + if _, ok := c.engine.GetCombat(hero.ID); ok { + return // already in combat + } + + enemy := pickEnemyForLevel(hero.Level) + enemy.ID = generateEnemyID() + hero.State = model.StateFighting + + c.engine.StartCombat(hero, &enemy) + + c.sendMessage(WrapEvent("combat_start", map[string]any{ + "enemy": enemy, + "heroHp": hero.HP, + "heroMaxHp": hero.MaxHP, + })) +} +``` + +Now the engine's tick loop will drive the combat, emit `CombatEvent` via `eventCh`, which flows through the bridge goroutine to `Hub.BroadcastEvent`, to matching clients. + +#### 3. Enrich engine events with envelope — `internal/game/engine.go` + +Change `emitEvent` to emit `WSMessage` instead of `CombatEvent`: + +```go +type Engine struct { + // ... + eventCh chan model.WSMessage // changed from CombatEvent +} + +func (e *Engine) emitEvent(eventType string, payload any) { + msg := model.WrapEvent(eventType, payload) + select { + case e.eventCh <- msg: + default: + e.logger.Warn("event channel full, dropping", "type", eventType) + } +} +``` + +Update all `emitEvent` call sites in `processHeroAttack`, `processEnemyAttack`, `handleEnemyDeath`, `StartCombat`, and the debuff/death checks. + +#### 4. Server-side rewards on enemy death — `internal/game/engine.go` + +`handleEnemyDeath` already awards XP/gold and calls `hero.LevelUp()`. Add: + +a) Persist to DB after rewards: + +```go +func (e *Engine) handleEnemyDeath(cs *model.CombatState, now time.Time) { + hero := cs.Hero + enemy := &cs.Enemy + + oldLevel := hero.Level + hero.XP += enemy.XPReward + hero.Gold += enemy.GoldReward + + leveledUp := false + for hero.LevelUp() { + leveledUp = true + } + hero.State = model.StateWalking + + // Persist + if e.store != nil { + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) + defer cancel() + if err := e.store.Save(ctx, hero); err != nil { + e.logger.Error("failed to persist after enemy death", "error", err) + } + } + + // Emit combat_end with rewards + e.emitEvent("combat_end", map[string]any{ + "xpGained": enemy.XPReward, + "goldGained": enemy.GoldReward, + "newXp": hero.XP, + "newGold": hero.Gold, + "newLevel": hero.Level, + "leveledUp": leveledUp, + "loot": generateLoot(enemy, hero), + }) + + if leveledUp { + e.emitEvent("level_up", map[string]any{ + "newLevel": hero.Level, "hp": hero.HP, "maxHp": hero.MaxHP, + "attack": hero.Attack, "defense": hero.Defense, "speed": hero.Speed, + "strength": hero.Strength, "constitution": hero.Constitution, + "agility": hero.Agility, "luck": hero.Luck, + }) + } + + delete(e.combats, cs.HeroID) +} +``` + +b) Add `store *storage.HeroStore` to `Engine` struct, pass it from `main.go`. + +#### 5. Implement server-side loot generation — `internal/game/loot.go` (new file) + +```go +package game + +import "math/rand" + +func generateLoot(enemy *model.Enemy, hero *model.Hero) []LootDrop { + roll := rand.Float64() + var rarity string + switch { + case roll < 0.001: + rarity = "legendary" + case roll < 0.01: + rarity = "epic" + case roll < 0.05: + rarity = "rare" + case roll < 0.25: + rarity = "uncommon" + default: + rarity = "common" + } + return []LootDrop{{ + ItemType: "gold", + Rarity: rarity, + GoldAmount: enemy.GoldReward, + }} +} + +type LootDrop struct { + ItemType string `json:"itemType"` + Rarity string `json:"rarity"` + GoldAmount int64 `json:"goldAmount"` +} +``` + +#### 6. Replace `SaveHero` — `internal/handler/game.go` + +**Delete** the current `SaveHero` handler entirely (lines 471–585). Replace with a minimal preferences-only endpoint: + +```go +type savePreferencesRequest struct { + // Only non-gameplay settings +} + +func (h *GameHandler) SavePreferences(w http.ResponseWriter, r *http.Request) { + writeJSON(w, http.StatusOK, map[string]string{"status": "ok"}) +} +``` + +Update the route in `router.go`: replace `r.Post("/hero/save", gameH.SaveHero)` with `r.Post("/hero/preferences", gameH.SavePreferences)` (or remove entirely for now). + +Keep `POST /hero/encounter`, `POST /hero/revive`, and `POST /hero/buff/{buffType}` as REST fallbacks, but the primary flow should be WS commands. The REST encounter handler should also call `engine.StartCombat`: + +```go +func (h *GameHandler) RequestEncounter(w http.ResponseWriter, r *http.Request) { + // ... existing hero lookup ... + enemy := pickEnemyForLevel(hero.Level) + enemy.ID = time.Now().UnixNano() + + h.engine.StartCombat(hero, &enemy) // NEW: register combat + + writeJSON(w, http.StatusOK, encounterEnemyResponse{...}) +} +``` + +#### 7. Persist buffs/debuffs — `internal/storage/hero_store.go` + +Add methods to write/read `hero_active_buffs` and `hero_active_debuffs` tables. Update `Save` to transactionally persist hero + buffs + debuffs. Update `GetByTelegramID` to join and hydrate them. + +#### 8. Enable auth middleware — `internal/router/router.go` + +Uncomment line 59: + +```go +r.Use(handler.TelegramAuthMiddleware(deps.BotToken)) +``` + +Fix `validateInitData` to reject empty `botToken` instead of skipping HMAC. +Restrict CORS origin to the Telegram Mini App domain instead of `*`. +Set `CheckOrigin` in ws.go to validate against allowed origins. + +#### 9. Hero state synchronization on WS connect + +When a client connects, send `hero_state` with the full current hero. If the hero is in an active combat, also send `combat_start` with the current enemy and HP values so the client can resume rendering mid-fight. + +#### 10. Auto-save on disconnect + +In `readPump`'s defer (when client disconnects), if hero is in combat, call `engine.StopCombat(heroID)` and persist the hero state to DB. + +### Files to Modify + +| File | Action | +|------|--------| +| `internal/model/ws_message.go` | **New** — `WSMessage` struct + `WrapEvent` helper | +| `internal/handler/ws.go` | Major rewrite — envelope, text ping/pong, command routing, auth, encounter/revive/buff handlers | +| `internal/game/engine.go` | Change `eventCh` to `chan WSMessage`, add `store`, enrich `handleEnemyDeath` with rewards+persist | +| `internal/game/loot.go` | **New** — `generateLoot` | +| `internal/handler/game.go` | Delete `SaveHero` (lines 471–585), wire `StartCombat` into `RequestEncounter` | +| `internal/router/router.go` | Uncomment auth, remove `/hero/save` route, pass engine to WSHandler | +| `internal/storage/hero_store.go` | Add buff/debuff persistence in `Save` and `GetByTelegramID` | +| `internal/handler/auth.go` | Reject empty `botToken`, export `ValidateAndExtractUserID` for WS | +| `cmd/server/main.go` | Pass `store` to engine, pass `engine` + `store` + `auth` to WSHandler | + +### Risks + +1. **Engine holds `*model.Hero` in memory** — if the REST handler also loads the same hero from DB and modifies it, state diverges. Mitigation: during active combat, REST reads should load from engine's `CombatState`, not DB. Or: make the engine the single writer for heroes in combat. +2. **Tick-based DoT/regen** — `ProcessDebuffDamage` and `ProcessEnemyRegen` are called in `processTick` but may need careful timing. Verify they run at 10Hz and produce sane damage values. +3. **Event channel backpressure** — if a slow client falls behind, events are dropped (non-blocking send). Consider per-client buffering with disconnect on overflow (already partly implemented via `sendBufSize`). + +--- + +## Part 3: Frontend Engineer Prompt (React/TS) + +### Objective + +Transform the frontend from a "simulate locally, sync periodically" model to a **"render what the server tells you"** model. The client sends commands over WebSocket, receives authoritative state updates, and renders them. Client-side combat simulation is removed. + +### What the Frontend Keeps Ownership Of + +- **Rendering:** PixiJS canvas, isometric projection, sprites, draw calls +- **Camera:** pan, zoom, shake effects +- **Animation:** walking cycle, attack animations, death animations, visual transitions +- **UI overlays:** HUD, HP bars, buff bars, death screen, loot popups, floating damage numbers +- **Walking movement:** client drives the visual walking animation (diagonal drift) between encounters. The walking is cosmetic — the server decides when an encounter starts, not the client. +- **Input:** touch/click events for buff activation, revive button +- **Sound/haptics:** triggered by incoming server events + +### What the Frontend Stops Doing + +- Computing damage (hero or enemy) +- Rolling crits, applying debuffs +- Deciding when enemies die +- Awarding XP, gold, levels +- Generating loot +- Running `_simulateFighting` / `_onEnemyDefeated` / `_spawnEnemy` +- Auto-saving hero stats to `/hero/save` +- Sending `sendBeacon` with hero stats on unload +- Level-up stat calculations + +### New WS Message Types to Consume + +```typescript +// src/network/types.ts (new file or add to existing types) + +interface CombatStartPayload { + enemy: { + id: number; + name: string; + hp: number; + maxHp: number; + attack: number; + defense: number; + speed: number; + enemyType: string; + isElite: boolean; + }; + heroHp: number; + heroMaxHp: number; +} + +interface AttackPayload { + source: 'hero' | 'enemy'; + damage: number; + isCrit: boolean; + heroHp: number; + enemyHp: number; + debuffApplied: string | null; + timestamp: string; +} + +interface HeroDiedPayload { + heroHp: number; + enemyHp: number; + killedBy: string; +} + +interface CombatEndPayload { + xpGained: number; + goldGained: number; + newXp: number; + newGold: number; + newLevel: number; + leveledUp: boolean; + loot: LootDrop[]; +} + +interface LevelUpPayload { + newLevel: number; + hp: number; + maxHp: number; + attack: number; + defense: number; + speed: number; + strength: number; + constitution: number; + agility: number; + luck: number; +} + +interface HeroStatePayload { + id: number; + hp: number; + maxHp: number; + attack: number; + defense: number; + speed: number; + // ...all fields +} + +interface BuffAppliedPayload { + buffType: string; + magnitude: number; + durationMs: number; + expiresAt: string; +} + +interface DebuffAppliedPayload { + debuffType: string; + magnitude: number; + durationMs: number; + expiresAt: string; +} +``` + +### New WS Commands to Send + +```typescript +// Request next encounter (triggers server combat) +ws.send('request_encounter', {}); + +// Request revive +ws.send('request_revive', {}); + +// Activate buff +ws.send('activate_buff', { buffType: 'rage' }); +``` + +### Step-by-Step Changes + +#### 1. Fix WebSocket client — `src/network/websocket.ts` + +The current implementation already expects `{type, payload}` envelope and handles text `"pong"` — this matches the new server protocol. **No changes needed** to the message parsing. + +#### 2. Gut `_simulateFighting` — `src/game/engine.ts` + +Remove the entire fighting simulation. The `_simulateTick` method should only handle the walking phase visually: + +```typescript +private _simulateTick(dtMs: number): void { + if (!this._gameState.hero) return; + + if (this._gameState.phase === GamePhase.Walking) { + this._simulateWalking(dtMs); + } + // Fighting, death, loot — all driven by server events now +} +``` + +**Remove entirely:** +- `_simulateFighting` (lines 464–551) +- `_onEnemyDefeated` (lines 624–671) +- `_spawnEnemy` (lines 553–572) +- `_requestEncounter` (lines 575–595) — encounters are now requested via WS +- `_effectiveHeroDamage`, `_effectiveHeroAttackSpeed`, `_incomingDamageMultiplier` — server computes these +- `_isBuffActive`, `_isHeroStunned` — server handles stun/buff logic +- Attack timer fields: `_nextHeroAttackMs`, `_nextEnemyAttackMs` + +**Keep** `_simulateWalking` but strip it down to visual movement only — remove the encounter spawning logic: + +```typescript +private _simulateWalking(dtMs: number): void { + const hero = this._gameState.hero!; + + const moveSpeed = 0.002; // tiles per ms + hero.position.x += moveSpeed * dtMs * 0.7071; + hero.position.y += moveSpeed * dtMs * 0.7071; +} +``` + +#### 3. Remove `_serverAuthoritative` flag — `src/game/engine.ts` + +This flag is no longer needed. The engine is always server-authoritative. Remove: +- The `_serverAuthoritative` field (line 61–62) +- The `if (!this._serverAuthoritative)` check in `_update` (line 334) +- The flag-setting in `applyServerState` (line 185) +- The `if (this._serverAuthoritative) return` guard in `reviveHero` (line 674) + +#### 4. Add server event handlers to the engine — `src/game/engine.ts` + +```typescript +handleCombatStart(payload: CombatStartPayload): void { + const enemy: EnemyState = { + id: payload.enemy.id, + name: payload.enemy.name, + hp: payload.enemy.hp, + maxHp: payload.enemy.maxHp, + position: { + x: this._gameState.hero!.position.x + 1.5, + y: this._gameState.hero!.position.y, + }, + attackSpeed: payload.enemy.speed, + damage: payload.enemy.attack, + defense: payload.enemy.defense, + enemyType: payload.enemy.enemyType as EnemyType, + }; + + this._gameState = { + ...this._gameState, + phase: GamePhase.Fighting, + enemy, + hero: { ...this._gameState.hero!, hp: payload.heroHp, maxHp: payload.heroMaxHp }, + }; + this._onStateChange?.(this._gameState); +} + +handleAttack(payload: AttackPayload): void { + const hero = { ...this._gameState.hero! }; + const enemy = this._gameState.enemy ? { ...this._gameState.enemy } : null; + + hero.hp = payload.heroHp; + if (enemy) enemy.hp = payload.enemyHp; + + this._gameState = { ...this._gameState, hero, enemy }; + this._onStateChange?.(this._gameState); +} + +handleHeroDied(payload: HeroDiedPayload): void { + this._gameState = { + ...this._gameState, + phase: GamePhase.Dead, + hero: { ...this._gameState.hero!, hp: 0 }, + }; + this._onStateChange?.(this._gameState); +} + +handleCombatEnd(payload: CombatEndPayload): void { + const hero = { ...this._gameState.hero! }; + hero.xp = payload.newXp; + hero.gold = payload.newGold; + hero.level = payload.newLevel; + hero.xpToNext = Math.round(100 * Math.pow(1.1, payload.newLevel)); + + this._gameState = { + ...this._gameState, + phase: GamePhase.Walking, + hero, + enemy: null, + loot: payload.loot.length > 0 ? payload.loot[0] : null, + }; + this._onStateChange?.(this._gameState); +} + +handleLevelUp(payload: LevelUpPayload): void { + const hero = { ...this._gameState.hero! }; + hero.level = payload.newLevel; + hero.hp = payload.hp; + hero.maxHp = payload.maxHp; + hero.damage = payload.attack; + hero.defense = payload.defense; + hero.attackSpeed = payload.speed; + hero.strength = payload.strength; + hero.constitution = payload.constitution; + hero.agility = payload.agility; + hero.luck = payload.luck; + hero.xpToNext = Math.round(100 * Math.pow(1.1, payload.newLevel)); + + this._gameState = { ...this._gameState, hero }; + this._onStateChange?.(this._gameState); +} + +handleHeroState(payload: HeroStatePayload): void { + const heroState = heroResponseToState(payload); + this._gameState = { + ...this._gameState, + hero: heroState, + }; + this._onStateChange?.(this._gameState); +} +``` + +#### 5. Wire WS events in App.tsx — `src/App.tsx` + +Replace existing WS handlers with: + +```typescript +ws.on('hero_state', (msg) => { + engine.handleHeroState(msg.payload as HeroStatePayload); +}); + +ws.on('combat_start', (msg) => { + engine.handleCombatStart(msg.payload as CombatStartPayload); +}); + +ws.on('attack', (msg) => { + const p = msg.payload as AttackPayload; + engine.handleAttack(p); + hapticImpact(p.isCrit ? 'heavy' : 'light'); + engine.camera.shake(p.isCrit ? 8 : 4, p.isCrit ? 250 : 150); +}); + +ws.on('hero_died', (msg) => { + engine.handleHeroDied(msg.payload as HeroDiedPayload); + hapticNotification('error'); +}); + +ws.on('combat_end', (msg) => { + engine.handleCombatEnd(msg.payload as CombatEndPayload); + hapticNotification('success'); +}); + +ws.on('level_up', (msg) => { + engine.handleLevelUp(msg.payload as LevelUpPayload); + hapticNotification('success'); +}); +``` + +#### 6. Replace encounter trigger + +Remove `engine.setEncounterProvider(...)`. Instead, after walking for X seconds, send a WS command: + +```typescript +// In _simulateWalking: +private _walkTimerMs = 0; +private static readonly ENCOUNTER_REQUEST_INTERVAL_MS = 3000; + +private _simulateWalking(dtMs: number): void { + // ... visual movement ... + + this._walkTimerMs += dtMs; + if (this._walkTimerMs >= GameEngine.ENCOUNTER_REQUEST_INTERVAL_MS) { + this._walkTimerMs = 0; + this._onRequestEncounter?.(); + } +} + +// In App.tsx: +engine.onRequestEncounter(() => { + ws.send('request_encounter', {}); +}); +``` + +#### 7. Remove auto-save + +- Remove `engine.onSave(...)` registration +- Remove `_triggerSave`, `_saveTimerMs`, `SAVE_INTERVAL_MS` from engine.ts +- Remove `handleBeforeUnload` / `sendBeacon` +- Remove `heroStateToSaveRequest` function +- Remove the import of `saveHero` from `network/api.ts` + +#### 8. Fix revive flow + +```typescript +const handleRevive = useCallback(() => { + ws.send('request_revive', {}); +}, []); +``` + +Remove `engine.reviveHero()` from engine.ts. + +#### 9. Fix buff activation + +```typescript +const handleBuffActivate = useCallback((type: BuffType) => { + ws.send('activate_buff', { buffType: type }); + hapticImpact('medium'); +}, []); +``` + +Keep REST `activateBuff` as fallback if WS disconnected. + +#### 10. Handle WS disconnect gracefully + +Show "Reconnecting..." overlay. On reconnect, server sends `hero_state` automatically. +Remove `initDemoState` fallback (or gate behind explicit `DEV_OFFLINE` flag). + +### Files to Modify + +| File | Action | +|------|--------| +| `src/game/engine.ts` | Major rewrite — remove fighting sim, add server event handlers, remove save logic | +| `src/App.tsx` | Replace WS handlers, remove auto-save, encounter provider, fix revive/buff to use WS | +| `src/network/websocket.ts` | No changes needed (already correct format) | +| `src/network/api.ts` | Remove `saveHero`. Keep `initHero`, `requestRevive`, `activateBuff` as REST fallbacks | +| `src/network/types.ts` | **New** — WS payload interfaces | +| `src/game/types.ts` | Remove types only used by client-side combat (if any) | +| `src/ui/LootPopup.tsx` | Wire to `combat_end` loot payload instead of client-generated loot | + +### Risks + +1. **Latency perception** — At 10Hz server tick (100ms), attacks feel delayed compared to client-side instant feedback. Mitigation: client can play "optimistic" attack animations immediately and snap HP values when the `attack` event arrives. 100ms is fast enough for idle game feel. +2. **Walking encounter timing** — If the client requests encounters every 3s but WS latency varies, encounters may feel irregular. Mitigation: server enforces minimum walk cooldown (e.g. 2s) and responds immediately when valid. +3. **Disconnect during combat** — If the client disconnects mid-fight, the server keeps the combat running. Hero might die while offline. On reconnect, server sends current state (possibly dead). Client must handle resuming into any phase. +4. **Demo mode removal** — Removing `initDemoState` means the game won't work without a backend. Keep a `DEV_OFFLINE` env flag for development. + +--- + +## Implementation Priority + +| Order | Task | Owner | Blocks | +|-------|------|-------|--------| +| 1 | Enable auth middleware + fix `validateInitData` | Backend | Everything | +| 2 | WS envelope + text ping/pong + heroID from auth | Backend | Frontend WS integration | +| 3 | Wire `StartCombat` into `RequestEncounter` handler | Backend | Server-driven combat | +| 4 | Enrich engine events with rewards, persist on death | Backend | Frontend can render combat | +| 5 | Delete `SaveHero`, add `SavePreferences` | Backend | Frontend must stop auto-save | +| 6 | Frontend: remove client combat sim, add server event handlers | Frontend | Needs steps 2–4 done | +| 7 | Frontend: switch encounter/revive/buff to WS commands | Frontend | Needs step 2 done | +| 8 | Buff/debuff DB persistence | Backend | Nice-to-have for MVP | +| 9 | Server-side loot generation | Backend | Nice-to-have for MVP | +| 10 | Restrict CORS + WS CheckOrigin | Backend | Pre-production hardening | + +Steps 1–5 (backend) and 6–7 (frontend) can be parallelized once the WS contract (envelope format + event types) is agreed upon — which this document defines. diff --git a/docs/spec-server-authoritative.md b/docs/spec-server-authoritative.md new file mode 100644 index 0000000..576d929 --- /dev/null +++ b/docs/spec-server-authoritative.md @@ -0,0 +1,662 @@ +# Server-Authoritative Architecture: Implementation Specification + +Status: APPROVED for implementation +Date: 2026-03-27 + +This spec is the contract between the backend and frontend agents. +Each phase is independently deployable. Phases must ship in order. + +--- + +## 1. WebSocket Message Protocol + +All messages use a typed envelope: + +```json +{"type": "", "payload": { ... }} +``` + +The `type` field is the discriminant. `payload` is always an object (never null). + +### 1.1 Server -> Client Messages + +| type | payload | when sent | +|---|---|---| +| `hero_state` | Full `Hero` JSON (same shape as GET /hero) | On WS connect; after level-up; after revive; after equipment change | +| `hero_move` | `{x, y, targetX, targetY, speed, heading}` | 2 Hz while hero is walking (every 500ms) | +| `position_sync` | `{x, y, waypointIndex, waypointFraction, state}` | Every 10s as drift correction | +| `route_assigned` | `{roadId, waypoints: [{x,y}], destinationTownId, speed}` | When hero starts walking a new road segment | +| `combat_start` | `{enemy: {name, type, hp, maxHp, attack, defense, speed, isElite}}` | Server decides encounter | +| `attack` | `{source: "hero"\|"enemy", damage, isCrit, heroHp, enemyHp, debuffApplied}` | Each swing during combat | +| `combat_end` | `{xpGained, goldGained, loot: [{itemType, name, rarity}], leveledUp, newLevel}` | Hero wins fight | +| `hero_died` | `{killedBy: ""}` | Hero HP reaches 0 | +| `hero_revived` | `{hp}` | After revive (client-requested or auto) | +| `buff_applied` | `{buffType, duration, magnitude}` | Buff activated | +| `town_enter` | `{townId, townName, biome, npcs: [{id, name, type}], restDurationMs}` | Hero arrives at town | +| `town_exit` | `{}` | Rest complete, hero leaves town | +| `npc_encounter` | `{npcId, npcName, role, dialogue, cost}` | Wandering merchant on road | +| `level_up` | `{newLevel, statChanges: {hp, attack, defense, strength, constitution, agility, luck}}` | On level-up | +| `equipment_change` | `{slot: "weapon"\|"armor", item}` | Auto-equip happened | +| `potion_collected` | `{count}` | Potion dropped from loot | +| `quest_available` | `{questId, title, description, npcName}` | NPC offers quest in town | +| `quest_progress` | `{questId, current, target}` | Kill/collect progress update | +| `quest_complete` | `{questId, title, rewards: {xp, gold}}` | Quest objectives met | +| `error` | `{code, message}` | Invalid client action | + +### 1.2 Client -> Server Messages + +| type | payload | effect | +|---|---|---| +| `activate_buff` | `{buffType: string}` | Activate a buff (server validates charges/gold) | +| `use_potion` | `{}` | Use healing potion (server validates potions > 0, in combat) | +| `accept_quest` | `{questId: int}` | Accept quest from NPC (must be in town with that NPC) | +| `claim_quest` | `{questId: int}` | Claim completed quest reward | +| `npc_interact` | `{npcId: int}` | Interact with NPC (must be in same town) | +| `npc_alms_accept` | `{}` | Accept wandering merchant offer | +| `npc_alms_decline` | `{}` | Decline wandering merchant offer | +| `revive` | `{}` | Request revive (when dead) | +| `ping` | `{}` | Keepalive (server replies with `{"type":"pong","payload":{}}`) | + +### 1.3 Backward Compatibility Notes + +- Current `CombatEvent` struct (type/heroId/damage/source/isCrit/debuffApplied/heroHp/enemyHp/timestamp) maps directly into the new `attack` envelope payload. Migration: wrap in `{"type":"attack","payload":{...}}`. +- Current `readPump` handles raw `"ping"` string. Change to parse JSON envelope; keep raw `"ping"` support during transition. +- `maxMessageSize` must increase from 512 to 4096 to accommodate `hero_state` and `route_assigned` payloads. + +--- + +## 2. Backend Changes + +### 2.1 New GameState Values + +Add to `model/combat.go`: + +```go +const ( + StateWalking GameState = "walking" + StateFighting GameState = "fighting" + StateDead GameState = "dead" + StateResting GameState = "resting" // NEW: in town, resting + StateInTown GameState = "in_town" // NEW: in town, interacting with NPCs +) +``` + +### 2.2 Hero Model Additions + +Add fields to `model.Hero`: + +```go +// Movement state (persisted to DB for reconnect recovery) +CurrentTownID *int64 `json:"currentTownId,omitempty"` +DestinationTownID *int64 `json:"destinationTownId,omitempty"` +RoadID *int64 `json:"roadId,omitempty"` +WaypointIndex int `json:"waypointIndex"` +WaypointFraction float64 `json:"waypointFraction"` // 0.0-1.0 between waypoints +``` + +Migration: `000007_hero_movement_state.sql` + +```sql +ALTER TABLE heroes + ADD COLUMN current_town_id BIGINT REFERENCES towns(id), + ADD COLUMN destination_town_id BIGINT REFERENCES towns(id), + ADD COLUMN road_id BIGINT, + ADD COLUMN waypoint_index INT NOT NULL DEFAULT 0, + ADD COLUMN waypoint_fraction DOUBLE PRECISION NOT NULL DEFAULT 0; +``` + +### 2.3 Road Graph (DB + in-memory) + +Migration: `000008_roads.sql` + +```sql +CREATE TABLE roads ( + id BIGSERIAL PRIMARY KEY, + from_town_id BIGINT NOT NULL REFERENCES towns(id), + to_town_id BIGINT NOT NULL REFERENCES towns(id), + distance DOUBLE PRECISION NOT NULL, + UNIQUE(from_town_id, to_town_id) +); + +CREATE TABLE road_waypoints ( + id BIGSERIAL PRIMARY KEY, + road_id BIGINT NOT NULL REFERENCES roads(id), + seq INT NOT NULL, + x DOUBLE PRECISION NOT NULL, + y DOUBLE PRECISION NOT NULL, + UNIQUE(road_id, seq) +); + +-- Linear chain: Willowdale(1) -> Thornwatch(2) -> ... -> Starfall(7) +-- Waypoints generated at insert time with +-2 tile jitter every 20 tiles +``` + +In-memory: `game.RoadGraph` struct loaded at startup. Contains all roads + waypoints. Immutable after load. + +```go +type RoadGraph struct { + Roads map[int64]*Road // road ID -> road + TownRoads map[int64][]*Road // town ID -> outgoing roads + Towns map[int64]*model.Town // town ID -> town + TownOrder []int64 // ordered town IDs for sequential traversal +} + +type Road struct { + ID int64 + FromTownID int64 + ToTownID int64 + Waypoints []Point // ordered list + Distance float64 +} + +type Point struct { + X, Y float64 +} +``` + +### 2.4 Movement System + +New file: `backend/internal/game/movement.go` + +```go +type HeroMovement struct { + HeroID int64 + Hero *model.Hero // live reference + CurrentX float64 + CurrentY float64 + TargetX float64 // next waypoint + TargetY float64 + Speed float64 // units/sec, base 2.0 + State model.GameState + DestinationTownID int64 + Road *Road + WaypointIndex int + WaypointFraction float64 + LastEncounterAt time.Time // cooldown tracking + RestUntil time.Time // when resting in town +} + +const ( + BaseMoveSpeed = 2.0 // units per second + MovementTickRate = 500 * time.Millisecond // 2 Hz + PositionSyncRate = 10 * time.Second + EncounterCooldownBase = 15 * time.Second // min time between encounters + EncounterChancePerTick = 0.04 // ~4-5 per road segment + TownRestDuration = 7 * time.Second // 5-10s, randomized per visit +) +``` + +**Movement tick logic** (called from `Engine.processTick`): + +``` +for each online hero with active movement: + if state == "resting" and now > restUntil: + set state = "walking" + pick next destination town + assign route + send town_exit + route_assigned + continue + + if state != "walking": + continue + + // Advance position along waypoints + distanceThisTick = speed * tickDelta.Seconds() + advance hero along road waypoints by distanceThisTick + update waypointIndex, waypointFraction, currentX, currentY + + // Check for random encounter (if cooldown passed) + if now - lastEncounterAt > encounterCooldown: + if rand < encounterChancePerTick: + spawn enemy for hero level + start combat (engine.StartCombat) + send combat_start + lastEncounterAt = now + + // Check if reached destination town + if waypointIndex >= len(road.Waypoints) - 1 and fraction >= 1.0: + set state = "resting" + set restUntil = now + randomDuration(5s, 10s) + set currentTownID = destinationTownID + send town_enter + + // Send position update (2 Hz) + send hero_move {x, y, targetX, targetY, speed, heading} +``` + +**Destination selection:** + +``` +func pickNextTown(hero, roadGraph) townID: + if hero has no currentTownID: + return nearest town by Euclidean distance + + // Walk the town chain: find current position, go to next + currentIdx = indexOf(hero.currentTownID, roadGraph.TownOrder) + nextIdx = currentIdx + 1 + if nextIdx >= len(TownOrder): + nextIdx = currentIdx - 1 // reverse at chain end + return TownOrder[nextIdx] +``` + +Heroes bounce back and forth along the 7-town chain. + +### 2.5 Engine Integration + +`Engine` gains: + +```go +type Engine struct { + // ... existing fields ... + movements map[int64]*HeroMovement // keyed by hero ID + roadGraph *RoadGraph + moveTicker *time.Ticker // 2 Hz + syncTicker *time.Ticker // 0.1 Hz +} +``` + +`Engine.Run` changes: + +```go +func (e *Engine) Run(ctx context.Context) error { + combatTicker := time.NewTicker(e.tickRate) // existing: 100ms + moveTicker := time.NewTicker(MovementTickRate) // new: 500ms + syncTicker := time.NewTicker(PositionSyncRate) // new: 10s + + for { + select { + case <-ctx.Done(): ... + case now := <-combatTicker.C: + e.processCombatTick(now) // renamed from processTick + case now := <-moveTicker.C: + e.processMovementTick(now) + case now := <-syncTicker.C: + e.processPositionSync(now) + } + } +} +``` + +### 2.6 Hub Refactor + +The `Hub` currently only broadcasts `model.CombatEvent`. Change to broadcast generic envelopes: + +```go +// WSEnvelope is the wire format for all WS messages. +type WSEnvelope struct { + Type string `json:"type"` + Payload interface{} `json:"payload"` +} + +type Client struct { + hub *Hub + conn *websocket.Conn + send chan WSEnvelope // changed from model.CombatEvent + heroID int64 +} + +type Hub struct { + // ... existing fields ... + broadcast chan WSEnvelope // changed + incoming chan ClientMessage // NEW: messages from clients +} + +type ClientMessage struct { + HeroID int64 + Type string + Payload json.RawMessage +} +``` + +`readPump` change: parse incoming JSON as `WSEnvelope`, route to `Hub.incoming` channel. The engine reads from `Hub.incoming` and dispatches. + +`writePump` change: serialize `WSEnvelope` via `WriteJSON`. + +`BroadcastEvent` still exists but now wraps `CombatEvent` in an envelope before sending. + +New method: + +```go +// SendToHero sends a message to all connections for a specific hero. +func (h *Hub) SendToHero(heroID int64, msgType string, payload interface{}) { + env := WSEnvelope{Type: msgType, Payload: payload} + h.mu.RLock() + for client := range h.clients { + if client.heroID == heroID { + select { + case client.send <- env: + default: + go func(c *Client) { h.unregister <- c }(client) + } + } + } + h.mu.RUnlock() +} +``` + +### 2.7 Hero Lifecycle on WS Connect/Disconnect + +**On connect:** +1. Load hero from DB +2. If hero has no movement state, initialize: place at nearest town, pick destination, assign route +3. Create `HeroMovement` in engine +4. Send `hero_state` (full snapshot) +5. Send `route_assigned` (current route) +6. If hero was mid-combat (state == fighting), resume or cancel combat + +**On disconnect:** +1. Persist hero state to DB (position, HP, gold, etc.) +2. Remove `HeroMovement` from engine +3. Hero becomes eligible for offline simulator ticks + +### 2.8 Combat Integration with Movement + +When `Engine` decides to start combat (from movement tick): +1. Stop hero movement (state = fighting) +2. Call existing `Engine.StartCombat(hero, enemy)` +3. Send `combat_start` via Hub + +When combat ends (enemy dies in `handleEnemyDeath`): +1. Apply rewards (existing `onEnemyDeath` callback) +2. Set state back to "walking" +3. Send `combat_end` with rewards summary +4. Resume movement from where hero stopped + +When hero dies: +1. Send `hero_died` +2. Set state to "dead" +3. Stop movement +4. Wait for client `revive` message (or auto-revive after 1 hour, same as offline) + +### 2.9 Server-Side Potion Use + +When client sends `use_potion`: +1. Validate: hero is in combat, hero.Potions > 0, hero.HP > 0 +2. Apply: hero.HP += hero.MaxHP * 30 / 100, clamp to MaxHP, hero.Potions-- +3. Emit `attack` event with source "potion" (or a new `potion_used` type) +4. Error envelope if validation fails + +--- + +## 3. Frontend Changes + +### 3.1 What to REMOVE from `src/game/engine.ts` + +- All movement/walking logic (position calculation, direction, speed) +- Combat simulation (damage calculation, attack timing, HP tracking) +- Encounter triggering (requestEncounter calls) +- Victory reporting (reportVictory calls) +- Save calls (/hero/save) +- Local state mutation for HP, XP, gold, equipment (all comes from server) + +### 3.2 What to KEEP in `src/game/engine.ts` + +- `requestAnimationFrame` render loop +- Camera follow (track hero position) +- Sprite rendering, animations +- UI overlay rendering (HP bar, XP bar, buff icons) + +### 3.3 New: WS Message Handler + +```typescript +// src/game/ws-handler.ts + +interface WSEnvelope { + type: string; + payload: Record; +} + +class GameWSHandler { + private ws: WebSocket; + private gameState: GameState; // local render state + + onMessage(env: WSEnvelope) { + switch (env.type) { + case 'hero_state': this.handleHeroState(env.payload); break; + case 'hero_move': this.handleHeroMove(env.payload); break; + case 'position_sync': this.handlePositionSync(env.payload); break; + case 'route_assigned': this.handleRouteAssigned(env.payload); break; + case 'combat_start': this.handleCombatStart(env.payload); break; + case 'attack': this.handleAttack(env.payload); break; + case 'combat_end': this.handleCombatEnd(env.payload); break; + case 'hero_died': this.handleHeroDied(env.payload); break; + case 'hero_revived': this.handleHeroRevived(env.payload); break; + case 'town_enter': this.handleTownEnter(env.payload); break; + case 'town_exit': this.handleTownExit(env.payload); break; + case 'level_up': this.handleLevelUp(env.payload); break; + case 'equipment_change': this.handleEquipmentChange(env.payload); break; + // ... etc + } + } + + // Client -> Server + sendActivateBuff(buffType: string) { + this.send({ type: 'activate_buff', payload: { buffType } }); + } + sendUsePotion() { + this.send({ type: 'use_potion', payload: {} }); + } + sendRevive() { + this.send({ type: 'revive', payload: {} }); + } +} +``` + +### 3.4 Position Interpolation + +Frontend must interpolate between `hero_move` updates (received at 2 Hz, rendered at 60 fps): + +```typescript +// On receiving hero_move: +this.prevPosition = this.currentPosition; +this.targetPosition = { x: payload.x, y: payload.y }; +this.moveTarget = { x: payload.targetX, y: payload.targetY }; +this.heroSpeed = payload.speed; +this.lastUpdateTime = performance.now(); + +// In render loop: +const elapsed = (performance.now() - this.lastUpdateTime) / 1000; +const t = Math.min(elapsed / 0.5, 1.0); // 500ms between updates +this.renderX = lerp(this.prevPosition.x, this.targetPosition.x, t); +this.renderY = lerp(this.prevPosition.y, this.targetPosition.y, t); + +// On position_sync: snap to server position if drift > 2 tiles +const drift = distance(render, sync); +if (drift > 2.0) { + this.renderX = sync.x; + this.renderY = sync.y; +} +``` + +### 3.5 REST Endpoints: What Stays, What Goes + +**KEEP (Phase 1-2):** +- `GET /api/v1/hero` -- initial hero load +- `POST /api/v1/hero` -- create hero +- `POST /api/v1/hero/name` -- set name +- `GET /api/v1/hero/adventure-log` -- history +- `GET /api/v1/map` -- map data + +**MOVE TO WS (Phase 2-3, then remove REST):** +- `POST /api/v1/hero/buff/{buffType}` -> client WS `activate_buff` +- `POST /api/v1/hero/revive` -> client WS `revive` +- `POST /api/v1/hero/encounter` -> removed entirely (server decides) +- `POST /api/v1/hero/victory` -> removed entirely (server resolves) + +**Phase 3: deprecation.** These endpoints return 410 Gone with `{"error":"use websocket"}`. + +--- + +## 4. Phase Plan + +### Phase 1: WS Protocol + Server Movement (est. 3-5 days) + +**Backend tasks:** +1. Define `WSEnvelope` type in `model/` or `handler/` +2. Refactor `Hub.broadcast` from `chan model.CombatEvent` to `chan WSEnvelope` +3. Refactor `Client.send` from `chan model.CombatEvent` to `chan WSEnvelope` +4. Add `Hub.SendToHero(heroID, type, payload)` method +5. Wrap existing `emitEvent` calls in envelope: `WSEnvelope{Type: evt.Type, Payload: evt}` +6. Parse incoming client messages as JSON envelopes in `readPump` +7. Add `Hub.incoming` channel + dispatch logic +8. Increase `maxMessageSize` to 4096 +9. Run migration `000007_hero_movement_state.sql` +10. Run migration `000008_roads.sql` + seed waypoints +11. Implement `RoadGraph` loader (read from DB at startup) +12. Implement `HeroMovement` struct and movement tick in engine +13. Add `hero_move` (2 Hz) and `position_sync` (10s) sends +14. Send `hero_state` on WS connect +15. Send `route_assigned` when hero starts a new road +16. Send `town_enter` / `town_exit` on arrival/departure +17. Implement hero lifecycle on connect/disconnect (section 2.7) + +**Frontend tasks:** +1. Create `ws-handler.ts` with typed envelope parsing +2. Implement `hero_move` handler with lerp interpolation +3. Implement `position_sync` handler with drift snap +4. Implement `route_assigned` handler (optional: draw road on map) +5. Implement `town_enter`/`town_exit` UI +6. Remove client-side walking/movement logic from engine.ts +7. Remove `requestEncounter` calls +8. Remove `reportVictory` calls +9. Keep combat UI rendering but drive it from WS `attack` events + +**Integration test:** Connect via WS, verify hero starts walking, receives `hero_move` at 2 Hz, enters town, exits town, receives `combat_start` from server. + +### Phase 2: Server-Authoritative Combat (est. 2-3 days) + +**Backend tasks:** +1. Engine auto-starts combat when movement tick triggers encounter +2. `combat_start` envelope includes full enemy state +3. `attack` envelopes replace client-simulated damage +4. `combat_end` envelope includes full reward summary +5. Wire `use_potion` client message to potion logic +6. Wire `activate_buff` client message to buff logic (move from REST handler) +7. Wire `revive` client message to revive logic (move from REST handler) +8. `hero_died` sent on death; hero waits for `revive` or auto-revive timer + +**Frontend tasks:** +1. Remove all local combat simulation code +2. Display combat from server `attack` events (animate swing, show damage number) +3. Wire "Use Potion" button to `use_potion` WS message +4. Wire buff activation buttons to `activate_buff` WS message +5. Wire revive button to `revive` WS message +6. Display `combat_end` reward summary + +### Phase 3: Remove Deprecated Endpoints (est. 1 day) + +**Backend:** +1. Remove `RequestEncounter` handler +2. Remove `ReportVictory` handler +3. Remove REST buff/revive handlers (if all clients migrated) +4. Add 410 Gone responses for removed endpoints +5. Remove save endpoint if no longer needed (state persisted on disconnect) + +**Frontend:** +1. Remove all REST calls that were migrated to WS +2. Remove any polling/interval-based state refresh (WS pushes everything) + +--- + +## 5. Data Flow Diagrams + +### 5.1 Walking + Encounter + +``` +Engine (2Hz tick) + | + |-- advance hero position along road waypoints + |-- roll encounter check (4% per tick, with cooldown) + | + |-- [no encounter] --> Hub.SendToHero("hero_move", {x,y,...}) + | + |-- [encounter!] --> Engine.StartCombat(hero, enemy) + | | + | +--> Hub.SendToHero("combat_start", {enemy}) + | +--> movement paused + | + |-- [reach town] --> Hub.SendToHero("town_enter", {townId,...}) + | +--> set state = resting, restUntil = now+7s +``` + +### 5.2 Combat Resolution + +``` +Engine (100ms combat tick) + | + |-- process attack queue (existing heap) + |-- hero attacks --> Hub.SendToHero("attack", {source:"hero",...}) + |-- enemy attacks --> Hub.SendToHero("attack", {source:"enemy",...}) + | + |-- [enemy HP <= 0] --> onEnemyDeath callback (loot, xp, gold) + | Hub.SendToHero("combat_end", {rewards}) + | resume movement + | + |-- [hero HP <= 0] --> Hub.SendToHero("hero_died", {killedBy}) + | stop movement, wait for revive +``` + +### 5.3 Client Reconnect + +``` +Client connects via WS + | + +--> Server loads hero from DB + +--> Server sends hero_state (full snapshot) + +--> Server sends route_assigned (current or new route) + +--> Server registers HeroMovement in engine + +--> If mid-combat: send combat_start to resume UI + +--> Normal 2Hz ticks begin +``` + +--- + +## 6. Risks and Mitigations + +| Risk | Impact | Mitigation | +|---|---|---| +| WS disconnect during combat | Hero stuck in "fighting" state | On disconnect: persist state. On reconnect: if combat stale (>60s), auto-resolve (hero takes proportional damage, combat ends). | +| High tick rate CPU load | Engine CPU spike with many heroes | Movement tick is O(n) over connected heroes only. 2 Hz * 100 heroes = 200 ops/s -- trivial. Monitor via engine status endpoint. | +| Client interpolation jitter | Visual glitches | Lerp with 500ms window. Snap on drift > 2 tiles. Frontend can smooth with exponential decay. | +| Backward compat during rollout | Old clients break | Phase 1 wraps existing events in envelopes. Old client sees `type` field on CombatEvent already. Add version handshake later if needed. | +| Offline simulator conflict | Offline sim moves hero, then WS reconnect loads stale position | Offline sim does NOT touch position/movement fields. It only simulates combat/rewards. Movement state is only live when hero is online. | + +--- + +## 7. Constants Reference + +```go +// Movement +BaseMoveSpeed = 2.0 // units/sec +MovementTickRate = 500ms // 2 Hz position updates +PositionSyncRate = 10s // drift correction +WaypointJitter = 2.0 // +/- tiles for road waypoints +WaypointSpacing = 20.0 // tiles between jitter points +TownRestMin = 5 * time.Second +TownRestMax = 10 * time.Second + +// Encounters +EncounterCooldown = 15s // min gap between fights +EncounterChancePerTick = 0.04 // per 500ms tick = ~4.8 per 60s of walking + +// WS +MaxMessageSize = 4096 // up from 512 +SendBufSize = 64 // unchanged +``` + +## 8. File Manifest + +New files to create: +- `backend/internal/game/movement.go` -- HeroMovement, movement tick, destination selection +- `backend/internal/game/road_graph.go` -- RoadGraph struct, DB loader, waypoint generation +- `backend/internal/handler/ws_envelope.go` -- WSEnvelope, ClientMessage types, dispatch +- `backend/migrations/000007_hero_movement_state.sql` +- `backend/migrations/000008_roads.sql` +- `frontend/src/game/ws-handler.ts` -- typed WS message handler + +Files to modify: +- `backend/internal/handler/ws.go` -- Hub/Client refactor to WSEnvelope, add SendToHero, incoming channel +- `backend/internal/game/engine.go` -- add movement map, multi-ticker Run loop, movement/sync ticks +- `backend/internal/model/combat.go` -- add StateResting, StateInTown +- `backend/internal/model/hero.go` -- add movement fields (CurrentTownID, etc.) +- `frontend/src/game/engine.ts` -- gut movement/combat logic, receive from WS only diff --git a/docs/specification-content-catalog.md b/docs/specification-content-catalog.md new file mode 100644 index 0000000..3b006cd --- /dev/null +++ b/docs/specification-content-catalog.md @@ -0,0 +1,306 @@ +# AutoHero Content Catalog (MVP Companion) + +Aligned with `specification.md` sections 2.3–2.4, 4, **5.3**, **6.3–6.4**, 8, 11, and 12. Section **0a**: `gear.form.*`; section **0d**: `gear.ammo.*` и слот `quiver`. **Item scaling** (`ilvl`, `M(rarity)`, `L(ilvl)`) — канон в `specification.md` §6.4. +Goal: provide engineering-ready IDs and mappings for models, sounds, and VFX intent. + +## 0) Equipment Slot Catalog (gear) + +Naming convention: +- `gear.slot.` — canonical slot keys (see `specification.md` §6.3) +- Item instances reference exactly one slot; item family IDs may use `item...v1` when introduced in implementation + +| slotId | displayName (EN) | notes | +|---|---|---| +| `gear.slot.main_hand` | Main hand | weapons | +| `gear.slot.off_hand` | Off hand | shield or off-hand weapon | +| `gear.slot.head` | Head | helmet, hood, hat | +| `gear.slot.chest` | Chest | body armor | +| `gear.slot.legs` | Legs | leggings, greaves | +| `gear.slot.feet` | Feet | boots | +| `gear.slot.cloak` | Cloak | cloak, cape, mantle | +| `gear.slot.neck` | Neck | amulet, medallion | +| `gear.slot.finger` | Finger | rings (implementation may use `finger_1` / `finger_2`) | +| `gear.slot.wrist` | Wrist | bracers, bracelets | +| `gear.slot.quiver` | Quiver | arrows/bolts; active only with bow or crossbow in `main_hand` (see §5.3) | + +### 0a) Equipment form catalog (виды / подтипы по слотам) + +Назначение: стабильные ключи **формы предмета** (визуальный и дизайн-архетип), привязанные к **ровно одному** `gear.slot.*`. +Используются в данных лута, UI-иконках, генерации имён и связке с `modelId` одежды. + +Naming convention: +- `gear.form..` — канонический ID вида; `` совпадает с суффиксом `gear.slot.` +- Предмет в инвентаре ссылается на `slotId` + опционально `formId` = `gear.form.*` +- Новые виды добавляются только сюда; произвольные строки в коде не вводить + +| formId | slotId | displayName (EN) | displayName (RU) | notes | +|---|---|---|---|---| +| `gear.form.main_hand.sword` | `gear.slot.main_hand` | Sword | Меч | baseline blade | +| `gear.form.main_hand.axe` | `gear.slot.main_hand` | Axe | Топор | heavy swing | +| `gear.form.main_hand.dagger` | `gear.slot.main_hand` | Dagger | Кинжал | fast, low base | +| `gear.form.main_hand.mace` | `gear.slot.main_hand` | Mace | Булава | blunt | +| `gear.form.main_hand.staff` | `gear.slot.main_hand` | Staff | Посох | two-handed caster vibe | +| `gear.form.main_hand.spear` | `gear.slot.main_hand` | Spear | Копьё | reach | +| `gear.form.main_hand.bow` | `gear.slot.main_hand` | Bow | Лук | ranged; pairs with `gear.slot.quiver` | +| `gear.form.main_hand.crossbow` | `gear.slot.main_hand` | Crossbow | Арбалет | ranged; pairs with `gear.slot.quiver` | +| `gear.form.off_hand.shield` | `gear.slot.off_hand` | Shield | Щит | block / defense | +| `gear.form.off_hand.buckler` | `gear.slot.off_hand` | Buckler | Баклер | small shield | +| `gear.form.off_hand.orb` | `gear.slot.off_hand` | Orb | Сфера | off-hand caster | +| `gear.form.head.helmet` | `gear.slot.head` | Helmet | Шлем | full head metal | +| `gear.form.head.hood` | `gear.slot.head` | Hood | Капюшон | cloth/leather | +| `gear.form.head.hat` | `gear.slot.head` | Hat | Шляпа | wide brim / travel | +| `gear.form.head.circlet` | `gear.slot.head` | Circlet | Диадема | light headband | +| `gear.form.head.mask` | `gear.slot.head` | Mask | Маска | face cover | +| `gear.form.head.coif` | `gear.slot.head` | Coif | Койф | mail under-helmet | +| `gear.form.chest.plate` | `gear.slot.chest` | Plate cuirass | Латы / кираса | heavy plate | +| `gear.form.chest.mail` | `gear.slot.chest` | Mail hauberk | Кольчуга | ring mail | +| `gear.form.chest.leather` | `gear.slot.chest` | Leather jack | Кожаный доспех | light | +| `gear.form.chest.robe` | `gear.slot.chest` | Robe | Роба | cloth / caster | +| `gear.form.chest.brigandine` | `gear.slot.chest` | Brigandine | Брига | riveted plates on cloth | +| `gear.form.legs.greaves` | `gear.slot.legs` | Greaves | Наколенники / латы ног | plate legs | +| `gear.form.legs.chausses` | `gear.slot.legs` | Chausses | Поножи (кольч.) | mail legs | +| `gear.form.legs.pants` | `gear.slot.legs` | Pants | Штаны | cloth/leather legs | +| `gear.form.legs.tassets` | `gear.slot.legs` | Tassets | Тассы | hanging plates | +| `gear.form.feet.boots` | `gear.slot.feet` | Boots | Сапоги | default footwear | +| `gear.form.feet.sabatons` | `gear.slot.feet` | Sabatons | Сабатоны | plate boots | +| `gear.form.feet.shoes` | `gear.slot.feet` | Shoes | Ботинки / туфли | light | +| `gear.form.feet.sandals` | `gear.slot.feet` | Sandals | Сандалии | open | +| `gear.form.cloak.cloak` | `gear.slot.cloak` | Cloak | Плащ | back slot mantle | +| `gear.form.cloak.cape` | `gear.slot.cloak` | Cape | Накидка | short back | +| `gear.form.cloak.mantle` | `gear.slot.cloak` | Mantle | Мантия | heavy drape | +| `gear.form.neck.amulet` | `gear.slot.neck` | Amulet | Амулет | default neck | +| `gear.form.neck.medallion` | `gear.slot.neck` | Medallion | Медальон | disk | +| `gear.form.neck.pendant` | `gear.slot.neck` | Pendant | Кулон | gem drop | +| `gear.form.neck.talisman` | `gear.slot.neck` | Talisman | Талисман | charm | +| `gear.form.finger.ring` | `gear.slot.finger` | Ring | Кольцо | default ring | +| `gear.form.finger.signet` | `gear.slot.finger` | Signet | Перстень | heavy ring | +| `gear.form.finger.band` | `gear.slot.finger` | Band | Обручь | slim band | +| `gear.form.wrist.bracers` | `gear.slot.wrist` | Bracers | Наручи | armor wrist | +| `gear.form.wrist.bracelet` | `gear.slot.wrist` | Bracelet | Браслет | jewelry | +| `gear.form.wrist.vambraces` | `gear.slot.wrist` | Vambraces | Рукава (латные) | plate forearm | + +### 0d) Ammunition catalog (боеприпасы, слот `gear.slot.quiver`) + +Naming convention: +- `gear.ammo..v1` — каноническое семейство боеприпасов +- Экземпляр несёт `ilvl`, `rarity`; **первичный** бонус к атаке: `primaryOut = round(basePrimary × L(ilvl) × M(rarity))` (§6.4.3) +- **Вторичные** поля (`baseCritBps`, `baseArmorPenBps`): `secondaryOut = round(base × M(rarity))` (§6.4.4). Базисные пункты (bps): `100 = 1.00%`. +- `deltaSpeed` — целое, добавляется к стату **Speed** героя с предмета **без** масштабирования по `ilvl` (только знак и величина из каталога; при необходимости позже — отдельный баланс-пас) + +| ammoId | basePrimary | baseCritBps | baseArmorPenBps | deltaSpeed | displayName (EN) | displayName (RU) | notes | +|---|---:|---:|---:|---:|---|---|---| +| `gear.ammo.crude_wood.v1` | 2 | 0 | 0 | 0 | Crude Wood Arrows | Грубые деревянные стрелы | стартовый/дешёвый дроп | +| `gear.ammo.hunting_standard.v1` | 3 | 15 | 0 | 0 | Standard Hunting Arrows | Охотничьи стрелы | лёгкий крит | +| `gear.ammo.flint_tipped.v1` | 4 | 35 | 0 | 0 | Flint-Tipped Arrows | Стрелы с кремнёвым наконечником | универсал | +| `gear.ammo.iron_bodkin.v1` | 5 | 0 | 80 | 0 | Iron Bodkin | Железные бодкины | упор в пробитие, без крита | +| `gear.ammo.steel_broadhead.v1` | 7 | 55 | 40 | -1 | Steel Broadheads | Стальные широкие наконечники | тяжелее, −1 Speed | +| `gear.ammo.silver_anointed.v1` | 6 | 25 | 100 | 0 | Silver-Anointed Bolts | Освящённые серебряные болты | тег `holy` для будущих модификаторов против нежити | +| `gear.ammo.glass_razor.v1` | 6 | 140 | 0 | -1 | Glass-Razor Quills | Стеклянные бритвенные оперения | высокий крит, хрупкий стиль | +| `gear.ammo.rune_fletched.v1` | 8 | 70 | 50 | 0 | Rune-Fletched Arrows | Стрелы с руническим оперением | маг. среда | +| `gear.ammo.manticore_barb.v1` | 10 | 90 | 70 | 0 | Manticore Barb Shafts | Шипы мантикоры | сильный mid/high family | +| `gear.ammo.starfall_sabot.v1` | 12 | 110 | 90 | 0 | Starfall Sabots | Сабо падающей звезды | top family base для лейт-дропа | + +**Баланс-якорь:** при `ilvl ≈ 25`, `Common`, семейство `steel_broadhead`: `primaryOut ≈ round(7 × 1.72 × 1.00) = 12` к Attack; при `Rare`, `ilvl ≈ 14`: `round(7 × 1.39 × 1.30) ≈ 13` — редкость компенсирует более низкий ilvl (см. §6.4.3). + +## 0b) World encounter & social content (map) + +Naming convention: +- `encounter.player_meet.v1` — abstract meeting of two heroes (payload names players, positions) +- `event.duel.offer.v1` — optional duel prompt UI contract +- `event.social.pass.v1` — talk/walk / emote-only resolution +- `event.quest.alms.v1` — NPC mini-quest: pay gold → random garment + +| contentKey | type | summary | +|---|---|---| +| `encounter.player_meet.v1` | encounter | Two heroes in proximity; server rolls outcome bucket (social vs duel prompt vs silent) | +| `event.social.pass.v1` | event | Emote / short line; no combat | +| `event.duel.offer.v1` | event | Show duel accept/decline; both must accept | +| `event.quest.alms.v1` | event | NPC asks for coins; success grants random `gear.slot.*` item | + +## 0c) Non-hostile NPC catalog (minimal) + +Naming convention: +- `npc...v1` +- `modelId` follows `monster.*` style but for neutral: `npc.model..v1` (neutral rigs) + +| npcId | displayName | role | modelId | defaultInteraction | +|---|---|---|---|---| +| `npc.traveler.worn_merchant.v1` | Worn Merchant | quest_giver | `npc.model.worn_merchant.v1` | `event.quest.alms.v1` | +| `npc.hermit.ash_sage.v1` | Ash Sage | flavor_talk | `npc.model.ash_sage.v1` | `event.social.pass.v1` | +| `npc.child.lost_acorn.v1` | Lost Acorn Kid | flavor_talk | `npc.model.lost_acorn.v1` | `event.social.pass.v1` | + +## 1) Monster Model Catalog + +Naming convention: +- `monster...v1` +- `levelBand` is inclusive and matches `specification.md` +- `levelBand` is also the anchor for enemy in-band scaling: scaling starts from `minLevel` of the band, not from a global all-level multiplier +- `visualStyleTags` are lightweight art-direction tags for batching/filtering + +| enemyId | displayName | class | levelBand | modelId | visualStyleTags | +|---|---|---|---|---|---| +| `enemy.wolf_forest` | Forest Wolf | base | `1-5` | `monster.base.wolf_forest.v1` | `beast,forest,fast,low-hp,gray-brown` | +| `enemy.boar_wild` | Wild Boar | base | `2-6` | `monster.base.boar_wild.v1` | `beast,forest,tanky,charge,earthy` | +| `enemy.zombie_rotting` | Rotting Zombie | base | `3-8` | `monster.base.zombie_rotting.v1` | `undead,decay,slow,poison,green-fog` | +| `enemy.spider_cave` | Cave Spider | base | `4-9` | `monster.base.spider_cave.v1` | `arachnid,cave,very-fast,crit,purple-dark` | +| `enemy.orc_warrior` | Orc Warrior | base | `5-12` | `monster.base.orc_warrior.v1` | `orc,midgame,armored,brutal,green-metal` | +| `enemy.skeleton_archer` | Skeleton Archer | base | `6-14` | `monster.base.skeleton_archer.v1` | `undead,ranged,bone,dodge,desaturated` | +| `enemy.lizard_battle` | Battle Lizard | base | `7-15` | `monster.base.lizard_battle.v1` | `reptile,defense,tank,scales,olive` | +| `enemy.demon_fire` | Fire Demon | elite | `10-20` | `monster.elite.demon_fire.v1` | `demon,fire,elite,burn,red-orange` | +| `enemy.guard_ice` | Ice Guard | elite | `12-22` | `monster.elite.guard_ice.v1` | `elemental,ice,elite,defense,frost-blue` | +| `enemy.skeleton_king` | Skeleton King | elite | `15-25` | `monster.elite.skeleton_king.v1` | `undead,bosslike,summoner,regeneration,gold-bone` | +| `enemy.element_water` | Water Element | elite | `18-28` | `monster.elite.element_water.v1` | `elemental,water,slow,aura,cyan` | +| `enemy.guard_forest` | Forest Guardian | elite | `20-30` | `monster.elite.guard_forest.v1` | `nature,guardian,very-tanky,regen,moss` | +| `enemy.titan_lightning` | Lightning Titan | elite | `25-35` | `monster.elite.titan_lightning.v1` | `titan,lightning,burst,stun,blue-yellow` | + +## 2) Object Model Catalog (Map Objects) + +Naming convention: +- `obj...v1` +- Keep collision simple in MVP: `road` non-blocking, all others blocking unless flagged + +| objectType | variantId | modelId | gameplayTag | notes | +|---|---|---|---|---| +| `road` | `dirt_straight` | `obj.road.dirt_straight.v1` | `path` | default biome path | +| `road` | `dirt_curve` | `obj.road.dirt_curve.v1` | `path` | curve segment | +| `road` | `stone_straight` | `obj.road.stone_straight.v1` | `path` | higher tier area visual | +| `road` | `stone_intersection` | `obj.road.stone_intersection.v1` | `path` | junction tile | +| `tree` | `pine_small` | `obj.tree.pine_small.v1` | `nature_blocker` | forest filler | +| `tree` | `pine_tall` | `obj.tree.pine_tall.v1` | `nature_blocker` | silhouette depth | +| `tree` | `dead_tree` | `obj.tree.dead_tree.v1` | `nature_blocker` | corrupted zone accent | +| `bush` | `bush_round` | `obj.bush.round.v1` | `nature_soft` | low silhouette | +| `bush` | `bush_berries` | `obj.bush.berries.v1` | `nature_soft` | color variation | +| `rock` | `rock_small` | `obj.rock.small.v1` | `stone_blocker` | edge clutter | +| `rock` | `rock_large` | `obj.rock.large.v1` | `stone_blocker` | hard blocker | +| `rock` | `rock_crystal` | `obj.rock.crystal.v1` | `stone_accent` | elite-zone hint | +| `prop` | `campfire_off` | `obj.prop.campfire_off.v1` | `poi` | non-interactive MVP | +| `prop` | `cart_broken` | `obj.prop.cart_broken.v1` | `poi` | roadside storytelling | +| `prop` | `sign_wood` | `obj.prop.sign_wood.v1` | `poi` | route marker | +| `prop` | `totem_bone` | `obj.prop.totem_bone.v1` | `poi_dark` | undead area marker | + +## 3) Sound Cue Catalog (Gameplay + UI) + +Naming convention: +- `sfx...v1` +- `ambient.*` loops; all others one-shots + +| soundCueId | category | trigger | defaultMixNotes | +|---|---|---|---| +| `sfx.combat.hit.v1` | combat | normal successful hit | short, dry, high frequency | +| `sfx.combat.crit.v1` | combat | critical hit | layered transient + brighter tail | +| `sfx.combat.death_enemy.v1` | combat | enemy dies | medium tail, low-mid body | +| `sfx.loot.pickup.v1` | reward | loot granted/picked | fast sparkle, non-intrusive | +| `sfx.status.buff_activate.v1` | status | any buff applied | uplifting whoosh/chime | +| `sfx.status.debuff_apply.v1` | status | any debuff applied | dark stinger, short | +| `sfx.ambient.forest_loop.v1` | ambient | forest biome active | birds/wind, low distraction | +| `sfx.ui.click.v1` | ui | button tap/click | soft click, no low-end | +| `sfx.progress.level_up.v1` | progression | player level increases | celebratory stinger | +| `sfx.social.emote.v1` | social | player meet / NPC short interaction | light chirp, non-combat | +| `sfx.ui.duel_prompt.v1` | ui | duel offer shown | subtle tension, not alarm | + +## 4) Enemy/Object -> Sound + VFX Intent Mapping + +MVP guidance: +- Use generic combat cues first; add per-enemy overrides only for elites. +- VFX rarity colors should follow `specification.md` section 11. + +| sourceType | sourceId | onHitSoundCueId | onDeathSoundCueId | statusSoundCueId | vfxIntent | +|---|---|---|---|---|---| +| `enemy` | `enemy.wolf_forest` | `sfx.combat.hit.v1` | `sfx.combat.death_enemy.v1` | *(none)* | `quick claw slash, light dust` | +| `enemy` | `enemy.boar_wild` | `sfx.combat.hit.v1` | `sfx.combat.death_enemy.v1` | *(none)* | `heavy impact spark, dirt kick` | +| `enemy` | `enemy.zombie_rotting` | `sfx.combat.hit.v1` | `sfx.combat.death_enemy.v1` | `sfx.status.debuff_apply.v1` (Poison) | `green poison puff` | +| `enemy` | `enemy.spider_cave` | `sfx.combat.hit.v1` | `sfx.combat.death_enemy.v1` | *(none)* | `fast bite streak, dark venom speck` | +| `enemy` | `enemy.orc_warrior` | `sfx.combat.hit.v1` | `sfx.combat.death_enemy.v1` | *(none)* | `weapon arc trail, medium impact` | +| `enemy` | `enemy.skeleton_archer` | `sfx.combat.hit.v1` | `sfx.combat.death_enemy.v1` | *(none)* | `bone shard burst` | +| `enemy` | `enemy.lizard_battle` | `sfx.combat.hit.v1` | `sfx.combat.death_enemy.v1` | *(none)* | `scale spark, shield-like flicker` | +| `enemy` | `enemy.demon_fire` | `sfx.combat.hit.v1` | `sfx.combat.death_enemy.v1` | `sfx.status.debuff_apply.v1` (Burn) | `fire embers + orange burn overlay` | +| `enemy` | `enemy.guard_ice` | `sfx.combat.hit.v1` | `sfx.combat.death_enemy.v1` | `sfx.status.debuff_apply.v1` (Freeze/AS slow) | `frost shards + blue slow ring` | +| `enemy` | `enemy.skeleton_king` | `sfx.combat.crit.v1` | `sfx.combat.death_enemy.v1` | `sfx.status.buff_activate.v1` (self-heal/summon pulse) | `gold-purple necro pulse` | +| `enemy` | `enemy.element_water` | `sfx.combat.hit.v1` | `sfx.combat.death_enemy.v1` | `sfx.status.debuff_apply.v1` (Slow) | `water splash + cyan slow ripple` | +| `enemy` | `enemy.guard_forest` | `sfx.combat.hit.v1` | `sfx.combat.death_enemy.v1` | `sfx.status.buff_activate.v1` (regen tick) | `green regen aura + bark particles` | +| `enemy` | `enemy.titan_lightning` | `sfx.combat.crit.v1` | `sfx.combat.death_enemy.v1` | `sfx.status.debuff_apply.v1` (Stun) | `lightning arc + yellow stun stars` | +| `object` | `road:*` | *(none)* | *(none)* | *(none)* | `subtle dust under movement` | +| `object` | `tree:*` | *(none)* | *(none)* | *(none)* | `sway only; no combat VFX` | +| `object` | `bush:*` | *(none)* | *(none)* | *(none)* | `minor rustle if traversed nearby` | +| `object` | `rock:*` | *(none)* | *(none)* | *(none)* | `static; optional tiny pebbles` | +| `object` | `prop:campfire_off` | *(none)* | *(none)* | *(none)* | `optional smoke wisps` | + +## 5) JSON-Ready Schema Examples (Map Payload) + +### 5.1 Minimal Entity Schemas + +```json +{ + "enemy": { + "id": "spawn-000123", + "enemyId": "enemy.demon_fire", + "level": 14, + "modelId": "monster.elite.demon_fire.v1", + "soundCueId": "sfx.combat.hit.v1" + }, + "object": { + "id": "obj-00421", + "objectType": "tree", + "variantId": "pine_tall", + "modelId": "obj.tree.pine_tall.v1", + "soundCueId": null + } +} +``` + +### 5.2 Map Chunk Payload Example + +```json +{ + "chunkId": "forest_01_03", + "ambientSoundCueId": "sfx.ambient.forest_loop.v1", + "enemies": [ + { + "id": "e-1001", + "enemyId": "enemy.wolf_forest", + "level": 3, + "modelId": "monster.base.wolf_forest.v1", + "soundCueId": "sfx.combat.hit.v1" + }, + { + "id": "e-1002", + "enemyId": "enemy.demon_fire", + "level": 12, + "modelId": "monster.elite.demon_fire.v1", + "soundCueId": "sfx.combat.hit.v1" + } + ], + "objects": [ + { + "id": "o-2201", + "objectType": "road", + "variantId": "dirt_curve", + "modelId": "obj.road.dirt_curve.v1", + "soundCueId": null + }, + { + "id": "o-2202", + "objectType": "tree", + "variantId": "pine_small", + "modelId": "obj.tree.pine_small.v1", + "soundCueId": null + }, + { + "id": "o-2203", + "objectType": "prop", + "variantId": "totem_bone", + "modelId": "obj.prop.totem_bone.v1", + "soundCueId": null + } + ] +} +``` + +## MVP Defaults (Recommended) + +1. Use one shared hit/death sound for all base enemies; add unique status sounds for elites only. +2. Keep `soundCueId` optional per entity; use `ambientSoundCueId` at chunk/biome level. +3. Start with one model per enemy archetype (`.v1`), then skin variants later (`.v2`, `.v3`). +4. Map objects may remain non-interactive in early MVP; **NPCs and player-meet events** use `npc.*` / `event.*` keys from §0b–0c when wired. +5. Preserve stable IDs (`enemyId`, `modelId`, `soundCueId`, `gear.slot.*`, `gear.form.*`, `gear.ammo.*`, `npc.*`, `event.*`) as content-contract keys across backend/client. +6. Optional duel/social flow: prefer one generic UI sound for accept/decline (e.g. extend catalog with `sfx.ui.duel_prompt.v1` when implemented). diff --git a/docs/specification.md b/docs/specification.md new file mode 100644 index 0000000..1064c34 --- /dev/null +++ b/docs/specification.md @@ -0,0 +1,777 @@ +# AutoHero — Полная спецификация игры + +--- + +## 1. 🎮 Обзор игры + +### 1.1 Концепция + +AutoHero — это idle/incremental RPG с изометрическим видом и таймер-базированной боевой системой. + +### 1.2 Первый вход: имя героя + +При **первом** входе в игру (создание профиля героя) игрок обязан **ввести имя героя** — это отдельный шаг до полноценного геймплея на карте. + +**Назначение имени:** + +- Отображается **над моделью героя** (nameplate / табличка), читаемая на мобильном экране. +- Используется в **социальных взаимодействиях**: встречи с другими игроками (§2.3), приглашения на дуэль, отображение в UI рядом с портретом/иконкой, будущие списки друзей/гильдий — везде, где нужен человекочитаемый идентификатор вместо Telegram ID. + +**Правила имени:** + +- **Уникальность глобальная:** в рамках игры не может существовать двух героев с одинаковым именем (регистронезависимое сравнение: `Ser` и `ser` — конфликт; точная политика нормализации — на стороне сервера). +- Если выбранное имя **уже занято**, клиент получает **ошибку** (например, код `HERO_NAME_TAKEN` / сообщение для пользователя «Имя занято») и **не создаёт** героя до смены имени. +- Длина и допустимые символы (ориентир): **2–16** символов; буквы (латиница и/или кириллица по политике продукта), цифры; без пробелов в начале/конце; запрещены оскорбительные шаблоны (модерация — отдельная политика, в MVP достаточно длины + уникальности). +- После успешной регистрации имя **меняется только** через отдельную платную/редкую механику или саппорт — не часть базового MVP, если не указано иначе. + +**UX:** + +- Один экран: поле ввода, кнопка «Продолжить», подсказка про уникальность. +- При ошибке занятости — поле подсвечивается, текст ошибки краткий. + +--- + +## 2. 🌍 Мир игры + +### 2.1 Общее описание + +Игрок автоматически движется, встречает врагов, собирает лут и развивает персонажа. + +### 2.2 Поведение перемещения героя + +Герой не должен бесконечно идти по одной диагонали. В MVP используется **wander-поведение** с мягкими сменами направления и короткими паузами: + +- Длина одного отрезка движения: `2.5-5.5 сек` +- В начале нового отрезка герой меняет курс относительно текущего направления на `-35° ... +35°` +- Во время движения каждые `0.7-1.2 сек` добавляется мягкая корректировка курса на `-10° ... +10°` +- Скорость поворота ограничена `90°/сек`, чтобы движение выглядело как плавная дуга, а не как резкий рывок +- Множитель скорости ходьбы на отрезок: `0.90x-1.10x` от базовой +- После каждого отрезка есть `18%` шанс остановиться и "отдохнуть" на `1-3 сек` +- Если герой двигался без паузы более `25 сек`, следующая пауза становится обязательной +- Во время паузы герой не запрашивает новые энкаунтеры, но сохраняет текущее состояние/ориентацию + +**Коллизии и непроходимость:** герой **не может** перемещаться **сквозь** препятствия. К непроходимым относятся как минимум: + +- **деревья** и **кусты** (объекты природы на тайле); +- **камни** (включая крупные валуны); +- **постройки** (стены, дома, руины и прочие здания — см. §2.6); +- при необходимости — **вода** / обрывы по дизайну карты (если на карте есть непроходимые биомы). + +Поведение: траектория wander и любое автоматическое движение **обходит** препятствия (коррекция курса, локальный обход, упрощённый pathfinding — деталь реализации). Визуально герой не «режет» силуэты объектов и не проходит по их клеткам/полигонам коллизии. + +### 2.3 Карта и встречи с другими игроками (shared world) + +На общей карте герои разных игроков могут оказываться рядом (один шард/чанк/инстанс — деталь реализации). Это **не обязательно** приводит к бою. + +**Принципы:** + +- **По умолчанию — мирный контакт:** чаще всего герои **просто проходят мимо**, обмениваются коротким **эмоутом/репликой** (иконка + 1 строка текста по желанию) и продолжают wander. +- **Дуэль — опционально и по шансу:** при сближении двух чужих героев система может предложить **всплывающий выбор** «Дуэль?» с таймаутом. Игрок может **отказаться без штрафа**; при отказе или таймауте оба продолжают путь как в пункте выше. +- **Вероятности (ориентиры для баланса, не жёсткий MVP):** + - `p_social_only` — «поздороваться и разойтись» (talk / walk): **~55–75%** от срабатываний «встречи». + - `p_duel_prompt` — показать предложение дуэли: **~10–25%** (остальное до 100% — тихий проход без UI, если не хотим спамить). + - Из тех, кому показали дуэль, оба должны согласиться; иначе — отмена без последствий. +- **Дуэль не обязательна для прогрессии:** награды за дуэль — отдельный небольшой пул (честь/косметика/чуть золота), без блокировки основного PvE-loop. + +**Ограничения UX (mobile-first):** + +- Один экран, минимум текста: иконки «меч», «ладонь (отказ)», таймер **3–5 сек**. +- Нет обязательного чата; опционально пресеты фраз. + +### 2.4 Несраженческие события (дружелюбные NPC) + +Помимо врагов на карте могут встречаться **нейтральные NPC** (не враждебные). + +**Пример мини-квеста «alms» (подай монет):** + +- NPC появляется как отдельная сущность карты (см. каталог `npc.*`). +- Условие: отдать **N** золота (`N` масштабируется от уровня/биома или фиксировано для MVP). +- Награда: **случайный предмет экипировки** в одном из **гармент-слотов** (см. §6.3), редкость по общим правилам лута или смещённая таблица «quest reward». +- Ограничения: кулдаун между такими событиями на героя / глобальный лимит в день — чтобы не было эксплойта. + +Другие варианты non-combat (на будущее): короткий диалог-ветка, обмен ресурса, временный бафф от «благословения» NPC — в MVP достаточно одного шаблона выше. + +### 2.5 Города и населённые пункты на карте + +Мир содержит **несколько городов** разного **размера** и **планировки**. Они зафиксированы в данных карты (координаты, границы, входы). Город — это зона с **плотной застройкой**, **без спавна враждебных энкаунтеров** внутри (или с сильно сниженным шансом — по балансу), плюс визуальные маркеры на миникарте/краю экрана по желанию. + +**Распределение по карте (логические регионы):** + +| Ключ (для контента) | Название | Размер | Конфигурация / силуэт | Регион на карте | +|---------------------|----------|--------|------------------------|-----------------| +| `city.silver_rampart` | **Серебряный Вал** | Крупный (XL) | Кольцо стен + внутренний рынок и кварталы; 4 ворот | Центр — столица региона | +| `city.ashen_march` | **Пепельный Марш** | Средний (M) | Две параллельные улицы вдоль дороги; узкий «город-лента» | Восток — тракт у скал | +| `city.oak_haven` | **Ясеневая Гавань** | Средний (M) | Радиальная площадь + 3 «луча» улиц к причалам/полям | Север — лесная окраина | +| `city.stone_morrow` | **Каменное Утро** | Средний (M) | Сетка кварталов 3×4 с узкими переулками | Юго-запад — подножие холмов | +| `city.three_lanterns` | **Три Фонаря** | Малый (S) | Один двор + кольцо домов вокруг колодца | Запад — перекрёсток троп | +| `city.dry_ford` | **Сухой Брод** | Малый (S) | Дома вдоль брода; вытянутый вдоль реки | Юг — речная низина | +| `city.greymoor` | **Серомур** | Малый (S) | Полукруг домов у старой башни | Северо-восток — туманные низины | +| `city.watch_rest` | **Сторожевой Привал** | Крошечный (XS), форпост | Укреплённый донжон + 2–3 дома + палисад | Восточная граница карты — КПП | + +Города **не должны** перекрывать друг друга; между ними — дикие зоны (лес, дорога, поля). Размер влияет на число NPC, точек квестов и длину «городского» пути при проходе wander. + +### 2.6 Постройки и объекты окружения + +На карте (в городах и вне них) встречаются **различные постройки** и декоративно-геймплейные объекты: + +- **Жилые:** дом, хижина, длинный дом общины. +- **Хозяйственные:** мельница, амбар, кузница, стойка торговца. +- **Оборонительные:** стена, башня, ворота, баррикада, руины укрепления. +- **Религиозные / культурные:** часовня, святилище, памятник. +- **Инфраструктура:** мост, причал, колодец, дорожный указатель. +- **Временные / сюжетные:** лагерь, повозка, костёр (как точка интереса, не обязательно интерактив в MVP). + +У всех построек с **объёмом** на карте задаётся **коллизия** (см. непроходимость в §2.2): герой обходит контур. Мелкие декоративные объекты без коллизии — только по явному флагу в данных карты. + +### 2.7 Типы квестов + +Квесты группируются по **источнику** и **цели**. Ниже — каноническая типология для дизайна контента и API. + +**По источнику:** + +| Тип | Описание | Примеры | +|-----|----------|---------| +| **Сюжетный** | Привязан к фазе мира / одной цепочке; прогресс хранится сервером | Введение, открытие города | +| **Побочный** | Опционален, не блокирует основной прогресс | «Принеси 10 когтей» | +| **Ежедневный / еженедельный** | Обновляется по таймеру, награды в таблице ретенции (см. §10) | Убить N врагов | +| **Микро-квест NPC** | Короткое взаимодействие на карте (§2.4) | Alms: монеты → предмет | +| **Исследование** | Награда за посещение точки / города / первое открытие зоны | Первый визит в «Серебряный Вал» | +| **Социальный** | Связан с другими игроками | Условный «свидетель дуэли», обмен эмоутом (расширение) | + +**По цели (механика):** + +| Тип цели | Условие выполнения | +|----------|-------------------| +| **Убить** | Победить N врагов заданного типа / класса | +| **Собрать** | Накопить золото / дроп / валюту квеста | +| **Доставить** | Принести предмет или золото NPC | +| **Посетить** | Дойти до маркера / города / здания | +| **Выжить / удержать** | Пробежать маршрут без смерти / удержать HP выше порога до конца таймера | +| **Поговорить / взаимодействовать** | Завершить диалог или взаимодействие с объектом/NPC | + +**Правила наград:** + +- Квест не должен нарушать глобальное правило: **золото с убийств врагов** остаётся по §8; награда квеста — **дополнительный** слой (XP, предмет, косметика). +- Повторяемые квесты (ежедневные) имеют **сброс** и **лимит** попыток в день. + +--- + +## 3. ⚔️ Combat Balance + +### 3.1 Модель боя + +Система основана на временных интервалах (next_attack_at). + +### 3.2 Баланс коэффициентов + +- agility_coef = 0.03 +- MIN_ATTACK_INTERVAL = 250 ms +- целевой максимум: 4 атаки/сек + +### 3.3 Уточнения боевой модели + +- Бой остаётся **timer-based** через `next_attack_at`, а не через кадры или частоту рендера. +- HP героя **сохраняется между боями** и не восстанавливается автоматически после каждой победы. +- Допустимые источники восстановления HP: + - бафф **Исцеление** + - бафф **Воскрешение** + - механика revive + - явно описанная регенерация/лечение по механике врага, баффа или режима +- **Level Up не восстанавливает HP полностью автоматически**, если это не описано отдельной механикой. +- Смерть должна ощущаться как пауза/потеря темпа, но не как бесплатный сброс всех последствий боя. + +### 3.4 Рост героя по уровням + +После плейтестов выяснилось, что даже замедленная MVP-кривая (v2) всё ещё слишком быстро усиливает героя. **Версия v3** снова ужимает прогрессию примерно в **10 раз** относительно v2: пороги XP к следующему уровню умножены на `10`, награды за убийство — поделены на `10` (с минимумом `1`), а шаги роста статов при `LevelUp` сделаны в **10 раз реже** (кратности `30 / 40 / 50 / 60 / 100` вместо `3 / 4 / 5 / 6 / 10`, MaxHP — каждые `10` уровней вместо каждого уровня). + +| Параметр | v2 | v3 | +|------|------|------| +| MaxHP | `+1 + floor(Constitution / 6)` каждый уровень | то же правило, но только на уровнях, кратных `10` | +| Attack / Defense | `+1` на уровнях, кратных `3` | `+1` каждый на уровнях, кратных `30` | +| Base Speed за уровень | `+0.0` | `+0.0` | + +Новые derived-формулы героя: + +- `EffectiveAttack = Attack + Strength * 2 + floor(Agility / 4)` +- `EffectiveDefense = Defense + Constitution + floor(Agility / 4)` +- `EffectiveSpeed = Speed + Agility * 0.03` + +Правила роста вторичных статов при `LevelUp` (v3): + +- `Strength +1` только на уровнях, кратных `40` +- `Constitution +1` только на уровнях, кратных `50` +- `Agility +1` только на уровнях, кратных `60` +- `Luck +1` только на уровнях, кратных `100` +- `HP` при повышении уровня **не восстанавливается автоматически**; увеличивается только `MaxHP` +- Стартовые статы героя **не меняются**: `HP=100`, `MaxHP=100`, `Attack=10`, `Defense=5`, `Speed=1.0`, `Strength=1`, `Constitution=1`, `Agility=1`, `Luck=1` + +Причина: рост силы теперь идёт не через частые level-up бонусы, а через более редкие вторичные статы, экипировку и длинную кривую прогрессии. Это убирает резкий разгон героя без искусственного ослабления стартового опыта. + +Контрольная таблица роста героя **без экипировки и без временных баффов** (v3, канон — `hero.go` и тест `TestProgressionV3CanonicalSnapshots`): + +| Уровень | MaxHP | Attack | Defense | Strength | Constitution | Agility | Luck | AttackPower | DefensePower | AttackSpeed | +|------|------|------|------|------|------|------|------|------|------|------| +| 1 | `100` | `10` | `5` | `1` | `1` | `1` | `1` | `12` | `6` | `1.03` | +| 5 | `100` | `10` | `5` | `1` | `1` | `1` | `1` | `12` | `6` | `1.03` | +| 10 | `101` | `10` | `5` | `1` | `1` | `1` | `1` | `12` | `6` | `1.03` | +| 20 | `102` | `10` | `5` | `1` | `1` | `1` | `1` | `12` | `6` | `1.03` | +| 30 | `103` | `11` | `6` | `1` | `1` | `1` | `1` | `13` | `7` | `1.03` | +| 45 | `104` | `11` | `6` | `2` | `1` | `1` | `1` | `15` | `7` | `1.03` | + +### 3.5 Целевые боевые показатели героя + +Ориентиры для инженеров и QA при проверке новой кривой силы героя **без временных баффов**: + +| Уровень | MaxHP | AttackPower | DefensePower | AttackSpeed | +|------|------|------|------|------| +| 10 | `100-105` | `12-16` | `6-9` | `1.03-1.10 APS` | +| 25 | `101-108` | `12-18` | `6-12` | `1.03-1.15 APS` | +| 45 | `103-120` | `14-28` | `7-18` | `1.03-1.30 APS` | + +Герой `L45` без временных баффов и без сильной экипировки остаётся относительно плоским по числам; основной рост mid/late-game должен ощущаться через экипировку, баффы и редкие уровни. + +--- + +## 4. 🧟 Враги (Enemy Design) + +### 4.1 Базовые враги (7 типов) + +#### 🐺 Лесной волк (Уровни 1-5) +- Быстрый, низкий HP, часто атакует +- Крит шанс: 5% + +#### 🐗 Дикий кабан (Уровни 2-6) +- Средний HP, высокий урон, редкие атаки +- Крит шанс: 8% + +#### 🧟 Гниющий зомби (Уровни 3-8) +- Медленный, много HP, слабый урон +- Способность: 10% шанс apply Poison + +#### 🕷 Пещерный паук (Уровни 4-9) +- Очень быстрый, может критовать +- Крит шанс: 15% + +#### 👹 Орк-воин (Уровни 5-12) +- Сбалансированный враг мид-гейма +- Способность: раз в 3 атаки = 1.5x урона + +#### 💀 Скелетный лучник (Уровни 6-14) +- Средние статы +- Способность: 20% dodge входящего урона + +#### 🐢 Боевая ящерица (Уровни 7-15) +- Много HP, высокая защита +- Способность: восстанавливает 2% от полученного урона + +### 4.2 Элитные враги (6 типов) + +#### 🔥 Огненный демон (Уровни 10-20) +- Высокий урон +- Способность: 30% шанс apply Burn + +#### ❄️ Ледяной страж (Уровни 12-22) +- Высокая защита +- Способность: -20% скорость атаки игрока + +#### 💀 Король Скелетов (Уровни 15-25) +- Восстанавливает 10% HP +- Создаёт скелетных слуг раз в 15 сек + +#### 🌊 Водяной элемент (Уровни 18-28) +- Много HP +- Способность: apply Slow (-40% Movement) + +#### 🌳 Лесной страж (Уровни 20-30) +- ОЧЕНЬ МНОГО HP, ОЧЕНЬ ВЫСОКАЯ защита +- Регенерирует 5% HP/сек + +#### ⚡ Молниевой титан (Уровни 25-35) +- ОЧЕНЬ ВЫСОКИЙ урон, ОЧЕНЬ быстрый +- Способность: 25% шанс Stun +- Цепная молния: после 5 атак = 3x урон + +### 4.3 Масштабирование врагов + +Старый множитель `1 + (heroLevel - 1) * 0.08` растит врагов слишком резко на длинной дистанции и конфликтует с ростом героя. В новой версии враги масштабируются **от своей level band**, а не от глобального уровня героя: + +- `bandLevel = clamp(heroLevel, enemy.minLevel, enemy.maxLevel)` +- `bandDelta = bandLevel - enemy.minLevel` +- `overcapDelta = max(0, heroLevel - enemy.maxLevel)` +- `hpMultiplier = 1 + bandDelta * 0.05 + overcapDelta * 0.025` +- `attackMultiplier = 1 + bandDelta * 0.035 + overcapDelta * 0.018` +- `defenseMultiplier = 1 + bandDelta * 0.035 + overcapDelta * 0.018` +- `speedMultiplier = 1.0` (скорость атаки задаётся архетипом, а не разгоняется по уровню) + +Это даёт: + +- Более мягкий рост внутри зоны врага +- Сильную разницу между архетипами за счёт базовых шаблонов +- Контролируемый бесконечный рост после выхода героя за верхний `levelBand` + +Примеры: + +| Враг | Уровень героя | HP Mult | ATK/DEF Mult | +|------|------|------|------| +| Forest Wolf | `1` | `1.00` | `1.00` | +| Forest Wolf | `5` | `1.20` | `1.14` | +| Lightning Titan | `35` | `1.50` | `1.35` | +| Lightning Titan | `45` | `1.75` | `1.53` | + +### 4.4 Базовые награды врагов + +**v3:** к шаблонам v2 применено ещё одно десятикратное сжатие базовых наград (целочисленно, с минимумом `1` для золота и XP). Реализация — `EnemyTemplates` в `enemy.go`. + +| Enemy ID | Базовый XP | Базовое золото | +|------|------|------| +| `enemy.wolf_forest` | `1` | `1` | +| `enemy.boar_wild` | `1` | `1` | +| `enemy.zombie_rotting` | `1` | `1` | +| `enemy.spider_cave` | `1` | `1` | +| `enemy.orc_warrior` | `1` | `1` | +| `enemy.skeleton_archer` | `1` | `1` | +| `enemy.lizard_battle` | `1` | `1` | +| `enemy.demon_fire` | `1` | `1` | +| `enemy.guard_ice` | `1` | `1` | +| `enemy.skeleton_king` | `1` | `1` | +| `enemy.element_water` | `2` | `1` | +| `enemy.guard_forest` | `2` | `1` | +| `enemy.titan_lightning` | `3` | `2` | + +Формулы наград при спавне: + +- `xpReward = round(baseXP * (1 + bandDelta * 0.05 + overcapDelta * 0.03))` +- `goldReward = round(baseGold * (1 + bandDelta * 0.05 + overcapDelta * 0.025))` + +Золото масштабируется мягче, чем XP, потому что при замедлении левелинга игрок должен продолжать ощущать прогресс через экипировку и экономику. + +--- + +## 5. 🗡 Оружие + +### 5.1 Типы оружия + +#### Кинжалы +- Скорость: 1.3x базовая +- Урон: 0.7x базовый + +#### Мечи +- Скорость: 1.0x (базовая) +- Урон: 1.0x (базовый) + +#### Топоры +- Скорость: 0.7x +- Урон: 1.5x (ВЫСОКИЙ) + +#### Луки (дальний бой, требуют слот `quiver`, см. §5.3) +- Скорость: 0.85x базовой частоты атак (чуть быстрее топора, медленнее меча) +- Урон: 1.0x базового **до** бонуса боеприпасов; итоговый урон складывается из оружия и аммуниции + +#### Арбалеты (дальний бой, требуют слот `quiver`) +- Скорость: 0.55x +- Урон: 1.35x (сильнее лука за счёт темпа) + +### 5.2 Примеры оружия (15 штук) + +#### Кинжалы: +- Rusty Dagger (Common) +- Iron Dagger (Uncommon) +- Assassin's Blade (Rare) +- Phantom Edge (Epic) +- Fang of the Void (Legendary) + +#### Мечи: +- Iron Sword (Common) +- Steel Sword (Uncommon) +- Longsword (Rare) +- Excalibur (Epic) +- Soul Reaver (Legendary) + +#### Топоры: +- Rusty Axe (Common) +- Battle Axe (Uncommon) +- War Axe (Rare) +- Infernal Axe (Epic) +- Godslayer's Edge (Legendary) + +### 5.3 Боеприпасы (аммуниция) и слот колчана + +**Слот:** `quiver` (см. §6.3 и каталог `gear.slot.quiver`, `gear.ammo.*`). +**Условие:** бонусы из колчана применяются **только** если в `main_hand` экипирован лук или арбалет (`gear.form.main_hand.bow` / `gear.form.main_hand.crossbow`). Иначе слот игнорируется в расчёте боя (предмет может храниться, но не даёт статов). + +**Роль в бою:** каждый тип боеприпасов задаёт **базовые коэффициенты** в каталоге; у конкретного экземпляра числа получаются по **§6.4** (уровень предмета `ilvl` и редкость). +**Вклад в героя:** рассчитанный `bonusAttack` аммуниции суммируется с **Attack** (как плоский бонус к цепочке `EffectiveAttack` после базы героя и остальной экипировки — порядок суммирования на стороне сервера фиксируется в коде, но обязан быть детерминированным). + +**Вторичные поля** (крит, пробитие, штраф к скорости): для боеприпасов используется **упрощённое** масштабирование только по редкости — **§6.4.4**; иначе высокий `ilvl` раздувал бы утилити без контроля. + +**Баланс:** сильные семейства боеприпасов имеют больший `basePrimary`, но могут иметь штрафы (`deltaSpeed`, низкий потолок крита и т.д.) — см. каталог. + +--- + +## 6. 🛡 Броня + +### 6.1 Типы брони + +- Лёгкая: 0.8x Defense, +Agility/Speed +- Средняя: 1.0x Defense, +Constitution/Luck +- Тяжёлая: 1.5x Defense, +Constitution/Strength, -30% Speed + +### 6.2 Комплекты брони (4 комплекта) + +- Assassin's Set +- Knight's Set +- Berserker's Set +- Ancient Guardian's Set + +### 6.3 Расширенные категории гардероба и экипировки (слоты) + +Помимо базовой пары «оружие + броня» (см. §5 и §6.1), целевая модель включает **дополнительные слоты предметов** — для разнообразия билдов и наград (в т.ч. с NPC-квестов и дуэлей). + +**Канонические слоты (ключи для каталога `gear.slot.*`):** + +| Слот (ключ) | Описание | +|-------------|----------| +| `main_hand` | Основное оружие (как сейчас) | +| `off_hand` | Вторая рука: щит **или** лёгкое off-hand (деталь баланса отдельно) | +| `head` | Шлем / шапка / капюшон | +| `chest` | Нагрудник (тяжёлая «броня» из §6.1 маппится сюда) | +| `legs` | Поножи / штаны | +| `feet` | Сапоги / ботинки | +| `cloak` | Плащ / накидка (часто даёт малый утилити-стат или чисто визуал в косметике) | +| `neck` | Амулет | +| `finger` | Кольцо (возможны **2** слота `finger_1`, `finger_2` в реализации; в каталоге — одно семейство `gear.slot.finger`) | +| `wrist` | Браслеты (опционально) | +| `quiver` | Боеприпасы (стрелы / болты); дают бонус к дальнему бою при луке или арбалете (§5.3) | + +**Правила:** + +- Каждый предмет принадлежит **ровно одному** слоту; нет «универсальных» без явного правила в каталоге. +- Щит в `off_hand` даёт защиту и может иметь штраф к скорости атаки по архетипу (как в классических RPG); детальные множители — в балансе предметов, не в этом разделе. +- Реализация может вводить слоты поэтапно: сначала `head` / `feet` / `neck`, затем остальные — но **ID слотов в каталоге** фиксируются заранее. + +### 6.4 Уровень предмета (`ilvl`) и масштабирование от уровня и редкости + +Каждый выпавший предмет (включая боеприпасы) имеет: + +- **`ilvl`** — целое **≥ 1** (уровень предмета; не путать с уровнем героя). +- **`rarity`** — одна из глобальных редкостей (`Common` … `Legendary`, как в §8.1–8.2). +- **`familyId`** — ссылка на строку каталога (`gear.ammo.*`, форма `gear.form.*`, в будущем — семейства оружия/брони), откуда берутся **базовые** числа. + +#### 6.4.1 Фактор уровня предмета + +Коэффициент (плавный рост от `ilvl`, без ступеней): + +- `α = 0.03` +- `L(ilvl) = 1 + α × max(0, ilvl − 1)` + +Примеры: `L(1) = 1.00`; `L(10) = 1.27`; `L(25) = 1.72`; `L(50) = 2.47`. + +#### 6.4.2 Множитель редкости + +Одинаков для всех типов предметов, для воспроизводимости: + +| Редкость | `M(rarity)` | +|----------|----------------| +| Common | `1.00` | +| Uncommon | `1.12` | +| Rare | `1.30` | +| Epic | `1.52` | +| Legendary | `1.78` | + +#### 6.4.3 Первичные статы предмета (урон / защита от предмета) + +Для величин, которые напрямую входят в `EffectiveAttack` / `EffectiveDefense` как **плоские бонусы** от экипировки (в т.ч. `bonusAttack` боеприпасов, бонус Defense с нагрудника и т.д.): + +``` +primaryOut = round( basePrimary × L(ilvl) × M(rarity) ) +``` + +`basePrimary` — целое из каталога для семейства предмета на «эталоне» `ilvl = 1`, `Common`. + +**Свойство баланса:** при тех же `basePrimary` возможны ситуации, когда **редкий предмет с меньшим `ilvl` даёт больше или столько же**, чем **обычный с большим `ilvl`**, потому что `M(rarity)` растёт быстрее, чем `L(ilvl)` в типичных диапазонах дропа. Примеры (без привязки к слоту, `basePrimary = 10`): + +| Конфигурация | Вычисление | `primaryOut` | +|--------------|------------|----------------| +| Common, ilvl 25 | `round(10 × 1.72 × 1.00)` | `17` | +| Rare, ilvl 13 | `round(10 × 1.36 × 1.30)` | `18` | +| Epic, ilvl 7 | `round(10 × 1.18 × 1.52)` | `18` | + +То есть **Rare ниже по ilvl** и **Epic ещё ниже по ilvl** могут превосходить **Common высокого ilvl** — это намеренно. + +#### 6.4.4 Вторичные статы (крит, пробитие, малые штрафы скорости у аммуниции) + +Чтобы утилити не разгонялась бесконечно с `ilvl`, для **вторичных** величин в MVP используется: + +``` +secondaryOut = round( baseSecondary × M(rarity) ) +``` + +`baseSecondary` — из каталога (например крит в базисных пунктах: `100 = 1.00%`). Рост только от редкости; при необходимости позже вводится мягкий множитель от `ilvl` отдельным баланс-пасом. + +#### 6.4.5 Связь `ilvl` с уровнем источника дропа + +Базовое правило для дропа с убитого врага уровня `monsterLevel` (уровень экземпляра в бою): + +1. Сэмплируется смещение `δ` ∈ `{ −1, 0, +1 }` с **равными** вероятностями `1/3` каждое. +2. `ilvl = clamp( monsterLevel + δ, 1, ilvlMax )`, где **`ilvlMax = 100`** (резерв под эндгейм). + +**Elite-враги** (класс elite в каталоге): вместо шага 1 используется `δ` ∈ `{ 0, +1, +2 }` с весами **`0.4 / 0.4 / 0.2`** — смещение в сторону более высокого уровня предмета. + +**Правило согласованности:** типичный дроп с врага уровня `N` имеет `ilvl` около `N`, реже на `1` ниже или выше; сильные враги не обязаны давать предмет выше своего уровня без elite-бонуса, чтобы не ломать ранний прогресс. + +#### 6.4.6 Ничьи при сравнении экипировки + +Если после §6.4 два предмета в одном слоте дают одинаковый вклад в `combatRating` (§8.5), **предпочтение отдаётся более высокой редкости**; если и редкость совпала — большему `ilvl`. + +--- + +## 7. ✨ Баффы и Дебаффы + +### 7.1 Баффы (8 штук) + +| Бафф | Эффект | +|------|--------| +| Рывок | +50% движение | +| Ярость | +100% урон | +| Щит | -50% входящий урон | +| Удача | x2.5 лут | +| Воскрешение | Воскрес 50% HP | +| Исцеление | +50% HP | +| Зелье силы | +150% урон | +| Боевой клич | +100% Attack speed | + +### 7.2 Дебаффы (6 штук) + +| Дебафф | Эффект | +|--------|--------| +| Отравление | -2% HP/сек | +| Заморозка | -50% Attack speed | +| Горение | -3% HP/сек | +| Оглушение | Нет атак (2 сек) | +| Замедление | -40% Movement | +| Ослабление | -30% входящий урон | + +--- + +## 8. 💰 Система лута и золота + +### 8.1 Дроп система + +- Шанс, что враг вообще дропнет предмет экипировки: `22%` +- Если предмет выпал, его редкость распределяется так: + - Common: `75%` + - Uncommon: `20%` + - Rare: `4%` + - Epic: `0.9%` + - Legendary: `0.1%` +- Каждый побеждённый враг **всегда** даёт золото. +- Золото — это **гарантированная базовая награда** за убийство, чтобы каждая победа ощущалась как прогресс. +- Предметы экипировки — это **дополнительный необязательный дроп**, а не замена золоту. +- Отсутствие предмета после убийства — это нормальное поведение; отсутствие золота — нет. + +### 8.2 Таблица редкости предмета + +| Редкость | Шанс внутри выпавшего предмета | Золото | +|----------|---|---| +| Common | 75% | 5-15 | +| Uncommon | 20% | 20-50 | +| Rare | 4% | 50-150 | +| Epic | 0.9% | 200-500 | +| Legendary | 0.1% | 1000-5000 | + +### 8.3 Правила наград + +- Награда за бой состоит из: + - гарантированного золота + - возможного предмета (оружие, броня нагрудника или — после внедрения §6.3 — предмет в любом доступном слоте) +- Если предмет выпал, он должен использовать ту же систему редкости (`Common` ... `Legendary`). +- Бафф **Удача** усиливает лут, но не отменяет правило гарантированного золота. +- В MVP допустим простой формат награды, но логика должна быть прозрачной: `gold always, item sometimes`. +- Уровень выпавшего предмета (`ilvl`) и масштабирование статов — **§6.4**; связь `ilvl` с уровнем убитого врага — **§6.4.5**. + +### 8.4 MVP Inventory / Equipment HUD + +Для MVP нет полноценного инвентаря-рюкзака. Игрок хранит только то, что влияет на бой прямо сейчас: + +- `equippedWeapon` (слот `main_hand`; при появлении off-hand — `off_hand`) +- `equippedArmor` (слот `chest`, пока не разделён UI) +- `equippedQuiver` или аналог (слот `quiver`) — когда включён дальний бой и колчан в дропе +- `gold` +- По мере внедрения §6.3 — дополнительные `equipped*` по слотам из каталога + +Правила: + +- На каждый слот из §6.3 — не более **одного** экипированного предмета (кольца: до **двух**, если включены оба слота пальцев). +- Предметы не складываются в bag/stash +- Все выпавшие предметы обрабатываются сразу после боя +- UI обязан постоянно показывать: + - золото + - текущее оружие: иконка, имя, редкость + - текущую броню: иконка, имя, редкость + - по мере расширения слотов — компактная полоса иконок по активным слотам или свёрнутая панель «gear» + - краткий toast о последнем дропе/автоэкипировке/автопродаже + +### 8.5 Правила автоэкипировки и автопродажи + +Чтобы MVP оставался простым, предмет не требует ручного менеджмента: + +- Если слот пустой, предмет сразу экипируется +- Если слот занят, игра считает `combatRating` +- `combatRating = EffectiveAttack * EffectiveSpeed + EffectiveDefense * 0.35` +- Для сравнения подставляется герой с новым предметом того же слота и герой с текущим предметом +- Если новый предмет даёт `>= 3%` улучшения `combatRating`, он автоматически экипируется +- Иначе предмет автоматически продаётся + +Фиксированные цены автопродажи по редкости: + +| Редкость | Auto-sell Gold | +|------|------| +| Common | `3` | +| Uncommon | `8` | +| Rare | `20` | +| Epic | `60` | +| Legendary | `180` | + +Эта схема даёт игроку прозрачный MVP loop: золото приходит всегда, хороший предмет сразу усиливает героя, плохой предмет всё равно конвертируется в ощутимую награду. + +### 8.6 Кратко: уровень предмета при дропе + +Полные формулы — **§6.4** и **§6.4.5**. Для дизайна контента: + +- Чем выше **уровень поверженного врага**, тем выше типичный **`ilvl`** выпавшего предмета (с джиттером ±1, у elite — сдвиг вверх). +- Редкость по-прежнему крутится по таблице §8.1 внутри события «предмет выпал»; затем к выбранному семейству применяется §6.4. +- Автоэкипировка (§8.5) сравнивает итогового героя с учётом **всех** активных слотов, включая `quiver`, если лук/арбалет экипирован. + +--- + +## 9. 📈 Система прогрессии + +### 9.1 Уровни персонажа + +Используется **piecewise XP curve** по фазам игры. **v3** умножает базовые коэффициенты v2 на `10` (темп до следующего уровня в тех же условиях боя — примерно в `10` раз медленнее). + +`XPToNextLevel(L)`: + +- Для `L = 1-9`: `round(180 * 1.28^(L-1))` +- Для `L = 10-29`: `round(1450 * 1.15^(L-10))` +- Для `L >= 30`: `round(23000 * 1.10^(L-30))` + +`TotalXPForLevel(1) = 0` + +`TotalXPForLevel(L) = sum(XPToNextLevel(n))`, где `n = 1 .. L-1` + +- Формула XP одинакова для online/offline прогрессии. +- Рост статов при повышении уровня должен использовать **один и тот же канонический путь** во всех режимах. +- Offline-прогрессия не должна использовать отдельные "упрощённые" правила роста статов, если они дают другой результат. + +Контрольные значения `XPToNextLevel`: + +| Текущий уровень | XP до следующего уровня | +|------|------| +| 1 | `180` | +| 5 | `483` | +| 10 | `1450` | +| 20 | `5866` | +| 30 | `23000` | +| 40 | `59656` | +| 45 | `96077` | +| 50 | `154732` | + +### 9.2 Игровые фазы + +| Фаза | Уровни | Время | +|------|--------|-------| +| Ранняя | 1-10 | 3-5 часов | +| Середина | 11-30 | 25-45 часов | +| Поздняя | 31-50 | 90-150 часов | +| Лейт/предэндгейм | 51-100 | 300+ часов | +| Эндгейм | 100+ | Бесконечная | + +### 9.3 Система Аскензии + +После L100: AP = (Max_Level - 50) / 10 + +--- + +## 10. 🏆 Meta-Game & Retention + +### 10.1 Дневные задачи + +- Kill 10 enemies +- Defeat an Elite +- Collect 500 Gold +- Use 3 Buffs +- Reach Level X + +### 10.2 Еженедельные вызовы + +- Reach Level 50 +- Defeat 5 Elites +- Collect 5000 Gold +- Die less than 5 times + +### 10.3 Достижения + +- Первая кровь +- Воин (L50) +- Легенда (L100) +- Охотник +- Богач +- Везунчик +- Неустрашимый + +--- + +## 11. 🎨 Визуальная система + +### 11.1 Система цветов + +| Редкость | Цвет | Эффект | +|----------|------|--------| +| Common | Серый | Обычный | +| Uncommon | Зелёный | Glow | +| Rare | Синий | Частицы | +| Epic | Фиолетовый | Яркие частицы | +| Legendary | Золотой | Золотой луч | + +--- + +## 12. 📱 UX принципы + +1. Один экран = вся игра +2. Минимум текста — максимум визуала +3. Всё через иконки и цвета +4. Игрок всегда в моменте +5. Нет загрузок — всё instant +6. Мобильная оптимизация +7. Кнопка паузы/play +8. UI должен честно показывать состояние героя: нельзя визуально скрывать потерю HP автоматическим лечением, если сервер/механика этого не дали +9. UI должен ясно показывать модель наград: золото за каждую победу, предметы только при фактическом дропе +10. **Имя героя** (§1.2) всегда видно над моделью в мире; в социальных контекстах — то же имя, без расхождения с сервером + +--- + +## 13. 📊 Баланс-принципы + +### 13.1 Цели дизайна + +- Ранняя (1-10): Щедрая прогрессия +- Середина (11-50): Сбалансированное развитие +- Поздняя (51+): Медленная прогрессия +- Эндгейм (100+): Аскензия, сезоны + +--- + +## 14. 🔮 Будущие расширения + +- Рейды +- Гильдии +- Питомцы +- Ремесло +- Полноценный PvP-рейтинг и арена (базовые **опциональные дуэли на карте** описаны в §2.3) +- Сезонные события +- Расширение полного комплекта слотов §6.3 с отдельным экраном «персонаж» + +--- + +**Конец спецификации** diff --git a/frontend/Dockerfile b/frontend/Dockerfile new file mode 100644 index 0000000..95d1aa0 --- /dev/null +++ b/frontend/Dockerfile @@ -0,0 +1,28 @@ +# Stage 1: Build +FROM node:20-alpine AS builder + +WORKDIR /app + +# Install dependencies first (layer caching) +COPY package.json ./ +RUN npm install + +# Copy source and build +COPY . . +RUN npm run build + +# Stage 2: Serve +FROM nginx:alpine + +# Remove default nginx config +RUN rm /etc/nginx/conf.d/default.conf + +# Copy custom nginx config +COPY nginx.conf /etc/nginx/conf.d/default.conf + +# Copy built assets from builder +COPY --from=builder /app/dist /usr/share/nginx/html + +EXPOSE 80 + +CMD ["nginx", "-g", "daemon off;"] diff --git a/frontend/index.html b/frontend/index.html new file mode 100644 index 0000000..0eb15f9 --- /dev/null +++ b/frontend/index.html @@ -0,0 +1,26 @@ + + + + + + + AutoHero + + + + +
+ + + diff --git a/frontend/nginx.conf b/frontend/nginx.conf new file mode 100644 index 0000000..41c1584 --- /dev/null +++ b/frontend/nginx.conf @@ -0,0 +1,110 @@ +# Local Docker usage should work over plain HTTP on the mapped port. +server { + listen 80; + listen [::]:80; + server_name _; + + root /usr/share/nginx/html; + index index.html; + + # Gzip compression + gzip on; + gzip_types text/plain text/css application/json application/javascript text/xml application/xml text/javascript image/svg+xml; + gzip_min_length 256; + + # SPA client-side routing: serve index.html for all non-file routes + location / { + try_files $uri $uri/ /index.html; + } + + # Proxy REST API to backend + location /api/ { + proxy_pass http://backend:8080; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + } + + # Proxy WebSocket to backend + location /ws { + proxy_pass http://backend:8080; + proxy_http_version 1.1; + proxy_set_header Upgrade $http_upgrade; + proxy_set_header Connection "upgrade"; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + proxy_read_timeout 86400; + } + + # Cache static assets aggressively + location /assets/ { + expires 1y; + add_header Cache-Control "public, immutable"; + } + + # Security headers + add_header Content-Security-Policy "frame-ancestors 'self' https://web.telegram.org https://*.telegram.org;" always; + add_header X-Content-Type-Options "nosniff" always; + add_header Referrer-Policy "strict-origin-when-cross-origin" always; +} + +server { + listen 443 ssl; + listen [::]:443 ssl; + server_name _; + + ssl_certificate /etc/nginx/ssl/fullchain.pem; + ssl_certificate_key /etc/nginx/ssl/privkey.pem; + ssl_protocols TLSv1.2 TLSv1.3; + ssl_ciphers HIGH:!aNULL:!MD5; + ssl_prefer_server_ciphers on; + + root /usr/share/nginx/html; + index index.html; + + # Gzip compression + gzip on; + gzip_types text/plain text/css application/json application/javascript text/xml application/xml text/javascript image/svg+xml; + gzip_min_length 256; + + # SPA client-side routing: serve index.html for all non-file routes + location / { + try_files $uri $uri/ /index.html; + } + + # Proxy REST API to backend + location /api/ { + proxy_pass http://backend:8080; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + } + + # Proxy WebSocket to backend + location /ws { + proxy_pass http://backend:8080; + proxy_http_version 1.1; + proxy_set_header Upgrade $http_upgrade; + proxy_set_header Connection "upgrade"; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + proxy_read_timeout 86400; + } + + # Cache static assets aggressively + location /assets/ { + expires 1y; + add_header Cache-Control "public, immutable"; + } + + # Security headers + add_header Content-Security-Policy "frame-ancestors 'self' https://web.telegram.org https://*.telegram.org;" always; + add_header X-Content-Type-Options "nosniff" always; + add_header Referrer-Policy "strict-origin-when-cross-origin" always; +} diff --git a/frontend/package-lock.json b/frontend/package-lock.json new file mode 100644 index 0000000..c169e41 --- /dev/null +++ b/frontend/package-lock.json @@ -0,0 +1,2989 @@ +{ + "name": "autohero-frontend", + "version": "0.1.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "autohero-frontend", + "version": "0.1.0", + "dependencies": { + "pixi.js": "^8.6.6", + "react": "^19.0.0", + "react-dom": "^19.0.0" + }, + "devDependencies": { + "@types/react": "^19.2.14", + "@types/react-dom": "^19.0.0", + "@vitejs/plugin-react": "^4.3.4", + "eslint": "^9.17.0", + "typescript": "~5.7.2", + "vite": "^6.2.0" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz", + "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-validator-identifier": "^7.28.5", + "js-tokens": "^4.0.0", + "picocolors": "^1.1.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/compat-data": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz", + "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/core": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz", + "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", + "@babel/helper-compilation-targets": "^7.28.6", + "@babel/helper-module-transforms": "^7.28.6", + "@babel/helpers": "^7.28.6", + "@babel/parser": "^7.29.0", + "@babel/template": "^7.28.6", + "@babel/traverse": "^7.29.0", + "@babel/types": "^7.29.0", + "@jridgewell/remapping": "^2.3.5", + "convert-source-map": "^2.0.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.3", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + } + }, + "node_modules/@babel/generator": { + "version": "7.29.1", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz", + "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.0", + "@babel/types": "^7.29.0", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", + "jsesc": "^3.0.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz", + "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.28.6", + "@babel/helper-validator-option": "^7.27.1", + "browserslist": "^4.24.0", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-globals": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz", + "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz", + "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.28.6", + "@babel/types": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz", + "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.28.6", + "@babel/helper-validator-identifier": "^7.28.5", + "@babel/traverse": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz", + "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", + "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz", + "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-option": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz", + "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.29.2", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.2.tgz", + "integrity": "sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.28.6", + "@babel/types": "^7.29.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.29.2", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.2.tgz", + "integrity": "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.0" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-self": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz", + "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-source": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz", + "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/template": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz", + "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.28.6", + "@babel/parser": "^7.28.6", + "@babel/types": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz", + "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", + "@babel/helper-globals": "^7.28.0", + "@babel/parser": "^7.29.0", + "@babel/template": "^7.28.6", + "@babel/types": "^7.29.0", + "debug": "^4.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz", + "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.28.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz", + "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz", + "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz", + "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz", + "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz", + "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz", + "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz", + "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz", + "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz", + "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz", + "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz", + "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz", + "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz", + "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz", + "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz", + "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz", + "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz", + "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz", + "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz", + "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz", + "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz", + "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz", + "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz", + "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz", + "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz", + "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz", + "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@eslint-community/eslint-utils": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz", + "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "eslint-visitor-keys": "^3.4.3" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" + } + }, + "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": { + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", + "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint-community/regexpp": { + "version": "4.12.2", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz", + "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + } + }, + "node_modules/@eslint/config-array": { + "version": "0.21.2", + "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.2.tgz", + "integrity": "sha512-nJl2KGTlrf9GjLimgIru+V/mzgSK0ABCDQRvxw5BjURL7WfH5uoWmizbH7QB6MmnMBd8cIC9uceWnezL1VZWWw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/object-schema": "^2.1.7", + "debug": "^4.3.1", + "minimatch": "^3.1.5" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/config-helpers": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz", + "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/core": "^0.17.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/core": { + "version": "0.17.0", + "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz", + "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@types/json-schema": "^7.0.15" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/eslintrc": { + "version": "3.3.5", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.5.tgz", + "integrity": "sha512-4IlJx0X0qftVsN5E+/vGujTRIFtwuLbNsVUe7TO6zYPDR1O6nFwvwhIKEKSrl6dZchmYBITazxKoUYOjdtjlRg==", + "dev": true, + "license": "MIT", + "dependencies": { + "ajv": "^6.14.0", + "debug": "^4.3.2", + "espree": "^10.0.1", + "globals": "^14.0.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.1.1", + "minimatch": "^3.1.5", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint/js": { + "version": "9.39.4", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.4.tgz", + "integrity": "sha512-nE7DEIchvtiFTwBw4Lfbu59PG+kCofhjsKaCWzxTpt4lfRjRMqG6uMBzKXuEcyXhOHoUp9riAm7/aWYGhXZ9cw==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://eslint.org/donate" + } + }, + "node_modules/@eslint/object-schema": { + "version": "2.1.7", + "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz", + "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/plugin-kit": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz", + "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/core": "^0.17.0", + "levn": "^0.4.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@humanfs/core": { + "version": "0.19.1", + "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz", + "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18.18.0" + } + }, + "node_modules/@humanfs/node": { + "version": "0.16.7", + "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz", + "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@humanfs/core": "^0.19.1", + "@humanwhocodes/retry": "^0.4.0" + }, + "engines": { + "node": ">=18.18.0" + } + }, + "node_modules/@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.22" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@humanwhocodes/retry": { + "version": "0.4.3", + "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz", + "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18.18" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/remapping": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", + "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@pixi/colord": { + "version": "2.9.6", + "resolved": "https://registry.npmjs.org/@pixi/colord/-/colord-2.9.6.tgz", + "integrity": "sha512-nezytU2pw587fQstUu1AsJZDVEynjskwOL+kibwcdxsMBFqPsFFNA7xl0ii/gXuDi6M0xj3mfRJj8pBSc2jCfA==", + "license": "MIT" + }, + "node_modules/@rolldown/pluginutils": { + "version": "1.0.0-beta.27", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz", + "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.0.tgz", + "integrity": "sha512-WOhNW9K8bR3kf4zLxbfg6Pxu2ybOUbB2AjMDHSQx86LIF4rH4Ft7vmMwNt0loO0eonglSNy4cpD3MKXXKQu0/A==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.0.tgz", + "integrity": "sha512-u6JHLll5QKRvjciE78bQXDmqRqNs5M/3GVqZeMwvmjaNODJih/WIrJlFVEihvV0MiYFmd+ZyPr9wxOVbPAG2Iw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.0.tgz", + "integrity": "sha512-qEF7CsKKzSRc20Ciu2Zw1wRrBz4g56F7r/vRwY430UPp/nt1x21Q/fpJ9N5l47WWvJlkNCPJz3QRVw008fi7yA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.0.tgz", + "integrity": "sha512-WADYozJ4QCnXCH4wPB+3FuGmDPoFseVCUrANmA5LWwGmC6FL14BWC7pcq+FstOZv3baGX65tZ378uT6WG8ynTw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.0.tgz", + "integrity": "sha512-6b8wGHJlDrGeSE3aH5mGNHBjA0TTkxdoNHik5EkvPHCt351XnigA4pS7Wsj/Eo9Y8RBU6f35cjN9SYmCFBtzxw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.0.tgz", + "integrity": "sha512-h25Ga0t4jaylMB8M/JKAyrvvfxGRjnPQIR8lnCayyzEjEOx2EJIlIiMbhpWxDRKGKF8jbNH01NnN663dH638mA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.0.tgz", + "integrity": "sha512-RzeBwv0B3qtVBWtcuABtSuCzToo2IEAIQrcyB/b2zMvBWVbjo8bZDjACUpnaafaxhTw2W+imQbP2BD1usasK4g==", + "cpu": [ + "arm" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.0.tgz", + "integrity": "sha512-Sf7zusNI2CIU1HLzuu9Tc5YGAHEZs5Lu7N1ssJG4Tkw6e0MEsN7NdjUDDfGNHy2IU+ENyWT+L2obgWiguWibWQ==", + "cpu": [ + "arm" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.0.tgz", + "integrity": "sha512-DX2x7CMcrJzsE91q7/O02IJQ5/aLkVtYFryqCjduJhUfGKG6yJV8hxaw8pZa93lLEpPTP/ohdN4wFz7yp/ry9A==", + "cpu": [ + "arm64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.0.tgz", + "integrity": "sha512-09EL+yFVbJZlhcQfShpswwRZ0Rg+z/CsSELFCnPt3iK+iqwGsI4zht3secj5vLEs957QvFFXnzAT0FFPIxSrkQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.0.tgz", + "integrity": "sha512-i9IcCMPr3EXm8EQg5jnja0Zyc1iFxJjZWlb4wr7U2Wx/GrddOuEafxRdMPRYVaXjgbhvqalp6np07hN1w9kAKw==", + "cpu": [ + "loong64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.0.tgz", + "integrity": "sha512-DGzdJK9kyJ+B78MCkWeGnpXJ91tK/iKA6HwHxF4TAlPIY7GXEvMe8hBFRgdrR9Ly4qebR/7gfUs9y2IoaVEyog==", + "cpu": [ + "loong64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.0.tgz", + "integrity": "sha512-RwpnLsqC8qbS8z1H1AxBA1H6qknR4YpPR9w2XX0vo2Sz10miu57PkNcnHVaZkbqyw/kUWfKMI73jhmfi9BRMUQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.0.tgz", + "integrity": "sha512-Z8pPf54Ly3aqtdWC3G4rFigZgNvd+qJlOE52fmko3KST9SoGfAdSRCwyoyG05q1HrrAblLbk1/PSIV+80/pxLg==", + "cpu": [ + "ppc64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.0.tgz", + "integrity": "sha512-3a3qQustp3COCGvnP4SvrMHnPQ9d1vzCakQVRTliaz8cIp/wULGjiGpbcqrkv0WrHTEp8bQD/B3HBjzujVWLOA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.0.tgz", + "integrity": "sha512-pjZDsVH/1VsghMJ2/kAaxt6dL0psT6ZexQVrijczOf+PeP2BUqTHYejk3l6TlPRydggINOeNRhvpLa0AYpCWSQ==", + "cpu": [ + "riscv64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.0.tgz", + "integrity": "sha512-3ObQs0BhvPgiUVZrN7gqCSvmFuMWvWvsjG5ayJ3Lraqv+2KhOsp+pUbigqbeWqueGIsnn+09HBw27rJ+gYK4VQ==", + "cpu": [ + "s390x" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.0.tgz", + "integrity": "sha512-EtylprDtQPdS5rXvAayrNDYoJhIz1/vzN2fEubo3yLE7tfAw+948dO0g4M0vkTVFhKojnF+n6C8bDNe+gDRdTg==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.0.tgz", + "integrity": "sha512-k09oiRCi/bHU9UVFqD17r3eJR9bn03TyKraCrlz5ULFJGdJGi7VOmm9jl44vOJvRJ6P7WuBi/s2A97LxxHGIdw==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.0.tgz", + "integrity": "sha512-1o/0/pIhozoSaDJoDcec+IVLbnRtQmHwPV730+AOD29lHEEo4F5BEUB24H0OBdhbBBDwIOSuf7vgg0Ywxdfiiw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.0.tgz", + "integrity": "sha512-pESDkos/PDzYwtyzB5p/UoNU/8fJo68vcXM9ZW2V0kjYayj1KaaUfi1NmTUTUpMn4UhU4gTuK8gIaFO4UGuMbA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.0.tgz", + "integrity": "sha512-hj1wFStD7B1YBeYmvY+lWXZ7ey73YGPcViMShYikqKT1GtstIKQAtfUI6yrzPjAy/O7pO0VLXGmUVWXQMaYgTQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.0.tgz", + "integrity": "sha512-SyaIPFoxmUPlNDq5EHkTbiKzmSEmq/gOYFI/3HHJ8iS/v1mbugVa7dXUzcJGQfoytp9DJFLhHH4U3/eTy2Bq4w==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.0.tgz", + "integrity": "sha512-RdcryEfzZr+lAr5kRm2ucN9aVlCCa2QNq4hXelZxb8GG0NJSazq44Z3PCCc8wISRuCVnGs0lQJVX5Vp6fKA+IA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.0.tgz", + "integrity": "sha512-PrsWNQ8BuE00O3Xsx3ALh2Df8fAj9+cvvX9AIA6o4KpATR98c9mud4XtDWVvsEuyia5U4tVSTKygawyJkjm60w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@types/babel__core": { + "version": "7.20.5", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz", + "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + } + }, + "node_modules/@types/babel__generator": { + "version": "7.27.0", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz", + "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__template": { + "version": "7.4.4", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz", + "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__traverse": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz", + "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.28.2" + } + }, + "node_modules/@types/earcut": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@types/earcut/-/earcut-3.0.0.tgz", + "integrity": "sha512-k/9fOUGO39yd2sCjrbAJvGDEQvRwRnQIZlBz43roGwUZo5SHAmyVvSFyaVVZkicRVCaDXPKlbxrUcBuJoSWunQ==", + "license": "MIT" + }, + "node_modules/@types/estree": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/json-schema": { + "version": "7.0.15", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", + "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/react": { + "version": "19.2.14", + "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.14.tgz", + "integrity": "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==", + "dev": true, + "license": "MIT", + "dependencies": { + "csstype": "^3.2.2" + } + }, + "node_modules/@types/react-dom": { + "version": "19.2.3", + "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.3.tgz", + "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "@types/react": "^19.2.0" + } + }, + "node_modules/@vitejs/plugin-react": { + "version": "4.7.0", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz", + "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/core": "^7.28.0", + "@babel/plugin-transform-react-jsx-self": "^7.27.1", + "@babel/plugin-transform-react-jsx-source": "^7.27.1", + "@rolldown/pluginutils": "1.0.0-beta.27", + "@types/babel__core": "^7.20.5", + "react-refresh": "^0.17.0" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "peerDependencies": { + "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" + } + }, + "node_modules/@webgpu/types": { + "version": "0.1.69", + "resolved": "https://registry.npmjs.org/@webgpu/types/-/types-0.1.69.tgz", + "integrity": "sha512-RPmm6kgRbI8e98zSD3RVACvnuktIja5+yLgDAkTmxLr90BEwdTXRQWNLF3ETTTyH/8mKhznZuN5AveXYFEsMGQ==", + "license": "BSD-3-Clause" + }, + "node_modules/@xmldom/xmldom": { + "version": "0.8.11", + "resolved": "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.8.11.tgz", + "integrity": "sha512-cQzWCtO6C8TQiYl1ruKNn2U6Ao4o4WBBcbL61yJl84x+j5sOWWFU9X7DpND8XZG3daDppSsigMdfAIl2upQBRw==", + "license": "MIT", + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/acorn": { + "version": "8.16.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz", + "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==", + "dev": true, + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-jsx": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", + "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/ajv": { + "version": "6.14.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz", + "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==", + "dev": true, + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true, + "license": "Python-2.0" + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true, + "license": "MIT" + }, + "node_modules/baseline-browser-mapping": { + "version": "2.10.11", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.11.tgz", + "integrity": "sha512-DAKrHphkJyiGuau/cFieRYhcTFeK/lBuD++C7cZ6KZHbMhBrisoi+EvhQ5RZrIfV5qwsW8kgQ07JIC+MDJRAhg==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.cjs" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/brace-expansion": { + "version": "1.1.13", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.13.tgz", + "integrity": "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/browserslist": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz", + "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "baseline-browser-mapping": "^2.9.0", + "caniuse-lite": "^1.0.30001759", + "electron-to-chromium": "^1.5.263", + "node-releases": "^2.0.27", + "update-browserslist-db": "^1.2.0" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001781", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001781.tgz", + "integrity": "sha512-RdwNCyMsNBftLjW6w01z8bKEvT6e/5tpPVEgtn22TiLGlstHOVecsX2KHFkD5e/vRnIE4EGzpuIODb3mtswtkw==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "CC-BY-4.0" + }, + "node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "license": "MIT" + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true, + "license": "MIT" + }, + "node_modules/convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "dev": true, + "license": "MIT" + }, + "node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/csstype": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/earcut": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/earcut/-/earcut-3.0.2.tgz", + "integrity": "sha512-X7hshQbLyMJ/3RPhyObLARM2sNxxmRALLKx1+NVFFnQ9gKzmCrxm9+uLIAdBcvc8FNLpctqlQ2V6AE92Ol9UDQ==", + "license": "ISC" + }, + "node_modules/electron-to-chromium": { + "version": "1.5.328", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.328.tgz", + "integrity": "sha512-QNQ5l45DzYytThO21403XN3FvK0hOkWDG8viNf6jqS42msJ8I4tGDSpBCgvDRRPnkffafiwAym2X2eHeGD2V0w==", + "dev": true, + "license": "ISC" + }, + "node_modules/esbuild": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz", + "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.25.12", + "@esbuild/android-arm": "0.25.12", + "@esbuild/android-arm64": "0.25.12", + "@esbuild/android-x64": "0.25.12", + "@esbuild/darwin-arm64": "0.25.12", + "@esbuild/darwin-x64": "0.25.12", + "@esbuild/freebsd-arm64": "0.25.12", + "@esbuild/freebsd-x64": "0.25.12", + "@esbuild/linux-arm": "0.25.12", + "@esbuild/linux-arm64": "0.25.12", + "@esbuild/linux-ia32": "0.25.12", + "@esbuild/linux-loong64": "0.25.12", + "@esbuild/linux-mips64el": "0.25.12", + "@esbuild/linux-ppc64": "0.25.12", + "@esbuild/linux-riscv64": "0.25.12", + "@esbuild/linux-s390x": "0.25.12", + "@esbuild/linux-x64": "0.25.12", + "@esbuild/netbsd-arm64": "0.25.12", + "@esbuild/netbsd-x64": "0.25.12", + "@esbuild/openbsd-arm64": "0.25.12", + "@esbuild/openbsd-x64": "0.25.12", + "@esbuild/openharmony-arm64": "0.25.12", + "@esbuild/sunos-x64": "0.25.12", + "@esbuild/win32-arm64": "0.25.12", + "@esbuild/win32-ia32": "0.25.12", + "@esbuild/win32-x64": "0.25.12" + } + }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint": { + "version": "9.39.4", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.4.tgz", + "integrity": "sha512-XoMjdBOwe/esVgEvLmNsD3IRHkm7fbKIUGvrleloJXUZgDHig2IPWNniv+GwjyJXzuNqVjlr5+4yVUZjycJwfQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.8.0", + "@eslint-community/regexpp": "^4.12.1", + "@eslint/config-array": "^0.21.2", + "@eslint/config-helpers": "^0.4.2", + "@eslint/core": "^0.17.0", + "@eslint/eslintrc": "^3.3.5", + "@eslint/js": "9.39.4", + "@eslint/plugin-kit": "^0.4.1", + "@humanfs/node": "^0.16.6", + "@humanwhocodes/module-importer": "^1.0.1", + "@humanwhocodes/retry": "^0.4.2", + "@types/estree": "^1.0.6", + "ajv": "^6.14.0", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.6", + "debug": "^4.3.2", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^8.4.0", + "eslint-visitor-keys": "^4.2.1", + "espree": "^10.4.0", + "esquery": "^1.5.0", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^8.0.0", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "ignore": "^5.2.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "lodash.merge": "^4.6.2", + "minimatch": "^3.1.5", + "natural-compare": "^1.4.0", + "optionator": "^0.9.3" + }, + "bin": { + "eslint": "bin/eslint.js" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://eslint.org/donate" + }, + "peerDependencies": { + "jiti": "*" + }, + "peerDependenciesMeta": { + "jiti": { + "optional": true + } + } + }, + "node_modules/eslint-scope": { + "version": "8.4.0", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz", + "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-visitor-keys": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz", + "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/espree": { + "version": "10.4.0", + "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz", + "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "acorn": "^8.15.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^4.2.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/esquery": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz", + "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "estraverse": "^5.1.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "estraverse": "^5.2.0" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/eventemitter3": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.4.tgz", + "integrity": "sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==", + "license": "MIT" + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "dev": true, + "license": "MIT" + }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/file-entry-cache": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz", + "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "flat-cache": "^4.0.0" + }, + "engines": { + "node": ">=16.0.0" + } + }, + "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "license": "MIT", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/flat-cache": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz", + "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==", + "dev": true, + "license": "MIT", + "dependencies": { + "flatted": "^3.2.9", + "keyv": "^4.5.4" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/flatted": { + "version": "3.4.2", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.2.tgz", + "integrity": "sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==", + "dev": true, + "license": "ISC" + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/gifuct-js": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/gifuct-js/-/gifuct-js-2.1.2.tgz", + "integrity": "sha512-rI2asw77u0mGgwhV3qA+OEgYqaDn5UNqgs+Bx0FGwSpuqfYn+Ir6RQY5ENNQ8SbIiG/m5gVa7CD5RriO4f4Lsg==", + "license": "MIT", + "dependencies": { + "js-binary-schema-parser": "^2.0.3" + } + }, + "node_modules/glob-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/globals": { + "version": "14.0.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz", + "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/ignore": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", + "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/import-fresh": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz", + "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true, + "license": "ISC" + }, + "node_modules/ismobilejs": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ismobilejs/-/ismobilejs-1.1.1.tgz", + "integrity": "sha512-VaFW53yt8QO61k2WJui0dHf4SlL8lxBofUuUmwBo0ljPk0Drz2TiuDW4jo3wDcv41qy/SxrJ+VAzJ/qYqsmzRw==", + "license": "MIT" + }, + "node_modules/js-binary-schema-parser": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/js-binary-schema-parser/-/js-binary-schema-parser-2.0.3.tgz", + "integrity": "sha512-xezGJmOb4lk/M1ZZLTR/jaBHQ4gG/lqQnJqdIv4721DMggsa1bDVlHXNeHYogaIEHD9vCRv0fcL4hMA+Coarkg==", + "license": "MIT" + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/js-yaml": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz", + "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==", + "dev": true, + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsesc": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", + "dev": true, + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/json-buffer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", + "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", + "dev": true, + "license": "MIT" + }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true, + "license": "MIT", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/keyv": { + "version": "4.5.4", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + "dev": true, + "license": "MIT", + "dependencies": { + "json-buffer": "3.0.1" + } + }, + "node_modules/levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "license": "ISC", + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/minimatch": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz", + "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/nanoid": { + "version": "3.3.11", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz", + "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", + "dev": true, + "license": "MIT" + }, + "node_modules/node-releases": { + "version": "2.0.36", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.36.tgz", + "integrity": "sha512-TdC8FSgHz8Mwtw9g5L4gR/Sh9XhSP/0DEkQxfEFXOpiul5IiHgHan2VhYYb6agDSfp4KuvltmGApc8HMgUrIkA==", + "dev": true, + "license": "MIT" + }, + "node_modules/optionator": { + "version": "0.9.4", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz", + "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==", + "dev": true, + "license": "MIT", + "dependencies": { + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0", + "word-wrap": "^1.2.5" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, + "license": "MIT", + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/parse-svg-path": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/parse-svg-path/-/parse-svg-path-0.1.2.tgz", + "integrity": "sha512-JyPSBnkTJ0AI8GGJLfMXvKq42cj5c006fnLz6fXy6zfoVjJizi8BNTpu8on8ziI1cKy9d9DGNuY17Ce7wuejpQ==", + "license": "MIT" + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz", + "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/pixi.js": { + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/pixi.js/-/pixi.js-8.17.1.tgz", + "integrity": "sha512-OB4TpZHrP5RYy+7FqmFrAc0IHRhfOoNIfF4sVeinvK3aG1r2pYrSMneJAKi9+WvGKC70Dj7GEpZ2OZGB6o/xdg==", + "license": "MIT", + "workspaces": [ + "examples", + "playground" + ], + "dependencies": { + "@pixi/colord": "^2.9.6", + "@types/earcut": "^3.0.0", + "@webgpu/types": "^0.1.69", + "@xmldom/xmldom": "^0.8.11", + "earcut": "^3.0.2", + "eventemitter3": "^5.0.1", + "gifuct-js": "^2.1.2", + "ismobilejs": "^1.1.1", + "parse-svg-path": "^0.1.2", + "tiny-lru": "^11.4.7" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/pixijs" + } + }, + "node_modules/postcss": { + "version": "8.5.8", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.8.tgz", + "integrity": "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.11", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/react": { + "version": "19.2.4", + "resolved": "https://registry.npmjs.org/react/-/react-19.2.4.tgz", + "integrity": "sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "19.2.4", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.4.tgz", + "integrity": "sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ==", + "license": "MIT", + "dependencies": { + "scheduler": "^0.27.0" + }, + "peerDependencies": { + "react": "^19.2.4" + } + }, + "node_modules/react-refresh": { + "version": "0.17.0", + "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz", + "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/rollup": { + "version": "4.60.0", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.60.0.tgz", + "integrity": "sha512-yqjxruMGBQJ2gG4HtjZtAfXArHomazDHoFwFFmZZl0r7Pdo7qCIXKqKHZc8yeoMgzJJ+pO6pEEHa+V7uzWlrAQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.8" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.60.0", + "@rollup/rollup-android-arm64": "4.60.0", + "@rollup/rollup-darwin-arm64": "4.60.0", + "@rollup/rollup-darwin-x64": "4.60.0", + "@rollup/rollup-freebsd-arm64": "4.60.0", + "@rollup/rollup-freebsd-x64": "4.60.0", + "@rollup/rollup-linux-arm-gnueabihf": "4.60.0", + "@rollup/rollup-linux-arm-musleabihf": "4.60.0", + "@rollup/rollup-linux-arm64-gnu": "4.60.0", + "@rollup/rollup-linux-arm64-musl": "4.60.0", + "@rollup/rollup-linux-loong64-gnu": "4.60.0", + "@rollup/rollup-linux-loong64-musl": "4.60.0", + "@rollup/rollup-linux-ppc64-gnu": "4.60.0", + "@rollup/rollup-linux-ppc64-musl": "4.60.0", + "@rollup/rollup-linux-riscv64-gnu": "4.60.0", + "@rollup/rollup-linux-riscv64-musl": "4.60.0", + "@rollup/rollup-linux-s390x-gnu": "4.60.0", + "@rollup/rollup-linux-x64-gnu": "4.60.0", + "@rollup/rollup-linux-x64-musl": "4.60.0", + "@rollup/rollup-openbsd-x64": "4.60.0", + "@rollup/rollup-openharmony-arm64": "4.60.0", + "@rollup/rollup-win32-arm64-msvc": "4.60.0", + "@rollup/rollup-win32-ia32-msvc": "4.60.0", + "@rollup/rollup-win32-x64-gnu": "4.60.0", + "@rollup/rollup-win32-x64-msvc": "4.60.0", + "fsevents": "~2.3.2" + } + }, + "node_modules/scheduler": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz", + "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==", + "license": "MIT" + }, + "node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/tiny-lru": { + "version": "11.4.7", + "resolved": "https://registry.npmjs.org/tiny-lru/-/tiny-lru-11.4.7.tgz", + "integrity": "sha512-w/Te7uMUVeH0CR8vZIjr+XiN41V+30lkDdK+NRIDCUYKKuL9VcmaUEmaPISuwGhLlrTGh5yu18lENtR9axSxYw==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=12" + } + }, + "node_modules/tinyglobby": { + "version": "0.2.15", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz", + "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.3" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/typescript": { + "version": "5.7.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.3.tgz", + "integrity": "sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/update-browserslist-db": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz", + "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "escalade": "^3.2.0", + "picocolors": "^1.1.1" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/vite": { + "version": "6.4.1", + "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.1.tgz", + "integrity": "sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.25.0", + "fdir": "^6.4.4", + "picomatch": "^4.0.2", + "postcss": "^8.5.3", + "rollup": "^4.34.9", + "tinyglobby": "^0.2.13" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^18.0.0 || ^20.0.0 || >=22.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", + "jiti": ">=1.21.0", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "sass-embedded": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/word-wrap": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", + "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true, + "license": "ISC" + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + } + } +} diff --git a/frontend/package.json b/frontend/package.json new file mode 100644 index 0000000..3309151 --- /dev/null +++ b/frontend/package.json @@ -0,0 +1,25 @@ +{ + "name": "autohero-frontend", + "version": "0.1.0", + "private": true, + "type": "module", + "scripts": { + "dev": "vite", + "build": "tsc -b && vite build", + "preview": "vite preview", + "lint": "eslint src --ext .ts,.tsx --max-warnings 0" + }, + "dependencies": { + "pixi.js": "^8.6.6", + "react": "^19.0.0", + "react-dom": "^19.0.0" + }, + "devDependencies": { + "@types/react": "^19.2.14", + "@types/react-dom": "^19.0.0", + "@vitejs/plugin-react": "^4.3.4", + "eslint": "^9.17.0", + "typescript": "~5.7.2", + "vite": "^6.2.0" + } +} diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx new file mode 100644 index 0000000..6200859 --- /dev/null +++ b/frontend/src/App.tsx @@ -0,0 +1,1278 @@ +import { useEffect, useRef, useState, useCallback, type CSSProperties } from 'react'; +import { GameEngine } from './game/engine'; +import { GamePhase, BuffType, type GameState, type FloatingDamageData, type ActiveBuff, type NPCData } from './game/types'; +import type { NPCEncounterEvent } from './game/types'; +import { GameWebSocket } from './network/websocket'; +import { + wireWSHandler, + sendActivateBuff, + sendUsePotion, + sendRevive, + sendNPCAlmsAccept, + sendNPCAlmsDecline, + buildLootFromCombatEnd, +} from './game/ws-handler'; +import { + ApiError, + initHero, + getAdventureLog, + getTowns, + getTownNPCs, + getHeroQuests, + getHeroEquipment, + claimQuest, + abandonQuest, + getAchievements, + getNearbyHeroes, + getDailyTasks, + claimDailyTask, + buyPotion, + healAtNPC, + requestRevive, +} from './network/api'; +import type { HeroResponse, Achievement, DailyTaskResponse } from './network/api'; +import type { AdventureLogEntry, Town, HeroQuest, NPC, TownData, EquipmentItem } from './game/types'; +import type { OfflineReport as OfflineReportData } from './network/api'; +import { + BUFF_COOLDOWN_MS, + BUFF_DURATION_MS, + mapHeroBuffsFromServer, + mapHeroDebuffsFromServer, +} from './network/buffMap'; +import { hapticImpact, hapticNotification, onThemeChanged, getTelegramUserId } from './shared/telegram'; +import { Rarity } from './game/types'; +import type { HeroState, BuffChargeState } from './game/types'; +import { HUD } from './ui/HUD'; +import { DeathScreen } from './ui/DeathScreen'; +import { FloatingDamage } from './ui/FloatingDamage'; +import { GameToast } from './ui/GameToast'; +import { AdventureLog } from './ui/AdventureLog'; +import { OfflineReport } from './ui/OfflineReport'; +import { QuestLog } from './ui/QuestLog'; +import { NPCDialog } from './ui/NPCDialog'; +import { NameEntryScreen } from './ui/NameEntryScreen'; +import { DailyTasks } from './ui/DailyTasks'; +import { AchievementsPanel } from './ui/AchievementsPanel'; +import { Minimap } from './ui/Minimap'; +import { NPCInteraction } from './ui/NPCInteraction'; +import { WanderingNPCPopup } from './ui/WanderingNPCPopup'; + +const appStyle: CSSProperties = { + width: '100%', + height: '100%', + position: 'relative', + overflow: 'hidden', +}; + +const canvasContainerStyle: CSSProperties = { + width: '100%', + height: '100%', + position: 'absolute', + top: 0, + left: 0, +}; + +const connectionBanner: CSSProperties = { + position: 'absolute', + top: 0, + left: 0, + right: 0, + textAlign: 'center', + padding: '4px 0', + fontSize: 12, + fontWeight: 600, + color: '#fff', + backgroundColor: 'rgba(204, 51, 51, 0.85)', + zIndex: 200, +}; + +function buffCdStorageKey(heroId: number): string { + return `autohero-buffCd-v1-${heroId}`; +} + +function pruneCooldownEnds( + raw: Partial>, + now: number, +): Partial> { + const out: Partial> = {}; + for (const [k, v] of Object.entries(raw)) { + if (typeof v === 'number' && v > now && (Object.values(BuffType) as string[]).includes(k)) { + out[k as BuffType] = v; + } + } + return out; +} + +function loadCooldownsFromStorage(heroId: number): Partial> { + try { + const raw = sessionStorage.getItem(buffCdStorageKey(heroId)); + if (!raw) return {}; + const parsed = JSON.parse(raw) as Partial>; + return pruneCooldownEnds(parsed, Date.now()); + } catch { + return {}; + } +} + +function saveCooldownsToStorage(heroId: number, ends: Partial>): void { + try { + const pruned = pruneCooldownEnds(ends, Date.now()); + sessionStorage.setItem(buffCdStorageKey(heroId), JSON.stringify(pruned)); + } catch { + /* ignore quota / private mode */ + } +} + +function xpToNextLevel(level: number): number { + if (level < 1) level = 1; + if (level <= 9) return Math.round(180 * Math.pow(1.28, level - 1)); + if (level <= 29) return Math.round(1450 * Math.pow(1.15, level - 10)); + return Math.round(23000 * Math.pow(1.10, level - 30)); +} + +/** Map backend buffCharges (keyed by string) into typed Partial>. */ +function mapBuffCharges( + raw: Record | undefined, +): Partial> { + if (!raw) return {}; + const out: Partial> = {}; + const validTypes = new Set(Object.values(BuffType) as string[]); + for (const [key, val] of Object.entries(raw)) { + if (validTypes.has(key)) { + out[key as BuffType] = { remaining: val.remaining, periodEnd: val.periodEnd }; + } + } + return out; +} + +/** Map backend equipment record to typed EquipmentItem map. */ +function mapEquipment( + raw: HeroResponse['equipment'], + res: HeroResponse, +): Record { + const out: Record = {}; + + if (raw) { + for (const [slot, item] of Object.entries(raw)) { + out[slot] = { + id: item.id, + slot: item.slot ?? slot, + formId: item.formId ?? '', + name: item.name, + rarity: (item.rarity?.toLowerCase() ?? 'common') as EquipmentItem['rarity'], + ilvl: item.ilvl ?? 1, + primaryStat: item.primaryStat ?? 0, + statType: item.statType ?? 'mixed', + }; + } + } + + // Fallback: populate main_hand from legacy weapon if not already set + if (!out['main_hand'] && res.weapon) { + out['main_hand'] = { + id: res.weapon.id ?? 0, + slot: 'main_hand', + formId: '', + name: res.weapon.name ?? 'Unknown', + rarity: (res.weapon.rarity?.toLowerCase() ?? 'common') as EquipmentItem['rarity'], + ilvl: res.weapon.ilvl ?? 1, + primaryStat: res.weapon.damage ?? 0, + statType: 'attack', + }; + } + + if (!out['chest'] && res.armor) { + out['chest'] = { + id: res.armor.id ?? 0, + slot: 'chest', + formId: '', + name: res.armor.name ?? 'Unknown', + rarity: (res.armor.rarity?.toLowerCase() ?? 'common') as EquipmentItem['rarity'], + ilvl: res.armor.ilvl ?? 1, + primaryStat: res.armor.defense ?? 0, + statType: 'defense', + }; + } + + return out; +} + +/** Convert Town (from /towns API) to engine-facing TownData, optionally with NPCs */ +function townToTownData(town: Town, npcs?: NPC[]): TownData { + const npcData: NPCData[] | undefined = npcs?.map((n) => ({ + id: n.id, + name: n.name, + type: n.type, + worldX: town.worldX + n.offsetX, + worldY: town.worldY + n.offsetY, + })); + return { + id: town.id, + name: town.name, + centerX: town.worldX, + centerY: town.worldY, + radius: town.radius, + biome: town.biome, + levelMin: town.levelMin, + size: town.radius > 40 ? 'XL' : town.radius > 25 ? 'M' : town.radius > 15 ? 'S' : 'XS', + npcs: npcData, + }; +} + +function heroResponseToState(res: HeroResponse): HeroState { + const now = Date.now(); + return { + id: res.id, + hp: res.hp, + maxHp: res.maxHp, + position: { x: res.positionX ?? 0, y: res.positionY ?? 0 }, + attackSpeed: res.attackSpeed ?? res.speed, + damage: res.attackPower ?? res.attack, + defense: res.defensePower ?? res.defense, + weaponType: (res.weapon?.type ?? 'sword') as HeroState['weaponType'], + weaponName: res.weapon?.name ?? '', + weaponRarity: (res.weapon?.rarity ?? 'common') as Rarity, + weaponIlvl: res.weapon?.ilvl, + armorType: (res.armor?.type ?? 'medium') as HeroState['armorType'], + armorName: res.armor?.name ?? '', + armorRarity: (res.armor?.rarity ?? 'common') as Rarity, + armorIlvl: res.armor?.ilvl, + activeBuffs: mapHeroBuffsFromServer(res.buffs, now), + debuffs: mapHeroDebuffsFromServer(res.debuffs, now), + level: res.level, + xp: res.xp, + xpToNext: res.xpToNext ?? xpToNextLevel(res.level || 1), + gold: res.gold, + strength: res.strength, + constitution: res.constitution, + agility: res.agility, + luck: res.luck, + reviveCount: res.reviveCount, + subscriptionActive: res.subscriptionActive, + buffFreeChargesRemaining: res.buffFreeChargesRemaining, + buffQuotaPeriodEnd: res.buffQuotaPeriodEnd, + buffCharges: mapBuffCharges(res.buffCharges), + potions: res.potions ?? 0, + moveSpeed: res.moveSpeed, + equipment: mapEquipment(res.equipment, res), + }; +} + + +export function App() { + const canvasRef = useRef(null); + const engineRef = useRef(null); + const wsRef = useRef(null); + + const [gameState, setGameState] = useState({ + phase: GamePhase.Walking, + hero: null, + enemy: null, + loot: null, + lastVictoryLoot: null, + tick: 0, + serverTimeMs: 0, + }); + + const [damages, setDamages] = useState([]); + const [wsConnected, setWsConnected] = useState(false); + const [wsEverConnected, setWsEverConnected] = useState(false); + const [buffCooldownEndsAt, setBuffCooldownEndsAt] = useState< + Partial> + >({}); + const [connectionError, setConnectionError] = useState(null); + const [toast, setToast] = useState<{ message: string; color: string } | null>(null); + const [logEntries, setLogEntries] = useState([]); + const [offlineReport, setOfflineReport] = useState(null); + const [needsName, setNeedsName] = useState(false); + const logIdCounter = useRef(0); + const nearbyIntervalRef = useRef | null>(null); + + // Quest system state + const [towns, setTowns] = useState([]); + const townsRef = useRef([]); + const [heroQuests, setHeroQuests] = useState([]); + const [currentTown, setCurrentTown] = useState(null); + const [selectedNPC, setSelectedNPC] = useState(null); + const [questLogOpen, setQuestLogOpen] = useState(false); + + // NPC interaction state (server-driven via town_enter) + const [nearestNPC, setNearestNPC] = useState(null); + const [npcInteractionDismissed, setNpcInteractionDismissed] = useState(null); + + // Wandering NPC encounter state + const [wanderingNPC, setWanderingNPC] = useState(null); + // Daily tasks (backend-driven) + const [dailyTasks, setDailyTasks] = useState([]); + // Achievements + const [achievements, setAchievements] = useState([]); + const prevAchievementsRef = useRef([]); + + const addLogEntry = useCallback((message: string) => { + logIdCounter.current += 1; + const entry: AdventureLogEntry = { + id: logIdCounter.current, + message, + timestamp: Date.now(), + }; + setLogEntries((prev) => [...prev, entry]); + }, []); + + const refreshEquipment = useCallback(() => { + const telegramId = getTelegramUserId() ?? 1; + getHeroEquipment(telegramId) + .then((eqMap) => { + const merged: Record = {}; + for (const [slot, item] of Object.entries(eqMap)) { + merged[slot] = { + id: item.id, + slot: item.slot ?? slot, + formId: item.formId ?? '', + name: item.name, + rarity: (item.rarity?.toLowerCase() ?? 'common') as EquipmentItem['rarity'], + ilvl: item.ilvl ?? 1, + primaryStat: item.primaryStat ?? 0, + statType: item.statType ?? 'mixed', + }; + } + const engine = engineRef.current; + if (engine?.gameState.hero) { + const prevEquip = engine.gameState.hero.equipment ?? {}; + const combined = { ...prevEquip, ...merged }; + engine.gameState.hero.equipment = combined; + } + setGameState((prev) => { + if (!prev.hero) return prev; + const prevEquip = prev.hero.equipment ?? {}; + return { ...prev, hero: { ...prev.hero, equipment: { ...prevEquip, ...merged } } }; + }); + }) + .catch(() => console.warn('[App] Could not fetch equipment')); + }, []); + + const refreshHeroQuests = useCallback(() => { + const telegramId = getTelegramUserId() ?? 1; + getHeroQuests(telegramId) + .then((q) => setHeroQuests(q)) + .catch(() => console.warn('[App] Could not refresh hero quests')); + }, []); + + // Initialize engine and WebSocket + useEffect(() => { + const container = canvasRef.current; + if (!container) return; + + // ---- Game Engine ---- + const engine = new GameEngine(); + engineRef.current = engine; + + engine.onStateChange((state) => { + setGameState(state); + }); + + // Wire up damage events from the engine + engine.onDamage((dmg: FloatingDamageData) => { + setDamages((prev) => [...prev, dmg]); + if (dmg.isCrit) { + hapticImpact('heavy'); + } else { + hapticImpact('light'); + } + engine.camera.shake(dmg.isCrit ? 8 : 4, dmg.isCrit ? 250 : 150); + }); + + engine.init(container).then(async () => { + try { + const telegramId = getTelegramUserId() ?? 1; + const initRes = await initHero(telegramId); + + // Gate game start behind name entry + if (initRes.needsName) { + setNeedsName(true); + const heroState = heroResponseToState(initRes.hero); + engine.initFromServer(heroState, initRes.hero.state); + console.info('[App] Hero needs name, showing name entry screen'); + return; + } + + const heroState = heroResponseToState(initRes.hero); + engine.initFromServer(heroState, initRes.hero.state); + engine.setHeroName(initRes.hero.name); + console.info('[App] Loaded hero from server, id=', initRes.hero.id); + + if (initRes.offlineReport && initRes.offlineReport.monstersKilled > 0) { + const r = initRes.offlineReport; + console.info(`[Offline] ${r.message} Killed ${r.monstersKilled} monsters, +${r.xpGained} XP, +${r.goldGained} gold, +${r.levelsGained} levels`); + setOfflineReport(r); + } + + // Fetch towns, then their NPCs, and pass everything to the engine + getTowns() + .then(async (t) => { + setTowns(t); + townsRef.current = t; + const townNPCMap = new Map(); + try { + const npcResults = await Promise.allSettled( + t.map((town) => getTownNPCs(town.id).then((npcs) => ({ townId: town.id, npcs }))), + ); + for (const result of npcResults) { + if (result.status === 'fulfilled') { + townNPCMap.set(result.value.townId, result.value.npcs); + } + } + } catch { + console.warn('[App] Error fetching town NPCs'); + } + const townDataList = t.map((town) => townToTownData(town, townNPCMap.get(town.id))); + engine.setTowns(townDataList); + const allNPCs: NPCData[] = []; + for (const td of townDataList) { + if (td.npcs) allNPCs.push(...td.npcs); + } + engine.setNPCs(allNPCs); + }) + .catch(() => console.warn('[App] Could not fetch towns')); + + getHeroQuests(telegramId) + .then((q) => setHeroQuests(q)) + .catch(() => console.warn('[App] Could not fetch hero quests')); + refreshEquipment(); + + getAchievements(telegramId) + .then((a) => { prevAchievementsRef.current = a; setAchievements(a); }) + .catch(() => console.warn('[App] Could not fetch achievements')); + + getDailyTasks(telegramId) + .then((t) => setDailyTasks(t)) + .catch(() => console.warn('[App] Could not fetch daily tasks')); + + // Poll nearby heroes every 5 seconds + const nearbyInterval = setInterval(() => { + getNearbyHeroes(telegramId) + .then((heroes) => engine.setNearbyHeroes(heroes.map((h) => ({ + id: h.id, + name: h.name, + level: h.level, + positionX: h.positionX, + positionY: h.positionY, + })))) + .catch(() => {}); + }, 5000); + getNearbyHeroes(telegramId) + .then((heroes) => engine.setNearbyHeroes(heroes.map((h) => ({ + id: h.id, + name: h.name, + level: h.level, + positionX: h.positionX, + positionY: h.positionY, + })))) + .catch(() => {}); + nearbyIntervalRef.current = nearbyInterval; + + // Fetch adventure log + try { + const serverLog = await getAdventureLog(telegramId, 50); + if (serverLog.length > 0) { + const mapped: AdventureLogEntry[] = serverLog.map((entry, i) => ({ + id: i + 1, + message: entry.message, + timestamp: new Date(entry.createdAt).getTime(), + })); + logIdCounter.current = mapped.length; + setLogEntries(mapped); + } + } catch { + console.warn('[App] Could not fetch adventure log'); + } + } catch (err) { + console.error('[App] Backend not available. Game requires a server connection:', err); + setConnectionError('Cannot reach game server. Please try again later.'); + return; + } + engine.start(); + }).catch((err) => { + console.error('[App] Failed to initialize game engine:', err); + }); + + // ---- WebSocket ---- + const ws = new GameWebSocket(); + wsRef.current = ws; + + // Pass telegram ID so the WS connection identifies the correct hero. + const wsTelegramId = getTelegramUserId() ?? 1; + ws.setTelegramId(wsTelegramId); + + ws.onConnectionState((connState) => { + const connected = connState === 'connected'; + setWsConnected(connected); + if (connected) setWsEverConnected(true); + }); + + // Wire WS handler -- routes server messages to engine + UI callbacks + wireWSHandler(ws, engine, { + onHeroStateReceived: (payload) => { + // Convert raw payload to HeroResponse shape and apply + const res = payload as unknown as HeroResponse; + const heroState = heroResponseToState(res); + engine.applyHeroState(heroState); + }, + + onCombatEnd: (p) => { + const loot = buildLootFromCombatEnd(p); + engine.applyLoot(loot); + hapticNotification('success'); + + const parts: string[] = []; + if (p.xpGained > 0) parts.push(`+${p.xpGained} XP`); + if (p.goldGained > 0) parts.push(`+${p.goldGained} gold`); + const equipDrop = p.loot.find((l) => l.itemType === 'weapon' || l.itemType === 'armor'); + if (equipDrop?.name) parts.push(`found ${equipDrop.name}`); + if (parts.length > 0) addLogEntry(`Victory: ${parts.join(', ')}`); + + if (p.leveledUp && p.newLevel) { + setToast({ message: `Level up! Now level ${p.newLevel}`, color: '#ffd700' }); + hapticNotification('success'); + } + + // Refresh quests, equipment, daily tasks, achievements after combat + const tid = getTelegramUserId() ?? 1; + getHeroQuests(tid).then((q) => setHeroQuests(q)).catch(() => {}); + refreshEquipment(); + getDailyTasks(tid).then((t) => setDailyTasks(t)).catch(() => {}); + getAchievements(tid).then((a) => { + const prevIds = new Set(prevAchievementsRef.current.filter((x) => x.unlocked).map((x) => x.id)); + const newlyUnlocked = a.filter((x) => x.unlocked && !prevIds.has(x.id)); + for (const ach of newlyUnlocked) { + setToast({ message: `Achievement unlocked: ${ach.title}!`, color: '#ffd700' }); + hapticNotification('success'); + } + prevAchievementsRef.current = a; + setAchievements(a); + }).catch(() => {}); + }, + + onHeroDied: (p) => { + hapticNotification('error'); + addLogEntry(`Hero was slain by ${p.killedBy}`); + }, + + onHeroRevived: () => { + addLogEntry('Hero revived!'); + setToast({ message: 'Hero revived!', color: '#44cc44' }); + }, + + onBuffApplied: (p) => { + addLogEntry(`Buff applied: ${p.buffType}`); + }, + + onTownEnter: (p) => { + const town = townsRef.current.find((t) => t.id === p.townId) ?? null; + setCurrentTown(town); + setToast({ message: `Entering ${p.townName}`, color: '#daa520' }); + addLogEntry(`Entered ${p.townName}`); + const npcs = p.npcs ?? []; + if (npcs.length > 0) { + const firstNPC = npcs[0]!; + setNearestNPC({ + id: firstNPC.id, + name: firstNPC.name, + type: firstNPC.type as NPCData['type'], + worldX: 0, + worldY: 0, + }); + setNpcInteractionDismissed(null); + } + }, + + onTownNPCVisit: (p) => { + const role = + p.type === 'merchant' ? 'Shop' : p.type === 'healer' ? 'Healer' : 'Quest'; + addLogEntry(`${role}: ${p.name}`); + setToast({ message: `${role}: ${p.name}`, color: '#c9a227' }); + setNearestNPC({ + id: p.npcId, + name: p.name, + type: p.type as NPCData['type'], + worldX: 0, + worldY: 0, + }); + setNpcInteractionDismissed(null); + }, + + onTownExit: () => { + setCurrentTown(null); + setNearestNPC(null); + }, + + onNPCEncounter: (p) => { + const npcEvent: NPCEncounterEvent = { + type: 'npc_event', + npcName: p.npcName, + message: `${p.npcName} approaches!`, + cost: p.cost, + }; + setWanderingNPC(npcEvent); + }, + + onLevelUp: (p) => { + setToast({ message: `Level up! Now level ${p.newLevel}`, color: '#ffd700' }); + hapticNotification('success'); + addLogEntry(`Reached level ${p.newLevel}`); + }, + + onEquipmentChange: (p) => { + setToast({ message: `New ${p.slot}: ${p.item.name}`, color: '#cc88ff' }); + addLogEntry(`Equipped ${p.item.name} (${p.slot})`); + refreshEquipment(); + }, + + onPotionCollected: (p) => { + setToast({ message: `+${p.count} potion${p.count > 1 ? 's' : ''}`, color: '#44cc44' }); + }, + + onQuestProgress: (p) => { + setHeroQuests((prev) => + prev.map((hq) => + hq.questId === p.questId + ? { ...hq, progress: p.current } + : hq, + ), + ); + if (p.title) { + setToast({ + message: `${p.title} (${p.current}/${p.target})`, + color: '#44aaff', + }); + } + }, + + onQuestComplete: (p) => { + setHeroQuests((prev) => + prev.map((hq) => + hq.questId === p.questId + ? { ...hq, status: 'completed' as const } + : hq, + ), + ); + setToast({ message: `Quest completed: ${p.title}!`, color: '#ffd700' }); + hapticNotification('success'); + }, + + onError: (p) => { + setToast({ message: p.message, color: '#ff4444' }); + }, + }); + + ws.connect(); + + // ---- Telegram Theme Listener ---- + const unsubTheme = onThemeChanged(); + + // ---- Cleanup ---- + return () => { + engine.destroy(); + ws.disconnect(); + unsubTheme(); + if (nearbyIntervalRef.current) { + clearInterval(nearbyIntervalRef.current); + nearbyIntervalRef.current = null; + } + engineRef.current = null; + wsRef.current = null; + }; + }, []); + + // Restore per-hero buff button cooldowns + useEffect(() => { + const id = gameState.hero?.id; + if (id == null) return; + const loaded = loadCooldownsFromStorage(id); + if (Object.keys(loaded).length === 0) return; + setBuffCooldownEndsAt((prev) => ({ ...loaded, ...prev })); + }, [gameState.hero?.id]); + + // ---- Handlers ---- + + const handleBuffActivate = useCallback((type: BuffType) => { + const engine = engineRef.current; + const ws = wsRef.current; + const hero = engine?.gameState.hero; + const now = Date.now(); + + // Check per-buff charge quota + if (hero) { + const charge = hero.buffCharges?.[type]; + if (charge != null && charge.remaining <= 0) { + const label = type.charAt(0).toUpperCase() + type.slice(1).replace('_', ' '); + setToast({ message: `No charges left for ${label}`, color: '#ff8844' }); + return; + } + } + + // Optimistic update + if (engine && hero) { + const durationMs = BUFF_DURATION_MS[type]; + const optimisticBuff: ActiveBuff = { + type, + remainingMs: durationMs, + durationMs, + cooldownMs: BUFF_COOLDOWN_MS[type], + cooldownRemainingMs: 0, + expiresAtMs: now + durationMs, + }; + + const alreadyActive = hero.activeBuffs.some( + (b) => b.type === type && (b.expiresAtMs ?? 0) > now, + ); + const updatedBuffs = alreadyActive + ? hero.activeBuffs.map((b) => (b.type === type ? optimisticBuff : b)) + : [...hero.activeBuffs, optimisticBuff]; + + let { damage, defense, attackSpeed, hp, maxHp } = hero; + + if (!alreadyActive) { + switch (type) { + case BuffType.Rage: + damage = Math.round(damage * 2); + break; + case BuffType.PowerPotion: + damage = Math.round(damage * 2.5); + break; + case BuffType.WarCry: + attackSpeed = Math.round(attackSpeed * 2 * 100) / 100; + break; + case BuffType.Heal: + hp = Math.min(maxHp, hp + Math.round(maxHp * 0.5)); + break; + } + } + + engine.patchHeroCombat({ + damage, + defense, + attackSpeed, + activeBuffs: updatedBuffs, + }); + + if (type === BuffType.Heal && hp !== hero.hp) { + engine.patchHeroHp(hp); + } + + setBuffCooldownEndsAt((prev) => { + const next = { ...prev, [type]: now + BUFF_COOLDOWN_MS[type] }; + if (hero.id != null) saveCooldownsToStorage(hero.id, next); + return next; + }); + + // Optimistic decrement of per-buff charge + const currentCharge = hero.buffCharges?.[type]; + if (currentCharge != null && currentCharge.remaining > 0) { + const updatedCharges: Partial> = { + ...hero.buffCharges, + [type]: { ...currentCharge, remaining: currentCharge.remaining - 1 }, + }; + engine.patchHeroBuffQuota({ + buffFreeChargesRemaining: hero.buffFreeChargesRemaining, + buffQuotaPeriodEnd: hero.buffQuotaPeriodEnd, + buffCharges: updatedCharges, + }); + } + + hapticImpact('medium'); + addLogEntry(`Activated ${type} buff`); + } + + // Send command to server via WebSocket + if (ws) { + sendActivateBuff(ws, type); + } + }, [addLogEntry]); + + const handleRevive = useCallback(() => { + const ws = wsRef.current; + if (ws && ws.getState() === 'connected') { + sendRevive(ws); + } else { + // Fallback to REST if WS not connected + const telegramId = getTelegramUserId() ?? 1; + requestRevive(telegramId) + .then((hero) => { + const engine = engineRef.current; + if (engine) { + const state = heroResponseToState(hero); + engine.applyHeroRevived(state.hp); + engine.applyHeroState(state); + } + }) + .catch((err) => { + console.warn('[App] Revive failed:', err); + }); + } + }, []); + + const handleQuestClaim = useCallback( + (heroQuestId: number) => { + const telegramId = getTelegramUserId() ?? 1; + claimQuest(heroQuestId, telegramId) + .then((hero) => { + const merged = heroResponseToState(hero); + const engine = engineRef.current; + if (engine) { + const pos = engine.gameState.hero?.position; + if (pos) merged.position = pos; + engine.applyHeroState(merged); + } + setToast({ message: 'Quest rewards claimed!', color: '#ffd700' }); + hapticNotification('success'); + refreshHeroQuests(); + }) + .catch((err) => { + console.warn('[App] Failed to claim quest:', err); + setToast({ message: 'Failed to claim rewards', color: '#ff4444' }); + }); + }, + [refreshHeroQuests], + ); + + const handleQuestAbandon = useCallback( + (heroQuestId: number) => { + const telegramId = getTelegramUserId() ?? 1; + abandonQuest(heroQuestId, telegramId) + .then(() => { + setToast({ message: 'Quest abandoned', color: '#ff8844' }); + refreshHeroQuests(); + }) + .catch((err) => { + console.warn('[App] Failed to abandon quest:', err); + setToast({ message: 'Failed to abandon quest', color: '#ff4444' }); + }); + }, + [refreshHeroQuests], + ); + + const handleNPCHeroUpdated = useCallback((hero: HeroResponse) => { + const merged = heroResponseToState(hero); + const engine = engineRef.current; + if (engine) { + const pos = engine.gameState.hero?.position; + if (pos) merged.position = pos; + engine.applyHeroState(merged); + } + }, []); + + const handleNameSet = useCallback((hero: HeroResponse) => { + setNeedsName(false); + const engine = engineRef.current; + if (engine) { + const heroState = heroResponseToState(hero); + const pos = engine.gameState.hero?.position; + if (pos) heroState.position = pos; + engine.initFromServer(heroState, hero.state); + engine.setHeroName(hero.name); + engine.start(); + + const telegramId = getTelegramUserId() ?? 1; + getTowns() + .then(async (t) => { + setTowns(t); + const townNPCMap = new Map(); + try { + const npcResults = await Promise.allSettled( + t.map((town) => getTownNPCs(town.id).then((npcs) => ({ townId: town.id, npcs }))), + ); + for (const result of npcResults) { + if (result.status === 'fulfilled') { + townNPCMap.set(result.value.townId, result.value.npcs); + } + } + } catch { /* ignore */ } + const townDataList = t.map((town) => townToTownData(town, townNPCMap.get(town.id))); + engine.setTowns(townDataList); + const allNPCs: NPCData[] = []; + for (const td of townDataList) { + if (td.npcs) allNPCs.push(...td.npcs); + } + engine.setNPCs(allNPCs); + }) + .catch(() => console.warn('[App] Could not fetch towns')); + getHeroQuests(telegramId) + .then((q) => setHeroQuests(q)) + .catch(() => console.warn('[App] Could not fetch hero quests')); + getAdventureLog(telegramId, 50) + .then((serverLog) => { + if (serverLog.length > 0) { + const mapped: AdventureLogEntry[] = serverLog.map((entry, i) => ({ + id: i + 1, + message: entry.message, + timestamp: new Date(entry.createdAt).getTime(), + })); + logIdCounter.current = mapped.length; + setLogEntries(mapped); + } + }) + .catch(() => console.warn('[App] Could not fetch adventure log')); + getAchievements(telegramId) + .then((a) => { prevAchievementsRef.current = a; setAchievements(a); }) + .catch(() => {}); + getDailyTasks(telegramId) + .then((t) => setDailyTasks(t)) + .catch(() => {}); + } + }, []); + + const handleClaimDailyTask = useCallback((taskId: string) => { + const telegramId = getTelegramUserId() ?? 1; + claimDailyTask(taskId, telegramId) + .then((hero) => { + const merged = heroResponseToState(hero); + const engine = engineRef.current; + if (engine) { + const pos = engine.gameState.hero?.position; + if (pos) merged.position = pos; + engine.applyHeroState(merged); + } + setToast({ message: 'Daily task reward claimed!', color: '#ffd700' }); + hapticNotification('success'); + getDailyTasks(telegramId).then((t) => setDailyTasks(t)).catch(() => {}); + }) + .catch((err) => { + console.warn('[App] Failed to claim daily task:', err); + setToast({ message: 'Failed to claim reward', color: '#ff4444' }); + }); + }, []); + + const handleUsePotion = useCallback(() => { + const ws = wsRef.current; + const hero = engineRef.current?.gameState.hero; + if (!hero || (hero.potions ?? 0) <= 0) return; + + // Send via WS + if (ws) { + sendUsePotion(ws); + } + hero.potions-- + + addLogEntry('Used healing potion'); + hapticImpact('medium'); + }, [addLogEntry]); + + // ---- NPC Interaction Handlers ---- + + const handleNPCViewQuests = useCallback((npc: NPCData) => { + const matchedNPC: NPC = { + id: npc.id, + townId: 0, + name: npc.name, + type: npc.type, + offsetX: 0, + offsetY: 0, + }; + setSelectedNPC(matchedNPC); + setNpcInteractionDismissed(npc.id); + }, []); + + const handleNPCBuyPotion = useCallback((npc: NPCData) => { + const telegramId = getTelegramUserId() ?? 1; + buyPotion(telegramId) + .then((hero) => { + hapticImpact('medium'); + setToast({ message: 'Bought a potion for 50 gold', color: '#88dd88' }); + handleNPCHeroUpdated(hero); + addLogEntry(`Bought potion from ${npc.name}`); + }) + .catch((err) => { + console.warn('[App] Failed to buy potion:', err); + if (err instanceof ApiError) { + try { + const j = JSON.parse(err.body) as { error?: string }; + setToast({ message: j.error ?? 'Failed to buy potion', color: '#ff4444' }); + } catch { + setToast({ message: 'Failed to buy potion', color: '#ff4444' }); + } + } + }); + }, [handleNPCHeroUpdated, addLogEntry]); + + const handleNPCHeal = useCallback((npc: NPCData) => { + const telegramId = getTelegramUserId() ?? 1; + healAtNPC(telegramId) + .then((hero) => { + hapticImpact('medium'); + setToast({ message: 'Healed to full HP!', color: '#44cc44' }); + handleNPCHeroUpdated(hero); + addLogEntry(`Healed at ${npc.name}`); + }) + .catch((err) => { + console.warn('[App] Failed to heal:', err); + if (err instanceof ApiError) { + try { + const j = JSON.parse(err.body) as { error?: string }; + setToast({ message: j.error ?? 'Failed to heal', color: '#ff4444' }); + } catch { + setToast({ message: 'Failed to heal', color: '#ff4444' }); + } + } + }); + }, [handleNPCHeroUpdated, addLogEntry]); + + const handleNPCInteractionDismiss = useCallback(() => { + if (nearestNPC) { + setNpcInteractionDismissed(nearestNPC.id); + } + }, [nearestNPC]); + + // ---- Wandering NPC Encounter Handlers (via WS) ---- + + const handleWanderingAccept = useCallback(() => { + const ws = wsRef.current; + if (ws) { + sendNPCAlmsAccept(ws); + } + setWanderingNPC(null); + addLogEntry('Accepted wandering merchant offer'); + }, [addLogEntry]); + + const handleWanderingDecline = useCallback(() => { + const ws = wsRef.current; + if (ws) { + sendNPCAlmsDecline(ws); + } + setWanderingNPC(null); + addLogEntry('Declined wandering merchant'); + }, [addLogEntry]); + + // Show NPC interaction when near an NPC and not dismissed + const showNPCInteraction = + nearestNPC !== null && + npcInteractionDismissed !== nearestNPC.id && + (gameState.phase === GamePhase.Walking || gameState.phase === GamePhase.InTown) && + !selectedNPC; + + return ( +
+ {/* PixiJS Canvas */} +
+ + {/* React UI Overlay */} + + + {/* Floating Damage Numbers */} + + + {/* Name Entry Screen */} + {needsName && } + + {/* Death Screen */} + + + {/* Toast Notification */} + {toast && ( + setToast(null)} + /> + )} + + {/* Town Name Indicator */} + {currentTown && ( +
+ {currentTown.name} +
+ )} + + {/* Quest Log Toggle Button */} + {gameState.hero && ( + + )} + + {/* Quest Log Panel */} + {questLogOpen && ( + setQuestLogOpen(false)} + /> + )} + + {/* NPC Proximity Interaction */} + {showNPCInteraction && nearestNPC && ( + + )} + + {/* NPC Dialog */} + {selectedNPC && ( + setSelectedNPC(null)} + onQuestsChanged={refreshHeroQuests} + onHeroUpdated={handleNPCHeroUpdated} + onToast={(message, color) => setToast({ message, color })} + /> + )} + + {/* Wandering NPC Encounter Popup */} + {wanderingNPC && ( + + )} + + {/* Daily Tasks (top-right) */} + {gameState.hero && } + + {/* Minimap (below daily tasks, top-right) */} + {gameState.hero && ( + + )} + + {/* Achievements Panel */} + {gameState.hero && } + + {/* Adventure Log */} + + + {/* Offline Report Overlay */} + {offlineReport && ( + setOfflineReport(null)} + /> + )} + + {/* Connection Status Banner */} + {wsEverConnected && !wsConnected && ( +
+ Reconnecting... +
+ )} + + {/* Fatal connection error */} + {connectionError && ( +
+
⚠
+
Connection Failed
+
{connectionError}
+ +
+ )} +
+ ); +} diff --git a/frontend/src/game/camera.ts b/frontend/src/game/camera.ts new file mode 100644 index 0000000..a21f985 --- /dev/null +++ b/frontend/src/game/camera.ts @@ -0,0 +1,91 @@ +import { + CAMERA_FOLLOW_LERP, + SHAKE_MAGNITUDE, + SHAKE_DURATION_MS, +} from '../shared/constants'; + +/** + * Camera controller with soft follow and screen shake. + * + * The camera tracks a target position (the hero's screen-space position) + * and applies a smooth lerp to follow. Screen shake is applied as an + * additive offset that decays over time. + */ +export class Camera { + /** Current camera position (center of view in world-screen space) */ + x = 0; + y = 0; + + /** Target position to follow */ + private targetX = 0; + private targetY = 0; + + /** Shake state */ + private shakeTimeRemaining = 0; + private shakeMagnitude = SHAKE_MAGNITUDE; + private shakeOffsetX = 0; + private shakeOffsetY = 0; + + /** Lerp factor (0..1) */ + private lerpFactor: number; + + constructor(lerpFactor = CAMERA_FOLLOW_LERP) { + this.lerpFactor = lerpFactor; + } + + /** Set the target position for the camera to follow */ + setTarget(x: number, y: number): void { + this.targetX = x; + this.targetY = y; + } + + /** Snap the camera instantly to the target (no lerp) */ + snapToTarget(): void { + this.x = this.targetX; + this.y = this.targetY; + } + + /** Trigger a screen shake effect (e.g., on hit) */ + shake(magnitude = SHAKE_MAGNITUDE, durationMs = SHAKE_DURATION_MS): void { + this.shakeMagnitude = magnitude; + this.shakeTimeRemaining = durationMs; + } + + /** Update camera position. Call once per frame with delta time in ms. */ + update(dtMs: number): void { + // Soft follow via linear interpolation + this.x += (this.targetX - this.x) * this.lerpFactor; + this.y += (this.targetY - this.y) * this.lerpFactor; + + // Update screen shake + if (this.shakeTimeRemaining > 0) { + this.shakeTimeRemaining -= dtMs; + const intensity = Math.max(0, this.shakeTimeRemaining / SHAKE_DURATION_MS); + const mag = this.shakeMagnitude * intensity; + this.shakeOffsetX = (Math.random() * 2 - 1) * mag; + this.shakeOffsetY = (Math.random() * 2 - 1) * mag; + } else { + this.shakeOffsetX = 0; + this.shakeOffsetY = 0; + } + } + + /** Get the final camera X including shake offset */ + get finalX(): number { + return this.x + this.shakeOffsetX; + } + + /** Get the final camera Y including shake offset */ + get finalY(): number { + return this.y + this.shakeOffsetY; + } + + /** + * Apply camera transform to a PixiJS container. + * The container is shifted so the camera target appears at screen center. + */ + applyTo(container: { x: number; y: number }, screenWidth: number, screenHeight: number): void { + container.x = screenWidth / 2 - this.finalX; + container.y = screenHeight / 2 - this.finalY; + } +} diff --git a/frontend/src/game/enemyVisuals.ts b/frontend/src/game/enemyVisuals.ts new file mode 100644 index 0000000..f19b376 --- /dev/null +++ b/frontend/src/game/enemyVisuals.ts @@ -0,0 +1,640 @@ +import { Graphics } from 'pixi.js'; +import { EnemyType } from './types'; + +export type BodyShape = 'diamond' | 'round' | 'wide' | 'tall' | 'spiky'; +export type HeadShape = 'circle' | 'horns' | 'crown' | 'none' | 'fangs' | 'helmet'; + +export interface EnemyVisualConfig { + bodyColor: number; + strokeColor: number; + headColor: number; + headStrokeColor: number; + size: number; + bodyShape: BodyShape; + headShape: HeadShape; + glowColor?: number; + isElite: boolean; + drawExtras?: (gfx: Graphics, cx: number, cy: number, size: number, now: number) => void; +} + +function getBodyTopY(cy: number, size: number, shape: BodyShape): number { + switch (shape) { + case 'diamond': return cy - size; + case 'round': return cy - size * 0.75; + case 'wide': return cy - size * 0.6; + case 'tall': return cy - size * 1.1; + case 'spiky': return cy - size * 1.1; + } +} + +function drawBody( + gfx: Graphics, cx: number, cy: number, size: number, + shape: BodyShape, color: number, strokeColor: number, +): void { + switch (shape) { + case 'diamond': + gfx.poly([cx, cy - size, cx + size * 0.7, cy, cx, cy + size * 0.6, cx - size * 0.7, cy]); + break; + case 'round': + gfx.ellipse(cx, cy - size * 0.2, size * 0.65, size * 0.55); + break; + case 'wide': + gfx.poly([cx, cy - size * 0.6, cx + size, cy, cx, cy + size * 0.4, cx - size, cy]); + break; + case 'tall': + gfx.poly([cx, cy - size * 1.1, cx + size * 0.45, cy, cx, cy + size * 0.5, cx - size * 0.45, cy]); + break; + case 'spiky': + gfx.poly([ + cx, cy - size * 1.1, + cx + size * 0.35, cy - size * 0.4, + cx + size * 0.8, cy - size * 0.15, + cx + size * 0.4, cy + size * 0.15, + cx, cy + size * 0.6, + cx - size * 0.4, cy + size * 0.15, + cx - size * 0.8, cy - size * 0.15, + cx - size * 0.35, cy - size * 0.4, + ]); + break; + } + gfx.fill({ color }); + gfx.stroke({ color: strokeColor, width: 2 }); +} + +function drawHead( + gfx: Graphics, cx: number, bodyTop: number, + shape: HeadShape, color: number, strokeColor: number, +): void { + if (shape === 'none') return; + + const headY = bodyTop - 5; + const r = 5; + + switch (shape) { + case 'circle': + gfx.circle(cx, headY, r); + gfx.fill({ color }); + gfx.stroke({ color: strokeColor, width: 1.5 }); + break; + + case 'horns': + gfx.circle(cx, headY, r); + gfx.fill({ color }); + gfx.stroke({ color: strokeColor, width: 1.5 }); + gfx.poly([cx - 4, headY - 2, cx - 7, headY - 10, cx - 1, headY - 4]); + gfx.fill({ color: strokeColor }); + gfx.poly([cx + 4, headY - 2, cx + 7, headY - 10, cx + 1, headY - 4]); + gfx.fill({ color: strokeColor }); + break; + + case 'crown': + gfx.circle(cx, headY, r); + gfx.fill({ color }); + gfx.stroke({ color: strokeColor, width: 1.5 }); + gfx.poly([ + cx - 6, headY - 3, + cx - 4, headY - 10, + cx - 1, headY - 6, + cx, headY - 12, + cx + 1, headY - 6, + cx + 4, headY - 10, + cx + 6, headY - 3, + ]); + gfx.fill({ color: 0xFFDD44 }); + gfx.stroke({ color: 0xCCAA22, width: 1 }); + break; + + case 'fangs': + gfx.circle(cx, headY, r); + gfx.fill({ color }); + gfx.stroke({ color: strokeColor, width: 1.5 }); + gfx.poly([cx - 3, headY + 3, cx - 1.5, headY + 8, cx, headY + 3]); + gfx.fill({ color: 0xEEEEDD }); + gfx.poly([cx, headY + 3, cx + 1.5, headY + 8, cx + 3, headY + 3]); + gfx.fill({ color: 0xEEEEDD }); + break; + + case 'helmet': + gfx.rect(cx - 6, headY - 6, 12, 10); + gfx.fill({ color }); + gfx.stroke({ color: strokeColor, width: 1.5 }); + gfx.rect(cx - 4, headY - 1, 8, 2.5); + gfx.fill({ color: 0x222233 }); + gfx.rect(cx - 1.5, headY - 8, 3, 4); + gfx.fill({ color: strokeColor }); + break; + } +} + +// --------------------------------------------------------------------------- +// Visual configs for all 13 enemy types +// --------------------------------------------------------------------------- + +export const ENEMY_VISUALS: Record = { + + // ======================================================================= + // BASE ENEMIES + // ======================================================================= + + [EnemyType.Wolf]: { + bodyColor: 0x808075, + strokeColor: 0x5A5A50, + headColor: 0x909085, + headStrokeColor: 0x6A6A60, + size: 12, + bodyShape: 'diamond', + headShape: 'fangs', + isElite: false, + drawExtras(gfx, cx, cy, size, now) { + const headY = cy - size - 5; + // Pointed ears + gfx.poly([cx - 3, headY - 2, cx - 5, headY - 7, cx - 1, headY - 3]); + gfx.fill({ color: 0x707065 }); + gfx.poly([cx + 3, headY - 2, cx + 5, headY - 7, cx + 1, headY - 3]); + gfx.fill({ color: 0x707065 }); + // Wagging tail + const wag = Math.sin(now * 0.01) * 3; + gfx.poly([ + cx - size * 0.5, cy + size * 0.3, + cx - size * 0.9 + wag, cy + size * 0.1, + cx - size * 0.5, cy + size * 0.45, + ]); + gfx.fill({ color: 0x6A6A5A }); + }, + }, + + [EnemyType.Boar]: { + bodyColor: 0x8B6544, + strokeColor: 0x6A4C33, + headColor: 0x9B7554, + headStrokeColor: 0x7A5C43, + size: 16, + bodyShape: 'wide', + headShape: 'circle', + isElite: false, + drawExtras(gfx, cx, cy, size) { + const headY = cy - size * 0.6 - 5; + // Upward-curving tusks + gfx.poly([cx - 4, headY + 1, cx - 6, headY - 6, cx - 2, headY]); + gfx.fill({ color: 0xEEEEDD }); + gfx.poly([cx + 4, headY + 1, cx + 6, headY - 6, cx + 2, headY]); + gfx.fill({ color: 0xEEEEDD }); + // Muscular back hump + gfx.ellipse(cx, cy - size * 0.45, size * 0.4, size * 0.18); + gfx.fill({ color: 0x7A5534, alpha: 0.7 }); + }, + }, + + [EnemyType.Zombie]: { + bodyColor: 0x5A7A4A, + strokeColor: 0x3A5A2A, + headColor: 0x6A8A5A, + headStrokeColor: 0x4A6A3A, + size: 14, + bodyShape: 'diamond', + headShape: 'circle', + isElite: false, + drawExtras(gfx, cx, cy, size, now) { + // Green poison fog at feet + const pulse = Math.sin(now * 0.003) * 0.15 + 0.3; + gfx.ellipse(cx - 3, cy + size * 0.5, size * 0.8, 3); + gfx.fill({ color: 0x44AA33, alpha: pulse }); + gfx.ellipse(cx + 4, cy + size * 0.55, size * 0.6, 2.5); + gfx.fill({ color: 0x33BB22, alpha: pulse * 0.8 }); + }, + }, + + [EnemyType.Spider]: { + bodyColor: 0x6B3A7A, + strokeColor: 0x4A2A5A, + headColor: 0x6B3A7A, + headStrokeColor: 0x4A2A5A, + size: 11, + bodyShape: 'round', + headShape: 'none', + isElite: false, + drawExtras(gfx, cx, cy, size, now) { + const wiggle = Math.sin(now * 0.008) * 1.5; + // 3 legs per side (6 total, thin triangles) + for (let i = 0; i < 3; i++) { + const yOff = (i - 1) * 4; + const baseY = cy - size * 0.2 + yOff; + const spread = size * 0.6 + i * 2; + const tipY = baseY - 2 + wiggle * (i % 2 === 0 ? 1 : -1); + // Left leg + gfx.poly([ + cx - size * 0.5, baseY, + cx - size * 0.5 - spread, tipY, + cx - size * 0.5 - spread + 0.8, tipY + 1.5, + ]); + gfx.fill({ color: 0x5A2A6A, alpha: 0.9 }); + // Right leg + gfx.poly([ + cx + size * 0.5, baseY, + cx + size * 0.5 + spread, tipY, + cx + size * 0.5 + spread - 0.8, tipY + 1.5, + ]); + gfx.fill({ color: 0x5A2A6A, alpha: 0.9 }); + } + // Red eyes + gfx.circle(cx - 2.5, cy - size * 0.4, 1.5); + gfx.fill({ color: 0xFF2222 }); + gfx.circle(cx + 2.5, cy - size * 0.4, 1.5); + gfx.fill({ color: 0xFF2222 }); + }, + }, + + [EnemyType.Orc]: { + bodyColor: 0x4A7A3A, + strokeColor: 0x2A5A1A, + headColor: 0x888899, + headStrokeColor: 0x666677, + size: 15, + bodyShape: 'wide', + headShape: 'helmet', + isElite: false, + drawExtras(gfx, cx, cy, size) { + // Shoulder armor plates + gfx.rect(cx - size - 2, cy - size * 0.3, 5, 6); + gfx.fill({ color: 0x666677 }); + gfx.stroke({ color: 0x555566, width: 1 }); + gfx.rect(cx + size - 3, cy - size * 0.3, 5, 6); + gfx.fill({ color: 0x666677 }); + gfx.stroke({ color: 0x555566, width: 1 }); + }, + }, + + [EnemyType.SkeletonArcher]: { + bodyColor: 0xD4C8AA, + strokeColor: 0xAA9E80, + headColor: 0xE0D8BB, + headStrokeColor: 0xBBB099, + size: 13, + bodyShape: 'tall', + headShape: 'circle', + isElite: false, + drawExtras(gfx, cx, cy, size) { + // Bow on right side + const bowX = cx + size * 0.6; + const bowMid = cy - size * 0.3; + gfx.poly([bowX, bowMid - 8, bowX + 3, bowMid, bowX, bowMid + 8, bowX + 2, bowMid]); + gfx.stroke({ color: 0x8B7355, width: 1.5 }); + // Bowstring + gfx.poly([bowX, bowMid - 8, bowX - 1, bowMid, bowX, bowMid + 8]); + gfx.stroke({ color: 0xCCCCBB, width: 0.7, alpha: 0.6 }); + // Rib lines for skeletal look + const ribs: [number, number][] = [[-0.5, 4], [-0.2, 3.5], [0.1, 3]]; + for (const [yFrac, w] of ribs) { + gfx.rect(cx - w / 2, cy + size * yFrac, w, 1); + gfx.fill({ color: 0xBBB099, alpha: 0.5 }); + } + }, + }, + + [EnemyType.BattleLizard]: { + bodyColor: 0x6B7A3A, + strokeColor: 0x4B5A1A, + headColor: 0x6B7A3A, + headStrokeColor: 0x4B5A1A, + size: 16, + bodyShape: 'wide', + headShape: 'none', + isElite: false, + drawExtras(gfx, cx, cy, size) { + // Scale pattern (small diamonds across body) + const sc = 0x5A6A2A; + for (let row = 0; row < 2; row++) { + for (let col = -1; col <= 1; col++) { + const sx = cx + col * 6; + const sy = cy - size * 0.15 + row * 5; + gfx.poly([sx, sy - 2, sx + 2.5, sy, sx, sy + 2, sx - 2.5, sy]); + gfx.fill({ color: sc, alpha: 0.5 }); + } + } + // Snout bump (head substitute) + const topY = cy - size * 0.6; + gfx.ellipse(cx, topY - 4, 4.5, 3); + gfx.fill({ color: 0x7B8A4A }); + gfx.stroke({ color: 0x5B6A2A, width: 1 }); + // Yellow reptile eyes + gfx.circle(cx - 2, topY - 5, 1.2); + gfx.fill({ color: 0xDDAA22 }); + gfx.circle(cx + 2, topY - 5, 1.2); + gfx.fill({ color: 0xDDAA22 }); + // Tail extending behind + gfx.poly([ + cx - size * 0.7, cy + size * 0.2, + cx - size - 5, cy + size * 0.45, + cx - size * 0.6, cy + size * 0.35, + ]); + gfx.fill({ color: 0x5A6A2A }); + }, + }, + + // ======================================================================= + // ELITE ENEMIES + // ======================================================================= + + [EnemyType.FireDemon]: { + bodyColor: 0xCC4422, + strokeColor: 0xAA2211, + headColor: 0xDD5533, + headStrokeColor: 0xBB3322, + size: 15, + bodyShape: 'spiky', + headShape: 'horns', + glowColor: 0xFF6600, + isElite: true, + drawExtras(gfx, cx, cy, size, now) { + const headY = cy - size * 1.1 - 5; + const f1 = Math.sin(now * 0.008) * 3; + const f2 = Math.cos(now * 0.011) * 2; + const f3 = Math.sin(now * 0.014 + 1) * 2.5; + // Main flame + gfx.poly([cx - 3, headY - 6, cx, headY - 14 + f1, cx + 3, headY - 6]); + gfx.fill({ color: 0xFF6600, alpha: 0.85 }); + // Side flames + gfx.poly([cx + 3, headY - 4, cx + 5, headY - 11 + f2, cx + 7, headY - 4]); + gfx.fill({ color: 0xFFAA00, alpha: 0.7 }); + gfx.poly([cx - 7, headY - 4, cx - 5, headY - 10 + f3, cx - 3, headY - 4]); + gfx.fill({ color: 0xFF4400, alpha: 0.65 }); + // Bright inner core + gfx.poly([cx - 1.5, headY - 4, cx, headY - 9 + f2, cx + 1.5, headY - 4]); + gfx.fill({ color: 0xFFDD44, alpha: 0.9 }); + }, + }, + + [EnemyType.IceGuardian]: { + bodyColor: 0x44AADD, + strokeColor: 0x2288BB, + headColor: 0x99CCDD, + headStrokeColor: 0x77AABB, + size: 16, + bodyShape: 'diamond', + headShape: 'helmet', + glowColor: 0x44CCFF, + isElite: true, + drawExtras(gfx, cx, cy, size, now) { + const pulse = Math.sin(now * 0.003) * 0.2 + 0.8; + // Left ice crystal + gfx.poly([ + cx - size * 0.7 - 1, cy - 2, + cx - size * 0.7 - 6, cy - 10, + cx - size * 0.7 - 3, cy, + ]); + gfx.fill({ color: 0xAADDFF, alpha: pulse }); + gfx.stroke({ color: 0x88CCFF, width: 0.8, alpha: pulse }); + // Right ice crystal + gfx.poly([ + cx + size * 0.7 + 1, cy - 3, + cx + size * 0.7 + 7, cy - 9, + cx + size * 0.7 + 3, cy, + ]); + gfx.fill({ color: 0x99CCEE, alpha: pulse }); + gfx.stroke({ color: 0x77AADD, width: 0.8, alpha: pulse }); + // Top crystal spike + gfx.poly([cx - 2, cy - size - 12, cx, cy - size - 18, cx + 2, cy - size - 12]); + gfx.fill({ color: 0xBBEEFF, alpha: pulse * 0.9 }); + // Frost sparkles (blink on/off) + if (Math.sin(now * 0.006) > 0.5) { + gfx.circle(cx - size * 0.5, cy - size * 0.7, 1); + gfx.fill({ color: 0xFFFFFF, alpha: 0.8 }); + gfx.circle(cx + size * 0.6, cy - size * 0.3, 1); + gfx.fill({ color: 0xFFFFFF, alpha: 0.7 }); + } + }, + }, + + [EnemyType.SkeletonKing]: { + bodyColor: 0xCCBB77, + strokeColor: 0xAA9955, + headColor: 0xDDCC88, + headStrokeColor: 0xBBAA66, + size: 16, + bodyShape: 'tall', + headShape: 'crown', + glowColor: 0xAA44FF, + isElite: true, + drawExtras(gfx, cx, cy, size, now) { + // Orbiting bone fragments + const angle = now * 0.002; + const orbitR = size + 10; + for (let i = 0; i < 3; i++) { + const a = angle + (i * Math.PI * 2) / 3; + const bx = cx + Math.cos(a) * orbitR; + const by = cy - size * 0.3 + Math.sin(a) * orbitR * 0.4; + gfx.rect(bx - 1, by - 2.5, 2, 5); + gfx.fill({ color: 0xDDCCAA, alpha: 0.75 }); + } + // Rib lines for skeletal body + gfx.rect(cx - 2.5, cy - size * 0.5, 5, 1); + gfx.fill({ color: 0xAA9955, alpha: 0.5 }); + gfx.rect(cx - 2, cy - size * 0.15, 4, 1); + gfx.fill({ color: 0xAA9955, alpha: 0.5 }); + }, + }, + + [EnemyType.WaterElement]: { + bodyColor: 0x33AACC, + strokeColor: 0x1188AA, + headColor: 0x33AACC, + headStrokeColor: 0x1188AA, + size: 14, + bodyShape: 'round', + headShape: 'none', + glowColor: 0x33DDFF, + isElite: true, + drawExtras(gfx, cx, cy, size, now) { + // Translucent highlight for watery look + gfx.ellipse(cx, cy - size * 0.25, size * 0.4, size * 0.35); + gfx.fill({ color: 0x77DDFF, alpha: 0.3 }); + // Animated ripple rings at base + const ripple = (now * 0.003) % (Math.PI * 2); + const r1 = size * 0.5 + Math.sin(ripple) * 4; + gfx.ellipse(cx, cy + size * 0.3, r1 + 4, (r1 + 4) * 0.35); + gfx.stroke({ color: 0x44DDFF, width: 1, alpha: 0.35 + Math.sin(ripple) * 0.15 }); + const r2 = size * 0.5 + Math.sin(ripple + 1.5) * 3; + gfx.ellipse(cx, cy + size * 0.4, r2 + 7, (r2 + 7) * 0.3); + gfx.stroke({ color: 0x33CCEE, width: 0.8, alpha: 0.25 + Math.sin(ripple + 1.5) * 0.1 }); + // Water droplets floating upward + const d1 = cy - size * 0.5 - ((now * 0.02) % 12); + const d2 = cy - size * 0.3 - ((now * 0.018 + 6) % 10); + gfx.circle(cx - 3, d1, 1.2); + gfx.fill({ color: 0x88EEFF, alpha: 0.6 }); + gfx.circle(cx + 4, d2, 1); + gfx.fill({ color: 0x77DDFF, alpha: 0.5 }); + }, + }, + + [EnemyType.ForestWarden]: { + bodyColor: 0x3A6A2A, + strokeColor: 0x1A4A0A, + headColor: 0x3A6A2A, + headStrokeColor: 0x1A4A0A, + size: 18, + bodyShape: 'wide', + headShape: 'none', + glowColor: 0x44CC44, + isElite: true, + drawExtras(gfx, cx, cy, size, now) { + // Bark texture (horizontal grooves) + for (let i = 0; i < 3; i++) { + const ly = cy - size * 0.25 + i * 5; + const lw = size * (0.5 - i * 0.08); + gfx.rect(cx - lw, ly, lw * 2, 1.5); + gfx.fill({ color: 0x2A4A1A, alpha: 0.4 }); + } + // Tree canopy crown on top + const topY = cy - size * 0.6; + gfx.ellipse(cx, topY - 7, 9, 5.5); + gfx.fill({ color: 0x2D7A1D, alpha: 0.9 }); + gfx.ellipse(cx - 4, topY - 4, 6, 4); + gfx.fill({ color: 0x358A25, alpha: 0.85 }); + gfx.ellipse(cx + 4, topY - 4, 6, 4); + gfx.fill({ color: 0x358A25, alpha: 0.85 }); + // Glowing eyes peering from canopy + gfx.circle(cx - 3, topY - 6, 1.5); + gfx.fill({ color: 0x88FF44 }); + gfx.circle(cx + 3, topY - 6, 1.5); + gfx.fill({ color: 0x88FF44 }); + // Root tendrils at base + const sway = Math.sin(now * 0.002) * 1.5; + gfx.poly([ + cx - size * 0.6, cy + size * 0.3, + cx - size - 3 + sway, cy + size * 0.5, + cx - size * 0.5, cy + size * 0.4, + ]); + gfx.fill({ color: 0x4A5A2A, alpha: 0.7 }); + gfx.poly([ + cx + size * 0.5, cy + size * 0.3, + cx + size + 2 - sway, cy + size * 0.5, + cx + size * 0.6, cy + size * 0.4, + ]); + gfx.fill({ color: 0x4A5A2A, alpha: 0.7 }); + }, + }, + + [EnemyType.LightningTitan]: { + bodyColor: 0x5577CC, + strokeColor: 0x3355AA, + headColor: 0x6688DD, + headStrokeColor: 0x4466BB, + size: 20, + bodyShape: 'tall', + headShape: 'horns', + glowColor: 0xFFDD44, + isElite: true, + drawExtras(gfx, cx, cy, size, now) { + // Lightning bolt zigzag (intermittent) + const strike = Math.sin(now * 0.015); + if (strike > 0.2) { + const alpha = Math.min(1, (strike - 0.2) * 1.25); + const lx = cx + Math.sin(now * 0.02) * 5; + const topY = cy - size * 1.1 - 5; + gfx.poly([ + lx - 1, topY - 8, + lx + 4, topY - 2, + lx, topY - 1, + lx + 3, topY + 6, + lx - 2, topY + 7, + lx + 1, topY + 14, + lx - 1, topY + 7, + lx + 1, topY + 6, + lx - 3, topY, + lx + 1, topY - 1, + lx - 2, topY - 2, + ]); + gfx.fill({ color: 0xFFFF44, alpha: alpha * 0.7 }); + gfx.stroke({ color: 0xFFFFAA, width: 1, alpha }); + } + // Static sparks orbiting the body + const sparkPhase = (now * 0.01) % (Math.PI * 2); + for (let i = 0; i < 4; i++) { + const a = sparkPhase + (i * Math.PI) / 2; + if (Math.sin(a + now * 0.005) > 0.6) { + const sx = cx + Math.cos(a) * (size * 0.8); + const sy = cy + Math.sin(a) * (size * 0.4) - size * 0.3; + gfx.circle(sx, sy, 1.5); + gfx.fill({ color: 0xFFFF88, alpha: 0.85 }); + } + } + }, + }, +}; + +// --------------------------------------------------------------------------- +// Main draw function — replaces the generic red-diamond drawEnemy +// --------------------------------------------------------------------------- + +export function drawEnemyByType( + gfx: Graphics, + wx: number, + wy: number, + hp: number, + maxHp: number, + enemyType: EnemyType, + now: number, + worldToScreenFn: (wx: number, wy: number) => { x: number; y: number }, +): void { + gfx.clear(); + + const config = ENEMY_VISUALS[enemyType]; + if (!config) return; + + const iso = worldToScreenFn(wx, wy); + const sway = Math.sin(now * 0.004) * 2; + const cx = iso.x; + const cy = iso.y + sway; + const { size } = config; + + // 1. Shadow + gfx.ellipse(cx, cy + 8, size + 2, 5); + gfx.fill({ color: 0x000000, alpha: 0.3 }); + + // 2. Elite glow (behind body) + if (config.isElite && config.glowColor != null) { + const pulse = Math.sin(now * 0.003) * 0.12 + 0.22; + gfx.circle(cx, cy - size * 0.2, size + 8); + gfx.fill({ color: config.glowColor, alpha: pulse }); + } + + // 3. Body + drawBody(gfx, cx, cy, size, config.bodyShape, config.bodyColor, config.strokeColor); + + // 4. Head + const bodyTop = getBodyTopY(cy, size, config.bodyShape); + drawHead(gfx, cx, bodyTop, config.headShape, config.headColor, config.headStrokeColor); + + // 5. Type-specific decorations + config.drawExtras?.(gfx, cx, cy, size, now); + + // 6. HP bar + const barWidth = 30; + const barHeight = 4; + const headHeight = config.headShape === 'none' + ? (config.isElite ? 12 : 6) + : config.headShape === 'crown' ? 22 + : config.headShape === 'horns' ? 18 + : config.headShape === 'helmet' ? 16 + : 14; + const hpBarY = bodyTop - headHeight - 4; + + gfx.rect(cx - barWidth / 2, hpBarY, barWidth, barHeight); + gfx.fill({ color: 0x000000, alpha: 0.6 }); + + const hpRatio = maxHp > 0 ? Math.max(0, hp / maxHp) : 0; + if (hpRatio > 0) { + gfx.rect(cx - barWidth / 2, hpBarY, barWidth * hpRatio, barHeight); + const hpColor = hpRatio > 0.5 ? 0xcc3333 : hpRatio > 0.25 ? 0xccaa22 : 0xff2222; + gfx.fill({ color: hpColor }); + } + + // Elite HP bar border + if (config.isElite) { + gfx.rect(cx - barWidth / 2, hpBarY, barWidth, barHeight); + gfx.stroke({ color: config.glowColor ?? 0xFFAA00, width: 1, alpha: 0.8 }); + } + + // Depth sorting + gfx.zIndex = cy + 100; +} diff --git a/frontend/src/game/engine.ts b/frontend/src/game/engine.ts new file mode 100644 index 0000000..977a4b9 --- /dev/null +++ b/frontend/src/game/engine.ts @@ -0,0 +1,821 @@ +import { + FIXED_DT_MS, + MAX_ACCUMULATED_MS, +} from '../shared/constants'; +import type { + GameState, + EnemyState, + HeroState, + FloatingDamageData, + LootDrop, + TownData, + NearbyHeroData, + NPCData, +} from './types'; +import { GamePhase } from './types'; +import { GameRenderer, worldToScreen } from './renderer'; +import { buildWorldTerrainContext } from './procedural'; +import { Camera } from './camera'; +import { getViewport } from '../shared/telegram'; + +/** + * Server-authoritative game engine. + * + * This engine does NOT simulate walking, combat, encounters, or any + * game logic. All state comes from the server via WebSocket messages. + * + * Responsibilities: + * - Hold current game state (hero, enemy, phase) + * - Interpolate hero position between server updates (2 Hz -> 60 fps) + * - Run the requestAnimationFrame render loop + * - Camera follow + shake + * - Emit state change and damage callbacks for React UI + * - Thought bubble display (server-driven rest state) + */ + +// ---- Thought Bubble Pool ---- + +const HERO_THOUGHTS = [ + "I wonder what's ahead...", + 'Need better gear...', + 'Getting stronger!', + 'This forest is huge', + 'I smell adventure', + 'Gold... need more gold', + 'What was that sound?', + 'Time to rest a bit', + 'My sword needs sharpening', + 'Almost leveled up!', +]; + +// ---- Callbacks ---- + +export type DamageCallback = (damage: FloatingDamageData) => void; + +/** Drift threshold in world tiles before snapping to server position. */ +const POSITION_DRIFT_SNAP_THRESHOLD = 2.0; + +/** Interpolation window matching the server's 2 Hz send rate. */ +const MOVE_UPDATE_INTERVAL_S = 0.5; + +export class GameEngine { + renderer: GameRenderer; + camera: Camera; + + private _running = false; + private _rafId: number | null = null; + private _lastTime = 0; + private _accumulator = 0; + + /** Current game state (exposed to React via onStateChange) */ + private _gameState: GameState = { + phase: GamePhase.Walking, + hero: null, + enemy: null, + loot: null, + lastVictoryLoot: null, + tick: 0, + serverTimeMs: 0, + }; + + // ---- Server-driven position interpolation ---- + private _heroDisplayX = 0; + private _heroDisplayY = 0; + private _prevPositionX = 0; + private _prevPositionY = 0; + private _targetPositionX = 0; + private _targetPositionY = 0; + _moveTargetX = 0; + _moveTargetY = 0; + _heroSpeed = 0; + private _lastMoveUpdateTime = 0; + + /** Road waypoints from route_assigned, for optional path rendering. */ + _routeWaypoints: Array<{ x: number; y: number }> = []; + + /** Loot popup auto-clear timer */ + private _lootTimerMs = 0; + + /** Thought bubble text shown during rest pauses (null = hidden). */ + private _thoughtText: string | null = null; + private _thoughtStartMs = 0; + + /** Towns for map rendering */ + private _towns: TownData[] = []; + /** All NPCs from towns for rendering */ + private _allNPCs: NPCData[] = []; + /** Nearby heroes from the shared world (polled periodically) */ + private _nearbyHeroes: NearbyHeroData[] = []; + + /** Callbacks */ + private _onStateChange: ((state: GameState) => void) | null = null; + private _onDamage: DamageCallback | null = null; + private _handleResize: (() => void) | null = null; + + constructor() { + this.renderer = new GameRenderer(); + this.camera = new Camera(); + } + + get running(): boolean { + return this._running; + } + + get gameState(): GameState { + return this._gameState; + } + + /** Current thought text if hero is resting (null otherwise). */ + get thoughtText(): string | null { + return this._thoughtText; + } + + /** performance.now() when the thought started, for fade animation. */ + get thoughtStartMs(): number { + return this._thoughtStartMs; + } + + // ---- Callback Registration ---- + + /** Register a callback for game state changes (for React UI) */ + onStateChange(cb: (state: GameState) => void): void { + this._onStateChange = cb; + } + + /** Register a callback for damage events (floating numbers) */ + onDamage(cb: DamageCallback): void { + this._onDamage = cb; + } + + // ---- Data Setters (static data from REST init) ---- + + /** Set the hero display name on the renderer label. */ + setHeroName(name: string): void { + this.renderer.setHeroName(name); + } + + /** Set towns for map rendering. */ + setTowns(towns: TownData[]): void { + this._towns = towns; + this._syncWorldTerrainContext(); + } + + /** Set NPC data for rendering. */ + setNPCs(npcs: NPCData[]): void { + this._allNPCs = npcs; + } + + /** Update the list of nearby heroes for shared-world rendering. */ + setNearbyHeroes(heroes: NearbyHeroData[]): void { + this._nearbyHeroes = heroes; + } + + // ---- Server State Application ---- + + /** + * Initialize the engine with hero data from the REST init endpoint. + * This sets the initial state before WebSocket messages start arriving. + */ + initFromServer(hero: HeroState, serverHeroState?: string): void { + const serverDead = serverHeroState?.toLowerCase() === 'dead'; + const serverResting = serverHeroState?.toLowerCase() === 'resting'; + const serverInTown = serverHeroState?.toLowerCase() === 'in_town'; + + let phase = GamePhase.Walking; + if (hero.hp <= 0 || serverDead) phase = GamePhase.Dead; + else if (serverResting) phase = GamePhase.Resting; + else if (serverInTown) phase = GamePhase.InTown; + + this._gameState = { + phase, + hero, + enemy: null, + loot: null, + lastVictoryLoot: null, + tick: 0, + serverTimeMs: 0, + }; + + // Initialize display position + this._heroDisplayX = hero.position.x || 0; + this._heroDisplayY = hero.position.y || 0; + this._prevPositionX = this._heroDisplayX; + this._prevPositionY = this._heroDisplayY; + this._targetPositionX = this._heroDisplayX; + this._targetPositionY = this._heroDisplayY; + this._lastMoveUpdateTime = performance.now(); + this._lootTimerMs = 0; + + const heroScreen = worldToScreen(this._heroDisplayX, this._heroDisplayY); + this.camera.setTarget(heroScreen.x, heroScreen.y); + this.camera.snapToTarget(); + + if (phase === GamePhase.Resting || phase === GamePhase.InTown) { + this._showThought(); + } + + this._notifyStateChange(); + } + + /** + * Called when server sends hero_move (2 Hz). + * Smoothly interpolates between positions in the render loop. + */ + applyHeroMove( + x: number, + y: number, + targetX: number, + targetY: number, + speed: number, + ): void { + this._prevPositionX = this._heroDisplayX; + this._prevPositionY = this._heroDisplayY; + this._targetPositionX = x; + this._targetPositionY = y; + this._moveTargetX = targetX; + this._moveTargetY = targetY; + this._heroSpeed = speed; + this._lastMoveUpdateTime = performance.now(); + + // Update hero state position to server-known position + if (this._gameState.hero) { + this._gameState.hero.position.x = x; + this._gameState.hero.position.y = y; + } + + // Clear rest/thought when moving + if ( + this._gameState.phase === GamePhase.Resting || + this._gameState.phase === GamePhase.InTown + ) { + this._gameState = { ...this._gameState, phase: GamePhase.Walking }; + this._thoughtText = null; + } else if (this._gameState.phase !== GamePhase.Walking) { + // Don't override fighting/dead phase from move messages + } + } + + /** + * Called when server sends position_sync (every 10s). + * Snaps to server position if drift exceeds threshold. + */ + applyPositionSync(x: number, y: number, state: string): void { + const dx = this._heroDisplayX - x; + const dy = this._heroDisplayY - y; + const drift = Math.sqrt(dx * dx + dy * dy); + + if (drift > POSITION_DRIFT_SNAP_THRESHOLD) { + this._heroDisplayX = x; + this._heroDisplayY = y; + this._prevPositionX = x; + this._prevPositionY = y; + this._targetPositionX = x; + this._targetPositionY = y; + } + + if (this._gameState.hero) { + this._gameState.hero.position.x = x; + this._gameState.hero.position.y = y; + } + + // Sync phase from server state string + if (state === 'walking' && this._gameState.phase !== GamePhase.Fighting) { + this._gameState = { ...this._gameState, phase: GamePhase.Walking }; + this._thoughtText = null; + } + } + + /** + * Called when server sends route_assigned. + * Stores waypoints for optional path rendering. + */ + applyRouteAssigned( + waypoints: Array<{ x: number; y: number }>, + speed: number, + ): void { + this._routeWaypoints = waypoints; + this._heroSpeed = speed; + this._syncWorldTerrainContext(); + this._gameState = { ...this._gameState, phase: GamePhase.Walking }; + this._thoughtText = null; + this._notifyStateChange(); + } + + /** Rebuild procedural terrain context from towns + current route (ring + active polyline). */ + private _syncWorldTerrainContext(): void { + if (this._towns.length === 0) { + this.renderer.setWorldTerrainContext(null); + return; + } + const influences = this._towns.map((t) => ({ + id: t.id, + cx: t.centerX, + cy: t.centerY, + radius: t.radius, + biome: t.biome, + levelMin: t.levelMin, + })); + const route = + this._routeWaypoints.length >= 2 ? this._routeWaypoints : null; + this.renderer.setWorldTerrainContext( + buildWorldTerrainContext(influences, route), + ); + } + + /** + * Apply a full hero state snapshot from the server. + * Sent on WS connect, after level-up, revive, equipment change. + */ + applyHeroState(hero: HeroState): void { + const prevPos = this._gameState.hero?.position; + // Preserve display position if hero hasn't moved significantly + if (prevPos) { + const dx = (hero.position.x || 0) - prevPos.x; + const dy = (hero.position.y || 0) - prevPos.y; + if (dx * dx + dy * dy < 0.01) { + hero.position = prevPos; + } + } + + this._gameState = { + ...this._gameState, + hero, + }; + this._notifyStateChange(); + } + + /** + * Called when server sends combat_start. + */ + applyCombatStart(enemy: EnemyState): void { + // Position enemy near hero + enemy.position = { + x: this._heroDisplayX + 1.5, + y: this._heroDisplayY - 0.5, + }; + + this._gameState = { + ...this._gameState, + phase: GamePhase.Fighting, + enemy, + loot: null, + }; + this._lootTimerMs = 0; + this._thoughtText = null; + this._notifyStateChange(); + } + + /** + * Called when server sends attack. + * Updates HP values and emits floating damage numbers. + */ + applyAttack( + source: 'hero' | 'enemy' | 'potion', + damage: number, + isCrit: boolean, + heroHp: number, + enemyHp: number, + ): void { + if (this._gameState.hero) { + this._gameState.hero.hp = heroHp; + } + if (this._gameState.enemy) { + this._gameState.enemy.hp = enemyHp; + } + + // Emit floating damage at appropriate screen position + const viewport = getViewport(); + if (source === 'hero') { + // Damage on enemy (right side of screen) + this._emitDamage( + damage, + viewport.width / 2 + 60, + viewport.height / 2 - 30, + isCrit, + ); + } else if (source === 'enemy') { + // Damage on hero (left side of screen) + this._emitDamage( + damage, + viewport.width / 2 - 60, + viewport.height / 2 - 30, + false, + ); + } + // potion source: no floating damage + + this._notifyStateChange(); + } + + /** + * Called when server sends combat_end. + * Transitions back to walking phase. + */ + applyCombatEnd(): void { + this._gameState = { + ...this._gameState, + phase: GamePhase.Walking, + enemy: null, + }; + this._notifyStateChange(); + } + + /** + * Apply loot from combat_end for the popup UI. + */ + applyLoot(loot: LootDrop | null): void { + this._lootTimerMs = 0; + this._gameState = { + ...this._gameState, + loot, + lastVictoryLoot: loot != null ? loot : this._gameState.lastVictoryLoot, + }; + this._notifyStateChange(); + } + + /** + * Called when server sends hero_died. + */ + applyHeroDied(): void { + this._gameState = { + ...this._gameState, + phase: GamePhase.Dead, + }; + this._notifyStateChange(); + } + + /** + * Called when server sends hero_revived. + */ + applyHeroRevived(hp: number): void { + if (this._gameState.hero) { + this._gameState.hero.hp = hp; + } + this._gameState = { + ...this._gameState, + phase: GamePhase.Walking, + enemy: null, + }; + this._notifyStateChange(); + } + + /** + * Called when server sends town_enter. + */ + applyTownEnter(): void { + this._gameState = { + ...this._gameState, + phase: GamePhase.InTown, + }; + this._showThought(); + this._notifyStateChange(); + } + + /** Server simulated approach to a town NPC (quest / shop / healer). */ + applyTownNPCVisit(npcName: string, npcType: string): void { + const label = + npcType === 'merchant' + ? 'Shop' + : npcType === 'healer' + ? 'Healer' + : 'Quest'; + this._thoughtText = `${label}: ${npcName}`; + this._thoughtStartMs = performance.now(); + this._notifyStateChange(); + } + + /** + * Called when server sends town_exit. + */ + applyTownExit(): void { + this._gameState = { + ...this._gameState, + phase: GamePhase.Walking, + }; + this._thoughtText = null; + this._notifyStateChange(); + } + + // ---- Patch helpers for UI-driven optimistic updates ---- + + /** Merge server-side active buffs into the current hero. */ + patchHeroBuffs(activeBuffs: HeroState['activeBuffs']): void { + const hero = this._gameState.hero; + if (!hero) return; + this._gameState = { + ...this._gameState, + hero: { ...hero, activeBuffs }, + }; + this._notifyStateChange(); + } + + /** Merge buff quota fields. */ + patchHeroBuffQuota( + fields: Pick< + HeroState, + 'buffFreeChargesRemaining' | 'buffQuotaPeriodEnd' | 'buffCharges' + >, + ): void { + const hero = this._gameState.hero; + if (!hero) return; + this._gameState = { + ...this._gameState, + hero: { ...hero, ...fields }, + }; + this._notifyStateChange(); + } + + /** Patch server-derived combat stats after buff application. */ + patchHeroCombat( + combat: Pick< + HeroState, + 'damage' | 'defense' | 'attackSpeed' | 'activeBuffs' + >, + ): void { + const hero = this._gameState.hero; + if (!hero) return; + this._gameState = { + ...this._gameState, + hero: { + ...hero, + damage: combat.damage, + defense: combat.defense, + attackSpeed: combat.attackSpeed, + activeBuffs: combat.activeBuffs, + }, + }; + this._notifyStateChange(); + } + + /** Patch hero HP (e.g. after potion use). */ + patchHeroHp(hp: number): void { + const hero = this._gameState.hero; + if (!hero) return; + this._gameState = { + ...this._gameState, + hero: { ...hero, hp: Math.min(hp, hero.maxHp) }, + }; + this._notifyStateChange(); + } + + /** Replace debuffs from server snapshot. */ + patchHeroDebuffs(debuffs: HeroState['debuffs']): void { + const hero = this._gameState.hero; + if (!hero) return; + this._gameState = { + ...this._gameState, + hero: { ...hero, debuffs }, + }; + this._notifyStateChange(); + } + + /** Apply a full server state override (used for backward compat). */ + applyServerState(state: GameState): void { + this._gameState = { + ...state, + lastVictoryLoot: + state.lastVictoryLoot ?? this._gameState.lastVictoryLoot, + }; + this._notifyStateChange(); + } + + // ---- Lifecycle ---- + + /** Initialize the engine and attach to the DOM */ + async init(canvasContainer: HTMLElement): Promise { + await this.renderer.init(canvasContainer); + + this._handleResize = (): void => { + this.renderer.resize(); + }; + window.addEventListener('resize', this._handleResize); + window.addEventListener('orientationchange', this._handleResize); + } + + /** Start the game loop */ + start(): void { + if (this._running) return; + this._running = true; + this._lastTime = performance.now(); + this._accumulator = 0; + this._tick(performance.now()); + } + + /** Stop the game loop */ + stop(): void { + this._running = false; + if (this._rafId !== null) { + cancelAnimationFrame(this._rafId); + this._rafId = null; + } + } + + /** Clean up everything */ + destroy(): void { + this.stop(); + if (this._handleResize) { + window.removeEventListener('resize', this._handleResize); + window.removeEventListener('orientationchange', this._handleResize); + this._handleResize = null; + } + this.renderer.destroy(); + } + + // ---- Private: Loop ---- + + /** Main loop tick - called by requestAnimationFrame */ + private _tick = (now: number): void => { + if (!this._running) return; + + const frameTime = Math.min(now - this._lastTime, MAX_ACCUMULATED_MS); + this._lastTime = now; + this._accumulator += frameTime; + + // Fixed timestep updates (camera, loot timer only -- no game logic) + while (this._accumulator >= FIXED_DT_MS) { + this._update(FIXED_DT_MS); + this._accumulator -= FIXED_DT_MS; + } + + // Render (alpha available for future interpolation use) + void this._accumulator; + this._render(); + + this._rafId = requestAnimationFrame(this._tick); + }; + + /** Fixed-step update -- camera follow and loot timer only */ + private _update(dtMs: number): void { + // Interpolate hero display position toward target + this._interpolatePosition(); + + // Camera follows interpolated hero position + if (this._gameState.hero) { + const heroScreen = worldToScreen( + this._heroDisplayX, + this._heroDisplayY, + ); + this.camera.setTarget(heroScreen.x, heroScreen.y); + } + this.camera.update(dtMs); + + // Auto-clear loot popup + if (this._gameState.loot) { + this._lootTimerMs += dtMs; + if (this._lootTimerMs >= 2000) { + this._gameState = { ...this._gameState, loot: null }; + this._lootTimerMs = 0; + } + } + } + + /** + * Interpolate hero display position between server updates. + * + * Server sends hero_move at 2 Hz (every 500ms). We linearly + * interpolate between the previous known position and the target + * position over that interval. + */ + private _interpolatePosition(): void { + const elapsed = + (performance.now() - this._lastMoveUpdateTime) / 1000; + const t = Math.min(elapsed / MOVE_UPDATE_INTERVAL_S, 1.0); + + this._heroDisplayX = + this._prevPositionX + + (this._targetPositionX - this._prevPositionX) * t; + this._heroDisplayY = + this._prevPositionY + + (this._targetPositionY - this._prevPositionY) * t; + } + + /** Render frame */ + private _render(): void { + if (!this.renderer.initialized) return; + + const viewport = getViewport(); + + // Apply camera to world container + this.camera.applyTo( + this.renderer.worldContainer, + viewport.width, + viewport.height, + ); + + // Draw the ground tiles + this.renderer.drawGround(this.camera, viewport.width, viewport.height); + + // Draw towns on the map + if (this._towns.length > 0) { + this.renderer.drawTowns( + this._towns, + this.camera, + viewport.width, + viewport.height, + ); + } + + // Draw entities + const state = this._gameState; + const now = performance.now(); + + if (state.hero) { + const isWalking = state.phase === GamePhase.Walking; + const isFighting = state.phase === GamePhase.Fighting; + const animPhase = isWalking + ? 'walk' + : isFighting + ? 'fight' + : 'idle'; + + this.renderer.drawHero( + this._heroDisplayX, + this._heroDisplayY, + animPhase, + now, + ); + + // Thought bubble during rest/town pauses + if (this._thoughtText) { + this.renderer.drawThoughtBubble( + this._heroDisplayX, + this._heroDisplayY, + this._thoughtText, + now, + this._thoughtStartMs, + ); + } else { + this.renderer.clearThoughtBubble(); + } + } + + // Draw NPCs from towns + if (this._allNPCs.length > 0) { + this.renderer.drawNPCs( + this._allNPCs, + this.camera, + viewport.width, + viewport.height, + now, + ); + } else { + this.renderer.clearNPCs(); + } + + // Draw nearby heroes from the shared world + if (this._nearbyHeroes.length > 0) { + this.renderer.drawNearbyHeroes(this._nearbyHeroes, now); + } else { + this.renderer.clearNearbyHeroes(); + } + + // Draw enemy during combat or death + const showEnemy = + state.enemy && + (state.phase === GamePhase.Fighting || + (state.phase === GamePhase.Dead && state.enemy)); + if (showEnemy && state.enemy) { + this.renderer.drawEnemy( + state.enemy.position.x, + state.enemy.position.y, + state.enemy.hp, + state.enemy.maxHp, + state.enemy.enemyType, + now, + ); + } + + // Sort entities for isometric depth + this.renderer.sortEntities(); + } + + // ---- Private: Helpers ---- + + private _notifyStateChange(): void { + this._onStateChange?.(this._gameState); + } + + private _emitDamage( + value: number, + x: number, + y: number, + isCrit: boolean, + ): void { + if (!this._onDamage) return; + this._onDamage({ + id: Date.now() + Math.random(), + value, + x, + y, + isCrit, + createdAt: performance.now(), + }); + } + + private _showThought(): void { + this._thoughtText = + HERO_THOUGHTS[Math.floor(Math.random() * HERO_THOUGHTS.length)] ?? + null; + this._thoughtStartMs = performance.now(); + } +} diff --git a/frontend/src/game/procedural.ts b/frontend/src/game/procedural.ts new file mode 100644 index 0000000..13b0b56 --- /dev/null +++ b/frontend/src/game/procedural.ts @@ -0,0 +1,256 @@ +/** + * Terrain and props around server-defined towns and roads. + * + * 1) Town centers + radii define settlements (plaza + rim). + * 2) A closed ring through towns (sorted by levelMin) defines the main road corridor. + * 3) Optional `activeRoute` waypoints from `route_assigned` refine the path for the current leg. + * 4) Wild tiles use the nearest town's biome as the base, then light noise. + */ + +/** One town for terrain influence (from REST /towns or TownData). */ +export interface TownTerrainInfluence { + id: number; + cx: number; + cy: number; + radius: number; + biome: string; + levelMin: number; +} + +/** Built once per frame batch / when towns or route change. */ +export interface WorldTerrainContext { + towns: TownTerrainInfluence[]; + /** Town centers in travel order (sorted by levelMin), for the ring road. */ + networkCenters: Array<{ x: number; y: number }>; + /** Current road polyline from server (may be empty). */ + activeRoute: Array<{ x: number; y: number }> | null; +} + +/** Deterministic integer hash for tile coordinates -> [0, 1) */ +export function tileHash(x: number, y: number, seed: number): number { + let h = (Math.imul(x | 0, 374761393) + Math.imul(y | 0, 668265263) + seed) | 0; + h = Math.imul(h ^ (h >>> 13), 1274126177); + h = h ^ (h >>> 16); + return (h & 0x7fffffff) / 0x7fffffff; +} + +function distPointToSegment( + px: number, + py: number, + ax: number, + ay: number, + bx: number, + by: number, +): number { + const abx = bx - ax; + const aby = by - ay; + const apx = px - ax; + const apy = py - ay; + const ab2 = abx * abx + aby * aby; + let t = ab2 > 1e-12 ? (apx * abx + apy * aby) / ab2 : 0; + t = Math.max(0, Math.min(1, t)); + const qx = ax + abx * t; + const qy = ay + aby * t; + return Math.hypot(px - qx, py - qy); +} + +/** Open polyline: consecutive vertex pairs. */ +export function minDistToOpenPolyline( + px: number, + py: number, + pts: Array<{ x: number; y: number }>, +): number { + if (pts.length < 2) return Number.POSITIVE_INFINITY; + let min = Number.POSITIVE_INFINITY; + for (let i = 0; i < pts.length - 1; i++) { + const a = pts[i]!; + const b = pts[i + 1]!; + const d = distPointToSegment(px, py, a.x, a.y, b.x, b.y); + if (d < min) min = d; + } + return min; +} + +/** Closed ring through centers: (c0,c1)…(c_{n-2},c_{n-1}),(c_{n-1},c0). */ +export function minDistToRing( + px: number, + py: number, + centers: Array<{ x: number; y: number }>, +): number { + const n = centers.length; + if (n < 2) return Number.POSITIVE_INFINITY; + let min = Number.POSITIVE_INFINITY; + for (let i = 0; i < n; i++) { + const a = centers[i]!; + const b = centers[(i + 1) % n]!; + const d = distPointToSegment(px, py, a.x, a.y, b.x, b.y); + if (d < min) min = d; + } + return min; +} + +/** Sort towns like the server chain (level_min, then id). */ +export function orderedTownCenters(towns: TownTerrainInfluence[]): Array<{ x: number; y: number }> { + const sorted = [...towns].sort((a, b) => a.levelMin - b.levelMin || a.id - b.id); + return sorted.map((t) => ({ x: t.cx, y: t.cy })); +} + +export function buildWorldTerrainContext( + towns: TownTerrainInfluence[], + activeRoute: Array<{ x: number; y: number }> | null, +): WorldTerrainContext { + return { + towns, + networkCenters: orderedTownCenters(towns), + activeRoute: activeRoute && activeRoute.length >= 2 ? activeRoute : null, + }; +} + +/** Helpers for Minimap / tests: Town[] -> influences */ +export function townsApiToInfluences( + towns: Array<{ + id: number; + worldX: number; + worldY: number; + radius: number; + biome: string; + levelMin: number; + }>, +): TownTerrainInfluence[] { + return towns.map((t) => ({ + id: t.id, + cx: t.worldX, + cy: t.worldY, + radius: t.radius, + biome: t.biome, + levelMin: t.levelMin, + })); +} + +function roadClearance(wx: number, wy: number, ctx: WorldTerrainContext): number { + const ringD = minDistToRing(wx, wy, ctx.networkCenters); + const activeD = ctx.activeRoute + ? minDistToOpenPolyline(wx, wy, ctx.activeRoute) + : Number.POSITIVE_INFINITY; + return Math.min(ringD, activeD); +} + +function nearestTown(wx: number, wy: number, towns: TownTerrainInfluence[]): TownTerrainInfluence | null { + if (towns.length === 0) return null; + let best = towns[0]!; + let bestD = Math.hypot(wx - best.cx, wy - best.cy); + for (let i = 1; i < towns.length; i++) { + const t = towns[i]!; + const d = Math.hypot(wx - t.cx, wy - t.cy); + if (d < bestD) { + bestD = d; + best = t; + } + } + return best; +} + +/** Map server biome id to a ground tile key (colors in renderer). */ +export function biomeToTerrainKey(biome: string): string { + const b = biome.toLowerCase(); + if (b === 'forest') return 'forest_floor'; + if (b === 'ruins') return 'ruins_floor'; + if (b === 'canyon') return 'canyon_floor'; + if (b === 'swamp') return 'swamp_floor'; + if (b === 'volcanic') return 'volcanic_floor'; + if (b === 'astral') return 'astral_floor'; + if (b === 'meadow') return 'grass'; + return 'grass'; +} + +/** + * Terrain at integer tile (wx, wy). + * With `context`, roads follow the town ring + active route; wild tiles follow nearest town biome. + * Without context, simple grass + noise (no synthetic diagonal road). + */ +export function proceduralTerrain( + wx: number, + wy: number, + context?: WorldTerrainContext | null, +): string { + const ctx = context; + if (!ctx || ctx.towns.length === 0) { + const h = tileHash(wx, wy, 42); + if (h < 0.06) return 'dirt'; + if (h < 0.1) return 'stone'; + return 'grass'; + } + + let minEdge = Number.POSITIVE_INFINITY; + for (const t of ctx.towns) { + const d = Math.hypot(wx - t.cx, wy - t.cy) - t.radius; + if (d < minEdge) minEdge = d; + } + + if (minEdge < -0.8) return 'plaza'; + if (minEdge < 2.2) return 'dirt'; + + const rd = roadClearance(wx, wy, ctx); + if (rd < 1.15) return 'road'; + if (rd < 2.65) return 'dirt'; + + const near = nearestTown(wx, wy, ctx.towns); + let base = near ? biomeToTerrainKey(near.biome) : 'grass'; + const h = tileHash(wx, wy, 42); + if (base === 'forest_floor' && h < 0.12) return 'dirt'; + if (base === 'swamp_floor' && h < 0.1) return 'dirt'; + if (h < 0.04) return 'stone'; + if (h < 0.09) return 'dirt'; + return base; +} + +/** Prop types for ground layer. */ +export function proceduralObject( + wx: number, + wy: number, + terrain: string, + context?: WorldTerrainContext | null, +): string | null { + if (terrain === 'plaza') { + const h = tileHash(wx, wy, 201); + if (h < 0.1) return 'stall'; + if (h < 0.16) return 'well'; + if (h < 0.22) return 'banner'; + return null; + } + + if (context && roadClearance(wx, wy, context) < 3.0) return null; + + const h = tileHash(wx, wy, 137); + let treeTh = 0.045; + if (terrain === 'forest_floor') treeTh = 0.09; + if (terrain === 'swamp_floor') treeTh = 0.025; + if (h < treeTh) return 'tree'; + if (h < 0.08) return 'bush'; + if (h < 0.095) return 'rock'; + if (h < 0.11) return 'stump'; + if (h < 0.122) return 'cart'; + if (h < 0.132) return 'bones'; + if (h < 0.142) return 'mushroom'; + if (h < 0.15) return 'ruin'; + return null; +} + +/** Blocking object types that hero cannot walk through */ +const BLOCKING_TYPES = new Set(['tree', 'bush', 'rock', 'ruin', 'stall', 'well']); + +/** + * Check if a tile at the given world coordinate is blocked by a procedural obstacle. + */ +export function isProcedurallyBlocked( + wx: number, + wy: number, + context?: WorldTerrainContext | null, +): boolean { + const ix = Math.floor(wx); + const iy = Math.floor(wy); + const terrain = proceduralTerrain(ix, iy, context); + const obj = proceduralObject(ix, iy, terrain, context); + if (obj === null) return false; + return BLOCKING_TYPES.has(obj); +} diff --git a/frontend/src/game/renderer.ts b/frontend/src/game/renderer.ts new file mode 100644 index 0000000..fbfffb7 --- /dev/null +++ b/frontend/src/game/renderer.ts @@ -0,0 +1,1181 @@ +import { Application, Container, Graphics, Text, TextStyle } from 'pixi.js'; +import { TILE_WIDTH, TILE_HEIGHT, MAP_ZOOM } from '../shared/constants'; +import { getViewport } from '../shared/telegram'; +import type { Camera } from './camera'; +import type { EnemyType } from './types'; +import type { TownData, NPCData } from './types'; +import { drawEnemyByType } from './enemyVisuals'; + +/** + * Isometric coordinate conversion utilities. + * + * We use a standard 2:1 isometric projection. + * World coordinates are in tile units (float). + * Screen coordinates are in pixels. + */ + +export interface ScreenPoint { + x: number; + y: number; +} + +export interface WorldPoint { + x: number; + y: number; +} + +/** Convert world (tile) coordinates to screen (pixel) coordinates */ +export function worldToScreen(wx: number, wy: number): ScreenPoint { + return { + x: (wx - wy) * (TILE_WIDTH / 2), + y: (wx + wy) * (TILE_HEIGHT / 2), + }; +} + +/** Convert screen (pixel) coordinates to world (tile) coordinates */ +export function screenToWorld(sx: number, sy: number): WorldPoint { + return { + x: (sx / (TILE_WIDTH / 2) + sy / (TILE_HEIGHT / 2)) / 2, + y: (sy / (TILE_HEIGHT / 2) - sx / (TILE_WIDTH / 2)) / 2, + }; +} + +// ---- Procedural terrain generation (shared module) ---- +import { + tileHash, + proceduralTerrain, + proceduralObject, + type WorldTerrainContext, +} from './procedural'; + +/** + * Main renderer. Wraps a PixiJS Application and manages the scene graph. + * + * Terrain follows server towns + road ring, then active route waypoints; wild tiles use nearest town biome. + * + * Scene structure: + * app.stage + * -> worldContainer (moved by camera) + * -> groundLayer (tiles, terrain) + * -> entityLayer (hero, enemies, sorted by depth) + * -> effectLayer (particles, flashes) + * -> uiContainer (fixed HUD elements rendered in Pixi, if any) + */ +export class GameRenderer { + app: Application; + worldContainer: Container; + groundLayer: Container; + entityLayer: Container; + effectLayer: Container; + uiContainer: Container; + + private _initialized = false; + + /** Town ring + active route for procedural ground (null until towns loaded). */ + private _worldTerrainContext: WorldTerrainContext | null = null; + + // Reusable Graphics objects (avoid GC in hot path) + private _groundGfx: Graphics | null = null; + private _heroGfx: Graphics | null = null; + private _enemyGfx: Graphics | null = null; + private _thoughtGfx: Graphics | null = null; + private _thoughtText: Text | null = null; + private _heroNameText: Text | null = null; + private _heroName = ''; + + // Town rendering + private _townGfx: Graphics | null = null; + private _townLabels: Text[] = []; + private _townLabelPool: Text[] = []; + + // NPC rendering + private _npcGfx: Graphics | null = null; + private _npcLabels: Text[] = []; + private _npcLabelPool: Text[] = []; + + // Nearby hero rendering + private _nearbyHeroGfx: Graphics | null = null; + private _nearbyHeroLabels: Text[] = []; + private _nearbyHeroLabelPool: Text[] = []; + + private _drawBush(gfx: Graphics, x: number, y: number, variant: number): void { + const s = (0.9 + variant * 0.25) * 3.5; + gfx.ellipse(x - 4 * s, y - 7 * s, 7 * s, 4.5 * s); + gfx.fill({ color: 0x356e2b, alpha: 0.95 }); + gfx.ellipse(x + 3 * s, y - 8 * s, 6.5 * s, 4 * s); + gfx.fill({ color: 0x2f6526, alpha: 0.95 }); + gfx.ellipse(x, y - 10 * s, 8 * s, 4.5 * s); + gfx.fill({ color: 0x3f7d32, alpha: 0.95 }); + gfx.ellipse(x, y - 5 * s, 9 * s, 2.5 * s); + gfx.fill({ color: 0x22481b, alpha: 0.35 }); + } + + private _drawTree(gfx: Graphics, x: number, y: number, variant: number): void { + const s = (0.95 + variant * 0.35) * 3.5; + gfx.rect(x - 2 * s, y - 24 * s, 4 * s, 12 * s); + gfx.fill({ color: 0x5a3d24, alpha: 0.98 }); + gfx.ellipse(x, y - 28 * s, 11 * s, 7.5 * s); + gfx.fill({ color: 0x2f6c29, alpha: 0.98 }); + gfx.ellipse(x - 6 * s, y - 24 * s, 8 * s, 6 * s); + gfx.fill({ color: 0x3a7e31, alpha: 0.98 }); + gfx.ellipse(x + 6 * s, y - 24 * s, 8 * s, 6 * s); + gfx.fill({ color: 0x3a7e31, alpha: 0.98 }); + gfx.ellipse(x, y - 19 * s, 10 * s, 6 * s); + gfx.fill({ color: 0x2a5f23, alpha: 0.92 }); + } + + private _drawRock(gfx: Graphics, x: number, y: number, variant: number): void { + const s = (0.8 + variant * 0.4) * 3.5; + gfx.ellipse(x, y - 4 * s, 7 * s, 4 * s); + gfx.fill({ color: 0x6b6b6b, alpha: 0.95 }); + gfx.ellipse(x - 2 * s, y - 6 * s, 5 * s, 3.5 * s); + gfx.fill({ color: 0x7e7e7e, alpha: 0.95 }); + gfx.ellipse(x, y - 2 * s, 8 * s, 2 * s); + gfx.fill({ color: 0x3a3a3a, alpha: 0.25 }); + } + + private _drawStump(gfx: Graphics, x: number, y: number, variant: number): void { + const s = (0.85 + variant * 0.2) * 3.2; + gfx.roundRect(x - 5 * s, y - 8 * s, 10 * s, 9 * s, 2 * s); + gfx.fill({ color: 0x4a3020, alpha: 0.98 }); + gfx.ellipse(x, y - 10 * s, 6 * s, 3 * s); + gfx.fill({ color: 0x3d2818, alpha: 0.9 }); + } + + private _drawBrokenCart(gfx: Graphics, x: number, y: number, variant: number): void { + const s = (0.9 + variant * 0.15) * 3; + gfx.rect(x - 14 * s, y - 3 * s, 22 * s, 6 * s); + gfx.fill({ color: 0x5c4030, alpha: 0.95 }); + gfx.rect(x + 8 * s, y - 2 * s, 3 * s, 8 * s); + gfx.fill({ color: 0x3a3a3a, alpha: 0.9 }); + gfx.circle(x - 10 * s, y + 4 * s, 3 * s); + gfx.fill({ color: 0x2a2a2a, alpha: 0.85 }); + } + + private _drawBones(gfx: Graphics, x: number, y: number, variant: number): void { + const s = (0.8 + variant * 0.3) * 2.8; + gfx.roundRect(x - 8 * s, y - 2 * s, 16 * s, 3 * s, 1 * s); + gfx.fill({ color: 0xddd5c8, alpha: 0.9 }); + gfx.circle(x - 5 * s, y - 1 * s, 2 * s); + gfx.fill({ color: 0xc9c2b6, alpha: 0.9 }); + gfx.circle(x + 6 * s, y, 1.5 * s); + gfx.fill({ color: 0xb0a898, alpha: 0.85 }); + } + + private _drawMushroom(gfx: Graphics, x: number, y: number, variant: number): void { + const s = (0.85 + variant * 0.25) * 3; + gfx.rect(x - 1.5 * s, y - 4 * s, 3 * s, 6 * s); + gfx.fill({ color: 0xe8e0d5, alpha: 0.95 }); + gfx.ellipse(x, y - 8 * s, 5 * s, 3.5 * s); + gfx.fill({ color: variant > 0.5 ? 0xc44a4a : 0xd9c04a, alpha: 0.95 }); + gfx.ellipse(x, y - 8 * s, 2 * s, 1.2 * s); + gfx.fill({ color: 0xffffff, alpha: 0.35 }); + } + + private _drawRuin(gfx: Graphics, x: number, y: number, variant: number): void { + const s = (0.9 + variant * 0.2) * 3.2; + gfx.rect(x - 4 * s, y - 14 * s, 4 * s, 14 * s); + gfx.fill({ color: 0x6a6a72, alpha: 0.95 }); + gfx.rect(x + 2 * s, y - 10 * s, 5 * s, 10 * s); + gfx.fill({ color: 0x5a5a62, alpha: 0.92 }); + gfx.rect(x - 1 * s, y - 4 * s, 8 * s, 3 * s); + gfx.fill({ color: 0x4a4a52, alpha: 0.88 }); + } + + private _drawMarketStall(gfx: Graphics, x: number, y: number, variant: number): void { + const s = (0.95 + variant * 0.1) * 3.5; + gfx.rect(x - 12 * s, y - 2 * s, 24 * s, 5 * s); + gfx.fill({ color: 0x6b4a32, alpha: 0.96 }); + gfx.poly([x, y - 16 * s, x + 14 * s, y - 4 * s, x - 14 * s, y - 4 * s]); + gfx.fill({ color: 0x8b3a3a, alpha: 0.94 }); + gfx.rect(x - 3 * s, y - 8 * s, 6 * s, 5 * s); + gfx.fill({ color: 0x2a5080, alpha: 0.85 }); + } + + private _drawWell(gfx: Graphics, x: number, y: number, variant: number): void { + const s = (0.9 + variant * 0.15) * 3.2; + gfx.ellipse(x, y - 2 * s, 9 * s, 5 * s); + gfx.fill({ color: 0x5a5a62, alpha: 0.95 }); + gfx.ellipse(x, y - 4 * s, 5 * s, 3 * s); + gfx.fill({ color: 0x1a4a6e, alpha: 0.85 }); + gfx.rect(x - 2 * s, y - 12 * s, 4 * s, 8 * s); + gfx.fill({ color: 0x7a7a82, alpha: 0.9 }); + } + + private _drawBanner(gfx: Graphics, x: number, y: number, variant: number): void { + const s = (0.85 + variant * 0.2) * 3; + gfx.rect(x - 1.2 * s, y - 18 * s, 2.4 * s, 18 * s); + gfx.fill({ color: 0x4a3a28, alpha: 0.95 }); + gfx.poly([x + 1.2 * s, y - 18 * s, x + 12 * s, y - 14 * s, x + 1.2 * s, y - 10 * s]); + gfx.fill({ color: 0x6a3a8e, alpha: 0.92 }); + } + + private _terrainColors(terrain: string, dark: boolean): number { + if (terrain === 'plaza') return dark ? 0x5a5a62 : 0x6c6c75; + if (terrain === 'road') return dark ? 0x7b6545 : 0x8e7550; + if (terrain === 'dirt') return dark ? 0x6b5338 : 0x7c6242; + if (terrain === 'stone') return dark ? 0x5c5f67 : 0x6c7078; + if (terrain === 'forest_floor') return dark ? 0x234a1c : 0x2d5a24; + if (terrain === 'ruins_floor') return dark ? 0x4a4a48 : 0x5a5a58; + if (terrain === 'canyon_floor') return dark ? 0x7a6248 : 0x8b7355; + if (terrain === 'swamp_floor') return dark ? 0x324c36 : 0x3d5c42; + if (terrain === 'volcanic_floor') return dark ? 0x4a2e28 : 0x5c3830; + if (terrain === 'astral_floor') return dark ? 0x3a3568 : 0x4a4580; + return dark ? 0x2d5a1e : 0x3a7a28; // grass + } + + private _terrainStrokeColor(terrain: string): number { + if (terrain === 'road') return 0x4e3f2d; + if (terrain === 'plaza' || terrain === 'stone') return 0x333340; + if (terrain === 'dirt') return 0x4a3828; + if (terrain === 'ruins_floor') return 0x2a2a30; + if (terrain === 'canyon_floor') return 0x5a4835; + if (terrain === 'swamp_floor') return 0x1a3a28; + if (terrain === 'volcanic_floor') return 0x4a2020; + if (terrain === 'astral_floor') return 0x302840; + return 0x1a4a12; + } + + /** Called from GameEngine when towns or route waypoints change. */ + setWorldTerrainContext(ctx: WorldTerrainContext | null): void { + this._worldTerrainContext = ctx; + } + + constructor() { + this.app = new Application(); + this.worldContainer = new Container(); + this.groundLayer = new Container(); + this.entityLayer = new Container(); + this.effectLayer = new Container(); + this.uiContainer = new Container(); + } + + get initialized(): boolean { + return this._initialized; + } + + /** Initialize the PixiJS application and attach to canvas container */ + async init(canvasContainer: HTMLElement): Promise { + if (this._initialized) return; + + const viewport = getViewport(); + + await this.app.init({ + width: viewport.width, + height: viewport.height, + backgroundColor: 0x1a1a2e, + resolution: Math.min(window.devicePixelRatio, 2), + autoDensity: true, + antialias: false, + powerPreference: 'high-performance', + }); + + canvasContainer.appendChild(this.app.canvas as HTMLCanvasElement); + + // Build scene graph + this.worldContainer.addChild(this.groundLayer); + this.worldContainer.addChild(this.entityLayer); + this.worldContainer.addChild(this.effectLayer); + this.app.stage.addChild(this.worldContainer); + this.app.stage.addChild(this.uiContainer); + + // Center the world container and apply zoom + this.worldContainer.x = viewport.width / 2; + this.worldContainer.y = viewport.height / 2; + this.worldContainer.scale.set(MAP_ZOOM); + + // Create reusable graphics objects + this._groundGfx = new Graphics(); + this.groundLayer.addChild(this._groundGfx); + + this._heroGfx = new Graphics(); + this.entityLayer.addChild(this._heroGfx); + + this._enemyGfx = new Graphics(); + this.entityLayer.addChild(this._enemyGfx); + + this._thoughtGfx = new Graphics(); + this.entityLayer.addChild(this._thoughtGfx); + + this._thoughtText = new Text({ + text: '', + style: new TextStyle({ + fontSize: 11, + fontFamily: 'system-ui, sans-serif', + fill: 0x333333, + wordWrap: true, + wordWrapWidth: 130, + align: 'center', + }), + }); + this._thoughtText.anchor.set(0.5, 0.5); + this._thoughtText.visible = false; + this.entityLayer.addChild(this._thoughtText); + + this._heroNameText = new Text({ + text: '', + style: new TextStyle({ + fontSize: 11, + fontFamily: 'system-ui, sans-serif', + fill: 0xffffff, + stroke: { color: 0x000000, width: 3 }, + align: 'center', + }), + }); + this._heroNameText.anchor.set(0.5, 0.5); + this._heroNameText.visible = false; + this.entityLayer.addChild(this._heroNameText); + + // Town graphics (drawn between ground and entity layers) + this._townGfx = new Graphics(); + this.groundLayer.addChild(this._townGfx); + + // NPC graphics (drawn in entity layer for depth sorting) + this._npcGfx = new Graphics(); + this.entityLayer.addChild(this._npcGfx); + + // Nearby hero graphics + this._nearbyHeroGfx = new Graphics(); + this.entityLayer.addChild(this._nearbyHeroGfx); + + this._initialized = true; + console.info(`[Renderer] Initialized ${viewport.width}x${viewport.height} @${this.app.renderer.resolution}x`); + } + + /** Handle window/viewport resize */ + resize(): void { + if (!this._initialized) return; + const viewport = getViewport(); + this.app.renderer.resize(viewport.width, viewport.height); + this.worldContainer.x = viewport.width / 2; + this.worldContainer.y = viewport.height / 2; + this.worldContainer.scale.set(MAP_ZOOM); + } + + /** + * Draw visible ground tiles and decorative objects. + * Terrain is procedurally generated — the world is endless. + */ + drawGround(camera: Camera, screenWidth: number, screenHeight: number): void { + const gfx = this._groundGfx; + if (!gfx) return; + gfx.clear(); + + const cx = camera.finalX; + const cy = camera.finalY; + const halfW = screenWidth / (2 * MAP_ZOOM) + TILE_WIDTH * 2; + const halfH = screenHeight / (2 * MAP_ZOOM) + TILE_HEIGHT * 2; + + const worldCorners = [ + screenToWorld(cx - halfW, cy - halfH), + screenToWorld(cx + halfW, cy - halfH), + screenToWorld(cx - halfW, cy + halfH), + screenToWorld(cx + halfW, cy + halfH), + ]; + + const renderPaddingTiles = 4; + let minWX = Number.POSITIVE_INFINITY; + let maxWX = Number.NEGATIVE_INFINITY; + let minWY = Number.POSITIVE_INFINITY; + let maxWY = Number.NEGATIVE_INFINITY; + + for (const corner of worldCorners) { + if (corner.x < minWX) minWX = corner.x; + if (corner.x > maxWX) maxWX = corner.x; + if (corner.y < minWY) minWY = corner.y; + if (corner.y > maxWY) maxWY = corner.y; + } + + minWX -= renderPaddingTiles; + maxWX += renderPaddingTiles; + minWY -= renderPaddingTiles; + maxWY += renderPaddingTiles; + + const startX = Math.floor(minWX); + const endX = Math.ceil(maxWX); + const startY = Math.floor(minWY); + const endY = Math.ceil(maxWY); + + const hw = TILE_WIDTH / 2; + const hh = TILE_HEIGHT / 2; + const terrainCtx = this._worldTerrainContext; + + // Pass 1: tiles + for (let wx = startX; wx <= endX; wx++) { + for (let wy = startY; wy <= endY; wy++) { + const terrain = proceduralTerrain(wx, wy, terrainCtx); + const iso = worldToScreen(wx, wy); + const dark = (wx + wy) % 2 === 0; + const color = this._terrainColors(terrain, dark); + + gfx.poly([ + iso.x, iso.y - hh, + iso.x + hw, iso.y, + iso.x, iso.y + hh, + iso.x - hw, iso.y, + ]); + gfx.fill({ color, alpha: 1 }); + + gfx.poly([ + iso.x, iso.y - hh, + iso.x + hw, iso.y, + iso.x, iso.y + hh, + iso.x - hw, iso.y, + ]); + gfx.stroke({ + color: this._terrainStrokeColor(terrain), + width: 1, + alpha: 0.25, + }); + } + } + + // Pass 2: objects (drawn after tiles so they layer on top) + // Slightly expanded object bounds prevent enlarged props from edge clipping. + const objectPaddingTiles = 4; + const objectStartX = startX - objectPaddingTiles; + const objectEndX = endX + objectPaddingTiles; + const objectStartY = startY - objectPaddingTiles; + const objectEndY = endY + objectPaddingTiles; + for (let wx = objectStartX; wx <= objectEndX; wx++) { + for (let wy = objectStartY; wy <= objectEndY; wy++) { + const terrainHere = proceduralTerrain(wx, wy, terrainCtx); + const obj = proceduralObject(wx, wy, terrainHere, terrainCtx); + if (!obj) continue; + const iso = worldToScreen(wx, wy); + const variant = tileHash(wx, wy, 999); + if (obj === 'tree') this._drawTree(gfx, iso.x, iso.y, variant); + else if (obj === 'bush') this._drawBush(gfx, iso.x, iso.y, variant); + else if (obj === 'rock') this._drawRock(gfx, iso.x, iso.y, variant); + else if (obj === 'stump') this._drawStump(gfx, iso.x, iso.y, variant); + else if (obj === 'cart') this._drawBrokenCart(gfx, iso.x, iso.y, variant); + else if (obj === 'bones') this._drawBones(gfx, iso.x, iso.y, variant); + else if (obj === 'mushroom') this._drawMushroom(gfx, iso.x, iso.y, variant); + else if (obj === 'ruin') this._drawRuin(gfx, iso.x, iso.y, variant); + else if (obj === 'stall') this._drawMarketStall(gfx, iso.x, iso.y, variant); + else if (obj === 'well') this._drawWell(gfx, iso.x, iso.y, variant); + else if (obj === 'banner') this._drawBanner(gfx, iso.x, iso.y, variant); + } + } + } + + /** + * Draw the hero as a compact adventurer (silhouette + cape + blade) with bob / combat flash. + */ + drawHero(wx: number, wy: number, phase: 'walk' | 'fight' | 'idle', now: number): void { + const gfx = this._heroGfx; + if (!gfx) return; + gfx.clear(); + + const iso = worldToScreen(wx, wy); + let yOffset = 0; + + if (phase === 'walk') { + yOffset = Math.sin(now * 0.006) * 3; + } else if (phase === 'fight') { + yOffset = Math.sin(now * 0.012) * 2; + } + + const cx = iso.x; + const cy = iso.y + yOffset; + + // Shadow + gfx.ellipse(cx, cy + 10, 16, 5); + gfx.fill({ color: 0x000000, alpha: 0.28 }); + + // Cape (behind body) + gfx.poly([cx - 14, cy - 4, cx - 18, cy + 10, cx + 2, cy + 6, cx + 4, cy - 8]); + gfx.fill({ color: 0x6a1a2e, alpha: 0.92 }); + + // Torso / tunic + gfx.roundRect(cx - 9, cy - 18, 18, 22, 4); + gfx.fill({ color: 0x3a5a8a, alpha: 0.98 }); + gfx.stroke({ color: 0x1a3050, width: 1.2 }); + + // Belt + gfx.rect(cx - 9, cy + 2, 18, 4); + gfx.fill({ color: 0x3a2818, alpha: 0.95 }); + + // Head / helm + gfx.roundRect(cx - 7, cy - 30, 14, 13, 5); + gfx.fill({ color: 0x8899aa, alpha: 0.98 }); + gfx.stroke({ color: 0x556070, width: 1 }); + + // Blade (readability at small zoom) + gfx.rect(cx + 8, cy - 22, 3, 20); + gfx.fill({ color: 0xc8d8e8, alpha: 0.95 }); + gfx.rect(cx + 8, cy - 4, 6, 3); + gfx.fill({ color: 0x4a3018, alpha: 0.95 }); + + if (phase === 'fight') { + const flash = (Math.sin(now * 0.01) + 1) * 0.5; + if (flash > 0.75) { + gfx.circle(cx + 14, cy - 10, 5); + gfx.fill({ color: 0xffffff, alpha: flash * 0.55 }); + } + } + + gfx.zIndex = cy + 100; + + // Hero name label above head (or above thought bubble if visible) + const nameTxt = this._heroNameText; + if (nameTxt && this._heroName) { + nameTxt.text = this._heroName; + nameTxt.x = iso.x; + // Default: above hero head; drawThoughtBubble will reposition if active + nameTxt.y = iso.y - 42; + nameTxt.visible = true; + nameTxt.zIndex = cy + 199; + } + } + + /** + * Draw an enemy with type-specific visuals and an HP bar above. + */ + drawEnemy(wx: number, wy: number, hp: number, maxHp: number, enemyType: EnemyType, now: number): void { + const gfx = this._enemyGfx; + if (!gfx) return; + drawEnemyByType(gfx, wx, wy, hp, maxHp, enemyType, now, worldToScreen); + } + + /** + * Draw a white rounded-rect thought bubble above the hero with a small + * downward-pointing triangle. Fades in over 300ms and fades out when the + * rest period is about to end. + */ + drawThoughtBubble(wx: number, wy: number, text: string, now: number, startMs: number): void { + const gfx = this._thoughtGfx; + const txt = this._thoughtText; + if (!gfx || !txt) return; + gfx.clear(); + + const elapsed = now - startMs; + // Fade in over 300ms + const fadeIn = Math.min(1, elapsed / 300); + const alpha = fadeIn; + if (alpha <= 0) { + txt.visible = false; + return; + } + + const iso = worldToScreen(wx, wy); + const bx = iso.x; + const by = iso.y - 52; // above hero head + + const w = 140; + const h = 28; + const left = bx - w / 2; + const top = by - h / 2; + + // Bubble background + gfx.roundRect(left, top, w, h, 6); + gfx.fill({ color: 0xffffff, alpha: 0.92 * alpha }); + gfx.stroke({ color: 0xcccccc, width: 1, alpha: 0.6 * alpha }); + + // Triangle pointer pointing down + const triW = 8; + const triH = 6; + gfx.poly([ + bx - triW / 2, top + h, + bx + triW / 2, top + h, + bx, top + h + triH, + ]); + gfx.fill({ color: 0xffffff, alpha: 0.92 * alpha }); + + gfx.zIndex = by + 200; // above hero + + // Text + txt.text = text; + txt.x = bx; + txt.y = by; + txt.alpha = alpha; + txt.visible = true; + txt.zIndex = by + 201; + + // Move hero name above the thought bubble + const nameTxt = this._heroNameText; + if (nameTxt && this._heroName) { + nameTxt.y = top - 10; + nameTxt.x = bx; + nameTxt.zIndex = by + 202; + } + } + + /** Hide the thought bubble when not resting. Called implicitly when drawThoughtBubble is not invoked. */ + clearThoughtBubble(): void { + if (this._thoughtGfx) this._thoughtGfx.clear(); + if (this._thoughtText) this._thoughtText.visible = false; + } + + /** Set the hero display name for the above-hero label */ + setHeroName(name: string): void { + this._heroName = name; + if (this._heroNameText) { + this._heroNameText.text = name; + this._heroNameText.visible = name.length > 0; + } + } + + /** + * Draw a single house with varied detail: windows, door, optional chimney. + * cx/cy = base center-bottom in screen space. + * roofStyle: 0 = pointed, 1 = flat, 2 = pointed with chimney + */ + private _drawHouse( + gfx: Graphics, cx: number, cy: number, + w: number, h: number, roofH: number, + wallColor: number, roofColor: number, + roofStyle: number = 0, + ): void { + // Wall + gfx.rect(cx - w / 2, cy - h, w, h); + gfx.fill({ color: wallColor, alpha: 0.95 }); + gfx.stroke({ color: 0x3a2a18, width: 1.2, alpha: 0.5 }); + + // Roof + if (roofStyle === 1) { + // Flat roof + gfx.rect(cx - w / 2 - 4, cy - h - roofH * 0.35, w + 8, roofH * 0.35); + gfx.fill({ color: roofColor, alpha: 0.95 }); + gfx.stroke({ color: 0x4a2a10, width: 1, alpha: 0.4 }); + } else { + // Pointed roof (triangle) + gfx.poly([ + cx - w / 2 - 4, cy - h, + cx + w / 2 + 4, cy - h, + cx, cy - h - roofH, + ]); + gfx.fill({ color: roofColor, alpha: 0.95 }); + gfx.stroke({ color: 0x4a2a10, width: 1, alpha: 0.4 }); + } + + // Chimney (roofStyle 2) + if (roofStyle === 2) { + const chimW = w * 0.12; + const chimH = roofH * 0.6; + const chimX = cx + w * 0.22; + gfx.rect(chimX - chimW / 2, cy - h - roofH * 0.7, chimW, chimH); + gfx.fill({ color: 0x5a4a3a, alpha: 0.95 }); + } + + // Door (dark rectangle at bottom center) + const doorW = w * 0.18; + const doorH = h * 0.42; + gfx.rect(cx - doorW / 2, cy - doorH, doorW, doorH); + gfx.fill({ color: 0x3a2818, alpha: 0.9 }); + // Door knob + gfx.circle(cx + doorW * 0.28, cy - doorH * 0.45, w * 0.02); + gfx.fill({ color: 0xccaa44, alpha: 0.8 }); + + // Windows (2-3 yellow rectangles) + const winS = w * 0.12; + const winY = cy - h * 0.68; + // Left window + gfx.rect(cx - w * 0.32, winY, winS, winS); + gfx.fill({ color: 0xeedd88, alpha: 0.75 }); + gfx.stroke({ color: 0x5a4a3a, width: 0.8, alpha: 0.5 }); + // Right window + gfx.rect(cx + w * 0.32 - winS, winY, winS, winS); + gfx.fill({ color: 0xeedd88, alpha: 0.75 }); + gfx.stroke({ color: 0x5a4a3a, width: 0.8, alpha: 0.5 }); + // Center window (only on wider houses) + if (w > 40) { + gfx.rect(cx - winS / 2, winY - winS * 0.3, winS, winS); + gfx.fill({ color: 0xeedd88, alpha: 0.6 }); + gfx.stroke({ color: 0x5a4a3a, width: 0.8, alpha: 0.4 }); + } + } + + /** Draw a fence segment beside a house. */ + private _drawFence(gfx: Graphics, cx: number, cy: number, w: number, side: 'left' | 'right'): void { + const dir = side === 'left' ? -1 : 1; + const fenceX = cx + dir * (w / 2 + 4); + for (let i = 0; i < 3; i++) { + const postX = fenceX + dir * i * 6; + gfx.rect(postX - 1, cy - 12, 2, 12); + gfx.fill({ color: 0x6a5a3a, alpha: 0.8 }); + } + // Rail + gfx.rect(fenceX - 1, cy - 10, dir * 14, 1.5); + gfx.fill({ color: 0x6a5a3a, alpha: 0.7 }); + gfx.rect(fenceX - 1, cy - 5, dir * 14, 1.5); + gfx.fill({ color: 0x6a5a3a, alpha: 0.7 }); + } + + /** Draw a market stall structure for town variety. */ + private _drawTownStall(gfx: Graphics, cx: number, cy: number, s: number): void { + // Counter / table + gfx.rect(cx - 18 * s, cy - 6 * s, 36 * s, 8 * s); + gfx.fill({ color: 0x6b4a32, alpha: 0.95 }); + // Cloth awning + gfx.poly([ + cx - 22 * s, cy - 6 * s, + cx + 22 * s, cy - 6 * s, + cx + 20 * s, cy - 20 * s, + cx - 20 * s, cy - 20 * s, + ]); + gfx.fill({ color: 0x8b3a3a, alpha: 0.85 }); + // Supports + gfx.rect(cx - 18 * s, cy - 20 * s, 2 * s, 14 * s); + gfx.fill({ color: 0x4a3a28, alpha: 0.9 }); + gfx.rect(cx + 16 * s, cy - 20 * s, 2 * s, 14 * s); + gfx.fill({ color: 0x4a3a28, alpha: 0.9 }); + // Goods on counter + gfx.circle(cx - 6 * s, cy - 8 * s, 3 * s); + gfx.fill({ color: 0xddaa44, alpha: 0.7 }); + gfx.circle(cx + 4 * s, cy - 8 * s, 2.5 * s); + gfx.fill({ color: 0x44aa88, alpha: 0.7 }); + } + + /** + * Draw towns visible in the current viewport. + * Each town renders a ground plane, a large cluster of buildings with detail, + * market stalls, fences, a name label, and a dashed border. + */ + drawTowns(towns: TownData[], camera: Camera, screenWidth: number, screenHeight: number): void { + const gfx = this._townGfx; + if (!gfx) return; + gfx.clear(); + + // Hide all existing labels first; we'll show visible ones below + for (const lbl of this._townLabels) { + lbl.visible = false; + } + + const cx = camera.finalX; + const cy = camera.finalY; + const halfW = screenWidth / (2 * MAP_ZOOM) + TILE_WIDTH * 10; + const halfH = screenHeight / (2 * MAP_ZOOM) + TILE_HEIGHT * 10; + + let labelIdx = 0; + + for (const town of towns) { + // Convert town world position to screen space + const townScreen = worldToScreen(town.centerX, town.centerY); + + // Viewport culling: skip towns whose center is far outside the view + if ( + Math.abs(townScreen.x - cx) > halfW + town.radius * TILE_WIDTH || + Math.abs(townScreen.y - cy) > halfH + town.radius * TILE_HEIGHT + ) { + continue; + } + + const tx = townScreen.x; + const ty = townScreen.y; + const s = Math.max(0.7, Math.min(1.6, town.radius / 8)); + + // --- Much larger border --- + const borderRadius = town.radius * TILE_WIDTH * 0.7; + const segments = 48; + for (let i = 0; i < segments; i++) { + const a1 = (i / segments) * Math.PI * 2; + const a2 = ((i + 1) / segments) * Math.PI * 2; + if (i % 2 === 0) { + gfx.moveTo(tx + Math.cos(a1) * borderRadius, ty + Math.sin(a1) * borderRadius * 0.5); + gfx.lineTo(tx + Math.cos(a2) * borderRadius, ty + Math.sin(a2) * borderRadius * 0.5); + gfx.stroke({ color: 0xdaa520, width: 2, alpha: 0.3 }); + } + } + + // --- Ground plane: tan/brown dirt ellipse --- + const groundW = borderRadius * 0.85; + const groundH = groundW * 0.5; + gfx.ellipse(tx, ty, groundW, groundH); + gfx.fill({ color: 0x8a7454, alpha: 0.35 }); + // Inner lighter patch + gfx.ellipse(tx, ty, groundW * 0.6, groundH * 0.6); + gfx.fill({ color: 0x9a8462, alpha: 0.2 }); + + // Glow circle behind town + gfx.circle(tx, ty, borderRadius * 0.6); + gfx.fill({ color: 0xdaa520, alpha: 0.04 }); + + // --- Building cluster: many houses spread wide --- + const houseCount = + town.size === 'XS' ? 5 : + town.size === 'S' ? 7 : + town.size === 'M' ? 10 : 14; + + // Generate house positions spread across a wider area + const housePositions: Array<{ dx: number; dy: number; w: number; h: number; rh: number; roofStyle: number; fence: boolean; stall: boolean }> = []; + const spread = 100 * s; + const baseW = 60; + const baseH = 48; + const baseRH = 32; + + // Seed pseudo-random from town id for deterministic layout + const townSeed = typeof town.id === 'number' ? town.id : 0; + for (let i = 0; i < houseCount; i++) { + // Deterministic pseudo-random using a simple hash + const hash = ((townSeed * 31 + i * 17) ^ (i * 0x45d9f3b)) >>> 0; + const r1 = ((hash & 0xffff) / 0xffff); + const r2 = (((hash >> 16) & 0xffff) / 0xffff); + const r3 = ((hash * 7 + i * 13) & 0xff) / 0xff; + + // Angle-based layout to fill the town area + const angle = (i / houseCount) * Math.PI * 2 + r1 * 0.4; + const dist = spread * (0.2 + r2 * 0.65); + const dx = Math.cos(angle) * dist; + const dy = Math.sin(angle) * dist * 0.5; // isometric compression + + const sizeVar = 0.7 + r3 * 0.5; + const w = baseW * s * sizeVar; + const h = baseH * s * sizeVar; + const rh = baseRH * s * sizeVar; + const roofStyle = i % 5 === 0 ? 1 : i % 3 === 0 ? 2 : 0; + const fence = i % 4 === 1; + const stall = false; // stalls are added separately + + housePositions.push({ dx, dy, w, h, rh, roofStyle, fence, stall }); + } + + const wallColors = [0x9a7e5a, 0x8b7252, 0xa08860, 0x7e6844, 0x907656, 0x9e8862, 0x887050]; + const roofColors = [0x6a3a22, 0x5a3020, 0x7a4028, 0x5e3422, 0x6e3a24, 0x724030, 0x603828]; + + for (let i = 0; i < housePositions.length; i++) { + const hp = housePositions[i]!; + this._drawHouse( + gfx, + tx + hp.dx, + ty + hp.dy, + hp.w, + hp.h, + hp.rh, + wallColors[i % wallColors.length]!, + roofColors[i % roofColors.length]!, + hp.roofStyle, + ); + if (hp.fence) { + this._drawFence(gfx, tx + hp.dx, ty + hp.dy, hp.w, i % 2 === 0 ? 'left' : 'right'); + } + } + + // Add 1-2 market stalls per town (larger towns get 2) + const stallCount = houseCount >= 10 ? 2 : 1; + for (let si = 0; si < stallCount; si++) { + const stallAngle = (si + 0.5) * Math.PI + (townSeed & 0xf) * 0.1; + const stallDist = spread * 0.35; + this._drawTownStall( + gfx, + tx + Math.cos(stallAngle) * stallDist, + ty + Math.sin(stallAngle) * stallDist * 0.5, + s * 0.9, + ); + } + + // --- Town name label (larger font, positioned higher) --- + let label: Text; + if (labelIdx < this._townLabels.length) { + label = this._townLabels[labelIdx]!; + } else { + if (this._townLabelPool.length > 0) { + label = this._townLabelPool.pop()!; + } else { + label = new Text({ + text: '', + style: new TextStyle({ + fontSize: 18, + fontFamily: 'system-ui, sans-serif', + fontWeight: 'bold', + fill: 0xdaa520, + stroke: { color: 0x000000, width: 4 }, + align: 'center', + }), + }); + label.anchor.set(0.5, 0.5); + } + this.groundLayer.addChild(label); + this._townLabels.push(label); + } + + label.text = town.name; + label.x = tx; + label.y = ty - spread - 30 * s; + label.visible = true; + label.zIndex = ty - 500; + labelIdx++; + } + } + + /** + * Draw NPCs within the viewport. Each NPC type has a distinct shape and icon. + * NPCs have a gentle idle sway animation. + */ + drawNPCs( + npcs: NPCData[], + camera: Camera, + screenWidth: number, + screenHeight: number, + now: number, + ): void { + const gfx = this._npcGfx; + if (!gfx) return; + gfx.clear(); + + for (const lbl of this._npcLabels) { + lbl.visible = false; + } + + const camX = camera.finalX; + const camY = camera.finalY; + const halfW = screenWidth / (2 * MAP_ZOOM) + TILE_WIDTH * 3; + const halfH = screenHeight / (2 * MAP_ZOOM) + TILE_HEIGHT * 3; + + let labelIdx = 0; + + for (const npc of npcs) { + const iso = worldToScreen(npc.worldX, npc.worldY); + + // Viewport culling + if ( + Math.abs(iso.x - camX) > halfW || + Math.abs(iso.y - camY) > halfH + ) continue; + + // Idle sway based on NPC id + const swayY = Math.sin(now * 0.002 + npc.id * 1.7) * 2.5; + const cx = iso.x; + const cy = iso.y + swayY; + + // Shadow + gfx.ellipse(cx, cy + 8, 10, 3.5); + gfx.fill({ color: 0x000000, alpha: 0.22 }); + + // NPC body diamond (type-specific color) + let bodyColor: number; + let bodyStroke: number; + let iconText: string; + let iconColor: number; + + switch (npc.type) { + case 'quest_giver': + bodyColor = 0xdaa520; + bodyStroke = 0x8a6510; + iconText = '!'; + iconColor = 0xffd700; + break; + case 'merchant': + bodyColor = 0x44aa55; + bodyStroke = 0x2a7a3a; + iconText = '$'; + iconColor = 0x88dd88; + break; + case 'healer': + bodyColor = 0xdddddd; + bodyStroke = 0x8888aa; + iconText = '+'; + iconColor = 0xff6666; + break; + default: + bodyColor = 0x8888aa; + bodyStroke = 0x555577; + iconText = '?'; + iconColor = 0xaaaacc; + } + + // Diamond body + const ds = 0.85; + gfx.poly([ + cx, cy - 18 * ds, + cx + 10 * ds, cy - 2 * ds, + cx, cy + 8 * ds, + cx - 10 * ds, cy - 2 * ds, + ]); + gfx.fill({ color: bodyColor, alpha: 0.75 }); + gfx.stroke({ color: bodyStroke, width: 1.5, alpha: 0.7 }); + + // Head circle + gfx.circle(cx, cy - 16 * ds, 5 * ds); + gfx.fill({ color: bodyColor, alpha: 0.6 }); + + // Floating icon above head + const iconBob = Math.sin(now * 0.004 + npc.id * 2.3) * 2; + const iconY = cy - 28 * ds + iconBob; + + // Icon background circle + gfx.circle(cx, iconY, 7); + gfx.fill({ color: 0x000000, alpha: 0.35 }); + + // We use Text for the icon character + // (drawn as part of label pool) + + // NPC name label below + let nameLabel: Text; + if (labelIdx < this._npcLabels.length) { + nameLabel = this._npcLabels[labelIdx]!; + } else { + if (this._npcLabelPool.length > 0) { + nameLabel = this._npcLabelPool.pop()!; + } else { + nameLabel = new Text({ + text: '', + style: new TextStyle({ + fontSize: 10, + fontFamily: 'system-ui, sans-serif', + fill: 0xcccccc, + stroke: { color: 0x000000, width: 2 }, + align: 'center', + }), + }); + nameLabel.anchor.set(0.5, 0.5); + } + this.entityLayer.addChild(nameLabel); + this._npcLabels.push(nameLabel); + } + + nameLabel.text = npc.name; + nameLabel.x = cx; + nameLabel.y = cy + 14; + nameLabel.visible = true; + nameLabel.zIndex = cy + 101; + labelIdx++; + + // Icon label (reusing label pool pattern: +1 entry for the icon) + let iconLabel: Text; + if (labelIdx < this._npcLabels.length) { + iconLabel = this._npcLabels[labelIdx]!; + } else { + if (this._npcLabelPool.length > 0) { + iconLabel = this._npcLabelPool.pop()!; + } else { + iconLabel = new Text({ + text: '', + style: new TextStyle({ + fontSize: 12, + fontFamily: 'system-ui, sans-serif', + fontWeight: 'bold', + fill: 0xffffff, + align: 'center', + }), + }); + iconLabel.anchor.set(0.5, 0.5); + } + this.entityLayer.addChild(iconLabel); + this._npcLabels.push(iconLabel); + } + + iconLabel.text = iconText; + iconLabel.style.fill = iconColor; + iconLabel.x = cx; + iconLabel.y = iconY; + iconLabel.visible = true; + iconLabel.zIndex = cy + 201; + labelIdx++; + + gfx.zIndex = cy + 100; + } + } + + /** Clear NPC visuals when there are none to render */ + clearNPCs(): void { + if (this._npcGfx) this._npcGfx.clear(); + for (const lbl of this._npcLabels) { + lbl.visible = false; + } + } + + /** + * Draw nearby heroes as semi-transparent green diamonds with name + level labels. + * Each hero gets a subtle idle sway animation. + */ + drawNearbyHeroes( + heroes: ReadonlyArray<{ name: string; level: number; positionX: number; positionY: number }>, + now: number, + ): void { + const gfx = this._nearbyHeroGfx; + if (!gfx) return; + gfx.clear(); + + // Hide all existing labels first + for (const lbl of this._nearbyHeroLabels) { + lbl.visible = false; + } + + let labelIdx = 0; + + for (const hero of heroes) { + const iso = worldToScreen(hero.positionX, hero.positionY); + // Idle sway: use a per-hero offset based on name hash + const hashOffset = hero.name.length * 1.37; + const swayY = Math.sin(now * 0.003 + hashOffset) * 2; + + const cx = iso.x; + const cy = iso.y + swayY; + + // Shadow + gfx.ellipse(cx, cy + 8, 10, 3); + gfx.fill({ color: 0x000000, alpha: 0.2 }); + + // Green diamond body (smaller than hero) + const s = 0.7; + gfx.poly([ + cx, cy - 16 * s, + cx + 10 * s, cy, + cx, cy + 8 * s, + cx - 10 * s, cy, + ]); + gfx.fill({ color: 0x44aa55, alpha: 0.55 }); + gfx.stroke({ color: 0x2d7a3a, width: 1.2, alpha: 0.6 }); + + // Small head circle + gfx.circle(cx, cy - 14 * s, 4 * s); + gfx.fill({ color: 0x66cc77, alpha: 0.5 }); + + // Label: "Name Lv.X" + let label: Text; + if (labelIdx < this._nearbyHeroLabels.length) { + label = this._nearbyHeroLabels[labelIdx]!; + } else { + if (this._nearbyHeroLabelPool.length > 0) { + label = this._nearbyHeroLabelPool.pop()!; + } else { + label = new Text({ + text: '', + style: new TextStyle({ + fontSize: 9, + fontFamily: 'system-ui, sans-serif', + fill: 0x88ddaa, + stroke: { color: 0x000000, width: 2 }, + align: 'center', + }), + }); + label.anchor.set(0.5, 0.5); + } + this.entityLayer.addChild(label); + this._nearbyHeroLabels.push(label); + } + + label.text = `${hero.name} Lv.${hero.level}`; + label.x = cx; + label.y = cy - 22; + label.visible = true; + label.zIndex = cy + 101; + labelIdx++; + + // Set gfx z-index for depth sorting + gfx.zIndex = cy + 100; + } + } + + /** Clear nearby hero visuals when there are none to render */ + clearNearbyHeroes(): void { + if (this._nearbyHeroGfx) this._nearbyHeroGfx.clear(); + for (const lbl of this._nearbyHeroLabels) { + lbl.visible = false; + } + } + + /** Sort entity layer by y-position for correct isometric depth */ + sortEntities(): void { + this.entityLayer.sortableChildren = true; + this.entityLayer.children.sort((a, b) => (a.zIndex ?? a.y) - (b.zIndex ?? b.y)); + } + + /** Clean up the renderer */ + destroy(): void { + if (!this._initialized) return; + this.app.destroy(true, { children: true, texture: true }); + this._initialized = false; + } +} diff --git a/frontend/src/game/types.ts b/frontend/src/game/types.ts new file mode 100644 index 0000000..2bd5d46 --- /dev/null +++ b/frontend/src/game/types.ts @@ -0,0 +1,541 @@ +// ---- Game Phase ---- + +export enum GamePhase { + Walking = 'WALKING', + Fighting = 'FIGHTING', + Dead = 'DEAD', + Resting = 'RESTING', + InTown = 'IN_TOWN', +} + +// ---- Buff Types ---- + +export enum BuffType { + Rush = 'rush', // +50% movement speed + Rage = 'rage', // +100% damage + Shield = 'shield', // -50% incoming damage + Luck = 'luck', // x2.5 loot + Resurrection = 'resurrection', // auto-resurrect at 50% HP + Heal = 'heal', // +50% HP instant + PowerPotion = 'power_potion', // +150% damage + WarCry = 'war_cry', // +100% attack speed +} + +// ---- Debuff Types ---- + +export enum DebuffType { + Poison = 'poison', // -2% HP/sec + Freeze = 'freeze', // -50% attack speed + Burn = 'burn', // -3% HP/sec + Stun = 'stun', // no attacks (2 sec) + Slow = 'slow', // -40% movement + Weaken = 'weaken', // -30% outgoing damage +} + +export interface BuffChargeState { + remaining: number; + periodEnd: string | null; +} + +export interface ActiveDebuff { + type: DebuffType; + remainingMs: number; + durationMs: number; + /** Wall-clock expiry when synced from server (optional). */ + expiresAtMs?: number; +} + +// ---- Rarity ---- + +export enum Rarity { + Common = 'common', + Uncommon = 'uncommon', + Rare = 'rare', + Epic = 'epic', + Legendary = 'legendary', +} + +// ---- Enemy Types ---- + +export enum EnemyType { + Wolf = 'wolf', + Boar = 'boar', + Zombie = 'zombie', + Spider = 'spider', + Orc = 'orc', + SkeletonArcher = 'skeleton_archer', + BattleLizard = 'battle_lizard', + FireDemon = 'fire_demon', + IceGuardian = 'ice_guardian', + SkeletonKing = 'skeleton_king', + WaterElement = 'water_element', + ForestWarden = 'forest_warden', + LightningTitan = 'lightning_titan', +} + +// ---- Weapon Types ---- + +export enum WeaponType { + Daggers = 'daggers', + Sword = 'sword', + Axe = 'axe', +} + +// ---- Armor Types ---- + +export enum ArmorType { + Light = 'light', + Medium = 'medium', + Heavy = 'heavy', +} + +// ---- Loot ---- + +export interface LootDrop { + itemType: 'weapon' | 'armor' | 'gold'; + itemName?: string; + rarity: Rarity; + goldAmount: number; + /** Optional equipment drop shown together with gold (backend may return gold + item). */ + bonusItem?: { + itemType: 'weapon' | 'armor'; + rarity: Rarity; + itemName?: string; + }; +} + +// ---- Entity State ---- + +export interface Position { + x: number; + y: number; +} + +export interface HeroState { + id: number; + hp: number; + maxHp: number; + position: Position; + attackSpeed: number; + damage: number; + defense: number; + weaponType: WeaponType; + weaponName: string; + weaponRarity: Rarity; + weaponIlvl?: number; + armorType: ArmorType; + armorName: string; + armorRarity: Rarity; + armorIlvl?: number; + activeBuffs: ActiveBuff[]; + debuffs: ActiveDebuff[]; + level: number; + xp: number; + xpToNext: number; + gold: number; + // Secondary stats + strength: number; + constitution: number; + agility: number; + luck: number; + /** Server-only meta for revive quota UI */ + reviveCount?: number; + subscriptionActive?: boolean; + /** Free buff activations left (non-subscribers); from server */ + buffFreeChargesRemaining?: number; + /** ISO timestamp when the free buff quota window resets */ + buffQuotaPeriodEnd?: string; + /** Per-buff charge quotas (remaining activations per 24h period) */ + buffCharges: Partial>; + /** Number of healing potions the hero currently holds */ + potions: number; + /** Movement speed multiplier (1.0 = normal, affected by buffs/debuffs) */ + moveSpeed?: number; + /** Extended equipment slots (§6.3): slot key -> equipped item */ + equipment?: Record; +} + +export interface ActiveBuff { + type: BuffType; + remainingMs: number; + durationMs: number; + cooldownMs: number; + cooldownRemainingMs: number; + /** Wall-clock expiry when synced from server (optional). */ + expiresAtMs?: number; +} + +export interface EnemyState { + id: number; + name: string; + hp: number; + maxHp: number; + position: Position; + attackSpeed: number; + damage: number; + defense: number; + enemyType: EnemyType; +} + +// ---- Full Game State ---- + +export interface GameState { + phase: GamePhase; + hero: HeroState | null; + enemy: EnemyState | null; + loot: LootDrop | null; + /** Last victory rewards; kept after the transient loot popup clears */ + lastVictoryLoot: LootDrop | null; + tick: number; + serverTimeMs: number; +} + +// ---- Rendering State (interpolated) ---- + +export interface RenderableEntity { + id: string; + screenX: number; + screenY: number; + animationState: AnimationState; + facing: 'left' | 'right'; + flashTimer: number; +} + +export enum AnimationState { + Idle = 'idle', + Walk = 'walk', + Attack = 'attack', + Hit = 'hit', + Death = 'death', + BuffActivation = 'buff_activation', +} + +// ---- Adventure Log ---- + +export interface AdventureLogEntry { + id: number; + message: string; + timestamp: number; +} + +// ---- Town & NPC & Quest ---- + +export interface Town { + id: number; + name: string; + biome: string; + worldX: number; + worldY: number; + radius: number; + levelMin: number; + levelMax: number; +} + +export interface NPC { + id: number; + townId: number; + name: string; + type: 'quest_giver' | 'merchant' | 'healer'; + offsetX: number; + offsetY: number; +} + +export interface Quest { + id: number; + npcId: number; + title: string; + description: string; + type: 'kill_count' | 'visit_town' | 'collect_item'; + targetCount: number; + targetEnemyType?: string; + targetTownId?: number; + dropChance: number; + minLevel: number; + maxLevel: number; + rewardXp: number; + rewardGold: number; + rewardPotions: number; +} + +export interface HeroQuest { + id: number; + questId: number; + title: string; + description: string; + type: string; + targetCount: number; + progress: number; + status: 'accepted' | 'completed' | 'claimed'; + rewardXp: number; + rewardGold: number; + rewardPotions: number; + npcName: string; + townName: string; +} + +// ---- Equipment Item (extended slots per §6.3) ---- + +export interface EquipmentItem { + id: number; + slot: string; + formId: string; + name: string; + rarity: Rarity; + ilvl: number; + primaryStat: number; + statType: string; // 'attack' | 'defense' | 'speed' | 'mixed' +} + +/** Canonical equipment slot keys from spec §6.3 */ +export type EquipmentSlot = + | 'main_hand' + | 'off_hand' + | 'head' + | 'chest' + | 'legs' + | 'feet' + | 'cloak' + | 'neck' + | 'finger' + | 'wrist' + | 'quiver'; + +/** NPC data for map rendering and interaction */ +export interface NPCData { + id: number; + name: string; + type: 'quest_giver' | 'merchant' | 'healer'; + worldX: number; + worldY: number; +} + +/** Alias: engine-facing town data for map rendering */ +export interface TownData { + id: number; + name: string; + centerX: number; + centerY: number; + radius: number; + /** Server biome id (meadow, forest, …) — drives wild tiles around the road network. */ + biome: string; + levelMin: number; + size: string; + npcs?: NPCData[]; +} + +/** NPC encounter event returned instead of an enemy */ +export interface NPCEncounterEvent { + type: 'npc_event'; + npcName: string; + message: string; + cost: number; +} + +// ---- Daily Tasks ---- + +export interface DailyTask { + id: string; + label: string; + current: number; + target: number; +} + +// ---- Nearby Heroes (shared world) ---- + +export interface NearbyHeroData { + id: number; + name: string; + level: number; + positionX: number; + positionY: number; +} + +// ---- Floating Damage ---- + +export interface FloatingDamageData { + id: number; + value: number; + x: number; + y: number; + isCrit: boolean; + createdAt: number; +} + +// ---- Server -> Client Message Payloads ---- + +export type ServerMessageType = + | 'hero_state' + | 'hero_move' + | 'position_sync' + | 'route_assigned' + | 'combat_start' + | 'attack' + | 'combat_end' + | 'hero_died' + | 'hero_revived' + | 'buff_applied' + | 'town_enter' + | 'town_exit' + | 'town_npc_visit' + | 'npc_encounter' + | 'level_up' + | 'equipment_change' + | 'potion_collected' + | 'quest_available' + | 'quest_progress' + | 'quest_complete' + | 'error' + | 'pong'; + +export interface HeroMovePayload { + x: number; + y: number; + targetX: number; + targetY: number; + speed: number; + heading?: number; +} + +export interface PositionSyncPayload { + x: number; + y: number; + waypointIndex: number; + waypointFraction: number; + state: string; +} + +export interface RouteAssignedPayload { + roadId: number; + waypoints: Array<{ x: number; y: number }>; + destinationTownId: number; + speed: number; +} + +export interface CombatStartPayload { + enemy: { + name: string; + type: string; + hp: number; + maxHp: number; + attack: number; + defense: number; + speed: number; + isElite?: boolean; + }; +} + +export interface AttackPayload { + source: 'hero' | 'enemy' | 'potion'; + damage: number; + isCrit: boolean; + heroHp: number; + enemyHp: number; + debuffApplied?: string; +} + +export interface CombatEndPayload { + xpGained: number; + goldGained: number; + loot: Array<{ itemType: string; name: string; rarity: string }>; + leveledUp: boolean; + newLevel?: number; +} + +export interface HeroDiedPayload { + killedBy: string; +} + +export interface HeroRevivedPayload { + hp: number; +} + +export interface BuffAppliedPayload { + buffType: string; + duration: number; + magnitude?: number; +} + +export interface TownEnterPayload { + townId: number; + townName: string; + biome?: string; + npcs?: Array<{ id: number; name: string; type: string }>; + restDurationMs?: number; +} + +export interface TownNPCVisitPayload { + npcId: number; + name: string; + type: string; + townId: number; +} + +export interface TownExitPayload {} + +export interface NPCEncounterPayload { + npcId: number; + npcName: string; + role: string; + dialogue?: string; + cost: number; +} + +export interface LevelUpPayload { + newLevel: number; + statChanges: { + hp?: number; + attack?: number; + defense?: number; + strength?: number; + constitution?: number; + agility?: number; + luck?: number; + }; +} + +export interface EquipmentChangePayload { + slot: string; + item: EquipmentItem; +} + +export interface PotionCollectedPayload { + count: number; +} + +export interface QuestAvailablePayload { + questId: number; + title: string; + description: string; + npcName: string; +} + +export interface QuestProgressPayload { + questId: number; + current: number; + target: number; + title?: string; +} + +export interface QuestCompletePayload { + questId: number; + title: string; + rewards: { xp: number; gold: number }; +} + +export interface ServerErrorPayload { + code: string; + message: string; +} + +// ---- Client -> Server Commands ---- + +export type ClientCommandType = + | 'activate_buff' + | 'use_potion' + | 'revive' + | 'accept_quest' + | 'claim_quest' + | 'npc_interact' + | 'npc_alms_accept' + | 'npc_alms_decline' + | 'ping'; diff --git a/frontend/src/game/ws-handler.ts b/frontend/src/game/ws-handler.ts new file mode 100644 index 0000000..996b6ee --- /dev/null +++ b/frontend/src/game/ws-handler.ts @@ -0,0 +1,263 @@ +import type { GameWebSocket, ServerMessage } from '../network/websocket'; +import type { GameEngine } from './engine'; +import type { + HeroMovePayload, + PositionSyncPayload, + RouteAssignedPayload, + CombatStartPayload, + AttackPayload, + CombatEndPayload, + HeroDiedPayload, + HeroRevivedPayload, + BuffAppliedPayload, + TownEnterPayload, + TownNPCVisitPayload, + NPCEncounterPayload, + LevelUpPayload, + EquipmentChangePayload, + PotionCollectedPayload, + QuestProgressPayload, + QuestCompletePayload, + QuestAvailablePayload, + ServerErrorPayload, + EnemyState, + LootDrop, +} from './types'; +import { EnemyType, Rarity } from './types'; + +// ---- Callback types for UI layer (App.tsx) ---- + +export interface WSHandlerCallbacks { + onCombatEnd?: (payload: CombatEndPayload) => void; + onHeroDied?: (payload: HeroDiedPayload) => void; + onHeroRevived?: (payload: HeroRevivedPayload) => void; + onBuffApplied?: (payload: BuffAppliedPayload) => void; + onTownEnter?: (payload: TownEnterPayload) => void; + onTownNPCVisit?: (payload: TownNPCVisitPayload) => void; + onTownExit?: () => void; + onNPCEncounter?: (payload: NPCEncounterPayload) => void; + onLevelUp?: (payload: LevelUpPayload) => void; + onEquipmentChange?: (payload: EquipmentChangePayload) => void; + onPotionCollected?: (payload: PotionCollectedPayload) => void; + onQuestProgress?: (payload: QuestProgressPayload) => void; + onQuestComplete?: (payload: QuestCompletePayload) => void; + onQuestAvailable?: (payload: QuestAvailablePayload) => void; + onError?: (payload: ServerErrorPayload) => void; + onHeroStateReceived?: (hero: Record) => void; +} + +/** + * Bridges WebSocket messages to engine state updates and UI callbacks. + * + * This is a stateless dispatcher: it parses typed envelopes from the + * server and calls the appropriate engine method or UI callback. + * No game logic lives here -- just routing. + */ +export function wireWSHandler( + ws: GameWebSocket, + engine: GameEngine, + callbacks: WSHandlerCallbacks, +): void { + // ---- Server -> Client: Movement ---- + + ws.on('hero_move', (msg: ServerMessage) => { + const p = msg.payload as HeroMovePayload; + engine.applyHeroMove(p.x, p.y, p.targetX, p.targetY, p.speed); + }); + + ws.on('position_sync', (msg: ServerMessage) => { + const p = msg.payload as PositionSyncPayload; + engine.applyPositionSync(p.x, p.y, p.state); + }); + + ws.on('route_assigned', (msg: ServerMessage) => { + const p = msg.payload as RouteAssignedPayload; + engine.applyRouteAssigned(p.waypoints, p.speed); + }); + + // ---- Server -> Client: Hero state snapshot ---- + + ws.on('hero_state', (msg: ServerMessage) => { + const payload = msg.payload as Record; + callbacks.onHeroStateReceived?.(payload); + }); + + // ---- Server -> Client: Combat ---- + + ws.on('combat_start', (msg: ServerMessage) => { + const p = msg.payload as CombatStartPayload; + const enemy: EnemyState = { + id: Date.now(), + name: p.enemy.name, + hp: p.enemy.hp, + maxHp: p.enemy.maxHp, + position: { x: 0, y: 0 }, // engine will position relative to hero + attackSpeed: p.enemy.speed, + damage: p.enemy.attack, + defense: p.enemy.defense, + enemyType: (p.enemy.type as EnemyType) || EnemyType.Wolf, + }; + engine.applyCombatStart(enemy); + }); + + ws.on('attack', (msg: ServerMessage) => { + const p = msg.payload as AttackPayload; + engine.applyAttack(p.source, p.damage, p.isCrit, p.heroHp, p.enemyHp); + }); + + ws.on('combat_end', (msg: ServerMessage) => { + const p = msg.payload as CombatEndPayload; + engine.applyCombatEnd(); + callbacks.onCombatEnd?.(p); + }); + + // ---- Server -> Client: Death / Revive ---- + + ws.on('hero_died', (msg: ServerMessage) => { + const p = msg.payload as HeroDiedPayload; + engine.applyHeroDied(); + callbacks.onHeroDied?.(p); + }); + + ws.on('hero_revived', (msg: ServerMessage) => { + const p = msg.payload as HeroRevivedPayload; + engine.applyHeroRevived(p.hp); + callbacks.onHeroRevived?.(p); + }); + + // ---- Server -> Client: Buffs ---- + + ws.on('buff_applied', (msg: ServerMessage) => { + const p = msg.payload as BuffAppliedPayload; + callbacks.onBuffApplied?.(p); + }); + + // ---- Server -> Client: Town ---- + + ws.on('town_enter', (msg: ServerMessage) => { + const p = msg.payload as TownEnterPayload; + engine.applyTownEnter(); + callbacks.onTownEnter?.(p); + }); + + ws.on('town_exit', () => { + engine.applyTownExit(); + callbacks.onTownExit?.(); + }); + + ws.on('town_npc_visit', (msg: ServerMessage) => { + const p = msg.payload as TownNPCVisitPayload; + engine.applyTownNPCVisit(p.name, p.type); + callbacks.onTownNPCVisit?.(p); + }); + + // ---- Server -> Client: NPC Encounter ---- + + ws.on('npc_encounter', (msg: ServerMessage) => { + const p = msg.payload as NPCEncounterPayload; + callbacks.onNPCEncounter?.(p); + }); + + // ---- Server -> Client: Progression ---- + + ws.on('level_up', (msg: ServerMessage) => { + const p = msg.payload as LevelUpPayload; + callbacks.onLevelUp?.(p); + }); + + ws.on('equipment_change', (msg: ServerMessage) => { + const p = msg.payload as EquipmentChangePayload; + callbacks.onEquipmentChange?.(p); + }); + + ws.on('potion_collected', (msg: ServerMessage) => { + const p = msg.payload as PotionCollectedPayload; + callbacks.onPotionCollected?.(p); + }); + + // ---- Server -> Client: Quests ---- + + ws.on('quest_progress', (msg: ServerMessage) => { + const p = msg.payload as QuestProgressPayload; + callbacks.onQuestProgress?.(p); + }); + + ws.on('quest_complete', (msg: ServerMessage) => { + const p = msg.payload as QuestCompletePayload; + callbacks.onQuestComplete?.(p); + }); + + ws.on('quest_available', (msg: ServerMessage) => { + const p = msg.payload as QuestAvailablePayload; + callbacks.onQuestAvailable?.(p); + }); + + // ---- Server -> Client: Error ---- + + ws.on('error', (msg: ServerMessage) => { + const p = msg.payload as ServerErrorPayload; + console.warn('[WS] Server error:', p.code, p.message); + callbacks.onError?.(p); + }); +} + +// ---- Client -> Server command helpers ---- + +export function sendActivateBuff(ws: GameWebSocket, buffType: string): void { + ws.send('activate_buff', { buffType }); +} + +export function sendUsePotion(ws: GameWebSocket): void { + ws.send('use_potion', {}); +} + +export function sendRevive(ws: GameWebSocket): void { + ws.send('revive', {}); +} + +export function sendAcceptQuest(ws: GameWebSocket, questId: number): void { + ws.send('accept_quest', { questId }); +} + +export function sendClaimQuest(ws: GameWebSocket, questId: number): void { + ws.send('claim_quest', { questId }); +} + +export function sendNPCInteract(ws: GameWebSocket, npcId: number): void { + ws.send('npc_interact', { npcId }); +} + +export function sendNPCAlmsAccept(ws: GameWebSocket): void { + ws.send('npc_alms_accept', {}); +} + +export function sendNPCAlmsDecline(ws: GameWebSocket): void { + ws.send('npc_alms_decline', {}); +} + +/** + * Build a LootDrop from combat_end payload for the loot popup UI. + */ +export function buildLootFromCombatEnd(p: CombatEndPayload): LootDrop | null { + if (p.goldGained <= 0 && p.loot.length === 0) return null; + + const equip = p.loot.find( + (l) => l.itemType === 'weapon' || l.itemType === 'armor', + ); + + return { + itemType: 'gold', + rarity: equip + ? ((equip.rarity?.toLowerCase() ?? 'common') as Rarity) + : Rarity.Common, + goldAmount: Math.max(0, p.goldGained), + itemName: equip?.name, + bonusItem: equip + ? { + itemType: equip.itemType as 'weapon' | 'armor', + rarity: (equip.rarity?.toLowerCase() ?? 'common') as Rarity, + itemName: equip.name, + } + : undefined, + }; +} diff --git a/frontend/src/hooks/useUiClock.ts b/frontend/src/hooks/useUiClock.ts new file mode 100644 index 0000000..372ba85 --- /dev/null +++ b/frontend/src/hooks/useUiClock.ts @@ -0,0 +1,11 @@ +import { useEffect, useState } from 'react'; + +/** Monotonic wall clock for cooldown / effect countdown UI (low-frequency re-renders). */ +export function useUiClock(intervalMs = 100): number { + const [t, setT] = useState(() => Date.now()); + useEffect(() => { + const id = window.setInterval(() => setT(Date.now()), intervalMs); + return () => window.clearInterval(id); + }, [intervalMs]); + return t; +} diff --git a/frontend/src/main.tsx b/frontend/src/main.tsx new file mode 100644 index 0000000..7215121 --- /dev/null +++ b/frontend/src/main.tsx @@ -0,0 +1,18 @@ +import { StrictMode } from 'react'; +import { createRoot } from "react-dom/client"; +import { App } from './App'; +import { initTelegramApp } from './shared/telegram'; + +// Initialize Telegram Mini App SDK before rendering +initTelegramApp(); + +const rootEl = document.getElementById('root'); +if (!rootEl) { + throw new Error('Root element not found'); +} + +createRoot(rootEl).render( + + + , +); diff --git a/frontend/src/network/api.ts b/frontend/src/network/api.ts new file mode 100644 index 0000000..c163d9e --- /dev/null +++ b/frontend/src/network/api.ts @@ -0,0 +1,671 @@ +import { API_BASE } from '../shared/constants'; +import { getTelegramInitData } from '../shared/telegram'; +import type { ServerActiveBuffRow, ServerActiveDebuffRow } from './buffMap'; + +/** + * REST API client for /api/v1/* endpoints. + * + * All requests include Telegram initData for authentication. + * Responses are typed via generics. + */ + +export class ApiError extends Error { + constructor( + public status: number, + public statusText: string, + public body: string, + ) { + super(`API Error ${status}: ${statusText}`); + this.name = 'ApiError'; + } +} + +/** Build headers with Telegram auth */ +function buildHeaders(extra?: Record): Record { + const headers: Record = { + 'Content-Type': 'application/json', + ...extra, + }; + + const initData = getTelegramInitData(); + if (initData) { + headers['X-Telegram-Init-Data'] = initData; + } + + return headers; +} + +/** Parse response or throw ApiError */ +async function handleResponse(res: Response): Promise { + if (!res.ok) { + const body = await res.text().catch(() => ''); + throw new ApiError(res.status, res.statusText, body); + } + + // 204 No Content + if (res.status === 204) { + return undefined as T; + } + + return res.json() as Promise; +} + +/** GET request */ +export async function apiGet(path: string): Promise { + const res = await fetch(`${API_BASE}${path}`, { + method: 'GET', + headers: buildHeaders(), + }); + return handleResponse(res); +} + +/** POST request */ +export async function apiPost(path: string, body?: unknown): Promise { + const res = await fetch(`${API_BASE}${path}`, { + method: 'POST', + headers: buildHeaders(), + body: body !== undefined ? JSON.stringify(body) : undefined, + }); + return handleResponse(res); +} + +/** PUT request */ +export async function apiPut(path: string, body?: unknown): Promise { + const res = await fetch(`${API_BASE}${path}`, { + method: 'PUT', + headers: buildHeaders(), + body: body !== undefined ? JSON.stringify(body) : undefined, + }); + return handleResponse(res); +} + +/** DELETE request */ +export async function apiDelete(path: string): Promise { + const res = await fetch(`${API_BASE}${path}`, { + method: 'DELETE', + headers: buildHeaders(), + }); + return handleResponse(res); +} + +// ---- Typed API Methods ---- + +export interface HeroResponse { + id: number; + telegramId: number; + name: string; + hp: number; + maxHp: number; + attack: number; + defense: number; + speed: number; + attackSpeed?: number; + attackPower?: number; + defensePower?: number; + strength: number; + constitution: number; + agility: number; + luck: number; + state: string; + weaponId: number; + armorId: number; + weapon: WeaponResponse | null; + armor: ArmorResponse | null; + gold: number; + xp: number; + xpToNext?: number; + level: number; + reviveCount?: number; + subscriptionActive?: boolean; + buffFreeChargesRemaining?: number; + buffQuotaPeriodEnd?: string; + buffCharges?: Record; + potions?: number; + positionX?: number; + positionY?: number; + moveSpeed?: number; + buffs?: ServerActiveBuffRow[]; + debuffs?: ServerActiveDebuffRow[]; + /** Extended equipment slots (§6.3) keyed by slot name */ + equipment?: Record; +} + +export interface AuthResponse { + token: string; + heroId: number; +} + +/** Authenticate via Telegram initData, returns session info */ +export async function authenticate(): Promise { + return apiPost('/auth/telegram'); +} + +/** Get current hero state */ +export async function getHero(telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiGet(`/hero${query}`); +} + +export interface OfflineReport { + offlineSeconds: number; + monstersKilled: number; + xpGained: number; + goldGained: number; + levelsGained: number; + message: string; +} + +export interface InitHeroResponse { + hero: HeroResponse; + offlineReport: OfflineReport | null; + mapRef: MapRefResponse; + needsName?: boolean; +} + +/** Initialize or retrieve a hero from the backend (creates on first call) */ +export async function initHero(telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiGet(`/hero/init${query}`); +} + +/** Set the hero's display name (first time only). Returns updated hero on success. */ +export async function setHeroName(name: string, telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiPost(`/hero/name${query}`, { name }); +} + +export interface MapRefResponse { + mapId: string; + mapVersion: string; + etag: string; + biome: string; + recommendedLevelMin: number; + recommendedLevelMax: number; +} + +export interface MapTileResponse { + x: number; + y: number; + terrain: string; +} + +export interface MapObjectResponse { + id: string; + type: string; + x: number; + y: number; +} + +export interface SpawnPointResponse { + id: string; + kind: string; + x: number; + y: number; +} + +export interface ServerMapResponse { + mapId: string; + mapVersion: string; + biome: string; + recommendedLevelMin: number; + recommendedLevelMax: number; + width: number; + height: number; + tiles: MapTileResponse[]; + objects: MapObjectResponse[]; + spawnPoints: SpawnPointResponse[]; +} + +export interface GetMapResult { + map: ServerMapResponse | null; + etag: string; + notModified: boolean; +} + +/** Get map payload by map ID with optional ETag conditional fetch. */ +export async function getMap(mapId: string, etag?: string): Promise { + const headers = buildHeaders(); + if (etag) { + headers['If-None-Match'] = etag; + } + + const res = await fetch(`${API_BASE}/maps/${encodeURIComponent(mapId)}`, { + method: 'GET', + headers, + }); + + const responseEtag = res.headers.get('ETag') ?? etag ?? ''; + if (res.status === 304) { + return { + map: null, + etag: responseEtag, + notModified: true, + }; + } + if (!res.ok) { + const body = await res.text().catch(() => ''); + throw new ApiError(res.status, res.statusText, body); + } + + return { + map: await res.json() as ServerMapResponse, + etag: responseEtag, + notModified: false, + }; +} + +export interface ActivateBuffResponse { + buff: ServerActiveBuffRow; + heroBuffs: ServerActiveBuffRow[]; + hero?: HeroResponse; +} + +/** Activate a buff by type */ +export async function activateBuff( + buffType: string, + telegramId?: number, +): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiPost(`/hero/buff/${buffType}${query}`); +} + +/** Request revive after death — returns authoritative hero snapshot */ +export async function requestRevive(telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiPost(`/hero/revive${query}`); +} + +export interface VictoryDropResponse { + itemType: string; + itemId?: number; + itemName?: string; + rarity: string; + goldAmount: number; +} + +export interface ReportVictoryResponse { + hero: HeroResponse; + drops: VictoryDropResponse[]; +} + +/** Apply server-side kill rewards (XP, gold, loot rolls, HP rules) after client-resolved combat */ +export async function reportVictory( + body: { enemyType: string; heroHp: number; positionX?: number; positionY?: number }, + telegramId?: number, +): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiPost(`/hero/victory${query}`, body); +} + +// ---- Loot & Equipment ---- + +export interface LootResponse { + itemType: 'weapon' | 'armor' | 'gold'; + itemName?: string; + rarity: string; + goldAmount: number; +} + +export interface WeaponResponse { + id: number; + name: string; + type: string; + rarity: string; + damage: number; + speedMultiplier: number; + ilvl?: number; +} + +export interface ArmorResponse { + id: number; + name: string; + type: string; + rarity: string; + defense: number; + speedMultiplier: number; + ilvl?: number; +} + +export interface EncounterEnemyResponse { + id: number; + name: string; + hp: number; + maxHp: number; + attack: number; + defense: number; + speed: number; + enemyType: string; +} + +/** Fetch extended equipment slots for the hero */ +export async function getHeroEquipment(telegramId?: number): Promise> { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiGet>(`/hero/equipment${query}`); +} + +export interface EquipmentItemResponse { + id: number; + slot: string; + formId: string; + name: string; + rarity: string; + ilvl: number; + basePrimary: number; + primaryStat: number; + statType: string; +} + +/** Ask backend to generate the next encounter enemy for this hero. */ +export async function requestEncounter(telegramId?: number, posX?: number, posY?: number): Promise { + const params = new URLSearchParams(); + if (telegramId != null) params.set('telegramId', String(telegramId)); + if (posX != null) params.set('posX', posX.toFixed(2)); + if (posY != null) params.set('posY', posY.toFixed(2)); + const query = params.toString() ? `?${params.toString()}` : ''; + return apiPost(`/hero/encounter${query}`); +} + +/** Get recent loot drops for the hero */ +export async function getLoot(): Promise { + return apiGet('/hero/loot'); +} + +/** Get available weapons catalog */ +export async function getWeapons(): Promise { + return apiGet('/weapons'); +} + +/** Get available armor catalog */ +export async function getArmor(): Promise { + return apiGet('/armor'); +} + +// ---- Adventure Log ---- + +export interface LogEntry { + id: number; + message: string; + createdAt: string; +} + +/** Fetch recent adventure log entries (offline events, etc.) */ +export async function getAdventureLog(telegramId?: number, limit?: number): Promise { + const params = new URLSearchParams(); + if (telegramId != null) params.set('telegramId', String(telegramId)); + if (limit != null) params.set('limit', String(limit)); + const query = params.toString() ? `?${params.toString()}` : ''; + return apiGet(`/hero/log${query}`); +} + +// ---- Potions ---- + +/** Use a healing potion; returns updated hero state */ +export async function usePotion(telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiPost(`/hero/use-potion${query}`); +} + +// ---- Towns ---- + +import type { Town, HeroQuest, NPC, Quest } from '../game/types'; + +/** Fetch all towns */ +export async function getTowns(): Promise { + return apiGet('/towns'); +} + +/** Fetch NPCs for a town */ +export async function getTownNPCs(townId: number): Promise { + return apiGet(`/towns/${townId}/npcs`); +} + +/** Fetch available quests from an NPC */ +export async function getNPCQuests(npcId: number, telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiGet(`/npcs/${npcId}/quests${query}`); +} + +// ---- Hero Quests ---- + +/** Raw shape from backend — quest details are nested under "quest" */ +interface HeroQuestRaw { + id: number; + heroId: number; + questId: number; + status: string; + progress: number; + quest?: { + id: number; + npcId: number; + title: string; + description: string; + type: string; + targetCount: number; + targetEnemyType?: string; + targetTownId?: number; + dropChance: number; + minLevel: number; + maxLevel: number; + rewardXp: number; + rewardGold: number; + rewardPotions: number; + }; + // Also accept flat fields in case backend changes later + title?: string; + description?: string; + type?: string; + targetCount?: number; + rewardXp?: number; + rewardGold?: number; + rewardPotions?: number; + npcName?: string; + townName?: string; +} + +function flattenHeroQuest(raw: HeroQuestRaw): HeroQuest { + const q = raw.quest; + return { + id: raw.id, + questId: raw.questId, + title: raw.title ?? q?.title ?? '', + description: raw.description ?? q?.description ?? '', + type: raw.type ?? q?.type ?? '', + targetCount: raw.targetCount ?? q?.targetCount ?? 0, + progress: raw.progress, + status: (raw.status as HeroQuest['status']) ?? 'accepted', + rewardXp: raw.rewardXp ?? q?.rewardXp ?? 0, + rewardGold: raw.rewardGold ?? q?.rewardGold ?? 0, + rewardPotions: raw.rewardPotions ?? q?.rewardPotions ?? 0, + npcName: raw.npcName ?? '', + townName: raw.townName ?? '', + }; +} + +/** Fetch hero's active/completed quests */ +export async function getHeroQuests(telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + const raw = await apiGet(`/hero/quests${query}`); + return raw.map(flattenHeroQuest); +} + +/** Accept a quest */ +export async function acceptQuest(questId: number, telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiPost(`/hero/quests/${questId}/accept${query}`); +} + +/** Claim a completed quest's rewards */ +export async function claimQuest(heroQuestId: number, telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiPost(`/hero/quests/${heroQuestId}/claim${query}`); +} + +/** Abandon a quest */ +export async function abandonQuest(heroQuestId: number, telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiDelete(`/hero/quests/${heroQuestId}${query}`); +} + +// ---- NPC Services ---- + +/** Buy a potion from a merchant NPC (matches backend POST /api/v1/hero/npc-buy-potion) */ +export async function buyPotion(telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiPost(`/hero/npc-buy-potion${query}`); +} + +/** Heal to full at a healer NPC (matches backend POST /api/v1/hero/npc-heal) */ +export async function healAtNPC(telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiPost(`/hero/npc-heal${query}`); +} + +// ---- NPC Proximity & Interaction ---- + +export interface NearbyNPCResponse { + id: number; + name: string; + type: string; + worldX: number; + worldY: number; +} + +export interface NPCInteractResponse { + npcName: string; + npcType: string; + actions: Array<{ type: string; label: string; cost?: number }>; + quests?: Quest[]; +} + +/** Fetch NPCs near the hero's current position */ +export async function getNearbyNPCs(telegramId?: number, posX?: number, posY?: number): Promise { + const params = new URLSearchParams(); + if (telegramId != null) params.set('telegramId', String(telegramId)); + if (posX != null) params.set('posX', String(posX)); + if (posY != null) params.set('posY', String(posY)); + const query = params.toString() ? `?${params.toString()}` : ''; + return apiGet(`/hero/nearby-npcs${query}`); +} + +/** Interact with an NPC to get available actions */ +export async function interactWithNPC(npcId: number, telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiPost(`/npcs/${npcId}/interact${query}`); +} + +/** Buy an item from a merchant NPC */ +export async function buyFromMerchant(npcId: number, item: string, telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiPost(`/npcs/${npcId}/buy${query}`, { item }); +} + +/** Heal at a healer NPC */ +export async function healAtHealerNPC(npcId: number, telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiPost(`/npcs/${npcId}/heal${query}`); +} + +// ---- Wandering NPC alms ---- + +/** Matches backend model.AlmsResponse (POST /hero/npc-alms) */ +export interface NPCAlmsResponse { + accepted: boolean; + message: string; + goldSpent?: number; + itemDrop?: { + itemType: string; + itemId?: number; + itemName?: string; + rarity: string; + goldAmount?: number; + }; + hero?: HeroResponse; +} + +/** Give gold to a wandering NPC for a mysterious item */ +export async function giveNPCAlms(telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiPost(`/hero/npc-alms${query}`, { accept: true }); +} + +/** Purchase a buff charge refill (placeholder for Telegram Payments integration) */ +export async function purchaseBuffRefill( + buffType: string, + telegramId?: number, +): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiPost(`/hero/purchase-buff-refill${query}`, { buffType }); +} + +// ---- Achievements (spec 10.3) ---- + +export interface Achievement { + id: string; + title: string; + description: string; + conditionType: string; + conditionValue: number; + rewardType: string; + rewardAmount: number; + unlocked: boolean; + unlockedAt?: string; +} + +/** Fetch all achievements with unlock status */ +export async function getAchievements(telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiGet(`/hero/achievements${query}`); +} + +// ---- Nearby Heroes (spec 2.3 shared world) ---- + +export interface NearbyHero { + id: number; + name: string; + level: number; + positionX: number; + positionY: number; +} + +/** Fetch heroes near the player's current position */ +export async function getNearbyHeroes(telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiGet(`/hero/nearby${query}`); +} + +// ---- Daily Tasks (backend-driven, spec 10.1) ---- + +export interface DailyTaskResponse { + taskId: string; + title: string; + description: string; + objectiveType: string; + objectiveCount: number; + progress: number; + completed: boolean; + claimed: boolean; + rewardType: string; + rewardAmount: number; + period: string; +} + +/** Fetch daily tasks with progress */ +export async function getDailyTasks(telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiGet(`/hero/daily-tasks${query}`); +} + +/** Claim a completed daily task reward */ +export async function claimDailyTask(taskId: string, telegramId?: number): Promise { + const query = telegramId != null ? `?telegramId=${telegramId}` : ''; + return apiPost(`/hero/daily-tasks/${encodeURIComponent(taskId)}/claim${query}`); +} diff --git a/frontend/src/network/buffMap.ts b/frontend/src/network/buffMap.ts new file mode 100644 index 0000000..988c034 --- /dev/null +++ b/frontend/src/network/buffMap.ts @@ -0,0 +1,148 @@ +import { BuffType, DebuffType, type ActiveBuff, type ActiveDebuff } from '../game/types'; + +/** Mirrors backend/internal/model/buff.go CooldownDuration */ +export const BUFF_COOLDOWN_MS: Record = { + [BuffType.Rush]: 15 * 60_000, // 15 min + [BuffType.Rage]: 10 * 60_000, // 10 min + [BuffType.Shield]: 12 * 60_000, // 12 min + [BuffType.Luck]: 2 * 60 * 60_000, // 2 hours + [BuffType.Resurrection]: 30 * 60_000, // 30 min + [BuffType.Heal]: 5 * 60_000, // 5 min + [BuffType.PowerPotion]: 20 * 60_000, // 20 min + [BuffType.WarCry]: 10 * 60_000, // 10 min +}; + +/** Max buff charges per 24h period (mirrors backend per-buff quotas). */ +export const BUFF_MAX_CHARGES: Record = { + [BuffType.Rush]: 3, + [BuffType.Rage]: 2, + [BuffType.Shield]: 2, + [BuffType.Luck]: 1, + [BuffType.Resurrection]: 1, + [BuffType.Heal]: 3, + [BuffType.PowerPotion]: 1, + [BuffType.WarCry]: 2, +}; + +/** Mirrors backend/internal/model/buff.go Duration */ +export const BUFF_DURATION_MS: Record = { + [BuffType.Rush]: 5 * 60_000, // 5 min + [BuffType.Rage]: 3 * 60_000, // 3 min + [BuffType.Shield]: 5 * 60_000, // 5 min + [BuffType.Luck]: 30 * 60_000, // 30 min + [BuffType.Resurrection]: 10 * 60_000, // 10 min + [BuffType.Heal]: 1_000, // instant + [BuffType.PowerPotion]: 5 * 60_000, // 5 min + [BuffType.WarCry]: 3 * 60_000, // 3 min +}; + +// ---- Server row shapes (Go JSON) ---- + +export interface ServerBuffRow { + id?: number; + type: string; + name?: string; + duration?: number; + magnitude?: number; + cooldownDuration?: number; +} + +export interface ServerActiveBuffRow { + buff: ServerBuffRow; + appliedAt: string; + expiresAt: string; +} + +export interface ServerDebuffRow { + id?: number; + type: string; + name?: string; + duration?: number; + magnitude?: number; +} + +export interface ServerActiveDebuffRow { + debuff: ServerDebuffRow; + appliedAt: string; + expiresAt: string; +} + +function durationToMs(raw: unknown): number { + if (typeof raw === 'number' && Number.isFinite(raw)) { + return Math.round(raw / 1_000_000); + } + return 0; +} + +function isBuffType(s: string): s is BuffType { + return Object.values(BuffType).includes(s as BuffType); +} + +function isDebuffType(s: string): s is DebuffType { + return Object.values(DebuffType).includes(s as DebuffType); +} + +/** Parse one active buff row from the API into client ActiveBuff (with expiresAtMs for UI ticking). */ +export function mapServerActiveBuff(row: ServerActiveBuffRow, nowMs: number): ActiveBuff | null { + const t = row.buff?.type; + if (!t || !isBuffType(t)) return null; + const exp = Date.parse(row.expiresAt); + const app = Date.parse(row.appliedAt); + if (!Number.isFinite(exp) || !Number.isFinite(app)) return null; + + const cooldownMs = durationToMs(row.buff.cooldownDuration) || BUFF_COOLDOWN_MS[t]; + const durationMs = Math.max(0, exp - app); + + return { + type: t, + remainingMs: Math.max(0, exp - nowMs), + durationMs, + cooldownMs, + cooldownRemainingMs: 0, + expiresAtMs: exp, + }; +} + +export function mapServerActiveDebuff(row: ServerActiveDebuffRow, nowMs: number): ActiveDebuff | null { + const t = row.debuff?.type; + if (!t || !isDebuffType(t)) return null; + const exp = Date.parse(row.expiresAt); + const app = Date.parse(row.appliedAt); + if (!Number.isFinite(exp) || !Number.isFinite(app)) return null; + + const durationMs = Math.max(0, exp - app); + return { + type: t, + remainingMs: Math.max(0, exp - nowMs), + durationMs, + expiresAtMs: exp, + }; +} + +export function mapHeroBuffsFromServer(rows: ServerActiveBuffRow[] | undefined, nowMs: number): ActiveBuff[] { + if (!rows?.length) return []; + const out: ActiveBuff[] = []; + for (const row of rows) { + const b = mapServerActiveBuff(row, nowMs); + if (b && b.remainingMs > 0) out.push(b); + } + return out; +} + +export function mapHeroDebuffsFromServer(rows: ServerActiveDebuffRow[] | undefined, nowMs: number): ActiveDebuff[] { + if (!rows?.length) return []; + const out: ActiveDebuff[] = []; + for (const row of rows) { + const d = mapServerActiveDebuff(row, nowMs); + if (d && d.remainingMs > 0) out.push(d); + } + return out; +} + +export function cooldownMsFromActivateBuffRow(row: ServerActiveBuffRow): number { + const t = row.buff?.type; + const fromApi = durationToMs(row.buff?.cooldownDuration); + if (fromApi > 0) return fromApi; + if (t && isBuffType(t)) return BUFF_COOLDOWN_MS[t]; + return 45_000; +} diff --git a/frontend/src/network/websocket.ts b/frontend/src/network/websocket.ts new file mode 100644 index 0000000..0131153 --- /dev/null +++ b/frontend/src/network/websocket.ts @@ -0,0 +1,260 @@ +import { + WS_RECONNECT_BASE_MS, + WS_RECONNECT_MAX_MS, + WS_HEARTBEAT_INTERVAL_MS, + WS_HEARTBEAT_TIMEOUT_MS, + WS_PATH, +} from '../shared/constants'; +import { getTelegramInitData } from '../shared/telegram'; + +// ---- Message Types ---- + +export interface ServerMessage { + type: string; + payload: unknown; +} + +export type MessageHandler = (msg: ServerMessage) => void; + +export type ConnectionState = 'connecting' | 'connected' | 'disconnected' | 'reconnecting'; + +export type ConnectionStateHandler = (state: ConnectionState) => void; + +// ---- WebSocket Client ---- + +/** + * WebSocket client with auto-reconnect, heartbeat, and typed message handling. + * + * Features: + * - Automatic reconnection with exponential backoff + * - Heartbeat ping/pong to detect dead connections + * - Message queue for messages sent while disconnected + * - Typed message handlers by message type + */ +export class GameWebSocket { + private ws: WebSocket | null = null; + private url: string; + private handlers = new Map(); + private connectionStateHandler: ConnectionStateHandler | null = null; + private state: ConnectionState = 'disconnected'; + + // Reconnect state + private reconnectAttempts = 0; + private reconnectTimer: ReturnType | null = null; + private shouldReconnect = true; + + // Heartbeat state + private heartbeatInterval: ReturnType | null = null; + private heartbeatTimeout: ReturnType | null = null; + + // Telegram user ID for dev-mode WS identification + private _telegramId: number | null = null; + + // Message queue (buffered while disconnected) + private messageQueue: string[] = []; + + constructor(url?: string) { + // Build WS URL from current location if not provided + if (url) { + this.url = url; + } else { + const proto = window.location.protocol === 'https:' ? 'wss:' : 'ws:'; + this.url = `${proto}//${window.location.host}${WS_PATH}`; + } + } + + /** Set telegram user ID for WS identification (dev mode fallback). */ + setTelegramId(id: number): void { + this._telegramId = id; + } + + /** Register a handler for a specific message type */ + on(type: string, handler: MessageHandler): void { + const existing = this.handlers.get(type) ?? []; + existing.push(handler); + this.handlers.set(type, existing); + } + + /** Remove a handler */ + off(type: string, handler: MessageHandler): void { + const existing = this.handlers.get(type); + if (!existing) return; + const idx = existing.indexOf(handler); + if (idx >= 0) existing.splice(idx, 1); + } + + /** Register a connection state change handler */ + onConnectionState(handler: ConnectionStateHandler): void { + this.connectionStateHandler = handler; + } + + /** Connect to the server */ + connect(): void { + if (this.ws?.readyState === WebSocket.OPEN) return; + + this.shouldReconnect = true; + this.setConnectionState('connecting'); + + // Append Telegram auth data or telegramId for dev mode + const initData = getTelegramInitData(); + const urlParams = new URLSearchParams(); + if (initData) { + urlParams.set('initData', initData); + } + if (this._telegramId) { + urlParams.set('telegramId', String(this._telegramId)); + } + const qs = urlParams.toString(); + const separator = this.url.includes('?') ? '&' : '?'; + const fullUrl = qs ? `${this.url}${separator}${qs}` : this.url; + + this.ws = new WebSocket(fullUrl); + + this.ws.onopen = () => { + this.reconnectAttempts = 0; + this.setConnectionState('connected'); + this.startHeartbeat(); + this.flushQueue(); + console.info('[WS] Connected'); + }; + + this.ws.onmessage = (event: MessageEvent) => { + this.resetHeartbeatTimeout(); + + if (event.data === 'pong') return; + + try { + const msg = JSON.parse(event.data as string) as ServerMessage; + // Handle JSON pong response from server + if (msg.type === 'pong') return; + this.dispatch(msg); + } catch (err) { + console.warn('[WS] Failed to parse message:', err); + } + }; + + this.ws.onclose = (event) => { + console.info(`[WS] Closed: code=${event.code} reason=${event.reason}`); + this.cleanup(); + if (this.shouldReconnect) { + this.scheduleReconnect(); + } else { + this.setConnectionState('disconnected'); + } + }; + + this.ws.onerror = () => { + // Error details are intentionally opaque in browsers. + // The onclose handler will fire next and handle reconnection. + console.warn('[WS] Connection error'); + }; + } + + /** Send a typed message to the server */ + send(type: string, payload: unknown): void { + const msg = JSON.stringify({ type, payload }); + + if (this.ws?.readyState === WebSocket.OPEN) { + this.ws.send(msg); + } else { + // Buffer for when we reconnect + this.messageQueue.push(msg); + } + } + + /** Disconnect and stop reconnecting */ + disconnect(): void { + this.shouldReconnect = false; + this.cleanup(); + this.ws?.close(1000, 'client disconnect'); + this.ws = null; + this.setConnectionState('disconnected'); + } + + /** Get current connection state */ + getState(): ConnectionState { + return this.state; + } + + // ---- Private ---- + + private setConnectionState(state: ConnectionState): void { + this.state = state; + this.connectionStateHandler?.(state); + } + + private dispatch(msg: ServerMessage): void { + const handlers = this.handlers.get(msg.type); + if (handlers) { + for (const handler of handlers) { + handler(msg); + } + } + + // Also dispatch to wildcard handlers + const wildcardHandlers = this.handlers.get('*'); + if (wildcardHandlers) { + for (const handler of wildcardHandlers) { + handler(msg); + } + } + } + + private startHeartbeat(): void { + this.stopHeartbeat(); + this.heartbeatInterval = setInterval(() => { + if (this.ws?.readyState === WebSocket.OPEN) { + this.ws.send('ping'); + this.heartbeatTimeout = setTimeout(() => { + console.warn('[WS] Heartbeat timeout, closing connection'); + this.ws?.close(4000, 'heartbeat timeout'); + }, WS_HEARTBEAT_TIMEOUT_MS); + } + }, WS_HEARTBEAT_INTERVAL_MS); + } + + private resetHeartbeatTimeout(): void { + if (this.heartbeatTimeout) { + clearTimeout(this.heartbeatTimeout); + this.heartbeatTimeout = null; + } + } + + private stopHeartbeat(): void { + if (this.heartbeatInterval) { + clearInterval(this.heartbeatInterval); + this.heartbeatInterval = null; + } + this.resetHeartbeatTimeout(); + } + + private scheduleReconnect(): void { + this.setConnectionState('reconnecting'); + const delay = Math.min( + WS_RECONNECT_BASE_MS * Math.pow(2, this.reconnectAttempts), + WS_RECONNECT_MAX_MS, + ); + this.reconnectAttempts++; + console.info(`[WS] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`); + this.reconnectTimer = setTimeout(() => { + this.connect(); + }, delay); + } + + private flushQueue(): void { + while (this.messageQueue.length > 0) { + const msg = this.messageQueue.shift(); + if (msg && this.ws?.readyState === WebSocket.OPEN) { + this.ws.send(msg); + } + } + } + + private cleanup(): void { + this.stopHeartbeat(); + if (this.reconnectTimer) { + clearTimeout(this.reconnectTimer); + this.reconnectTimer = null; + } + } +} diff --git a/frontend/src/shared/constants.ts b/frontend/src/shared/constants.ts new file mode 100644 index 0000000..972055d --- /dev/null +++ b/frontend/src/shared/constants.ts @@ -0,0 +1,110 @@ +/** Free-tier buff activations per rolling 24h window (spec daily task "Use 3 Buffs") */ +export const FREE_BUFF_ACTIVATIONS_PER_PERIOD = 2; + +/** Server tick rate in Hz */ +export const TICK_RATE = 10; + +/** Fixed timestep for game logic in seconds */ +export const FIXED_DT = 1 / TICK_RATE; + +/** Fixed timestep in milliseconds */ +export const FIXED_DT_MS = 1000 / TICK_RATE; + +/** Isometric tile width in pixels */ +export const TILE_WIDTH = 96; + +/** Isometric tile height in pixels (typically half of width for 2:1 iso) */ +export const TILE_HEIGHT = 48; + +/** Camera follow lerp factor (0 = no follow, 1 = instant snap) */ +export const CAMERA_FOLLOW_LERP = 0.08; + +/** Map zoom level (<1 = zoomed out to show more tiles, 1 = default) */ +export const MAP_ZOOM = 1.0; + +/** Screen shake magnitude in pixels */ +export const SHAKE_MAGNITUDE = 6; + +/** Screen shake duration in milliseconds */ +export const SHAKE_DURATION_MS = 200; + +/** WebSocket reconnect base delay in milliseconds */ +export const WS_RECONNECT_BASE_MS = 1000; + +/** WebSocket reconnect max delay in milliseconds */ +export const WS_RECONNECT_MAX_MS = 30000; + +/** WebSocket heartbeat interval in milliseconds */ +export const WS_HEARTBEAT_INTERVAL_MS = 15000; + +/** WebSocket heartbeat timeout in milliseconds */ +export const WS_HEARTBEAT_TIMEOUT_MS = 5000; + +/** Max accumulated time before we drop frames (prevents spiral of death) */ +export const MAX_ACCUMULATED_MS = 250; + +/** Floating damage number duration in milliseconds */ +export const DAMAGE_NUMBER_DURATION_MS = 1200; + +/** Floating damage rise distance in pixels */ +export const DAMAGE_NUMBER_RISE_PX = 60; + +/** Buff cooldown overlay animation fps */ +export const BUFF_OVERLAY_FPS = 30; + +/** Death screen auto-revive countdown (seconds); manual "Revive now" is always available when server allows. */ +export const REVIVE_TIMER_SECONDS = 300; + +/** Client combat tuning: longer fights vs server-authoritative preview (matches backend pace intent). */ +export const COMBAT_HIT_INTERVAL_MULT = 5; +/** Multiplier applied to outgoing/incoming hit damage (before minimum 1). */ +export const COMBAT_DAMAGE_SCALE = 0.35; + +/** API base path */ +export const API_BASE = '/api/v1'; + +/** WebSocket path */ +export const WS_PATH = '/ws'; + +// ---- Rarity Colors (WoW-style) ---- + +export const RARITY_COLORS: Record = { + common: '#9d9d9d', + uncommon: '#1eff00', + rare: '#0070dd', + epic: '#a335ee', + legendary: '#ffd700', +}; + +export const RARITY_GLOW: Record = { + common: 'none', + uncommon: '0 0 8px #1eff0066', + rare: '0 0 10px #0070dd88, 0 0 20px #0070dd44', + epic: '0 0 12px #a335ee99, 0 0 24px #a335ee55', + legendary: '0 0 16px #ffd700cc, 0 0 32px #ffd70066, 0 0 48px #ffd70033', +}; + +// ---- Debuff Colors ---- + +export const DEBUFF_COLORS: Record = { + poison: '#44cc44', + freeze: '#44ddff', + burn: '#ff8833', + stun: '#ffdd44', + slow: '#4488ff', + weaken: '#aa44dd', +}; + +// ---- Debuff Default Durations (ms) ---- + +export const DEBUFF_DURATION_DEFAULTS: Record = { + poison: 5000, + freeze: 3000, + burn: 4000, + stun: 2000, + slow: 4000, + weaken: 5000, +}; + +/** Loot popup display duration in milliseconds */ +export const LOOT_POPUP_DURATION_MS = 5000; diff --git a/frontend/src/shared/telegram.ts b/frontend/src/shared/telegram.ts new file mode 100644 index 0000000..6dfeccb --- /dev/null +++ b/frontend/src/shared/telegram.ts @@ -0,0 +1,204 @@ +/** + * Telegram Mini Apps SDK wrapper. + * + * The SDK script is loaded in index.html before the app mounts, + * so `window.Telegram.WebApp` should be available synchronously. + */ + +// Extend Window interface for Telegram SDK +declare global { + interface Window { + Telegram?: { + WebApp: TelegramWebApp; + }; + } +} + +export interface TelegramWebApp { + ready: () => void; + expand: () => void; + close: () => void; + initData: string; + initDataUnsafe: Record; + version: string; + platform: string; + colorScheme: 'light' | 'dark'; + themeParams: { + bg_color?: string; + text_color?: string; + hint_color?: string; + link_color?: string; + button_color?: string; + button_text_color?: string; + secondary_bg_color?: string; + }; + viewportHeight: number; + viewportStableHeight: number; + isExpanded: boolean; + MainButton: { + text: string; + color: string; + textColor: string; + isVisible: boolean; + isActive: boolean; + show: () => void; + hide: () => void; + onClick: (cb: () => void) => void; + offClick: (cb: () => void) => void; + setText: (text: string) => void; + enable: () => void; + disable: () => void; + }; + BackButton: { + isVisible: boolean; + show: () => void; + hide: () => void; + onClick: (cb: () => void) => void; + offClick: (cb: () => void) => void; + }; + HapticFeedback: { + impactOccurred: (style: 'light' | 'medium' | 'heavy' | 'rigid' | 'soft') => void; + notificationOccurred: (type: 'error' | 'success' | 'warning') => void; + selectionChanged: () => void; + }; + showPopup: (params: { + title?: string; + message: string; + buttons?: Array<{ id?: string; type?: 'default' | 'ok' | 'close' | 'cancel' | 'destructive'; text?: string }>; + }, cb?: (buttonId: string) => void) => void; + requestWriteAccess: (cb?: (granted: boolean) => void) => void; + onEvent: (event: string, cb: (...args: unknown[]) => void) => void; + offEvent: (event: string, cb: (...args: unknown[]) => void) => void; + sendData: (data: string) => void; + setHeaderColor: (color: string) => void; + setBackgroundColor: (color: string) => void; +} + +/** Returns the Telegram WebApp instance, or null if not inside Telegram */ +export function getTelegramWebApp(): TelegramWebApp | null { + return window.Telegram?.WebApp ?? null; +} + +/** Returns true if running inside a Telegram client */ +export function isTelegram(): boolean { + return getTelegramWebApp() !== null; +} + +/** Initialize Telegram Mini App: signal readiness, expand viewport */ +export function initTelegramApp(): void { + const tg = getTelegramWebApp(); + if (!tg) { + console.info('[Telegram] Not running inside Telegram, skipping init'); + return; + } + + tg.ready(); + tg.expand(); + + // Apply Telegram theme to CSS variables for UI components + const theme = tg.themeParams; + const root = document.documentElement; + if (theme.bg_color) root.style.setProperty('--tg-bg', theme.bg_color); + if (theme.text_color) root.style.setProperty('--tg-text', theme.text_color); + if (theme.button_color) root.style.setProperty('--tg-button', theme.button_color); + if (theme.button_text_color) root.style.setProperty('--tg-button-text', theme.button_text_color); + if (theme.secondary_bg_color) root.style.setProperty('--tg-secondary-bg', theme.secondary_bg_color); + + console.info(`[Telegram] Initialized v${tg.version} on ${tg.platform}, scheme=${tg.colorScheme}`); +} + +/** Get Telegram initData for authenticating API requests */ +export function getTelegramInitData(): string { + return getTelegramWebApp()?.initData ?? ''; +} + +/** Get the Telegram user ID from initDataUnsafe, or null if unavailable */ +export function getTelegramUserId(): number | null { + const tg = getTelegramWebApp(); + if (!tg) return null; + const user = tg.initDataUnsafe?.user as { id?: number } | undefined; + return user?.id ?? null; +} + +/** Get viewport dimensions accounting for Telegram safe areas */ +export function getViewport(): { width: number; height: number } { + const tg = getTelegramWebApp(); + return { + width: window.innerWidth, + height: tg?.viewportStableHeight ?? window.innerHeight, + }; +} + +// ---- Haptic Feedback ---- + +/** Trigger haptic impact feedback (combat hits, UI taps) */ +export function hapticImpact(style: 'light' | 'medium' | 'heavy'): void { + getTelegramWebApp()?.HapticFeedback.impactOccurred(style); +} + +/** Trigger haptic notification feedback (success/error/warning events) */ +export function hapticNotification(type: 'error' | 'success' | 'warning'): void { + getTelegramWebApp()?.HapticFeedback.notificationOccurred(type); +} + +// ---- Popup ---- + +/** Show a native Telegram popup dialog */ +export function showPopup( + title: string, + message: string, + buttons?: Array<{ id?: string; type?: 'default' | 'ok' | 'close' | 'cancel' | 'destructive'; text?: string }>, +): Promise { + return new Promise((resolve) => { + const tg = getTelegramWebApp(); + if (!tg) { + resolve(''); + return; + } + tg.showPopup({ title, message, buttons }, (buttonId) => { + resolve(buttonId); + }); + }); +} + +// ---- Write Access ---- + +/** Request write access permission from the user */ +export function requestWriteAccess(): Promise { + return new Promise((resolve) => { + const tg = getTelegramWebApp(); + if (!tg) { + resolve(false); + return; + } + tg.requestWriteAccess((granted) => { + resolve(granted); + }); + }); +} + +// ---- Theme Change Listener ---- + +/** Subscribe to Telegram theme changes and re-apply CSS variables */ +export function onThemeChanged(cb?: () => void): () => void { + const tg = getTelegramWebApp(); + if (!tg) return () => {}; + + const handler = () => { + const theme = tg.themeParams; + const root = document.documentElement; + if (theme.bg_color) root.style.setProperty('--tg-bg', theme.bg_color); + if (theme.text_color) root.style.setProperty('--tg-text', theme.text_color); + if (theme.button_color) root.style.setProperty('--tg-button', theme.button_color); + if (theme.button_text_color) root.style.setProperty('--tg-button-text', theme.button_text_color); + if (theme.secondary_bg_color) root.style.setProperty('--tg-secondary-bg', theme.secondary_bg_color); + cb?.(); + }; + + tg.onEvent('themeChanged', handler); + + // Return unsubscribe function + return () => { + tg.offEvent('themeChanged', handler); + }; +} diff --git a/frontend/src/ui/AchievementsPanel.tsx b/frontend/src/ui/AchievementsPanel.tsx new file mode 100644 index 0000000..eec2551 --- /dev/null +++ b/frontend/src/ui/AchievementsPanel.tsx @@ -0,0 +1,196 @@ +import { useState, type CSSProperties } from 'react'; +import type { Achievement } from '../network/api'; + +interface AchievementsPanelProps { + achievements: Achievement[]; +} + +const buttonStyle: CSSProperties = { + position: 'fixed', + top: 12, + right: 240, + zIndex: 50, + display: 'flex', + alignItems: 'center', + gap: 4, + padding: '5px 10px', + borderRadius: 8, + border: '1px solid rgba(255, 215, 0, 0.2)', + backgroundColor: 'rgba(0,0,0,0.55)', + color: '#daa520', + fontSize: 11, + fontWeight: 600, + cursor: 'pointer', + pointerEvents: 'auto', + userSelect: 'none', +}; + +const panelStyle: CSSProperties = { + position: 'fixed', + top: 12, + right: 240, + zIndex: 50, + width: 260, + maxHeight: 340, + borderRadius: 10, + border: '1px solid rgba(255, 215, 0, 0.15)', + backgroundColor: 'rgba(10, 10, 20, 0.88)', + backdropFilter: 'blur(6px)', + overflow: 'hidden', + pointerEvents: 'auto', + display: 'flex', + flexDirection: 'column', +}; + +const panelHeaderStyle: CSSProperties = { + display: 'flex', + justifyContent: 'space-between', + alignItems: 'center', + padding: '7px 10px', + borderBottom: '1px solid rgba(255,255,255,0.08)', + fontSize: 12, + fontWeight: 700, + color: '#daa520', + flexShrink: 0, +}; + +const closeButtonStyle: CSSProperties = { + background: 'none', + border: 'none', + color: '#888', + fontSize: 14, + cursor: 'pointer', + padding: '0 4px', + lineHeight: 1, +}; + +const listStyle: CSSProperties = { + padding: '6px 10px 8px', + overflowY: 'auto', + flex: 1, +}; + +function achievementRowStyle(unlocked: boolean): CSSProperties { + return { + marginBottom: 8, + padding: '6px 8px', + borderRadius: 6, + border: unlocked + ? '1px solid rgba(255, 215, 0, 0.5)' + : '1px solid rgba(255, 255, 255, 0.08)', + backgroundColor: unlocked + ? 'rgba(255, 215, 0, 0.06)' + : 'rgba(255, 255, 255, 0.02)', + }; +} + +const titleRowStyle: CSSProperties = { + display: 'flex', + justifyContent: 'space-between', + alignItems: 'center', + marginBottom: 3, +}; + +const progressBarBgStyle: CSSProperties = { + width: '100%', + height: 5, + borderRadius: 3, + backgroundColor: 'rgba(255,255,255,0.08)', + overflow: 'hidden', + marginTop: 4, +}; + +function progressBarFillStyle(pct: number, unlocked: boolean): CSSProperties { + return { + width: `${Math.min(100, pct)}%`, + height: '100%', + borderRadius: 3, + backgroundColor: unlocked ? '#ffd700' : '#daa520', + transition: 'width 300ms ease', + }; +} + +function formatDate(iso: string): string { + try { + const d = new Date(iso); + return d.toLocaleDateString(undefined, { month: 'short', day: 'numeric' }); + } catch { + return ''; + } +} + +export function AchievementsPanel({ achievements }: AchievementsPanelProps) { + const [expanded, setExpanded] = useState(false); + + const unlockedCount = achievements.filter((a) => a.unlocked).length; + + if (!expanded) { + return ( + + ); + } + + return ( +
+
+ 🏆 Achievements + +
+
+ {achievements.map((ach) => { + const pct = ach.conditionValue > 0 + ? (Math.min(ach.conditionValue, ach.conditionValue) / ach.conditionValue) * 100 + : 0; + + return ( +
+
+ + {ach.unlocked ? '\u2714 ' : ''}{ach.title} + + {ach.unlocked && ach.unlockedAt && ( + + {formatDate(ach.unlockedAt)} + + )} +
+
+ {ach.description} +
+ {!ach.unlocked && ( +
+
+
+ )} + {ach.unlocked && ( +
+ +{ach.rewardAmount} {ach.rewardType} +
+ )} +
+ ); + })} + {achievements.length === 0 && ( +
+ No achievements yet +
+ )} +
+
+ ); +} diff --git a/frontend/src/ui/AdventureLog.tsx b/frontend/src/ui/AdventureLog.tsx new file mode 100644 index 0000000..1ac67ba --- /dev/null +++ b/frontend/src/ui/AdventureLog.tsx @@ -0,0 +1,138 @@ +import { useEffect, useRef, useState, type CSSProperties } from 'react'; +import type { AdventureLogEntry } from '../game/types'; + +interface AdventureLogProps { + entries: AdventureLogEntry[]; +} + +function formatTime(timestamp: number): string { + const d = new Date(timestamp); + const hh = String(d.getHours()).padStart(2, '0'); + const mm = String(d.getMinutes()).padStart(2, '0'); + return `${hh}:${mm}`; +} + +const buttonStyle: CSSProperties = { + position: 'fixed', + bottom: 60, + left: 12, + zIndex: 50, + display: 'flex', + alignItems: 'center', + gap: 4, + padding: '6px 12px', + borderRadius: 8, + border: '1px solid rgba(255,255,255,0.15)', + backgroundColor: 'rgba(0,0,0,0.55)', + color: '#ccc', + fontSize: 12, + fontWeight: 600, + cursor: 'pointer', + pointerEvents: 'auto', + userSelect: 'none', +}; + +const panelStyle: CSSProperties = { + position: 'fixed', + bottom: 60, + left: 12, + zIndex: 50, + width: 'calc(100vw - 24px)', + maxWidth: 360, + maxHeight: '40vh', + display: 'flex', + flexDirection: 'column', + borderRadius: 10, + border: '1px solid rgba(255,255,255,0.12)', + backgroundColor: 'rgba(10, 10, 20, 0.82)', + backdropFilter: 'blur(6px)', + overflow: 'hidden', + pointerEvents: 'auto', +}; + +const panelHeaderStyle: CSSProperties = { + display: 'flex', + justifyContent: 'space-between', + alignItems: 'center', + padding: '8px 12px', + borderBottom: '1px solid rgba(255,255,255,0.08)', + fontSize: 13, + fontWeight: 700, + color: '#ddd', +}; + +const scrollAreaStyle: CSSProperties = { + flex: 1, + overflowY: 'auto', + padding: '6px 10px', + fontSize: 12, + lineHeight: 1.6, + color: '#bbb', +}; + +const entryStyle: CSSProperties = { + whiteSpace: 'nowrap', + overflow: 'hidden', + textOverflow: 'ellipsis', +}; + +const timestampStyle: CSSProperties = { + color: 'rgba(140,160,200,0.7)', + marginRight: 4, + fontFamily: 'monospace', + fontSize: 11, +}; + +const closeButtonStyle: CSSProperties = { + background: 'none', + border: 'none', + color: '#999', + fontSize: 16, + cursor: 'pointer', + padding: '0 4px', + lineHeight: 1, +}; + +export function AdventureLog({ entries }: AdventureLogProps) { + const [expanded, setExpanded] = useState(false); + const scrollRef = useRef(null); + + // Auto-scroll to bottom when new entries arrive while expanded + useEffect(() => { + if (expanded && scrollRef.current) { + scrollRef.current.scrollTop = scrollRef.current.scrollHeight; + } + }, [entries.length, expanded]); + + if (!expanded) { + return ( + + ); + } + + return ( +
+
+ 📜 Adventure Log + +
+
+ {entries.length === 0 && ( +
+ No events yet... +
+ )} + {entries.map((entry) => ( +
+ [{formatTime(entry.timestamp)}] + {entry.message} +
+ ))} +
+
+ ); +} diff --git a/frontend/src/ui/BuffBar.tsx b/frontend/src/ui/BuffBar.tsx new file mode 100644 index 0000000..9b812f6 --- /dev/null +++ b/frontend/src/ui/BuffBar.tsx @@ -0,0 +1,535 @@ +import { useCallback, useEffect, useRef, useState, type CSSProperties } from 'react'; +import { BuffType, type ActiveBuff, type BuffChargeState } from '../game/types'; +import { BUFF_COOLDOWN_MS, BUFF_MAX_CHARGES } from '../network/buffMap'; +import { BUFF_META } from './buffMeta'; +import { purchaseBuffRefill } from '../network/api'; +import type { HeroResponse } from '../network/api'; +import { getTelegramUserId } from '../shared/telegram'; + +// ---- Types ---- + +interface BuffBarProps { + buffs: ActiveBuff[]; + /** Client-side cooldown end timestamps (ms); backend does not persist these yet. */ + cooldownEndsAt: Partial>; + /** Per-buff charge quotas from the server. */ + buffCharges: Partial>; + nowMs: number; + onActivate: (type: BuffType) => void; + /** Called when a buff refill purchase returns an updated hero */ + onHeroUpdated?: (hero: HeroResponse) => void; +} + +interface BuffButtonProps { + buff: ActiveBuff; + meta: { icon: string; label: string; color: string; desc: string }; + charge: BuffChargeState | undefined; + maxCharges: number; + onActivate: () => void; + onRefill?: (type: BuffType) => void; + nowMs: number; +} + +// ---- Tooltip ---- + +const LONG_PRESS_MS = 400; +const TOOLTIP_AUTO_HIDE_MS = 2500; + +const tooltipStyle: CSSProperties = { + position: 'absolute', + bottom: '110%', + left: '50%', + transform: 'translateX(-50%)', + padding: '6px 10px', + borderRadius: 8, + backgroundColor: 'rgba(10, 10, 20, 0.92)', + border: '1px solid rgba(255,255,255,0.15)', + color: '#eee', + fontSize: 11, + fontWeight: 600, + whiteSpace: 'nowrap', + pointerEvents: 'none', + zIndex: 100, + textAlign: 'center', + lineHeight: 1.4, + boxShadow: '0 4px 12px rgba(0,0,0,0.5)', +}; + +const tooltipArrow: CSSProperties = { + position: 'absolute', + bottom: -5, + left: '50%', + transform: 'translateX(-50%)', + width: 0, + height: 0, + borderLeft: '5px solid transparent', + borderRight: '5px solid transparent', + borderTop: '5px solid rgba(10, 10, 20, 0.92)', +}; + +// ---- Charge Badge ---- + +const chargeBadgeBase: CSSProperties = { + position: 'absolute', + top: -4, + right: -4, + minWidth: 16, + height: 16, + borderRadius: 8, + display: 'flex', + alignItems: 'center', + justifyContent: 'center', + fontSize: 9, + fontWeight: 700, + lineHeight: 1, + padding: '0 3px', + zIndex: 10, + pointerEvents: 'none', + border: '1px solid rgba(0,0,0,0.4)', +}; + +// ---- Radial Cooldown SVG ---- + +function RadialCooldown({ progress }: { progress: number }) { + if (progress <= 0) return null; + + const radius = 22; + const cx = 25; + const cy = 25; + const circumference = 2 * Math.PI * radius; + const offset = circumference * (1 - progress); + + return ( + + + + + ); +} + +// ---- Helpers ---- + +/** Format an ISO timestamp as HH:MM in local time. */ +function formatTimeHHMM(iso: string): string { + const d = new Date(iso); + if (isNaN(d.getTime())) return '??:??'; + return d.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }); +} + +// ---- Buff Button ---- + +const buttonBase: CSSProperties = { + position: 'relative', + border: '2px solid rgba(255,255,255,0.2)', + backgroundColor: 'rgba(0,0,0,0.5)', + display: 'flex', + alignItems: 'center', + justifyContent: 'center', + flexDirection: 'column', + cursor: 'pointer', + userSelect: 'none', + WebkitTapHighlightColor: 'transparent', +}; + +function BuffButton({ buff, meta, charge, maxCharges, onActivate, onRefill, nowMs }: BuffButtonProps) { + const [pressed, setPressed] = useState(false); + const [showTooltip, setShowTooltip] = useState(false); + const [showRefillConfirm, setShowRefillConfirm] = useState(false); + const longPressTimer = useRef | null>(null); + const autoHideTimer = useRef | null>(null); + const didLongPress = useRef(false); + + const remainingEffectMs = + buff.expiresAtMs != null ? Math.max(0, buff.expiresAtMs - nowMs) : buff.remainingMs; + const isActive = remainingEffectMs > 0; + + const isOnCooldown = buff.cooldownRemainingMs > 0; + const cooldownProgress = + buff.cooldownMs > 0 ? buff.cooldownRemainingMs / buff.cooldownMs : 0; + + const cdSec = Math.ceil((buff.cooldownMs || 0) / 1000); + + // Charge state + const remaining = charge?.remaining; + const hasChargeData = remaining != null; + const isOutOfCharges = hasChargeData && remaining === 0; + const isDisabled = isOnCooldown || (isOutOfCharges && !isActive); + + useEffect(() => { + return () => { + if (longPressTimer.current) clearTimeout(longPressTimer.current); + if (autoHideTimer.current) clearTimeout(autoHideTimer.current); + }; + }, []); + + const openTooltip = (): void => { + setShowTooltip(true); + if (autoHideTimer.current) clearTimeout(autoHideTimer.current); + autoHideTimer.current = setTimeout(() => setShowTooltip(false), TOOLTIP_AUTO_HIDE_MS); + }; + + const closeTooltip = (): void => { + setShowTooltip(false); + if (autoHideTimer.current) clearTimeout(autoHideTimer.current); + }; + + const handleTouchStart = (): void => { + didLongPress.current = false; + longPressTimer.current = setTimeout(() => { + didLongPress.current = true; + openTooltip(); + }, LONG_PRESS_MS); + }; + + const handleTouchEnd = (): void => { + if (longPressTimer.current) { + clearTimeout(longPressTimer.current); + longPressTimer.current = null; + } + }; + + const handleClick = (): void => { + if (didLongPress.current) { + didLongPress.current = false; + return; + } + setPressed(true); + window.setTimeout(() => setPressed(false), 140); + + // When out of charges, show refill confirmation instead of doing nothing + if (isOutOfCharges && !isOnCooldown && !isActive) { + setShowRefillConfirm(true); + return; + } + + if (isDisabled) return; + onActivate(); + }; + + const style: CSSProperties = { + ...buttonBase, + width: 44, + height: 50, + borderRadius: 10, + borderColor: isActive ? meta.color : pressed ? '#fff' : 'rgba(255,255,255,0.2)', + opacity: isDisabled ? (isOutOfCharges && !isOnCooldown ? 0.3 : 0.55) : 1, + boxShadow: isActive + ? `0 0 12px ${meta.color}` + : pressed + ? `0 0 10px rgba(255,255,255,0.5), inset 0 0 12px ${meta.color}66` + : 'none', + transform: pressed ? 'scale(0.94)' : 'scale(1)', + transition: 'transform 80ms ease, box-shadow 80ms ease, border-color 80ms ease, opacity 150ms ease', + cursor: isDisabled ? 'not-allowed' : 'pointer', + }; + + return ( + + )} +
+
+ )} + + {/* Refill confirmation popup */} + {showRefillConfirm && ( +
+
+ Refill {meta.label}? +
+
+ {buff.type === BuffType.Resurrection ? '150\u20BD' : '50\u20BD'} +
+
+ + +
+
+ )} + + ); +} + +// ---- Buff Bar ---- + +const barStyle: CSSProperties = { + display: 'flex', + gap: 4, + justifyContent: 'center', + flexWrap: 'wrap', + padding: '6px 0', +}; + +/** All buff types that should always be visible as buttons */ +const ALL_BUFF_TYPES: BuffType[] = [ + BuffType.Heal, BuffType.Rage, BuffType.Shield, + BuffType.Rush, BuffType.PowerPotion, BuffType.WarCry, + BuffType.Luck, +]; + +function getBuffEntry( + type: BuffType, + activeBuffs: ActiveBuff[], + cooldownEndsAt: Partial>, + nowMs: number, +): ActiveBuff { + const active = activeBuffs.find((b) => b.type === type); + const cdEnd = cooldownEndsAt[type]; + const cdRem = cdEnd != null ? Math.max(0, cdEnd - nowMs) : 0; + const cdFull = active?.cooldownMs || BUFF_COOLDOWN_MS[type]; + + if (active) { + const exp = active.expiresAtMs; + const remainingMs = exp != null ? Math.max(0, exp - nowMs) : active.remainingMs; + return { + ...active, + remainingMs, + cooldownMs: active.cooldownMs || cdFull, + cooldownRemainingMs: cdRem, + }; + } + + return { + type, + remainingMs: 0, + durationMs: 0, + cooldownMs: cdFull, + cooldownRemainingMs: cdRem, + }; +} + +export function BuffBar({ buffs, cooldownEndsAt, buffCharges, nowMs, onActivate, onHeroUpdated }: BuffBarProps) { + const handleActivate = useCallback( + (type: BuffType) => () => onActivate(type), + [onActivate], + ); + + const handleRefill = useCallback( + (type: BuffType) => { + const telegramId = getTelegramUserId() ?? undefined; + purchaseBuffRefill(type, telegramId) + .then((hero) => { + onHeroUpdated?.(hero); + }) + .catch((err) => { + console.warn('[BuffBar] purchaseBuffRefill failed:', err); + }); + }, + [onHeroUpdated], + ); + + return ( +
+ {ALL_BUFF_TYPES.map((type) => { + const buff = getBuffEntry(type, buffs, cooldownEndsAt, nowMs); + const meta = BUFF_META[type]; + const charge = buffCharges[type]; + const maxCharges = BUFF_MAX_CHARGES[type]; + return ( + + ); + })} +
+ ); +} diff --git a/frontend/src/ui/BuffStatusStrip.tsx b/frontend/src/ui/BuffStatusStrip.tsx new file mode 100644 index 0000000..25646de --- /dev/null +++ b/frontend/src/ui/BuffStatusStrip.tsx @@ -0,0 +1,80 @@ +import { type CSSProperties } from 'react'; +import type { ActiveBuff } from '../game/types'; +import { BUFF_META } from './buffMeta'; + +interface BuffStatusStripProps { + buffs: ActiveBuff[]; + nowMs: number; +} + +const rowStyle: CSSProperties = { + display: 'flex', + gap: 4, + flexWrap: 'nowrap', + alignItems: 'center', + flexShrink: 0, + maxWidth: 'min(46vw, 260px)', + overflowX: 'auto', + WebkitOverflowScrolling: 'touch', + pointerEvents: 'none', +}; + +const chipStyle: CSSProperties = { + display: 'inline-flex', + alignItems: 'center', + gap: 3, + padding: '2px 6px', + borderRadius: 6, + fontSize: 10, + fontWeight: 700, + color: '#fff', + textShadow: '0 1px 2px rgba(0,0,0,0.85)', + flexShrink: 0, +}; + +function liveRemainingMs(buff: ActiveBuff, nowMs: number): number { + if (buff.expiresAtMs != null) { + return Math.max(0, buff.expiresAtMs - nowMs); + } + return Math.max(0, buff.remainingMs); +} + +/** Read-only active buff indicators (no activation controls). */ +export function BuffStatusStrip({ buffs, nowMs }: BuffStatusStripProps) { + const live = buffs + .map((b) => ({ ...b, remainingMs: liveRemainingMs(b, nowMs) })) + .filter((b) => b.remainingMs > 0); + + if (live.length === 0) return null; + + return ( +
+ {live.map((buff) => { + const meta = BUFF_META[buff.type]; + if (!meta) return null; + const sec = Math.ceil(buff.remainingMs / 1000); + const justApplied = + buff.durationMs > 0 && buff.remainingMs / buff.durationMs > 0.8; + const style: CSSProperties = { + ...chipStyle, + backgroundColor: `${meta.color}44`, + border: `1px solid ${meta.color}aa`, + animation: justApplied ? 'buff-status-pulse 0.55s ease-out' : undefined, + }; + return ( + + {meta.icon} + {sec}s + + ); + })} + +
+ ); +} diff --git a/frontend/src/ui/DailyTasks.tsx b/frontend/src/ui/DailyTasks.tsx new file mode 100644 index 0000000..ef85b8a --- /dev/null +++ b/frontend/src/ui/DailyTasks.tsx @@ -0,0 +1,189 @@ +import { useState, type CSSProperties } from 'react'; +import type { DailyTaskResponse } from '../network/api'; + +interface DailyTasksProps { + tasks: DailyTaskResponse[]; + onClaim: (taskId: string) => void; +} + +const buttonStyle: CSSProperties = { + position: 'fixed', + top: 12, + right: 12, + zIndex: 50, + display: 'flex', + alignItems: 'center', + gap: 4, + padding: '5px 10px', + borderRadius: 8, + border: '1px solid rgba(255, 215, 0, 0.2)', + backgroundColor: 'rgba(0,0,0,0.55)', + color: '#daa520', + fontSize: 11, + fontWeight: 600, + cursor: 'pointer', + pointerEvents: 'auto', + userSelect: 'none', +}; + +const panelStyle: CSSProperties = { + position: 'fixed', + top: 12, + right: 12, + zIndex: 50, + width: 230, + borderRadius: 10, + border: '1px solid rgba(255, 215, 0, 0.15)', + backgroundColor: 'rgba(10, 10, 20, 0.88)', + backdropFilter: 'blur(6px)', + overflow: 'hidden', + pointerEvents: 'auto', +}; + +const panelHeaderStyle: CSSProperties = { + display: 'flex', + justifyContent: 'space-between', + alignItems: 'center', + padding: '7px 10px', + borderBottom: '1px solid rgba(255,255,255,0.08)', + fontSize: 12, + fontWeight: 700, + color: '#daa520', +}; + +const closeButtonStyle: CSSProperties = { + background: 'none', + border: 'none', + color: '#888', + fontSize: 14, + cursor: 'pointer', + padding: '0 4px', + lineHeight: 1, +}; + +const taskListStyle: CSSProperties = { + padding: '6px 10px 8px', +}; + +const taskRowStyle: CSSProperties = { + marginBottom: 8, +}; + +const taskLabelStyle: CSSProperties = { + display: 'flex', + justifyContent: 'space-between', + alignItems: 'center', + fontSize: 11, + color: '#ccc', + marginBottom: 3, +}; + +const progressBarBgStyle: CSSProperties = { + width: '100%', + height: 6, + borderRadius: 3, + backgroundColor: 'rgba(255,255,255,0.08)', + overflow: 'hidden', +}; + +function progressBarFillStyle(pct: number, done: boolean): CSSProperties { + return { + width: `${Math.min(100, pct)}%`, + height: '100%', + borderRadius: 3, + backgroundColor: done ? '#44cc44' : '#daa520', + transition: 'width 300ms ease', + }; +} + +const claimButtonStyle: CSSProperties = { + marginTop: 4, + padding: '2px 10px', + borderRadius: 4, + border: '1px solid rgba(255, 215, 0, 0.4)', + backgroundColor: 'rgba(255, 215, 0, 0.15)', + color: '#ffd700', + fontSize: 10, + fontWeight: 600, + cursor: 'pointer', + display: 'block', + width: '100%', + textAlign: 'center', +}; + +export function DailyTasks({ tasks, onClaim }: DailyTasksProps) { + const [expanded, setExpanded] = useState(false); + + const completedCount = tasks.filter((t) => t.completed).length; + const claimableCount = tasks.filter((t) => t.completed && !t.claimed).length; + + if (!expanded) { + return ( + + ); + } + + return ( +
+
+ ⭐ Daily Tasks + +
+
+ {tasks.map((task) => { + const done = task.completed; + const pct = (task.progress / Math.max(1, task.objectiveCount)) * 100; + const canClaim = task.completed && !task.claimed; + + return ( +
+
+ + {task.claimed ? '\u2705 ' : done ? '\u2714 ' : ''}{task.title} + + + {task.progress}/{task.objectiveCount} + +
+
+
+
+ {task.rewardAmount > 0 && ( +
+ +{task.rewardAmount} {task.rewardType} +
+ )} + {canClaim && ( + + )} +
+ ); + })} + {tasks.length === 0 && ( +
+ No daily tasks available +
+ )} +
+
+ ); +} diff --git a/frontend/src/ui/DeathScreen.tsx b/frontend/src/ui/DeathScreen.tsx new file mode 100644 index 0000000..6b41d86 --- /dev/null +++ b/frontend/src/ui/DeathScreen.tsx @@ -0,0 +1,119 @@ +import { useEffect, useState, type CSSProperties } from 'react'; +import { REVIVE_TIMER_SECONDS } from '../shared/constants'; + +interface DeathScreenProps { + visible: boolean; + onRevive: () => void; + /** Free revives left for non-subscribers; omit when subscribed / unlimited. */ + revivesRemaining?: number; +} + +const overlayStyle: CSSProperties = { + position: 'absolute', + top: 0, + left: 0, + width: '100%', + height: '100%', + backgroundColor: 'rgba(0, 0, 0, 0.7)', + display: 'flex', + flexDirection: 'column', + alignItems: 'center', + justifyContent: 'center', + gap: 24, + zIndex: 100, + transition: 'opacity 0.5s ease', +}; + +const titleStyle: CSSProperties = { + fontSize: 36, + fontWeight: 900, + color: '#cc3333', + textShadow: '0 0 20px rgba(204, 51, 51, 0.5)', + letterSpacing: 4, +}; + +const timerStyle: CSSProperties = { + fontSize: 48, + fontWeight: 700, + color: '#ffffff', + fontVariantNumeric: 'tabular-nums', +}; + +const buttonStyle: CSSProperties = { + padding: '14px 40px', + fontSize: 18, + fontWeight: 700, + color: '#fff', + backgroundColor: '#cc3333', + border: 'none', + borderRadius: 8, + cursor: 'pointer', + transition: 'background-color 0.2s', +}; + +export function DeathScreen({ visible, onRevive, revivesRemaining }: DeathScreenProps) { + const [timer, setTimer] = useState(REVIVE_TIMER_SECONDS); + const canRevive = revivesRemaining === undefined || revivesRemaining > 0; + + // Countdown timer + useEffect(() => { + if (!visible) { + setTimer(REVIVE_TIMER_SECONDS); + return; + } + + const interval = setInterval(() => { + setTimer((t) => { + if (t <= 1) { + clearInterval(interval); + return 0; + } + return t - 1; + }); + }, 1000); + + return () => clearInterval(interval); + }, [visible]); + + // Auto-revive when timer hits 0 (only if server still allows free revives) + useEffect(() => { + if (visible && timer === 0 && canRevive) { + onRevive(); + } + }, [visible, timer, onRevive, canRevive]); + + if (!visible) return null; + + return ( +
+
YOU DIED
+
{canRevive ? timer : '—'}
+ {revivesRemaining !== undefined && ( +
+ Free revives left: {Math.max(0, revivesRemaining)} +
+ )} + +
+ {canRevive ? `Auto-revive in ${timer}s` : 'No free revives left — subscription required'} +
+
+ ); +} diff --git a/frontend/src/ui/DebuffBar.tsx b/frontend/src/ui/DebuffBar.tsx new file mode 100644 index 0000000..024a7cb --- /dev/null +++ b/frontend/src/ui/DebuffBar.tsx @@ -0,0 +1,89 @@ +import { type CSSProperties } from 'react'; +import { DebuffType, type ActiveDebuff } from '../game/types'; +import { DEBUFF_COLORS } from '../shared/constants'; + +// ---- Debuff metadata ---- + +const DEBUFF_META: Record = { + [DebuffType.Poison]: { icon: '\u2620\uFE0F', label: 'Poison' }, + [DebuffType.Freeze]: { icon: '\u2744\uFE0F', label: 'Freeze' }, + [DebuffType.Burn]: { icon: '\uD83D\uDD25', label: 'Burn' }, + [DebuffType.Stun]: { icon: '\uD83D\uDCAB', label: 'Stun' }, + [DebuffType.Slow]: { icon: '\uD83D\uDC22', label: 'Slow' }, + [DebuffType.Weaken]: { icon: '\uD83D\uDCC9', label: 'Weaken' }, +}; + +// ---- Types ---- + +interface DebuffBarProps { + debuffs: ActiveDebuff[]; +} + +// ---- Styles ---- + +const containerStyle: CSSProperties = { + display: 'flex', + gap: 4, + flexWrap: 'wrap', + marginTop: 4, +}; + +const debuffStyle: CSSProperties = { + display: 'flex', + alignItems: 'center', + gap: 3, + padding: '2px 6px', + borderRadius: 6, + fontSize: 11, + fontWeight: 600, + color: '#fff', + textShadow: '0 1px 2px rgba(0,0,0,0.8)', +}; + +// ---- Component ---- + +function DebuffIcon({ debuff }: { debuff: ActiveDebuff }) { + const meta = DEBUFF_META[debuff.type]; + const color = DEBUFF_COLORS[debuff.type] ?? '#999'; + const remainingSec = Math.ceil(debuff.remainingMs / 1000); + + /** Pulse when more than 80% duration remains (just applied). */ + const justApplied = debuff.durationMs > 0 + && debuff.remainingMs / debuff.durationMs > 0.8; + + const style: CSSProperties = { + ...debuffStyle, + backgroundColor: `${color}33`, + border: `1px solid ${color}88`, + animation: justApplied ? 'debuff-pulse 0.6s ease-out' : undefined, + }; + + return ( + + {meta.icon} + {remainingSec}s + + ); +} + +export function DebuffBar({ debuffs }: DebuffBarProps) { + if (debuffs.length === 0) return null; + + return ( + <> + {/* Inject keyframe animation once */} + +
+ {debuffs.map((d) => ( + + ))} +
+ + ); +} diff --git a/frontend/src/ui/EquipmentPanel.tsx b/frontend/src/ui/EquipmentPanel.tsx new file mode 100644 index 0000000..7d65014 --- /dev/null +++ b/frontend/src/ui/EquipmentPanel.tsx @@ -0,0 +1,177 @@ +import { useState, type CSSProperties } from 'react'; +import type { EquipmentItem } from '../game/types'; +import { RARITY_COLORS, RARITY_GLOW } from '../shared/constants'; + +/** Ordered slot definitions for display */ +const SLOT_DEFS: Array<{ key: string; icon: string; label: string }> = [ + { key: 'main_hand', icon: '\u2694\uFE0F', label: 'Weapon' }, + { key: 'chest', icon: '\uD83D\uDEE1\uFE0F', label: 'Chest' }, + { key: 'head', icon: '\u26D1\uFE0F', label: 'Head' }, + { key: 'feet', icon: '\uD83D\uDC62', label: 'Feet' }, + { key: 'neck', icon: '\uD83D\uDCBF', label: 'Neck' }, + { key: 'hands', icon: '\uD83D\uDC42', label: 'Hands' }, + { key: 'legs', icon: '\uD83D\uDC62', label: 'Legs' }, + { key: 'cloak', icon: '\uD83D\uDEE1\uFE0F', label: 'Cloak' }, + { key: 'finger', icon: '\uD83D\uDCBF', label: 'Finger' }, + { key: 'wrist', icon: '\uD83D\uDC42', label: 'Wrist' }, +]; + +function rarityColor(rarity: string): string { + return RARITY_COLORS[rarity.toLowerCase()] ?? '#9d9d9d'; +} + +function rarityGlow(rarity: string): string { + return RARITY_GLOW[rarity.toLowerCase()] ?? 'none'; +} + +function statLabel(statType: string): string { + switch (statType) { + case 'attack': return 'ATK'; + case 'defense': return 'DEF'; + case 'speed': return 'SPD'; + default: return 'STAT'; + } +} + +const wrapStyle: CSSProperties = { + marginTop: 6, + borderRadius: 8, + backgroundColor: 'rgba(0,0,0,0.45)', + border: '1px solid rgba(255,255,255,0.12)', + overflow: 'hidden', + flex: 1, + minWidth: 0, +}; + +const headerStyle: CSSProperties = { + width: '100%', + display: 'flex', + alignItems: 'center', + justifyContent: 'space-between', + padding: '6px 10px', + fontSize: 12, + fontWeight: 700, + color: '#e8e8e8', + cursor: 'pointer', + userSelect: 'none', + WebkitTapHighlightColor: 'transparent', + background: 'rgba(255,255,255,0.04)', + border: 'none', + fontFamily: 'inherit', +}; + +const bodyStyle: CSSProperties = { + padding: '8px 10px 10px', + fontSize: 11, + color: '#ccc', +}; + +const slotRow: CSSProperties = { + display: 'flex', + alignItems: 'center', + justifyContent: 'space-between', + padding: '4px 0', + borderBottom: '1px solid rgba(255,255,255,0.06)', +}; + +const slotLeftStyle: CSSProperties = { + display: 'flex', + alignItems: 'center', + gap: 6, + minWidth: 0, + overflow: 'hidden', +}; + +const slotIconStyle: CSSProperties = { + fontSize: 13, + flexShrink: 0, + width: 18, + textAlign: 'center', +}; + +const emptyLabelStyle: CSSProperties = { + color: '#555', + fontStyle: 'italic', + fontSize: 10, +}; + +const itemNameStyle: CSSProperties = { + fontWeight: 600, + fontSize: 11, + whiteSpace: 'nowrap', + overflow: 'hidden', + textOverflow: 'ellipsis', +}; + +const statValStyle: CSSProperties = { + fontSize: 10, + color: '#999', + flexShrink: 0, + textAlign: 'right', + marginLeft: 8, +}; + +interface EquipmentPanelProps { + equipment: Record; +} + +export function EquipmentPanel({ equipment }: EquipmentPanelProps) { + const [open, setOpen] = useState(false); + + const equippedCount = equipment ? Object.keys(equipment).length : 0; + + return ( +
+ + {open && ( +
+ {SLOT_DEFS.map((def) => { + const item = equipment?.[def.key]; + if (!item) { + return ( +
+
+ {def.icon} + {def.label} +
+ Empty +
+ ); + } + + const color = rarityColor(item.rarity); + const glow = rarityGlow(item.rarity); + + return ( +
+
+ {def.icon} + {item.name} +
+ + {statLabel(item.statType)} {item.primaryStat} + {' \u00B7 '}ilvl {item.ilvl} + +
+ ); + })} +
+ )} +
+ ); +} diff --git a/frontend/src/ui/FloatingDamage.tsx b/frontend/src/ui/FloatingDamage.tsx new file mode 100644 index 0000000..abc3cdb --- /dev/null +++ b/frontend/src/ui/FloatingDamage.tsx @@ -0,0 +1,98 @@ +import { useEffect, useState, type CSSProperties } from 'react'; +import { DAMAGE_NUMBER_DURATION_MS, DAMAGE_NUMBER_RISE_PX } from '../shared/constants'; +import type { FloatingDamageData } from '../game/types'; + +interface FloatingDamageProps { + damages: FloatingDamageData[]; +} + +interface DamageNumberProps { + data: FloatingDamageData; + onExpire: (id: number) => void; +} + +function DamageNumber({ data, onExpire }: DamageNumberProps) { + const [progress, setProgress] = useState(0); + + useEffect(() => { + let rafId: number; + const start = data.createdAt; + + const animate = () => { + const elapsed = performance.now() - start; + const p = Math.min(1, elapsed / DAMAGE_NUMBER_DURATION_MS); + setProgress(p); + + if (p < 1) { + rafId = requestAnimationFrame(animate); + } else { + onExpire(data.id); + } + }; + + rafId = requestAnimationFrame(animate); + return () => cancelAnimationFrame(rafId); + }, [data.createdAt, data.id, onExpire]); + + const offsetY = -progress * DAMAGE_NUMBER_RISE_PX; + const opacity = 1 - progress * progress; // ease-out fade + const scale = data.isCrit ? 1.4 - progress * 0.4 : 1; + + const style: CSSProperties = { + position: 'absolute', + left: data.x, + top: data.y + offsetY, + transform: `translate(-50%, -50%) scale(${scale})`, + opacity, + color: data.isCrit ? '#ffdd44' : '#ffffff', + fontSize: data.isCrit ? 24 : 18, + fontWeight: 900, + textShadow: '0 2px 4px rgba(0,0,0,0.9), 0 0 8px rgba(0,0,0,0.5)', + pointerEvents: 'none', + willChange: 'transform, opacity', + }; + + return ( +
+ {data.isCrit && 'CRIT '} + {Math.round(data.value)} +
+ ); +} + +/** + * Floating damage numbers overlay. + * Renders above the game canvas in screen space. + */ +export function FloatingDamage({ damages }: FloatingDamageProps) { + const [activeDamages, setActiveDamages] = useState([]); + + // Sync incoming damages + useEffect(() => { + setActiveDamages((prev) => { + const existingIds = new Set(prev.map((d) => d.id)); + const newDamages = damages.filter((d) => !existingIds.has(d.id)); + return [...prev, ...newDamages]; + }); + }, [damages]); + + const handleExpire = (id: number) => { + setActiveDamages((prev) => prev.filter((d) => d.id !== id)); + }; + + return ( +
+ {activeDamages.map((d) => ( + + ))} +
+ ); +} diff --git a/frontend/src/ui/GameToast.tsx b/frontend/src/ui/GameToast.tsx new file mode 100644 index 0000000..b3b0a29 --- /dev/null +++ b/frontend/src/ui/GameToast.tsx @@ -0,0 +1,66 @@ +import { useEffect, useState, type CSSProperties } from 'react'; + +interface GameToastProps { + message: string; + color?: string; + duration?: number; + onDone: () => void; +} + +export function GameToast({ message, color = '#ff4444', duration = 3000, onDone }: GameToastProps) { + const [fading, setFading] = useState(false); + + useEffect(() => { + const fadeTimer = setTimeout(() => setFading(true), duration - 400); + const doneTimer = setTimeout(onDone, duration); + return () => { + clearTimeout(fadeTimer); + clearTimeout(doneTimer); + }; + }, [duration, onDone]); + + const containerStyle: CSSProperties = { + position: 'absolute', + top: 32, + left: '50%', + transform: 'translateX(-50%)', + display: 'flex', + alignItems: 'center', + gap: 10, + padding: '10px 20px', + borderRadius: 8, + backgroundColor: 'rgba(0, 0, 0, 0.82)', + borderLeft: `4px solid ${color}`, + boxShadow: `0 0 16px ${color}44, 0 4px 12px rgba(0,0,0,0.5)`, + zIndex: 500, + pointerEvents: 'none', + animation: fading ? 'toast-fade-out 0.4s ease-in forwards' : 'toast-slide-down 0.35s ease-out', + maxWidth: 'calc(100vw - 48px)', + }; + + const textStyle: CSSProperties = { + fontSize: 14, + fontWeight: 600, + color: '#fff', + textShadow: `0 0 6px ${color}66`, + lineHeight: 1.3, + }; + + return ( + <> + +
+ {message} +
+ + ); +} \ No newline at end of file diff --git a/frontend/src/ui/HPBar.tsx b/frontend/src/ui/HPBar.tsx new file mode 100644 index 0000000..71b1cd1 --- /dev/null +++ b/frontend/src/ui/HPBar.tsx @@ -0,0 +1,80 @@ +import { useEffect, useRef, type CSSProperties } from 'react'; + +interface HPBarProps { + current: number; + max: number; + /** Bar color, defaults to health green */ + color?: string; + /** Height in pixels */ + height?: number; + /** Show numeric text */ + showText?: boolean; + /** Label prefix (e.g., "HP", "Enemy") */ + label?: string; +} + +const containerStyle: CSSProperties = { + width: '100%', + borderRadius: 4, + overflow: 'hidden', + position: 'relative', + backgroundColor: 'rgba(0, 0, 0, 0.6)', + border: '1px solid rgba(255, 255, 255, 0.15)', +}; + +const textStyle: CSSProperties = { + position: 'absolute', + top: 0, + left: 0, + right: 0, + bottom: 0, + display: 'flex', + alignItems: 'center', + justifyContent: 'center', + color: '#fff', + fontSize: 12, + fontWeight: 700, + textShadow: '0 1px 2px rgba(0,0,0,0.8)', + pointerEvents: 'none', +}; + +export function HPBar({ + current, + max, + color = '#44cc44', + height = 20, + showText = true, + label, +}: HPBarProps) { + const barRef = useRef(null); + const ratio = max > 0 ? Math.max(0, Math.min(1, current / max)) : 0; + + // Animate width via ref to avoid React re-renders on every tick + useEffect(() => { + if (barRef.current) { + barRef.current.style.width = `${ratio * 100}%`; + } + }, [ratio]); + + // Color shifts to red as HP drops + const barColor = ratio > 0.5 ? color : ratio > 0.25 ? '#ccaa22' : '#cc3333'; + + const barStyle: CSSProperties = { + height: '100%', + width: `${ratio * 100}%`, + backgroundColor: barColor, + transition: 'width 0.2s ease-out, background-color 0.3s ease', + borderRadius: 4, + }; + + return ( +
+
+ {showText && ( +
+ {label ? `${label}: ` : ''}{Math.ceil(current)} / {Math.ceil(max)} +
+ )} +
+ ); +} diff --git a/frontend/src/ui/HUD.tsx b/frontend/src/ui/HUD.tsx new file mode 100644 index 0000000..f20213e --- /dev/null +++ b/frontend/src/ui/HUD.tsx @@ -0,0 +1,235 @@ +import { useCallback, type CSSProperties } from 'react'; +import { HPBar } from './HPBar'; +import { BuffBar } from './BuffBar'; +import { BuffStatusStrip } from './BuffStatusStrip'; +import { DebuffBar } from './DebuffBar'; +import { LootPopup } from './LootPopup'; +import { HeroPanel } from './HeroPanel'; +import { EquipmentPanel } from './EquipmentPanel'; +import { InventoryStrip } from './InventoryStrip'; +import type { GameState } from '../game/types'; +import { GamePhase, BuffType } from '../game/types'; +import { useUiClock } from '../hooks/useUiClock'; +import type { HeroResponse } from '../network/api'; +// FREE_BUFF_ACTIVATIONS_PER_PERIOD removed — per-buff charges are now shown on each button + +interface HUDProps { + gameState: GameState; + onBuffActivate: (type: BuffType) => void; + buffCooldownEndsAt: Partial>; + onUsePotion?: () => void; + onHeroUpdated?: (hero: HeroResponse) => void; +} + +const containerStyle: CSSProperties = { + position: 'absolute', + top: 0, + left: 0, + width: '100%', + height: '100%', + pointerEvents: 'none', + display: 'flex', + flexDirection: 'column', + justifyContent: 'space-between', + padding: '12px 16px', + zIndex: 10, +}; + +const topSection: CSSProperties = { + display: 'flex', + flexDirection: 'column', + gap: 8, + pointerEvents: 'auto', +}; + +const levelBadge: CSSProperties = { + backgroundColor: 'rgba(68, 170, 255, 0.8)', + color: '#fff', + fontSize: 12, + fontWeight: 700, + padding: '2px 8px', + borderRadius: 4, + minWidth: 32, + textAlign: 'center', +}; + +const heroTopRowStyle: CSSProperties = { + display: 'flex', + justifyContent: 'flex-start', + alignItems: 'center', + gap: 8, + width: '100%', +}; + +const hpBuffRowStyle: CSSProperties = { + display: 'flex', + alignItems: 'center', + gap: 8, + width: '100%', + marginTop: 8, + minWidth: 0, +}; + +const hpBarFlex: CSSProperties = { + flex: 1, + minWidth: 0, +}; + +const enemySection: CSSProperties = { + marginTop: 8, +}; + +const enemyNameStyle: CSSProperties = { + color: '#ff6666', + fontSize: 13, + fontWeight: 600, + marginBottom: 4, + textShadow: '0 1px 2px rgba(0,0,0,0.8)', +}; + +const bottomSection: CSSProperties = { + pointerEvents: 'auto', +}; + +const phaseIndicator: CSSProperties = { + position: 'absolute', + bottom: 8, + left: 8, + color: '#fff', + fontSize: 10, + fontWeight: 500, + opacity: 0.3, + pointerEvents: 'none', + textTransform: 'uppercase', + letterSpacing: 1, +}; + +const potionButtonStyle: CSSProperties = { + display: 'inline-flex', + alignItems: 'center', + gap: 3, + padding: '3px 8px', + borderRadius: 6, + border: '1px solid rgba(100, 200, 100, 0.3)', + backgroundColor: 'rgba(30, 60, 30, 0.65)', + color: '#88dd88', + fontSize: 12, + fontWeight: 600, + cursor: 'pointer', + pointerEvents: 'auto', + userSelect: 'none', +}; + +const potionButtonDisabledStyle: CSSProperties = { + ...potionButtonStyle, + opacity: 0.4, + cursor: 'default', +}; + +export function HUD({ gameState, onBuffActivate, buffCooldownEndsAt, onUsePotion, onHeroUpdated }: HUDProps) { + const { hero, enemy, phase, lastVictoryLoot } = gameState; + const nowMs = useUiClock(100); + + const handleBuffActivate = useCallback( + (type: BuffType) => { + onBuffActivate(type); + }, + [onBuffActivate], + ); + + const debuffsLive = + hero?.debuffs + .map((d) => ({ + ...d, + remainingMs: + d.expiresAtMs != null ? Math.max(0, d.expiresAtMs - nowMs) : d.remainingMs, + })) + .filter((d) => d.remainingMs > 0) ?? []; + + return ( +
+ {/* Top: Hero HP + Enemy info */} +
+ {!hero && ( +
+ Loading hero... +
+ )} + {hero && ( + <> +
+ Lv.{hero.level} + +
+
+
+
+ +
+ +
+ {/* Per-buff charge quotas are now shown on each BuffBar button */} +
+ + + {/* Debuff indicators */} + {debuffsLive.length > 0 && } + +
+ + +
+ + )} + + {enemy && + (phase === GamePhase.Fighting || + (phase === GamePhase.Dead && enemy)) && ( +
+
{enemy.name}
+ +
+ )} +
+ + {/* Center: Phase indicator (debug/subtle) */} +
{phase}
+ + {/* Loot popup */} + + +
+ {hero && ( + + )} +
+
+ ); +} diff --git a/frontend/src/ui/HeroPanel.tsx b/frontend/src/ui/HeroPanel.tsx new file mode 100644 index 0000000..d09a0eb --- /dev/null +++ b/frontend/src/ui/HeroPanel.tsx @@ -0,0 +1,248 @@ +import { useState, type CSSProperties } from 'react'; +import type { HeroState } from '../game/types'; +import { BuffType, DebuffType, type ActiveBuff, type ActiveDebuff } from '../game/types'; +import { DEBUFF_COLORS } from '../shared/constants'; +import { HPBar } from './HPBar'; + +const BUFF_LABEL: Record = { + [BuffType.Rush]: 'Rush', + [BuffType.Rage]: 'Rage', + [BuffType.Shield]: 'Shield', + [BuffType.Luck]: 'Luck', + [BuffType.Resurrection]: 'Resurrect', + [BuffType.Heal]: 'Heal', + [BuffType.PowerPotion]: 'Power', + [BuffType.WarCry]: 'War Cry', +}; + +const DEBUFF_LABEL: Record = { + [DebuffType.Poison]: 'Poison', + [DebuffType.Freeze]: 'Freeze', + [DebuffType.Burn]: 'Burn', + [DebuffType.Stun]: 'Stun', + [DebuffType.Slow]: 'Slow', + [DebuffType.Weaken]: 'Weaken', +}; + +const wrapStyle: CSSProperties = { + marginTop: 6, + borderRadius: 8, + backgroundColor: 'rgba(0,0,0,0.45)', + border: '1px solid rgba(255,255,255,0.12)', + overflow: 'hidden', + flex: 1, + minWidth: 0, +}; + +const headerStyle: CSSProperties = { + width: '100%', + display: 'flex', + alignItems: 'center', + justifyContent: 'space-between', + padding: '6px 10px', + fontSize: 12, + fontWeight: 700, + color: '#e8e8e8', + cursor: 'pointer', + userSelect: 'none', + WebkitTapHighlightColor: 'transparent', + background: 'rgba(255,255,255,0.04)', + border: 'none', + fontFamily: 'inherit', +}; + +const bodyStyle: CSSProperties = { + padding: '8px 10px 10px', + fontSize: 11, + color: '#ccc', +}; + +const statRow: CSSProperties = { + display: 'flex', + justifyContent: 'space-between', + padding: '2px 0', + borderBottom: '1px solid rgba(255,255,255,0.06)', +}; + +const sectionTitle: CSSProperties = { + fontSize: 10, + fontWeight: 700, + color: '#888', + textTransform: 'uppercase', + letterSpacing: 0.5, + marginTop: 10, + marginBottom: 4, +}; + +const fxChip: CSSProperties = { + display: 'inline-flex', + alignItems: 'center', + gap: 4, + padding: '3px 8px', + borderRadius: 6, + fontSize: 10, + fontWeight: 600, + marginRight: 4, + marginBottom: 4, + color: '#fff', + textShadow: '0 1px 2px rgba(0,0,0,0.7)', +}; + + +function liveBuffRemaining(b: ActiveBuff, nowMs: number): number { + if (b.expiresAtMs != null) return Math.max(0, b.expiresAtMs - nowMs); + return b.remainingMs; +} + +function liveDebuffRemaining(d: ActiveDebuff, nowMs: number): number { + if (d.expiresAtMs != null) return Math.max(0, d.expiresAtMs - nowMs); + return d.remainingMs; +} + +interface HeroPanelProps { + hero: HeroState; + nowMs: number; +} + +function hasActiveBuff(buffs: ActiveBuff[], type: BuffType, nowMs: number): boolean { + return buffs.some((b) => b.type === type && liveBuffRemaining(b, nowMs) > 0); +} + +function hasActiveDebuff(debuffs: ActiveDebuff[], type: DebuffType, nowMs: number): boolean { + return debuffs.some((d) => d.type === type && liveDebuffRemaining(d, nowMs) > 0); +} + +const buffedColor = '#44ff88'; +const nerfedColor = '#ff6666'; + +function StatValue({ value, label, buffed, nerfed }: { value: string; label: string; buffed: boolean; nerfed: boolean }) { + const color = buffed ? buffedColor : nerfed ? nerfedColor : '#ccc'; + const arrow = buffed ? ' \u25B2' : nerfed ? ' \u25BC' : ''; + return ( +
+ {label} + + {value}{arrow} + +
+ ); +} + + +export function HeroPanel({ hero, nowMs }: HeroPanelProps) { + const [open, setOpen] = useState(false); + + const buffsLive = hero.activeBuffs + .map((b) => ({ + ...b, + remainingMs: liveBuffRemaining(b, nowMs), + })) + .filter((b) => b.remainingMs > 0); + + const debuffsLive = hero.debuffs + .map((d) => ({ + ...d, + remainingMs: liveDebuffRemaining(d, nowMs), + })) + .filter((d) => d.remainingMs > 0); + + const atkBuffed = hasActiveBuff(hero.activeBuffs, BuffType.Rage, nowMs) + || hasActiveBuff(hero.activeBuffs, BuffType.PowerPotion, nowMs); + const atkNerfed = hasActiveDebuff(hero.debuffs, DebuffType.Weaken, nowMs); + const spdBuffed = hasActiveBuff(hero.activeBuffs, BuffType.WarCry, nowMs); + const spdNerfed = hasActiveDebuff(hero.debuffs, DebuffType.Freeze, nowMs); + const defBuffed = hasActiveBuff(hero.activeBuffs, BuffType.Shield, nowMs); + + return ( +
+ + {open && ( +
+ {/* Combat Stats */} + + + + +
STR{hero.strength}
+
CON{hero.constitution}
+
AGI{hero.agility}
+
LUCK{hero.luck}
+ + + {/* XP */} +
Experience
+
+ +
+ + {/* Buffs */} +
Active Buffs
+ {buffsLive.length === 0 ? ( +
None
+ ) : ( +
+ {buffsLive.map((b) => ( + + {BUFF_LABEL[b.type]} + {Math.ceil(b.remainingMs / 1000)}s + + ))} +
+ )} + + {/* Debuffs */} +
Active Debuffs
+ {debuffsLive.length === 0 ? ( +
None
+ ) : ( +
+ {debuffsLive.map((d) => { + const color = DEBUFF_COLORS[d.type] ?? '#999'; + return ( + + {DEBUFF_LABEL[d.type]} + {Math.ceil(d.remainingMs / 1000)}s + + ); + })} +
+ )} +
+ )} +
+ ); +} diff --git a/frontend/src/ui/InventoryStrip.tsx b/frontend/src/ui/InventoryStrip.tsx new file mode 100644 index 0000000..ac20477 --- /dev/null +++ b/frontend/src/ui/InventoryStrip.tsx @@ -0,0 +1,70 @@ +import type { CSSProperties } from 'react'; +import type { HeroState, LootDrop } from '../game/types'; + +interface InventoryStripProps { + hero: HeroState; + /** Most recent victory loot (gold + optional item); persists after popup fades */ + lastLoot?: LootDrop | null; +} + +function formatLastLootLine(loot: LootDrop): string { + const parts: string[] = []; + if (loot.goldAmount > 0) { + parts.push(`+${loot.goldAmount.toLocaleString()} gold`); + } + if (loot.bonusItem?.itemName) { + parts.push(loot.bonusItem.itemName); + } else if (loot.itemName && !loot.bonusItem) { + parts.push(loot.itemName); + } + return parts.join(' \u00B7 ') || 'Victory'; +} + +const stripStyle: CSSProperties = { + marginTop: 4, + display: 'flex', + alignItems: 'center', + gap: 8, + padding: '4px 8px', + borderRadius: 8, + background: 'rgba(10, 16, 24, 0.72)', + border: '1px solid rgba(255, 255, 255, 0.14)', + fontSize: 12, + minHeight: 28, +}; + +const goldStyle: CSSProperties = { + display: 'flex', + alignItems: 'center', + gap: 5, + color: '#ffd700', + fontWeight: 700, + flexShrink: 0, + whiteSpace: 'nowrap', +}; + +const lastLootStyle: CSSProperties = { + marginLeft: 'auto', + fontSize: 10, + color: 'rgba(220, 230, 255, 0.7)', + whiteSpace: 'nowrap', + textOverflow: 'ellipsis', + overflow: 'hidden', + maxWidth: 160, +}; + +export function InventoryStrip({ hero, lastLoot }: InventoryStripProps) { + return ( +
+
+ {'\uD83E\uDE99'} + {hero.gold.toLocaleString()} +
+ {lastLoot && ( +
+ {formatLastLootLine(lastLoot)} +
+ )} +
+ ); +} diff --git a/frontend/src/ui/LootPopup.tsx b/frontend/src/ui/LootPopup.tsx new file mode 100644 index 0000000..dfc492f --- /dev/null +++ b/frontend/src/ui/LootPopup.tsx @@ -0,0 +1,153 @@ +import { useEffect, useState, type CSSProperties } from 'react'; +import { Rarity, type LootDrop } from '../game/types'; +import { RARITY_COLORS, RARITY_GLOW, LOOT_POPUP_DURATION_MS } from '../shared/constants'; + +// ---- Types ---- + +interface LootPopupProps { + loot: LootDrop | null; +} + +// ---- Helpers ---- + +function rarityLabel(rarity: Rarity): string { + switch (rarity) { + case Rarity.Common: return 'Common'; + case Rarity.Uncommon: return 'Uncommon'; + case Rarity.Rare: return 'Rare'; + case Rarity.Epic: return 'Epic'; + case Rarity.Legendary: return 'Legendary'; + default: return 'Common'; + } +} + +// ---- Component ---- + +export function LootPopup({ loot }: LootPopupProps) { + const [visible, setVisible] = useState(false); + const [currentLoot, setCurrentLoot] = useState(null); + + useEffect(() => { + if (!loot) return; + + setCurrentLoot(loot); + setVisible(true); + + const timer = setTimeout(() => { + setVisible(false); + }, LOOT_POPUP_DURATION_MS); + + return () => clearTimeout(timer); + // Re-show when a new drop object arrives (reference + payload may repeat). + }, [loot, loot?.goldAmount, loot?.rarity, loot?.itemName, loot?.bonusItem?.itemType]); + + if (!visible || !currentLoot) return null; + + const color = RARITY_COLORS[currentLoot.rarity] ?? RARITY_COLORS.common; + const bonusColor = currentLoot.bonusItem + ? (RARITY_COLORS[currentLoot.bonusItem.rarity] ?? color) + : color; + const isLegendary = + currentLoot.rarity === Rarity.Legendary || + currentLoot.bonusItem?.rarity === Rarity.Legendary; + + const containerStyle: CSSProperties = { + position: 'absolute', + bottom: 100, + left: '50%', + transform: 'translateX(-50%)', + display: 'flex', + flexDirection: 'column', + alignItems: 'center', + gap: 6, + padding: '12px 24px', + borderRadius: 12, + backgroundColor: 'rgba(0, 0, 0, 0.75)', + border: `2px solid ${color}`, + boxShadow: RARITY_GLOW[currentLoot.rarity] ?? `0 0 20px ${color}66`, + zIndex: 400, + pointerEvents: 'none', + animation: 'loot-slide-in 0.4s ease-out', + overflow: 'hidden', + }; + + const nameStyle: CSSProperties = { + fontSize: 16, + fontWeight: 700, + color, + textShadow: `0 0 8px ${color}88`, + textAlign: 'center', + }; + + const rarityTagStyle: CSSProperties = { + fontSize: 11, + fontWeight: 600, + color, + opacity: 0.8, + textTransform: 'uppercase', + letterSpacing: 1, + }; + + const goldStyle: CSSProperties = { + fontSize: 14, + fontWeight: 700, + color: '#ffd700', + textShadow: '0 0 6px rgba(255, 215, 0, 0.5)', + }; + + return ( + <> + +
+ {/* Legendary golden ray background effect */} + {isLegendary && ( +
+ )} + + {rarityLabel(currentLoot.rarity)} + + {currentLoot.itemName && !currentLoot.bonusItem && ( + {currentLoot.itemName} + )} + + {currentLoot.goldAmount > 0 && ( + +{currentLoot.goldAmount} gold + )} + + {currentLoot.bonusItem && ( + + {currentLoot.bonusItem.itemName ?? + (currentLoot.bonusItem.itemType === 'weapon' ? 'Weapon drop' : 'Armor drop')} + + )} +
+ + ); +} diff --git a/frontend/src/ui/Minimap.tsx b/frontend/src/ui/Minimap.tsx new file mode 100644 index 0000000..f0c6c57 --- /dev/null +++ b/frontend/src/ui/Minimap.tsx @@ -0,0 +1,234 @@ +import { useEffect, useRef, useState, type CSSProperties } from 'react'; +import { buildWorldTerrainContext, proceduralTerrain, townsApiToInfluences } from '../game/procedural'; +import type { Town } from '../game/types'; + +// ---- Types ---- + +interface MinimapProps { + heroX: number; + heroY: number; + towns: Town[]; +} + +/** 0 = свернуто, 1 = маленькая, 2 = большая */ +type MapMode = 0 | 1 | 2; + +// ---- Constants ---- + +const SIZE_SMALL = 120; +const SIZE_LARGE = 240; + +/** Each pixel represents this many world units */ +const WORLD_UNITS_PER_PX = 10; +/** Only redraw when hero has moved at least this many world units */ +const REDRAW_THRESHOLD = 5; + +const TERRAIN_BG: Record = { + grass: '#3a7a28', + road: '#8e7550', + dirt: '#7c6242', + stone: '#6c7078', + plaza: '#6c6c75', + forest_floor: '#2d5a24', + ruins_floor: '#5a5a58', + canyon_floor: '#8b7355', + swamp_floor: '#3d5c42', + volcanic_floor: '#5c3830', + astral_floor: '#4a4580', +}; + +const DEFAULT_BG = '#1e2420'; + +// ---- Styles ---- + +const containerStyle: CSSProperties = { + position: 'fixed', + top: 42, + right: 8, + zIndex: 40, + userSelect: 'none', +}; + +const toggleBtnStyle: CSSProperties = { + display: 'flex', + alignItems: 'center', + justifyContent: 'center', + gap: 4, + padding: '3px 8px', + fontSize: 8, + fontWeight: 700, + color: 'rgba(255,255,255,0.55)', + background: 'rgba(0,0,0,0.5)', + border: '1px solid rgba(255,255,255,0.15)', + borderRadius: 6, + cursor: 'pointer', + fontFamily: 'monospace', + letterSpacing: 1, + WebkitTapHighlightColor: 'transparent', + marginBottom: 2, + marginLeft: 'auto', + pointerEvents: 'auto', +}; + +function canvasStyleForSize(px: number): CSSProperties { + return { + width: px, + height: px, + borderRadius: 8, + border: '2px solid rgba(255,255,255,0.2)', + boxShadow: '0 2px 12px rgba(0,0,0,0.6)', + display: 'block', + }; +} + +function modeLabel(mode: MapMode): string { + if (mode === 0) return `MAP \u25B6`; + if (mode === 1) return 'MAP S'; + return 'MAP L'; +} + +// ---- Component ---- + +export function Minimap({ heroX, heroY, towns }: MinimapProps) { + const [mode, setMode] = useState(1); + const canvasRef = useRef(null); + const lastDrawPos = useRef<{ x: number; y: number }>({ x: NaN, y: NaN }); + const lastHeroTile = useRef<{ tx: number; ty: number } | null>(null); + + const size = mode === 2 ? SIZE_LARGE : SIZE_SMALL; + const collapsed = mode === 0; + + useEffect(() => { + if (!collapsed) { + lastDrawPos.current = { x: NaN, y: NaN }; + lastHeroTile.current = null; + } + }, [collapsed, size]); + + useEffect(() => { + if (collapsed) return; + + const tileX = Math.floor(heroX); + const tileY = Math.floor(heroY); + const last = lastDrawPos.current; + const dx = Math.abs(heroX - last.x); + const dy = Math.abs(heroY - last.y); + const lt = lastHeroTile.current; + const tileChanged = !lt || lt.tx !== tileX || lt.ty !== tileY; + if (!tileChanged && dx < REDRAW_THRESHOLD && dy < REDRAW_THRESHOLD) return; + + const canvas = canvasRef.current; + if (!canvas) return; + const ctx = canvas.getContext('2d'); + if (!ctx) return; + + lastDrawPos.current = { x: heroX, y: heroY }; + lastHeroTile.current = { tx: tileX, ty: tileY }; + + const w = canvas.width; + const h = canvas.height; + const cx = w / 2; + const cy = h / 2; + const minDim = Math.min(w, h); + const gridStep = Math.max(10, Math.round(minDim / 6)); + const fontLetter = `${Math.max(7, Math.round(minDim * 0.067))}px monospace`; + const fontTown = `${Math.max(5, Math.round(minDim * 0.048))}px monospace`; + const margin = Math.max(4, Math.round(minDim * 0.05)); + const heroR = Math.max(3, Math.round(minDim * 0.035)); + const glowR = Math.max(8, Math.round(minDim * 0.09)); + + const miniCtx = + towns.length === 0 + ? null + : buildWorldTerrainContext(townsApiToInfluences(towns), null); + const terrain = proceduralTerrain(tileX, tileY, miniCtx); + ctx.fillStyle = TERRAIN_BG[terrain] ?? DEFAULT_BG; + ctx.fillRect(0, 0, w, h); + + ctx.strokeStyle = 'rgba(180, 170, 140, 0.4)'; + ctx.lineWidth = Math.max(1, minDim / 70); + ctx.beginPath(); + const diagOff = minDim * 0.06; + ctx.moveTo(0, cy + diagOff); + ctx.lineTo(w, cy - diagOff); + ctx.stroke(); + + ctx.strokeStyle = 'rgba(255, 255, 255, 0.06)'; + ctx.lineWidth = 0.5; + for (let gx = 0; gx < w; gx += gridStep) { + ctx.beginPath(); ctx.moveTo(gx, 0); ctx.lineTo(gx, h); ctx.stroke(); + } + for (let gy = 0; gy < h; gy += gridStep) { + ctx.beginPath(); ctx.moveTo(0, gy); ctx.lineTo(w, gy); ctx.stroke(); + } + + for (const town of towns) { + const relX = (town.worldX - heroX) / WORLD_UNITS_PER_PX; + const relY = (town.worldY - heroY) / WORLD_UNITS_PER_PX; + let px = cx + relX; + let py = cy + relY; + + const clamped = + px < margin || px > w - margin || py < margin || py > h - margin; + px = Math.max(margin, Math.min(w - margin, px)); + py = Math.max(margin, Math.min(h - margin, py)); + + const radius = clamped ? heroR * 0.95 : heroR + 1; + ctx.beginPath(); + ctx.arc(px, py, radius, 0, Math.PI * 2); + ctx.fillStyle = '#daa520'; + ctx.fill(); + ctx.strokeStyle = '#ffd700'; + ctx.lineWidth = 1.2; + ctx.stroke(); + + const letter = town.name.charAt(0).toUpperCase(); + ctx.fillStyle = '#000'; + ctx.font = `bold ${fontLetter}`; + ctx.textAlign = 'center'; + ctx.textBaseline = 'middle'; + ctx.fillText(letter, px, py + 0.5); + + if (!clamped) { + ctx.fillStyle = 'rgba(255,255,255,0.7)'; + ctx.font = fontTown; + ctx.fillText(town.name, px, py + radius + Math.max(5, minDim * 0.04)); + } + } + + const grad = ctx.createRadialGradient(cx, cy, 0, cx, cy, glowR); + grad.addColorStop(0, 'rgba(0, 255, 255, 0.3)'); + grad.addColorStop(1, 'rgba(0, 255, 255, 0)'); + ctx.fillStyle = grad; + ctx.fillRect(cx - glowR, cy - glowR, glowR * 2, glowR * 2); + + ctx.beginPath(); + ctx.arc(cx, cy, heroR, 0, Math.PI * 2); + ctx.fillStyle = '#00ffff'; + ctx.fill(); + ctx.strokeStyle = '#ffffff'; + ctx.lineWidth = 1.5; + ctx.stroke(); + }, [heroX, heroY, towns, collapsed, size]); + + return ( +
+ + {!collapsed && ( + + )} +
+ ); +} diff --git a/frontend/src/ui/NPCDialog.tsx b/frontend/src/ui/NPCDialog.tsx new file mode 100644 index 0000000..d23c371 --- /dev/null +++ b/frontend/src/ui/NPCDialog.tsx @@ -0,0 +1,563 @@ +import { useState, useEffect, useCallback, type CSSProperties } from 'react'; +import type { NPC, Quest, HeroQuest } from '../game/types'; +import { getNPCQuests, acceptQuest, claimQuest, buyPotion, healAtNPC } from '../network/api'; +import type { HeroResponse } from '../network/api'; +import { getTelegramUserId } from '../shared/telegram'; +import { hapticImpact } from '../shared/telegram'; + +// ---- Types ---- + +interface NPCDialogProps { + npc: NPC; + heroQuests: HeroQuest[]; + heroGold: number; + onClose: () => void; + onQuestsChanged: () => void; + onHeroUpdated: (hero: HeroResponse) => void; + onToast: (message: string, color: string) => void; +} + +// ---- Styles ---- + +const overlayStyle: CSSProperties = { + position: 'absolute', + inset: 0, + zIndex: 700, + pointerEvents: 'auto', +}; + +const backdropStyle: CSSProperties = { + position: 'absolute', + inset: 0, + backgroundColor: 'rgba(0, 0, 0, 0.6)', +}; + +const dialogStyle: CSSProperties = { + position: 'absolute', + bottom: 0, + left: 0, + right: 0, + maxHeight: '55vh', + backgroundColor: 'rgba(15, 15, 25, 0.96)', + borderTop: '2px solid rgba(255, 215, 0, 0.35)', + borderRadius: '16px 16px 0 0', + display: 'flex', + flexDirection: 'column', + animation: 'npc-dialog-slide-up 0.3s ease-out', + overflow: 'hidden', +}; + +const headerStyle: CSSProperties = { + display: 'flex', + alignItems: 'center', + justifyContent: 'space-between', + padding: '12px 16px 8px', + borderBottom: '1px solid rgba(255, 255, 255, 0.08)', +}; + +const npcNameStyle: CSSProperties = { + fontSize: 15, + fontWeight: 700, + color: '#e8e8e8', +}; + +const npcTypeTag: CSSProperties = { + fontSize: 10, + fontWeight: 600, + color: '#999', + textTransform: 'uppercase', + letterSpacing: 0.5, + marginLeft: 8, +}; + +const closeBtnStyle: CSSProperties = { + background: 'none', + border: 'none', + color: '#888', + fontSize: 20, + cursor: 'pointer', + padding: '4px 8px', + lineHeight: 1, +}; + +const bodyStyle: CSSProperties = { + overflowY: 'auto', + padding: '10px 14px 18px', + flex: 1, +}; + +const sectionTitleStyle: CSSProperties = { + fontSize: 11, + fontWeight: 700, + color: '#888', + textTransform: 'uppercase', + letterSpacing: 0.5, + marginTop: 10, + marginBottom: 6, +}; + +const questCardStyle: CSSProperties = { + backgroundColor: 'rgba(255, 255, 255, 0.04)', + border: '1px solid rgba(255, 255, 255, 0.08)', + borderRadius: 10, + padding: '10px 12px', + marginBottom: 8, +}; + +const questTitleRow: CSSProperties = { + display: 'flex', + alignItems: 'center', + justifyContent: 'space-between', + gap: 8, +}; + +const questTitleText: CSSProperties = { + fontSize: 13, + fontWeight: 600, + color: '#e8e8e8', + flex: 1, +}; + +const questDescStyle: CSSProperties = { + fontSize: 11, + color: '#999', + marginTop: 4, + lineHeight: 1.4, +}; + +const rewardsRow: CSSProperties = { + display: 'flex', + gap: 10, + marginTop: 6, + fontSize: 11, + fontWeight: 600, +}; + +const rewardChip: CSSProperties = { + display: 'inline-flex', + alignItems: 'center', + gap: 3, +}; + +const acceptBtnStyle: CSSProperties = { + marginTop: 8, + width: '100%', + padding: '8px 0', + border: 'none', + borderRadius: 8, + backgroundColor: 'rgba(68, 170, 255, 0.25)', + color: '#66bbff', + fontSize: 12, + fontWeight: 700, + cursor: 'pointer', + transition: 'background-color 150ms ease', +}; + +const claimBtnStyle: CSSProperties = { + marginTop: 8, + width: '100%', + padding: '8px 0', + border: 'none', + borderRadius: 8, + backgroundColor: 'rgba(255, 215, 0, 0.25)', + color: '#ffd700', + fontSize: 12, + fontWeight: 700, + cursor: 'pointer', + textShadow: '0 0 6px rgba(255, 215, 0, 0.4)', + animation: 'npc-claim-glow 1.5s ease-in-out infinite', +}; + +const progressBarOuter: CSSProperties = { + height: 6, + borderRadius: 3, + backgroundColor: 'rgba(255, 255, 255, 0.08)', + marginTop: 6, + overflow: 'hidden', +}; + +const serviceBtnStyle: CSSProperties = { + width: '100%', + padding: '12px 0', + border: 'none', + borderRadius: 10, + fontSize: 14, + fontWeight: 700, + cursor: 'pointer', + marginBottom: 8, + transition: 'background-color 150ms ease', +}; + +const disabledBtnStyle: CSSProperties = { + ...serviceBtnStyle, + opacity: 0.4, + cursor: 'default', +}; + +// ---- NPC Type Info ---- + +function npcTypeIcon(type: string): string { + switch (type) { + case 'quest_giver': + return '\u2753'; // question mark + case 'merchant': + return '\uD83D\uDCB0'; // money bag + case 'healer': + return '\u2764\uFE0F'; // heart + default: + return '\uD83D\uDDE3\uFE0F'; // speaking + } +} + +function npcTypeLabel(type: string): string { + switch (type) { + case 'quest_giver': return 'Quest Giver'; + case 'merchant': return 'Merchant'; + case 'healer': return 'Healer'; + default: return 'NPC'; + } +} + +function questTypeIcon(type: string): string { + switch (type) { + case 'kill_count': return '\u2694\uFE0F'; + case 'visit_town': return '\uD83E\uDDED'; + case 'collect_item': return '\uD83D\uDC8E'; + default: return '\uD83D\uDCDC'; + } +} + +// ---- Constants ---- + +const POTION_COST = 50; +const HEAL_COST = 30; + +// ---- Component ---- + +export function NPCDialog({ + npc, + heroQuests, + heroGold, + onClose, + onQuestsChanged, + onHeroUpdated, + onToast, +}: NPCDialogProps) { + const [availableQuests, setAvailableQuests] = useState([]); + const [loading, setLoading] = useState(false); + + const telegramId = getTelegramUserId() ?? 1; + + // Fetch available quests for quest giver NPCs + useEffect(() => { + if (npc.type !== 'quest_giver') return; + setLoading(true); + getNPCQuests(npc.id, telegramId) + .then((qs) => setAvailableQuests(qs)) + .catch((err) => { + console.warn('[NPCDialog] Failed to fetch quests:', err); + setAvailableQuests([]); + }) + .finally(() => setLoading(false)); + }, [npc.id, npc.type, telegramId]); + + // Close on Escape + useEffect(() => { + const handleKey = (e: KeyboardEvent) => { + if (e.key === 'Escape') onClose(); + }; + window.addEventListener('keydown', handleKey); + return () => window.removeEventListener('keydown', handleKey); + }, [onClose]); + + const handleAcceptQuest = useCallback( + (questId: number) => { + acceptQuest(questId, telegramId) + .then(() => { + hapticImpact('medium'); + onToast('Quest accepted!', '#44aaff'); + onQuestsChanged(); + // Remove from available list + setAvailableQuests((prev) => prev.filter((q) => q.id !== questId)); + }) + .catch((err) => { + console.warn('[NPCDialog] Failed to accept quest:', err); + onToast('Failed to accept quest', '#ff4444'); + }); + }, + [telegramId, onQuestsChanged, onToast], + ); + + const handleClaimQuest = useCallback( + (heroQuestId: number) => { + claimQuest(heroQuestId, telegramId) + .then((hero) => { + hapticImpact('heavy'); + onToast('Quest rewards claimed!', '#ffd700'); + onHeroUpdated(hero); + onQuestsChanged(); + }) + .catch((err) => { + console.warn('[NPCDialog] Failed to claim quest:', err); + onToast('Failed to claim rewards', '#ff4444'); + }); + }, + [telegramId, onQuestsChanged, onHeroUpdated, onToast], + ); + + const handleBuyPotion = useCallback(() => { + if (heroGold < POTION_COST) { + onToast('Not enough gold!', '#ff4444'); + return; + } + buyPotion(telegramId) + .then((hero) => { + hapticImpact('medium'); + onToast(`Bought a potion for ${POTION_COST} gold`, '#88dd88'); + onHeroUpdated(hero); + }) + .catch((err) => { + console.warn('[NPCDialog] Failed to buy potion:', err); + onToast('Failed to buy potion', '#ff4444'); + }); + }, [telegramId, heroGold, onHeroUpdated, onToast]); + + const handleHeal = useCallback(() => { + if (heroGold < HEAL_COST) { + onToast('Not enough gold!', '#ff4444'); + return; + } + healAtNPC(telegramId) + .then((hero) => { + hapticImpact('medium'); + onToast('Healed to full HP!', '#44cc44'); + onHeroUpdated(hero); + }) + .catch((err) => { + console.warn('[NPCDialog] Failed to heal:', err); + onToast('Failed to heal', '#ff4444'); + }); + }, [telegramId, heroGold, onHeroUpdated, onToast]); + + // Quests relevant to this NPC + const npcHeroQuests = heroQuests.filter( + (hq) => hq.status !== 'claimed', + ); + // Filter to quests from this NPC based on npcName matching + const npcInProgressQuests = npcHeroQuests.filter( + (hq) => hq.npcName === npc.name && hq.status === 'accepted', + ); + const npcCompletedQuests = npcHeroQuests.filter( + (hq) => hq.npcName === npc.name && hq.status === 'completed', + ); + + return ( + <> + +
+
+
+ {/* Header */} +
+
+ {npcTypeIcon(npc.type)} + {npc.name} + {npcTypeLabel(npc.type)} +
+ +
+ + {/* Body */} +
+ {/* ---- Quest Giver ---- */} + {npc.type === 'quest_giver' && ( + <> + {/* Completed quests — claim first */} + {npcCompletedQuests.length > 0 && ( + <> +
Completed
+ {npcCompletedQuests.map((hq) => ( +
+
+ {questTypeIcon(hq.type)} + {hq.title} + + {hq.progress}/{hq.targetCount} + +
+
+ {hq.rewardXp > 0 && ( + + {'\u2728'} {hq.rewardXp} XP + + )} + {hq.rewardGold > 0 && ( + + {'\uD83D\uDCB0'} {hq.rewardGold} + + )} + {hq.rewardPotions > 0 && ( + + {'\uD83E\uDDEA'} {hq.rewardPotions} + + )} +
+ +
+ ))} + + )} + + {/* In-progress quests */} + {npcInProgressQuests.length > 0 && ( + <> +
In Progress
+ {npcInProgressQuests.map((hq) => { + const pct = hq.targetCount > 0 + ? Math.min(100, (hq.progress / hq.targetCount) * 100) + : 0; + return ( +
+
+ {questTypeIcon(hq.type)} + {hq.title} + + {hq.progress}/{hq.targetCount} + +
+
+
+
+
+ ); + })} + + )} + + {/* Available quests */} + {loading ? ( +
+ Loading quests... +
+ ) : availableQuests.length > 0 ? ( + <> +
Available Quests
+ {availableQuests.map((q) => ( +
+
+ {questTypeIcon(q.type)} + {q.title} +
+
{q.description}
+
+ {q.rewardXp > 0 && ( + + {'\u2728'} {q.rewardXp} XP + + )} + {q.rewardGold > 0 && ( + + {'\uD83D\uDCB0'} {q.rewardGold} + + )} + {q.rewardPotions > 0 && ( + + {'\uD83E\uDDEA'} {q.rewardPotions} + + )} +
+ +
+ ))} + + ) : ( + npcInProgressQuests.length === 0 && + npcCompletedQuests.length === 0 && ( +
+ No quests available right now. +
+ ) + )} + + )} + + {/* ---- Merchant ---- */} + {npc.type === 'merchant' && ( + <> +
Shop
+ +
+ Your gold: {heroGold} +
+ + )} + + {/* ---- Healer ---- */} + {npc.type === 'healer' && ( + <> +
Services
+ +
+ Your gold: {heroGold} +
+ + )} +
+
+
+ + ); +} diff --git a/frontend/src/ui/NPCInteraction.tsx b/frontend/src/ui/NPCInteraction.tsx new file mode 100644 index 0000000..fb46033 --- /dev/null +++ b/frontend/src/ui/NPCInteraction.tsx @@ -0,0 +1,207 @@ +import { useCallback, type CSSProperties } from 'react'; +import type { NPCData } from '../game/types'; + +// ---- Types ---- + +interface NPCInteractionProps { + npc: NPCData; + heroGold: number; + onViewQuests: (npc: NPCData) => void; + onBuyPotion: (npc: NPCData) => void; + onHeal: (npc: NPCData) => void; + onDismiss: () => void; +} + +// ---- Styles ---- + +const panelStyle: CSSProperties = { + position: 'absolute', + bottom: 130, + left: '50%', + transform: 'translateX(-50%)', + minWidth: 220, + maxWidth: 320, + backgroundColor: 'rgba(15, 15, 25, 0.94)', + border: '1px solid rgba(255, 215, 0, 0.3)', + borderRadius: 12, + padding: '10px 14px 12px', + zIndex: 120, + pointerEvents: 'auto', + animation: 'npc-interact-fade-in 0.25s ease-out', + boxShadow: '0 4px 20px rgba(0, 0, 0, 0.5)', +}; + +const headerRow: CSSProperties = { + display: 'flex', + alignItems: 'center', + gap: 8, + marginBottom: 8, +}; + +const npcIconStyle: CSSProperties = { + width: 28, + height: 28, + borderRadius: 14, + display: 'flex', + alignItems: 'center', + justifyContent: 'center', + fontSize: 14, + fontWeight: 700, +}; + +const npcNameStyle: CSSProperties = { + fontSize: 13, + fontWeight: 700, + color: '#e8e8e8', + flex: 1, +}; + +const npcTypeStyle: CSSProperties = { + fontSize: 9, + fontWeight: 600, + color: '#888', + textTransform: 'uppercase', + letterSpacing: 0.5, +}; + +const actionBtnStyle: CSSProperties = { + width: '100%', + padding: '8px 12px', + border: 'none', + borderRadius: 8, + fontSize: 12, + fontWeight: 600, + cursor: 'pointer', + marginBottom: 4, + transition: 'background-color 150ms ease', + textAlign: 'center', +}; + +const POTION_COST = 50; +const HEAL_COST = 30; + +// ---- NPC appearance ---- + +function npcColor(type: string): { bg: string; icon: string; text: string } { + switch (type) { + case 'quest_giver': + return { bg: 'rgba(218, 165, 32, 0.2)', icon: '!', text: 'Quest Giver' }; + case 'merchant': + return { bg: 'rgba(68, 170, 85, 0.2)', icon: '$', text: 'Merchant' }; + case 'healer': + return { bg: 'rgba(220, 80, 80, 0.2)', icon: '+', text: 'Healer' }; + default: + return { bg: 'rgba(136, 136, 170, 0.2)', icon: '?', text: 'NPC' }; + } +} + +// ---- Component ---- + +export function NPCInteraction({ + npc, + heroGold, + onViewQuests, + onBuyPotion, + onHeal, + onDismiss, +}: NPCInteractionProps) { + const info = npcColor(npc.type); + + const handleAction = useCallback(() => { + switch (npc.type) { + case 'quest_giver': + onViewQuests(npc); + break; + case 'merchant': + onBuyPotion(npc); + break; + case 'healer': + onHeal(npc); + break; + } + }, [npc, onViewQuests, onBuyPotion, onHeal]); + + const actionLabel = (() => { + switch (npc.type) { + case 'quest_giver': + return 'View Quests'; + case 'merchant': + return `Buy Potion (${POTION_COST}g)`; + case 'healer': + return `Heal to Full (${HEAL_COST}g)`; + default: + return 'Talk'; + } + })(); + + const canAfford = + npc.type === 'quest_giver' || + (npc.type === 'merchant' && heroGold >= POTION_COST) || + (npc.type === 'healer' && heroGold >= HEAL_COST); + + return ( + <> + +
+
+
+ {info.icon} +
+
+
{npc.name}
+
{info.text}
+
+ +
+ + +
+ + ); +} diff --git a/frontend/src/ui/NameEntryScreen.tsx b/frontend/src/ui/NameEntryScreen.tsx new file mode 100644 index 0000000..1bc59aa --- /dev/null +++ b/frontend/src/ui/NameEntryScreen.tsx @@ -0,0 +1,190 @@ +import { useState, useRef, useEffect, type CSSProperties, type FormEvent } from 'react'; +import { ApiError, setHeroName } from '../network/api'; +import type { HeroResponse } from '../network/api'; +import { getTelegramUserId } from '../shared/telegram'; + +const MIN_LEN = 2; +const MAX_LEN = 16; + +interface NameEntryScreenProps { + onNameSet: (hero: HeroResponse) => void; +} + +const overlayStyle: CSSProperties = { + position: 'absolute', + inset: 0, + display: 'flex', + alignItems: 'center', + justifyContent: 'center', + backgroundColor: 'rgba(0, 0, 0, 0.82)', + zIndex: 100, + fontFamily: 'system-ui, sans-serif', +}; + +const cardStyle: CSSProperties = { + width: '90%', + maxWidth: 340, + padding: '28px 24px', + borderRadius: 14, + backgroundColor: 'rgba(18, 18, 32, 0.96)', + border: '1px solid rgba(180, 140, 255, 0.25)', + boxShadow: '0 0 40px rgba(120, 80, 220, 0.15), 0 8px 32px rgba(0,0,0,0.5)', + display: 'flex', + flexDirection: 'column' as const, + alignItems: 'center', + gap: 16, +}; + +const titleStyle: CSSProperties = { + fontSize: 20, + fontWeight: 800, + color: '#e8dff8', + textAlign: 'center', + letterSpacing: 0.5, + textShadow: '0 0 12px rgba(180, 140, 255, 0.3)', +}; + +const inputStyle: CSSProperties = { + width: '100%', + padding: '12px 14px', + fontSize: 16, + fontWeight: 600, + color: '#eee', + backgroundColor: 'rgba(255, 255, 255, 0.07)', + border: '2px solid rgba(180, 140, 255, 0.3)', + borderRadius: 8, + outline: 'none', + fontFamily: 'inherit', + boxSizing: 'border-box', + transition: 'border-color 200ms ease', +}; + +const inputFocusedBorder = 'rgba(180, 140, 255, 0.6)'; + +const counterStyle: CSSProperties = { + fontSize: 11, + color: '#888', + alignSelf: 'flex-end', + marginTop: -10, +}; + +const buttonStyle: CSSProperties = { + width: '100%', + padding: '13px 0', + fontSize: 16, + fontWeight: 700, + color: '#fff', + backgroundColor: '#6a40c8', + border: 'none', + borderRadius: 8, + cursor: 'pointer', + transition: 'background-color 150ms ease, opacity 150ms ease', +}; + +const errorStyle: CSSProperties = { + fontSize: 12, + fontWeight: 600, + color: '#ff5555', + textAlign: 'center', + minHeight: 16, +}; + +export function NameEntryScreen({ onNameSet }: NameEntryScreenProps) { + const [name, setName] = useState(''); + const [loading, setLoading] = useState(false); + const [error, setError] = useState(null); + const [focused, setFocused] = useState(false); + const inputRef = useRef(null); + + useEffect(() => { + // Auto-focus on mount with a small delay for mobile keyboards + const t = setTimeout(() => inputRef.current?.focus(), 300); + return () => clearTimeout(t); + }, []); + + const trimmed = name.trim(); + const isValid = trimmed.length >= MIN_LEN && trimmed.length <= MAX_LEN; + + const handleSubmit = async (e: FormEvent) => { + e.preventDefault(); + if (!isValid || loading) return; + + setLoading(true); + setError(null); + + try { + const telegramId = getTelegramUserId(); + const hero = await setHeroName(trimmed, telegramId ?? undefined); + onNameSet(hero); + } catch (err) { + if (err instanceof ApiError) { + if (err.status === 409) { + setError('Name already taken, try another'); + } else if (err.status === 400) { + try { + const j = JSON.parse(err.body) as { error?: string }; + setError(j.error ?? 'Invalid name'); + } catch { + setError('Invalid name'); + } + } else { + setError(`Server error (${err.status})`); + } + } else { + setError('Connection failed, please retry'); + } + } finally { + setLoading(false); + } + }; + + return ( +
+
+
Choose Your Hero Name
+ + { + const v = e.target.value; + if (v.length <= MAX_LEN) { + setName(v); + setError(null); + } + }} + onFocus={() => setFocused(true)} + onBlur={() => setFocused(false)} + placeholder="Enter a name..." + maxLength={MAX_LEN} + autoComplete="off" + autoCorrect="off" + spellCheck={false} + style={{ + ...inputStyle, + borderColor: focused ? inputFocusedBorder : inputStyle.borderColor, + }} + /> + +
+ {trimmed.length}/{MAX_LEN} +
+ +
{error ?? '\u00A0'}
+ + +
+
+ ); +} diff --git a/frontend/src/ui/OfflineReport.tsx b/frontend/src/ui/OfflineReport.tsx new file mode 100644 index 0000000..99867c7 --- /dev/null +++ b/frontend/src/ui/OfflineReport.tsx @@ -0,0 +1,121 @@ +import { useEffect, useState, type CSSProperties } from 'react'; + +interface OfflineReportProps { + monstersKilled: number; + xpGained: number; + goldGained: number; + levelsGained: number; + onDismiss: () => void; +} + +const overlayStyle: CSSProperties = { + position: 'absolute', + top: 0, + left: 0, + right: 0, + bottom: 0, + display: 'flex', + alignItems: 'center', + justifyContent: 'center', + backgroundColor: 'rgba(0, 0, 0, 0.65)', + zIndex: 400, + cursor: 'pointer', + pointerEvents: 'auto', +}; + +const cardStyle: CSSProperties = { + backgroundColor: 'rgba(15, 15, 30, 0.95)', + border: '1px solid rgba(100, 160, 255, 0.3)', + borderRadius: 12, + padding: '20px 28px', + maxWidth: 320, + width: 'calc(100vw - 48px)', + textAlign: 'center', + boxShadow: '0 0 30px rgba(50, 100, 200, 0.2)', + animation: 'offline-report-in 0.4s ease-out', +}; + +const titleStyle: CSSProperties = { + fontSize: 16, + fontWeight: 700, + color: '#b8d4ff', + marginBottom: 12, +}; + +const lineStyle: CSSProperties = { + fontSize: 14, + color: '#ddd', + lineHeight: 1.8, +}; + +const highlightStyle: CSSProperties = { + fontWeight: 700, + color: '#ffd700', +}; + +const hintStyle: CSSProperties = { + fontSize: 11, + color: 'rgba(180, 190, 220, 0.5)', + marginTop: 14, +}; + +export function OfflineReport({ + monstersKilled, + xpGained, + goldGained, + levelsGained, + onDismiss, +}: OfflineReportProps) { + const [fading, setFading] = useState(false); + + useEffect(() => { + const fadeTimer = setTimeout(() => setFading(true), 4600); + const doneTimer = setTimeout(onDismiss, 5000); + return () => { + clearTimeout(fadeTimer); + clearTimeout(doneTimer); + }; + }, [onDismiss]); + + return ( + <> + +
+
e.stopPropagation()}> +
While you were away...
+
+ Killed {monstersKilled} monster{monstersKilled !== 1 ? 's' : ''} +
+ {xpGained > 0 && ( +
+ +{xpGained} XP +
+ )} + {goldGained > 0 && ( +
+ +{goldGained} gold +
+ )} + {levelsGained > 0 && ( +
+ Gained {levelsGained} level{levelsGained !== 1 ? 's' : ''}! +
+ )} +
Tap anywhere to dismiss
+
+
+ + ); +} diff --git a/frontend/src/ui/QuestLog.tsx b/frontend/src/ui/QuestLog.tsx new file mode 100644 index 0000000..94b73af --- /dev/null +++ b/frontend/src/ui/QuestLog.tsx @@ -0,0 +1,330 @@ +import { useState, useCallback, useEffect, type CSSProperties } from 'react'; +import type { HeroQuest } from '../game/types'; + +// ---- Types ---- + +interface QuestLogProps { + quests: HeroQuest[]; + onClaim: (heroQuestId: number) => void; + onAbandon: (heroQuestId: number) => void; + onClose: () => void; +} + +// ---- Quest Type Icons ---- + +function questTypeIcon(type: string): string { + switch (type) { + case 'kill_count': + return '\u2694\uFE0F'; // swords + case 'visit_town': + return '\uD83E\uDDED'; // compass + case 'collect_item': + return '\uD83D\uDC8E'; // gem + default: + return '\uD83D\uDCDC'; // scroll + } +} + +// ---- Styles ---- + +const overlayStyle: CSSProperties = { + position: 'absolute', + inset: 0, + zIndex: 600, + pointerEvents: 'auto', +}; + +const backdropStyle: CSSProperties = { + position: 'absolute', + inset: 0, + backgroundColor: 'rgba(0, 0, 0, 0.4)', +}; + +const panelStyle: CSSProperties = { + position: 'absolute', + bottom: 0, + left: 0, + right: 0, + maxHeight: '40vh', + backgroundColor: 'rgba(15, 15, 25, 0.95)', + borderTop: '2px solid rgba(255, 215, 0, 0.3)', + borderRadius: '16px 16px 0 0', + display: 'flex', + flexDirection: 'column', + animation: 'quest-log-slide-up 0.3s ease-out', + overflow: 'hidden', +}; + +const headerStyle: CSSProperties = { + display: 'flex', + alignItems: 'center', + justifyContent: 'space-between', + padding: '12px 16px 8px', + borderBottom: '1px solid rgba(255, 255, 255, 0.08)', +}; + +const titleStyle: CSSProperties = { + fontSize: 15, + fontWeight: 700, + color: '#ffd700', + textShadow: '0 0 8px rgba(255, 215, 0, 0.3)', +}; + +const closeBtnStyle: CSSProperties = { + background: 'none', + border: 'none', + color: '#888', + fontSize: 20, + cursor: 'pointer', + padding: '4px 8px', + lineHeight: 1, +}; + +const listStyle: CSSProperties = { + overflowY: 'auto', + padding: '8px 12px 16px', + flex: 1, +}; + +const questCardStyle: CSSProperties = { + backgroundColor: 'rgba(255, 255, 255, 0.04)', + border: '1px solid rgba(255, 255, 255, 0.08)', + borderRadius: 10, + padding: '10px 12px', + marginBottom: 8, + cursor: 'pointer', + transition: 'background-color 150ms ease', +}; + +const questHeaderRow: CSSProperties = { + display: 'flex', + alignItems: 'center', + gap: 8, +}; + +const questTitleStyle: CSSProperties = { + fontSize: 13, + fontWeight: 600, + color: '#e8e8e8', + flex: 1, +}; + +const progressTextStyle: CSSProperties = { + fontSize: 11, + fontWeight: 700, + color: '#aaa', + whiteSpace: 'nowrap', +}; + +const progressBarOuter: CSSProperties = { + height: 6, + borderRadius: 3, + backgroundColor: 'rgba(255, 255, 255, 0.08)', + marginTop: 6, + overflow: 'hidden', +}; + +const descriptionStyle: CSSProperties = { + fontSize: 11, + color: '#999', + marginTop: 8, + lineHeight: 1.4, +}; + +const rewardsRow: CSSProperties = { + display: 'flex', + gap: 10, + marginTop: 8, + fontSize: 11, + fontWeight: 600, +}; + +const rewardChip: CSSProperties = { + display: 'inline-flex', + alignItems: 'center', + gap: 3, +}; + +const actionRow: CSSProperties = { + display: 'flex', + gap: 8, + marginTop: 10, +}; + +const claimBtnStyle: CSSProperties = { + flex: 1, + padding: '8px 0', + border: 'none', + borderRadius: 8, + backgroundColor: 'rgba(255, 215, 0, 0.25)', + color: '#ffd700', + fontSize: 13, + fontWeight: 700, + cursor: 'pointer', + textShadow: '0 0 6px rgba(255, 215, 0, 0.4)', + boxShadow: '0 0 12px rgba(255, 215, 0, 0.15)', + animation: 'quest-claim-glow 1.5s ease-in-out infinite', +}; + +const abandonBtnStyle: CSSProperties = { + padding: '8px 14px', + border: '1px solid rgba(255, 80, 80, 0.3)', + borderRadius: 8, + backgroundColor: 'rgba(255, 50, 50, 0.1)', + color: '#cc6666', + fontSize: 11, + fontWeight: 600, + cursor: 'pointer', +}; + +const emptyStyle: CSSProperties = { + textAlign: 'center', + color: '#666', + fontSize: 13, + padding: '24px 0', +}; + +// ---- Component ---- + +export function QuestLog({ quests, onClaim, onAbandon, onClose }: QuestLogProps) { + const [expandedId, setExpandedId] = useState(null); + + const activeQuests = quests.filter((q) => q.status !== 'claimed'); + + const handleCardClick = useCallback((id: number) => { + setExpandedId((prev) => (prev === id ? null : id)); + }, []); + + // Close on Escape + useEffect(() => { + const handleKey = (e: KeyboardEvent) => { + if (e.key === 'Escape') onClose(); + }; + window.addEventListener('keydown', handleKey); + return () => window.removeEventListener('keydown', handleKey); + }, [onClose]); + + return ( + <> + +
+
+
+
+ {'\uD83D\uDCDC'} Quest Log + +
+
+ {activeQuests.length === 0 ? ( +
No active quests. Visit an NPC to accept quests!
+ ) : ( + activeQuests.map((q) => { + const isExpanded = expandedId === q.id; + const isCompleted = q.status === 'completed'; + const pct = q.targetCount > 0 ? Math.min(100, (q.progress / q.targetCount) * 100) : 0; + + return ( +
handleCardClick(q.id)} + > +
+ {questTypeIcon(q.type)} + {q.title} + + {q.progress}/{q.targetCount} + +
+ + {/* Progress bar */} +
+
+
+ + {/* Expanded details */} + {isExpanded && ( + <> +
{q.description}
+
+ {q.npcName} · {q.townName} +
+
+ {q.rewardXp > 0 && ( + + {'\u2728'} {q.rewardXp} XP + + )} + {q.rewardGold > 0 && ( + + {'\uD83D\uDCB0'} {q.rewardGold} + + )} + {q.rewardPotions > 0 && ( + + {'\uD83E\uDDEA'} {q.rewardPotions} + + )} +
+
+ {isCompleted ? ( + + ) : ( + + )} +
+ + )} +
+ ); + }) + )} +
+
+
+ + ); +} diff --git a/frontend/src/ui/WanderingNPCPopup.tsx b/frontend/src/ui/WanderingNPCPopup.tsx new file mode 100644 index 0000000..4236933 --- /dev/null +++ b/frontend/src/ui/WanderingNPCPopup.tsx @@ -0,0 +1,152 @@ +import { useState, type CSSProperties } from 'react'; + +// ---- Types ---- + +interface WanderingNPCPopupProps { + npcName: string; + message: string; + cost: number; + heroGold: number; + onAccept: () => void; + onDecline: () => void; +} + +// ---- Styles ---- + +const overlayStyle: CSSProperties = { + position: 'absolute', + inset: 0, + zIndex: 800, + display: 'flex', + alignItems: 'center', + justifyContent: 'center', + pointerEvents: 'auto', +}; + +const backdropStyle: CSSProperties = { + position: 'absolute', + inset: 0, + backgroundColor: 'rgba(0, 0, 0, 0.55)', +}; + +const cardStyle: CSSProperties = { + position: 'relative', + width: '85%', + maxWidth: 320, + backgroundColor: 'rgba(15, 15, 25, 0.96)', + border: '2px solid rgba(218, 165, 32, 0.4)', + borderRadius: 16, + padding: '20px 18px 16px', + textAlign: 'center', + animation: 'wander-npc-pop 0.3s ease-out', +}; + +const titleStyle: CSSProperties = { + fontSize: 16, + fontWeight: 700, + color: '#daa520', + marginBottom: 8, +}; + +const messageStyle: CSSProperties = { + fontSize: 13, + color: '#ccc', + lineHeight: 1.5, + marginBottom: 16, +}; + +const costStyle: CSSProperties = { + fontSize: 14, + fontWeight: 700, + color: '#ffd700', + marginBottom: 16, +}; + +const btnRow: CSSProperties = { + display: 'flex', + gap: 10, + justifyContent: 'center', +}; + +const btnBase: CSSProperties = { + flex: 1, + padding: '10px 0', + borderRadius: 10, + fontSize: 13, + fontWeight: 700, + border: 'none', + cursor: 'pointer', + transition: 'background-color 150ms ease', +}; + +// ---- Component ---- + +export function WanderingNPCPopup({ + npcName, + message, + cost, + heroGold, + onAccept, + onDecline, +}: WanderingNPCPopupProps) { + const [pending, setPending] = useState(false); + const canAfford = heroGold >= cost; + + const handleAccept = () => { + if (!canAfford || pending) return; + setPending(true); + onAccept(); + }; + + return ( + <> + +
+
+
+
{npcName}
+
{message}
+
+ Give {cost} gold for a mysterious item? +
+ {!canAfford && ( +
+ Not enough gold ({heroGold}/{cost}) +
+ )} +
+ + +
+
+
+ + ); +} diff --git a/frontend/src/ui/buffMeta.ts b/frontend/src/ui/buffMeta.ts new file mode 100644 index 0000000..a78adca --- /dev/null +++ b/frontend/src/ui/buffMeta.ts @@ -0,0 +1,16 @@ +import { BuffType } from '../game/types'; + +/** Icons and colors for buff UI (BuffBar buttons + BuffStatusStrip). */ +export const BUFF_META: Record< + BuffType, + { icon: string; label: string; color: string; desc: string } +> = { + [BuffType.Rush]: { icon: '\u26A1', label: 'Rush', color: '#44aaff', desc: '+50% movement speed' }, + [BuffType.Rage]: { icon: '\u2694\uFE0F', label: 'Rage', color: '#ff4444', desc: '+100% damage' }, + [BuffType.Shield]: { icon: '\uD83D\uDEE1\uFE0F', label: 'Shield', color: '#aaaaff', desc: '-50% incoming damage' }, + [BuffType.Luck]: { icon: '\uD83C\uDF40', label: 'Luck', color: '#44ff44', desc: 'x2.5 loot drops' }, + [BuffType.Resurrection]: { icon: '\uD83D\uDD2E', label: 'Resurrect', color: '#ffaa44', desc: 'Revive at 50% HP' }, + [BuffType.Heal]: { icon: '\u2764\uFE0F', label: 'Heal', color: '#ff6699', desc: '+50% HP instant' }, + [BuffType.PowerPotion]: { icon: '\uD83E\uDDEA', label: 'Power', color: '#dd44ff', desc: '+150% damage' }, + [BuffType.WarCry]: { icon: '\uD83D\uDCE3', label: 'WarCry', color: '#ffcc00', desc: '+100% attack speed' }, +}; diff --git a/frontend/src/vite-env.d.ts b/frontend/src/vite-env.d.ts new file mode 100644 index 0000000..11f02fe --- /dev/null +++ b/frontend/src/vite-env.d.ts @@ -0,0 +1 @@ +/// diff --git a/frontend/tsconfig.json b/frontend/tsconfig.json new file mode 100644 index 0000000..cda9f26 --- /dev/null +++ b/frontend/tsconfig.json @@ -0,0 +1,28 @@ +{ + "compilerOptions": { + "target": "ES2020", + "lib": ["ES2020", "DOM", "DOM.Iterable"], + "module": "ESNext", + "moduleResolution": "bundler", + "jsx": "react-jsx", + "strict": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "noFallthroughCasesInSwitch": true, + "noUncheckedIndexedAccess": true, + "forceConsistentCasingInFileNames": true, + "resolveJsonModule": true, + "isolatedModules": true, + "esModuleInterop": true, + "skipLibCheck": true, + "useDefineForClassFields": true, + "baseUrl": ".", + "paths": { + "@/*": ["src/*"] + }, + "outDir": "dist", + "sourceMap": true + }, + "include": ["src"], + "references": [{ "path": "./tsconfig.node.json" }] +} diff --git a/frontend/tsconfig.node.json b/frontend/tsconfig.node.json new file mode 100644 index 0000000..8108530 --- /dev/null +++ b/frontend/tsconfig.node.json @@ -0,0 +1,14 @@ +{ + "compilerOptions": { + "target": "ES2022", + "lib": ["ES2023"], + "module": "ESNext", + "moduleResolution": "bundler", + "strict": true, + "skipLibCheck": true, + "composite": true, + "isolatedModules": true, + "allowSyntheticDefaultImports": true + }, + "include": ["vite.config.ts"] +} diff --git a/frontend/tsconfig.node.tsbuildinfo b/frontend/tsconfig.node.tsbuildinfo new file mode 100644 index 0000000..faa7aca --- /dev/null +++ b/frontend/tsconfig.node.tsbuildinfo @@ -0,0 +1 @@ +{"fileNames":["./node_modules/typescript/lib/lib.es5.d.ts","./node_modules/typescript/lib/lib.es2015.d.ts","./node_modules/typescript/lib/lib.es2016.d.ts","./node_modules/typescript/lib/lib.es2017.d.ts","./node_modules/typescript/lib/lib.es2018.d.ts","./node_modules/typescript/lib/lib.es2019.d.ts","./node_modules/typescript/lib/lib.es2020.d.ts","./node_modules/typescript/lib/lib.es2021.d.ts","./node_modules/typescript/lib/lib.es2022.d.ts","./node_modules/typescript/lib/lib.es2023.d.ts","./node_modules/typescript/lib/lib.es2015.core.d.ts","./node_modules/typescript/lib/lib.es2015.collection.d.ts","./node_modules/typescript/lib/lib.es2015.generator.d.ts","./node_modules/typescript/lib/lib.es2015.iterable.d.ts","./node_modules/typescript/lib/lib.es2015.promise.d.ts","./node_modules/typescript/lib/lib.es2015.proxy.d.ts","./node_modules/typescript/lib/lib.es2015.reflect.d.ts","./node_modules/typescript/lib/lib.es2015.symbol.d.ts","./node_modules/typescript/lib/lib.es2015.symbol.wellknown.d.ts","./node_modules/typescript/lib/lib.es2016.array.include.d.ts","./node_modules/typescript/lib/lib.es2016.intl.d.ts","./node_modules/typescript/lib/lib.es2017.arraybuffer.d.ts","./node_modules/typescript/lib/lib.es2017.date.d.ts","./node_modules/typescript/lib/lib.es2017.object.d.ts","./node_modules/typescript/lib/lib.es2017.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2017.string.d.ts","./node_modules/typescript/lib/lib.es2017.intl.d.ts","./node_modules/typescript/lib/lib.es2017.typedarrays.d.ts","./node_modules/typescript/lib/lib.es2018.asyncgenerator.d.ts","./node_modules/typescript/lib/lib.es2018.asynciterable.d.ts","./node_modules/typescript/lib/lib.es2018.intl.d.ts","./node_modules/typescript/lib/lib.es2018.promise.d.ts","./node_modules/typescript/lib/lib.es2018.regexp.d.ts","./node_modules/typescript/lib/lib.es2019.array.d.ts","./node_modules/typescript/lib/lib.es2019.object.d.ts","./node_modules/typescript/lib/lib.es2019.string.d.ts","./node_modules/typescript/lib/lib.es2019.symbol.d.ts","./node_modules/typescript/lib/lib.es2019.intl.d.ts","./node_modules/typescript/lib/lib.es2020.bigint.d.ts","./node_modules/typescript/lib/lib.es2020.date.d.ts","./node_modules/typescript/lib/lib.es2020.promise.d.ts","./node_modules/typescript/lib/lib.es2020.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2020.string.d.ts","./node_modules/typescript/lib/lib.es2020.symbol.wellknown.d.ts","./node_modules/typescript/lib/lib.es2020.intl.d.ts","./node_modules/typescript/lib/lib.es2020.number.d.ts","./node_modules/typescript/lib/lib.es2021.promise.d.ts","./node_modules/typescript/lib/lib.es2021.string.d.ts","./node_modules/typescript/lib/lib.es2021.weakref.d.ts","./node_modules/typescript/lib/lib.es2021.intl.d.ts","./node_modules/typescript/lib/lib.es2022.array.d.ts","./node_modules/typescript/lib/lib.es2022.error.d.ts","./node_modules/typescript/lib/lib.es2022.intl.d.ts","./node_modules/typescript/lib/lib.es2022.object.d.ts","./node_modules/typescript/lib/lib.es2022.string.d.ts","./node_modules/typescript/lib/lib.es2022.regexp.d.ts","./node_modules/typescript/lib/lib.es2023.array.d.ts","./node_modules/typescript/lib/lib.es2023.collection.d.ts","./node_modules/typescript/lib/lib.es2023.intl.d.ts","./node_modules/typescript/lib/lib.decorators.d.ts","./node_modules/typescript/lib/lib.decorators.legacy.d.ts","./node_modules/@types/estree/index.d.ts","./node_modules/rollup/dist/rollup.d.ts","./node_modules/rollup/dist/parseast.d.ts","./node_modules/vite/types/hmrpayload.d.ts","./node_modules/vite/types/customevent.d.ts","./node_modules/vite/types/hot.d.ts","./node_modules/vite/dist/node/modulerunnertransport.d-dj_me5sf.d.ts","./node_modules/vite/dist/node/module-runner.d.ts","./node_modules/esbuild/lib/main.d.ts","./node_modules/source-map-js/source-map.d.ts","./node_modules/postcss/lib/previous-map.d.ts","./node_modules/postcss/lib/input.d.ts","./node_modules/postcss/lib/css-syntax-error.d.ts","./node_modules/postcss/lib/declaration.d.ts","./node_modules/postcss/lib/root.d.ts","./node_modules/postcss/lib/warning.d.ts","./node_modules/postcss/lib/lazy-result.d.ts","./node_modules/postcss/lib/no-work-result.d.ts","./node_modules/postcss/lib/processor.d.ts","./node_modules/postcss/lib/result.d.ts","./node_modules/postcss/lib/document.d.ts","./node_modules/postcss/lib/rule.d.ts","./node_modules/postcss/lib/node.d.ts","./node_modules/postcss/lib/comment.d.ts","./node_modules/postcss/lib/container.d.ts","./node_modules/postcss/lib/at-rule.d.ts","./node_modules/postcss/lib/list.d.ts","./node_modules/postcss/lib/postcss.d.ts","./node_modules/postcss/lib/postcss.d.mts","./node_modules/vite/types/internal/lightningcssoptions.d.ts","./node_modules/vite/types/internal/csspreprocessoroptions.d.ts","./node_modules/vite/types/importglob.d.ts","./node_modules/vite/types/metadata.d.ts","./node_modules/vite/dist/node/index.d.ts","./node_modules/@babel/types/lib/index.d.ts","./node_modules/@types/babel__generator/index.d.ts","./node_modules/@babel/parser/typings/babel-parser.d.ts","./node_modules/@types/babel__template/index.d.ts","./node_modules/@types/babel__traverse/index.d.ts","./node_modules/@types/babel__core/index.d.ts","./node_modules/@vitejs/plugin-react/dist/index.d.ts","./vite.config.ts","./node_modules/@types/earcut/index.d.ts","./node_modules/@types/json-schema/index.d.ts","./node_modules/@types/react/global.d.ts","./node_modules/csstype/index.d.ts","./node_modules/@types/react/index.d.ts","./node_modules/@types/react-dom/index.d.ts"],"fileIdsList":[[96],[96,97,98,99,100],[96,98],[108],[106,107],[95,101],[86],[84,86],[75,83,84,85,87,89],[73],[76,81,86,89],[72,89],[76,77,80,81,82,89],[76,77,78,80,81,89],[73,74,75,76,77,81,82,83,85,86,87,89],[89],[71,73,74,75,76,77,78,80,81,82,83,84,85,86,87,88],[71,89],[76,78,79,81,82,89],[80,89],[81,82,86,89],[74,84],[63,94,95],[62,63],[63,64,65,66,68,69,70,90,91,92,93,94,95],[65,66,67,68],[65],[66],[63,95],[95,102]],"fileInfos":[{"version":"e41c290ef7dd7dab3493e6cbe5909e0148edf4a8dad0271be08edec368a0f7b9","affectsGlobalScope":true,"impliedFormat":1},{"version":"45b7ab580deca34ae9729e97c13cfd999df04416a79116c3bfb483804f85ded4","impliedFormat":1},{"version":"3facaf05f0c5fc569c5649dd359892c98a85557e3e0c847964caeb67076f4d75","impliedFormat":1},{"version":"e44bb8bbac7f10ecc786703fe0a6a4b952189f908707980ba8f3c8975a760962","impliedFormat":1},{"version":"5e1c4c362065a6b95ff952c0eab010f04dcd2c3494e813b493ecfd4fcb9fc0d8","impliedFormat":1},{"version":"68d73b4a11549f9c0b7d352d10e91e5dca8faa3322bfb77b661839c42b1ddec7","impliedFormat":1},{"version":"5efce4fc3c29ea84e8928f97adec086e3dc876365e0982cc8479a07954a3efd4","impliedFormat":1},{"version":"feecb1be483ed332fad555aff858affd90a48ab19ba7272ee084704eb7167569","impliedFormat":1},{"version":"ee7bad0c15b58988daa84371e0b89d313b762ab83cb5b31b8a2d1162e8eb41c2","impliedFormat":1},{"version":"27bdc30a0e32783366a5abeda841bc22757c1797de8681bbe81fbc735eeb1c10","impliedFormat":1},{"version":"c57796738e7f83dbc4b8e65132f11a377649c00dd3eee333f672b8f0a6bea671","affectsGlobalScope":true,"impliedFormat":1},{"version":"dc2df20b1bcdc8c2d34af4926e2c3ab15ffe1160a63e58b7e09833f616efff44","affectsGlobalScope":true,"impliedFormat":1},{"version":"515d0b7b9bea2e31ea4ec968e9edd2c39d3eebf4a2d5cbd04e88639819ae3b71","affectsGlobalScope":true,"impliedFormat":1},{"version":"62bb211266ee48b2d0edf0d8d1b191f0c24fc379a82bd4c1692a082c540bc6b1","affectsGlobalScope":true,"impliedFormat":1},{"version":"0dc1e7ceda9b8b9b455c3a2d67b0412feab00bd2f66656cd8850e8831b08b537","affectsGlobalScope":true,"impliedFormat":1},{"version":"ce691fb9e5c64efb9547083e4a34091bcbe5bdb41027e310ebba8f7d96a98671","affectsGlobalScope":true,"impliedFormat":1},{"version":"8d697a2a929a5fcb38b7a65594020fcef05ec1630804a33748829c5ff53640d0","affectsGlobalScope":true,"impliedFormat":1},{"version":"4ff2a353abf8a80ee399af572debb8faab2d33ad38c4b4474cff7f26e7653b8d","affectsGlobalScope":true,"impliedFormat":1},{"version":"936e80ad36a2ee83fc3caf008e7c4c5afe45b3cf3d5c24408f039c1d47bdc1df","affectsGlobalScope":true,"impliedFormat":1},{"version":"d15bea3d62cbbdb9797079416b8ac375ae99162a7fba5de2c6c505446486ac0a","affectsGlobalScope":true,"impliedFormat":1},{"version":"68d18b664c9d32a7336a70235958b8997ebc1c3b8505f4f1ae2b7e7753b87618","affectsGlobalScope":true,"impliedFormat":1},{"version":"eb3d66c8327153d8fa7dd03f9c58d351107fe824c79e9b56b462935176cdf12a","affectsGlobalScope":true,"impliedFormat":1},{"version":"38f0219c9e23c915ef9790ab1d680440d95419ad264816fa15009a8851e79119","affectsGlobalScope":true,"impliedFormat":1},{"version":"69ab18c3b76cd9b1be3d188eaf8bba06112ebbe2f47f6c322b5105a6fbc45a2e","affectsGlobalScope":true,"impliedFormat":1},{"version":"fef8cfad2e2dc5f5b3d97a6f4f2e92848eb1b88e897bb7318cef0e2820bceaab","affectsGlobalScope":true,"impliedFormat":1},{"version":"2f11ff796926e0832f9ae148008138ad583bd181899ab7dd768a2666700b1893","affectsGlobalScope":true,"impliedFormat":1},{"version":"4de680d5bb41c17f7f68e0419412ca23c98d5749dcaaea1896172f06435891fc","affectsGlobalScope":true,"impliedFormat":1},{"version":"954296b30da6d508a104a3a0b5d96b76495c709785c1d11610908e63481ee667","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac9538681b19688c8eae65811b329d3744af679e0bdfa5d842d0e32524c73e1c","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a969edff4bd52585473d24995c5ef223f6652d6ef46193309b3921d65dd4376","affectsGlobalScope":true,"impliedFormat":1},{"version":"9e9fbd7030c440b33d021da145d3232984c8bb7916f277e8ffd3dc2e3eae2bdb","affectsGlobalScope":true,"impliedFormat":1},{"version":"811ec78f7fefcabbda4bfa93b3eb67d9ae166ef95f9bff989d964061cbf81a0c","affectsGlobalScope":true,"impliedFormat":1},{"version":"717937616a17072082152a2ef351cb51f98802fb4b2fdabd32399843875974ca","affectsGlobalScope":true,"impliedFormat":1},{"version":"d7e7d9b7b50e5f22c915b525acc5a49a7a6584cf8f62d0569e557c5cfc4b2ac2","affectsGlobalScope":true,"impliedFormat":1},{"version":"71c37f4c9543f31dfced6c7840e068c5a5aacb7b89111a4364b1d5276b852557","affectsGlobalScope":true,"impliedFormat":1},{"version":"576711e016cf4f1804676043e6a0a5414252560eb57de9faceee34d79798c850","affectsGlobalScope":true,"impliedFormat":1},{"version":"89c1b1281ba7b8a96efc676b11b264de7a8374c5ea1e6617f11880a13fc56dc6","affectsGlobalScope":true,"impliedFormat":1},{"version":"74f7fa2d027d5b33eb0471c8e82a6c87216223181ec31247c357a3e8e2fddc5b","affectsGlobalScope":true,"impliedFormat":1},{"version":"f1e2a172204962276504466a6393426d2ca9c54894b1ad0a6c9dad867a65f876","affectsGlobalScope":true,"impliedFormat":1},{"version":"063600664504610fe3e99b717a1223f8b1900087fab0b4cad1496a114744f8df","affectsGlobalScope":true,"impliedFormat":1},{"version":"934019d7e3c81950f9a8426d093458b65d5aff2c7c1511233c0fd5b941e608ab","affectsGlobalScope":true,"impliedFormat":1},{"version":"52ada8e0b6e0482b728070b7639ee42e83a9b1c22d205992756fe020fd9f4a47","affectsGlobalScope":true,"impliedFormat":1},{"version":"3bdefe1bfd4d6dee0e26f928f93ccc128f1b64d5d501ff4a8cf3c6371200e5e6","affectsGlobalScope":true,"impliedFormat":1},{"version":"59fb2c069260b4ba00b5643b907ef5d5341b167e7d1dbf58dfd895658bda2867","affectsGlobalScope":true,"impliedFormat":1},{"version":"639e512c0dfc3fad96a84caad71b8834d66329a1f28dc95e3946c9b58176c73a","affectsGlobalScope":true,"impliedFormat":1},{"version":"368af93f74c9c932edd84c58883e736c9e3d53cec1fe24c0b0ff451f529ceab1","affectsGlobalScope":true,"impliedFormat":1},{"version":"af3dd424cf267428f30ccfc376f47a2c0114546b55c44d8c0f1d57d841e28d74","affectsGlobalScope":true,"impliedFormat":1},{"version":"995c005ab91a498455ea8dfb63aa9f83fa2ea793c3d8aa344be4a1678d06d399","affectsGlobalScope":true,"impliedFormat":1},{"version":"959d36cddf5e7d572a65045b876f2956c973a586da58e5d26cde519184fd9b8a","affectsGlobalScope":true,"impliedFormat":1},{"version":"965f36eae237dd74e6cca203a43e9ca801ce38824ead814728a2807b1910117d","affectsGlobalScope":true,"impliedFormat":1},{"version":"3925a6c820dcb1a06506c90b1577db1fdbf7705d65b62b99dce4be75c637e26b","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a3d63ef2b853447ec4f749d3f368ce642264246e02911fcb1590d8c161b8005","affectsGlobalScope":true,"impliedFormat":1},{"version":"b5ce7a470bc3628408429040c4e3a53a27755022a32fd05e2cb694e7015386c7","affectsGlobalScope":true,"impliedFormat":1},{"version":"8444af78980e3b20b49324f4a16ba35024fef3ee069a0eb67616ea6ca821c47a","affectsGlobalScope":true,"impliedFormat":1},{"version":"3287d9d085fbd618c3971944b65b4be57859f5415f495b33a6adc994edd2f004","affectsGlobalScope":true,"impliedFormat":1},{"version":"b4b67b1a91182421f5df999988c690f14d813b9850b40acd06ed44691f6727ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"bab26767638ab3557de12c900f0b91f710c7dc40ee9793d5a27d32c04f0bf646","affectsGlobalScope":true,"impliedFormat":1},{"version":"436aaf437562f276ec2ddbee2f2cdedac7664c1e4c1d2c36839ddd582eeb3d0a","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e3c06ea092138bf9fa5e874a1fdbc9d54805d074bee1de31b99a11e2fec239d","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e7f8264d0fb4c5339605a15daadb037bf238c10b654bb3eee14208f860a32ea","affectsGlobalScope":true,"impliedFormat":1},{"version":"782dec38049b92d4e85c1585fbea5474a219c6984a35b004963b00beb1aab538","affectsGlobalScope":true,"impliedFormat":1},{"version":"151ff381ef9ff8da2da9b9663ebf657eac35c4c9a19183420c05728f31a6761d","impliedFormat":1},{"version":"ee70b8037ecdf0de6c04f35277f253663a536d7e38f1539d270e4e916d225a3f","affectsGlobalScope":true,"impliedFormat":1},{"version":"a660aa95476042d3fdcc1343cf6bb8fdf24772d31712b1db321c5a4dcc325434","impliedFormat":1},{"version":"a7ca8df4f2931bef2aa4118078584d84a0b16539598eaadf7dce9104dfaa381c","impliedFormat":1},{"version":"11443a1dcfaaa404c68d53368b5b818712b95dd19f188cab1669c39bee8b84b3","impliedFormat":1},{"version":"36977c14a7f7bfc8c0426ae4343875689949fb699f3f84ecbe5b300ebf9a2c55","impliedFormat":1},{"version":"035d0934d304483f07148427a5bd5b98ac265dae914a6b49749fe23fbd893ec7","impliedFormat":99},{"version":"e2ed5b81cbed3a511b21a18ab2539e79ac1f4bc1d1d28f8d35d8104caa3b429f","impliedFormat":99},{"version":"161c8e0690c46021506e32fda85956d785b70f309ae97011fd27374c065cac9b","affectsGlobalScope":true,"impliedFormat":1},{"version":"402e5c534fb2b85fa771170595db3ac0dd532112c8fa44fc23f233bc6967488b","impliedFormat":1},{"version":"7965dc3c7648e2a7a586d11781cabb43d4859920716bc2fdc523da912b06570d","impliedFormat":1},{"version":"90c2bd9a3e72fe08b8fa5982e78cb8dc855a1157b26e11e37a793283c52bf64b","impliedFormat":1},{"version":"a8122fe390a2a987079e06c573b1471296114677923c1c094c24a53ddd7344a2","impliedFormat":1},{"version":"70c2cb19c0c42061a39351156653aa0cf5ba1ecdc8a07424dd38e3a1f1e3c7f4","impliedFormat":1},{"version":"a8fb10fd8c7bc7d9b8f546d4d186d1027f8a9002a639bec689b5000dab68e35c","impliedFormat":1},{"version":"c9b467ea59b86bd27714a879b9ad43c16f186012a26d0f7110b1322025ceaa83","impliedFormat":1},{"version":"57ea19c2e6ba094d8087c721bac30ff1c681081dbd8b167ac068590ef633e7a5","impliedFormat":1},{"version":"cba81ec9ae7bc31a4dc56f33c054131e037649d6b9a2cfa245124c67e23e4721","impliedFormat":1},{"version":"ad193f61ba708e01218496f093c23626aa3808c296844a99189be7108a9c8343","impliedFormat":1},{"version":"a0544b3c8b70b2f319a99ea380b55ab5394ede9188cdee452a5d0ce264f258b2","impliedFormat":1},{"version":"8c654c17c334c7c168c1c36e5336896dc2c892de940886c1639bebd9fc7b9be4","impliedFormat":1},{"version":"6a4da742485d5c2eb6bcb322ae96993999ffecbd5660b0219a5f5678d8225bb0","impliedFormat":1},{"version":"c65ca21d7002bdb431f9ab3c7a6e765a489aa5196e7e0ef00aed55b1294df599","impliedFormat":1},{"version":"c8fc655c2c4bafc155ceee01c84ab3d6c03192ced5d3f2de82e20f3d1bd7f9fa","impliedFormat":1},{"version":"be5a7ff3b47f7e553565e9483bdcadb0ca2040ac9e5ec7b81c7e115a81059882","impliedFormat":1},{"version":"1a93f36ecdb60a95e3a3621b561763e2952da81962fae217ab5441ac1d77ffc5","impliedFormat":1},{"version":"2a771d907aebf9391ac1f50e4ad37952943515eeea0dcc7e78aa08f508294668","impliedFormat":1},{"version":"0146fd6262c3fd3da51cb0254bb6b9a4e42931eb2f56329edd4c199cb9aaf804","impliedFormat":1},{"version":"183f480885db5caa5a8acb833c2be04f98056bdcc5fb29e969ff86e07efe57ab","impliedFormat":99},{"version":"4ec16d7a4e366c06a4573d299e15fe6207fc080f41beac5da06f4af33ea9761e","impliedFormat":1},{"version":"7870becb94cbc11d2d01b77c4422589adcba4d8e59f726246d40cd0d129784d8","affectsGlobalScope":true,"impliedFormat":1},{"version":"7f698624bbbb060ece7c0e51b7236520ebada74b747d7523c7df376453ed6fea","impliedFormat":1},{"version":"f70b8328a15ca1d10b1436b691e134a49bc30dcf3183a69bfaa7ba77e1b78ecd","impliedFormat":1},{"version":"683b035f752e318d02e303894e767a1ac16ac4493baa2b593195d7976e6b7310","impliedFormat":99},{"version":"556ccd493ec36c7d7cb130d51be66e147b91cc1415be383d71da0f1e49f742a9","impliedFormat":1},{"version":"b6d03c9cfe2cf0ba4c673c209fcd7c46c815b2619fd2aad59fc4229aaef2ed43","impliedFormat":1},{"version":"95aba78013d782537cc5e23868e736bec5d377b918990e28ed56110e3ae8b958","impliedFormat":1},{"version":"670a76db379b27c8ff42f1ba927828a22862e2ab0b0908e38b671f0e912cc5ed","impliedFormat":1},{"version":"13b77ab19ef7aadd86a1e54f2f08ea23a6d74e102909e3c00d31f231ed040f62","impliedFormat":1},{"version":"069bebfee29864e3955378107e243508b163e77ab10de6a5ee03ae06939f0bb9","impliedFormat":1},{"version":"26e0ffceb2198feb1ef460d5d14111c69ad07d44c5a67fd4bfeb74c969aa9afb","impliedFormat":99},"5b320dfd14eb5471da88a7f6a60514b1738fc6a1a62e5b4fde4c3d0c42a38ab7",{"version":"c754e6c968fc1d647c59b974bdbaf0d786ae5794bade2c59996da1d312e5ace5","impliedFormat":99},{"version":"f3d8c757e148ad968f0d98697987db363070abada5f503da3c06aefd9d4248c1","impliedFormat":1},{"version":"7e29f41b158de217f94cb9676bf9cbd0cd9b5a46e1985141ed36e075c52bf6ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac51dd7d31333793807a6abaa5ae168512b6131bd41d9c5b98477fc3b7800f9f","impliedFormat":1},{"version":"dc0a7f107690ee5cd8afc8dbf05c4df78085471ce16bdd9881642ec738bc81fe","impliedFormat":1},{"version":"be1cc4d94ea60cbe567bc29ed479d42587bf1e6cba490f123d329976b0fe4ee5","impliedFormat":1}],"root":[103],"options":{"allowSyntheticDefaultImports":true,"composite":true,"module":99,"skipLibCheck":true,"strict":true,"target":9},"referencedMap":[[98,1],[101,2],[97,1],[99,3],[100,1],[109,4],[108,5],[102,6],[87,7],[85,8],[86,9],[74,10],[75,8],[82,11],[73,12],[78,13],[79,14],[84,15],[90,16],[89,17],[72,18],[80,19],[81,20],[76,21],[83,7],[77,22],[64,23],[63,24],[95,25],[69,26],[68,27],[66,27],[67,28],[94,29],[103,30]],"affectedFilesPendingEmit":[[103,17]],"emitSignatures":[103],"version":"5.7.3"} \ No newline at end of file diff --git a/frontend/vite.config.ts b/frontend/vite.config.ts new file mode 100644 index 0000000..79c77d3 --- /dev/null +++ b/frontend/vite.config.ts @@ -0,0 +1,38 @@ +import { defineConfig } from 'vite'; +import react from '@vitejs/plugin-react'; + +export default defineConfig({ + plugins: [react()], + resolve: { + alias: { + '@': '/src', + }, + }, + server: { + host: '0.0.0.0', + port: 5173, + strictPort: true, + proxy: { + '/api': { + target: 'http://localhost:8080', + changeOrigin: true, + }, + '/ws': { + target: 'ws://localhost:8080', + ws: true, + }, + }, + }, + build: { + target: 'es2020', + sourcemap: true, + rollupOptions: { + output: { + manualChunks: { + pixi: ['pixi.js'], + react: ['react', 'react-dom'], + }, + }, + }, + }, +}); diff --git a/scripts/admin-tool.ps1 b/scripts/admin-tool.ps1 new file mode 100644 index 0000000..475d104 --- /dev/null +++ b/scripts/admin-tool.ps1 @@ -0,0 +1,150 @@ +param( + [Parameter(Mandatory = $true, Position = 0)] + [ValidateSet( + "info", + "heroes", + "hero", + "set-level", + "set-gold", + "set-hp", + "revive", + "reset", + 'reset-buffs', + "delete", + "engine-status", + "engine-combats", + "ws-connections", + "add-potions" + )] + [string]$Command, + + [long]$HeroId, + [int]$Level, + [long]$Gold, + [int]$HP, + [int]$Limit = 20, + [int]$Offset = 0, + [int]$N, + [string]$BaseUrl = $env:ADMIN_BASE_URL, + [string]$Username = $env:ADMIN_BASIC_AUTH_USERNAME, + [string]$Password = $env:ADMIN_BASIC_AUTH_PASSWORD +) + +Set-StrictMode -Version Latest +$ErrorActionPreference = "Stop" + +if ([string]::IsNullOrWhiteSpace($BaseUrl)) { + $BaseUrl = "http://localhost:8080" +} + +if ([string]::IsNullOrWhiteSpace($Username) -or [string]::IsNullOrWhiteSpace($Password)) { + throw "Missing admin credentials. Set ADMIN_BASIC_AUTH_USERNAME and ADMIN_BASIC_AUTH_PASSWORD, or pass -Username and -Password." +} + +function Require-Value { + param( + [string]$Name, + [object]$Value + ) + + if ($null -eq $Value -or ($Value -is [string] -and [string]::IsNullOrWhiteSpace($Value))) { + throw "Parameter -$Name is required for '$Command'." + } +} + +function Invoke-AdminRequest { + param( + [Parameter(Mandatory = $true)][string]$Method, + [Parameter(Mandatory = $true)][string]$Path, + [object]$Body = $null + ) + + $uri = "{0}{1}" -f $BaseUrl.TrimEnd("/"), $Path + $pair = "{0}:{1}" -f $Username, $Password + $encoded = [Convert]::ToBase64String([Text.Encoding]::ASCII.GetBytes($pair)) + $headers = @{ + Authorization = "Basic $encoded" + Accept = "application/json" + } + + $params = @{ + Method = $Method + Uri = $uri + Headers = $headers + ContentType = "application/json" + } + + if ($null -ne $Body) { + $params.Body = ($Body | ConvertTo-Json -Depth 8 -Compress) + } + + Invoke-RestMethod @params +} + +switch ($Command) { + "info" { + $result = Invoke-AdminRequest -Method "GET" -Path "/admin/info" + } + "heroes" { + $result = Invoke-AdminRequest -Method "GET" -Path "/admin/heroes?limit=$Limit&offset=$Offset" + } + "hero" { + Require-Value -Name "HeroId" -Value $HeroId + $result = Invoke-AdminRequest -Method "GET" -Path "/admin/heroes/$HeroId" + } + "hero-potions" { + Require-Value -Name "HeroId" -Value $HeroId + $result = Invoke-AdminRequest -Method "GET" -Path "/admin/heroes/$HeroId/potions" + } + "set-level" { + Require-Value -Name "HeroId" -Value $HeroId + Require-Value -Name "Level" -Value $Level + $result = Invoke-AdminRequest -Method "POST" -Path "/admin/heroes/$HeroId/set-level" -Body @{ level = $Level } + } + "set-gold" { + Require-Value -Name "HeroId" -Value $HeroId + Require-Value -Name "Gold" -Value $Gold + $result = Invoke-AdminRequest -Method "POST" -Path "/admin/heroes/$HeroId/set-gold" -Body @{ gold = $Gold } + } + "set-hp" { + Require-Value -Name "HeroId" -Value $HeroId + Require-Value -Name "HP" -Value $HP + $result = Invoke-AdminRequest -Method "POST" -Path "/admin/heroes/$HeroId/set-hp" -Body @{ hp = $HP } + } + "revive" { + Require-Value -Name "HeroId" -Value $HeroId + $result = Invoke-AdminRequest -Method "POST" -Path "/admin/heroes/$HeroId/revive" -Body @{} + } + "reset" { + Require-Value -Name "HeroId" -Value $HeroId + $result = Invoke-AdminRequest -Method "POST" -Path "/admin/heroes/$HeroId/reset" -Body @{} + } + "reset-buffs" { + Require-Value -Name "HeroId" -Value $HeroId + $result = Invoke-AdminRequest -Method "POST" -Path "/admin/heroes/$HeroId/reset-buff-charges" -Body @{} + } + + "add-potions" { + Require-Value -Name "HeroId" -Value $HeroId + Require-Value -Name "N" -Value $N + $result = Invoke-AdminRequest -Method "POST" -Path "/admin/heroes/$HeroId/add-potions" -Body @{ potions = $N} + } + "delete" { + Require-Value -Name "HeroId" -Value $HeroId + $result = Invoke-AdminRequest -Method "DELETE" -Path "/admin/heroes/$HeroId" + } + "engine-status" { + $result = Invoke-AdminRequest -Method "GET" -Path "/admin/engine/status" + } + "engine-combats" { + $result = Invoke-AdminRequest -Method "GET" -Path "/admin/engine/combats" + } + "ws-connections" { + $result = Invoke-AdminRequest -Method "GET" -Path "/admin/ws/connections" + } + default { + throw "Unsupported command: $Command" + } +} + +$result | ConvertTo-Json -Depth 20 diff --git a/scripts/migrate.ps1 b/scripts/migrate.ps1 new file mode 100644 index 0000000..c1c2f45 --- /dev/null +++ b/scripts/migrate.ps1 @@ -0,0 +1,33 @@ +# Apply SQL migrations to PostgreSQL (Docker Compose service "postgres"). +# See scripts/migrate.sh for behavior (skips 000001_* unless MIGRATE_INCLUDE_BOOTSTRAP=1 or -Bootstrap). + +param([switch]$Bootstrap) + +$ErrorActionPreference = "Stop" +$Root = Split-Path -Parent $PSScriptRoot +$MigrationsDir = Join-Path $Root "backend/migrations" +$ComposeFile = if ($env:COMPOSE_FILE) { $env:COMPOSE_FILE } else { Join-Path $Root "docker-compose.yml" } + +$DbUser = if ($env:DB_USER) { $env:DB_USER } else { "autohero" } +$DbName = if ($env:DB_NAME) { $env:DB_NAME } else { "autohero" } +$includeBootstrap = $Bootstrap -or ($env:MIGRATE_INCLUDE_BOOTSTRAP -eq "1") + +Set-Location $Root + +docker compose -f $ComposeFile exec -T postgres pg_isready -U $DbUser -d $DbName 2>$null | Out-Null +if ($LASTEXITCODE -ne 0) { + Write-Error "postgres is not ready or container is not running. Start: docker compose up -d postgres" +} + +Get-ChildItem -Path $MigrationsDir -Filter "*.sql" | Sort-Object Name | ForEach-Object { + $name = $_.Name + if ($name -match '^000001_' -and -not $includeBootstrap) { + Write-Host "Skipping $name (set `$env:MIGRATE_INCLUDE_BOOTSTRAP='1' to apply bootstrap on an empty DB)" + return + } + Write-Host "Applying $name..." + Get-Content -LiteralPath $_.FullName -Raw | docker compose -f $ComposeFile exec -T postgres ` + psql -v ON_ERROR_STOP=1 -U $DbUser -d $DbName +} + +Write-Host "Done." diff --git a/scripts/migrate.sh b/scripts/migrate.sh new file mode 100644 index 0000000..6dfc9e7 --- /dev/null +++ b/scripts/migrate.sh @@ -0,0 +1,58 @@ +#!/usr/bin/env sh +# Apply SQL migrations to PostgreSQL (Docker Compose service "postgres" by default). +# +# By default skips 000001_* (bootstrap + seeds): Docker initdb runs it on first volume +# create; re-applying breaks on duplicate INSERTs. Set MIGRATE_INCLUDE_BOOTSTRAP=1 to +# include it (empty DB, no initdb hook). +# +# Usage: +# ./scripts/migrate.sh +# DB_USER=myuser DB_NAME=mydb ./scripts/migrate.sh +# MIGRATE_INCLUDE_BOOTSTRAP=1 ./scripts/migrate.sh + +set -eu + +ROOT_DIR="$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)" +MIGRATIONS_DIR="${ROOT_DIR}/backend/migrations" + +DB_USER="${DB_USER:-autohero}" +DB_NAME="${DB_NAME:-autohero}" +COMPOSE_FILE="${COMPOSE_FILE:-${ROOT_DIR}/docker-compose.yml}" + +cd "${ROOT_DIR}" + +if ! docker compose -f "${COMPOSE_FILE}" exec -T postgres pg_isready -U "${DB_USER}" -d "${DB_NAME}" >/dev/null 2>&1; then + echo "migrate.sh: postgres is not ready or container is not running. Start: docker compose up -d postgres" >&2 + exit 1 +fi + +apply_file() { + f="$1" + name="$(basename "$f")" + echo "Applying ${name}..." + docker compose -f "${COMPOSE_FILE}" exec -T postgres \ + psql -v ON_ERROR_STOP=1 -U "${DB_USER}" -d "${DB_NAME}" < "$f" +} + +# Sorted list (000001, 000002, ...); skip 000001 unless MIGRATE_INCLUDE_BOOTSTRAP=1 +found=0 +for f in $(find "${MIGRATIONS_DIR}" -maxdepth 1 -name '*.sql' | sort); do + found=1 + base="$(basename "$f")" + case "${base}" in + 000001_*.sql) + if [ "${MIGRATE_INCLUDE_BOOTSTRAP:-0}" != "1" ]; then + echo "Skipping ${base} (set MIGRATE_INCLUDE_BOOTSTRAP=1 to apply bootstrap on an empty DB)" + continue + fi + ;; + esac + apply_file "$f" +done + +if [ "${found}" -eq 0 ]; then + echo "migrate.sh: no .sql files in ${MIGRATIONS_DIR}" >&2 + exit 1 +fi + +echo "Done."