365 lines
9.1 KiB
Go

package functions
import (
"fmt"
"eq2emu/internal/events"
)
// Health and Power Management Functions
// SetCurrentHP sets the spawn's current HP
func SetCurrentHP(ctx *events.EventContext) error {
spawn := ctx.GetSpawn()
if spawn == nil {
return fmt.Errorf("no spawn in context")
}
hp := ctx.GetParameterFloat("hp", 0)
if hp < 0 {
return fmt.Errorf("HP cannot be negative")
}
spawn.SetHP(int32(hp))
ctx.Debug("Set HP to %f for spawn %s", hp, spawn.GetName())
return nil
}
// SetMaxHP sets the spawn's maximum HP
func SetMaxHP(ctx *events.EventContext) error {
spawn := ctx.GetSpawn()
if spawn == nil {
return fmt.Errorf("no spawn in context")
}
maxHP := ctx.GetParameterFloat("max_hp", 0)
if maxHP < 0 {
return fmt.Errorf("Max HP cannot be negative")
}
spawn.SetTotalHP(int32(maxHP))
ctx.Debug("Set Max HP to %f for spawn %s", maxHP, spawn.GetName())
return nil
}
// SetMaxHPBase sets the spawn's base maximum HP (before bonuses)
func SetMaxHPBase(ctx *events.EventContext) error {
// TODO: Implement base HP system when available
return SetMaxHP(ctx) // Fallback to regular max HP for now
}
// SetCurrentPower sets the spawn's current power
func SetCurrentPower(ctx *events.EventContext) error {
spawn := ctx.GetSpawn()
if spawn == nil {
return fmt.Errorf("no spawn in context")
}
power := ctx.GetParameterFloat("power", 0)
if power < 0 {
return fmt.Errorf("power cannot be negative")
}
spawn.SetPower(int32(power))
ctx.Debug("Set Power to %f for spawn %s", power, spawn.GetName())
return nil
}
// SetMaxPower sets the spawn's maximum power
func SetMaxPower(ctx *events.EventContext) error {
spawn := ctx.GetSpawn()
if spawn == nil {
return fmt.Errorf("no spawn in context")
}
maxPower := ctx.GetParameterFloat("max_power", 0)
if maxPower < 0 {
return fmt.Errorf("Max power cannot be negative")
}
spawn.SetTotalPower(int32(maxPower))
ctx.Debug("Set Max Power to %f for spawn %s", maxPower, spawn.GetName())
return nil
}
// SetMaxPowerBase sets the spawn's base maximum power (before bonuses)
func SetMaxPowerBase(ctx *events.EventContext) error {
// TODO: Implement base power system when available
return SetMaxPower(ctx) // Fallback to regular max power for now
}
// ModifyMaxHP modifies the spawn's maximum HP by a relative amount
func ModifyMaxHP(ctx *events.EventContext) error {
spawn := ctx.GetSpawn()
if spawn == nil {
return fmt.Errorf("no spawn in context")
}
modifier := ctx.GetParameterFloat("modifier", 0)
currentMax := float64(spawn.GetTotalHP())
newMax := currentMax + modifier
if newMax < 0 {
newMax = 0
}
spawn.SetTotalHP(int32(newMax))
ctx.Debug("Modified Max HP by %f (new value: %f) for spawn %s", modifier, newMax, spawn.GetName())
return nil
}
// ModifyMaxPower modifies the spawn's maximum power by a relative amount
func ModifyMaxPower(ctx *events.EventContext) error {
spawn := ctx.GetSpawn()
if spawn == nil {
return fmt.Errorf("no spawn in context")
}
modifier := ctx.GetParameterFloat("modifier", 0)
currentMax := float64(spawn.GetTotalPower())
newMax := currentMax + modifier
if newMax < 0 {
newMax = 0
}
spawn.SetTotalPower(int32(newMax))
ctx.Debug("Modified Max Power by %f (new value: %f) for spawn %s", modifier, newMax, spawn.GetName())
return nil
}
// ModifyPower modifies the spawn's current power by a relative amount
func ModifyPower(ctx *events.EventContext) error {
spawn := ctx.GetSpawn()
if spawn == nil {
return fmt.Errorf("no spawn in context")
}
modifier := ctx.GetParameterFloat("modifier", 0)
current := float64(spawn.GetPower())
newPower := current + modifier
// Clamp between 0 and max power
maxPower := float64(spawn.GetTotalPower())
if newPower < 0 {
newPower = 0
} else if newPower > maxPower {
newPower = maxPower
}
spawn.SetPower(int32(newPower))
ctx.Debug("Modified Power by %f (new value: %f) for spawn %s", modifier, newPower, spawn.GetName())
return nil
}
// ModifyHP modifies the spawn's current HP by a relative amount
func ModifyHP(ctx *events.EventContext) error {
spawn := ctx.GetSpawn()
if spawn == nil {
return fmt.Errorf("no spawn in context")
}
modifier := ctx.GetParameterFloat("modifier", 0)
current := float64(spawn.GetHP())
newHP := current + modifier
// Clamp between 0 and max HP
maxHP := float64(spawn.GetTotalHP())
if newHP < 0 {
newHP = 0
} else if newHP > maxHP {
newHP = maxHP
}
spawn.SetHP(int32(newHP))
ctx.Debug("Modified HP by %f (new value: %f) for spawn %s", modifier, newHP, spawn.GetName())
// Update alive state based on HP
if newHP <= 0 {
spawn.SetAlive(false)
ctx.Debug("Spawn %s is now dead", spawn.GetName())
} else if !spawn.IsAlive() {
spawn.SetAlive(true)
ctx.Debug("Spawn %s is now alive", spawn.GetName())
}
return nil
}
// ModifyTotalHP modifies the spawn's total/max HP by a relative amount
func ModifyTotalHP(ctx *events.EventContext) error {
return ModifyMaxHP(ctx) // Alias for ModifyMaxHP
}
// ModifyTotalPower modifies the spawn's total/max power by a relative amount
func ModifyTotalPower(ctx *events.EventContext) error {
return ModifyMaxPower(ctx) // Alias for ModifyMaxPower
}
// GetCurrentHP gets the spawn's current HP
func GetCurrentHP(ctx *events.EventContext) error {
spawn := ctx.GetSpawn()
if spawn == nil {
return fmt.Errorf("no spawn in context")
}
hp := spawn.GetHP()
ctx.SetResult("hp", hp)
return nil
}
// GetMaxHP gets the spawn's maximum HP
func GetMaxHP(ctx *events.EventContext) error {
spawn := ctx.GetSpawn()
if spawn == nil {
return fmt.Errorf("no spawn in context")
}
maxHP := spawn.GetTotalHP()
ctx.SetResult("max_hp", maxHP)
return nil
}
// GetMaxHPBase gets the spawn's base maximum HP (before bonuses)
func GetMaxHPBase(ctx *events.EventContext) error {
// TODO: Implement base HP system when available
return GetMaxHP(ctx) // Fallback to regular max HP for now
}
// GetCurrentPower gets the spawn's current power
func GetCurrentPower(ctx *events.EventContext) error {
spawn := ctx.GetSpawn()
if spawn == nil {
return fmt.Errorf("no spawn in context")
}
power := spawn.GetPower()
ctx.SetResult("power", power)
return nil
}
// GetMaxPower gets the spawn's maximum power
func GetMaxPower(ctx *events.EventContext) error {
spawn := ctx.GetSpawn()
if spawn == nil {
return fmt.Errorf("no spawn in context")
}
maxPower := spawn.GetTotalPower()
ctx.SetResult("max_power", maxPower)
return nil
}
// GetMaxPowerBase gets the spawn's base maximum power (before bonuses)
func GetMaxPowerBase(ctx *events.EventContext) error {
// TODO: Implement base power system when available
return GetMaxPower(ctx) // Fallback to regular max power for now
}
// GetPCTOfHP gets the percentage of current HP relative to max HP
func GetPCTOfHP(ctx *events.EventContext) error {
spawn := ctx.GetSpawn()
if spawn == nil {
return fmt.Errorf("no spawn in context")
}
currentHP := float64(spawn.GetHP())
maxHP := float64(spawn.GetTotalHP())
var percentage float64
if maxHP > 0 {
percentage = (currentHP / maxHP) * 100
} else {
percentage = 0
}
ctx.SetResult("hp_percentage", percentage)
return nil
}
// GetPCTOfPower gets the percentage of current power relative to max power
func GetPCTOfPower(ctx *events.EventContext) error {
spawn := ctx.GetSpawn()
if spawn == nil {
return fmt.Errorf("no spawn in context")
}
currentPower := float64(spawn.GetPower())
maxPower := float64(spawn.GetTotalPower())
var percentage float64
if maxPower > 0 {
percentage = (currentPower / maxPower) * 100
} else {
percentage = 0
}
ctx.SetResult("power_percentage", percentage)
return nil
}
// SpellHeal heals the spawn for a specific amount
func SpellHeal(ctx *events.EventContext) error {
spawn := ctx.GetSpawn()
if spawn == nil {
return fmt.Errorf("no spawn in context")
}
amount := ctx.GetParameterFloat("amount", 0)
if amount <= 0 {
return fmt.Errorf("heal amount must be positive")
}
current := float64(spawn.GetHP())
maxHP := float64(spawn.GetTotalHP())
newHP := current + amount
// Cap at max HP
if newHP > maxHP {
newHP = maxHP
amount = maxHP - current // Adjust amount to actual healed
}
spawn.SetHP(int32(newHP))
ctx.SetResult("amount_healed", amount)
ctx.Debug("Healed spawn %s for %f (new HP: %f)", spawn.GetName(), amount, newHP)
// Update alive state if necessary
if newHP > 0 && !spawn.IsAlive() {
spawn.SetAlive(true)
ctx.Debug("Spawn %s is now alive from healing", spawn.GetName())
}
return nil
}
// SpellHealPct heals the spawn for a percentage of max HP
func SpellHealPct(ctx *events.EventContext) error {
spawn := ctx.GetSpawn()
if spawn == nil {
return fmt.Errorf("no spawn in context")
}
percentage := ctx.GetParameterFloat("percentage", 0)
if percentage <= 0 {
return fmt.Errorf("heal percentage must be positive")
}
maxHP := float64(spawn.GetTotalHP())
healAmount := maxHP * (percentage / 100.0)
// Set the heal amount and delegate to SpellHeal
ctx.WithParameter("amount", healAmount)
return SpellHeal(ctx)
}
// IsAlive checks if the spawn is alive
func IsAlive(ctx *events.EventContext) error {
spawn := ctx.GetSpawn()
if spawn == nil {
return fmt.Errorf("no spawn in context")
}
ctx.SetResult("is_alive", spawn.IsAlive())
return nil
}