529 lines
14 KiB
Go
529 lines
14 KiB
Go
package player
|
|
|
|
// This file contains placeholder stub methods to make the player package compile
|
|
// These methods should be properly implemented when the corresponding systems are ready
|
|
|
|
import (
|
|
"eq2emu/internal/entity"
|
|
"eq2emu/internal/quests"
|
|
"eq2emu/internal/skills"
|
|
"eq2emu/internal/spells"
|
|
)
|
|
|
|
// Player-level flags handling since InfoStruct doesn't have these methods yet
|
|
var playerFlags = make(map[int32]int32)
|
|
var playerFlags2 = make(map[int32]int32)
|
|
|
|
// GetPlayerFlags returns player flags for a character
|
|
func (p *Player) GetPlayerFlags() int32 {
|
|
return playerFlags[p.GetCharacterID()]
|
|
}
|
|
|
|
// SetPlayerFlags sets player flags for a character
|
|
func (p *Player) SetPlayerFlags(flags int32) {
|
|
playerFlags[p.GetCharacterID()] = flags
|
|
}
|
|
|
|
// GetPlayerFlags2 returns player flags2 for a character
|
|
func (p *Player) GetPlayerFlags2() int32 {
|
|
return playerFlags2[p.GetCharacterID()]
|
|
}
|
|
|
|
// SetPlayerFlags2 sets player flags2 for a character
|
|
func (p *Player) SetPlayerFlags2(flags int32) {
|
|
playerFlags2[p.GetCharacterID()] = flags
|
|
}
|
|
|
|
// Player stub methods that may be called by other packages
|
|
|
|
// GetPrimaryStat returns the primary stat for the player's class (stub)
|
|
func (p *Player) GetPrimaryStat() int32 {
|
|
// TODO: Calculate based on class
|
|
return 100
|
|
}
|
|
|
|
// GetTarget returns the player's current target (stub)
|
|
func (p *Player) GetTarget() interface{} {
|
|
// TODO: Implement targeting system
|
|
return nil
|
|
}
|
|
|
|
// IsStunned returns whether the player is stunned (stub)
|
|
func (p *Player) IsStunned() bool {
|
|
// TODO: Implement status effect system
|
|
return false
|
|
}
|
|
|
|
// IsMezzed returns whether the player is mezzed (stub)
|
|
func (p *Player) IsMezzed() bool {
|
|
// TODO: Implement status effect system
|
|
return false
|
|
}
|
|
|
|
// Player-level combat state handling
|
|
var playerEngageCommands = make(map[int32]int32)
|
|
|
|
// GetPlayerEngageCommands returns combat state for a character
|
|
func (p *Player) GetPlayerEngageCommands() int32 {
|
|
return playerEngageCommands[p.GetCharacterID()]
|
|
}
|
|
|
|
// SetPlayerEngageCommands sets combat state for a character
|
|
func (p *Player) SetPlayerEngageCommands(commands int32) {
|
|
playerEngageCommands[p.GetCharacterID()] = commands
|
|
}
|
|
|
|
// IsDead returns whether the player is dead (stub)
|
|
func (p *Player) IsDead() bool {
|
|
// TODO: Implement death state tracking
|
|
return p.GetHP() <= 0
|
|
}
|
|
|
|
// Note: IsPlayer method is already implemented in player.go, so removed duplicate
|
|
|
|
// Entity stub methods for combat target
|
|
var entityDeathState = make(map[*entity.Entity]bool)
|
|
|
|
// IsDead checks if an entity is dead (stub for Entity type)
|
|
func IsDead(e *entity.Entity) bool {
|
|
// TODO: Implement proper entity death checking
|
|
return entityDeathState[e]
|
|
}
|
|
|
|
// Coin management stubs
|
|
var playerCoins = make(map[int32]int64) // characterID -> coin amount
|
|
|
|
// AddCoin adds coins to the player's InfoStruct (stub)
|
|
func (p *Player) AddCoin(amount int64) {
|
|
current := playerCoins[p.GetCharacterID()]
|
|
playerCoins[p.GetCharacterID()] = current + amount
|
|
}
|
|
|
|
// GetCoin returns the player's current coin amount (stub)
|
|
func (p *Player) GetCoin() int64 {
|
|
return playerCoins[p.GetCharacterID()]
|
|
}
|
|
|
|
// SubtractCoin removes coins from the player (stub)
|
|
func (p *Player) SubtractCoin(amount int64) bool {
|
|
current := playerCoins[p.GetCharacterID()]
|
|
if current >= amount {
|
|
playerCoins[p.GetCharacterID()] = current - amount
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// InfoStruct coin access stubs - these methods don't exist on InfoStruct yet
|
|
var playerCoinBreakdown = make(map[int32]map[string]int32) // characterID -> coin type -> amount
|
|
|
|
// GetCoinCopper returns copper coins (stub)
|
|
func (p *Player) GetInfoStructCoinCopper() int32 {
|
|
if playerCoinBreakdown[p.GetCharacterID()] == nil {
|
|
return 0
|
|
}
|
|
return playerCoinBreakdown[p.GetCharacterID()]["copper"]
|
|
}
|
|
|
|
// GetCoinSilver returns silver coins (stub)
|
|
func (p *Player) GetInfoStructCoinSilver() int32 {
|
|
if playerCoinBreakdown[p.GetCharacterID()] == nil {
|
|
return 0
|
|
}
|
|
return playerCoinBreakdown[p.GetCharacterID()]["silver"]
|
|
}
|
|
|
|
// GetCoinGold returns gold coins (stub)
|
|
func (p *Player) GetInfoStructCoinGold() int32 {
|
|
if playerCoinBreakdown[p.GetCharacterID()] == nil {
|
|
return 0
|
|
}
|
|
return playerCoinBreakdown[p.GetCharacterID()]["gold"]
|
|
}
|
|
|
|
// GetCoinPlat returns platinum coins (stub)
|
|
func (p *Player) GetInfoStructCoinPlat() int32 {
|
|
if playerCoinBreakdown[p.GetCharacterID()] == nil {
|
|
return 0
|
|
}
|
|
return playerCoinBreakdown[p.GetCharacterID()]["plat"]
|
|
}
|
|
|
|
// Bank coin methods (stubs)
|
|
func (p *Player) GetInfoStructBankCoinCopper() int32 {
|
|
if playerCoinBreakdown[p.GetCharacterID()] == nil {
|
|
return 0
|
|
}
|
|
return playerCoinBreakdown[p.GetCharacterID()]["bank_copper"]
|
|
}
|
|
|
|
func (p *Player) GetInfoStructBankCoinSilver() int32 {
|
|
if playerCoinBreakdown[p.GetCharacterID()] == nil {
|
|
return 0
|
|
}
|
|
return playerCoinBreakdown[p.GetCharacterID()]["bank_silver"]
|
|
}
|
|
|
|
func (p *Player) GetInfoStructBankCoinGold() int32 {
|
|
if playerCoinBreakdown[p.GetCharacterID()] == nil {
|
|
return 0
|
|
}
|
|
return playerCoinBreakdown[p.GetCharacterID()]["bank_gold"]
|
|
}
|
|
|
|
func (p *Player) GetInfoStructBankCoinPlat() int32 {
|
|
if playerCoinBreakdown[p.GetCharacterID()] == nil {
|
|
return 0
|
|
}
|
|
return playerCoinBreakdown[p.GetCharacterID()]["bank_plat"]
|
|
}
|
|
|
|
// GetStatusPoints returns status points (stub)
|
|
func (p *Player) GetInfoStructStatusPoints() int32 {
|
|
if playerCoinBreakdown[p.GetCharacterID()] == nil {
|
|
return 0
|
|
}
|
|
return playerCoinBreakdown[p.GetCharacterID()]["status"]
|
|
}
|
|
|
|
// Player methods that don't exist on Entity/Spawn yet (stubs)
|
|
func (p *Player) SetRace(race int8) {
|
|
// TODO: Implement race setting on entity/spawn
|
|
// For now, store in a map
|
|
if playerCoinBreakdown[p.GetCharacterID()] == nil {
|
|
playerCoinBreakdown[p.GetCharacterID()] = make(map[string]int32)
|
|
}
|
|
playerCoinBreakdown[p.GetCharacterID()]["race"] = int32(race)
|
|
}
|
|
|
|
func (p *Player) GetRace() int8 {
|
|
// TODO: Implement race getting from entity/spawn
|
|
if playerCoinBreakdown[p.GetCharacterID()] == nil {
|
|
return 0
|
|
}
|
|
return int8(playerCoinBreakdown[p.GetCharacterID()]["race"])
|
|
}
|
|
|
|
func (p *Player) SetZone(zoneID int32) {
|
|
// TODO: Implement zone setting on entity/spawn
|
|
if playerCoinBreakdown[p.GetCharacterID()] == nil {
|
|
playerCoinBreakdown[p.GetCharacterID()] = make(map[string]int32)
|
|
}
|
|
playerCoinBreakdown[p.GetCharacterID()]["zone"] = zoneID
|
|
}
|
|
|
|
func (p *Player) GetZone() int32 {
|
|
// TODO: Implement zone getting from entity/spawn
|
|
if playerCoinBreakdown[p.GetCharacterID()] == nil {
|
|
return 0
|
|
}
|
|
return playerCoinBreakdown[p.GetCharacterID()]["zone"]
|
|
}
|
|
|
|
// Experience vitality methods (InfoStruct stubs)
|
|
func (p *Player) GetInfoStructXPVitality() float32 {
|
|
// TODO: Implement XP vitality tracking
|
|
return 100.0 // Default vitality
|
|
}
|
|
|
|
func (p *Player) GetInfoStructTSXPVitality() float32 {
|
|
// TODO: Implement tradeskill XP vitality tracking
|
|
return 100.0 // Default vitality
|
|
}
|
|
|
|
// More InfoStruct experience method stubs
|
|
var playerXPData = make(map[int32]map[string]float64) // characterID -> xp type -> value
|
|
|
|
func (p *Player) GetInfoStructXPDebt() float32 {
|
|
charID := p.GetCharacterID()
|
|
if playerXPData[charID] == nil {
|
|
return 0.0
|
|
}
|
|
return float32(playerXPData[charID]["xp_debt"])
|
|
}
|
|
|
|
func (p *Player) GetInfoStructTSXPDebt() float32 {
|
|
charID := p.GetCharacterID()
|
|
if playerXPData[charID] == nil {
|
|
return 0.0
|
|
}
|
|
return float32(playerXPData[charID]["ts_xp_debt"])
|
|
}
|
|
|
|
func (p *Player) SetInfoStructXPNeeded(xp float64) {
|
|
charID := p.GetCharacterID()
|
|
if playerXPData[charID] == nil {
|
|
playerXPData[charID] = make(map[string]float64)
|
|
}
|
|
playerXPData[charID]["xp_needed"] = xp
|
|
}
|
|
|
|
func (p *Player) SetInfoStructXP(xp float64) {
|
|
charID := p.GetCharacterID()
|
|
if playerXPData[charID] == nil {
|
|
playerXPData[charID] = make(map[string]float64)
|
|
}
|
|
playerXPData[charID]["xp"] = xp
|
|
}
|
|
|
|
func (p *Player) SetInfoStructTSXPNeeded(xp float64) {
|
|
charID := p.GetCharacterID()
|
|
if playerXPData[charID] == nil {
|
|
playerXPData[charID] = make(map[string]float64)
|
|
}
|
|
playerXPData[charID]["ts_xp_needed"] = xp
|
|
}
|
|
|
|
func (p *Player) SetInfoStructTSXP(xp float64) {
|
|
charID := p.GetCharacterID()
|
|
if playerXPData[charID] == nil {
|
|
playerXPData[charID] = make(map[string]float64)
|
|
}
|
|
playerXPData[charID]["ts_xp"] = xp
|
|
}
|
|
|
|
func (p *Player) GetInfoStructXPNeeded() float64 {
|
|
charID := p.GetCharacterID()
|
|
if playerXPData[charID] == nil {
|
|
return 1000.0 // Default XP needed
|
|
}
|
|
return playerXPData[charID]["xp_needed"]
|
|
}
|
|
|
|
func (p *Player) GetInfoStructXP() float64 {
|
|
charID := p.GetCharacterID()
|
|
if playerXPData[charID] == nil {
|
|
return 0.0
|
|
}
|
|
return playerXPData[charID]["xp"]
|
|
}
|
|
|
|
func (p *Player) GetInfoStructTSXPNeeded() float64 {
|
|
charID := p.GetCharacterID()
|
|
if playerXPData[charID] == nil {
|
|
return 1000.0 // Default TS XP needed
|
|
}
|
|
return playerXPData[charID]["ts_xp_needed"]
|
|
}
|
|
|
|
func (p *Player) GetInfoStructTSXP() float64 {
|
|
charID := p.GetCharacterID()
|
|
if playerXPData[charID] == nil {
|
|
return 0.0
|
|
}
|
|
return playerXPData[charID]["ts_xp"]
|
|
}
|
|
|
|
// XP Debt methods
|
|
func (p *Player) SetInfoStructXPDebt(debt float32) {
|
|
charID := p.GetCharacterID()
|
|
if playerXPData[charID] == nil {
|
|
playerXPData[charID] = make(map[string]float64)
|
|
}
|
|
playerXPData[charID]["xp_debt"] = float64(debt)
|
|
}
|
|
|
|
func (p *Player) SetInfoStructTSXPDebt(debt float32) {
|
|
charID := p.GetCharacterID()
|
|
if playerXPData[charID] == nil {
|
|
playerXPData[charID] = make(map[string]float64)
|
|
}
|
|
playerXPData[charID]["ts_xp_debt"] = float64(debt)
|
|
}
|
|
|
|
// TS Level methods
|
|
func (p *Player) GetInfoStructTSLevel() int8 {
|
|
charID := p.GetCharacterID()
|
|
if playerXPData[charID] == nil {
|
|
return 1 // Default level
|
|
}
|
|
return int8(playerXPData[charID]["ts_level"])
|
|
}
|
|
|
|
func (p *Player) SetInfoStructTSLevel(level int8) {
|
|
charID := p.GetCharacterID()
|
|
if playerXPData[charID] == nil {
|
|
playerXPData[charID] = make(map[string]float64)
|
|
}
|
|
playerXPData[charID]["ts_level"] = float64(level)
|
|
}
|
|
|
|
// Player wrapper methods for TS level
|
|
func (p *Player) GetTSLevel() int8 {
|
|
return p.GetInfoStructTSLevel()
|
|
}
|
|
|
|
func (p *Player) SetTSLevel(level int8) {
|
|
p.SetInfoStructTSLevel(level)
|
|
p.SetCharSheetChanged(true)
|
|
}
|
|
|
|
// GetSpawnID returns the spawn ID (in EverQuest II, players use same ID as spawn)
|
|
func (p *Player) GetSpawnID() int32 {
|
|
// Use the player's spawnID field
|
|
return p.spawnID
|
|
}
|
|
|
|
// SetSpawnID sets the spawn ID
|
|
func (p *Player) SetSpawnID(id int32) {
|
|
p.spawnID = id
|
|
}
|
|
|
|
// AddSecondaryEntityCommand adds a secondary command (stub)
|
|
func (p *Player) AddSecondaryEntityCommand(name string, distance float32, command, errorText string, castTime int16, spellID int32) {
|
|
// TODO: Implement secondary entity commands
|
|
}
|
|
|
|
// Position and movement data storage (stubs for appearance system)
|
|
var playerMovementData = make(map[int32]map[string]float32) // characterID -> movement type -> value
|
|
|
|
// SetPos sets positional data (stub)
|
|
func (p *Player) SetPos(ptr *float32, value float32, updateFlags bool) {
|
|
// Since we can't access the appearance system, just store the value
|
|
charID := p.GetCharacterID()
|
|
if playerMovementData[charID] == nil {
|
|
playerMovementData[charID] = make(map[string]float32)
|
|
}
|
|
*ptr = value // Set the pointer value if it's valid
|
|
// TODO: Handle updateFlags when packet system is available
|
|
}
|
|
|
|
// GetPos gets positional data (stub)
|
|
func (p *Player) GetPos(key string) float32 {
|
|
charID := p.GetCharacterID()
|
|
if playerMovementData[charID] == nil {
|
|
return 0.0
|
|
}
|
|
return playerMovementData[charID][key]
|
|
}
|
|
|
|
// XP bar display methods (InfoStruct stubs)
|
|
func (p *Player) SetInfoStructXPYellow(value int16) {
|
|
// TODO: Implement XP bar display
|
|
}
|
|
|
|
func (p *Player) SetInfoStructXPBlue(value int16) {
|
|
// TODO: Implement XP bar display
|
|
}
|
|
|
|
func (p *Player) SetInfoStructXPBlueVitalityBar(value int16) {
|
|
// TODO: Implement XP bar display
|
|
}
|
|
|
|
func (p *Player) SetInfoStructXPYellowVitalityBar(value int16) {
|
|
// TODO: Implement XP bar display
|
|
}
|
|
|
|
func (p *Player) SetInfoStructTSXPYellow(value int16) {
|
|
// TODO: Implement TS XP bar display
|
|
}
|
|
|
|
func (p *Player) SetInfoStructTSXPBlue(value int16) {
|
|
// TODO: Implement TS XP bar display
|
|
}
|
|
|
|
func (p *Player) SetInfoStructTSXPBlueVitalityBar(value int16) {
|
|
// TODO: Implement TS XP bar display
|
|
}
|
|
|
|
func (p *Player) SetInfoStructTSXPYellowVitalityBar(value int16) {
|
|
// TODO: Implement TS XP bar display
|
|
}
|
|
|
|
// XP bar getter methods (InfoStruct stubs)
|
|
func (p *Player) GetInfoStructXPBlue() int16 {
|
|
// TODO: Implement XP bar display
|
|
return 0
|
|
}
|
|
|
|
func (p *Player) GetInfoStructXPYellow() int16 {
|
|
// TODO: Implement XP bar display
|
|
return 0
|
|
}
|
|
|
|
// Tradeskill XP bar methods
|
|
func (p *Player) SetInfoStructTradeskillExpYellow(value int16) {
|
|
// TODO: Implement TS XP bar display
|
|
}
|
|
|
|
func (p *Player) SetInfoStructTradeskillExpBlue(value int16) {
|
|
// TODO: Implement TS XP bar display
|
|
}
|
|
|
|
func (p *Player) SetInfoStructTSExpVitalityBlue(value int16) {
|
|
// TODO: Implement TS XP vitality bar display
|
|
}
|
|
|
|
func (p *Player) SetInfoStructTSExpVitalityYellow(value int16) {
|
|
// TODO: Implement TS XP vitality bar display
|
|
}
|
|
|
|
func (p *Player) GetInfoStructTradeskillExpBlue() int16 {
|
|
// TODO: Implement TS XP bar display
|
|
return 0
|
|
}
|
|
|
|
func (p *Player) GetInfoStructTradeskillExpYellow() int16 {
|
|
// TODO: Implement TS XP bar display
|
|
return 0
|
|
}
|
|
|
|
// Account age methods (InfoStruct stubs)
|
|
func (p *Player) SetInfoStructAccountAgeBase(value int32) {
|
|
// TODO: Implement account age tracking
|
|
}
|
|
|
|
func (p *Player) SetInfoStructAccountAge(value int32) {
|
|
// TODO: Implement account age tracking
|
|
}
|
|
|
|
// Quest helper functions - working around missing quest methods
|
|
// These should ideally be proper methods on the Quest type in the quests package
|
|
|
|
func GetQuestCompleteCount(q *quests.Quest) int32 {
|
|
// TODO: Implement quest completion tracking
|
|
// For now return 0 as a placeholder
|
|
return 0
|
|
}
|
|
|
|
func GetQuestID(q *quests.Quest) int32 {
|
|
// TODO: This should access q.ID field when available
|
|
return 0
|
|
}
|
|
|
|
func GetQuestStep(q *quests.Quest) int16 {
|
|
// TODO: Implement quest step retrieval
|
|
return 0
|
|
}
|
|
|
|
func GetQuestTaskGroup(q *quests.Quest) int8 {
|
|
// TODO: Implement quest task group system
|
|
return 0
|
|
}
|
|
|
|
func IncrementQuestCompleteCount(q *quests.Quest) {
|
|
// TODO: Implement quest completion tracking
|
|
}
|
|
|
|
// PlayerSkillList helper methods to work around method signature differences
|
|
func (p *Player) GetSkillByNameHelper(name string, checkUpdate bool) *skills.Skill {
|
|
// TODO: Work around method signature mismatch
|
|
// The actual method only takes name as parameter
|
|
return p.skillList.GetSkillByName(name)
|
|
}
|
|
|
|
func (p *Player) AddSkillHelper(skillID int32, currentVal, maxVal int16, saveNeeded bool) {
|
|
// TODO: Create proper Skill object and add it
|
|
// For now, this is a placeholder stub
|
|
}
|
|
|
|
func (p *Player) RemoveSkillHelper(skillID int32) {
|
|
// TODO: Remove skill by ID
|
|
// For now, this is a placeholder stub
|
|
}
|
|
|
|
// SpellData method stubs
|
|
func GetSpellLinkedTimerID(spellData *spells.SpellData) int32 {
|
|
// TODO: Implement LinkedTimerID field access
|
|
return 0
|
|
} |