simplify/ehance classes
This commit is contained in:
parent
32143aab1a
commit
f99343f490
@ -1,359 +0,0 @@
|
||||
package classes
|
||||
|
||||
import (
|
||||
"strings"
|
||||
)
|
||||
|
||||
// classMap contains the mapping of class names to IDs
|
||||
var classMap = map[string]int8{
|
||||
"COMMONER": ClassCommoner,
|
||||
"FIGHTER": ClassFighter,
|
||||
"WARRIOR": ClassWarrior,
|
||||
"GUARDIAN": ClassGuardian,
|
||||
"BERSERKER": ClassBerserker,
|
||||
"BRAWLER": ClassBrawler,
|
||||
"MONK": ClassMonk,
|
||||
"BRUISER": ClassBruiser,
|
||||
"CRUSADER": ClassCrusader,
|
||||
"SHADOWKNIGHT": ClassShadowknight,
|
||||
"PALADIN": ClassPaladin,
|
||||
"PRIEST": ClassPriest,
|
||||
"CLERIC": ClassCleric,
|
||||
"TEMPLAR": ClassTemplar,
|
||||
"INQUISITOR": ClassInquisitor,
|
||||
"DRUID": ClassDruid,
|
||||
"WARDEN": ClassWarden,
|
||||
"FURY": ClassFury,
|
||||
"SHAMAN": ClassShaman,
|
||||
"MYSTIC": ClassMystic,
|
||||
"DEFILER": ClassDefiler,
|
||||
"MAGE": ClassMage,
|
||||
"SORCERER": ClassSorcerer,
|
||||
"WIZARD": ClassWizard,
|
||||
"WARLOCK": ClassWarlock,
|
||||
"ENCHANTER": ClassEnchanter,
|
||||
"ILLUSIONIST": ClassIllusionist,
|
||||
"COERCER": ClassCoercer,
|
||||
"SUMMONER": ClassSummoner,
|
||||
"CONJUROR": ClassConjuror,
|
||||
"NECROMANCER": ClassNecromancer,
|
||||
"SCOUT": ClassScout,
|
||||
"ROGUE": ClassRogue,
|
||||
"SWASHBUCKLER": ClassSwashbuckler,
|
||||
"BRIGAND": ClassBrigand,
|
||||
"BARD": ClassBard,
|
||||
"TROUBADOR": ClassTroubador,
|
||||
"DIRGE": ClassDirge,
|
||||
"PREDATOR": ClassPredator,
|
||||
"RANGER": ClassRanger,
|
||||
"ASSASSIN": ClassAssassin,
|
||||
"ANIMALIST": ClassAnimalist,
|
||||
"BEASTLORD": ClassBeastlord,
|
||||
"SHAPER": ClassShaper,
|
||||
"CHANNELER": ClassChanneler,
|
||||
"ARTISAN": ClassArtisan,
|
||||
"CRAFTSMAN": ClassCraftsman,
|
||||
"PROVISIONER": ClassProvisioner,
|
||||
"WOODWORKER": ClassWoodworker,
|
||||
"CARPENTER": ClassCarpenter,
|
||||
"OUTFITTER": ClassOutfitter,
|
||||
"ARMORER": ClassArmorer,
|
||||
"WEAPONSMITH": ClassWeaponsmith,
|
||||
"TAILOR": ClassTailor,
|
||||
"SCHOLAR": ClassScholar,
|
||||
"JEWELER": ClassJeweler,
|
||||
"SAGE": ClassSage,
|
||||
"ALCHEMIST": ClassAlchemist,
|
||||
}
|
||||
|
||||
// displayNameMap contains the display names for each class ID
|
||||
var displayNameMap = map[int8]string{
|
||||
ClassCommoner: "Commoner",
|
||||
ClassFighter: "Fighter",
|
||||
ClassWarrior: "Warrior",
|
||||
ClassGuardian: "Guardian",
|
||||
ClassBerserker: "Berserker",
|
||||
ClassBrawler: "Brawler",
|
||||
ClassMonk: "Monk",
|
||||
ClassBruiser: "Bruiser",
|
||||
ClassCrusader: "Crusader",
|
||||
ClassShadowknight: "Shadowknight",
|
||||
ClassPaladin: "Paladin",
|
||||
ClassPriest: "Priest",
|
||||
ClassCleric: "Cleric",
|
||||
ClassTemplar: "Templar",
|
||||
ClassInquisitor: "Inquisitor",
|
||||
ClassDruid: "Druid",
|
||||
ClassWarden: "Warden",
|
||||
ClassFury: "Fury",
|
||||
ClassShaman: "Shaman",
|
||||
ClassMystic: "Mystic",
|
||||
ClassDefiler: "Defiler",
|
||||
ClassMage: "Mage",
|
||||
ClassSorcerer: "Sorcerer",
|
||||
ClassWizard: "Wizard",
|
||||
ClassWarlock: "Warlock",
|
||||
ClassEnchanter: "Enchanter",
|
||||
ClassIllusionist: "Illusionist",
|
||||
ClassCoercer: "Coercer",
|
||||
ClassSummoner: "Summoner",
|
||||
ClassConjuror: "Conjuror",
|
||||
ClassNecromancer: "Necromancer",
|
||||
ClassScout: "Scout",
|
||||
ClassRogue: "Rogue",
|
||||
ClassSwashbuckler: "Swashbuckler",
|
||||
ClassBrigand: "Brigand",
|
||||
ClassBard: "Bard",
|
||||
ClassTroubador: "Troubador",
|
||||
ClassDirge: "Dirge",
|
||||
ClassPredator: "Predator",
|
||||
ClassRanger: "Ranger",
|
||||
ClassAssassin: "Assassin",
|
||||
ClassAnimalist: "Animalist",
|
||||
ClassBeastlord: "Beastlord",
|
||||
ClassShaper: "Shaper",
|
||||
ClassChanneler: "Channeler",
|
||||
ClassArtisan: "Artisan",
|
||||
ClassCraftsman: "Craftsman",
|
||||
ClassProvisioner: "Provisioner",
|
||||
ClassWoodworker: "Woodworker",
|
||||
ClassCarpenter: "Carpenter",
|
||||
ClassOutfitter: "Outfitter",
|
||||
ClassArmorer: "Armorer",
|
||||
ClassWeaponsmith: "Weaponsmith",
|
||||
ClassTailor: "Tailor",
|
||||
ClassScholar: "Scholar",
|
||||
ClassJeweler: "Jeweler",
|
||||
ClassSage: "Sage",
|
||||
ClassAlchemist: "Alchemist",
|
||||
}
|
||||
|
||||
// GetClassID returns the class ID for a given class name
|
||||
// Converted from C++ Classes::GetClassID
|
||||
func GetClassID(name string) int8 {
|
||||
className := strings.ToUpper(strings.TrimSpace(name))
|
||||
if classID, exists := classMap[className]; exists {
|
||||
return classID
|
||||
}
|
||||
return -1 // Invalid class
|
||||
}
|
||||
|
||||
// GetClassName returns the uppercase class name for a given ID
|
||||
// Converted from C++ Classes::GetClassName
|
||||
func GetClassName(classID int8) string {
|
||||
// Search through class map to find the name
|
||||
for name, id := range classMap {
|
||||
if id == classID {
|
||||
return name
|
||||
}
|
||||
}
|
||||
return "" // Invalid class ID
|
||||
}
|
||||
|
||||
// GetClassNameCase returns the friendly display name for a given class ID
|
||||
// Converted from C++ Classes::GetClassNameCase
|
||||
func GetClassNameCase(classID int8) string {
|
||||
if displayName, exists := displayNameMap[classID]; exists {
|
||||
return displayName
|
||||
}
|
||||
return "" // Invalid class ID
|
||||
}
|
||||
|
||||
// GetBaseClass returns the base class ID for a given class
|
||||
// Converted from C++ Classes::GetBaseClass
|
||||
func GetBaseClass(classID int8) int8 {
|
||||
if classID >= ClassWarrior && classID <= ClassPaladin {
|
||||
return ClassFighter
|
||||
}
|
||||
if (classID >= ClassCleric && classID <= ClassDefiler) || (classID == ClassShaper || classID == ClassChanneler) {
|
||||
return ClassPriest
|
||||
}
|
||||
if classID >= ClassSorcerer && classID <= ClassNecromancer {
|
||||
return ClassMage
|
||||
}
|
||||
if classID >= ClassRogue && classID <= ClassBeastlord {
|
||||
return ClassScout
|
||||
}
|
||||
return ClassCommoner // Default for unknown classes
|
||||
}
|
||||
|
||||
// GetSecondaryBaseClass returns the secondary base class ID for specialized classes
|
||||
// Converted from C++ Classes::GetSecondaryBaseClass
|
||||
func GetSecondaryBaseClass(classID int8) int8 {
|
||||
switch classID {
|
||||
case ClassGuardian, ClassBerserker:
|
||||
return ClassWarrior
|
||||
case ClassMonk, ClassBruiser:
|
||||
return ClassBrawler
|
||||
case ClassShadowknight, ClassPaladin:
|
||||
return ClassCrusader
|
||||
case ClassTemplar, ClassInquisitor:
|
||||
return ClassCleric
|
||||
case ClassWarden, ClassFury:
|
||||
return ClassDruid
|
||||
case ClassMystic, ClassDefiler:
|
||||
return ClassShaman
|
||||
case ClassWizard, ClassWarlock:
|
||||
return ClassSorcerer
|
||||
case ClassIllusionist, ClassCoercer:
|
||||
return ClassEnchanter
|
||||
case ClassConjuror, ClassNecromancer:
|
||||
return ClassSummoner
|
||||
case ClassSwashbuckler, ClassBrigand:
|
||||
return ClassRogue
|
||||
case ClassTroubador, ClassDirge:
|
||||
return ClassBard
|
||||
case ClassRanger, ClassAssassin:
|
||||
return ClassPredator
|
||||
case ClassBeastlord:
|
||||
return ClassAnimalist
|
||||
case ClassChanneler:
|
||||
return ClassShaper
|
||||
}
|
||||
return ClassCommoner // Default for unknown classes
|
||||
}
|
||||
|
||||
// GetTSBaseClass returns the tradeskill base class ID
|
||||
// Converted from C++ Classes::GetTSBaseClass
|
||||
func GetTSBaseClass(classID int8) int8 {
|
||||
// This function maps tradeskill class IDs to their base tradeskill progression levels
|
||||
// The C++ code uses offset of 42 between adventure and tradeskill class systems
|
||||
if classID+42 >= ClassArtisan {
|
||||
return ClassArtisan - 44 // Returns 1 (base artisan level)
|
||||
}
|
||||
return classID // For non-tradeskill classes, return as-is
|
||||
}
|
||||
|
||||
// GetSecondaryTSBaseClass returns the secondary tradeskill base class ID
|
||||
// Converted from C++ Classes::GetSecondaryTSBaseClass
|
||||
func GetSecondaryTSBaseClass(classID int8) int8 {
|
||||
ret := classID + 42
|
||||
|
||||
if ret == ClassArtisan {
|
||||
return ClassArtisan - 44
|
||||
} else if ret >= ClassCraftsman && ret < ClassOutfitter {
|
||||
return ClassCraftsman - 44
|
||||
} else if ret >= ClassOutfitter && ret < ClassScholar {
|
||||
return ClassOutfitter - 44
|
||||
} else if ret >= ClassScholar {
|
||||
return ClassScholar - 44
|
||||
}
|
||||
|
||||
return classID
|
||||
}
|
||||
|
||||
// IsValidClassID checks if a class ID is valid
|
||||
func IsValidClassID(classID int8) bool {
|
||||
return classID >= MinClassID && classID <= MaxClassID
|
||||
}
|
||||
|
||||
// IsAdventureClass checks if a class is an adventure class
|
||||
func IsAdventureClass(classID int8) bool {
|
||||
return classID >= ClassCommoner && classID <= ClassChanneler
|
||||
}
|
||||
|
||||
// IsTradeskillClass checks if a class is a tradeskill class
|
||||
func IsTradeskillClass(classID int8) bool {
|
||||
return classID >= ClassArtisan && classID <= ClassAlchemist
|
||||
}
|
||||
|
||||
// GetClassType returns the type of class (adventure, tradeskill, etc.)
|
||||
func GetClassType(classID int8) string {
|
||||
if IsAdventureClass(classID) {
|
||||
return ClassTypeAdventure
|
||||
}
|
||||
if IsTradeskillClass(classID) {
|
||||
return ClassTypeTradeskill
|
||||
}
|
||||
return ClassTypeSpecial
|
||||
}
|
||||
|
||||
// GetAllClasses returns all class IDs and their display names
|
||||
func GetAllClasses() map[int8]string {
|
||||
result := make(map[int8]string)
|
||||
for classID, displayName := range displayNameMap {
|
||||
result[classID] = displayName
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// GetClassInfo returns comprehensive information about a class
|
||||
func GetClassInfo(classID int8) map[string]any {
|
||||
info := make(map[string]any)
|
||||
|
||||
if !IsValidClassID(classID) {
|
||||
info["valid"] = false
|
||||
return info
|
||||
}
|
||||
|
||||
info["valid"] = true
|
||||
info["class_id"] = classID
|
||||
info["name"] = GetClassName(classID)
|
||||
info["display_name"] = GetClassNameCase(classID)
|
||||
info["base_class"] = GetBaseClass(classID)
|
||||
info["secondary_base_class"] = GetSecondaryBaseClass(classID)
|
||||
info["type"] = GetClassType(classID)
|
||||
info["is_adventure"] = IsAdventureClass(classID)
|
||||
info["is_tradeskill"] = IsTradeskillClass(classID)
|
||||
|
||||
return info
|
||||
}
|
||||
|
||||
// GetClassHierarchy returns the full class hierarchy for a given class
|
||||
func GetClassHierarchy(classID int8) []int8 {
|
||||
if !IsValidClassID(classID) {
|
||||
return nil
|
||||
}
|
||||
|
||||
hierarchy := []int8{classID}
|
||||
|
||||
// Add secondary base class if it exists
|
||||
secondary := GetSecondaryBaseClass(classID)
|
||||
if secondary != ClassCommoner && secondary != classID {
|
||||
hierarchy = append(hierarchy, secondary)
|
||||
}
|
||||
|
||||
// Add base class
|
||||
base := GetBaseClass(classID)
|
||||
if base != ClassCommoner && base != classID {
|
||||
// Check if base is already in hierarchy (from secondary)
|
||||
found := false
|
||||
for _, id := range hierarchy {
|
||||
if id == base {
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
hierarchy = append(hierarchy, base)
|
||||
}
|
||||
}
|
||||
|
||||
// Always add Commoner as the root
|
||||
if classID != ClassCommoner {
|
||||
hierarchy = append(hierarchy, ClassCommoner)
|
||||
}
|
||||
|
||||
return hierarchy
|
||||
}
|
||||
|
||||
// IsSameArchetype checks if two classes share the same base archetype
|
||||
func IsSameArchetype(classID1, classID2 int8) bool {
|
||||
if !IsValidClassID(classID1) || !IsValidClassID(classID2) {
|
||||
return false
|
||||
}
|
||||
return GetBaseClass(classID1) == GetBaseClass(classID2)
|
||||
}
|
||||
|
||||
// GetArchetypeClasses returns all classes of a given archetype
|
||||
func GetArchetypeClasses(archetypeID int8) []int8 {
|
||||
var classes []int8
|
||||
|
||||
for classID := MinClassID; classID <= MaxClassID; classID++ {
|
||||
if GetBaseClass(classID) == archetypeID {
|
||||
classes = append(classes, classID)
|
||||
}
|
||||
}
|
||||
|
||||
return classes
|
||||
}
|
||||
540
internal/classes/classes.go
Normal file
540
internal/classes/classes.go
Normal file
@ -0,0 +1,540 @@
|
||||
package classes
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"sync"
|
||||
)
|
||||
|
||||
// Class represents a character class with all its properties
|
||||
type Class struct {
|
||||
ID int8 `json:"id"`
|
||||
Name string `json:"name"` // Uppercase name (WARRIOR)
|
||||
DisplayName string `json:"display_name"` // Friendly name (Warrior)
|
||||
BaseClass int8 `json:"base_class"` // Primary archetype
|
||||
SecondaryBaseClass int8 `json:"secondary_base"` // Secondary archetype
|
||||
ClassType string `json:"type"` // adventure/tradeskill/special
|
||||
IsAdventure bool `json:"is_adventure"`
|
||||
IsTradeskill bool `json:"is_tradeskill"`
|
||||
}
|
||||
|
||||
// GetID returns the class ID
|
||||
func (c *Class) GetID() int8 {
|
||||
return c.ID
|
||||
}
|
||||
|
||||
// GetName returns the uppercase class name (C++ API compatibility)
|
||||
func (c *Class) GetName() string {
|
||||
return c.Name
|
||||
}
|
||||
|
||||
// GetDisplayName returns the friendly display name
|
||||
func (c *Class) GetDisplayName() string {
|
||||
return c.DisplayName
|
||||
}
|
||||
|
||||
// GetBaseClass returns the base archetype (C++ API compatibility)
|
||||
func (c *Class) GetBaseClass() int8 {
|
||||
return c.BaseClass
|
||||
}
|
||||
|
||||
// GetSecondaryBaseClass returns the secondary archetype (C++ API compatibility)
|
||||
func (c *Class) GetSecondaryBaseClass() int8 {
|
||||
return c.SecondaryBaseClass
|
||||
}
|
||||
|
||||
// IsValid returns true if the class ID is valid
|
||||
func (c *Class) IsValid() bool {
|
||||
return c.ID >= MinClassID && c.ID <= MaxClassID
|
||||
}
|
||||
|
||||
// Manager provides centralized class management with caching and lookup optimization
|
||||
type Manager struct {
|
||||
classes map[int8]*Class // ID -> Class
|
||||
nameToID map[string]int8 // Uppercase name -> ID
|
||||
displayNameMap map[int8]string // ID -> Display name
|
||||
mutex sync.RWMutex
|
||||
|
||||
// Statistics
|
||||
stats struct {
|
||||
ClassesLoaded int32
|
||||
LookupsPerformed int32
|
||||
CacheHits int32
|
||||
CacheMisses int32
|
||||
}
|
||||
}
|
||||
|
||||
// NewManager creates a new class manager
|
||||
func NewManager() *Manager {
|
||||
manager := &Manager{
|
||||
classes: make(map[int8]*Class),
|
||||
nameToID: make(map[string]int8),
|
||||
displayNameMap: make(map[int8]string),
|
||||
}
|
||||
|
||||
// Initialize with all classes
|
||||
manager.initializeClasses()
|
||||
return manager
|
||||
}
|
||||
|
||||
// initializeClasses populates the manager with all class data
|
||||
func (m *Manager) initializeClasses() {
|
||||
m.mutex.Lock()
|
||||
defer m.mutex.Unlock()
|
||||
|
||||
// Define all classes with their properties
|
||||
classDefinitions := []struct {
|
||||
id int8
|
||||
name string
|
||||
displayName string
|
||||
baseClass int8
|
||||
secondaryBase int8
|
||||
classType string
|
||||
isAdventure bool
|
||||
isTradeskill bool
|
||||
}{
|
||||
// Base classes
|
||||
{ClassCommoner, "COMMONER", "Commoner", ClassCommoner, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
{ClassFighter, "FIGHTER", "Fighter", ClassFighter, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
{ClassPriest, "PRIEST", "Priest", ClassPriest, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
{ClassMage, "MAGE", "Mage", ClassMage, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
{ClassScout, "SCOUT", "Scout", ClassScout, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
|
||||
// Fighter subclasses
|
||||
{ClassWarrior, "WARRIOR", "Warrior", ClassFighter, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
{ClassGuardian, "GUARDIAN", "Guardian", ClassFighter, ClassWarrior, ClassTypeAdventure, true, false},
|
||||
{ClassBerserker, "BERSERKER", "Berserker", ClassFighter, ClassWarrior, ClassTypeAdventure, true, false},
|
||||
{ClassBrawler, "BRAWLER", "Brawler", ClassFighter, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
{ClassMonk, "MONK", "Monk", ClassFighter, ClassBrawler, ClassTypeAdventure, true, false},
|
||||
{ClassBruiser, "BRUISER", "Bruiser", ClassFighter, ClassBrawler, ClassTypeAdventure, true, false},
|
||||
{ClassCrusader, "CRUSADER", "Crusader", ClassFighter, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
{ClassShadowknight, "SHADOWKNIGHT", "Shadowknight", ClassFighter, ClassCrusader, ClassTypeAdventure, true, false},
|
||||
{ClassPaladin, "PALADIN", "Paladin", ClassFighter, ClassCrusader, ClassTypeAdventure, true, false},
|
||||
|
||||
// Priest subclasses
|
||||
{ClassCleric, "CLERIC", "Cleric", ClassPriest, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
{ClassTemplar, "TEMPLAR", "Templar", ClassPriest, ClassCleric, ClassTypeAdventure, true, false},
|
||||
{ClassInquisitor, "INQUISITOR", "Inquisitor", ClassPriest, ClassCleric, ClassTypeAdventure, true, false},
|
||||
{ClassDruid, "DRUID", "Druid", ClassPriest, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
{ClassWarden, "WARDEN", "Warden", ClassPriest, ClassDruid, ClassTypeAdventure, true, false},
|
||||
{ClassFury, "FURY", "Fury", ClassPriest, ClassDruid, ClassTypeAdventure, true, false},
|
||||
{ClassShaman, "SHAMAN", "Shaman", ClassPriest, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
{ClassMystic, "MYSTIC", "Mystic", ClassPriest, ClassShaman, ClassTypeAdventure, true, false},
|
||||
{ClassDefiler, "DEFILER", "Defiler", ClassPriest, ClassShaman, ClassTypeAdventure, true, false},
|
||||
|
||||
// Mage subclasses
|
||||
{ClassSorcerer, "SORCERER", "Sorcerer", ClassMage, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
{ClassWizard, "WIZARD", "Wizard", ClassMage, ClassSorcerer, ClassTypeAdventure, true, false},
|
||||
{ClassWarlock, "WARLOCK", "Warlock", ClassMage, ClassSorcerer, ClassTypeAdventure, true, false},
|
||||
{ClassEnchanter, "ENCHANTER", "Enchanter", ClassMage, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
{ClassIllusionist, "ILLUSIONIST", "Illusionist", ClassMage, ClassEnchanter, ClassTypeAdventure, true, false},
|
||||
{ClassCoercer, "COERCER", "Coercer", ClassMage, ClassEnchanter, ClassTypeAdventure, true, false},
|
||||
{ClassSummoner, "SUMMONER", "Summoner", ClassMage, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
{ClassConjuror, "CONJUROR", "Conjuror", ClassMage, ClassSummoner, ClassTypeAdventure, true, false},
|
||||
{ClassNecromancer, "NECROMANCER", "Necromancer", ClassMage, ClassSummoner, ClassTypeAdventure, true, false},
|
||||
|
||||
// Scout subclasses
|
||||
{ClassRogue, "ROGUE", "Rogue", ClassScout, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
{ClassSwashbuckler, "SWASHBUCKLER", "Swashbuckler", ClassScout, ClassRogue, ClassTypeAdventure, true, false},
|
||||
{ClassBrigand, "BRIGAND", "Brigand", ClassScout, ClassRogue, ClassTypeAdventure, true, false},
|
||||
{ClassBard, "BARD", "Bard", ClassScout, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
{ClassTroubador, "TROUBADOR", "Troubador", ClassScout, ClassBard, ClassTypeAdventure, true, false},
|
||||
{ClassDirge, "DIRGE", "Dirge", ClassScout, ClassBard, ClassTypeAdventure, true, false},
|
||||
{ClassPredator, "PREDATOR", "Predator", ClassScout, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
{ClassRanger, "RANGER", "Ranger", ClassScout, ClassPredator, ClassTypeAdventure, true, false},
|
||||
{ClassAssassin, "ASSASSIN", "Assassin", ClassScout, ClassPredator, ClassTypeAdventure, true, false},
|
||||
{ClassAnimalist, "ANIMALIST", "Animalist", ClassScout, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
{ClassBeastlord, "BEASTLORD", "Beastlord", ClassScout, ClassAnimalist, ClassTypeAdventure, true, false},
|
||||
|
||||
// Special classes
|
||||
{ClassShaper, "SHAPER", "Shaper", ClassPriest, ClassCommoner, ClassTypeAdventure, true, false},
|
||||
{ClassChanneler, "CHANNELER", "Channeler", ClassPriest, ClassShaper, ClassTypeAdventure, true, false},
|
||||
|
||||
// Tradeskill classes
|
||||
{ClassArtisan, "ARTISAN", "Artisan", ClassArtisan, ClassCommoner, ClassTypeTradeskill, false, true},
|
||||
{ClassCraftsman, "CRAFTSMAN", "Craftsman", ClassArtisan, ClassCommoner, ClassTypeTradeskill, false, true},
|
||||
{ClassProvisioner, "PROVISIONER", "Provisioner", ClassArtisan, ClassCraftsman, ClassTypeTradeskill, false, true},
|
||||
{ClassWoodworker, "WOODWORKER", "Woodworker", ClassArtisan, ClassCraftsman, ClassTypeTradeskill, false, true},
|
||||
{ClassCarpenter, "CARPENTER", "Carpenter", ClassArtisan, ClassCraftsman, ClassTypeTradeskill, false, true},
|
||||
{ClassOutfitter, "OUTFITTER", "Outfitter", ClassArtisan, ClassCommoner, ClassTypeTradeskill, false, true},
|
||||
{ClassArmorer, "ARMORER", "Armorer", ClassArtisan, ClassOutfitter, ClassTypeTradeskill, false, true},
|
||||
{ClassWeaponsmith, "WEAPONSMITH", "Weaponsmith", ClassArtisan, ClassOutfitter, ClassTypeTradeskill, false, true},
|
||||
{ClassTailor, "TAILOR", "Tailor", ClassArtisan, ClassOutfitter, ClassTypeTradeskill, false, true},
|
||||
{ClassScholar, "SCHOLAR", "Scholar", ClassArtisan, ClassCommoner, ClassTypeTradeskill, false, true},
|
||||
{ClassJeweler, "JEWELER", "Jeweler", ClassArtisan, ClassScholar, ClassTypeTradeskill, false, true},
|
||||
{ClassSage, "SAGE", "Sage", ClassArtisan, ClassScholar, ClassTypeTradeskill, false, true},
|
||||
{ClassAlchemist, "ALCHEMIST", "Alchemist", ClassArtisan, ClassScholar, ClassTypeTradeskill, false, true},
|
||||
}
|
||||
|
||||
// Create and store class objects
|
||||
for _, def := range classDefinitions {
|
||||
class := &Class{
|
||||
ID: def.id,
|
||||
Name: def.name,
|
||||
DisplayName: def.displayName,
|
||||
BaseClass: def.baseClass,
|
||||
SecondaryBaseClass: def.secondaryBase,
|
||||
ClassType: def.classType,
|
||||
IsAdventure: def.isAdventure,
|
||||
IsTradeskill: def.isTradeskill,
|
||||
}
|
||||
|
||||
m.classes[def.id] = class
|
||||
m.nameToID[def.name] = def.id
|
||||
m.displayNameMap[def.id] = def.displayName
|
||||
}
|
||||
|
||||
m.stats.ClassesLoaded = int32(len(classDefinitions))
|
||||
}
|
||||
|
||||
// GetClass gets class by ID
|
||||
func (m *Manager) GetClass(classID int8) *Class {
|
||||
m.mutex.RLock()
|
||||
defer m.mutex.RUnlock()
|
||||
m.stats.LookupsPerformed++
|
||||
|
||||
if class, exists := m.classes[classID]; exists {
|
||||
m.stats.CacheHits++
|
||||
return class
|
||||
}
|
||||
|
||||
m.stats.CacheMisses++
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetClassID returns the class ID for a given class name (C++ API compatibility)
|
||||
func (m *Manager) GetClassID(name string) int8 {
|
||||
m.mutex.RLock()
|
||||
defer m.mutex.RUnlock()
|
||||
m.stats.LookupsPerformed++
|
||||
|
||||
className := strings.ToUpper(strings.TrimSpace(name))
|
||||
if classID, exists := m.nameToID[className]; exists {
|
||||
m.stats.CacheHits++
|
||||
return classID
|
||||
}
|
||||
|
||||
m.stats.CacheMisses++
|
||||
return -1 // Invalid class
|
||||
}
|
||||
|
||||
// GetClassName returns the uppercase class name for a given ID (C++ API compatibility)
|
||||
func (m *Manager) GetClassName(classID int8) string {
|
||||
m.mutex.RLock()
|
||||
defer m.mutex.RUnlock()
|
||||
m.stats.LookupsPerformed++
|
||||
|
||||
if class := m.classes[classID]; class != nil {
|
||||
m.stats.CacheHits++
|
||||
return class.Name
|
||||
}
|
||||
|
||||
m.stats.CacheMisses++
|
||||
return "" // Invalid class ID
|
||||
}
|
||||
|
||||
// GetClassNameCase returns the friendly display name for a given class ID (C++ API compatibility)
|
||||
func (m *Manager) GetClassNameCase(classID int8) string {
|
||||
m.mutex.RLock()
|
||||
defer m.mutex.RUnlock()
|
||||
m.stats.LookupsPerformed++
|
||||
|
||||
if displayName, exists := m.displayNameMap[classID]; exists {
|
||||
m.stats.CacheHits++
|
||||
return displayName
|
||||
}
|
||||
|
||||
m.stats.CacheMisses++
|
||||
return "" // Invalid class ID
|
||||
}
|
||||
|
||||
// GetBaseClass returns the base class ID for a given class (C++ API compatibility)
|
||||
func (m *Manager) GetBaseClass(classID int8) int8 {
|
||||
m.mutex.RLock()
|
||||
defer m.mutex.RUnlock()
|
||||
m.stats.LookupsPerformed++
|
||||
|
||||
if class := m.classes[classID]; class != nil {
|
||||
m.stats.CacheHits++
|
||||
return class.BaseClass
|
||||
}
|
||||
|
||||
m.stats.CacheMisses++
|
||||
return ClassCommoner // Default for unknown classes
|
||||
}
|
||||
|
||||
// GetSecondaryBaseClass returns the secondary base class ID (C++ API compatibility)
|
||||
func (m *Manager) GetSecondaryBaseClass(classID int8) int8 {
|
||||
m.mutex.RLock()
|
||||
defer m.mutex.RUnlock()
|
||||
m.stats.LookupsPerformed++
|
||||
|
||||
if class := m.classes[classID]; class != nil {
|
||||
m.stats.CacheHits++
|
||||
return class.SecondaryBaseClass
|
||||
}
|
||||
|
||||
m.stats.CacheMisses++
|
||||
return ClassCommoner // Default for unknown classes
|
||||
}
|
||||
|
||||
// GetTSBaseClass returns the tradeskill base class ID (C++ API compatibility)
|
||||
func (m *Manager) GetTSBaseClass(classID int8) int8 {
|
||||
// This function maps tradeskill class IDs to their base tradeskill progression levels
|
||||
// The C++ code uses offset of 42 between adventure and tradeskill class systems
|
||||
if classID+42 >= ClassArtisan {
|
||||
return ClassArtisan - 44 // Returns 1 (base artisan level)
|
||||
}
|
||||
return classID // For non-tradeskill classes, return as-is
|
||||
}
|
||||
|
||||
// GetSecondaryTSBaseClass returns the secondary tradeskill base class ID (C++ API compatibility)
|
||||
func (m *Manager) GetSecondaryTSBaseClass(classID int8) int8 {
|
||||
ret := classID + 42
|
||||
|
||||
if ret == ClassArtisan {
|
||||
return ClassArtisan - 44
|
||||
} else if ret >= ClassCraftsman && ret < ClassOutfitter {
|
||||
return ClassCraftsman - 44
|
||||
} else if ret >= ClassOutfitter && ret < ClassScholar {
|
||||
return ClassOutfitter - 44
|
||||
} else if ret >= ClassScholar {
|
||||
return ClassScholar - 44
|
||||
}
|
||||
|
||||
return classID
|
||||
}
|
||||
|
||||
// IsValidClassID checks if a class ID is valid
|
||||
func (m *Manager) IsValidClassID(classID int8) bool {
|
||||
return classID >= MinClassID && classID <= MaxClassID
|
||||
}
|
||||
|
||||
// IsAdventureClass checks if a class is an adventure class
|
||||
func (m *Manager) IsAdventureClass(classID int8) bool {
|
||||
if class := m.GetClass(classID); class != nil {
|
||||
return class.IsAdventure
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// IsTradeskillClass checks if a class is a tradeskill class
|
||||
func (m *Manager) IsTradeskillClass(classID int8) bool {
|
||||
if class := m.GetClass(classID); class != nil {
|
||||
return class.IsTradeskill
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// GetClassType returns the type of class (adventure, tradeskill, etc.)
|
||||
func (m *Manager) GetClassType(classID int8) string {
|
||||
if class := m.GetClass(classID); class != nil {
|
||||
return class.ClassType
|
||||
}
|
||||
return ClassTypeSpecial
|
||||
}
|
||||
|
||||
// GetAllClasses returns all class IDs and their display names
|
||||
func (m *Manager) GetAllClasses() map[int8]string {
|
||||
m.mutex.RLock()
|
||||
defer m.mutex.RUnlock()
|
||||
|
||||
result := make(map[int8]string)
|
||||
for classID, displayName := range m.displayNameMap {
|
||||
result[classID] = displayName
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// GetClassInfo returns comprehensive information about a class
|
||||
func (m *Manager) GetClassInfo(classID int8) map[string]any {
|
||||
class := m.GetClass(classID)
|
||||
info := make(map[string]any)
|
||||
|
||||
if class == nil {
|
||||
info["valid"] = false
|
||||
return info
|
||||
}
|
||||
|
||||
info["valid"] = true
|
||||
info["class_id"] = class.ID
|
||||
info["name"] = class.Name
|
||||
info["display_name"] = class.DisplayName
|
||||
info["base_class"] = class.BaseClass
|
||||
info["secondary_base_class"] = class.SecondaryBaseClass
|
||||
info["type"] = class.ClassType
|
||||
info["is_adventure"] = class.IsAdventure
|
||||
info["is_tradeskill"] = class.IsTradeskill
|
||||
|
||||
return info
|
||||
}
|
||||
|
||||
// GetClassHierarchy returns the full class hierarchy for a given class
|
||||
func (m *Manager) GetClassHierarchy(classID int8) []int8 {
|
||||
class := m.GetClass(classID)
|
||||
if class == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
hierarchy := []int8{classID}
|
||||
|
||||
// Add secondary base class if it exists
|
||||
if class.SecondaryBaseClass != ClassCommoner && class.SecondaryBaseClass != classID {
|
||||
hierarchy = append(hierarchy, class.SecondaryBaseClass)
|
||||
}
|
||||
|
||||
// Add base class
|
||||
if class.BaseClass != ClassCommoner && class.BaseClass != classID {
|
||||
// Check if base is already in hierarchy (from secondary)
|
||||
found := false
|
||||
for _, id := range hierarchy {
|
||||
if id == class.BaseClass {
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
hierarchy = append(hierarchy, class.BaseClass)
|
||||
}
|
||||
}
|
||||
|
||||
// Always add Commoner as the root
|
||||
if classID != ClassCommoner {
|
||||
hierarchy = append(hierarchy, ClassCommoner)
|
||||
}
|
||||
|
||||
return hierarchy
|
||||
}
|
||||
|
||||
// IsSameArchetype checks if two classes share the same base archetype
|
||||
func (m *Manager) IsSameArchetype(classID1, classID2 int8) bool {
|
||||
class1 := m.GetClass(classID1)
|
||||
class2 := m.GetClass(classID2)
|
||||
|
||||
if class1 == nil || class2 == nil {
|
||||
return false
|
||||
}
|
||||
|
||||
return class1.BaseClass == class2.BaseClass
|
||||
}
|
||||
|
||||
// GetArchetypeClasses returns all classes of a given archetype
|
||||
func (m *Manager) GetArchetypeClasses(archetypeID int8) []int8 {
|
||||
m.mutex.RLock()
|
||||
defer m.mutex.RUnlock()
|
||||
|
||||
var classes []int8
|
||||
for classID, class := range m.classes {
|
||||
if class.BaseClass == archetypeID {
|
||||
classes = append(classes, classID)
|
||||
}
|
||||
}
|
||||
return classes
|
||||
}
|
||||
|
||||
// GetStatistics returns current manager statistics
|
||||
func (m *Manager) GetStatistics() map[string]interface{} {
|
||||
m.mutex.RLock()
|
||||
defer m.mutex.RUnlock()
|
||||
|
||||
return map[string]interface{}{
|
||||
"classes_loaded": m.stats.ClassesLoaded,
|
||||
"lookups_performed": m.stats.LookupsPerformed,
|
||||
"cache_hits": m.stats.CacheHits,
|
||||
"cache_misses": m.stats.CacheMisses,
|
||||
"total_classes": int32(len(m.classes)),
|
||||
"adventure_classes": m.countClassesByType(ClassTypeAdventure),
|
||||
"tradeskill_classes": m.countClassesByType(ClassTypeTradeskill),
|
||||
}
|
||||
}
|
||||
|
||||
// countClassesByType counts classes of a specific type
|
||||
func (m *Manager) countClassesByType(classType string) int32 {
|
||||
count := int32(0)
|
||||
for _, class := range m.classes {
|
||||
if class.ClassType == classType {
|
||||
count++
|
||||
}
|
||||
}
|
||||
return count
|
||||
}
|
||||
|
||||
// Global manager instance
|
||||
var globalManager *Manager
|
||||
|
||||
// InitializeManager initializes the global class manager
|
||||
func InitializeManager() {
|
||||
globalManager = NewManager()
|
||||
}
|
||||
|
||||
// GetManager returns the global class manager
|
||||
func GetManager() *Manager {
|
||||
if globalManager == nil {
|
||||
InitializeManager()
|
||||
}
|
||||
return globalManager
|
||||
}
|
||||
|
||||
// Global functions for C++ API compatibility
|
||||
func GetClassID(name string) int8 {
|
||||
return GetManager().GetClassID(name)
|
||||
}
|
||||
|
||||
func GetClassName(classID int8) string {
|
||||
return GetManager().GetClassName(classID)
|
||||
}
|
||||
|
||||
func GetClassNameCase(classID int8) string {
|
||||
return GetManager().GetClassNameCase(classID)
|
||||
}
|
||||
|
||||
func GetBaseClass(classID int8) int8 {
|
||||
return GetManager().GetBaseClass(classID)
|
||||
}
|
||||
|
||||
func GetSecondaryBaseClass(classID int8) int8 {
|
||||
return GetManager().GetSecondaryBaseClass(classID)
|
||||
}
|
||||
|
||||
func GetTSBaseClass(classID int8) int8 {
|
||||
return GetManager().GetTSBaseClass(classID)
|
||||
}
|
||||
|
||||
func GetSecondaryTSBaseClass(classID int8) int8 {
|
||||
return GetManager().GetSecondaryTSBaseClass(classID)
|
||||
}
|
||||
|
||||
func IsValidClassID(classID int8) bool {
|
||||
return GetManager().IsValidClassID(classID)
|
||||
}
|
||||
|
||||
func IsAdventureClass(classID int8) bool {
|
||||
return GetManager().IsAdventureClass(classID)
|
||||
}
|
||||
|
||||
func IsTradeskillClass(classID int8) bool {
|
||||
return GetManager().IsTradeskillClass(classID)
|
||||
}
|
||||
|
||||
func GetClassType(classID int8) string {
|
||||
return GetManager().GetClassType(classID)
|
||||
}
|
||||
|
||||
func GetAllClasses() map[int8]string {
|
||||
return GetManager().GetAllClasses()
|
||||
}
|
||||
|
||||
func GetClassInfo(classID int8) map[string]any {
|
||||
return GetManager().GetClassInfo(classID)
|
||||
}
|
||||
|
||||
func GetClassHierarchy(classID int8) []int8 {
|
||||
return GetManager().GetClassHierarchy(classID)
|
||||
}
|
||||
|
||||
func IsSameArchetype(classID1, classID2 int8) bool {
|
||||
return GetManager().IsSameArchetype(classID1, classID2)
|
||||
}
|
||||
|
||||
func GetArchetypeClasses(archetypeID int8) []int8 {
|
||||
return GetManager().GetArchetypeClasses(archetypeID)
|
||||
}
|
||||
578
internal/classes/classes_test.go
Normal file
578
internal/classes/classes_test.go
Normal file
@ -0,0 +1,578 @@
|
||||
package classes
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestClassBasics(t *testing.T) {
|
||||
class := &Class{
|
||||
ID: ClassWarrior,
|
||||
Name: "WARRIOR",
|
||||
DisplayName: "Warrior",
|
||||
BaseClass: ClassFighter,
|
||||
SecondaryBaseClass: ClassCommoner,
|
||||
ClassType: ClassTypeAdventure,
|
||||
IsAdventure: true,
|
||||
IsTradeskill: false,
|
||||
}
|
||||
|
||||
if class.GetID() != ClassWarrior {
|
||||
t.Errorf("Expected ID %d, got %d", ClassWarrior, class.GetID())
|
||||
}
|
||||
|
||||
if class.GetName() != "WARRIOR" {
|
||||
t.Errorf("Expected name 'WARRIOR', got %s", class.GetName())
|
||||
}
|
||||
|
||||
if class.GetDisplayName() != "Warrior" {
|
||||
t.Errorf("Expected display name 'Warrior', got %s", class.GetDisplayName())
|
||||
}
|
||||
|
||||
if class.GetBaseClass() != ClassFighter {
|
||||
t.Errorf("Expected base class %d, got %d", ClassFighter, class.GetBaseClass())
|
||||
}
|
||||
|
||||
if class.GetSecondaryBaseClass() != ClassCommoner {
|
||||
t.Errorf("Expected secondary base class %d, got %d", ClassCommoner, class.GetSecondaryBaseClass())
|
||||
}
|
||||
|
||||
if !class.IsValid() {
|
||||
t.Error("Expected class to be valid")
|
||||
}
|
||||
|
||||
// Test invalid class
|
||||
invalidClass := &Class{ID: int8(99)}
|
||||
if invalidClass.IsValid() {
|
||||
t.Error("Expected invalid class to be invalid")
|
||||
}
|
||||
}
|
||||
|
||||
func TestManagerCreation(t *testing.T) {
|
||||
manager := NewManager()
|
||||
|
||||
if manager == nil {
|
||||
t.Fatal("Manager creation failed")
|
||||
}
|
||||
|
||||
stats := manager.GetStatistics()
|
||||
if stats["classes_loaded"].(int32) == 0 {
|
||||
t.Error("Expected classes to be loaded during initialization")
|
||||
}
|
||||
|
||||
if stats["total_classes"].(int32) != MaxClasses {
|
||||
t.Errorf("Expected %d total classes, got %d", MaxClasses, stats["total_classes"])
|
||||
}
|
||||
|
||||
t.Logf("Manager initialized with %d classes", stats["total_classes"])
|
||||
}
|
||||
|
||||
func TestGetClassID(t *testing.T) {
|
||||
manager := NewManager()
|
||||
|
||||
// Test valid class names (C++ API compatibility)
|
||||
testCases := map[string]int8{
|
||||
"WARRIOR": ClassWarrior,
|
||||
"GUARDIAN": ClassGuardian,
|
||||
"TEMPLAR": ClassTemplar,
|
||||
"WIZARD": ClassWizard,
|
||||
"RANGER": ClassRanger,
|
||||
"BEASTLORD": ClassBeastlord,
|
||||
"CHANNELER": ClassChanneler,
|
||||
"ARTISAN": ClassArtisan,
|
||||
"PROVISIONER": ClassProvisioner,
|
||||
"ALCHEMIST": ClassAlchemist,
|
||||
"COMMONER": ClassCommoner,
|
||||
}
|
||||
|
||||
for name, expectedID := range testCases {
|
||||
id := manager.GetClassID(name)
|
||||
if id != expectedID {
|
||||
t.Errorf("GetClassID('%s'): expected %d, got %d", name, expectedID, id)
|
||||
}
|
||||
|
||||
// Test case insensitivity and whitespace handling
|
||||
id = manager.GetClassID(" " + strings.ToLower(name) + " ")
|
||||
if id != expectedID {
|
||||
t.Errorf("GetClassID('%s') with whitespace and lowercase: expected %d, got %d", name, expectedID, id)
|
||||
}
|
||||
}
|
||||
|
||||
// Test invalid class name
|
||||
invalidID := manager.GetClassID("INVALID_CLASS")
|
||||
if invalidID != -1 {
|
||||
t.Errorf("Expected -1 for invalid class name, got %d", invalidID)
|
||||
}
|
||||
|
||||
// Test empty string
|
||||
emptyID := manager.GetClassID("")
|
||||
if emptyID != -1 {
|
||||
t.Errorf("Expected -1 for empty class name, got %d", emptyID)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetClassName(t *testing.T) {
|
||||
manager := NewManager()
|
||||
|
||||
// Test valid class IDs (C++ API compatibility)
|
||||
testCases := map[int8]string{
|
||||
ClassWarrior: "WARRIOR",
|
||||
ClassGuardian: "GUARDIAN",
|
||||
ClassTemplar: "TEMPLAR",
|
||||
ClassWizard: "WIZARD",
|
||||
ClassRanger: "RANGER",
|
||||
ClassBeastlord: "BEASTLORD",
|
||||
ClassChanneler: "CHANNELER",
|
||||
ClassArtisan: "ARTISAN",
|
||||
ClassProvisioner: "PROVISIONER",
|
||||
ClassAlchemist: "ALCHEMIST",
|
||||
ClassCommoner: "COMMONER",
|
||||
}
|
||||
|
||||
for classID, expectedName := range testCases {
|
||||
name := manager.GetClassName(classID)
|
||||
if name != expectedName {
|
||||
t.Errorf("GetClassName(%d): expected '%s', got '%s'", classID, expectedName, name)
|
||||
}
|
||||
}
|
||||
|
||||
// Test invalid class ID
|
||||
invalidName := manager.GetClassName(int8(99))
|
||||
if invalidName != "" {
|
||||
t.Errorf("Expected empty string for invalid class ID, got '%s'", invalidName)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetClassNameCase(t *testing.T) {
|
||||
manager := NewManager()
|
||||
|
||||
// Test display names (C++ API compatibility)
|
||||
testCases := map[int8]string{
|
||||
ClassWarrior: "Warrior",
|
||||
ClassGuardian: "Guardian",
|
||||
ClassTemplar: "Templar",
|
||||
ClassWizard: "Wizard",
|
||||
ClassRanger: "Ranger",
|
||||
ClassBeastlord: "Beastlord",
|
||||
ClassChanneler: "Channeler",
|
||||
ClassArtisan: "Artisan",
|
||||
ClassProvisioner: "Provisioner",
|
||||
ClassAlchemist: "Alchemist",
|
||||
ClassCommoner: "Commoner",
|
||||
}
|
||||
|
||||
for classID, expectedDisplayName := range testCases {
|
||||
displayName := manager.GetClassNameCase(classID)
|
||||
if displayName != expectedDisplayName {
|
||||
t.Errorf("GetClassNameCase(%d): expected '%s', got '%s'", classID, expectedDisplayName, displayName)
|
||||
}
|
||||
}
|
||||
|
||||
// Test invalid class ID
|
||||
invalidDisplayName := manager.GetClassNameCase(int8(99))
|
||||
if invalidDisplayName != "" {
|
||||
t.Errorf("Expected empty string for invalid class ID, got '%s'", invalidDisplayName)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetBaseClass(t *testing.T) {
|
||||
manager := NewManager()
|
||||
|
||||
// Test base class mappings (C++ API compatibility)
|
||||
testCases := map[int8]int8{
|
||||
// Fighter archetype
|
||||
ClassWarrior: ClassFighter,
|
||||
ClassGuardian: ClassFighter,
|
||||
ClassBerserker: ClassFighter,
|
||||
ClassMonk: ClassFighter,
|
||||
ClassShadowknight: ClassFighter,
|
||||
ClassPaladin: ClassFighter,
|
||||
|
||||
// Priest archetype
|
||||
ClassCleric: ClassPriest,
|
||||
ClassTemplar: ClassPriest,
|
||||
ClassInquisitor: ClassPriest,
|
||||
ClassWarden: ClassPriest,
|
||||
ClassFury: ClassPriest,
|
||||
ClassMystic: ClassPriest,
|
||||
ClassDefiler: ClassPriest,
|
||||
ClassChanneler: ClassPriest,
|
||||
|
||||
// Mage archetype
|
||||
ClassSorcerer: ClassMage,
|
||||
ClassWizard: ClassMage,
|
||||
ClassWarlock: ClassMage,
|
||||
ClassIllusionist: ClassMage,
|
||||
ClassCoercer: ClassMage,
|
||||
ClassConjuror: ClassMage,
|
||||
ClassNecromancer: ClassMage,
|
||||
|
||||
// Scout archetype
|
||||
ClassRogue: ClassScout,
|
||||
ClassSwashbuckler: ClassScout,
|
||||
ClassBrigand: ClassScout,
|
||||
ClassTroubador: ClassScout,
|
||||
ClassDirge: ClassScout,
|
||||
ClassRanger: ClassScout,
|
||||
ClassAssassin: ClassScout,
|
||||
ClassBeastlord: ClassScout,
|
||||
|
||||
// Base classes should return themselves
|
||||
ClassFighter: ClassFighter,
|
||||
ClassPriest: ClassPriest,
|
||||
ClassMage: ClassMage,
|
||||
ClassScout: ClassScout,
|
||||
ClassCommoner: ClassCommoner,
|
||||
}
|
||||
|
||||
for classID, expectedBase := range testCases {
|
||||
base := manager.GetBaseClass(classID)
|
||||
if base != expectedBase {
|
||||
t.Errorf("GetBaseClass(%d): expected %d, got %d", classID, expectedBase, base)
|
||||
}
|
||||
}
|
||||
|
||||
// Test invalid class ID
|
||||
invalidBase := manager.GetBaseClass(int8(99))
|
||||
if invalidBase != ClassCommoner {
|
||||
t.Errorf("Expected %d (Commoner) for invalid class ID, got %d", ClassCommoner, invalidBase)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetSecondaryBaseClass(t *testing.T) {
|
||||
manager := NewManager()
|
||||
|
||||
// Test secondary base class mappings (C++ API compatibility)
|
||||
testCases := map[int8]int8{
|
||||
ClassGuardian: ClassWarrior,
|
||||
ClassBerserker: ClassWarrior,
|
||||
ClassMonk: ClassBrawler,
|
||||
ClassBruiser: ClassBrawler,
|
||||
ClassShadowknight: ClassCrusader,
|
||||
ClassPaladin: ClassCrusader,
|
||||
ClassTemplar: ClassCleric,
|
||||
ClassInquisitor: ClassCleric,
|
||||
ClassWarden: ClassDruid,
|
||||
ClassFury: ClassDruid,
|
||||
ClassMystic: ClassShaman,
|
||||
ClassDefiler: ClassShaman,
|
||||
ClassWizard: ClassSorcerer,
|
||||
ClassWarlock: ClassSorcerer,
|
||||
ClassIllusionist: ClassEnchanter,
|
||||
ClassCoercer: ClassEnchanter,
|
||||
ClassConjuror: ClassSummoner,
|
||||
ClassNecromancer: ClassSummoner,
|
||||
ClassSwashbuckler: ClassRogue,
|
||||
ClassBrigand: ClassRogue,
|
||||
ClassTroubador: ClassBard,
|
||||
ClassDirge: ClassBard,
|
||||
ClassRanger: ClassPredator,
|
||||
ClassAssassin: ClassPredator,
|
||||
ClassBeastlord: ClassAnimalist,
|
||||
ClassChanneler: ClassShaper,
|
||||
}
|
||||
|
||||
for classID, expectedSecondary := range testCases {
|
||||
secondary := manager.GetSecondaryBaseClass(classID)
|
||||
if secondary != expectedSecondary {
|
||||
t.Errorf("GetSecondaryBaseClass(%d): expected %d, got %d", classID, expectedSecondary, secondary)
|
||||
}
|
||||
}
|
||||
|
||||
// Test base classes (should return Commoner)
|
||||
baseClasses := []int8{ClassCommoner, ClassFighter, ClassPriest, ClassMage, ClassScout}
|
||||
for _, classID := range baseClasses {
|
||||
secondary := manager.GetSecondaryBaseClass(classID)
|
||||
if secondary != ClassCommoner {
|
||||
t.Errorf("GetSecondaryBaseClass(%d): expected %d (Commoner), got %d", classID, ClassCommoner, secondary)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestClassValidation(t *testing.T) {
|
||||
manager := NewManager()
|
||||
|
||||
// Test valid class IDs
|
||||
validClasses := []int8{
|
||||
ClassCommoner, ClassFighter, ClassWarrior, ClassGuardian,
|
||||
ClassTemplar, ClassWizard, ClassRanger, ClassBeastlord,
|
||||
ClassChanneler, ClassArtisan, ClassAlchemist,
|
||||
}
|
||||
|
||||
for _, classID := range validClasses {
|
||||
if !manager.IsValidClassID(classID) {
|
||||
t.Errorf("Expected class ID %d to be valid", classID)
|
||||
}
|
||||
}
|
||||
|
||||
// Test invalid class IDs
|
||||
invalidClasses := []int8{-1, -10, 58, 99, 127}
|
||||
for _, classID := range invalidClasses {
|
||||
if manager.IsValidClassID(classID) {
|
||||
t.Errorf("Expected class ID %d to be invalid", classID)
|
||||
}
|
||||
}
|
||||
|
||||
// Test boundary conditions
|
||||
if !manager.IsValidClassID(MinClassID) {
|
||||
t.Errorf("Expected MinClassID (%d) to be valid", MinClassID)
|
||||
}
|
||||
|
||||
if !manager.IsValidClassID(MaxClassID) {
|
||||
t.Errorf("Expected MaxClassID (%d) to be valid", MaxClassID)
|
||||
}
|
||||
}
|
||||
|
||||
func TestClassTypeChecking(t *testing.T) {
|
||||
manager := NewManager()
|
||||
|
||||
// Test adventure classes
|
||||
adventureClasses := []int8{
|
||||
ClassCommoner, ClassFighter, ClassWarrior, ClassGuardian,
|
||||
ClassTemplar, ClassWizard, ClassRanger, ClassBeastlord,
|
||||
ClassChanneler,
|
||||
}
|
||||
|
||||
for _, classID := range adventureClasses {
|
||||
if !manager.IsAdventureClass(classID) {
|
||||
t.Errorf("Expected class ID %d to be an adventure class", classID)
|
||||
}
|
||||
if manager.IsTradeskillClass(classID) {
|
||||
t.Errorf("Expected class ID %d to not be a tradeskill class", classID)
|
||||
}
|
||||
if manager.GetClassType(classID) != ClassTypeAdventure {
|
||||
t.Errorf("Expected class ID %d to have type '%s', got '%s'", classID, ClassTypeAdventure, manager.GetClassType(classID))
|
||||
}
|
||||
}
|
||||
|
||||
// Test tradeskill classes
|
||||
tradeskillClasses := []int8{
|
||||
ClassArtisan, ClassCraftsman, ClassProvisioner,
|
||||
ClassOutfitter, ClassArmorer, ClassScholar,
|
||||
ClassJeweler, ClassAlchemist,
|
||||
}
|
||||
|
||||
for _, classID := range tradeskillClasses {
|
||||
if manager.IsAdventureClass(classID) {
|
||||
t.Errorf("Expected class ID %d to not be an adventure class", classID)
|
||||
}
|
||||
if !manager.IsTradeskillClass(classID) {
|
||||
t.Errorf("Expected class ID %d to be a tradeskill class", classID)
|
||||
}
|
||||
if manager.GetClassType(classID) != ClassTypeTradeskill {
|
||||
t.Errorf("Expected class ID %d to have type '%s', got '%s'", classID, ClassTypeTradeskill, manager.GetClassType(classID))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestClassHierarchy(t *testing.T) {
|
||||
manager := NewManager()
|
||||
|
||||
// Test Guardian hierarchy: Guardian -> Warrior -> Fighter -> Commoner
|
||||
guardianHierarchy := manager.GetClassHierarchy(ClassGuardian)
|
||||
expectedGuardian := []int8{ClassGuardian, ClassWarrior, ClassFighter, ClassCommoner}
|
||||
|
||||
if len(guardianHierarchy) != len(expectedGuardian) {
|
||||
t.Errorf("Guardian hierarchy length: expected %d, got %d", len(expectedGuardian), len(guardianHierarchy))
|
||||
} else {
|
||||
for i, expected := range expectedGuardian {
|
||||
if i < len(guardianHierarchy) && guardianHierarchy[i] != expected {
|
||||
t.Errorf("Guardian hierarchy[%d]: expected %d, got %d", i, expected, guardianHierarchy[i])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Test Templar hierarchy: Templar -> Cleric -> Priest -> Commoner
|
||||
templarHierarchy := manager.GetClassHierarchy(ClassTemplar)
|
||||
expectedTemplar := []int8{ClassTemplar, ClassCleric, ClassPriest, ClassCommoner}
|
||||
|
||||
if len(templarHierarchy) != len(expectedTemplar) {
|
||||
t.Errorf("Templar hierarchy length: expected %d, got %d", len(expectedTemplar), len(templarHierarchy))
|
||||
} else {
|
||||
for i, expected := range expectedTemplar {
|
||||
if i < len(templarHierarchy) && templarHierarchy[i] != expected {
|
||||
t.Errorf("Templar hierarchy[%d]: expected %d, got %d", i, expected, templarHierarchy[i])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Test Commoner hierarchy: just Commoner
|
||||
commonerHierarchy := manager.GetClassHierarchy(ClassCommoner)
|
||||
if len(commonerHierarchy) != 1 || commonerHierarchy[0] != ClassCommoner {
|
||||
t.Errorf("Commoner hierarchy: expected [%d], got %v", ClassCommoner, commonerHierarchy)
|
||||
}
|
||||
|
||||
// Test invalid class
|
||||
invalidHierarchy := manager.GetClassHierarchy(int8(99))
|
||||
if invalidHierarchy != nil {
|
||||
t.Errorf("Expected nil hierarchy for invalid class, got %v", invalidHierarchy)
|
||||
}
|
||||
}
|
||||
|
||||
func TestArchetypeOperations(t *testing.T) {
|
||||
manager := NewManager()
|
||||
|
||||
// Test same archetype checking
|
||||
if !manager.IsSameArchetype(ClassWarrior, ClassGuardian) {
|
||||
t.Error("Expected Warrior and Guardian to be same archetype (Fighter)")
|
||||
}
|
||||
|
||||
if !manager.IsSameArchetype(ClassTemplar, ClassMystic) {
|
||||
t.Error("Expected Templar and Mystic to be same archetype (Priest)")
|
||||
}
|
||||
|
||||
if manager.IsSameArchetype(ClassWarrior, ClassTemplar) {
|
||||
t.Error("Expected Warrior and Templar to be different archetypes")
|
||||
}
|
||||
|
||||
// Test archetype class listing
|
||||
fighterClasses := manager.GetArchetypeClasses(ClassFighter)
|
||||
expectedFighterCount := 10 // Including base Fighter class (Fighter, Warrior, Guardian, Berserker, Brawler, Monk, Bruiser, Crusader, Shadowknight, Paladin)
|
||||
if len(fighterClasses) != expectedFighterCount {
|
||||
t.Errorf("Expected %d Fighter archetype classes, got %d", expectedFighterCount, len(fighterClasses))
|
||||
}
|
||||
|
||||
// Verify Fighter is in the list
|
||||
foundFighter := false
|
||||
for _, classID := range fighterClasses {
|
||||
if classID == ClassFighter {
|
||||
foundFighter = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !foundFighter {
|
||||
t.Error("Expected Fighter base class to be in Fighter archetype list")
|
||||
}
|
||||
}
|
||||
|
||||
func TestTradeskillClassOperations(t *testing.T) {
|
||||
manager := NewManager()
|
||||
|
||||
// Test tradeskill base class operations (C++ API compatibility)
|
||||
// Note: These functions use specific C++ logic with offsets
|
||||
|
||||
// Test with adventure class (should return as-is for most)
|
||||
warriorTS := manager.GetTSBaseClass(ClassWarrior)
|
||||
if warriorTS != ClassWarrior {
|
||||
t.Errorf("Expected GetTSBaseClass(%d) to return %d, got %d", ClassWarrior, ClassWarrior, warriorTS)
|
||||
}
|
||||
|
||||
// Test secondary tradeskill operations
|
||||
warriorSecondaryTS := manager.GetSecondaryTSBaseClass(ClassWarrior)
|
||||
// This should follow the C++ logic with +42 offset calculations
|
||||
t.Logf("GetSecondaryTSBaseClass(ClassWarrior) = %d", warriorSecondaryTS)
|
||||
}
|
||||
|
||||
func TestManagerStatistics(t *testing.T) {
|
||||
manager := NewManager()
|
||||
|
||||
// Perform some operations to generate statistics
|
||||
manager.GetClassID("WARRIOR")
|
||||
manager.GetClassName(ClassTemplar)
|
||||
manager.GetClassNameCase(ClassRanger)
|
||||
manager.GetBaseClass(ClassGuardian)
|
||||
manager.GetClass(ClassBeastlord)
|
||||
manager.GetClassID("INVALID_CLASS") // This should increment cache misses
|
||||
|
||||
stats := manager.GetStatistics()
|
||||
|
||||
// Check basic statistics
|
||||
if stats["classes_loaded"].(int32) == 0 {
|
||||
t.Error("Expected classes to be loaded")
|
||||
}
|
||||
|
||||
if stats["lookups_performed"].(int32) == 0 {
|
||||
t.Error("Expected lookups to be performed")
|
||||
}
|
||||
|
||||
if stats["total_classes"].(int32) != MaxClasses {
|
||||
t.Errorf("Expected %d total classes, got %d", MaxClasses, stats["total_classes"])
|
||||
}
|
||||
|
||||
// Check adventure vs tradeskill counts
|
||||
adventureCount := stats["adventure_classes"].(int32)
|
||||
tradeskillCount := stats["tradeskill_classes"].(int32)
|
||||
|
||||
if adventureCount == 0 {
|
||||
t.Error("Expected some adventure classes")
|
||||
}
|
||||
|
||||
if tradeskillCount == 0 {
|
||||
t.Error("Expected some tradeskill classes")
|
||||
}
|
||||
|
||||
t.Logf("Statistics: %+v", stats)
|
||||
}
|
||||
|
||||
func TestGlobalFunctions(t *testing.T) {
|
||||
// Test global functions that should initialize manager automatically
|
||||
|
||||
// Test basic operations
|
||||
id := GetClassID("WARRIOR")
|
||||
if id != ClassWarrior {
|
||||
t.Errorf("GetClassID('WARRIOR'): expected %d, got %d", ClassWarrior, id)
|
||||
}
|
||||
|
||||
name := GetClassName(ClassTemplar)
|
||||
if name != "TEMPLAR" {
|
||||
t.Errorf("GetClassName(%d): expected 'TEMPLAR', got '%s'", ClassTemplar, name)
|
||||
}
|
||||
|
||||
displayName := GetClassNameCase(ClassRanger)
|
||||
if displayName != "Ranger" {
|
||||
t.Errorf("GetClassNameCase(%d): expected 'Ranger', got '%s'", ClassRanger, displayName)
|
||||
}
|
||||
|
||||
base := GetBaseClass(ClassGuardian)
|
||||
if base != ClassFighter {
|
||||
t.Errorf("GetBaseClass(%d): expected %d, got %d", ClassGuardian, ClassFighter, base)
|
||||
}
|
||||
|
||||
secondary := GetSecondaryBaseClass(ClassGuardian)
|
||||
if secondary != ClassWarrior {
|
||||
t.Errorf("GetSecondaryBaseClass(%d): expected %d, got %d", ClassGuardian, ClassWarrior, secondary)
|
||||
}
|
||||
|
||||
// Test utility functions
|
||||
if !IsValidClassID(ClassBeastlord) {
|
||||
t.Errorf("Expected ClassBeastlord (%d) to be valid", ClassBeastlord)
|
||||
}
|
||||
|
||||
if !IsAdventureClass(ClassChanneler) {
|
||||
t.Errorf("Expected ClassChanneler (%d) to be adventure class", ClassChanneler)
|
||||
}
|
||||
|
||||
if !IsTradeskillClass(ClassAlchemist) {
|
||||
t.Errorf("Expected ClassAlchemist (%d) to be tradeskill class", ClassAlchemist)
|
||||
}
|
||||
|
||||
classType := GetClassType(ClassWarrior)
|
||||
if classType != ClassTypeAdventure {
|
||||
t.Errorf("Expected ClassWarrior type to be '%s', got '%s'", ClassTypeAdventure, classType)
|
||||
}
|
||||
|
||||
// Test collection functions
|
||||
allClasses := GetAllClasses()
|
||||
if len(allClasses) != MaxClasses {
|
||||
t.Errorf("Expected %d classes in GetAllClasses(), got %d", MaxClasses, len(allClasses))
|
||||
}
|
||||
|
||||
info := GetClassInfo(ClassTemplar)
|
||||
if !info["valid"].(bool) {
|
||||
t.Error("Expected ClassTemplar info to be valid")
|
||||
}
|
||||
|
||||
hierarchy := GetClassHierarchy(ClassGuardian)
|
||||
if len(hierarchy) == 0 {
|
||||
t.Error("Expected non-empty hierarchy for ClassGuardian")
|
||||
}
|
||||
|
||||
if !IsSameArchetype(ClassWarrior, ClassGuardian) {
|
||||
t.Error("Expected Warrior and Guardian to be same archetype")
|
||||
}
|
||||
|
||||
fighterClasses := GetArchetypeClasses(ClassFighter)
|
||||
if len(fighterClasses) == 0 {
|
||||
t.Error("Expected non-empty list of Fighter archetype classes")
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user