initial
commit
d4b99a0f3c
@ -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
|
||||
@ -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.
|
||||
@ -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.
|
||||
@ -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.
|
||||
@ -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.
|
||||
@ -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.
|
||||
@ -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).
|
||||
@ -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
|
||||
@ -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.
|
||||
@ -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.
|
||||
@ -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<string, EquipmentItem>` 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.
|
||||
@ -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
|
||||
@ -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
|
||||
@ -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.
|
||||
@ -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.
|
||||
@ -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.
|
||||
@ -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.
|
||||
@ -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.
|
||||
@ -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.
|
||||
@ -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.
|
||||
@ -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`.
|
||||
@ -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.
|
||||
@ -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.
|
||||
@ -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.
|
||||
@ -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 \"^$\")"
|
||||
]
|
||||
}
|
||||
}
|
||||
@ -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"
|
||||
@ -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
|
||||
@ -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"
|
||||
@ -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
|
||||
@ -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
|
||||
@ -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?"
|
||||
@ -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)
|
||||
@ -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.
|
||||
@ -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.<slug>` (e.g. `enemy.wolf_forest`, `enemy.demon_fire`)
|
||||
- Monster models: `monster.<class>.<slug>.v1` (e.g. `monster.base.wolf_forest.v1`, `monster.elite.demon_fire.v1`)
|
||||
- Map objects: `obj.<category>.<variant>.v1` (e.g. `obj.tree.pine_tall.v1`, `obj.road.dirt_curve.v1`)
|
||||
- Equipment slots: `gear.slot.<slug>` (e.g. `gear.slot.head`, `gear.slot.cloak`, `gear.slot.finger`)
|
||||
- Equipment forms (per-slot garment/weapon archetypes): `gear.form.<slotKey>.<formSlug>` (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.<slug>.v1` (e.g. `gear.ammo.iron_bodkin.v1`) — table in §0d; scaling formulas in `docs/specification.md` §6.4
|
||||
- Neutral NPCs: `npc.<role>.<slug>.v1` (e.g. `npc.traveler.worn_merchant.v1`)
|
||||
- World/social events: `event.<kind>.<slug>.v1` (e.g. `event.duel.offer.v1`, `event.quest.alms.v1`)
|
||||
- Sound cues: `sfx.<domain>.<intent>.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.
|
||||
@ -0,0 +1,10 @@
|
||||
.git
|
||||
.idea
|
||||
.vscode
|
||||
.claude
|
||||
*.md
|
||||
!README.md
|
||||
.env
|
||||
.env.*
|
||||
docker-compose*.yml
|
||||
Makefile
|
||||
@ -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
|
||||
@ -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
|
||||
@ -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.
|
||||
@ -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
|
||||
@ -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"]
|
||||
@ -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")
|
||||
}
|
||||
@ -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.
|
||||
@ -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
|
||||
)
|
||||
@ -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=
|
||||
@ -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
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
@ -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")
|
||||
}
|
||||
}
|
||||
@ -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,
|
||||
}
|
||||
}
|
||||
@ -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)
|
||||
}
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
}
|
||||
@ -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]
|
||||
}
|
||||
@ -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)
|
||||
}
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
@ -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)
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
@ -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)
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
@ -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")
|
||||
}
|
||||
}
|
||||
@ -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)
|
||||
}
|
||||
@ -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")
|
||||
}
|
||||
}
|
||||
@ -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,
|
||||
})
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -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")
|
||||
}
|
||||
}
|
||||
@ -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",
|
||||
})
|
||||
}
|
||||
@ -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)
|
||||
}
|
||||
@ -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.",
|
||||
})
|
||||
}
|
||||
@ -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",
|
||||
})
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
@ -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")
|
||||
}
|
||||
}
|
||||
@ -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"`
|
||||
}
|
||||
@ -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"`
|
||||
}
|
||||
@ -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},
|
||||
},
|
||||
}
|
||||
@ -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,
|
||||
}
|
||||
@ -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"},
|
||||
},
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
@ -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"`
|
||||
}
|
||||
@ -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"`
|
||||
}
|
||||
@ -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"`
|
||||
}
|
||||
@ -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)
|
||||
})
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
@ -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
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue