Catacombs/game/event.go

package game

import (
	"fmt"
	"math/rand"
	"time"

	"github.com/tolelom/catacombs/dungeon"
	"github.com/tolelom/catacombs/entity"
)

func (s *GameSession) EnterRoom(roomIdx int) {
	s.mu.Lock()
	defer s.mu.Unlock()

	now := time.Now()
	for _, p := range s.state.Players {
		if p.Fingerprint != "" {
			s.lastActivity[p.Fingerprint] = now
		}
	}

	s.state.Floor.CurrentRoom = roomIdx
	dungeon.UpdateVisibility(s.state.Floor)
	room := s.state.Floor.Rooms[roomIdx]

	if room.Cleared {
		return
	}

	switch room.Type {
	case dungeon.RoomCombat:
		s.spawnMonsters()
		s.state.Phase = PhaseCombat
		s.state.CombatTurn = 0
		s.signalCombat()
	case dungeon.RoomBoss:
		s.spawnBoss()
		s.state.Phase = PhaseCombat
		s.state.CombatTurn = 0
		s.signalCombat()
	case dungeon.RoomShop:
		s.generateShopItems()
		s.state.Phase = PhaseShop
	case dungeon.RoomTreasure:
		s.grantTreasure()
		room.Cleared = true
	case dungeon.RoomEvent:
		s.triggerEvent()
		room.Cleared = true
	case dungeon.RoomSecret:
		s.grantSecretTreasure()
		room.Cleared = true
	case dungeon.RoomMiniBoss:
		s.spawnMiniBoss()
		s.state.Phase = PhaseCombat
		s.state.CombatTurn = 0
		s.signalCombat()
	case dungeon.RoomEmpty:
		room.Cleared = true
	}
}

func (s *GameSession) spawnMonsters() {
	count := 1 + rand.Intn(5)
	floor := s.state.FloorNum
	s.state.Monsters = make([]*entity.Monster, count)

	type floorRange struct {
		mt       entity.MonsterType
		minFloor int
		maxFloor int
	}
	ranges := []floorRange{
		{entity.MonsterSlime, 1, 5},
		{entity.MonsterSkeleton, 3, 10},
		{entity.MonsterOrc, 6, 14},
		{entity.MonsterDarkKnight, 12, 20},
	}
	var valid []entity.MonsterType
	for _, r := range ranges {
		if floor >= r.minFloor && floor <= r.maxFloor {
			valid = append(valid, r.mt)
		}
	}
	if len(valid) == 0 {
		valid = []entity.MonsterType{entity.MonsterSlime}
	}

	for i := 0; i < count; i++ {
		mt := valid[rand.Intn(len(valid))]
		m := entity.NewMonster(mt, floor, s.cfg.Combat.MonsterScaling)
		if s.state.SoloMode {
			m.HP = int(float64(m.HP) * s.cfg.Combat.SoloHPReduction)
			if m.HP < 1 {
				m.HP = 1
			}
			m.MaxHP = m.HP
			m.DEF = int(float64(m.DEF) * s.cfg.Combat.SoloHPReduction)
		}
		if rand.Float64() < 0.20 {
			entity.ApplyPrefix(m, entity.RandomPrefix())
		}
		s.state.Monsters[i] = m
	}

	// Reset skill uses for all players at combat start
	for _, p := range s.state.Players {
		p.SkillUses = s.cfg.Game.SkillUses
	}
}

func (s *GameSession) spawnBoss() {
	var mt entity.MonsterType
	switch s.state.FloorNum {
	case 5:
		mt = entity.MonsterBoss5
	case 10:
		mt = entity.MonsterBoss10
	case 15:
		mt = entity.MonsterBoss15
	case 20:
		mt = entity.MonsterBoss20
	default:
		mt = entity.MonsterBoss5
	}
	boss := entity.NewMonster(mt, s.state.FloorNum, s.cfg.Combat.MonsterScaling)
	switch mt {
	case entity.MonsterBoss5:
		boss.Pattern = entity.PatternPoison // Swamp theme
	case entity.MonsterBoss10:
		boss.Pattern = entity.PatternBurn // Volcano theme
	case entity.MonsterBoss15:
		boss.Pattern = entity.PatternFreeze // Glacier theme
	case entity.MonsterBoss20:
		boss.Pattern = entity.PatternHeal // Inferno theme (+ natural AoE every 3 turns)
	}
	if s.state.SoloMode {
		boss.HP = int(float64(boss.HP) * s.cfg.Combat.SoloHPReduction)
		boss.MaxHP = boss.HP
		boss.DEF = int(float64(boss.DEF) * s.cfg.Combat.SoloHPReduction)
	}
	s.state.Monsters = []*entity.Monster{boss}

	// Reset skill uses for all players at combat start
	for _, p := range s.state.Players {
		p.SkillUses = s.cfg.Game.SkillUses
	}
}

func (s *GameSession) grantTreasure() {
	floor := s.state.FloorNum
	for _, p := range s.state.Players {
		if len(p.Inventory) >= s.cfg.Game.InventoryLimit {
			s.addLog(fmt.Sprintf("%s's inventory is full!", p.Name))
			continue
		}
		if rand.Float64() < 0.5 {
			bonus := 3 + rand.Intn(6) + floor/3
			item := entity.Item{
				Name: weaponName(floor), Type: entity.ItemWeapon, Bonus: bonus,
			}
			p.Inventory = append(p.Inventory, item)
			s.addLog(fmt.Sprintf("%s found %s (ATK+%d)", p.Name, item.Name, item.Bonus))
		} else {
			bonus := 2 + rand.Intn(4) + floor/4
			item := entity.Item{
				Name: armorName(floor), Type: entity.ItemArmor, Bonus: bonus,
			}
			p.Inventory = append(p.Inventory, item)
			s.addLog(fmt.Sprintf("%s found %s (DEF+%d)", p.Name, item.Name, item.Bonus))
		}
	}
}

func (s *GameSession) generateShopItems() {
	floor := s.state.FloorNum
	// Weapon bonus scales: base 3-8 + floor/3
	weaponBonus := 3 + rand.Intn(6) + floor/3
	// Armor bonus scales: base 2-5 + floor/4
	armorBonus := 2 + rand.Intn(4) + floor/4
	// Prices scale with power
	weaponPrice := 40 + weaponBonus*5
	armorPrice := 30 + armorBonus*5
	// Potion heals more on higher floors
	potionHeal := 30 + floor
	potionPrice := 20 + floor/2

	s.state.ShopItems = []entity.Item{
		{Name: "HP Potion", Type: entity.ItemConsumable, Bonus: potionHeal, Price: potionPrice},
		{Name: weaponName(floor), Type: entity.ItemWeapon, Bonus: weaponBonus, Price: weaponPrice},
		{Name: armorName(floor), Type: entity.ItemArmor, Bonus: armorBonus, Price: armorPrice},
	}
}

func weaponName(floor int) string {
	switch {
	case floor >= 15:
		return "Mythril Blade"
	case floor >= 10:
		return "Steel Sword"
	case floor >= 5:
		return "Bronze Sword"
	default:
		return "Iron Sword"
	}
}

func armorName(floor int) string {
	switch {
	case floor >= 15:
		return "Mythril Shield"
	case floor >= 10:
		return "Steel Shield"
	case floor >= 5:
		return "Bronze Shield"
	default:
		return "Iron Shield"
	}
}

func (s *GameSession) triggerEvent() {
	event := PickRandomEvent()
	s.addLog(fmt.Sprintf("Event: %s — %s", event.Name, event.Description))

	// Auto-resolve with a random choice
	choice := event.Choices[rand.Intn(len(event.Choices))]
	outcome := choice.Resolve(s.state.FloorNum)
	s.addLog(fmt.Sprintf("  → %s: %s", choice.Label, outcome.Description))

	// Pick a random alive player to apply the outcome
	var alive []*entity.Player
	for _, p := range s.state.Players {
		if !p.IsDead() {
			alive = append(alive, p)
		}
	}
	if len(alive) == 0 {
		return
	}
	target := alive[rand.Intn(len(alive))]

	if outcome.HPChange > 0 {
		before := target.HP
		target.Heal(outcome.HPChange)
		s.addLog(fmt.Sprintf("  %s heals %d HP", target.Name, target.HP-before))
	} else if outcome.HPChange < 0 {
		target.TakeDamage(-outcome.HPChange)
		s.addLog(fmt.Sprintf("  %s takes %d damage", target.Name, -outcome.HPChange))
	}

	if outcome.GoldChange != 0 {
		target.Gold += outcome.GoldChange
		if target.Gold < 0 {
			target.Gold = 0
		}
		if outcome.GoldChange > 0 {
			s.addLog(fmt.Sprintf("  %s gains %d gold", target.Name, outcome.GoldChange))
		} else {
			s.addLog(fmt.Sprintf("  %s loses %d gold", target.Name, -outcome.GoldChange))
		}
	}

	if outcome.ItemDrop {
		if len(target.Inventory) < s.cfg.Game.InventoryLimit {
			floor := s.state.FloorNum
			if rand.Float64() < 0.5 {
				bonus := 3 + rand.Intn(6) + floor/3
				item := entity.Item{Name: weaponName(floor), Type: entity.ItemWeapon, Bonus: bonus}
				target.Inventory = append(target.Inventory, item)
				s.addLog(fmt.Sprintf("  %s found %s (ATK+%d)", target.Name, item.Name, item.Bonus))
			} else {
				bonus := 2 + rand.Intn(4) + floor/4
				item := entity.Item{Name: armorName(floor), Type: entity.ItemArmor, Bonus: bonus}
				target.Inventory = append(target.Inventory, item)
				s.addLog(fmt.Sprintf("  %s found %s (DEF+%d)", target.Name, item.Name, item.Bonus))
			}
		} else {
			s.addLog(fmt.Sprintf("  %s's inventory is full!", target.Name))
		}
	}
}

func (s *GameSession) grantSecretTreasure() {
	s.addLog("You discovered a secret room filled with treasure!")
	floor := s.state.FloorNum
	// Double treasure: grant two items per player
	for _, p := range s.state.Players {
		for i := 0; i < 2; i++ {
			if len(p.Inventory) >= s.cfg.Game.InventoryLimit {
				s.addLog(fmt.Sprintf("%s's inventory is full!", p.Name))
				break
			}
			if rand.Float64() < 0.5 {
				bonus := 3 + rand.Intn(6) + floor/3
				item := entity.Item{
					Name: weaponName(floor), Type: entity.ItemWeapon, Bonus: bonus,
				}
				p.Inventory = append(p.Inventory, item)
				s.addLog(fmt.Sprintf("%s found %s (ATK+%d)", p.Name, item.Name, item.Bonus))
			} else {
				bonus := 2 + rand.Intn(4) + floor/4
				item := entity.Item{
					Name: armorName(floor), Type: entity.ItemArmor, Bonus: bonus,
				}
				p.Inventory = append(p.Inventory, item)
				s.addLog(fmt.Sprintf("%s found %s (DEF+%d)", p.Name, item.Name, item.Bonus))
			}
		}
	}
}

func (s *GameSession) spawnMiniBoss() {
	var mt entity.MonsterType
	floor := s.state.FloorNum
	switch {
	case floor <= 4:
		mt = entity.MonsterMiniBoss5
	case floor <= 9:
		mt = entity.MonsterMiniBoss10
	case floor <= 14:
		mt = entity.MonsterMiniBoss15
	default:
		mt = entity.MonsterMiniBoss20
	}
	miniBoss := entity.NewMonster(mt, floor, s.cfg.Combat.MonsterScaling)

	// Use same pattern as the subsequent boss
	switch mt {
	case entity.MonsterMiniBoss5:
		miniBoss.Pattern = entity.PatternPoison
	case entity.MonsterMiniBoss10:
		miniBoss.Pattern = entity.PatternBurn
	case entity.MonsterMiniBoss15:
		miniBoss.Pattern = entity.PatternFreeze
	case entity.MonsterMiniBoss20:
		miniBoss.Pattern = entity.PatternHeal
	}

	if s.state.SoloMode {
		miniBoss.HP = int(float64(miniBoss.HP) * s.cfg.Combat.SoloHPReduction)
		if miniBoss.HP < 1 {
			miniBoss.HP = 1
		}
		miniBoss.MaxHP = miniBoss.HP
		miniBoss.DEF = int(float64(miniBoss.DEF) * s.cfg.Combat.SoloHPReduction)
	}
	s.state.Monsters = []*entity.Monster{miniBoss}
	s.addLog(fmt.Sprintf("A mini-boss appears: %s!", miniBoss.Name))

	// Reset skill uses for all players at combat start
	for _, p := range s.state.Players {
		p.SkillUses = s.cfg.Game.SkillUses
	}
}