Changing GMCP output to support module level messages

When sending the full Char message it overwrites anything else added to
the Char as a submodule.

  - Split out all submodules in Char
  - Added CombatStatus
  - Fixed decimals in Balance and Round output
  - Added enemy info to CombatStatus

Author: MorquinDevlar

modules/combat-twitch/combat.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/GoMudEngine/GoMud/internal/combat"
 	"github.com/GoMudEngine/GoMud/internal/events"
+	"github.com/GoMudEngine/GoMud/internal/mobs"
 	"github.com/GoMudEngine/GoMud/internal/mudlog"
 	"github.com/GoMudEngine/GoMud/internal/plugins"
 	"github.com/GoMudEngine/GoMud/internal/users"
@@ -18,14 +19,19 @@ type TwitchCombat struct {
 	timer      *CooldownTimer
 	active     bool
 	mutex      sync.RWMutex
+
+	// Track last target name per user for persistent targeting
+	userTargets     map[int]string // userId -> target name
+	userTargetMutex sync.RWMutex
 }
 
 // NewTwitchCombat creates a new twitch-based combat system
 func NewTwitchCombat(plug *plugins.Plugin) *TwitchCombat {
 	tc := &TwitchCombat{
-		plug:       plug,
-		calculator: NewTwitchCalculator(),
-		active:     false,
+		plug:        plug,
+		calculator:  NewTwitchCalculator(),
+		active:      false,
+		userTargets: make(map[int]string),
 	}
 	tc.timer = NewCooldownTimer(tc)
 	return tc
@@ -103,10 +109,25 @@ func (tc *TwitchCombat) SendBalanceNotification(actorId int, actorType combat.So
 func (tc *TwitchCombat) SendGMCPBalanceUpdate(userId int, remainingSeconds float64, maxSeconds float64) {
 	// Check if user is actually in combat
 	inCombat := false
-	if user := users.GetByUserId(userId); user != nil {
+	targetHpCurrent := 0
+	targetHpMax := 0
+
+	user := users.GetByUserId(userId)
+	if user != nil {
 		inCombat = user.Character.Aggro != nil
+
+		// If in combat, get target HP
+		if inCombat && user.Character.Aggro.MobInstanceId > 0 {
+			if targetMob := mobs.GetInstance(user.Character.Aggro.MobInstanceId); targetMob != nil {
+				targetHpCurrent = targetMob.Character.Health
+				targetHpMax = targetMob.Character.HealthMax.ValueAdj
+			}
+		}
 	}
 
+	// Get the user's current target
+	target := tc.GetUserTarget(userId)
+
 	// Send GMCP combat status update
 	events.AddToQueue(gmcp.GMCPCombatStatusUpdate{
 		UserId:          userId,
@@ -117,5 +138,68 @@ func (tc *TwitchCombat) SendGMCPBalanceUpdate(userId int, remainingSeconds float
 		InCombat:        inCombat,
 		CombatStyle:     combat.GetActiveCombatSystemName(),
 		RoundNumber:     0, // Not applicable for twitch combat
+		Target:          target,
+		TargetHpCurrent: targetHpCurrent,
+		TargetHpMax:     targetHpMax,
 	})
 }
+
+// SetUserTarget stores the last target name for a user
+func (tc *TwitchCombat) SetUserTarget(userId int, targetName string) {
+	tc.userTargetMutex.Lock()
+	if targetName == "" {
+		delete(tc.userTargets, userId)
+	} else {
+		tc.userTargets[userId] = targetName
+	}
+	tc.userTargetMutex.Unlock()
+
+	// Send GMCP update with new target
+	// Get current cooldown to include in update
+	remaining := tc.timer.GetRemainingCooldown(userId, combat.User).Seconds()
+	maxDuration := float64(0)
+	if remaining > 0 {
+		// If on cooldown, get max duration
+		// For simplicity, we'll just send the update with current remaining time
+		maxDuration = remaining // This isn't perfect but avoids accessing internal timer state
+	}
+
+	tc.SendGMCPBalanceUpdate(userId, remaining, maxDuration)
+}
+
+// GetUserTarget retrieves the last target name for a user
+func (tc *TwitchCombat) GetUserTarget(userId int) string {
+	tc.userTargetMutex.RLock()
+	defer tc.userTargetMutex.RUnlock()
+
+	return tc.userTargets[userId]
+}
+
+// ClearUserTarget removes the stored target for a user
+func (tc *TwitchCombat) ClearUserTarget(userId int) {
+	tc.userTargetMutex.Lock()
+	delete(tc.userTargets, userId)
+	tc.userTargetMutex.Unlock()
+
+	// Send GMCP update with cleared target
+	remaining := tc.timer.GetRemainingCooldown(userId, combat.User).Seconds()
+	maxDuration := float64(0)
+	if remaining > 0 {
+		maxDuration = remaining
+	}
+
+	tc.SendGMCPBalanceUpdate(userId, remaining, maxDuration)
+}
+
+// SendCombatUpdate sends GMCP updates for a player involved in combat
+// This should be called after any combat action that might change HP
+func (tc *TwitchCombat) SendCombatUpdate(userId int) {
+	// Get current cooldown for the user
+	remaining := tc.timer.GetRemainingCooldown(userId, combat.User).Seconds()
+	maxDuration := float64(0)
+	if remaining > 0 {
+		maxDuration = remaining
+	}
+
+	tc.SendGMCPBalanceUpdate(userId, remaining, maxDuration)
+}

modules/combat-twitch/commands.go

@@ -14,6 +14,7 @@ import (
 	"github.com/GoMudEngine/GoMud/internal/mudlog"
 	"github.com/GoMudEngine/GoMud/internal/rooms"
 	"github.com/GoMudEngine/GoMud/internal/users"
+	"github.com/GoMudEngine/GoMud/internal/util"
 )
 
 // registerCommands registers all combat-related commands
@@ -22,6 +23,9 @@ func (tc *TwitchCombat) registerCommands() {
 	tc.plug.AddUserCommand("attack", tc.attackCommand, false, false)
 	tc.plug.AddUserCommand("kill", tc.attackCommand, false, false) // Alias for attack
 	tc.plug.AddUserCommand("balance", tc.balanceCommand, false, false)
+	tc.plug.AddUserCommand("cleartarget", tc.clearTargetCommand, false, false)
+	tc.plug.AddUserCommand("target", tc.targetCommand, false, false)
+	tc.plug.AddUserCommand("flee", tc.fleeCommand, false, false)
 	tc.plug.AddUserCommand("combatinfo", tc.combatInfoCommand, true, true) // Admin only
 	tc.plug.AddUserCommand("config", tc.configCommand, true, true)         // Admin only
 
@@ -41,23 +45,55 @@ func (tc *TwitchCombat) attackCommand(rest string, user *users.UserRecord, room
 		return true, nil
 	}
 
-	// Basic attack targeting logic (simplified for demo)
-	if rest == "" {
-		user.SendText("Attack whom?")
-		return true, nil
-	}
-
-	// Find target using the same logic as round-based combat
-	attackPlayerId, attackMobInstanceId := room.FindByName(rest)
+	var attackPlayerId, attackMobInstanceId int
+	var targetName string
 
-	// Can't attack self
-	if attackPlayerId == user.UserId {
-		attackPlayerId = 0
+	// If no target specified, check if we have a persistent target
+	if rest == "" {
+		// First check if we're in active combat with a specific mob
+		if user.Character.Aggro != nil && user.Character.Aggro.MobInstanceId > 0 {
+			// Reuse existing mob target
+			attackMobInstanceId = user.Character.Aggro.MobInstanceId
+			// Verify the mob is still in the room
+			targetMob := mobs.GetInstance(attackMobInstanceId)
+			if targetMob == nil || targetMob.Character.RoomId != user.Character.RoomId {
+				user.SendText("Your target is no longer here.")
+				user.Character.Aggro = nil
+				// Try to use stored target name
+				targetName = tc.GetUserTarget(user.UserId)
+				if targetName != "" {
+					attackPlayerId, attackMobInstanceId = room.FindByName(targetName)
+				}
+			}
+		} else {
+			// Not in active combat, check for stored target name
+			targetName = tc.GetUserTarget(user.UserId)
+			if targetName != "" {
+				attackPlayerId, attackMobInstanceId = room.FindByName(targetName)
+			} else {
+				user.SendText("Attack whom?")
+				return true, nil
+			}
+		}
+	} else {
+		// New target specified
+		targetName = rest
+		// Find target using the same logic as round-based combat
+		attackPlayerId, attackMobInstanceId = room.FindByName(rest)
+
+		// Can't attack self
+		if attackPlayerId == user.UserId {
+			attackPlayerId = 0
+		}
 	}
 
 	// Check if we found a target
 	if attackMobInstanceId == 0 && attackPlayerId == 0 {
 		user.SendText("They aren't here.")
+		// Clear stored target if it's no longer valid
+		if targetName != "" {
+			tc.ClearUserTarget(user.UserId)
+		}
 		return true, nil
 	}
 
@@ -73,6 +109,10 @@ func (tc *TwitchCombat) attackCommand(rest string, user *users.UserRecord, room
 		return true, nil
 	}
 
+	// Store the actual mob name for persistent targeting
+	// Always use the mob's actual name, not what the user typed
+	tc.SetUserTarget(user.UserId, targetMob.Character.Name)
+
 	// Register the player with the timer if not already registered
 	tc.timer.RegisterActor(user.UserId, combat.User)
 
@@ -191,6 +231,9 @@ func (tc *TwitchCombat) mobAttackCommand(rest string, mob *mobs.Mob, room *rooms
 	cooldown := tc.calculateWeaponCooldown(&mob.Character, true) // true = mob
 	tc.timer.SetActorCooldown(mob.InstanceId, combat.Mob, cooldown)
 
+	// Send GMCP update to the player showing updated HP
+	tc.SendCombatUpdate(attackPlayerId)
+
 	// Check if player died
 	if targetUser.Character.Health <= 0 {
 		mob.Character.EndAggro()
@@ -640,3 +683,134 @@ func (tc *TwitchCombat) configCommand(rest string, user *users.UserRecord, room
 		return true, nil
 	}
 }
+
+// clearTargetCommand clears the stored combat target
+func (tc *TwitchCombat) clearTargetCommand(rest string, user *users.UserRecord, room *rooms.Room, flags events.EventFlag) (bool, error) {
+	tc.ClearUserTarget(user.UserId)
+	user.SendText(`<ansi fg="yellow">Combat target cleared.</ansi>`)
+	return true, nil
+}
+
+// targetCommand shows or sets the combat target
+func (tc *TwitchCombat) targetCommand(rest string, user *users.UserRecord, room *rooms.Room, flags events.EventFlag) (bool, error) {
+	if rest == "" {
+		// Show current target
+		currentTarget := tc.GetUserTarget(user.UserId)
+		if currentTarget == "" {
+			user.SendText(`<ansi fg="yellow">No target set.</ansi>`)
+		} else {
+			user.SendText(fmt.Sprintf(`<ansi fg="yellow">Current target: %s</ansi>`, currentTarget))
+		}
+	} else {
+		// Set new target
+		// Verify the target exists in the room
+		_, mobId := room.FindByName(rest)
+		if mobId == 0 {
+			user.SendText("They aren't here.")
+			return true, nil
+		}
+
+		// Get the actual mob to use its real name
+		targetMob := mobs.GetInstance(mobId)
+		if targetMob == nil {
+			user.SendText("They aren't here.")
+			return true, nil
+		}
+
+		tc.SetUserTarget(user.UserId, targetMob.Character.Name)
+		user.SendText(fmt.Sprintf(`<ansi fg="yellow">Target set to: %s</ansi>`, targetMob.Character.Name))
+	}
+	return true, nil
+}
+
+// fleeCommand handles flee attempts in twitch combat
+func (tc *TwitchCombat) fleeCommand(rest string, user *users.UserRecord, room *rooms.Room, flags events.EventFlag) (bool, error) {
+	// Check if user is in combat
+	if user.Character.Aggro == nil {
+		user.SendText(`You aren't in combat!`)
+		return true, nil
+	}
+
+	// Check if still on cooldown from last action
+	if !tc.timer.CanPerformAction(user.UserId, combat.User) {
+		nextAction := tc.timer.GetNextActionTime(user.UserId, combat.User)
+		remaining := time.Until(nextAction)
+		user.SendText(fmt.Sprintf(`<ansi fg="red">You are unbalanced! Can't flee for %.1f seconds.</ansi>`, remaining.Seconds()))
+		return true, nil
+	}
+
+	user.SendText(`You attempt to flee...`)
+
+	// Immediate flee check based on speed stats
+	blockedByMob := ""
+
+	// Check each mob in the room that has aggro on the player
+	for _, mobId := range room.GetMobs() {
+		mob := mobs.GetInstance(mobId)
+		if mob == nil || mob.Character.Aggro == nil || mob.Character.Aggro.UserId != user.UserId {
+			continue
+		}
+
+		// Speed-based flee chance calculation (same as combat-rounds)
+		chanceIn100 := int(float64(user.Character.Stats.Speed.ValueAdj) /
+			(float64(user.Character.Stats.Speed.ValueAdj) + float64(mob.Character.Stats.Speed.ValueAdj)) * 70)
+		chanceIn100 += 30
+
+		roll := util.Rand(100)
+		util.LogRoll(`Flee`, roll, chanceIn100)
+
+		if roll >= chanceIn100 {
+			blockedByMob = mob.Character.Name
+			break
+		}
+	}
+
+	// Handle flee result
+	if blockedByMob != "" {
+		user.SendText(fmt.Sprintf(`<ansi fg="red">%s blocks your escape!</ansi>`, blockedByMob))
+		room.SendText(
+			fmt.Sprintf(`<ansi fg="username">%s</ansi> <ansi fg="red">tries to flee, but is blocked by %s!</ansi>`,
+				user.Character.Name, blockedByMob),
+			user.UserId)
+
+		// Set a short cooldown for failed flee
+		tc.timer.SetActorCooldown(user.UserId, combat.User, 2*time.Second)
+		tc.SendCombatUpdate(user.UserId)
+	} else {
+		// Successful flee
+		exitName, _ := room.GetRandomExit()
+		if exitName == "" {
+			user.SendText(`<ansi fg="red">There's nowhere to run!</ansi>`)
+			// Set a short cooldown
+			tc.timer.SetActorCooldown(user.UserId, combat.User, 2*time.Second)
+			tc.SendCombatUpdate(user.UserId)
+			return true, nil
+		}
+
+		// Execute flee
+		events.AddToQueue(events.Input{
+			UserId:    user.UserId,
+			InputText: exitName,
+		})
+
+		user.SendText(`<ansi fg="yellow">You flee in panic!</ansi>`)
+		room.SendText(
+			fmt.Sprintf(`<ansi fg="username">%s</ansi> <ansi fg="yellow">flees in panic!</ansi>`, user.Character.Name),
+			user.UserId)
+
+		// Clear combat state
+		user.Character.EndAggro()
+		tc.ClearUserTarget(user.UserId)
+		tc.timer.ClearActorCooldown(user.UserId, combat.User)
+
+		// Notify all mobs that were fighting this player
+		for _, mobId := range room.GetMobs() {
+			mob := mobs.GetInstance(mobId)
+			if mob != nil && mob.Character.Aggro != nil && mob.Character.Aggro.UserId == user.UserId {
+				mob.Character.EndAggro()
+			}
+		}
+	}
+
+	return true, nil
+}