immortal
/
autohero
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Huge refactor, i18n, payments, stats, inventory, logic

Browse Source
master
Denis Ranneft 2 hours ago
parent 1571936d46
commit e8de1d62c1
37 changed files with 2354 additions and 835 deletions
Show Stats Download Patch File Download Diff File

21
backend/cmd/server/main.go
Unescape Escape View File

@ -79,6 +79,15 @@ func main() {
engine.SetSender(hub) // Hub implements game.MessageSender
engine.SetRoadGraph(roadGraph)
engine.SetHeroStore(heroStore)
engine.SetAdventureLog(func(heroID int64, msg string) {
logCtx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
if err := logStore.Add(logCtx, heroID, msg); err != nil {
logger.Warn("failed to write adventure log", "hero_id", heroID, "error", err)
return
}
hub.SendToHero(heroID, "adventure_log_line", model.AdventureLogLinePayload{Message: msg})
})
// Hub callbacks: on connect, load hero and register movement; on disconnect, persist.
hub.OnConnect = func(heroID int64) {
@ -100,6 +109,13 @@ func main() {
case <-ctx.Done():
return
case msg := <-hub.Incoming:
if engine.IsTimePaused() {
hub.SendToHero(msg.HeroID, "error", model.ErrorPayload{
Code: "time_paused",
Message: "server time is paused",
})
continue
}
engine.IncomingCh() <- game.IncomingMessage{
HeroID: msg.HeroID,
Type: msg.Type,
@ -132,7 +148,9 @@ func main() {
// Record server start time for catch-up gap calculation.
serverStartedAt := time.Now()
offlineSim := game.NewOfflineSimulator(heroStore, logStore, roadGraph, logger)
offlineSim := game.NewOfflineSimulator(heroStore, logStore, roadGraph, logger, func() bool {
return engine.IsTimePaused()
})
go func() {
if err := offlineSim.Run(ctx); err != nil && err != context.Canceled {
logger.Error("offline simulator error", "error", err)
@ -145,6 +163,7 @@ func main() {
Hub: hub,
PgPool: pgPool,
BotToken: cfg.BotToken,
PaymentProviderToken: cfg.PaymentProviderToken,
AdminBasicAuthUsername: cfg.Admin.BasicAuthUsername,
AdminBasicAuthPassword: cfg.Admin.BasicAuthPassword,
AdminBasicAuthRealm: cfg.Admin.BasicAuthRealm,

18
backend/internal/config/config.go
Unescape Escape View File

@ -6,12 +6,13 @@ import (
)
type Config struct {
ServerPort string
BotToken string
DB DBConfig
Redis RedisConfig
Game GameConfig
Admin AdminConfig
ServerPort string
BotToken string
PaymentProviderToken string
DB DBConfig
Redis RedisConfig
Game GameConfig
Admin AdminConfig
}
type DBConfig struct {
@ -42,8 +43,9 @@ type AdminConfig struct {
func Load() *Config {
return &Config{
ServerPort: envOrDefault("SERVER_PORT", "8080"),
BotToken: os.Getenv("BOT_TOKEN"),
ServerPort: envOrDefault("SERVER_PORT", "8080"),
BotToken: os.Getenv("BOT_TOKEN"),
PaymentProviderToken: os.Getenv("PAYMENT_PROVIDER_TOKEN"),
DB: DBConfig{
Host: envOrDefault("DB_HOST", "localhost"),
Port: envOrDefault("DB_PORT", "5432"),

367
backend/internal/game/engine.go
Unescape Escape View File

@ -31,6 +31,7 @@ type EngineStatus struct {
ActiveCombats int `json:"activeCombats"`
ActiveMovements int `json:"activeMovements"`
UptimeMs int64 `json:"uptimeMs"`
TimePaused bool `json:"timePaused"`
}
// CombatInfo is a read-only snapshot of a single active combat.
@ -64,8 +65,16 @@ type Engine struct {
eventCh chan model.CombatEvent
logger *slog.Logger
onEnemyDeath EnemyDeathCallback
adventureLog AdventureLogWriter
startedAt time.Time
running bool
// timePaused: when true, combat/movement/sync ticks and WS game commands are no-ops.
timePaused bool
// pauseStartedAt is wall clock when global pause began (zero when running).
pauseStartedAt time.Time
// npcAlmsHandler runs when the client accepts a wandering merchant offer (WS).
npcAlmsHandler func(context.Context, int64) error
}
const minAttackInterval = 250 * time.Millisecond
@ -93,6 +102,98 @@ func (e *Engine) GetMovements(heroId int64) *HeroMovement {
return e.movements[heroId]
}
// RoadGraph returns the loaded world graph (for admin tools), or nil.
func (e *Engine) RoadGraph() *RoadGraph {
e.mu.RLock()
defer e.mu.RUnlock()
return e.roadGraph
}
// SetTimePaused freezes all engine simulation ticks and client command handling.
// On resume, movement/combat timers are shifted so wall time spent paused does not advance the sim
// (no invisible travel or burst combat).
func (e *Engine) SetTimePaused(paused bool) {
e.mu.Lock()
defer e.mu.Unlock()
if paused {
if !e.timePaused {
e.pauseStartedAt = time.Now()
e.timePaused = true
if e.logger != nil {
e.logger.Info("game time paused")
}
}
return
}
if !e.timePaused {
return
}
now := time.Now()
var pauseDur time.Duration
if !e.pauseStartedAt.IsZero() {
pauseDur = now.Sub(e.pauseStartedAt)
}
e.timePaused = false
e.pauseStartedAt = time.Time{}
if pauseDur > 0 {
for _, hm := range e.movements {
hm.ShiftGameDeadlines(pauseDur, now)
if hm.Hero != nil {
model.ShiftHeroEffectDeadlines(hm.Hero, pauseDur)
}
}
e.resyncCombatAfterPauseLocked(now, pauseDur)
if e.logger != nil {
e.logger.Info("game time resumed", "paused_wall_ms", pauseDur.Milliseconds())
}
}
}
// resyncCombatAfterPauseLocked shifts combat scheduling by pauseDur and rebuilds the attack heap.
// Caller must hold e.mu (write lock).
func (e *Engine) resyncCombatAfterPauseLocked(now time.Time, pauseDur time.Duration) {
if len(e.combats) == 0 {
return
}
for _, cs := range e.combats {
cs.LastTickAt = now
cs.StartedAt = cs.StartedAt.Add(pauseDur)
hna := cs.HeroNextAttack.Add(pauseDur)
ena := cs.EnemyNextAttack.Add(pauseDur)
if cs.Hero != nil {
if hna.Before(now) {
hna = now.Add(attackInterval(cs.Hero.EffectiveSpeed()))
}
} else if hna.Before(now) {
hna = now.Add(minAttackInterval * combatPaceMultiplier)
}
if ena.Before(now) {
ena = now.Add(attackInterval(cs.Enemy.Speed))
}
cs.HeroNextAttack = hna
cs.EnemyNextAttack = ena
}
e.queue = make(model.AttackQueue, 0)
for heroID, cs := range e.combats {
heap.Push(&e.queue, &model.AttackEvent{NextAttackAt: cs.HeroNextAttack, IsHero: true, CombatID: heroID})
heap.Push(&e.queue, &model.AttackEvent{NextAttackAt: cs.EnemyNextAttack, IsHero: false, CombatID: heroID})
}
heap.Init(&e.queue)
}
// IsTimePaused reports whether global simulation time is frozen.
func (e *Engine) IsTimePaused() bool {
e.mu.RLock()
defer e.mu.RUnlock()
return e.timePaused
}
// SetSender sets the WS message sender (typically handler.Hub).
func (e *Engine) SetSender(s MessageSender) {
e.mu.Lock()
@ -121,6 +222,20 @@ func (e *Engine) SetOnEnemyDeath(cb EnemyDeathCallback) {
e.onEnemyDeath = cb
}
// SetNPCAlmsHandler registers the handler for npc_alms_accept WebSocket commands.
func (e *Engine) SetNPCAlmsHandler(h func(context.Context, int64) error) {
e.mu.Lock()
defer e.mu.Unlock()
e.npcAlmsHandler = h
}
// SetAdventureLog registers a writer for town NPC visit lines (optional).
func (e *Engine) SetAdventureLog(w AdventureLogWriter) {
e.mu.Lock()
defer e.mu.Unlock()
e.adventureLog = w
}
// IncomingCh returns the channel for routing client WS commands into the engine.
func (e *Engine) IncomingCh() chan<- IncomingMessage {
return e.incomingCh
@ -154,11 +269,17 @@ func (e *Engine) Run(ctx context.Context) error {
e.logger.Info("game engine shutting down")
return ctx.Err()
case now := <-combatTicker.C:
e.processCombatTick(now)
if !e.IsTimePaused() {
e.processCombatTick(now)
}
case now := <-moveTicker.C:
e.processMovementTick(now)
if !e.IsTimePaused() {
e.processMovementTick(now)
}
case now := <-syncTicker.C:
e.processPositionSync(now)
if !e.IsTimePaused() {
e.processPositionSync(now)
}
case msg := <-e.incomingCh:
e.handleClientMessage(msg)
}
@ -167,6 +288,10 @@ func (e *Engine) Run(ctx context.Context) error {
// handleClientMessage routes a single inbound client command.
func (e *Engine) handleClientMessage(msg IncomingMessage) {
if e.IsTimePaused() {
e.sendError(msg.HeroID, "time_paused", "server time is paused")
return
}
switch msg.Type {
case "activate_buff":
e.handleActivateBuff(msg)
@ -174,6 +299,10 @@ func (e *Engine) handleClientMessage(msg IncomingMessage) {
e.handleUsePotion(msg)
case "revive":
e.handleRevive(msg)
case "npc_alms_accept":
e.handleNPCAlmsAccept(msg)
case "npc_alms_decline":
e.handleNPCAlmsDecline(msg)
default:
// Commands like accept_quest, claim_quest, npc_interact etc.
// are handled by their respective REST handlers for now.
@ -266,6 +395,35 @@ func (e *Engine) handleUsePotion(msg IncomingMessage) {
}
// handleRevive processes the revive client command.
func (e *Engine) handleNPCAlmsAccept(msg IncomingMessage) {
e.mu.RLock()
h := e.npcAlmsHandler
e.mu.RUnlock()
if h == nil {
e.sendError(msg.HeroID, "not_supported", "wandering merchant is not available")
return
}
if err := h(context.Background(), msg.HeroID); err != nil {
e.sendError(msg.HeroID, "alms_failed", err.Error())
}
}
func (e *Engine) handleNPCAlmsDecline(msg IncomingMessage) {
e.mu.Lock()
defer e.mu.Unlock()
hm, ok := e.movements[msg.HeroID]
if !ok {
return
}
if hm.WanderingMerchantDeadline.IsZero() {
return
}
hm.WanderingMerchantDeadline = time.Time{}
if e.sender != nil {
e.sender.SendToHero(msg.HeroID, "npc_encounter_end", model.NPCEncounterEndPayload{Reason: "declined"})
}
}
func (e *Engine) handleRevive(msg IncomingMessage) {
e.mu.Lock()
defer e.mu.Unlock()
@ -305,8 +463,10 @@ func (e *Engine) handleRevive(msg IncomingMessage) {
}
if e.sender != nil {
e.sender.SendToHero(msg.HeroID, "hero_revived", model.HeroRevivedPayload{HP: hero.HP})
hero.EnsureGearMap()
hero.RefreshDerivedCombatStats(time.Now())
e.sender.SendToHero(msg.HeroID, "hero_state", hero)
e.sender.SendToHero(msg.HeroID, "hero_revived", model.HeroRevivedPayload{HP: hero.HP})
}
}
@ -333,6 +493,7 @@ func (e *Engine) RegisterHeroMovement(hero *model.Hero) {
// Reconnect while the previous socket is still tearing down: keep live movement so we
// do not replace (x,y) and route with a stale DB snapshot.
if existing, ok := e.movements[hero.ID]; ok {
existing.Hero.EnsureGearMap()
existing.Hero.RefreshDerivedCombatStats(now)
e.logger.Info("hero movement reattached (existing session)",
"hero_id", hero.ID,
@ -367,6 +528,7 @@ func (e *Engine) RegisterHeroMovement(hero *model.Hero) {
// Send initial state via WS.
if e.sender != nil {
hm.Hero.EnsureGearMap()
hm.Hero.RefreshDerivedCombatStats(now)
e.sender.SendToHero(hero.ID, "hero_state", hm.Hero)
@ -428,7 +590,94 @@ func (e *Engine) Status() EngineStatus {
ActiveCombats: len(e.combats),
ActiveMovements: len(e.movements),
UptimeMs: uptimeMs,
TimePaused: e.timePaused,
}
}
// ApplyAdminStartAdventure forces an off-road adventure for an online hero (walking on a road).
func (e *Engine) ApplyAdminStartAdventure(heroID int64) (*model.Hero, bool) {
e.mu.Lock()
defer e.mu.Unlock()
hm, ok := e.movements[heroID]
if !ok || e.roadGraph == nil {
return nil, false
}
now := time.Now()
if !hm.StartAdventureForced(now) {
return nil, false
}
hm.SyncToHero()
h := hm.Hero
if e.sender != nil {
h.EnsureGearMap()
h.RefreshDerivedCombatStats(now)
e.sender.SendToHero(heroID, "hero_state", h)
e.sender.SendToHero(heroID, "hero_move", hm.MovePayload(now))
}
return h, true
}
// ApplyAdminTeleportTown places an online hero at the given town (same state as walking arrival).
func (e *Engine) ApplyAdminTeleportTown(heroID int64, townID int64) (*model.Hero, bool) {
e.mu.Lock()
defer e.mu.Unlock()
hm, ok := e.movements[heroID]
if !ok || e.roadGraph == nil {
return nil, false
}
now := time.Now()
if err := hm.AdminPlaceInTown(e.roadGraph, townID, now); err != nil {
return nil, false
}
delete(e.combats, heroID)
hm.SyncToHero()
h := hm.Hero
if e.sender != nil {
h.EnsureGearMap()
h.RefreshDerivedCombatStats(now)
e.sender.SendToHero(heroID, "hero_state", h)
town := e.roadGraph.Towns[hm.CurrentTownID]
if town != nil {
npcInfos := make([]model.TownNPCInfo, 0, len(e.roadGraph.TownNPCs[hm.CurrentTownID]))
for _, n := range e.roadGraph.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()
}
e.sender.SendToHero(heroID, "town_enter", model.TownEnterPayload{
TownID: town.ID,
TownName: town.Name,
Biome: town.Biome,
NPCs: npcInfos,
RestDurationMs: restMs,
})
}
}
return h, true
}
// ApplyAdminStartRest puts an online hero into town-style rest at the current location.
func (e *Engine) ApplyAdminStartRest(heroID int64) (*model.Hero, bool) {
e.mu.Lock()
defer e.mu.Unlock()
hm, ok := e.movements[heroID]
if !ok || e.roadGraph == nil {
return nil, false
}
now := time.Now()
if !hm.AdminStartRest(now, e.roadGraph) {
return nil, false
}
hm.SyncToHero()
h := hm.Hero
if e.sender != nil {
h.EnsureGearMap()
h.RefreshDerivedCombatStats(now)
e.sender.SendToHero(heroID, "hero_state", h)
}
return h, true
}
// ListActiveCombats returns a snapshot of all active combat sessions.
@ -464,6 +713,13 @@ func (e *Engine) StartCombat(hero *model.Hero, enemy *model.Enemy) {
func (e *Engine) startCombatLocked(hero *model.Hero, enemy *model.Enemy) {
now := time.Now()
if hm, ok := e.movements[hero.ID]; ok {
if hm.State == model.StateResting || hm.State == model.StateInTown {
e.logger.Debug("skip combat start: hero in town", "hero_id", hero.ID)
return
}
}
cs := &model.CombatState{
HeroID: hero.ID,
Hero: hero,
@ -529,10 +785,83 @@ func (e *Engine) SyncHeroState(hero *model.Hero) {
}
e.mu.Lock()
defer e.mu.Unlock()
if e.sender == nil {
return
}
hero.EnsureGearMap()
e.sender.SendToHero(hero.ID, "hero_state", hero)
}
// ApplyAdminHeroSnapshot merges a persisted hero (e.g. after admin set-hp) into the live
// movement session and pushes hero_state (+ route_assigned when a new road was bound).
func (e *Engine) ApplyAdminHeroSnapshot(hero *model.Hero) {
if hero == nil {
return
}
e.mu.Lock()
defer e.mu.Unlock()
hm, ok := e.movements[hero.ID]
if !ok || e.roadGraph == nil {
return
}
now := time.Now()
*hm.Hero = *hero
hm.State = hero.State
hm.CurrentX = hero.PositionX
hm.CurrentY = hero.PositionY
hm.LastMoveTick = now
hm.refreshSpeed(now)
routeAssigned := false
if hm.State == model.StateWalking && hm.Road == nil {
hm.pickDestination(e.roadGraph)
hm.assignRoad(e.roadGraph)
routeAssigned = true
}
if e.sender == nil {
return
}
hm.Hero.EnsureGearMap()
hm.Hero.RefreshDerivedCombatStats(now)
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)
}
}
}
// ApplyHeroAlmsUpdate merges a persisted hero after wandering merchant rewards into
// the live movement session and pushes hero_state when a sender is configured.
func (e *Engine) ApplyHeroAlmsUpdate(hero *model.Hero) {
if hero == nil {
return
}
e.mu.Lock()
defer e.mu.Unlock()
hm, ok := e.movements[hero.ID]
if ok {
now := time.Now()
hm.WanderingMerchantDeadline = time.Time{}
*hm.Hero = *hero
hm.Hero.EnsureGearMap()
hm.Hero.RefreshDerivedCombatStats(now)
}
if e.sender == nil {
return
}
if ok {
e.sender.SendToHero(hero.ID, "hero_state", hm.Hero)
} else {
hero.EnsureGearMap()
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.
@ -570,9 +899,11 @@ func (e *Engine) ApplyAdminHeroRevive(hero *model.Hero) {
if e.sender == nil {
return
}
hm.Hero.EnsureGearMap()
hm.Hero.RefreshDerivedCombatStats(now)
e.sender.SendToHero(hero.ID, "hero_revived", model.HeroRevivedPayload{HP: hm.Hero.HP})
// Full snapshot first so clients never briefly drop gear after hero_revived.
e.sender.SendToHero(hero.ID, "hero_state", hm.Hero)
e.sender.SendToHero(hero.ID, "hero_revived", model.HeroRevivedPayload{HP: hm.Hero.HP})
if routeAssigned {
if route := hm.RoutePayload(); route != nil {
e.sender.SendToHero(hero.ID, "route_assigned", route)
@ -593,6 +924,22 @@ func (e *Engine) processCombatTick(now time.Time) {
e.mu.Lock()
defer e.mu.Unlock()
// Heroes resting or touring town must not keep fighting in the background.
var purgeCombat []int64
for heroID := range e.combats {
if hm, ok := e.movements[heroID]; ok {
if hm.State == model.StateResting || hm.State == model.StateInTown {
purgeCombat = append(purgeCombat, heroID)
}
}
}
for _, heroID := range purgeCombat {
delete(e.combats, heroID)
if hm, ok := e.movements[heroID]; ok {
hm.Hero.State = hm.State
}
}
// Apply periodic effects (debuff DoT, enemy regen, summon damage) for all active combats.
for heroID, cs := range e.combats {
if cs.Hero == nil {
@ -777,9 +1124,11 @@ func (e *Engine) handleEnemyDeath(cs *model.CombatState, now time.Time) {
e.sender.SendToHero(cs.HeroID, "level_up", model.LevelUpPayload{
NewLevel: hero.Level,
})
hero.RefreshDerivedCombatStats(now)
e.sender.SendToHero(cs.HeroID, "hero_state", hero)
}
hero.EnsureGearMap()
hero.EnsureInventorySlice()
hero.RefreshDerivedCombatStats(now)
e.sender.SendToHero(cs.HeroID, "hero_state", hero)
}
delete(e.combats, cs.HeroID)
@ -810,7 +1159,7 @@ func (e *Engine) processMovementTick(now time.Time) {
}
for heroID, hm := range e.movements {
ProcessSingleHeroMovementTick(heroID, hm, e.roadGraph, now, e.sender, startCombat, nil)
ProcessSingleHeroMovementTick(heroID, hm, e.roadGraph, now, e.sender, startCombat, nil, e.adventureLog)
}
}

470
backend/internal/game/movement.go
Unescape Escape View File

@ -1,6 +1,7 @@
package game
import (
"fmt"
"math"
"math/rand"
"time"
@ -21,19 +22,43 @@ const (
// EncounterCooldownBase is the minimum gap between road encounters (monster or merchant).
EncounterCooldownBase = 12 * time.Second
// WanderingMerchantPromptTimeout is how long the hero stays stopped for the wandering merchant dialog (online).
WanderingMerchantPromptTimeout = 15 * time.Second
// EncounterActivityBase scales per-tick chance to roll an encounter after cooldown.
// Effective activity is higher deep off-road (see rollRoadEncounter).
EncounterActivityBase = 0.035
// StartAdventurePerTick is the chance per movement tick to leave the road for a timed excursion.
StartAdventurePerTick = 0.0021
StartAdventurePerTick = 0.000030
// AdventureDurationMin/Max bound how long an off-road excursion lasts.
AdventureDurationMin = 15 * time.Minute
AdventureDurationMax = 20 * time.Minute
// AdventureMaxLateral is max perpendicular offset from the road spine (world units) at peak wilderness.
AdventureMaxLateral = 3.5
AdventureMaxLateral = 20.0
// AdventureWildernessRampFraction is the share of excursion time spent easing off the road at the start
// and easing back at the end. The middle (1 - 2*ramp) stays at full lateral offset so the hero
// visibly walks beside the road for most of a long excursion.
AdventureWildernessRampFraction = 0.12
// LowHPThreshold: below this HP fraction (of MaxHP) the hero seeks a short roadside rest.
LowHPThreshold = 0.35
// RoadsideRestExitHP: leave roadside rest when HP reaches this fraction of MaxHP (or max duration).
RoadsideRestExitHP = 0.92
// RoadsideRestDurationMin/Max cap how long a roadside rest can last (hero may leave earlier if healed).
RoadsideRestDurationMin = 40 * time.Second
RoadsideRestDurationMax = 100 * time.Second
// RoadsideRestLateral is perpendicular offset from the road while resting (smaller than adventure).
RoadsideRestLateral = 1.15
// RoadsideRestHPPerSecond is MaxHP fraction restored per second while roadside resting (0.1%).
RoadsideRestHPPerSecond = 0.001
// RoadsideRestThoughtMinInterval / MaxInterval between adventure log lines while resting.
RoadsideRestThoughtMinInterval = 4 * time.Second
RoadsideRestThoughtMaxInterval = 11 * time.Second
// TownRestMin is the minimum rest duration when arriving at a town.
TownRestMin = 5 * 60 * time.Second
@ -50,8 +75,20 @@ const (
townNPCRollMin = 800 * time.Millisecond
townNPCRollMax = 2600 * time.Millisecond
townNPCRetryAfterMiss = 450 * time.Millisecond
// TownNPCVisitTownPause is how long the hero stays in town after the last NPC (whole town) before leaving.
TownNPCVisitTownPause = 30 * time.Second
// TownNPCVisitLogInterval is how often a line is written to the adventure log during a visit.
TownNPCVisitLogInterval = 5 * time.Second
// townNPCVisitLogLines is how many log lines to emit per NPC (every TownNPCVisitLogInterval).
townNPCVisitLogLines = 6
)
// TownNPCVisitNarrationBlock is the minimum gap before visiting the next town NPC (first line through last line).
var TownNPCVisitNarrationBlock = TownNPCVisitLogInterval * (townNPCVisitLogLines - 1)
// AdventureLogWriter persists or pushes one adventure log line for a hero (optional).
type AdventureLogWriter func(heroID int64, message string)
// HeroMovement holds the live movement state for a single online hero.
type HeroMovement struct {
HeroID int64
@ -74,11 +111,28 @@ type HeroMovement struct {
TownNPCQueue []int64
NextTownNPCRollAt time.Time
// Town NPC visit: adventure log lines until NextTownNPCRollAt (narration block) after town_npc_visit.
TownVisitNPCName string
TownVisitNPCType string
TownVisitStartedAt time.Time
TownVisitLogsEmitted int
// TownLeaveAt: after all town NPCs are visited (queue empty), leave only once now >= TownLeaveAt (TownNPCVisitTownPause).
TownLeaveAt time.Time
// Off-road excursion ("looking for trouble"): not persisted; cleared on town enter and when it ends.
AdventureStartAt time.Time
AdventureEndAt time.Time
AdventureSide int // +1 or -1 perpendicular direction while adventuring; 0 = not adventuring
// Roadside rest (low HP): step off the road and recover HP; not persisted.
RoadsideRestEndAt time.Time
RoadsideRestSide int // +1 / -1 perpendicular; 0 = not resting
RoadsideRestNextLog time.Time
// WanderingMerchantDeadline: non-zero while the hero is frozen for wandering merchant UI (online WS only).
WanderingMerchantDeadline time.Time
// spawnAtRoadStart: DB had no world position yet — place at first waypoint after assignRoad
// instead of projecting (0,0) onto the polyline (unreliable) or sending hero_state at 0,0.
spawnAtRoadStart bool
@ -349,6 +403,32 @@ func (hm *HeroMovement) snapProgressToNearestPointOnRoad() {
hm.CurrentY = bestY
}
// ShiftGameDeadlines advances movement-related deadlines by d (wall time spent paused) so
// simulation does not “catch up” after resume. LastMoveTick is set to now to avoid a huge dt on the next tick.
func (hm *HeroMovement) ShiftGameDeadlines(d time.Duration, now time.Time) {
if d <= 0 {
hm.LastMoveTick = now
return
}
shift := func(t time.Time) time.Time {
if t.IsZero() {
return t
}
return t.Add(d)
}
hm.LastEncounterAt = shift(hm.LastEncounterAt)
hm.RestUntil = shift(hm.RestUntil)
hm.NextTownNPCRollAt = shift(hm.NextTownNPCRollAt)
hm.TownVisitStartedAt = shift(hm.TownVisitStartedAt)
hm.TownLeaveAt = shift(hm.TownLeaveAt)
hm.AdventureStartAt = shift(hm.AdventureStartAt)
hm.AdventureEndAt = shift(hm.AdventureEndAt)
hm.RoadsideRestEndAt = shift(hm.RoadsideRestEndAt)
hm.RoadsideRestNextLog = shift(hm.RoadsideRestNextLog)
hm.WanderingMerchantDeadline = shift(hm.WanderingMerchantDeadline)
hm.LastMoveTick = now
}
// 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.
@ -453,6 +533,81 @@ func (hm *HeroMovement) expireAdventureIfNeeded(now time.Time) {
hm.AdventureSide = 0
}
func (hm *HeroMovement) roadsideRestInProgress() bool {
return !hm.RoadsideRestEndAt.IsZero()
}
func (hm *HeroMovement) endRoadsideRest() {
hm.RoadsideRestEndAt = time.Time{}
hm.RoadsideRestSide = 0
hm.RoadsideRestNextLog = time.Time{}
}
func (hm *HeroMovement) applyRoadsideRestHeal(dt float64) {
if dt <= 0 || hm.Hero == nil || hm.Hero.MaxHP <= 0 {
return
}
gain := int(math.Ceil(float64(hm.Hero.MaxHP) * RoadsideRestHPPerSecond * dt))
if gain < 1 {
gain = 1
}
hm.Hero.HP += gain
if hm.Hero.HP > hm.Hero.MaxHP {
hm.Hero.HP = hm.Hero.MaxHP
}
}
// tryStartRoadsideRest pulls the hero off the road when HP is low; cancels an active adventure.
func (hm *HeroMovement) tryStartRoadsideRest(now time.Time) {
if hm.roadsideRestInProgress() {
return
}
if hm.Hero == nil || hm.Hero.MaxHP <= 0 {
return
}
if float64(hm.Hero.HP)/float64(hm.Hero.MaxHP) > LowHPThreshold {
return
}
hm.AdventureStartAt = time.Time{}
hm.AdventureEndAt = time.Time{}
hm.AdventureSide = 0
spanNs := (RoadsideRestDurationMax - RoadsideRestDurationMin).Nanoseconds()
if spanNs < 1 {
spanNs = 1
}
hm.RoadsideRestEndAt = now.Add(RoadsideRestDurationMin + time.Duration(rand.Int63n(spanNs+1)))
if rand.Float64() < 0.5 {
hm.RoadsideRestSide = 1
} else {
hm.RoadsideRestSide = -1
}
hm.RoadsideRestNextLog = now.Add(randomRoadsideRestThoughtDelay())
}
func randomRoadsideRestThoughtDelay() time.Duration {
span := RoadsideRestThoughtMaxInterval - RoadsideRestThoughtMinInterval
if span < 0 {
span = 0
}
return RoadsideRestThoughtMinInterval + time.Duration(rand.Int63n(int64(span)+1))
}
// emitRoadsideRestThoughts appends occasional journal lines while the hero rests off the road.
func emitRoadsideRestThoughts(heroID int64, hm *HeroMovement, now time.Time, log AdventureLogWriter) {
if log == nil || !hm.roadsideRestInProgress() {
return
}
if hm.RoadsideRestNextLog.IsZero() {
hm.RoadsideRestNextLog = now.Add(randomRoadsideRestThoughtDelay())
return
}
if now.Before(hm.RoadsideRestNextLog) {
return
}
log(heroID, randomRoadsideRestThought())
hm.RoadsideRestNextLog = now.Add(randomRoadsideRestThoughtDelay())
}
// tryStartAdventure begins a timed off-road excursion with small probability.
func (hm *HeroMovement) tryStartAdventure(now time.Time) {
if hm.adventureActive(now) {
@ -474,7 +629,93 @@ func (hm *HeroMovement) tryStartAdventure(now time.Time) {
}
}
// wildernessFactor is 0 on the road, then 0→1→0 over the excursion (triangle: out, then back).
// StartAdventureForced starts an off-road adventure immediately (admin).
func (hm *HeroMovement) StartAdventureForced(now time.Time) bool {
if hm.Hero == nil || hm.Hero.State == model.StateDead || hm.Hero.HP <= 0 {
return false
}
if hm.State != model.StateWalking {
return false
}
if hm.Road == nil || len(hm.Road.Waypoints) < 2 {
return false
}
if hm.adventureActive(now) {
return true
}
spanNs := (AdventureDurationMax - AdventureDurationMin).Nanoseconds()
if spanNs < 1 {
spanNs = 1
}
hm.AdventureStartAt = now
hm.AdventureEndAt = now.Add(AdventureDurationMin + time.Duration(rand.Int63n(spanNs+1)))
if rand.Float64() < 0.5 {
hm.AdventureSide = 1
} else {
hm.AdventureSide = -1
}
return true
}
// AdminPlaceInTown moves the hero to a town center and applies EnterTown logic (NPC tour or rest).
func (hm *HeroMovement) AdminPlaceInTown(graph *RoadGraph, townID int64, now time.Time) error {
if graph == nil || townID == 0 {
return fmt.Errorf("invalid town")
}
if _, ok := graph.Towns[townID]; !ok {
return fmt.Errorf("unknown town")
}
hm.Road = nil
hm.WaypointIndex = 0
hm.WaypointFraction = 0
hm.DestinationTownID = townID
hm.spawnAtRoadStart = false
hm.AdventureStartAt = time.Time{}
hm.AdventureEndAt = time.Time{}
hm.AdventureSide = 0
hm.endRoadsideRest()
hm.WanderingMerchantDeadline = time.Time{}
hm.TownVisitNPCName = ""
hm.TownVisitNPCType = ""
hm.TownVisitStartedAt = time.Time{}
hm.TownVisitLogsEmitted = 0
t := graph.Towns[townID]
hm.CurrentX = t.WorldX
hm.CurrentY = t.WorldY
hm.EnterTown(now, graph)
return nil
}
// AdminStartRest forces a resting period (same duration model as town rest).
func (hm *HeroMovement) AdminStartRest(now time.Time, graph *RoadGraph) bool {
if hm.Hero == nil || hm.Hero.HP <= 0 || hm.Hero.State == model.StateDead {
return false
}
if hm.State == model.StateFighting {
return false
}
hm.endRoadsideRest()
hm.AdventureStartAt = time.Time{}
hm.AdventureEndAt = time.Time{}
hm.AdventureSide = 0
hm.WanderingMerchantDeadline = time.Time{}
hm.TownNPCQueue = nil
hm.NextTownNPCRollAt = time.Time{}
hm.TownVisitNPCName = ""
hm.TownVisitNPCType = ""
hm.TownVisitStartedAt = time.Time{}
hm.TownVisitLogsEmitted = 0
if graph != nil && hm.CurrentTownID == 0 {
hm.CurrentTownID = graph.NearestTown(hm.CurrentX, hm.CurrentY)
}
hm.State = model.StateResting
hm.Hero.State = model.StateResting
hm.RestUntil = now.Add(randomRestDuration())
return true
}
// wildernessFactor is 0 on the road, then ramps to 1, stays at 1 for most of the excursion, then ramps back.
// (Trapezoid, not a triangle — so "off-road" reads as a long stretch, not a brief peak at the midpoint.)
func (hm *HeroMovement) wildernessFactor(now time.Time) float64 {
if !hm.adventureActive(now) {
return 0
@ -490,10 +731,20 @@ func (hm *HeroMovement) wildernessFactor(now time.Time) float64 {
} else if p > 1 {
p = 1
}
if p < 0.5 {
return p * 2
r := AdventureWildernessRampFraction
if r < 1e-6 {
r = 1e-6
}
if r > 0.49 {
r = 0.49
}
if p < r {
return p / r
}
return (1 - p) * 2
if p > 1-r {
return (1 - p) / r
}
return 1
}
func (hm *HeroMovement) roadPerpendicularUnit() (float64, float64) {
@ -519,6 +770,14 @@ func (hm *HeroMovement) roadPerpendicularUnit() (float64, float64) {
}
func (hm *HeroMovement) displayOffset(now time.Time) (float64, float64) {
if hm.roadsideRestInProgress() {
if hm.RoadsideRestSide == 0 {
return 0, 0
}
px, py := hm.roadPerpendicularUnit()
mag := float64(hm.RoadsideRestSide) * RoadsideRestLateral
return px * mag, py * mag
}
w := hm.wildernessFactor(now)
if w <= 0 || hm.AdventureSide == 0 {
return 0, 0
@ -568,9 +827,15 @@ func (hm *HeroMovement) EnterTown(now time.Time, graph *RoadGraph) {
hm.Road = nil
hm.TownNPCQueue = nil
hm.NextTownNPCRollAt = time.Time{}
hm.TownVisitNPCName = ""
hm.TownVisitNPCType = ""
hm.TownVisitStartedAt = time.Time{}
hm.TownVisitLogsEmitted = 0
hm.TownLeaveAt = time.Time{}
hm.AdventureStartAt = time.Time{}
hm.AdventureEndAt = time.Time{}
hm.AdventureSide = 0
hm.endRoadsideRest()
ids := graph.TownNPCIDs(destID)
if len(ids) == 0 {
@ -593,8 +858,15 @@ func (hm *HeroMovement) EnterTown(now time.Time, graph *RoadGraph) {
func (hm *HeroMovement) LeaveTown(graph *RoadGraph, now time.Time) {
hm.TownNPCQueue = nil
hm.NextTownNPCRollAt = time.Time{}
hm.TownVisitNPCName = ""
hm.TownVisitNPCType = ""
hm.TownVisitStartedAt = time.Time{}
hm.TownVisitLogsEmitted = 0
hm.TownLeaveAt = time.Time{}
hm.State = model.StateWalking
hm.Hero.State = model.StateWalking
// Prevent a huge movement step on the first tick after town: AdvanceTick uses now - LastMoveTick.
hm.LastMoveTick = now
hm.pickDestination(graph)
hm.assignRoad(graph)
hm.refreshSpeed(now)
@ -608,6 +880,8 @@ func randomTownNPCDelay() time.Duration {
// StartFighting pauses movement for combat.
func (hm *HeroMovement) StartFighting() {
hm.State = model.StateFighting
hm.endRoadsideRest()
hm.WanderingMerchantDeadline = time.Time{}
}
// ResumWalking resumes movement after combat.
@ -620,6 +894,7 @@ func (hm *HeroMovement) ResumeWalking(now time.Time) {
// Die sets the movement state to dead.
func (hm *HeroMovement) Die() {
hm.State = model.StateDead
hm.endRoadsideRest()
}
// SyncToHero writes movement state back to the hero model for persistence.
@ -698,12 +973,100 @@ type EncounterStarter func(hm *HeroMovement, enemy *model.Enemy, now time.Time)
// MerchantEncounterHook is called for wandering-merchant road events when there is no WS sender (offline).
type MerchantEncounterHook func(hm *HeroMovement, now time.Time, cost int64)
func emitTownNPCVisitLogs(heroID int64, hm *HeroMovement, now time.Time, log AdventureLogWriter) {
if log == nil || hm.TownVisitStartedAt.IsZero() {
return
}
for hm.TownVisitLogsEmitted < townNPCVisitLogLines {
deadline := hm.TownVisitStartedAt.Add(time.Duration(hm.TownVisitLogsEmitted) * TownNPCVisitLogInterval)
if now.Before(deadline) {
break
}
msg := townNPCVisitLogMessage(hm.TownVisitNPCType, hm.TownVisitNPCName, hm.TownVisitLogsEmitted)
if msg != "" {
log(heroID, msg)
}
hm.TownVisitLogsEmitted++
}
}
func townNPCVisitLogMessage(npcType, npcName string, lineIndex int) string {
if lineIndex < 0 || lineIndex >= townNPCVisitLogLines {
return ""
}
switch npcType {
case "merchant":
switch lineIndex {
case 0:
return fmt.Sprintf("You stop at %s's stall.", npcName)
case 1:
return "Crates, pouches, and price tags blur together as you browse."
case 2:
return fmt.Sprintf("%s points out a few curious trinkets.", npcName)
case 3:
return "You weigh a potion against your coin purse."
case 4:
return "A short haggle ends in a reluctant nod."
case 5:
return fmt.Sprintf("You thank %s and step back from the counter.", npcName)
}
case "healer":
switch lineIndex {
case 0:
return fmt.Sprintf("You seek out %s.", npcName)
case 1:
return "The healer examines your wounds with a calm eye."
case 2:
return "Herbs steam gently; bandages are laid out in neat rows."
case 3:
return "A slow warmth spreads as salves are applied."
case 4:
return "You rest a moment on a bench, breathing easier."
case 5:
return fmt.Sprintf("You nod to %s and return to the street.", npcName)
}
case "quest_giver":
switch lineIndex {
case 0:
return fmt.Sprintf("You speak with %s about the road ahead.", npcName)
case 1:
return "Rumors of trouble and slim rewards fill the air."
case 2:
return "A worn map is smoothed flat between you."
case 3:
return "You mark targets and deadlines in your mind."
case 4:
return fmt.Sprintf("%s hints at better pay for the bold.", npcName)
case 5:
return "You part with a clearer picture of what must be done."
}
default:
switch lineIndex {
case 0:
return fmt.Sprintf("You spend time with %s.", npcName)
case 1:
return "Conversation drifts from weather to the wider world."
case 2:
return "A few practical details stick in your memory."
case 3:
return "You listen more than you speak."
case 4:
return "Promises and coin change hands—or almost do."
case 5:
return fmt.Sprintf("You say farewell to %s.", npcName)
}
}
return ""
}
// 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.
// adventureLog may be nil; when set, town NPC visits append timed lines (per NPC narration block),
// and roadside rest emits occasional thoughts.
func ProcessSingleHeroMovementTick(
heroID int64,
hm *HeroMovement,
@ -712,6 +1075,7 @@ func ProcessSingleHeroMovementTick(
sender MessageSender,
onEncounter EncounterStarter,
onMerchantEncounter MerchantEncounterHook,
adventureLog AdventureLogWriter,
) {
if graph == nil {
return
@ -722,6 +1086,8 @@ func ProcessSingleHeroMovementTick(
return
case model.StateResting:
// Advance logical movement time while idle so leaving town does not apply a huge dt (teleport).
hm.LastMoveTick = now
if now.After(hm.RestUntil) {
hm.LeaveTown(graph, now)
hm.SyncToHero()
@ -734,7 +1100,25 @@ func ProcessSingleHeroMovementTick(
}
case model.StateInTown:
// Same as resting: no road simulation here, but keep LastMoveTick aligned with wall time.
hm.LastMoveTick = now
// NPC visit pause ended: clear visit log state before the next roll.
if !hm.TownVisitStartedAt.IsZero() && !now.Before(hm.NextTownNPCRollAt) {
hm.TownVisitNPCName = ""
hm.TownVisitNPCType = ""
hm.TownVisitStartedAt = time.Time{}
hm.TownVisitLogsEmitted = 0
}
emitTownNPCVisitLogs(heroID, hm, now, adventureLog)
if len(hm.TownNPCQueue) == 0 {
if hm.TownLeaveAt.IsZero() {
hm.TownLeaveAt = now.Add(TownNPCVisitTownPause)
}
if now.Before(hm.TownLeaveAt) {
return
}
hm.TownLeaveAt = time.Time{}
hm.LeaveTown(graph, now)
hm.SyncToHero()
if sender != nil {
@ -751,12 +1135,19 @@ func ProcessSingleHeroMovementTick(
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,
})
if npc, ok := graph.NPCByID[npcID]; ok {
if sender != nil {
sender.SendToHero(heroID, "town_npc_visit", model.TownNPCVisitPayload{
NPCID: npc.ID, Name: npc.Name, Type: npc.Type, TownID: hm.CurrentTownID,
})
}
hm.TownVisitNPCName = npc.Name
hm.TownVisitNPCType = npc.Type
hm.TownVisitStartedAt = now
hm.TownVisitLogsEmitted = 0
emitTownNPCVisitLogs(heroID, hm, now, adventureLog)
}
hm.NextTownNPCRollAt = now.Add(randomTownNPCDelay())
hm.NextTownNPCRollAt = now.Add(TownNPCVisitNarrationBlock)
} else {
hm.NextTownNPCRollAt = now.Add(townNPCRetryAfterMiss)
}
@ -768,6 +1159,62 @@ func ProcessSingleHeroMovementTick(
hm.pickDestination(graph)
hm.assignRoad(graph)
}
// Wandering merchant dialog (online): freeze movement and encounter rolls until accept/decline or timeout.
if !hm.WanderingMerchantDeadline.IsZero() {
if !now.Before(hm.WanderingMerchantDeadline) {
hm.WanderingMerchantDeadline = time.Time{}
if sender != nil {
sender.SendToHero(heroID, "npc_encounter_end", model.NPCEncounterEndPayload{Reason: "timeout"})
}
} else {
hm.LastMoveTick = now
if sender != nil {
sender.SendToHero(heroID, "hero_move", hm.MovePayload(now))
}
if hm.Hero != nil {
hm.Hero.PositionX = hm.CurrentX
hm.Hero.PositionY = hm.CurrentY
}
return
}
}
if hm.roadsideRestInProgress() {
dt := now.Sub(hm.LastMoveTick).Seconds()
if dt <= 0 {
dt = MovementTickRate.Seconds()
}
hm.LastMoveTick = now
hm.applyRoadsideRestHeal(dt)
emitRoadsideRestThoughts(heroID, hm, now, adventureLog)
timeUp := !now.Before(hm.RoadsideRestEndAt)
hpOk := hm.Hero != nil && hm.Hero.MaxHP > 0 &&
float64(hm.Hero.HP)/float64(hm.Hero.MaxHP) >= RoadsideRestExitHP
if timeUp || hpOk {
hm.endRoadsideRest()
} else {
if sender != nil {
sender.SendToHero(heroID, "hero_move", hm.MovePayload(now))
}
hm.Hero.PositionX = hm.CurrentX
hm.Hero.PositionY = hm.CurrentY
return
}
}
hm.tryStartRoadsideRest(now)
if hm.roadsideRestInProgress() {
hm.LastMoveTick = now
emitRoadsideRestThoughts(heroID, hm, now, adventureLog)
if sender != nil {
sender.SendToHero(heroID, "hero_move", hm.MovePayload(now))
}
hm.Hero.PositionX = hm.CurrentX
hm.Hero.PositionY = hm.CurrentY
return
}
hm.tryStartAdventure(now)
reachedTown := hm.AdvanceTick(now, graph)
@ -815,6 +1262,7 @@ func ProcessSingleHeroMovementTick(
if sender != nil || onMerchantEncounter != nil {
hm.LastEncounterAt = now
if sender != nil {
hm.WanderingMerchantDeadline = now.Add(WanderingMerchantPromptTimeout)
sender.SendToHero(heroID, "npc_encounter", model.NPCEncounterPayload{
NPCID: 0,
NPCName: "Wandering Merchant",

57
backend/internal/game/offline.go
Unescape Escape View File

@ -21,16 +21,20 @@ type OfflineSimulator struct {
graph *RoadGraph
interval time.Duration
logger *slog.Logger
// isPaused, when set, skips simulation ticks while global server time is frozen.
isPaused func() bool
}
// NewOfflineSimulator creates a new OfflineSimulator that ticks every 30 seconds.
func NewOfflineSimulator(store *storage.HeroStore, logStore *storage.LogStore, graph *RoadGraph, logger *slog.Logger) *OfflineSimulator {
// isPaused may be nil; if it returns true, offline catch-up is skipped (aligned with engine pause).
func NewOfflineSimulator(store *storage.HeroStore, logStore *storage.LogStore, graph *RoadGraph, logger *slog.Logger, isPaused func() bool) *OfflineSimulator {
return &OfflineSimulator{
store: store,
logStore: logStore,
graph: graph,
interval: 30 * time.Second,
logger: logger,
isPaused: isPaused,
}
}
@ -54,6 +58,9 @@ func (s *OfflineSimulator) Run(ctx context.Context) error {
// processTick finds all offline heroes and simulates one fight for each.
func (s *OfflineSimulator) processTick(ctx context.Context) {
if s.isPaused != nil && s.isPaused() {
return
}
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)
@ -99,6 +106,14 @@ func (s *OfflineSimulator) simulateHeroTick(ctx context.Context, hero *model.Her
return nil
}
// Do not simulate roads/encounters while the hero is in town (rest or NPC tour).
if hero.State == model.StateInTown || hero.State == model.StateResting {
return nil
}
if hero.MoveState == string(model.StateInTown) || hero.MoveState == string(model.StateResting) {
return nil
}
if s.graph == nil {
s.logger.Warn("offline simulator: road graph nil, skipping movement tick", "hero_id", hero.ID)
return nil
@ -113,7 +128,9 @@ func (s *OfflineSimulator) simulateHeroTick(ctx context.Context, hero *model.Her
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)
survived, en, xpGained, goldGained := SimulateOneFight(hm.Hero, tickNow, enemy, s.graph, func(msg string) {
s.addLog(ctx, hm.Hero.ID, msg)
})
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)
@ -139,7 +156,10 @@ func (s *OfflineSimulator) simulateHeroTick(ctx context.Context, hero *model.Her
_ = cost
s.addLog(ctx, hm.Hero.ID, "Encountered a Wandering Merchant on the road")
}
ProcessSingleHeroMovementTick(hero.ID, hm, s.graph, next, nil, encounter, onMerchant)
adventureLog := func(heroID int64, msg string) {
s.addLog(ctx, heroID, msg)
}
ProcessSingleHeroMovementTick(hero.ID, hm, s.graph, next, nil, encounter, onMerchant, adventureLog)
if hm.Hero.State == model.StateDead || hm.Hero.HP <= 0 {
break
}
@ -174,14 +194,17 @@ func (s *OfflineSimulator) addLog(ctx context.Context, heroID int64, message str
// 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.
// onInventoryDiscard is called when a gear drop cannot be equipped and the backpack is full (may be nil).
// 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) {
func SimulateOneFight(hero *model.Hero, now time.Time, encounterEnemy *model.Enemy, g *RoadGraph, onInventoryDiscard func(string)) (survived bool, enemy model.Enemy, xpGained int64, goldGained int64) {
if encounterEnemy != nil {
enemy = *encounterEnemy
} else {
enemy = PickEnemyForLevel(hero.Level)
}
allowSell := g != nil && g.HeroInTownAt(hero.PositionX, hero.PositionY)
heroDmgPerHit := hero.EffectiveAttackAt(now) - enemy.Defense
if heroDmgPerHit < 1 {
heroDmgPerHit = 1
@ -245,8 +268,8 @@ func SimulateOneFight(hero *model.Hero, now time.Time, encounterEnemy *model.Ene
if family != nil {
ilvl := model.RollIlvl(enemy.MinLevel, enemy.IsElite)
item := model.NewGearItem(family, ilvl, drop.Rarity)
AutoEquipGear(hero, item, now)
} else {
TryEquipOrStashOffline(hero, item, now, onInventoryDiscard)
} else if allowSell {
hero.Gold += model.AutoSellPrices[drop.Rarity]
goldGained += model.AutoSellPrices[drop.Rarity]
}
@ -327,25 +350,3 @@ func ScaleEnemyTemplate(tmpl model.Enemy, heroLevel int) model.Enemy {
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]
}

8
backend/internal/game/offline_test.go
Unescape Escape View File

@ -17,7 +17,7 @@ func TestSimulateOneFight_HeroSurvives(t *testing.T) {
}
now := time.Now()
survived, enemy, xpGained, goldGained := SimulateOneFight(hero, now, nil)
survived, enemy, xpGained, goldGained := SimulateOneFight(hero, now, nil, nil, nil)
if !survived {
t.Fatalf("overpowered hero should survive, enemy was %s", enemy.Name)
@ -42,7 +42,7 @@ func TestSimulateOneFight_HeroDies(t *testing.T) {
}
now := time.Now()
survived, _, _, _ := SimulateOneFight(hero, now, nil)
survived, _, _, _ := SimulateOneFight(hero, now, nil, nil, nil)
if survived {
t.Fatal("1 HP hero should die to any enemy")
@ -66,7 +66,7 @@ func TestSimulateOneFight_LevelUp(t *testing.T) {
}
now := time.Now()
survived, _, xpGained, _ := SimulateOneFight(hero, now, nil)
survived, _, xpGained, _ := SimulateOneFight(hero, now, nil, nil, nil)
if !survived {
t.Fatal("overpowered hero should survive")
@ -98,7 +98,7 @@ func TestSimulateOneFight_PotionUsage(t *testing.T) {
break
}
hero.HP = 25 // force low HP to trigger potion usage
SimulateOneFight(hero, now, nil)
SimulateOneFight(hero, now, nil, nil, nil)
}
if hero.Potions >= startPotions {

18
backend/internal/game/road_graph.go
Unescape Escape View File

@ -165,6 +165,24 @@ func (g *RoadGraph) NextTownInChain(currentTownID int64) int64 {
return g.TownOrder[(idx+1)%n]
}
// HeroInTownAt returns true if (x, y) lies inside any town's radius (vendor / sell zone).
func (g *RoadGraph) HeroInTownAt(x, y float64) bool {
if g == nil {
return false
}
for _, t := range g.Towns {
if t == nil {
continue
}
dx := x - t.WorldX
dy := y - t.WorldY
if dx*dx+dy*dy <= t.Radius*t.Radius {
return true
}
}
return false
}
// NearestTown returns the town ID closest to the given world position.
func (g *RoadGraph) NearestTown(x, y float64) int64 {
bestDist := math.MaxFloat64

304
backend/internal/handler/admin.go
Unescape Escape View File

@ -1,7 +1,9 @@
package handler
import (
"context"
"encoding/json"
"fmt"
"log/slog"
"net/http"
"runtime"
@ -384,7 +386,9 @@ func (h *AdminHandler) SetHeroHP(w http.ResponseWriter, r *http.Request) {
}
h.logger.Info("admin: hero HP set", "hero_id", heroID, "hp", hero.HP)
hero.EnsureGearMap()
hero.RefreshDerivedCombatStats(time.Now())
h.engine.ApplyAdminHeroSnapshot(hero)
writeJSON(w, http.StatusOK, hero)
}
@ -430,6 +434,7 @@ func (h *AdminHandler) ReviveHero(w http.ResponseWriter, r *http.Request) {
h.engine.ApplyAdminHeroRevive(hero)
h.logger.Info("admin: hero revived", "hero_id", heroID, "hp", hero.HP)
hero.EnsureGearMap()
hero.RefreshDerivedCombatStats(time.Now())
writeJSON(w, http.StatusOK, hero)
}
@ -599,13 +604,304 @@ func (h *AdminHandler) DeleteHero(w http.ResponseWriter, r *http.Request) {
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,
"running": status.Running,
"tickRateMs": status.TickRate.Milliseconds(),
"activeCombats": status.ActiveCombats,
"activeMovements": status.ActiveMovements,
"timePaused": status.TimePaused,
"uptimeMs": status.UptimeMs,
})
}
type teleportTownRequest struct {
TownID int64 `json:"townId"`
}
// ListTowns returns town ids from the loaded road graph (for admin teleport).
// GET /admin/towns
func (h *AdminHandler) ListTowns(w http.ResponseWriter, r *http.Request) {
rg := h.engine.RoadGraph()
if rg == nil {
writeJSON(w, http.StatusServiceUnavailable, map[string]string{
"error": "road graph not loaded",
})
return
}
type row struct {
ID int64 `json:"id"`
Name string `json:"name"`
WorldX float64 `json:"worldX"`
WorldY float64 `json:"worldY"`
}
out := make([]row, 0, len(rg.TownOrder))
for _, id := range rg.TownOrder {
if t := rg.Towns[id]; t != nil {
out = append(out, row{ID: t.ID, Name: t.Name, WorldX: t.WorldX, WorldY: t.WorldY})
}
}
writeJSON(w, http.StatusOK, map[string]any{"towns": out})
}
// StartHeroAdventure forces off-road adventure for a hero (online or offline).
// POST /admin/heroes/{heroId}/start-adventure
func (h *AdminHandler) StartHeroAdventure(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
}
if h.isHeroInCombat(w, heroID) {
return
}
hero, err := h.store.GetByID(r.Context(), heroID)
if err != nil {
h.logger.Error("admin: get hero for start-adventure", "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
}
var hm = h.engine.GetMovements(heroID);
hero = hm.Hero;
if hero.State == model.StateFighting || hero.State == model.StateDead || hero.HP <= 0 {
writeJSON(w, http.StatusBadRequest, map[string]any{
"error": "hero must be alive and not in combat",
"hero": hero,
})
return
}
if hm := h.engine.GetMovements(heroID); hm != nil {
out, ok := h.engine.ApplyAdminStartAdventure(heroID)
if !ok || out == nil {
writeJSON(w, http.StatusBadRequest, map[string]any{
"error": "cannot start adventure (hero must be walking on a road)",
})
return
}
if err := h.store.Save(r.Context(), out); err != nil {
h.logger.Error("admin: save after start-adventure", "hero_id", heroID, "error", err)
writeJSON(w, http.StatusInternalServerError, map[string]string{
"error": "failed to save hero",
})
return
}
out.RefreshDerivedCombatStats(time.Now())
h.logger.Info("admin: start adventure", "hero_id", heroID)
writeJSON(w, http.StatusOK, out)
return
}
hero2, err := h.adminMovementOffline(r.Context(), hero, func(hm *game.HeroMovement, rg *game.RoadGraph, now time.Time) error {
if !hm.StartAdventureForced(now) {
return fmt.Errorf("cannot start adventure (hero must be walking on a road)")
}
return nil
})
if err != nil {
writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
return
}
h.logger.Info("admin: start adventure (offline)", "hero_id", heroID)
writeJSON(w, http.StatusOK, hero2)
}
// TeleportHeroTown moves the hero into a town (arrival logic: NPC tour or rest).
// POST /admin/heroes/{heroId}/teleport-town
func (h *AdminHandler) TeleportHeroTown(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
}
if h.isHeroInCombat(w, heroID) {
return
}
var req teleportTownRequest
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.TownID == 0 {
writeJSON(w, http.StatusBadRequest, map[string]string{
"error": "townId is required",
})
return
}
hero, err := h.store.GetByID(r.Context(), heroID)
if err != nil {
h.logger.Error("admin: get hero for teleport", "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 hero.State == model.StateFighting || hero.State == model.StateDead || hero.HP <= 0 {
writeJSON(w, http.StatusBadRequest, map[string]string{
"error": "hero must be alive and not in combat",
})
return
}
townID := req.TownID
if hm := h.engine.GetMovements(heroID); hm != nil {
out, ok := h.engine.ApplyAdminTeleportTown(heroID, townID)
if !ok || out == nil {
writeJSON(w, http.StatusBadRequest, map[string]string{
"error": "teleport failed (unknown town or hero not online with movement)",
})
return
}
if err := h.store.Save(r.Context(), out); err != nil {
h.logger.Error("admin: save after teleport", "hero_id", heroID, "error", err)
writeJSON(w, http.StatusInternalServerError, map[string]string{
"error": "failed to save hero",
})
return
}
out.RefreshDerivedCombatStats(time.Now())
h.logger.Info("admin: teleport town", "hero_id", heroID, "town_id", townID)
writeJSON(w, http.StatusOK, out)
return
}
hero2, err := h.adminMovementOffline(r.Context(), hero, func(hm *game.HeroMovement, rg *game.RoadGraph, now time.Time) error {
return hm.AdminPlaceInTown(rg, townID, now)
})
if err != nil {
writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
return
}
h.logger.Info("admin: teleport town (offline)", "hero_id", heroID, "town_id", townID)
writeJSON(w, http.StatusOK, hero2)
}
// StartHeroRest forces resting state (duration same as town rest).
// POST /admin/heroes/{heroId}/start-rest
func (h *AdminHandler) StartHeroRest(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
}
if h.isHeroInCombat(w, heroID) {
return
}
hero, err := h.store.GetByID(r.Context(), heroID)
if err != nil {
h.logger.Error("admin: get hero for start-rest", "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 hero.State == model.StateFighting || hero.State == model.StateDead || hero.HP <= 0 {
writeJSON(w, http.StatusBadRequest, map[string]string{
"error": "hero must be alive and not in combat",
})
return
}
if hm := h.engine.GetMovements(heroID); hm != nil {
out, ok := h.engine.ApplyAdminStartRest(heroID)
if !ok || out == nil {
writeJSON(w, http.StatusBadRequest, map[string]string{
"error": "cannot start rest",
})
return
}
if err := h.store.Save(r.Context(), out); err != nil {
h.logger.Error("admin: save after start-rest", "hero_id", heroID, "error", err)
writeJSON(w, http.StatusInternalServerError, map[string]string{
"error": "failed to save hero",
})
return
}
out.RefreshDerivedCombatStats(time.Now())
h.logger.Info("admin: start rest", "hero_id", heroID)
writeJSON(w, http.StatusOK, out)
return
}
hero2, err := h.adminMovementOffline(r.Context(), hero, func(hm *game.HeroMovement, rg *game.RoadGraph, now time.Time) error {
if !hm.AdminStartRest(now, rg) {
return fmt.Errorf("cannot start rest")
}
return nil
})
if err != nil {
writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
return
}
h.logger.Info("admin: start rest (offline)", "hero_id", heroID)
writeJSON(w, http.StatusOK, hero2)
}
// PauseTime freezes engine ticks, offline simulation, and blocks mutating game API calls.
// POST /admin/time/pause
func (h *AdminHandler) PauseTime(w http.ResponseWriter, r *http.Request) {
h.engine.SetTimePaused(true)
h.logger.Info("admin: global time paused")
writeJSON(w, http.StatusOK, map[string]any{"timePaused": true})
}
// ResumeTime resumes engine and offline simulation.
// POST /admin/time/resume
func (h *AdminHandler) ResumeTime(w http.ResponseWriter, r *http.Request) {
h.engine.SetTimePaused(false)
h.logger.Info("admin: global time resumed")
writeJSON(w, http.StatusOK, map[string]any{"timePaused": false})
}
// adminMovementOffline rebuilds movement from DB, applies fn, persists.
func (h *AdminHandler) adminMovementOffline(ctx context.Context, hero *model.Hero, fn func(hm *game.HeroMovement, rg *game.RoadGraph, now time.Time) error) (*model.Hero, error) {
rg := h.engine.RoadGraph()
if rg == nil {
return nil, fmt.Errorf("road graph not loaded")
}
now := time.Now()
hm := game.NewHeroMovement(hero, rg, now)
if err := fn(hm, rg, now); err != nil {
return nil, err
}
hm.SyncToHero()
if err := h.store.Save(ctx, hero); err != nil {
return nil, fmt.Errorf("failed to save hero: %w", err)
}
hero.RefreshDerivedCombatStats(now)
return hero, nil
}
// ActiveCombats returns all active combat sessions.
// GET /admin/engine/combats
func (h *AdminHandler) ActiveCombats(w http.ResponseWriter, r *http.Request) {

196
backend/internal/handler/game.go
Unescape Escape View File

@ -31,6 +31,7 @@ type GameHandler struct {
engine *game.Engine
store *storage.HeroStore
logStore *storage.LogStore
hub *Hub
questStore *storage.QuestStore
gearStore *storage.GearStore
achievementStore *storage.AchievementStore
@ -56,11 +57,12 @@ type encounterEnemyResponse struct {
EnemyType model.EnemyType `json:"enemyType"`
}
func NewGameHandler(engine *game.Engine, store *storage.HeroStore, logStore *storage.LogStore, worldSvc *world.Service, logger *slog.Logger, serverStartedAt time.Time, questStore *storage.QuestStore, gearStore *storage.GearStore, achievementStore *storage.AchievementStore, taskStore *storage.DailyTaskStore) *GameHandler {
func NewGameHandler(engine *game.Engine, store *storage.HeroStore, logStore *storage.LogStore, worldSvc *world.Service, logger *slog.Logger, serverStartedAt time.Time, questStore *storage.QuestStore, gearStore *storage.GearStore, achievementStore *storage.AchievementStore, taskStore *storage.DailyTaskStore, hub *Hub) *GameHandler {
h := &GameHandler{
engine: engine,
store: store,
logStore: logStore,
hub: hub,
questStore: questStore,
gearStore: gearStore,
achievementStore: achievementStore,
@ -75,7 +77,7 @@ func NewGameHandler(engine *game.Engine, store *storage.HeroStore, logStore *sto
return h
}
// addLog is a fire-and-forget helper that writes an adventure log entry.
// addLog is a fire-and-forget helper that writes an adventure log entry and mirrors it to the client via WS.
func (h *GameHandler) addLog(heroID int64, message string) {
if h.logStore == nil {
return
@ -84,6 +86,10 @@ func (h *GameHandler) addLog(heroID int64, message string) {
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)
return
}
if h.hub != nil {
h.hub.SendToHero(heroID, "adventure_log_line", model.AdventureLogLinePayload{Message: message})
}
}
@ -95,8 +101,9 @@ func (h *GameHandler) onEnemyDeath(hero *model.Hero, enemy *model.Enemy, now tim
// processVictoryRewards is the single source of truth for post-kill rewards.
// It awards XP, generates loot (gold is guaranteed via GenerateLoot — no separate
// enemy.GoldReward add), processes equipment drops with nil-fallback auto-sell,
// runs the level-up loop, sets hero state to walking, and records loot history.
// enemy.GoldReward add), processes equipment drops (auto-equip, else stash up to
// MaxInventorySlots, else discard + adventure log), runs the level-up loop,
// sets hero state to walking, and records loot history.
// Returns the drops for API response building.
func (h *GameHandler) processVictoryRewards(hero *model.Hero, enemy *model.Enemy, now time.Time) []model.LootDrop {
oldLevel := hero.Level
@ -110,6 +117,10 @@ func (h *GameHandler) processVictoryRewards(hero *model.Hero, enemy *model.Enemy
luckMult := game.LuckMultiplier(hero, now)
drops := model.GenerateLoot(enemy.Type, luckMult)
ctxTown, cancelTown := context.WithTimeout(context.Background(), 2*time.Second)
inTown := h.isHeroInTown(ctxTown, hero.PositionX, hero.PositionY)
cancelTown()
h.lootMu.Lock()
defer h.lootMu.Unlock()
@ -137,9 +148,13 @@ func (h *GameHandler) processVictoryRewards(hero *model.Hero, enemy *model.Enemy
if err := h.gearStore.CreateItem(ctx, item); err != nil {
h.logger.Warn("failed to create gear item", "slot", slot, "error", err)
cancel()
sellPrice := model.AutoSellPrices[drop.Rarity]
hero.Gold += sellPrice
drop.GoldAmount = sellPrice
if inTown {
sellPrice := model.AutoSellPrices[drop.Rarity]
hero.Gold += sellPrice
drop.GoldAmount = sellPrice
} else {
drop.GoldAmount = 0
}
goto recordLoot
}
cancel()
@ -152,11 +167,43 @@ func (h *GameHandler) processVictoryRewards(hero *model.Hero, enemy *model.Enemy
if equipped {
h.addLog(hero.ID, fmt.Sprintf("Equipped new %s: %s", slot, item.Name))
} else {
sellPrice := model.AutoSellPrices[drop.Rarity]
hero.Gold += sellPrice
drop.GoldAmount = sellPrice
hero.EnsureInventorySlice()
if len(hero.Inventory) >= model.MaxInventorySlots {
ctxDel, cancelDel := context.WithTimeout(context.Background(), 2*time.Second)
if h.gearStore != nil && item.ID != 0 {
if err := h.gearStore.DeleteGearItem(ctxDel, item.ID); err != nil {
h.logger.Warn("failed to delete gear (inventory full)", "gear_id", item.ID, "error", err)
}
}
cancelDel()
drop.ItemID = 0
drop.ItemName = ""
drop.GoldAmount = 0
h.addLog(hero.ID, fmt.Sprintf("Inventory full — dropped %s (%s)", item.Name, item.Rarity))
} else {
ctxInv, cancelInv := context.WithTimeout(context.Background(), 2*time.Second)
var err error
if h.gearStore != nil {
err = h.gearStore.AddToInventory(ctxInv, hero.ID, item.ID)
}
cancelInv()
if err != nil {
h.logger.Warn("failed to stash gear", "hero_id", hero.ID, "gear_id", item.ID, "error", err)
ctxDel, cancelDel := context.WithTimeout(context.Background(), 2*time.Second)
if h.gearStore != nil && item.ID != 0 {
_ = h.gearStore.DeleteGearItem(ctxDel, item.ID)
}
cancelDel()
drop.ItemID = 0
drop.ItemName = ""
drop.GoldAmount = 0
} else {
hero.Inventory = append(hero.Inventory, item)
drop.GoldAmount = 0
}
}
}
} else {
} else if inTown {
sellPrice := model.AutoSellPrices[drop.Rarity]
hero.Gold += sellPrice
drop.GoldAmount = sellPrice
@ -229,7 +276,7 @@ func resolveTelegramID(r *http.Request) (int64, bool) {
}
// Localhost fallback: default to telegram_id 1 for testing.
host := r.Host
if strings.HasPrefix(host, "localhost") || strings.HasPrefix(host, "127.0.0.1") || strings.HasPrefix(host, "[::1]") {
if strings.HasPrefix(host, "localhost") || strings.HasPrefix(host, "127.0.0.1") || strings.HasPrefix(host, "192.168.0.53") {
return 1, true
}
return 0, false
@ -262,9 +309,12 @@ func (h *GameHandler) GetHero(w http.ResponseWriter, r *http.Request) {
}
now := time.Now()
needsSave := hero.EnsureBuffChargesPopulated(now)
if hero.ApplyBuffQuotaRollover(now) {
needsSave = true
needsSave := false
if h.engine == nil || !h.engine.IsTimePaused() {
needsSave = hero.EnsureBuffChargesPopulated(now)
if hero.ApplyBuffQuotaRollover(now) {
needsSave = true
}
}
if needsSave {
if err := h.store.Save(r.Context(), hero); err != nil {
@ -567,23 +617,11 @@ func pickEnemyForLevel(level int) model.Enemy {
// to equip a new gear item. If it improves combat rating by >= 3%, equips it
// (persisting to DB if gearStore is available). Returns true if equipped.
func (h *GameHandler) tryAutoEquipGear(hero *model.Hero, item *model.GearItem, now time.Time) bool {
if hero.Gear == nil {
hero.Gear = make(map[model.EquipmentSlot]*model.GearItem)
}
current := hero.Gear[item.Slot]
if current == nil {
hero.Gear[item.Slot] = item
h.persistGearEquip(hero.ID, item)
return true
}
oldRating := hero.CombatRatingAt(now)
hero.Gear[item.Slot] = item
if hero.CombatRatingAt(now) >= oldRating*1.03 {
h.persistGearEquip(hero.ID, item)
return true
}
hero.Gear[item.Slot] = current
return false
if !game.TryAutoEquipInMemory(hero, item, now) {
return false
}
h.persistGearEquip(hero.ID, item)
return true
}
// persistGearEquip saves the equip to the hero_gear table if gearStore is available.
@ -826,6 +864,9 @@ func (h *GameHandler) buildOfflineReport(ctx context.Context, hero *model.Hero,
// This covers the period when the server was down and the offline simulator wasn't running.
// Returns true if any simulation was performed.
func (h *GameHandler) catchUpOfflineGap(ctx context.Context, hero *model.Hero) bool {
if h.engine != nil && h.engine.IsTimePaused() {
return false
}
gapDuration := h.serverStartedAt.Sub(hero.UpdatedAt)
if gapDuration < 30*time.Second {
return false
@ -860,7 +901,13 @@ func (h *GameHandler) catchUpOfflineGap(ctx context.Context, hero *model.Hero) b
break
}
survived, enemy, xpGained, goldGained := game.SimulateOneFight(hero, now, nil)
var rg *game.RoadGraph
if h.engine != nil {
rg = h.engine.RoadGraph()
}
survived, enemy, xpGained, goldGained := game.SimulateOneFight(hero, now, nil, rg, func(msg string) {
h.addLog(hero.ID, msg)
})
performed = true
h.addLog(hero.ID, fmt.Sprintf("Encountered %s", enemy.Name))
@ -942,11 +989,14 @@ func (h *GameHandler) InitHero(w http.ResponseWriter, r *http.Request) {
}
now := time.Now()
chargesInit := hero.EnsureBuffChargesPopulated(now)
quotaRolled := hero.ApplyBuffQuotaRollover(now)
if chargesInit || quotaRolled {
if err := h.store.Save(r.Context(), hero); err != nil {
h.logger.Warn("failed to persist buff charges init/rollover", "hero_id", hero.ID, "error", err)
simFrozen := h.engine != nil && h.engine.IsTimePaused()
if !simFrozen {
chargesInit := hero.EnsureBuffChargesPopulated(now)
quotaRolled := hero.ApplyBuffQuotaRollover(now)
if chargesInit || quotaRolled {
if err := h.store.Save(r.Context(), hero); err != nil {
h.logger.Warn("failed to persist buff charges init/rollover", "hero_id", hero.ID, "error", err)
}
}
}
@ -954,7 +1004,7 @@ func (h *GameHandler) InitHero(w http.ResponseWriter, r *http.Request) {
// (the period when the server was down and the offline simulator wasn't running).
offlineDuration := time.Since(hero.UpdatedAt)
var catchUpPerformed bool
if hero.UpdatedAt.Before(h.serverStartedAt) && hero.State == model.StateWalking && hero.HP > 0 {
if !simFrozen && hero.UpdatedAt.Before(h.serverStartedAt) && hero.State == model.StateWalking && hero.HP > 0 {
catchUpPerformed = h.catchUpOfflineGap(r.Context(), hero)
}
@ -969,7 +1019,7 @@ func (h *GameHandler) InitHero(w http.ResponseWriter, r *http.Request) {
}
// 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 {
if !simFrozen && (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
@ -1259,6 +1309,72 @@ func (h *GameHandler) PurchaseBuffRefill(w http.ResponseWriter, r *http.Request)
writeJSON(w, http.StatusOK, hero)
}
// PurchaseSubscription purchases a weekly subscription (x2 buffs, x2 revives).
// POST /api/v1/hero/purchase-subscription
func (h *GameHandler) PurchaseSubscription(w http.ResponseWriter, r *http.Request) {
telegramID, ok := resolveTelegramID(r)
if !ok {
writeJSON(w, http.StatusBadRequest, map[string]string{"error": "missing telegramId"})
return
}
hero, err := h.store.GetByTelegramID(r.Context(), telegramID)
if err != nil {
h.logger.Error("subscription: load hero failed", "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()
payment := &model.Payment{
HeroID: hero.ID,
Type: "subscription_weekly",
AmountRUB: model.SubscriptionWeeklyPriceRUB,
Status: model.PaymentCompleted,
CreatedAt: now,
CompletedAt: &now,
}
if err := h.store.CreatePayment(r.Context(), payment); err != nil {
h.logger.Error("subscription: payment failed", "error", err)
writeJSON(w, http.StatusInternalServerError, map[string]string{"error": "failed to process payment"})
return
}
hero.ActivateSubscription(now)
// Upgrade buff charges to subscriber limits immediately.
hero.EnsureBuffChargesPopulated(now)
for bt := range model.BuffFreeChargesPerType {
state := hero.GetBuffCharges(bt, now)
subMax := hero.MaxBuffCharges(bt)
if state.Remaining < subMax {
state.Remaining = subMax
hero.BuffCharges[string(bt)] = state
}
}
if err := h.store.Save(r.Context(), hero); err != nil {
h.logger.Error("subscription: save failed", "error", err)
writeJSON(w, http.StatusInternalServerError, map[string]string{"error": "failed to save"})
return
}
h.logger.Info("subscription purchased", "hero_id", hero.ID, "expires_at", hero.SubscriptionExpiresAt)
h.addLog(hero.ID, fmt.Sprintf("Subscribed for 7 days (%d₽) — x2 buffs & revives!", model.SubscriptionWeeklyPriceRUB))
hero.RefreshDerivedCombatStats(now)
writeJSON(w, http.StatusOK, map[string]any{
"hero": hero,
"expiresAt": hero.SubscriptionExpiresAt,
"priceRub": model.SubscriptionWeeklyPriceRUB,
})
}
// GetLoot returns the hero's recent loot history.
// GET /api/v1/hero/loot
func (h *GameHandler) GetLoot(w http.ResponseWriter, r *http.Request) {

187
backend/internal/handler/npc.go
Unescape Escape View File

@ -13,6 +13,7 @@ import (
"strconv"
"time"
"github.com/denisovdennis/autohero/internal/game"
"github.com/denisovdennis/autohero/internal/model"
"github.com/denisovdennis/autohero/internal/storage"
)
@ -24,20 +25,37 @@ type NPCHandler struct {
gearStore *storage.GearStore
logStore *storage.LogStore
logger *slog.Logger
engine *game.Engine
hub *Hub
}
// NewNPCHandler creates a new NPCHandler.
func NewNPCHandler(questStore *storage.QuestStore, heroStore *storage.HeroStore, gearStore *storage.GearStore, logStore *storage.LogStore, logger *slog.Logger) *NPCHandler {
func NewNPCHandler(questStore *storage.QuestStore, heroStore *storage.HeroStore, gearStore *storage.GearStore, logStore *storage.LogStore, logger *slog.Logger, eng *game.Engine, hub *Hub) *NPCHandler {
return &NPCHandler{
questStore: questStore,
heroStore: heroStore,
gearStore: gearStore,
logStore: logStore,
logger: logger,
engine: eng,
hub: hub,
}
}
// addLog is a fire-and-forget helper that writes an adventure log entry.
func (h *NPCHandler) sendMerchantLootWS(heroID int64, cost int64, drop *model.LootDrop) {
if h.hub == nil || drop == nil {
return
}
h.hub.SendToHero(heroID, "merchant_loot", model.MerchantLootPayload{
GoldSpent: cost,
ItemType: drop.ItemType,
ItemName: drop.ItemName,
Rarity: string(drop.Rarity),
GoldAmount: drop.GoldAmount,
})
}
// addLog is a fire-and-forget helper that writes an adventure log entry and mirrors it to the client via WS.
func (h *NPCHandler) addLog(heroID int64, message string) {
if h.logStore == nil {
return
@ -46,6 +64,10 @@ func (h *NPCHandler) addLog(heroID int64, message string) {
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)
return
}
if h.hub != nil {
h.hub.SendToHero(heroID, "adventure_log_line", model.AdventureLogLinePayload{Message: message})
}
}
@ -275,8 +297,120 @@ func (h *NPCHandler) NearbyNPCs(w http.ResponseWriter, r *http.Request) {
writeJSON(w, http.StatusOK, result)
}
// npcPersistGearEquip writes hero_gear when a merchant drop is equipped.
func (h *NPCHandler) npcPersistGearEquip(heroID int64, item *model.GearItem) {
if h.gearStore == nil || item == nil || item.ID == 0 {
return
}
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
if err := h.gearStore.EquipItem(ctx, heroID, item.Slot, item.ID); err != nil {
h.logger.Warn("failed to persist merchant gear equip", "hero_id", heroID, "slot", item.Slot, "error", err)
}
}
// grantMerchantLoot rolls one random gear piece; auto-equips if better.
// Outside town, unwanted pieces are discarded (gold for sells only in town).
// Cost must already be deducted from hero.Gold.
func (h *NPCHandler) grantMerchantLoot(ctx context.Context, hero *model.Hero, now time.Time) (*model.LootDrop, error) {
slots := model.AllEquipmentSlots
slot := slots[rand.Intn(len(slots))]
family := model.PickGearFamily(slot)
if family == nil || h.gearStore == nil {
return nil, errors.New("failed to roll gear")
}
rarity := model.RollRarity()
ilvl := model.RollIlvl(hero.Level, false)
item := model.NewGearItem(family, ilvl, rarity)
ctxCreate, cancel := context.WithTimeout(ctx, 2*time.Second)
err := h.gearStore.CreateItem(ctxCreate, item)
cancel()
if err != nil {
h.logger.Warn("failed to create alms gear item", "slot", slot, "error", err)
return nil, err
}
equipped := game.TryAutoEquipInMemory(hero, item, now)
if equipped {
h.npcPersistGearEquip(hero.ID, item)
h.addLog(hero.ID, fmt.Sprintf("Gave alms to wandering merchant, equipped %s", item.Name))
} else {
hero.EnsureInventorySlice()
if len(hero.Inventory) >= model.MaxInventorySlots {
ctxDel, cancelDel := context.WithTimeout(ctx, 2*time.Second)
if item.ID != 0 {
if err := h.gearStore.DeleteGearItem(ctxDel, item.ID); err != nil {
h.logger.Warn("failed to delete merchant gear (inventory full)", "gear_id", item.ID, "error", err)
}
}
cancelDel()
h.addLog(hero.ID, fmt.Sprintf("Inventory full — dropped %s (%s) (wandering merchant)", item.Name, item.Rarity))
} else {
ctxInv, cancelInv := context.WithTimeout(ctx, 2*time.Second)
err := h.gearStore.AddToInventory(ctxInv, hero.ID, item.ID)
cancelInv()
if err != nil {
h.logger.Warn("failed to stash merchant gear", "hero_id", hero.ID, "error", err)
ctxDel, cancelDel := context.WithTimeout(ctx, 2*time.Second)
_ = h.gearStore.DeleteGearItem(ctxDel, item.ID)
cancelDel()
} else {
hero.Inventory = append(hero.Inventory, item)
h.addLog(hero.ID, fmt.Sprintf("Gave alms to wandering merchant; stashed %s", item.Name))
}
}
}
drop := &model.LootDrop{
ItemType: string(item.Slot),
ItemID: item.ID,
ItemName: item.Name,
Rarity: rarity,
}
return drop, nil
}
// ProcessAlmsByHeroID applies wandering merchant rewards for a DB hero id (WebSocket npc_alms_accept).
func (h *NPCHandler) ProcessAlmsByHeroID(ctx context.Context, heroID int64) error {
hero, err := h.heroStore.GetByID(ctx, heroID)
if err != nil {
h.logger.Error("failed to get hero for ws npc alms", "hero_id", heroID, "error", err)
return errors.New("failed to load hero")
}
if hero == nil {
return errors.New("hero not found")
}
cost := int64(20 + hero.Level*5)
if hero.Gold < cost {
return fmt.Errorf("not enough gold (need %d, have %d)", cost, hero.Gold)
}
hero.Gold -= cost
now := time.Now()
drop, err := h.grantMerchantLoot(ctx, hero, now)
if err != nil {
hero.Gold += cost
return err
}
hero.RefreshDerivedCombatStats(now)
if err := h.heroStore.Save(ctx, hero); err != nil {
h.logger.Error("failed to save hero after alms", "hero_id", hero.ID, "error", err)
return errors.New("failed to save hero")
}
if h.engine != nil {
h.engine.ApplyHeroAlmsUpdate(hero)
}
h.sendMerchantLootWS(hero.ID, cost, drop)
return nil
}
// NPCAlms handles POST /api/v1/hero/npc-alms.
// The hero gives alms to a wandering merchant in exchange for random equipment.
// The hero pays for one random equipment roll; better items equip, worse are sold for gold.
func (h *NPCHandler) NPCAlms(w http.ResponseWriter, r *http.Request) {
telegramID, ok := resolveTelegramID(r)
if !ok {
@ -324,7 +458,6 @@ func (h *NPCHandler) NPCAlms(w http.ResponseWriter, r *http.Request) {
return
}
// Compute cost: 20 + level * 5.
cost := int64(20 + hero.Level*5)
if hero.Gold < cost {
writeJSON(w, http.StatusBadRequest, map[string]string{
@ -334,39 +467,9 @@ func (h *NPCHandler) NPCAlms(w http.ResponseWriter, r *http.Request) {
}
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.
now := time.Now()
drop, err := h.grantMerchantLoot(r.Context(), hero, now)
if err != nil {
hero.Gold += cost
writeJSON(w, http.StatusInternalServerError, map[string]string{
"error": "failed to generate reward",
@ -374,6 +477,7 @@ func (h *NPCHandler) NPCAlms(w http.ResponseWriter, r *http.Request) {
return
}
hero.RefreshDerivedCombatStats(now)
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{
@ -382,12 +486,19 @@ func (h *NPCHandler) NPCAlms(w http.ResponseWriter, r *http.Request) {
return
}
if h.engine != nil {
h.engine.ApplyHeroAlmsUpdate(hero)
}
h.sendMerchantLootWS(hero.ID, cost, drop)
msg := fmt.Sprintf("You gave %d gold to the wandering merchant and received %s.", cost, drop.ItemName)
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),
Message: msg,
})
}

80
backend/internal/model/buff_quota.go
Unescape Escape View File

@ -8,6 +8,12 @@ import (
// FreeBuffActivationsPerPeriod is the legacy shared limit. Kept for backward compatibility.
const FreeBuffActivationsPerPeriod = 2
// SubscriptionWeeklyPriceRUB is the price for a 7-day subscription in rubles.
const SubscriptionWeeklyPriceRUB = 299
// SubscriptionDuration is how long a subscription lasts.
const SubscriptionDuration = 7 * 24 * time.Hour
// BuffFreeChargesPerType defines the per-buff free charge limits per 24h window.
var BuffFreeChargesPerType = map[BuffType]int{
BuffRush: 3,
@ -20,6 +26,67 @@ var BuffFreeChargesPerType = map[BuffType]int{
BuffWarCry: 2,
}
// BuffSubscriberChargesPerType defines the per-buff charge limits for subscribers (x2).
var BuffSubscriberChargesPerType = map[BuffType]int{
BuffRush: 6,
BuffRage: 4,
BuffShield: 4,
BuffLuck: 2,
BuffResurrection: 2,
BuffHeal: 6,
BuffPowerPotion: 2,
BuffWarCry: 4,
}
// RefreshSubscription checks if the subscription has expired and updates SubscriptionActive.
// Returns true if the hero state was changed (caller should persist).
func (h *Hero) RefreshSubscription(now time.Time) bool {
if !h.SubscriptionActive {
return false
}
if h.SubscriptionExpiresAt != nil && now.After(*h.SubscriptionExpiresAt) {
h.SubscriptionActive = false
h.SubscriptionExpiresAt = nil
return true
}
return false
}
// ActivateSubscription sets the hero as a subscriber for SubscriptionDuration.
// If already subscribed, extends from current expiry.
func (h *Hero) ActivateSubscription(now time.Time) {
if h.SubscriptionActive && h.SubscriptionExpiresAt != nil && h.SubscriptionExpiresAt.After(now) {
// Extend from current expiry.
extended := h.SubscriptionExpiresAt.Add(SubscriptionDuration)
h.SubscriptionExpiresAt = &extended
} else {
expires := now.Add(SubscriptionDuration)
h.SubscriptionExpiresAt = &expires
}
h.SubscriptionActive = true
}
// MaxBuffCharges returns the max charges for a buff type, considering subscription status.
func (h *Hero) MaxBuffCharges(bt BuffType) int {
if h.SubscriptionActive {
if v, ok := BuffSubscriberChargesPerType[bt]; ok {
return v
}
}
if v, ok := BuffFreeChargesPerType[bt]; ok {
return v
}
return FreeBuffActivationsPerPeriod
}
// MaxRevives returns the max free revives per period (1 free, 2 for subscribers).
func (h *Hero) MaxRevives() int {
if h.SubscriptionActive {
return 2
}
return 1
}
// 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
@ -48,10 +115,7 @@ func (h *Hero) GetBuffCharges(bt BuffType, now time.Time) BuffChargeState {
h.BuffCharges = make(map[string]BuffChargeState)
}
maxCharges := BuffFreeChargesPerType[bt]
if maxCharges == 0 {
maxCharges = FreeBuffActivationsPerPeriod // fallback
}
maxCharges := h.MaxBuffCharges(bt)
state, exists := h.BuffCharges[string(bt)]
if !exists {
@ -151,9 +215,9 @@ func (h *Hero) ResetBuffCharges(bt *BuffType, now time.Time) {
}
// Reset ALL buff types.
for buffType, maxCharges := range BuffFreeChargesPerType {
for buffType := range BuffFreeChargesPerType {
h.BuffCharges[string(buffType)] = BuffChargeState{
Remaining: maxCharges,
Remaining: h.MaxBuffCharges(buffType),
PeriodEnd: &pe,
}
}
@ -174,9 +238,9 @@ func (h *Hero) EnsureBuffChargesPopulated(now time.Time) bool {
if h.BuffQuotaPeriodEnd != nil {
pe = *h.BuffQuotaPeriodEnd
}
for bt, maxCharges := range BuffFreeChargesPerType {
for bt := range BuffFreeChargesPerType {
h.BuffCharges[string(bt)] = BuffChargeState{
Remaining: maxCharges,
Remaining: h.MaxBuffCharges(bt),
PeriodEnd: &pe,
}
}

22
backend/internal/model/hero.go
Unescape Escape View File

@ -10,6 +10,8 @@ const (
AgilityCoef = 0.03
// MaxAttackSpeed enforces the target cap of ~4 attacks/sec.
MaxAttackSpeed = 4.0
// MaxInventorySlots is the maximum unequipped gear items carried at once.
MaxInventorySlots = 40
)
type Hero struct {
@ -29,6 +31,8 @@ type Hero struct {
WeaponID *int64 `json:"weaponId,omitempty"` // Deprecated: kept for DB backward compat
ArmorID *int64 `json:"armorId,omitempty"` // Deprecated: kept for DB backward compat
Gear map[EquipmentSlot]*GearItem `json:"gear"`
// Inventory holds unequipped gear (order matches DB slot_index). Max length: MaxInventorySlots.
Inventory []*GearItem `json:"inventory,omitempty"`
Buffs []ActiveBuff `json:"buffs,omitempty"`
Debuffs []ActiveDebuff `json:"debuffs,omitempty"`
Gold int64 `json:"gold"`
@ -43,7 +47,8 @@ type Hero struct {
PositionY float64 `json:"positionY"`
Potions int `json:"potions"`
ReviveCount int `json:"reviveCount"`
SubscriptionActive bool `json:"subscriptionActive"`
SubscriptionActive bool `json:"subscriptionActive"`
SubscriptionExpiresAt *time.Time `json:"subscriptionExpiresAt,omitempty"`
// Deprecated: BuffFreeChargesRemaining is the legacy shared counter. Use BuffCharges instead.
BuffFreeChargesRemaining int `json:"buffFreeChargesRemaining"`
// Deprecated: BuffQuotaPeriodEnd is the legacy shared period end. Use BuffCharges instead.
@ -319,6 +324,21 @@ func (h *Hero) MovementSpeedMultiplier(now time.Time) float64 {
return mult
}
// EnsureGearMap guarantees Gear is a non-nil map so JSON encodes "gear":{} instead of null
// (clients treat null as missing equipment).
func (h *Hero) EnsureGearMap() {
if h.Gear == nil {
h.Gear = make(map[EquipmentSlot]*GearItem)
}
}
// EnsureInventorySlice guarantees Inventory is a non-nil slice for append/count.
func (h *Hero) EnsureInventorySlice() {
if h.Inventory == nil {
h.Inventory = []*GearItem{}
}
}
// RefreshDerivedCombatStats updates exported derived combat fields for API/state usage.
func (h *Hero) RefreshDerivedCombatStats(now time.Time) {
h.XPToNext = XPToNextLevel(h.Level)

19
backend/internal/model/ws_message.go
Unescape Escape View File

@ -138,9 +138,23 @@ type TownNPCVisitPayload struct {
TownID int64 `json:"townId"`
}
// AdventureLogLinePayload is sent when a new line is appended to the hero's adventure log.
type AdventureLogLinePayload struct {
Message string `json:"message"`
}
// TownExitPayload is sent when the hero leaves a town.
type TownExitPayload struct{}
// MerchantLootPayload is sent after a successful wandering merchant trade (WS or REST when online).
type MerchantLootPayload struct {
GoldSpent int64 `json:"goldSpent"`
ItemType string `json:"itemType"` // "potion", equipment slot key, etc.
ItemName string `json:"itemName,omitempty"`
Rarity string `json:"rarity,omitempty"`
GoldAmount int64 `json:"goldAmount,omitempty"` // auto-sell gold
}
// NPCEncounterPayload is sent when the hero meets a wandering NPC on the road (e.g. merchant).
type NPCEncounterPayload struct {
NPCID int64 `json:"npcId"`
@ -150,6 +164,11 @@ type NPCEncounterPayload struct {
Cost int64 `json:"cost"`
}
// NPCEncounterEndPayload is sent when the wandering merchant prompt ends (e.g. timeout).
type NPCEncounterEndPayload struct {
Reason string `json:"reason"` // "timeout"
}
// LevelUpPayload is sent on level-up.
type LevelUpPayload struct {
NewLevel int `json:"newLevel"`

24
backend/internal/router/router.go
Unescape Escape View File

@ -1,6 +1,7 @@
package router
import (
"context"
"log/slog"
"net/http"
"time"
@ -21,6 +22,7 @@ type Deps struct {
Hub *handler.Hub
PgPool *pgxpool.Pool
BotToken string
PaymentProviderToken string
AdminBasicAuthUsername string
AdminBasicAuthPassword string
AdminBasicAuthRealm string
@ -60,6 +62,11 @@ func New(deps Deps) *chi.Mux {
authH := handler.NewAuthHandler(deps.BotToken, heroStore, deps.Logger)
r.Post("/api/v1/auth/telegram", authH.TelegramAuth)
// Telegram Payments.
paymentsH := handler.NewPaymentsHandler(deps.BotToken, deps.PaymentProviderToken, heroStore, logStore, deps.Logger)
r.Post("/api/v1/payments/create-invoice", paymentsH.CreateInvoice)
r.Post("/api/v1/payments/telegram-webhook", paymentsH.TelegramWebhook)
// 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) {
@ -77,18 +84,28 @@ func New(deps Deps) *chi.Mux {
r.Post("/heroes/{heroId}/revive", adminH.ReviveHero)
r.Post("/heroes/{heroId}/reset", adminH.ResetHero)
r.Post("/heroes/{heroId}/reset-buff-charges", adminH.ResetBuffCharges)
r.Post("/heroes/{heroId}/start-adventure", adminH.StartHeroAdventure)
r.Post("/heroes/{heroId}/teleport-town", adminH.TeleportHeroTown)
r.Post("/heroes/{heroId}/start-rest", adminH.StartHeroRest)
r.Delete("/heroes/{heroId}", adminH.DeleteHero)
r.Get("/towns", adminH.ListTowns)
r.Post("/time/pause", adminH.PauseTime)
r.Post("/time/resume", adminH.ResumeTime)
r.Get("/engine/status", adminH.EngineStatus)
r.Get("/engine/combats", adminH.ActiveCombats)
r.Get("/ws/connections", adminH.WSConnections)
r.Get("/info", adminH.ServerInfo)
r.Post("/payments/set-webhook", paymentsH.SetWebhook)
})
// API v1 (authenticated routes).
gameH := handler.NewGameHandler(deps.Engine, heroStore, logStore, worldSvc, deps.Logger, deps.ServerStartedAt, questStore, gearStore, achievementStore, taskStore)
gameH := handler.NewGameHandler(deps.Engine, heroStore, logStore, worldSvc, deps.Logger, deps.ServerStartedAt, questStore, gearStore, achievementStore, taskStore, deps.Hub)
mapsH := handler.NewMapsHandler(worldSvc, deps.Logger)
questH := handler.NewQuestHandler(questStore, heroStore, logStore, deps.Logger)
npcH := handler.NewNPCHandler(questStore, heroStore, gearStore, logStore, deps.Logger)
npcH := handler.NewNPCHandler(questStore, heroStore, gearStore, logStore, deps.Logger, deps.Engine, deps.Hub)
deps.Engine.SetNPCAlmsHandler(func(ctx context.Context, heroID int64) error {
return npcH.ProcessAlmsByHeroID(ctx, heroID)
})
achieveH := handler.NewAchievementHandler(achievementStore, heroStore, deps.Logger)
taskH := handler.NewDailyTaskHandler(taskStore, heroStore, deps.Logger)
r.Route("/api/v1", func(r chi.Router) {
@ -96,6 +113,8 @@ func New(deps Deps) *chi.Mux {
// Disabled for now to allow development without a bot token.
// r.Use(handler.TelegramAuthMiddleware(deps.BotToken))
r.Use(handler.APITimePausedMiddleware(deps.Engine))
r.Get("/hero", gameH.GetHero)
r.Get("/hero/init", gameH.InitHero)
r.Post("/hero/name", gameH.SetHeroName)
@ -104,6 +123,7 @@ func New(deps Deps) *chi.Mux {
r.Post("/hero/victory", gameH.ReportVictory)
r.Post("/hero/revive", gameH.ReviveHero)
r.Post("/hero/purchase-buff-refill", gameH.PurchaseBuffRefill)
r.Post("/hero/purchase-subscription", gameH.PurchaseSubscription)
r.Get("/hero/loot", gameH.GetLoot)
r.Get("/hero/log", gameH.GetAdventureLog)
r.Post("/hero/use-potion", gameH.UsePotion)

120
backend/internal/storage/gear_store.go
Unescape Escape View File

@ -120,6 +120,18 @@ func (s *GearStore) EquipItem(ctx context.Context, heroID int64, slot model.Equi
return nil
}
// DeleteGearItem removes a gear row by id (e.g. discarded drop not sold). Fails if still equipped.
func (s *GearStore) DeleteGearItem(ctx context.Context, id int64) error {
cmd, err := s.pool.Exec(ctx, `DELETE FROM gear WHERE id = $1`, id)
if err != nil {
return fmt.Errorf("delete gear item: %w", err)
}
if cmd.RowsAffected() == 0 {
return fmt.Errorf("delete gear item: no row for id %d", id)
}
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, `
@ -130,3 +142,111 @@ func (s *GearStore) UnequipSlot(ctx context.Context, heroID int64, slot model.Eq
}
return nil
}
// GetHeroInventory loads unequipped gear ordered by slot_index.
func (s *GearStore) GetHeroInventory(ctx context.Context, heroID int64) ([]*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_inventory hi
JOIN gear g ON hi.gear_id = g.id
WHERE hi.hero_id = $1
ORDER BY hi.slot_index ASC
`, heroID)
if err != nil {
return nil, fmt.Errorf("get hero inventory: %w", err)
}
defer rows.Close()
var out []*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 inventory gear: %w", err)
}
item.Slot = model.EquipmentSlot(slot)
item.Rarity = model.Rarity(rarity)
out = append(out, &item)
}
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("hero inventory rows: %w", err)
}
return out, nil
}
// AddToInventory inserts gear into the next free backpack slot. Fails if inventory is full.
func (s *GearStore) AddToInventory(ctx context.Context, heroID, gearID int64) error {
var n int
if err := s.pool.QueryRow(ctx, `
SELECT COUNT(*) FROM hero_inventory WHERE hero_id = $1
`, heroID).Scan(&n); err != nil {
return fmt.Errorf("inventory count: %w", err)
}
if n >= model.MaxInventorySlots {
return fmt.Errorf("inventory full")
}
_, err := s.pool.Exec(ctx, `
INSERT INTO hero_inventory (hero_id, slot_index, gear_id)
VALUES ($1, $2, $3)
`, heroID, n, gearID)
if err != nil {
return fmt.Errorf("add to inventory: %w", err)
}
return nil
}
// ReplaceHeroInventory deletes all backpack rows for the hero and re-inserts from the slice.
// Used when persisting offline-simulated heroes with in-memory-only gear rows (id may be 0).
func (s *GearStore) ReplaceHeroInventory(ctx context.Context, heroID int64, items []*model.GearItem) error {
tx, err := s.pool.Begin(ctx)
if err != nil {
return fmt.Errorf("replace inventory begin: %w", err)
}
defer tx.Rollback(ctx)
if _, err := tx.Exec(ctx, `DELETE FROM hero_inventory WHERE hero_id = $1`, heroID); err != nil {
return fmt.Errorf("replace inventory delete: %w", err)
}
for i, item := range items {
if item == nil || i >= model.MaxInventorySlots {
continue
}
gid := item.ID
if gid == 0 {
err := tx.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(&gid)
if err != nil {
return fmt.Errorf("replace inventory create gear: %w", err)
}
item.ID = gid
}
if _, err := tx.Exec(ctx, `
INSERT INTO hero_inventory (hero_id, slot_index, gear_id)
VALUES ($1, $2, $3)
`, heroID, i, gid); err != nil {
return fmt.Errorf("replace inventory insert: %w", err)
}
}
if err := tx.Commit(ctx); err != nil {
return fmt.Errorf("replace inventory commit: %w", err)
}
return nil
}

64
backend/internal/storage/hero_store.go
Unescape Escape View File

@ -22,7 +22,7 @@ const heroSelectQuery = `
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.revive_count, h.subscription_active, h.subscription_expires_at,
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,
@ -77,6 +77,9 @@ func (s *HeroStore) GetByTelegramID(ctx context.Context, telegramID int64) (*mod
if err := s.loadHeroGear(ctx, hero); err != nil {
return nil, fmt.Errorf("get hero by telegram_id gear: %w", err)
}
if err := s.loadHeroInventory(ctx, hero); err != nil {
return nil, fmt.Errorf("get hero by telegram_id inventory: %w", err)
}
if err := s.loadHeroBuffsAndDebuffs(ctx, hero); err != nil {
return nil, fmt.Errorf("get hero by telegram_id buffs: %w", err)
}
@ -118,6 +121,9 @@ func (s *HeroStore) ListHeroes(ctx context.Context, limit, offset int) ([]*model
if err := s.loadHeroGear(ctx, h); err != nil {
return nil, fmt.Errorf("list heroes load gear: %w", err)
}
if err := s.loadHeroInventory(ctx, h); err != nil {
return nil, fmt.Errorf("list heroes load inventory: %w", err)
}
if err := s.loadHeroBuffsAndDebuffs(ctx, h); err != nil {
return nil, fmt.Errorf("list heroes load buffs: %w", err)
}
@ -147,6 +153,9 @@ func (s *HeroStore) GetByID(ctx context.Context, id int64) (*model.Hero, error)
if err := s.loadHeroGear(ctx, hero); err != nil {
return nil, fmt.Errorf("get hero by id gear: %w", err)
}
if err := s.loadHeroInventory(ctx, hero); err != nil {
return nil, fmt.Errorf("get hero by id inventory: %w", err)
}
if err := s.loadHeroBuffsAndDebuffs(ctx, hero); err != nil {
return nil, fmt.Errorf("get hero by id buffs: %w", err)
}
@ -176,7 +185,7 @@ func (s *HeroStore) Create(ctx context.Context, hero *model.Hero) error {
strength, constitution, agility, luck,
state, weapon_id, armor_id,
gold, xp, level,
revive_count, subscription_active,
revive_count, subscription_active, subscription_expires_at,
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,
@ -203,7 +212,7 @@ func (s *HeroStore) Create(ctx context.Context, hero *model.Hero) error {
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.ReviveCount, hero.SubscriptionActive, hero.SubscriptionExpiresAt,
hero.BuffFreeChargesRemaining, hero.BuffQuotaPeriodEnd, buffChargesJSON,
hero.PositionX, hero.PositionY, hero.Potions,
hero.TotalKills, hero.EliteKills, hero.TotalDeaths, hero.KillsSinceDeath, hero.LegendaryDrops,
@ -280,17 +289,17 @@ func (s *HeroStore) Save(ctx context.Context, hero *model.Hero) error {
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,
revive_count = $16, subscription_active = $17, subscription_expires_at = $18,
buff_free_charges_remaining = $19, buff_quota_period_end = $20, buff_charges = $21,
position_x = $22, position_y = $23, potions = $24,
total_kills = $25, elite_kills = $26, total_deaths = $27,
kills_since_death = $28, legendary_drops = $29,
last_online_at = $30,
updated_at = $31,
destination_town_id = $32,
current_town_id = $33,
move_state = $34
WHERE id = $31
WHERE id = $35
`
tag, err := s.pool.Exec(ctx, query,
@ -299,17 +308,17 @@ func (s *HeroStore) Save(ctx context.Context, hero *model.Hero) error {
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.ReviveCount, hero.SubscriptionActive, hero.SubscriptionExpiresAt,
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,
hero.ID,
)
if err != nil {
return fmt.Errorf("update hero: %w", err)
@ -323,6 +332,14 @@ func (s *HeroStore) Save(ctx context.Context, hero *model.Hero) error {
return fmt.Errorf("update hero buffs/debuffs: %w", err)
}
inv := hero.Inventory
if inv == nil {
inv = []*model.GearItem{}
}
if err := s.gearStore.ReplaceHeroInventory(ctx, hero.ID, inv); err != nil {
return fmt.Errorf("update hero inventory: %w", err)
}
s.logger.Info("saved hero", "hero", hero)
return nil
@ -400,6 +417,7 @@ func (s *HeroStore) ListOfflineHeroes(ctx context.Context, offlineThreshold time
query := heroSelectQuery + `
WHERE h.state = 'walking' AND h.hp > 0 AND h.updated_at < $1
AND (h.move_state IS NULL OR h.move_state NOT IN ('in_town', 'resting'))
ORDER BY h.updated_at ASC
LIMIT $2
`
@ -425,6 +443,9 @@ func (s *HeroStore) ListOfflineHeroes(ctx context.Context, offlineThreshold time
if err := s.loadHeroGear(ctx, h); err != nil {
return nil, fmt.Errorf("list offline heroes load gear: %w", err)
}
if err := s.loadHeroInventory(ctx, h); err != nil {
return nil, fmt.Errorf("list offline heroes load inventory: %w", err)
}
}
return heroes, nil
}
@ -442,7 +463,7 @@ func scanHeroFromRows(rows pgx.Rows) (*model.Hero, error) {
&h.Strength, &h.Constitution, &h.Agility, &h.Luck,
&state, &h.WeaponID, &h.ArmorID,
&h.Gold, &h.XP, &h.Level,
&h.ReviveCount, &h.SubscriptionActive,
&h.ReviveCount, &h.SubscriptionActive, &h.SubscriptionExpiresAt,
&h.BuffFreeChargesRemaining, &h.BuffQuotaPeriodEnd, &buffChargesRaw,
&h.PositionX, &h.PositionY, &h.Potions,
&h.TotalKills, &h.EliteKills, &h.TotalDeaths, &h.KillsSinceDeath, &h.LegendaryDrops,
@ -474,7 +495,7 @@ func scanHeroRow(row pgx.Row) (*model.Hero, error) {
&h.Strength, &h.Constitution, &h.Agility, &h.Luck,
&state, &h.WeaponID, &h.ArmorID,
&h.Gold, &h.XP, &h.Level,
&h.ReviveCount, &h.SubscriptionActive,
&h.ReviveCount, &h.SubscriptionActive, &h.SubscriptionExpiresAt,
&h.BuffFreeChargesRemaining, &h.BuffQuotaPeriodEnd, &buffChargesRaw,
&h.PositionX, &h.PositionY, &h.Potions,
&h.TotalKills, &h.EliteKills, &h.TotalDeaths, &h.KillsSinceDeath, &h.LegendaryDrops,
@ -505,6 +526,19 @@ func (s *HeroStore) loadHeroGear(ctx context.Context, hero *model.Hero) error {
return nil
}
// loadHeroInventory populates the hero's backpack from hero_inventory.
func (s *HeroStore) loadHeroInventory(ctx context.Context, hero *model.Hero) error {
inv, err := s.gearStore.GetHeroInventory(ctx, hero.ID)
if err != nil {
return fmt.Errorf("load hero inventory: %w", err)
}
hero.Inventory = inv
if hero.Inventory == nil {
hero.Inventory = []*model.GearItem{}
}
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 {

1
docker-compose.yml
Unescape Escape View File

@ -50,6 +50,7 @@ services:
DB_NAME: ${DB_NAME:-autohero}
REDIS_ADDR: redis:6379
BOT_TOKEN: ${BOT_TOKEN:-}
PAYMENT_PROVIDER_TOKEN: ${PAYMENT_PROVIDER_TOKEN:-}
ADMIN_BASIC_AUTH_USERNAME: ${ADMIN_BASIC_AUTH_USERNAME:-}
ADMIN_BASIC_AUTH_PASSWORD: ${ADMIN_BASIC_AUTH_PASSWORD:-}
ADMIN_BASIC_AUTH_REALM: ${ADMIN_BASIC_AUTH_REALM:-AutoHero Admin}

305
frontend/src/App.tsx
Unescape Escape View File

@ -1,4 +1,4 @@
import { useEffect, useRef, useState, useCallback, type CSSProperties } from 'react';
import { useEffect, useRef, useState, useCallback, useMemo, type CSSProperties } from 'react';
import { GameEngine } from './game/engine';
import { GamePhase, BuffType, type GameState, type FloatingDamageData, type ActiveBuff, type NPCData } from './game/types';
import type { NPCEncounterEvent } from './game/types';
@ -11,6 +11,7 @@ import {
sendNPCAlmsAccept,
sendNPCAlmsDecline,
buildLootFromCombatEnd,
buildMerchantLootDrop,
} from './game/ws-handler';
import {
ApiError,
@ -24,13 +25,11 @@ import {
abandonQuest,
getAchievements,
getNearbyHeroes,
getDailyTasks,
claimDailyTask,
buyPotion,
healAtNPC,
requestRevive,
} from './network/api';
import type { HeroResponse, Achievement, DailyTaskResponse } from './network/api';
import type { HeroResponse, Achievement } from './network/api';
import type { AdventureLogEntry, Town, HeroQuest, NPC, TownData, EquipmentItem } from './game/types';
import type { OfflineReport as OfflineReportData } from './network/api';
import {
@ -42,20 +41,21 @@ import {
import { hapticImpact, hapticNotification, onThemeChanged, getTelegramUserId } from './shared/telegram';
import { Rarity } from './game/types';
import type { HeroState, BuffChargeState } from './game/types';
import { useUiClock } from './hooks/useUiClock';
import { adventureEntriesFromServerLog } from './game/adventureLogMap';
import { HUD } from './ui/HUD';
import { DeathScreen } from './ui/DeathScreen';
import { FloatingDamage } from './ui/FloatingDamage';
import { GameToast } from './ui/GameToast';
import { AdventureLog } from './ui/AdventureLog';
import { OfflineReport } from './ui/OfflineReport';
import { QuestLog } from './ui/QuestLog';
import { HeroSheetModal, type HeroSheetTab } from './ui/HeroSheetModal';
import { NPCDialog } from './ui/NPCDialog';
import { NameEntryScreen } from './ui/NameEntryScreen';
import { DailyTasks } from './ui/DailyTasks';
import { AchievementsPanel } from './ui/AchievementsPanel';
import { Minimap } from './ui/Minimap';
import { NPCInteraction } from './ui/NPCInteraction';
import { WanderingNPCPopup } from './ui/WanderingNPCPopup';
import { I18nContext, t, detectLocale, getTranslations, type Locale } from './i18n';
const appStyle: CSSProperties = {
width: '100%',
@ -152,8 +152,13 @@ function mapEquipment(
): Record<string, EquipmentItem> {
const out: Record<string, EquipmentItem> = {};
if (raw) {
for (const [slot, item] of Object.entries(raw)) {
// REST uses `equipment`, WS hero_state from Go uses `gear`. Treat JSON null like missing.
const merged = raw ?? res.gear;
const rawSlots =
merged != null && typeof merged === 'object' ? merged : undefined;
if (rawSlots) {
for (const [slot, item] of Object.entries(rawSlots)) {
out[slot] = {
id: item.id,
slot: item.slot ?? slot,
@ -255,11 +260,34 @@ function heroResponseToState(res: HeroResponse): HeroState {
potions: res.potions ?? 0,
moveSpeed: res.moveSpeed,
equipment: mapEquipment(res.equipment, res),
inventory: mapInventoryFromResponse(res.inventory),
};
}
function mapInventoryFromResponse(raw: HeroResponse['inventory']): EquipmentItem[] | undefined {
if (!raw?.length) return undefined;
return raw.map((it) => ({
id: it.id,
slot: it.slot,
formId: it.formId ?? '',
name: it.name,
rarity: it.rarity as Rarity,
ilvl: it.ilvl ?? 1,
primaryStat: it.primaryStat ?? 0,
statType: it.statType ?? 'mixed',
}));
}
export function App() {
const [locale, setLocale] = useState<Locale>(() => detectLocale());
const translations = useMemo(() => getTranslations(locale), [locale]);
const handleSetLocale = useCallback((l: Locale) => {
setLocale(l);
try { localStorage.setItem('autohero_locale', l); } catch { /* ignore */ }
}, []);
const tr = translations;
const canvasRef = useRef<HTMLDivElement>(null);
const engineRef = useRef<GameEngine | null>(null);
const wsRef = useRef<GameWebSocket | null>(null);
@ -295,7 +323,8 @@ export function App() {
const [heroQuests, setHeroQuests] = useState<HeroQuest[]>([]);
const [currentTown, setCurrentTown] = useState<Town | null>(null);
const [selectedNPC, setSelectedNPC] = useState<NPC | null>(null);
const [questLogOpen, setQuestLogOpen] = useState(false);
const [heroSheetOpen, setHeroSheetOpen] = useState(false);
const [heroSheetInitialTab, setHeroSheetInitialTab] = useState<HeroSheetTab>('stats');
// NPC interaction state (server-driven via town_enter)
const [nearestNPC, setNearestNPC] = useState<NPCData | null>(null);
@ -303,12 +332,12 @@ export function App() {
// Wandering NPC encounter state
const [wanderingNPC, setWanderingNPC] = useState<NPCEncounterEvent | null>(null);
// Daily tasks (backend-driven)
const [dailyTasks, setDailyTasks] = useState<DailyTaskResponse[]>([]);
// Achievements
const [achievements, setAchievements] = useState<Achievement[]>([]);
const prevAchievementsRef = useRef<Achievement[]>([]);
const sheetNowMs = useUiClock(100);
const addLogEntry = useCallback((message: string) => {
logIdCounter.current += 1;
const entry: AdventureLogEntry = {
@ -444,10 +473,6 @@ export function App() {
.then((a) => { prevAchievementsRef.current = a; setAchievements(a); })
.catch(() => console.warn('[App] Could not fetch achievements'));
getDailyTasks(telegramId)
.then((t) => setDailyTasks(t))
.catch(() => console.warn('[App] Could not fetch daily tasks'));
// Poll nearby heroes every 5 seconds
const nearbyInterval = setInterval(() => {
getNearbyHeroes(telegramId)
@ -471,18 +496,12 @@ export function App() {
.catch(() => {});
nearbyIntervalRef.current = nearbyInterval;
// Fetch adventure log
// Fetch adventure log (same source as server DB; response shape { log: [...] })
try {
const serverLog = await getAdventureLog(telegramId, 50);
if (serverLog.length > 0) {
const mapped: AdventureLogEntry[] = serverLog.map((entry, i) => ({
id: i + 1,
message: entry.message,
timestamp: new Date(entry.createdAt).getTime(),
}));
logIdCounter.current = mapped.length;
setLogEntries(mapped);
}
const { entries, maxId } = adventureEntriesFromServerLog(serverLog);
logIdCounter.current = Math.max(logIdCounter.current, maxId);
setLogEntries(entries);
} catch {
console.warn('[App] Could not fetch adventure log');
}
@ -529,18 +548,17 @@ export function App() {
if (p.goldGained > 0) parts.push(`+${p.goldGained} gold`);
const equipDrop = p.loot.find((l) => l.itemType === 'weapon' || l.itemType === 'armor');
if (equipDrop?.name) parts.push(`found ${equipDrop.name}`);
if (parts.length > 0) addLogEntry(`Victory: ${parts.join(', ')}`);
// Victory line comes from server adventure log (Defeated …) + WS adventure_log_line
if (p.leveledUp && p.newLevel) {
setToast({ message: `Level up! Now level ${p.newLevel}`, color: '#ffd700' });
setToast({ message: t(tr.levelUp, { level: p.newLevel }), color: '#ffd700' });
hapticNotification('success');
}
// Refresh quests, equipment, daily tasks, achievements after combat
// Refresh quests, equipment, achievements after combat
const tid = getTelegramUserId() ?? 1;
getHeroQuests(tid).then((q) => setHeroQuests(q)).catch(() => {});
refreshEquipment();
getDailyTasks(tid).then((t) => setDailyTasks(t)).catch(() => {});
getAchievements(tid).then((a) => {
const prevIds = new Set(prevAchievementsRef.current.filter((x) => x.unlocked).map((x) => x.id));
const newlyUnlocked = a.filter((x) => x.unlocked && !prevIds.has(x.id));
@ -553,24 +571,24 @@ export function App() {
}).catch(() => {});
},
onHeroDied: (p) => {
onHeroDied: (_p) => {
hapticNotification('error');
addLogEntry(`Hero was slain by ${p.killedBy}`);
// Death line comes from server log + WS
},
onHeroRevived: () => {
addLogEntry('Hero revived!');
setToast({ message: 'Hero revived!', color: '#44cc44' });
setToast({ message: tr.heroRevived, color: '#44cc44' });
// "Hero revived" comes from server log + WS
},
onBuffApplied: (p) => {
addLogEntry(`Buff applied: ${p.buffType}`);
onBuffApplied: (_p) => {
// Buff activation comes from server log + WS
},
onTownEnter: (p) => {
const town = townsRef.current.find((t) => t.id === p.townId) ?? null;
setCurrentTown(town);
setToast({ message: `Entering ${p.townName}`, color: '#daa520' });
setToast({ message: t(tr.entering, { townName: p.townName }), color: '#daa520' });
addLogEntry(`Entered ${p.townName}`);
const npcs = p.npcs ?? [];
if (npcs.length > 0) {
@ -586,10 +604,13 @@ export function App() {
}
},
onAdventureLogLine: (p) => {
addLogEntry(p.message);
},
onTownNPCVisit: (p) => {
const role =
p.type === 'merchant' ? 'Shop' : p.type === 'healer' ? 'Healer' : 'Quest';
addLogEntry(`${role}: ${p.name}`);
p.type === 'merchant' ? tr.shopLabel : p.type === 'healer' ? tr.healerLabel : tr.questLabel;
setToast({ message: `${role}: ${p.name}`, color: '#c9a227' });
setNearestNPC({
id: p.npcId,
@ -616,20 +637,27 @@ export function App() {
setWanderingNPC(npcEvent);
},
onNPCEncounterEnd: (p) => {
if (p.reason === 'timeout') {
addLogEntry('Wandering merchant moved on');
}
setWanderingNPC(null);
},
onLevelUp: (p) => {
setToast({ message: `Level up! Now level ${p.newLevel}`, color: '#ffd700' });
setToast({ message: t(tr.levelUp, { level: p.newLevel }), color: '#ffd700' });
hapticNotification('success');
addLogEntry(`Reached level ${p.newLevel}`);
// Level-up lines come from server log + WS
},
onEquipmentChange: (p) => {
setToast({ message: `New ${p.slot}: ${p.item.name}`, color: '#cc88ff' });
addLogEntry(`Equipped ${p.item.name} (${p.slot})`);
setToast({ message: t(tr.newEquipment, { slot: p.slot, itemName: p.item.name }), color: '#cc88ff' });
// Equipment line comes from server log + WS
refreshEquipment();
},
onPotionCollected: (p) => {
setToast({ message: `+${p.count} potion${p.count > 1 ? 's' : ''}`, color: '#44cc44' });
setToast({ message: t(tr.potionsCollected, { count: p.count }), color: '#44cc44' });
},
onQuestProgress: (p) => {
@ -642,7 +670,7 @@ export function App() {
);
if (p.title) {
setToast({
message: `${p.title} (${p.current}/${p.target})`,
message: t(tr.questProgress, { title: p.title, current: p.current, target: p.target }),
color: '#44aaff',
});
}
@ -656,13 +684,23 @@ export function App() {
: hq,
),
);
setToast({ message: `Quest completed: ${p.title}!`, color: '#ffd700' });
setToast({ message: t(tr.questCompleted, { title: p.title }), color: '#ffd700' });
hapticNotification('success');
},
onError: (p) => {
setToast({ message: p.message, color: '#ff4444' });
},
onMerchantLoot: (p) => {
const loot = buildMerchantLootDrop(p);
const eng = engineRef.current;
if (loot && eng) {
eng.applyLoot(loot);
}
hapticNotification('success');
refreshEquipment();
},
});
ws.connect();
@ -706,7 +744,7 @@ export function App() {
const charge = hero.buffCharges?.[type];
if (charge != null && charge.remaining <= 0) {
const label = type.charAt(0).toUpperCase() + type.slice(1).replace('_', ' ');
setToast({ message: `No charges left for ${label}`, color: '#ff8844' });
setToast({ message: t(tr.noChargesLeft, { label }), color: '#ff8844' });
return;
}
}
@ -781,14 +819,14 @@ export function App() {
}
hapticImpact('medium');
addLogEntry(`Activated ${type} buff`);
// Server logs buff activation + sends adventure_log_line
}
// Send command to server via WebSocket
if (ws) {
sendActivateBuff(ws, type);
}
}, [addLogEntry]);
}, []);
const handleRevive = useCallback(() => {
const ws = wsRef.current;
@ -824,13 +862,13 @@ export function App() {
if (pos) merged.position = pos;
engine.applyHeroState(merged);
}
setToast({ message: 'Quest rewards claimed!', color: '#ffd700' });
setToast({ message: tr.questRewardsClaimed, color: '#ffd700' });
hapticNotification('success');
refreshHeroQuests();
})
.catch((err) => {
console.warn('[App] Failed to claim quest:', err);
setToast({ message: 'Failed to claim rewards', color: '#ff4444' });
setToast({ message: tr.failedToClaimRewards, color: '#ff4444' });
});
},
[refreshHeroQuests],
@ -841,12 +879,12 @@ export function App() {
const telegramId = getTelegramUserId() ?? 1;
abandonQuest(heroQuestId, telegramId)
.then(() => {
setToast({ message: 'Quest abandoned', color: '#ff8844' });
setToast({ message: tr.questAbandoned, color: '#ff8844' });
refreshHeroQuests();
})
.catch((err) => {
console.warn('[App] Failed to abandon quest:', err);
setToast({ message: 'Failed to abandon quest', color: '#ff4444' });
setToast({ message: tr.failedToAbandonQuest, color: '#ff4444' });
});
},
[refreshHeroQuests],
@ -902,47 +940,17 @@ export function App() {
.catch(() => console.warn('[App] Could not fetch hero quests'));
getAdventureLog(telegramId, 50)
.then((serverLog) => {
if (serverLog.length > 0) {
const mapped: AdventureLogEntry[] = serverLog.map((entry, i) => ({
id: i + 1,
message: entry.message,
timestamp: new Date(entry.createdAt).getTime(),
}));
logIdCounter.current = mapped.length;
setLogEntries(mapped);
}
const { entries, maxId } = adventureEntriesFromServerLog(serverLog);
logIdCounter.current = Math.max(logIdCounter.current, maxId);
setLogEntries(entries);
})
.catch(() => console.warn('[App] Could not fetch adventure log'));
getAchievements(telegramId)
.then((a) => { prevAchievementsRef.current = a; setAchievements(a); })
.catch(() => {});
getDailyTasks(telegramId)
.then((t) => setDailyTasks(t))
.catch(() => {});
}
}, []);
const handleClaimDailyTask = useCallback((taskId: string) => {
const telegramId = getTelegramUserId() ?? 1;
claimDailyTask(taskId, telegramId)
.then((hero) => {
const merged = heroResponseToState(hero);
const engine = engineRef.current;
if (engine) {
const pos = engine.gameState.hero?.position;
if (pos) merged.position = pos;
engine.applyHeroState(merged);
}
setToast({ message: 'Daily task reward claimed!', color: '#ffd700' });
hapticNotification('success');
getDailyTasks(telegramId).then((t) => setDailyTasks(t)).catch(() => {});
})
.catch((err) => {
console.warn('[App] Failed to claim daily task:', err);
setToast({ message: 'Failed to claim reward', color: '#ff4444' });
});
}, []);
const handleUsePotion = useCallback(() => {
const ws = wsRef.current;
const hero = engineRef.current?.gameState.hero;
@ -954,9 +962,9 @@ export function App() {
}
hero.potions--
addLogEntry('Used healing potion');
hapticImpact('medium');
}, [addLogEntry]);
// Server logs potion use + sends adventure_log_line
}, []);
// ---- NPC Interaction Handlers ----
@ -973,49 +981,49 @@ export function App() {
setNpcInteractionDismissed(npc.id);
}, []);
const handleNPCBuyPotion = useCallback((npc: NPCData) => {
const handleNPCBuyPotion = useCallback((_npc: NPCData) => {
const telegramId = getTelegramUserId() ?? 1;
buyPotion(telegramId)
.then((hero) => {
hapticImpact('medium');
setToast({ message: 'Bought a potion for 50 gold', color: '#88dd88' });
setToast({ message: t(tr.boughtPotion, { cost: 50 }), color: '#88dd88' });
handleNPCHeroUpdated(hero);
addLogEntry(`Bought potion from ${npc.name}`);
// Server logs purchase + WS
})
.catch((err) => {
console.warn('[App] Failed to buy potion:', err);
if (err instanceof ApiError) {
try {
const j = JSON.parse(err.body) as { error?: string };
setToast({ message: j.error ?? 'Failed to buy potion', color: '#ff4444' });
setToast({ message: j.error ?? tr.failedToBuyPotion, color: '#ff4444' });
} catch {
setToast({ message: 'Failed to buy potion', color: '#ff4444' });
setToast({ message: tr.failedToBuyPotion, color: '#ff4444' });
}
}
});
}, [handleNPCHeroUpdated, addLogEntry]);
}, [handleNPCHeroUpdated]);
const handleNPCHeal = useCallback((npc: NPCData) => {
const handleNPCHeal = useCallback((_npc: NPCData) => {
const telegramId = getTelegramUserId() ?? 1;
healAtNPC(telegramId)
.then((hero) => {
hapticImpact('medium');
setToast({ message: 'Healed to full HP!', color: '#44cc44' });
setToast({ message: tr.healedToFull, color: '#44cc44' });
handleNPCHeroUpdated(hero);
addLogEntry(`Healed at ${npc.name}`);
// Server logs heal + WS
})
.catch((err) => {
console.warn('[App] Failed to heal:', err);
if (err instanceof ApiError) {
try {
const j = JSON.parse(err.body) as { error?: string };
setToast({ message: j.error ?? 'Failed to heal', color: '#ff4444' });
setToast({ message: j.error ?? tr.failedToHeal, color: '#ff4444' });
} catch {
setToast({ message: 'Failed to heal', color: '#ff4444' });
setToast({ message: tr.failedToHeal, color: '#ff4444' });
}
}
});
}, [handleNPCHeroUpdated, addLogEntry]);
}, [handleNPCHeroUpdated]);
const handleNPCInteractionDismiss = useCallback(() => {
if (nearestNPC) {
@ -1031,8 +1039,8 @@ export function App() {
sendNPCAlmsAccept(ws);
}
setWanderingNPC(null);
addLogEntry('Accepted wandering merchant offer');
}, [addLogEntry]);
// Alms outcome is logged on server + WS when trade completes
}, []);
const handleWanderingDecline = useCallback(() => {
const ws = wsRef.current;
@ -1051,6 +1059,7 @@ export function App() {
!selectedNPC;
return (
<I18nContext.Provider value={{ tr: translations, locale, setLocale: handleSetLocale }}>
<div style={appStyle}>
{/* PixiJS Canvas */}
<div ref={canvasRef} style={canvasContainerStyle} />
@ -1062,8 +1071,27 @@ export function App() {
buffCooldownEndsAt={buffCooldownEndsAt}
onUsePotion={handleUsePotion}
onHeroUpdated={handleNPCHeroUpdated}
onOpenHeroSheet={() => {
setHeroSheetInitialTab('stats');
setHeroSheetOpen(true);
}}
/>
{gameState.hero && (
<HeroSheetModal
open={heroSheetOpen}
onClose={() => setHeroSheetOpen(false)}
initialTab={heroSheetInitialTab}
hero={gameState.hero}
nowMs={sheetNowMs}
equipment={gameState.hero.equipment ?? {}}
logEntries={logEntries}
quests={heroQuests}
onQuestClaim={handleQuestClaim}
onQuestAbandon={handleQuestAbandon}
/>
)}
{/* Floating Damage Numbers */}
<FloatingDamage damages={damages} />
@ -1114,70 +1142,6 @@ export function App() {
</div>
)}
{/* Quest Log Toggle Button */}
{gameState.hero && (
<button
onClick={() => setQuestLogOpen((v) => !v)}
style={{
position: 'absolute',
bottom: 80,
right: 16,
width: 44,
height: 44,
borderRadius: 22,
border: '2px solid rgba(255, 215, 0, 0.35)',
backgroundColor: 'rgba(15, 15, 25, 0.85)',
color: '#ffd700',
fontSize: 20,
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
cursor: 'pointer',
zIndex: 50,
boxShadow: '0 2px 10px rgba(0,0,0,0.4)',
pointerEvents: 'auto',
}}
aria-label="Quest Log"
>
{'\uD83D\uDCDC'}
{heroQuests.filter((q) => q.status !== 'claimed').length > 0 && (
<span
style={{
position: 'absolute',
top: -4,
right: -4,
minWidth: 18,
height: 18,
borderRadius: 9,
backgroundColor: heroQuests.some((q) => q.status === 'completed')
? '#ffd700'
: '#4a90d9',
color: '#fff',
fontSize: 10,
fontWeight: 700,
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
padding: '0 4px',
border: '1px solid rgba(0,0,0,0.3)',
}}
>
{heroQuests.filter((q) => q.status !== 'claimed').length}
</span>
)}
</button>
)}
{/* Quest Log Panel */}
{questLogOpen && (
<QuestLog
quests={heroQuests}
onClaim={handleQuestClaim}
onAbandon={handleQuestAbandon}
onClose={() => setQuestLogOpen(false)}
/>
)}
{/* NPC Proximity Interaction */}
{showNPCInteraction && nearestNPC && (
<NPCInteraction
@ -1215,10 +1179,7 @@ export function App() {
/>
)}
{/* Daily Tasks (top-right) */}
{gameState.hero && <DailyTasks tasks={dailyTasks} onClaim={handleClaimDailyTask} />}
{/* Minimap (below daily tasks, top-right) */}
{/* Minimap (top-right) */}
{gameState.hero && (
<Minimap
heroX={gameState.hero.position.x}
@ -1231,9 +1192,6 @@ export function App() {
{/* Achievements Panel */}
{gameState.hero && <AchievementsPanel achievements={achievements} />}
{/* Adventure Log */}
<AdventureLog entries={logEntries} />
{/* Offline Report Overlay */}
{offlineReport && (
<OfflineReport
@ -1276,5 +1234,6 @@ export function App() {
</div>
)}
</div>
</I18nContext.Provider>
);
}

19
frontend/src/game/engine.ts
Unescape Escape View File

@ -477,15 +477,16 @@ export class GameEngine {
this._notifyStateChange();
}
/** Server simulated approach to a town NPC (quest / shop / healer). */
applyTownNPCVisit(npcName: string, npcType: string): void {
const label =
npcType === 'merchant'
? 'Shop'
: npcType === 'healer'
? 'Healer'
: 'Quest';
this._thoughtText = `${label}: ${npcName}`;
/** Server simulated approach to a town NPC (quest / shop / healer). Narration uses adventure_log_line. */
applyTownNPCVisit(_npcName: string, _npcType: string): void {
void _npcName;
void _npcType;
}
/** Same text as adventure log line — shown in the thought bubble above the hero (town NPC visits). */
applyAdventureLogLine(message: string): void {
if (!message) return;
this._thoughtText = message;
this._thoughtStartMs = performance.now();
this._notifyStateChange();
}

15
frontend/src/game/renderer.ts
Unescape Escape View File

@ -304,7 +304,7 @@ export class GameRenderer {
fontFamily: 'system-ui, sans-serif',
fill: 0x333333,
wordWrap: true,
wordWrapWidth: 130,
wordWrapWidth: 210,
align: 'center',
}),
});
@ -562,8 +562,14 @@ export class GameRenderer {
const bx = iso.x;
const by = iso.y - 52; // above hero head
const w = 140;
const h = 28;
txt.text = text;
txt.style.wordWrapWidth = 210;
const padX = 10;
const padY = 8;
const rawW = txt.width;
const rawH = txt.height;
const w = Math.min(240, Math.max(100, Math.ceil(rawW) + padX * 2));
const h = Math.max(30, Math.ceil(rawH) + padY * 2);
const left = bx - w / 2;
const top = by - h / 2;
@ -584,8 +590,7 @@ export class GameRenderer {
gfx.zIndex = by + 200; // above hero
// Text
txt.text = text;
// Text position (centered in bubble)
txt.x = bx;
txt.y = by;
txt.alpha = alpha;

22
frontend/src/game/types.ts
Unescape Escape View File

@ -153,6 +153,8 @@ export interface HeroState {
moveSpeed?: number;
/** Extended equipment slots (§6.3): slot key -> equipped item */
equipment?: Record<string, EquipmentItem>;
/** Backpack items (server max 40) */
inventory?: EquipmentItem[];
}
export interface ActiveBuff {
@ -380,12 +382,14 @@ export type ServerMessageType =
| 'town_exit'
| 'town_npc_visit'
| 'npc_encounter'
| 'npc_encounter_end'
| 'level_up'
| 'equipment_change'
| 'potion_collected'
| 'quest_available'
| 'quest_progress'
| 'quest_complete'
| 'merchant_loot'
| 'error'
| 'pong';
@ -443,6 +447,15 @@ export interface CombatEndPayload {
newLevel?: number;
}
/** Wandering merchant trade result (after npc alms). */
export interface MerchantLootPayload {
goldSpent: number;
itemType: string;
itemName?: string;
rarity?: string;
goldAmount?: number;
}
export interface HeroDiedPayload {
killedBy: string;
}
@ -472,6 +485,11 @@ export interface TownNPCVisitPayload {
townId: number;
}
/** Server-persisted adventure log line (e.g. town NPC visit narration). */
export interface AdventureLogLinePayload {
message: string;
}
export interface TownExitPayload {}
export interface NPCEncounterPayload {
@ -482,6 +500,10 @@ export interface NPCEncounterPayload {
cost: number;
}
export interface NPCEncounterEndPayload {
reason: 'timeout' | 'declined' | string;
}
export interface LevelUpPayload {
newLevel: number;
statChanges: {

46
frontend/src/game/ws-handler.ts
Unescape Escape View File

@ -12,7 +12,9 @@ import type {
BuffAppliedPayload,
TownEnterPayload,
TownNPCVisitPayload,
AdventureLogLinePayload,
NPCEncounterPayload,
NPCEncounterEndPayload,
LevelUpPayload,
EquipmentChangePayload,
PotionCollectedPayload,
@ -22,6 +24,7 @@ import type {
ServerErrorPayload,
EnemyState,
LootDrop,
MerchantLootPayload,
} from './types';
import { EnemyType, Rarity } from './types';
@ -34,8 +37,10 @@ export interface WSHandlerCallbacks {
onBuffApplied?: (payload: BuffAppliedPayload) => void;
onTownEnter?: (payload: TownEnterPayload) => void;
onTownNPCVisit?: (payload: TownNPCVisitPayload) => void;
onAdventureLogLine?: (payload: AdventureLogLinePayload) => void;
onTownExit?: () => void;
onNPCEncounter?: (payload: NPCEncounterPayload) => void;
onNPCEncounterEnd?: (payload: NPCEncounterEndPayload) => void;
onLevelUp?: (payload: LevelUpPayload) => void;
onEquipmentChange?: (payload: EquipmentChangePayload) => void;
onPotionCollected?: (payload: PotionCollectedPayload) => void;
@ -44,6 +49,7 @@ export interface WSHandlerCallbacks {
onQuestAvailable?: (payload: QuestAvailablePayload) => void;
onError?: (payload: ServerErrorPayload) => void;
onHeroStateReceived?: (hero: Record<string, unknown>) => void;
onMerchantLoot?: (payload: MerchantLootPayload) => void;
}
/**
@ -111,6 +117,11 @@ export function wireWSHandler(
callbacks.onCombatEnd?.(p);
});
ws.on('merchant_loot', (msg: ServerMessage) => {
const p = msg.payload as MerchantLootPayload;
callbacks.onMerchantLoot?.(p);
});
// ---- Server -> Client: Death / Revive ----
ws.on('hero_died', (msg: ServerMessage) => {
@ -151,6 +162,12 @@ export function wireWSHandler(
callbacks.onTownNPCVisit?.(p);
});
ws.on('adventure_log_line', (msg: ServerMessage) => {
const p = msg.payload as AdventureLogLinePayload;
engine.applyAdventureLogLine(p.message);
callbacks.onAdventureLogLine?.(p);
});
// ---- Server -> Client: NPC Encounter ----
ws.on('npc_encounter', (msg: ServerMessage) => {
@ -158,6 +175,11 @@ export function wireWSHandler(
callbacks.onNPCEncounter?.(p);
});
ws.on('npc_encounter_end', (msg: ServerMessage) => {
const p = msg.payload as NPCEncounterEndPayload;
callbacks.onNPCEncounterEnd?.(p);
});
// ---- Server -> Client: Progression ----
ws.on('level_up', (msg: ServerMessage) => {
@ -261,3 +283,27 @@ export function buildLootFromCombatEnd(p: CombatEndPayload): LootDrop | null {
: undefined,
};
}
/**
* Build a LootDrop for the popup after a wandering merchant trade (gear only; equip or auto-sell).
*/
export function buildMerchantLootDrop(p: MerchantLootPayload): LootDrop | null {
const rarity = (p.rarity?.toLowerCase() ?? 'common') as Rarity;
if (p.goldAmount != null && p.goldAmount > 0) {
return {
itemType: 'gold',
rarity,
goldAmount: p.goldAmount,
itemName: p.itemName ? `Sold: ${p.itemName}` : undefined,
};
}
if (p.itemName) {
return {
itemType: 'gold',
rarity,
goldAmount: 0,
itemName: p.itemName,
};
}
return null;
}

19
frontend/src/network/api.ts
Unescape Escape View File

@ -137,6 +137,19 @@ export interface HeroResponse {
primaryStat?: number;
statType?: string;
}>;
/** Same slot data as `equipment`; WebSocket `hero_state` from Go uses `gear` */
gear?: HeroResponse['equipment'];
/** Unequipped gear (backpack), max 40 — mirrors Go `Hero.Inventory` */
inventory?: Array<{
id: number;
slot: string;
formId?: string;
name: string;
rarity: string;
ilvl?: number;
primaryStat?: number;
statType?: string;
}>;
}
export interface AuthResponse {
@ -403,7 +416,11 @@ export async function getAdventureLog(telegramId?: number, limit?: number): Prom
if (telegramId != null) params.set('telegramId', String(telegramId));
if (limit != null) params.set('limit', String(limit));
const query = params.toString() ? `?${params.toString()}` : '';
return apiGet<LogEntry[]>(`/hero/log${query}`);
const raw = await apiGet<{ log?: LogEntry[] } | LogEntry[]>(`/hero/log${query}`);
if (Array.isArray(raw)) {
return raw;
}
return raw.log ?? [];
}
// ---- Potions ----

130
frontend/src/ui/AdventureLog.tsx
Unescape Escape View File

@ -1,9 +1,6 @@
import { useEffect, useRef, useState, type CSSProperties } from 'react';
import { useEffect, useRef, type CSSProperties, type RefObject } from 'react';
import type { AdventureLogEntry } from '../game/types';
interface AdventureLogProps {
entries: AdventureLogEntry[];
}
import { useT } from '../i18n';
function formatTime(timestamp: number): string {
const d = new Date(timestamp);
@ -12,62 +9,14 @@ function formatTime(timestamp: number): string {
return `${hh}:${mm}`;
}
const buttonStyle: CSSProperties = {
position: 'fixed',
bottom: 60,
left: 12,
zIndex: 50,
display: 'flex',
alignItems: 'center',
gap: 4,
padding: '6px 12px',
borderRadius: 8,
border: '1px solid rgba(255,255,255,0.15)',
backgroundColor: 'rgba(0,0,0,0.55)',
color: '#ccc',
fontSize: 12,
fontWeight: 600,
cursor: 'pointer',
pointerEvents: 'auto',
userSelect: 'none',
};
const panelStyle: CSSProperties = {
position: 'fixed',
bottom: 60,
left: 12,
zIndex: 50,
width: 'calc(100vw - 24px)',
maxWidth: 360,
maxHeight: '40vh',
display: 'flex',
flexDirection: 'column',
borderRadius: 10,
border: '1px solid rgba(255,255,255,0.12)',
backgroundColor: 'rgba(10, 10, 20, 0.82)',
backdropFilter: 'blur(6px)',
overflow: 'hidden',
pointerEvents: 'auto',
};
const panelHeaderStyle: CSSProperties = {
display: 'flex',
justifyContent: 'space-between',
alignItems: 'center',
padding: '8px 12px',
borderBottom: '1px solid rgba(255,255,255,0.08)',
fontSize: 13,
fontWeight: 700,
color: '#ddd',
};
const scrollAreaStyle: CSSProperties = {
flex: 1,
overflowY: 'auto',
padding: '6px 10px',
padding: '4px 2px',
fontSize: 12,
lineHeight: 1.6,
color: '#bbb',
maxHeight: 'min(52vh, 420px)',
};
const entryStyle: CSSProperties = {
@ -83,56 +32,37 @@ const timestampStyle: CSSProperties = {
fontSize: 11,
};
const closeButtonStyle: CSSProperties = {
background: 'none',
border: 'none',
color: '#999',
fontSize: 16,
cursor: 'pointer',
padding: '0 4px',
lineHeight: 1,
};
export function AdventureLog({ entries }: AdventureLogProps) {
const [expanded, setExpanded] = useState(false);
const scrollRef = useRef<HTMLDivElement>(null);
/** Scrollable adventure log list (Hero sheet Journal tab). */
export function AdventureLogEntries({
entries,
scrollRef,
}: {
entries: AdventureLogEntry[];
scrollRef?: RefObject<HTMLDivElement | null>;
}) {
const tr = useT();
const innerRef = useRef<HTMLDivElement>(null);
const ref = scrollRef ?? innerRef;
// Auto-scroll to bottom when new entries arrive while expanded
useEffect(() => {
if (expanded && scrollRef.current) {
scrollRef.current.scrollTop = scrollRef.current.scrollHeight;
if (ref.current) {
ref.current.scrollTop = ref.current.scrollHeight;
}
}, [entries.length, expanded]);
if (!expanded) {
return (
<button style={buttonStyle} onClick={() => setExpanded(true)}>
<span style={{ fontSize: 14 }}>&#x1F4DC;</span> Log
</button>
);
}
}, [entries.length, ref]);
return (
<div style={panelStyle}>
<div style={panelHeaderStyle}>
<span>&#x1F4DC; Adventure Log</span>
<button style={closeButtonStyle} onClick={() => setExpanded(false)}>
&#x2715;
</button>
</div>
<div ref={scrollRef} style={scrollAreaStyle}>
{entries.length === 0 && (
<div style={{ textAlign: 'center', opacity: 0.5, padding: 12 }}>
No events yet...
</div>
)}
{entries.map((entry) => (
<div key={entry.id} style={entryStyle}>
<span style={timestampStyle}>[{formatTime(entry.timestamp)}]</span>
{entry.message}
</div>
))}
</div>
<div ref={ref} style={scrollAreaStyle}>
{entries.length === 0 && (
<div style={{ textAlign: 'center', opacity: 0.5, padding: 12 }}>
{tr.noEventsYet}
</div>
)}
{entries.map((entry) => (
<div key={entry.id} style={entryStyle}>
<span style={timestampStyle}>[{formatTime(entry.timestamp)}]</span>
{entry.message}
</div>
))}
</div>
);
}

14
frontend/src/ui/BuffBar.tsx
Unescape Escape View File

@ -5,6 +5,7 @@ import { BUFF_META } from './buffMeta';
import { purchaseBuffRefill } from '../network/api';
import type { HeroResponse } from '../network/api';
import { getTelegramUserId } from '../shared/telegram';
import { useT, t } from '../i18n';
// ---- Types ----
@ -161,6 +162,7 @@ const buttonBase: CSSProperties = {
};
function BuffButton({ buff, meta, charge, maxCharges, onActivate, onRefill, nowMs }: BuffButtonProps) {
const tr = useT();
const [pressed, setPressed] = useState(false);
const [showTooltip, setShowTooltip] = useState(false);
const [showRefillConfirm, setShowRefillConfirm] = useState(false);
@ -332,12 +334,12 @@ function BuffButton({ buff, meta, charge, maxCharges, onActivate, onRefill, nowM
color: isOutOfCharges ? '#ff8844' : '#aaccff',
}}
>
Charges: {remaining}/{maxCharges}
{tr.charges}: {remaining}/{maxCharges}
</div>
)}
{isOutOfCharges && charge?.periodEnd && (
<div style={{ fontSize: 10, marginTop: 1, color: '#ff6644' }}>
Refills at {formatTimeHHMM(charge.periodEnd)}
{tr.refillsAt} {formatTimeHHMM(charge.periodEnd)}
</div>
)}
{isOutOfCharges && onRefill && (
@ -361,7 +363,7 @@ function BuffButton({ buff, meta, charge, maxCharges, onActivate, onRefill, nowM
pointerEvents: 'auto',
}}
>
Refill
{tr.refill}
</button>
)}
<div style={tooltipArrow} />
@ -390,7 +392,7 @@ function BuffButton({ buff, meta, charge, maxCharges, onActivate, onRefill, nowM
}}
>
<div style={{ marginBottom: 6 }}>
Refill {meta.label}?
{t(tr.refillQuestion, { label: meta.label })}
</div>
<div style={{ fontSize: 10, color: '#aaa', marginBottom: 8 }}>
{buff.type === BuffType.Resurrection ? '150\u20BD' : '50\u20BD'}
@ -414,7 +416,7 @@ function BuffButton({ buff, meta, charge, maxCharges, onActivate, onRefill, nowM
cursor: 'pointer',
}}
>
Refill
{tr.refill}
</button>
<button
type="button"
@ -433,7 +435,7 @@ function BuffButton({ buff, meta, charge, maxCharges, onActivate, onRefill, nowM
cursor: 'pointer',
}}
>
Cancel
{tr.cancel}
</button>
</div>
</div>

10
frontend/src/ui/DeathScreen.tsx
Unescape Escape View File

@ -1,5 +1,6 @@
import { useEffect, useState, type CSSProperties } from 'react';
import { REVIVE_TIMER_SECONDS } from '../shared/constants';
import { useT, t } from '../i18n';
interface DeathScreenProps {
visible: boolean;
@ -52,6 +53,7 @@ const buttonStyle: CSSProperties = {
};
export function DeathScreen({ visible, onRevive, revivesRemaining }: DeathScreenProps) {
const tr = useT();
const [timer, setTimer] = useState(REVIVE_TIMER_SECONDS);
const canRevive = revivesRemaining === undefined || revivesRemaining > 0;
@ -86,11 +88,11 @@ export function DeathScreen({ visible, onRevive, revivesRemaining }: DeathScreen
return (
<div style={overlayStyle}>
<div style={titleStyle}>YOU DIED</div>
<div style={titleStyle}>{tr.youDied}</div>
<div style={timerStyle}>{canRevive ? timer : '—'}</div>
{revivesRemaining !== undefined && (
<div style={{ color: '#aaa', fontSize: 14 }}>
Free revives left: {Math.max(0, revivesRemaining)}
{t(tr.freeRevivesLeft, { count: Math.max(0, revivesRemaining) })}
</div>
)}
<button
@ -109,10 +111,10 @@ export function DeathScreen({ visible, onRevive, revivesRemaining }: DeathScreen
e.currentTarget.style.backgroundColor = '#cc3333';
}}
>
REVIVE NOW
{tr.reviveNow}
</button>
<div style={{ color: '#888', fontSize: 13 }}>
{canRevive ? `Auto-revive in ${timer}s` : 'No free revives left — subscription required'}
{canRevive ? t(tr.autoReviveIn, { timer }) : tr.noFreeRevives}
</div>
</div>
);

177
frontend/src/ui/EquipmentPanel.tsx
Unescape Escape View File

@ -1,177 +0,0 @@
import { useState, type CSSProperties } from 'react';
import type { EquipmentItem } from '../game/types';
import { RARITY_COLORS, RARITY_GLOW } from '../shared/constants';
/** Ordered slot definitions for display */
const SLOT_DEFS: Array<{ key: string; icon: string; label: string }> = [
{ key: 'main_hand', icon: '\u2694\uFE0F', label: 'Weapon' },
{ key: 'chest', icon: '\uD83D\uDEE1\uFE0F', label: 'Chest' },
{ key: 'head', icon: '\u26D1\uFE0F', label: 'Head' },
{ key: 'feet', icon: '\uD83D\uDC62', label: 'Feet' },
{ key: 'neck', icon: '\uD83D\uDCBF', label: 'Neck' },
{ key: 'hands', icon: '\uD83D\uDC42', label: 'Hands' },
{ key: 'legs', icon: '\uD83D\uDC62', label: 'Legs' },
{ key: 'cloak', icon: '\uD83D\uDEE1\uFE0F', label: 'Cloak' },
{ key: 'finger', icon: '\uD83D\uDCBF', label: 'Finger' },
{ key: 'wrist', icon: '\uD83D\uDC42', label: 'Wrist' },
];
function rarityColor(rarity: string): string {
return RARITY_COLORS[rarity.toLowerCase()] ?? '#9d9d9d';
}
function rarityGlow(rarity: string): string {
return RARITY_GLOW[rarity.toLowerCase()] ?? 'none';
}
function statLabel(statType: string): string {
switch (statType) {
case 'attack': return 'ATK';
case 'defense': return 'DEF';
case 'speed': return 'SPD';
default: return 'STAT';
}
}
const wrapStyle: CSSProperties = {
marginTop: 6,
borderRadius: 8,
backgroundColor: 'rgba(0,0,0,0.45)',
border: '1px solid rgba(255,255,255,0.12)',
overflow: 'hidden',
flex: 1,
minWidth: 0,
};
const headerStyle: CSSProperties = {
width: '100%',
display: 'flex',
alignItems: 'center',
justifyContent: 'space-between',
padding: '6px 10px',
fontSize: 12,
fontWeight: 700,
color: '#e8e8e8',
cursor: 'pointer',
userSelect: 'none',
WebkitTapHighlightColor: 'transparent',
background: 'rgba(255,255,255,0.04)',
border: 'none',
fontFamily: 'inherit',
};
const bodyStyle: CSSProperties = {
padding: '8px 10px 10px',
fontSize: 11,
color: '#ccc',
};
const slotRow: CSSProperties = {
display: 'flex',
alignItems: 'center',
justifyContent: 'space-between',
padding: '4px 0',
borderBottom: '1px solid rgba(255,255,255,0.06)',
};
const slotLeftStyle: CSSProperties = {
display: 'flex',
alignItems: 'center',
gap: 6,
minWidth: 0,
overflow: 'hidden',
};
const slotIconStyle: CSSProperties = {
fontSize: 13,
flexShrink: 0,
width: 18,
textAlign: 'center',
};
const emptyLabelStyle: CSSProperties = {
color: '#555',
fontStyle: 'italic',
fontSize: 10,
};
const itemNameStyle: CSSProperties = {
fontWeight: 600,
fontSize: 11,
whiteSpace: 'nowrap',
overflow: 'hidden',
textOverflow: 'ellipsis',
};
const statValStyle: CSSProperties = {
fontSize: 10,
color: '#999',
flexShrink: 0,
textAlign: 'right',
marginLeft: 8,
};
interface EquipmentPanelProps {
equipment: Record<string, EquipmentItem>;
}
export function EquipmentPanel({ equipment }: EquipmentPanelProps) {
const [open, setOpen] = useState(false);
const equippedCount = equipment ? Object.keys(equipment).length : 0;
return (
<div style={wrapStyle}>
<button
type="button"
style={headerStyle}
onClick={() => setOpen((v) => !v)}
aria-expanded={open}
>
<span>Equipment ({equippedCount})</span>
<span style={{ opacity: 0.7, fontSize: 11 }}>{open ? '\u25BC' : '\u25B6'}</span>
</button>
{open && (
<div style={bodyStyle}>
{SLOT_DEFS.map((def) => {
const item = equipment?.[def.key];
if (!item) {
return (
<div key={def.key} style={slotRow}>
<div style={slotLeftStyle}>
<span style={slotIconStyle}>{def.icon}</span>
<span style={emptyLabelStyle}>{def.label}</span>
</div>
<span style={{ ...statValStyle, color: '#444' }}>Empty</span>
</div>
);
}
const color = rarityColor(item.rarity);
const glow = rarityGlow(item.rarity);
return (
<div
key={def.key}
style={{
...slotRow,
borderBottomColor: `${color}22`,
boxShadow: glow !== 'none' ? `inset 0 -1px 4px ${color}15` : undefined,
}}
>
<div style={slotLeftStyle}>
<span style={slotIconStyle}>{def.icon}</span>
<span style={{ ...itemNameStyle, color }}>{item.name}</span>
</div>
<span style={statValStyle}>
{statLabel(item.statType)} {item.primaryStat}
{' \u00B7 '}ilvl {item.ilvl}
</span>
</div>
);
})}
</div>
)}
</div>
);
}

86
frontend/src/ui/HUD.tsx
Unescape Escape View File

@ -4,13 +4,12 @@ import { BuffBar } from './BuffBar';
import { BuffStatusStrip } from './BuffStatusStrip';
import { DebuffBar } from './DebuffBar';
import { LootPopup } from './LootPopup';
import { HeroPanel } from './HeroPanel';
import { EquipmentPanel } from './EquipmentPanel';
import { InventoryStrip } from './InventoryStrip';
import type { GameState } from '../game/types';
import { GamePhase, BuffType } from '../game/types';
import { useUiClock } from '../hooks/useUiClock';
import type { HeroResponse } from '../network/api';
import { useT } from '../i18n';
// FREE_BUFF_ACTIVATIONS_PER_PERIOD removed — per-buff charges are now shown on each button
interface HUDProps {
@ -19,6 +18,7 @@ interface HUDProps {
buffCooldownEndsAt: Partial<Record<BuffType, number>>;
onUsePotion?: () => void;
onHeroUpdated?: (hero: HeroResponse) => void;
onOpenHeroSheet: () => void;
}
const containerStyle: CSSProperties = {
@ -126,9 +126,69 @@ const potionButtonDisabledStyle: CSSProperties = {
cursor: 'default',
};
export function HUD({ gameState, onBuffActivate, buffCooldownEndsAt, onUsePotion, onHeroUpdated }: HUDProps) {
const sheetBtnStyle: CSSProperties = {
flexShrink: 0,
minWidth: 44,
height: 40,
padding: '3px 6px',
borderRadius: 6,
border: '1px solid rgba(140, 170, 220, 0.35)',
backgroundColor: 'rgba(25, 35, 55, 0.75)',
color: '#b8c8e8',
cursor: 'pointer',
pointerEvents: 'auto',
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
justifyContent: 'center',
gap: 1,
userSelect: 'none',
WebkitTapHighlightColor: 'transparent',
};
const sheetBtnIconStyle: CSSProperties = {
lineHeight: 1,
fontSize: 14,
};
const sheetBtnLabelStyle: CSSProperties = {
fontSize: 9,
fontWeight: 700,
letterSpacing: 0.4,
textTransform: 'uppercase',
color: 'rgba(200, 215, 240, 0.95)',
lineHeight: 1,
};
/** Gold next to Hero sheet button — matches inventory tab styling */
const hudGoldChipStyle: CSSProperties = {
flexShrink: 0,
display: 'inline-flex',
alignItems: 'center',
gap: 4,
padding: '4px 8px',
borderRadius: 6,
background: 'rgba(255, 215, 0, 0.08)',
border: '1px solid rgba(255, 215, 0, 0.22)',
color: '#ffd700',
fontWeight: 700,
fontSize: 12,
pointerEvents: 'none',
userSelect: 'none',
whiteSpace: 'nowrap',
};
export function HUD({
gameState,
onBuffActivate,
buffCooldownEndsAt,
onUsePotion,
onHeroUpdated,
onOpenHeroSheet,
}: HUDProps) {
const { hero, enemy, phase, lastVictoryLoot } = gameState;
const nowMs = useUiClock(100);
const tr = useT();
const handleBuffActivate = useCallback(
(type: BuffType) => {
@ -170,6 +230,20 @@ export function HUD({ gameState, onBuffActivate, buffCooldownEndsAt, onUsePotion
</div>
<div>
<div style={hpBuffRowStyle}>
<button
type="button"
style={sheetBtnStyle}
onClick={onOpenHeroSheet}
aria-label="Hero sheet — stats, character, inventory"
title="Hero — stats, character, inventory, journal, quests"
>
<span style={sheetBtnIconStyle} aria-hidden>&#x2694;&#xFE0F;</span>
<span style={sheetBtnLabelStyle}>Hero</span>
</button>
<div style={hudGoldChipStyle} aria-label={`Gold: ${hero.gold}`}>
<span style={{ fontSize: 14 }} aria-hidden>{'\uD83E\uDE99'}</span>
<span>{hero.gold.toLocaleString()}</span>
</div>
<div style={hpBarFlex}>
<HPBar
current={hero.hp}
@ -177,7 +251,7 @@ export function HUD({ gameState, onBuffActivate, buffCooldownEndsAt, onUsePotion
color="#44cc44"
height={28}
showText
label="HP"
label={tr.hp}
/>
</div>
<BuffStatusStrip buffs={hero.activeBuffs} nowMs={nowMs} />
@ -189,10 +263,6 @@ export function HUD({ gameState, onBuffActivate, buffCooldownEndsAt, onUsePotion
{/* Debuff indicators */}
{debuffsLive.length > 0 && <DebuffBar debuffs={debuffsLive} />}
<div style={{ display: 'flex', gap: 6, alignItems: 'flex-start' }}>
<HeroPanel hero={hero} nowMs={nowMs} />
<EquipmentPanel equipment={hero.equipment ?? {}} />
</div>
</>
)}

128
frontend/src/ui/HeroPanel.tsx
Unescape Escape View File

@ -1,55 +1,35 @@
import { useState, type CSSProperties } from 'react';
import { type CSSProperties } from 'react';
import type { HeroState } from '../game/types';
import { BuffType, DebuffType, type ActiveBuff, type ActiveDebuff } from '../game/types';
import { DEBUFF_COLORS } from '../shared/constants';
import { HPBar } from './HPBar';
import { useT, type Translations } from '../i18n';
function buffLabel(tr: Translations, type: BuffType): string {
const map: Record<BuffType, string> = {
[BuffType.Rush]: tr.buffRush,
[BuffType.Rage]: tr.buffRage,
[BuffType.Shield]: tr.buffShield,
[BuffType.Luck]: tr.buffLuck,
[BuffType.Resurrection]: tr.buffResurrection,
[BuffType.Heal]: tr.buffHeal,
[BuffType.PowerPotion]: tr.buffPowerPotion,
[BuffType.WarCry]: tr.buffWarCry,
};
return map[type] ?? type;
}
const BUFF_LABEL: Record<BuffType, string> = {
[BuffType.Rush]: 'Rush',
[BuffType.Rage]: 'Rage',
[BuffType.Shield]: 'Shield',
[BuffType.Luck]: 'Luck',
[BuffType.Resurrection]: 'Resurrect',
[BuffType.Heal]: 'Heal',
[BuffType.PowerPotion]: 'Power',
[BuffType.WarCry]: 'War Cry',
};
const DEBUFF_LABEL: Record<DebuffType, string> = {
[DebuffType.Poison]: 'Poison',
[DebuffType.Freeze]: 'Freeze',
[DebuffType.Burn]: 'Burn',
[DebuffType.Stun]: 'Stun',
[DebuffType.Slow]: 'Slow',
[DebuffType.Weaken]: 'Weaken',
};
const wrapStyle: CSSProperties = {
marginTop: 6,
borderRadius: 8,
backgroundColor: 'rgba(0,0,0,0.45)',
border: '1px solid rgba(255,255,255,0.12)',
overflow: 'hidden',
flex: 1,
minWidth: 0,
};
const headerStyle: CSSProperties = {
width: '100%',
display: 'flex',
alignItems: 'center',
justifyContent: 'space-between',
padding: '6px 10px',
fontSize: 12,
fontWeight: 700,
color: '#e8e8e8',
cursor: 'pointer',
userSelect: 'none',
WebkitTapHighlightColor: 'transparent',
background: 'rgba(255,255,255,0.04)',
border: 'none',
fontFamily: 'inherit',
};
function debuffLabel(tr: Translations, type: DebuffType): string {
const map: Record<DebuffType, string> = {
[DebuffType.Poison]: tr.debuffPoison,
[DebuffType.Freeze]: tr.debuffFreeze,
[DebuffType.Burn]: tr.debuffBurn,
[DebuffType.Stun]: tr.debuffStun,
[DebuffType.Slow]: tr.debuffSlow,
[DebuffType.Weaken]: tr.debuffWeaken,
};
return map[type] ?? type;
}
const bodyStyle: CSSProperties = {
padding: '8px 10px 10px',
@ -129,9 +109,9 @@ function StatValue({ value, label, buffed, nerfed }: { value: string; label: str
}
export function HeroPanel({ hero, nowMs }: HeroPanelProps) {
const [open, setOpen] = useState(false);
/** Full hero stats block (Stats sheet tab). */
export function HeroStatsContent({ hero, nowMs }: HeroPanelProps) {
const tr = useT();
const buffsLive = hero.activeBuffs
.map((b) => ({
...b,
@ -154,36 +134,24 @@ export function HeroPanel({ hero, nowMs }: HeroPanelProps) {
const defBuffed = hasActiveBuff(hero.activeBuffs, BuffType.Shield, nowMs);
return (
<div style={wrapStyle}>
<button
type="button"
style={headerStyle}
onClick={() => setOpen((v) => !v)}
aria-expanded={open}
>
<span>Hero Stats</span>
<span style={{ opacity: 0.7, fontSize: 11 }}>{open ? '\u25BC' : '\u25B6'}</span>
</button>
{open && (
<div style={bodyStyle}>
<div style={bodyStyle}>
{/* Combat Stats */}
<StatValue label="ATK" value={String(hero.damage)} buffed={atkBuffed} nerfed={atkNerfed} />
<StatValue label="DEF" value={String(hero.defense)} buffed={defBuffed} nerfed={false} />
<StatValue label="Speed" value={`${hero.attackSpeed.toFixed(2)}/s`} buffed={spdBuffed} nerfed={spdNerfed} />
<StatValue label={tr.atk} value={String(hero.damage)} buffed={atkBuffed} nerfed={atkNerfed} />
<StatValue label={tr.def} value={String(hero.defense)} buffed={defBuffed} nerfed={false} />
<StatValue label={tr.spd} value={`${hero.attackSpeed.toFixed(2)}/s`} buffed={spdBuffed} nerfed={spdNerfed} />
<StatValue
label="Move speed"
label={tr.moveSpd}
value={`${(hero.moveSpeed ?? 1).toFixed(2)}x`}
buffed={hasActiveBuff(hero.activeBuffs, BuffType.Rush, nowMs)}
nerfed={hasActiveDebuff(hero.debuffs, DebuffType.Slow, nowMs)}
/>
<div style={statRow}><span>STR</span><span>{hero.strength}</span></div>
<div style={statRow}><span>CON</span><span>{hero.constitution}</span></div>
<div style={statRow}><span>AGI</span><span>{hero.agility}</span></div>
<div style={statRow}><span>LUCK</span><span>{hero.luck}</span></div>
<div style={statRow}><span>{tr.str}</span><span>{hero.strength}</span></div>
<div style={statRow}><span>{tr.con}</span><span>{hero.constitution}</span></div>
<div style={statRow}><span>{tr.agi}</span><span>{hero.agility}</span></div>
<div style={statRow}><span>{tr.luck}</span><span>{hero.luck}</span></div>
{/* XP */}
<div style={{ ...sectionTitle, marginTop: 12 }}>Experience</div>
<div style={{ ...sectionTitle, marginTop: 12 }}>{tr.experience}</div>
<div style={{ marginBottom: 2 }}>
<HPBar
current={hero.xp}
@ -191,14 +159,14 @@ export function HeroPanel({ hero, nowMs }: HeroPanelProps) {
color="#44aaff"
height={12}
showText
label="XP"
label={tr.xp}
/>
</div>
{/* Buffs */}
<div style={sectionTitle}>Active Buffs</div>
<div style={sectionTitle}>{tr.activeBuffs}</div>
{buffsLive.length === 0 ? (
<div style={{ opacity: 0.55, fontStyle: 'italic' }}>None</div>
<div style={{ opacity: 0.55, fontStyle: 'italic' }}>{tr.none}</div>
) : (
<div style={{ display: 'flex', flexWrap: 'wrap' }}>
{buffsLive.map((b) => (
@ -210,7 +178,7 @@ export function HeroPanel({ hero, nowMs }: HeroPanelProps) {
border: '1px solid rgba(68, 170, 255, 0.6)',
}}
>
{BUFF_LABEL[b.type]}
{buffLabel(tr, b.type)}
<span style={{ opacity: 0.9 }}>{Math.ceil(b.remainingMs / 1000)}s</span>
</span>
))}
@ -218,9 +186,9 @@ export function HeroPanel({ hero, nowMs }: HeroPanelProps) {
)}
{/* Debuffs */}
<div style={sectionTitle}>Active Debuffs</div>
<div style={sectionTitle}>{tr.activeDebuffs}</div>
{debuffsLive.length === 0 ? (
<div style={{ opacity: 0.55, fontStyle: 'italic' }}>None</div>
<div style={{ opacity: 0.55, fontStyle: 'italic' }}>{tr.none}</div>
) : (
<div style={{ display: 'flex', flexWrap: 'wrap' }}>
{debuffsLive.map((d) => {
@ -234,15 +202,13 @@ export function HeroPanel({ hero, nowMs }: HeroPanelProps) {
border: `1px solid ${color}99`,
}}
>
{DEBUFF_LABEL[d.type]}
{debuffLabel(tr, d.type)}
<span style={{ opacity: 0.9 }}>{Math.ceil(d.remainingMs / 1000)}s</span>
</span>
);
})}
</div>
)}
</div>
)}
</div>
);
}

27
frontend/src/ui/InventoryStrip.tsx
Unescape Escape View File

@ -2,6 +2,7 @@ import type { CSSProperties } from 'react';
import type { HeroState, LootDrop } from '../game/types';
interface InventoryStripProps {
/** Kept for call sites; gold is shown on HUD and in the inventory tab. */
hero: HeroState;
/** Most recent victory loot (gold + optional item); persists after popup fades */
lastLoot?: LootDrop | null;
@ -33,38 +34,22 @@ const stripStyle: CSSProperties = {
minHeight: 28,
};
const goldStyle: CSSProperties = {
display: 'flex',
alignItems: 'center',
gap: 5,
color: '#ffd700',
fontWeight: 700,
flexShrink: 0,
whiteSpace: 'nowrap',
};
const lastLootStyle: CSSProperties = {
marginLeft: 'auto',
fontSize: 10,
color: 'rgba(220, 230, 255, 0.7)',
whiteSpace: 'nowrap',
textOverflow: 'ellipsis',
overflow: 'hidden',
maxWidth: 160,
maxWidth: '100%',
};
export function InventoryStrip({ hero, lastLoot }: InventoryStripProps) {
export function InventoryStrip({ lastLoot }: InventoryStripProps) {
if (!lastLoot) return null;
return (
<div style={stripStyle}>
<div style={goldStyle}>
<span style={{ fontSize: 14 }}>{'\uD83E\uDE99'}</span>
<span>{hero.gold.toLocaleString()}</span>
<div style={lastLootStyle} title={formatLastLootLine(lastLoot)}>
{formatLastLootLine(lastLoot)}
</div>
{lastLoot && (
<div style={lastLootStyle} title={formatLastLootLine(lastLoot)}>
{formatLastLootLine(lastLoot)}
</div>
)}
</div>
);
}

14
frontend/src/ui/Minimap.tsx
Unescape Escape View File

@ -1,6 +1,7 @@
import { useEffect, useRef, useState, type CSSProperties } from 'react';
import { buildWorldTerrainContext, proceduralTerrain, townsApiToInfluences } from '../game/procedural';
import type { Town } from '../game/types';
import { useT } from '../i18n';
// ---- Types ----
@ -58,7 +59,7 @@ const DEFAULT_RGB = hexToRgb(DEFAULT_BG);
const containerStyle: CSSProperties = {
position: 'fixed',
top: 42,
top: 12,
right: 8,
zIndex: 40,
userSelect: 'none',
@ -96,15 +97,16 @@ function canvasStyleForSize(px: number): CSSProperties {
};
}
function modeLabel(mode: MapMode): string {
if (mode === 0) return `MAP \u25B6`;
if (mode === 1) return 'MAP S';
return 'MAP L';
function modeLabel(mode: MapMode, mapStr: string): string {
if (mode === 0) return `${mapStr} \u25B6`;
if (mode === 1) return `${mapStr} S`;
return `${mapStr} L`;
}
// ---- Component ----
export function Minimap({ heroX, heroY, towns, routeWaypoints }: MinimapProps) {
const tr = useT();
const [mode, setMode] = useState<MapMode>(1);
const canvasRef = useRef<HTMLCanvasElement>(null);
const lastDrawPos = useRef<{ x: number; y: number }>({ x: NaN, y: NaN });
@ -275,7 +277,7 @@ export function Minimap({ heroX, heroY, towns, routeWaypoints }: MinimapProps) {
title="Карта: свернуть / малый / большой"
onClick={() => setMode((m) => ((((m + 1) % 3) as MapMode)))}
>
{modeLabel(mode)}
{modeLabel(mode, tr.map)}
</button>
{!collapsed && (
<canvas

44
frontend/src/ui/NPCDialog.tsx
Unescape Escape View File

@ -4,6 +4,7 @@ import { getNPCQuests, acceptQuest, claimQuest, buyPotion, healAtNPC } from '../
import type { HeroResponse } from '../network/api';
import { getTelegramUserId } from '../shared/telegram';
import { hapticImpact } from '../shared/telegram';
import { useT, t } from '../i18n';
// ---- Types ----
@ -209,12 +210,12 @@ function npcTypeIcon(type: string): string {
}
}
function npcTypeLabel(type: string): string {
function npcTypeLabel(type: string, tr: ReturnType<typeof useT>): string {
switch (type) {
case 'quest_giver': return 'Quest Giver';
case 'merchant': return 'Merchant';
case 'healer': return 'Healer';
default: return 'NPC';
case 'quest_giver': return tr.questGiver;
case 'merchant': return tr.merchant;
case 'healer': return tr.healer;
default: return tr.npc;
}
}
@ -243,6 +244,7 @@ export function NPCDialog({
onHeroUpdated,
onToast,
}: NPCDialogProps) {
const tr = useT();
const [availableQuests, setAvailableQuests] = useState<Quest[]>([]);
const [loading, setLoading] = useState(false);
@ -275,14 +277,14 @@ export function NPCDialog({
acceptQuest(questId, telegramId)
.then(() => {
hapticImpact('medium');
onToast('Quest accepted!', '#44aaff');
onToast(tr.questAccepted, '#44aaff');
onQuestsChanged();
// Remove from available list
setAvailableQuests((prev) => prev.filter((q) => q.id !== questId));
})
.catch((err) => {
console.warn('[NPCDialog] Failed to accept quest:', err);
onToast('Failed to accept quest', '#ff4444');
onToast(tr.failedToAcceptQuest, '#ff4444');
});
},
[telegramId, onQuestsChanged, onToast],
@ -293,13 +295,13 @@ export function NPCDialog({
claimQuest(heroQuestId, telegramId)
.then((hero) => {
hapticImpact('heavy');
onToast('Quest rewards claimed!', '#ffd700');
onToast(tr.questRewardsClaimed, '#ffd700');
onHeroUpdated(hero);
onQuestsChanged();
})
.catch((err) => {
console.warn('[NPCDialog] Failed to claim quest:', err);
onToast('Failed to claim rewards', '#ff4444');
onToast(tr.failedToClaimRewards, '#ff4444');
});
},
[telegramId, onQuestsChanged, onHeroUpdated, onToast],
@ -307,35 +309,35 @@ export function NPCDialog({
const handleBuyPotion = useCallback(() => {
if (heroGold < POTION_COST) {
onToast('Not enough gold!', '#ff4444');
onToast(tr.notEnoughGold, '#ff4444');
return;
}
buyPotion(telegramId)
.then((hero) => {
hapticImpact('medium');
onToast(`Bought a potion for ${POTION_COST} gold`, '#88dd88');
onToast(t(tr.boughtPotion, { cost: POTION_COST }), '#88dd88');
onHeroUpdated(hero);
})
.catch((err) => {
console.warn('[NPCDialog] Failed to buy potion:', err);
onToast('Failed to buy potion', '#ff4444');
onToast(tr.failedToBuyPotion, '#ff4444');
});
}, [telegramId, heroGold, onHeroUpdated, onToast]);
const handleHeal = useCallback(() => {
if (heroGold < HEAL_COST) {
onToast('Not enough gold!', '#ff4444');
onToast(tr.notEnoughGold, '#ff4444');
return;
}
healAtNPC(telegramId)
.then((hero) => {
hapticImpact('medium');
onToast('Healed to full HP!', '#44cc44');
onToast(tr.healedToFull, '#44cc44');
onHeroUpdated(hero);
})
.catch((err) => {
console.warn('[NPCDialog] Failed to heal:', err);
onToast('Failed to heal', '#ff4444');
onToast(tr.failedToHeal, '#ff4444');
});
}, [telegramId, heroGold, onHeroUpdated, onToast]);
@ -371,7 +373,7 @@ export function NPCDialog({
<div style={{ display: 'flex', alignItems: 'center' }}>
<span style={{ fontSize: 18, marginRight: 8 }}>{npcTypeIcon(npc.type)}</span>
<span style={npcNameStyle}>{npc.name}</span>
<span style={npcTypeTag}>{npcTypeLabel(npc.type)}</span>
<span style={npcTypeTag}>{npcTypeLabel(npc.type, tr)}</span>
</div>
<button style={closeBtnStyle} onClick={onClose}>{'\u2715'}</button>
</div>
@ -384,7 +386,7 @@ export function NPCDialog({
{/* Completed quests — claim first */}
{npcCompletedQuests.length > 0 && (
<>
<div style={sectionTitleStyle}>Completed</div>
<div style={sectionTitleStyle}>{tr.completed}</div>
{npcCompletedQuests.map((hq) => (
<div
key={hq.id}
@ -421,7 +423,7 @@ export function NPCDialog({
style={claimBtnStyle}
onClick={() => handleClaimQuest(hq.id)}
>
Claim Rewards
{tr.claimRewards}
</button>
</div>
))}
@ -498,7 +500,7 @@ export function NPCDialog({
style={acceptBtnStyle}
onClick={() => handleAcceptQuest(q.id)}
>
Accept Quest
{tr.acceptQuest}
</button>
</div>
))}
@ -527,7 +529,7 @@ export function NPCDialog({
onClick={handleBuyPotion}
disabled={heroGold < POTION_COST}
>
{'\uD83E\uDDEA'} Buy Potion &mdash; {POTION_COST} gold
{'\uD83E\uDDEA'} {tr.buyPotion} &mdash; {POTION_COST} {tr.gold}
</button>
<div style={{ fontSize: 11, color: '#666', textAlign: 'center' }}>
Your gold: {heroGold}
@ -548,7 +550,7 @@ export function NPCDialog({
onClick={handleHeal}
disabled={heroGold < HEAL_COST}
>
{'\u2764\uFE0F'} Heal to Full &mdash; {HEAL_COST} gold
{'\u2764\uFE0F'} {tr.healToFull} &mdash; {HEAL_COST} {tr.gold}
</button>
<div style={{ fontSize: 11, color: '#666', textAlign: 'center' }}>
Your gold: {heroGold}

18
frontend/src/ui/NameEntryScreen.tsx
Unescape Escape View File

@ -2,6 +2,7 @@ import { useState, useRef, useEffect, type CSSProperties, type FormEvent } from
import { ApiError, setHeroName } from '../network/api';
import type { HeroResponse } from '../network/api';
import { getTelegramUserId } from '../shared/telegram';
import { useT, t } from '../i18n';
const MIN_LEN = 2;
const MAX_LEN = 16;
@ -90,6 +91,7 @@ const errorStyle: CSSProperties = {
};
export function NameEntryScreen({ onNameSet }: NameEntryScreenProps) {
const tr = useT();
const [name, setName] = useState('');
const [loading, setLoading] = useState(false);
const [error, setError] = useState<string | null>(null);
@ -119,19 +121,19 @@ export function NameEntryScreen({ onNameSet }: NameEntryScreenProps) {
} catch (err) {
if (err instanceof ApiError) {
if (err.status === 409) {
setError('Name already taken, try another');
setError(tr.nameTaken);
} else if (err.status === 400) {
try {
const j = JSON.parse(err.body) as { error?: string };
setError(j.error ?? 'Invalid name');
setError(j.error ?? tr.invalidName);
} catch {
setError('Invalid name');
setError(tr.invalidName);
}
} else {
setError(`Server error (${err.status})`);
setError(t(tr.serverError, { status: err.status }));
}
} else {
setError('Connection failed, please retry');
setError(tr.connectionFailed);
}
} finally {
setLoading(false);
@ -141,7 +143,7 @@ export function NameEntryScreen({ onNameSet }: NameEntryScreenProps) {
return (
<div style={overlayStyle}>
<form style={cardStyle} onSubmit={handleSubmit}>
<div style={titleStyle}>Choose Your Hero Name</div>
<div style={titleStyle}>{tr.chooseHeroName}</div>
<input
ref={inputRef}
@ -156,7 +158,7 @@ export function NameEntryScreen({ onNameSet }: NameEntryScreenProps) {
}}
onFocus={() => setFocused(true)}
onBlur={() => setFocused(false)}
placeholder="Enter a name..."
placeholder={tr.enterName}
maxLength={MAX_LEN}
autoComplete="off"
autoCorrect="off"
@ -182,7 +184,7 @@ export function NameEntryScreen({ onNameSet }: NameEntryScreenProps) {
cursor: isValid && !loading ? 'pointer' : 'not-allowed',
}}
>
{loading ? 'Saving...' : 'Continue'}
{loading ? tr.saving : tr.continue}
</button>
</form>
</div>

19
frontend/src/ui/OfflineReport.tsx
Unescape Escape View File

@ -1,4 +1,5 @@
import { useEffect, useState, type CSSProperties } from 'react';
import { useT, t } from '../i18n';
interface OfflineReportProps {
monstersKilled: number;
@ -48,11 +49,6 @@ const lineStyle: CSSProperties = {
lineHeight: 1.8,
};
const highlightStyle: CSSProperties = {
fontWeight: 700,
color: '#ffd700',
};
const hintStyle: CSSProperties = {
fontSize: 11,
color: 'rgba(180, 190, 220, 0.5)',
@ -66,6 +62,7 @@ export function OfflineReport({
levelsGained,
onDismiss,
}: OfflineReportProps) {
const tr = useT();
const [fading, setFading] = useState(false);
useEffect(() => {
@ -94,26 +91,26 @@ export function OfflineReport({
onClick={onDismiss}
>
<div style={cardStyle} onClick={(e) => e.stopPropagation()}>
<div style={titleStyle}>While you were away...</div>
<div style={titleStyle}>{tr.whileYouWereAway}</div>
<div style={lineStyle}>
Killed <span style={highlightStyle}>{monstersKilled}</span> monster{monstersKilled !== 1 ? 's' : ''}
{t(tr.killedMonsters, { count: monstersKilled })}
</div>
{xpGained > 0 && (
<div style={lineStyle}>
+<span style={highlightStyle}>{xpGained}</span> XP
{t(tr.gainedXP, { xp: xpGained })}
</div>
)}
{goldGained > 0 && (
<div style={lineStyle}>
+<span style={highlightStyle}>{goldGained}</span> gold
{t(tr.gainedGold, { gold: goldGained })}
</div>
)}
{levelsGained > 0 && (
<div style={lineStyle}>
Gained <span style={{ ...highlightStyle, color: '#44aaff' }}>{levelsGained}</span> level{levelsGained !== 1 ? 's' : ''}!
{t(tr.gainedLevels, { levels: levelsGained })}
</div>
)}
<div style={hintStyle}>Tap anywhere to dismiss</div>
<div style={hintStyle}>{tr.tapToDismiss}</div>
</div>
</div>
</>

75
frontend/src/ui/QuestLog.tsx
Unescape Escape View File

@ -1,5 +1,6 @@
import { useState, useCallback, useEffect, type CSSProperties } from 'react';
import type { HeroQuest } from '../game/types';
import { useT } from '../i18n';
// ---- Types ----
@ -184,9 +185,15 @@ const emptyStyle: CSSProperties = {
padding: '24px 0',
};
// ---- Component ----
interface QuestLogListProps {
quests: HeroQuest[];
onClaim: (heroQuestId: number) => void;
onAbandon: (heroQuestId: number) => void;
}
export function QuestLog({ quests, onClaim, onAbandon, onClose }: QuestLogProps) {
/** Quest list body (embedded in Hero sheet or standalone panel). */
export function QuestLogList({ quests, onClaim, onAbandon }: QuestLogListProps) {
const tr = useT();
const [expandedId, setExpandedId] = useState<number | null>(null);
const activeQuests = quests.filter((q) => q.status !== 'claimed');
@ -195,37 +202,23 @@ export function QuestLog({ quests, onClaim, onAbandon, onClose }: QuestLogProps)
setExpandedId((prev) => (prev === id ? null : id));
}, []);
// Close on Escape
useEffect(() => {
const handleKey = (e: KeyboardEvent) => {
if (e.key === 'Escape') onClose();
};
window.addEventListener('keydown', handleKey);
return () => window.removeEventListener('keydown', handleKey);
}, [onClose]);
return (
<>
<style>{`
@keyframes quest-log-slide-up {
0% { transform: translateY(100%); }
100% { transform: translateY(0); }
}
@keyframes quest-claim-glow {
0%, 100% { box-shadow: 0 0 8px rgba(255, 215, 0, 0.15); }
50% { box-shadow: 0 0 18px rgba(255, 215, 0, 0.4); }
}
`}</style>
<div style={overlayStyle}>
<div style={backdropStyle} onClick={onClose} />
<div style={panelStyle}>
<div style={headerStyle}>
<span style={titleStyle}>{'\uD83D\uDCDC'} Quest Log</span>
<button style={closeBtnStyle} onClick={onClose}>{'\u2715'}</button>
</div>
<div style={listStyle}>
<div
style={{
...listStyle,
padding: '0 0 8px',
maxHeight: 'min(52vh, 400px)',
}}
>
{activeQuests.length === 0 ? (
<div style={emptyStyle}>No active quests. Visit an NPC to accept quests!</div>
<div style={emptyStyle}>{tr.noActiveQuests}</div>
) : (
activeQuests.map((q) => {
const isExpanded = expandedId === q.id;
@ -302,7 +295,7 @@ export function QuestLog({ quests, onClaim, onAbandon, onClose }: QuestLogProps)
onClaim(q.id);
}}
>
Claim Rewards
{tr.claimRewards}
</button>
) : (
<button
@ -312,7 +305,7 @@ export function QuestLog({ quests, onClaim, onAbandon, onClose }: QuestLogProps)
onAbandon(q.id);
}}
>
Abandon
{tr.abandon}
</button>
)}
</div>
@ -322,7 +315,37 @@ export function QuestLog({ quests, onClaim, onAbandon, onClose }: QuestLogProps)
);
})
)}
</div>
</>
);
}
export function QuestLog({ quests, onClaim, onAbandon, onClose }: QuestLogProps) {
const tr = useT();
useEffect(() => {
const handleKey = (e: KeyboardEvent) => {
if (e.key === 'Escape') onClose();
};
window.addEventListener('keydown', handleKey);
return () => window.removeEventListener('keydown', handleKey);
}, [onClose]);
return (
<>
<style>{`
@keyframes quest-log-slide-up {
0% { transform: translateY(100%); }
100% { transform: translateY(0); }
}
`}</style>
<div style={overlayStyle}>
<div style={backdropStyle} onClick={onClose} />
<div style={panelStyle}>
<div style={headerStyle}>
<span style={titleStyle}>{'\uD83D\uDCDC'} {tr.questLog}</span>
<button style={closeBtnStyle} onClick={onClose}>{'\u2715'}</button>
</div>
<QuestLogList quests={quests} onClaim={onClaim} onAbandon={onAbandon} />
</div>
</div>
</>

10
frontend/src/ui/WanderingNPCPopup.tsx
Unescape Escape View File

@ -1,4 +1,5 @@
import { useState, type CSSProperties } from 'react';
import { useT, t } from '../i18n';
// ---- Types ----
@ -89,6 +90,7 @@ export function WanderingNPCPopup({
onAccept,
onDecline,
}: WanderingNPCPopupProps) {
const tr = useT();
const [pending, setPending] = useState(false);
const canAfford = heroGold >= cost;
@ -112,11 +114,11 @@ export function WanderingNPCPopup({
<div style={titleStyle}>{npcName}</div>
<div style={messageStyle}>{message}</div>
<div style={costStyle}>
Give {cost} gold for a mysterious item?
{t(tr.giveGoldForItem, { cost })}
</div>
{!canAfford && (
<div style={{ fontSize: 11, color: '#ff6666', marginBottom: 10 }}>
Not enough gold ({heroGold}/{cost})
{tr.notEnoughGold} ({heroGold}/{cost})
</div>
)}
<div style={btnRow}>
@ -131,7 +133,7 @@ export function WanderingNPCPopup({
onClick={handleAccept}
disabled={!canAfford || pending}
>
{pending ? 'Giving...' : 'Accept'}
{pending ? tr.giving : tr.accept}
</button>
<button
style={{
@ -142,7 +144,7 @@ export function WanderingNPCPopup({
onClick={onDecline}
disabled={pending}
>
Decline
{tr.decline}
</button>
</div>
</div>

35
scripts/admin-tool.ps1
Unescape Escape View File

@ -14,11 +14,18 @@ param(
"engine-status",
"engine-combats",
"ws-connections",
"add-potions"
"add-potions",
"towns",
"start-adventure",
"teleport-town",
"start-rest",
"time-pause",
"time-resume"
)]
[string]$Command,
[long]$HeroId,
[int]$TownId,
[int]$Level,
[long]$Gold,
[int]$HP,
@ -92,10 +99,6 @@ switch ($Command) {
Require-Value -Name "HeroId" -Value $HeroId
$result = Invoke-AdminRequest -Method "GET" -Path "/admin/heroes/$HeroId"
}
"hero-potions" {
Require-Value -Name "HeroId" -Value $HeroId
$result = Invoke-AdminRequest -Method "GET" -Path "/admin/heroes/$HeroId/potions"
}
"set-level" {
Require-Value -Name "HeroId" -Value $HeroId
Require-Value -Name "Level" -Value $Level
@ -142,6 +145,28 @@ switch ($Command) {
"ws-connections" {
$result = Invoke-AdminRequest -Method "GET" -Path "/admin/ws/connections"
}
"towns" {
$result = Invoke-AdminRequest -Method "GET" -Path "/admin/towns"
}
"start-adventure" {
Require-Value -Name "HeroId" -Value $HeroId
$result = Invoke-AdminRequest -Method "POST" -Path "/admin/heroes/$HeroId/start-adventure" -Body @{}
}
"teleport-town" {
Require-Value -Name "HeroId" -Value $HeroId
Require-Value -Name "TownId" -Value $TownId
$result = Invoke-AdminRequest -Method "POST" -Path "/admin/heroes/$HeroId/teleport-town" -Body @{ townId = $TownId }
}
"start-rest" {
Require-Value -Name "HeroId" -Value $HeroId
$result = Invoke-AdminRequest -Method "POST" -Path "/admin/heroes/$HeroId/start-rest" -Body @{}
}
"time-pause" {
$result = Invoke-AdminRequest -Method "POST" -Path "/admin/time/pause" -Body @{}
}
"time-resume" {
$result = Invoke-AdminRequest -Method "POST" -Path "/admin/time/resume" -Body @{}
}
default {
throw "Unsupported command: $Command"
}

Write Preview
Loading…
Cancel
Save