database

package
v0.0.221 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 22, 2026 License: MIT Imports: 33 Imported by: 0

Documentation

Index

Constants

View Source 
const EndTimeEchoLootString = `` /* 1177-byte string literal not displayed */
View Source 
const MIN_EFFECT_ILVL = 416

Sets the minimum itemlevel that should be considered for this expansions

View Source 
const TmplStrEnchant = `` /* 1422-byte string literal not displayed */
View Source 
const TmplStrMissingEffects = `` /* 754-byte string literal not displayed */
View Source 
const TmplStrOnUse = `` /* 1189-byte string literal not displayed */
View Source 
const TmplStrProc = `` /* 2512-byte string literal not displayed */

Variables

View Source 
var AtlasLootDifficulties = map[string]proto.DungeonDifficulty{
	"NORMAL_DIFF":    proto.DungeonDifficulty_DifficultyNormal,
	"HEROIC_DIFF":    proto.DungeonDifficulty_DifficultyHeroic,
	"CELESTIAL_DIFF": proto.DungeonDifficulty_DifficultyCelestial,
	"RAID10_DIFF":    proto.DungeonDifficulty_DifficultyRaid10,
	"RAID10H_DIFF":   proto.DungeonDifficulty_DifficultyRaid10H,
	"RAID25RF_DIFF":  proto.DungeonDifficulty_DifficultyRaid25RF,
	"RAID25_DIFF":    proto.DungeonDifficulty_DifficultyRaid25,
	"RAID25H_DIFF":   proto.DungeonDifficulty_DifficultyRaid25H,
	"FLEX_DIFF":      proto.DungeonDifficulty_DifficultyRaidFlex,
	"VENDOR_DIFF":    proto.DungeonDifficulty_DifficultyVendor,
}
View Source 
var AtlasLootDungeonToRaidDifficulty = map[string]string{
	"RF_DIFF":        "RAID25RF_DIFF",
	"NORMAL_DIFF":    "RAID25_DIFF",
	"HEROIC_DIFF":    "RAID25H_DIFF",
	"FLEX_DIFF":      "FLEX_DIFF",
	"CELESTIAL_DIFF": "CELESTIAL_DIFF",
}
View Source 
var AtlasLootFactionRestrictions = map[proto.Faction]proto.UIItem_FactionRestriction{
	proto.Faction_Unknown:  proto.UIItem_FACTION_RESTRICTION_UNSPECIFIED,
	proto.Faction_Alliance: proto.UIItem_FACTION_RESTRICTION_ALLIANCE_ONLY,
	proto.Faction_Horde:    proto.UIItem_FACTION_RESTRICTION_HORDE_ONLY,
}
View Source 
var AtlasLootFactions = map[string]proto.Faction{
	"FACTIONS_CONTENT":       proto.Faction_Unknown,
	"FACTIONS_ALLI_CONTENT":  proto.Faction_Alliance,
	"FACTIONS_HORDE_CONTENT": proto.Faction_Horde,
}
View Source 
var AtlasLootProfessionIDs = map[int]proto.Profession{

	5: proto.Profession_Blacksmithing,
	6: proto.Profession_Leatherworking,
	7: proto.Profession_Alchemy,

	10: proto.Profession_Mining,
	11: proto.Profession_Tailoring,
	12: proto.Profession_Engineering,
	13: proto.Profession_Enchanting,
	17: proto.Profession_Jewelcrafting,
	18: proto.Profession_Inscription,
}
View Source 
var AtlasLootRepLevel = map[string]proto.RepLevel{
	"Exalted":  proto.RepLevel_RepLevelExalted,
	"Revered":  proto.RepLevel_RepLevelRevered,
	"Honored":  proto.RepLevel_RepLevelHonored,
	"Friendly": proto.RepLevel_RepLevelFriendly,
	"Neutral":  proto.RepLevel_RepLevelNeutral,
}
View Source 
var ConsumableAllowList = []int32{

	62649,
	62290,

	13442,

	20520,
	46376,
	45568,
	54221,
}

Item Ids of consumables to allow

View Source 
var ConsumableDenyList = []int32{
	57099,
}
View Source 
var ConsumableOverrides = []*proto.Consumable{
	{Id: 62290, BuffsMainStat: true, Stats: stats.Stats{stats.Stamina: 90}.ToProtoArray()},
	{Id: 62649, BuffsMainStat: true, Stats: stats.Stats{stats.Stamina: 90}.ToProtoArray()},
	{Id: 86125, Type: proto.ConsumableType_ConsumableTypePotion},
	{Id: 86569, Type: proto.ConsumableType_ConsumableTypeFlask},
}
View Source 
var DatabasePath string
View Source 
var DenyListNameRegexes = []*regexp.Regexp{
	regexp.MustCompile(`30 Epic`),
	regexp.MustCompile(`130 Epic`),
	regexp.MustCompile(`63 Blue`),
	regexp.MustCompile(`63 Green`),
	regexp.MustCompile(`66 Epic`),
	regexp.MustCompile(`90 Epic`),
	regexp.MustCompile(`90 Green`),
	regexp.MustCompile(`Boots 1`),
	regexp.MustCompile(`Boots 2`),
	regexp.MustCompile(`Boots 3`),
	regexp.MustCompile(`Bracer 1`),
	regexp.MustCompile(`Bracer 2`),
	regexp.MustCompile(`Bracer 3`),
	regexp.MustCompile(`DB\d`),
	regexp.MustCompile(`DEPRECATED`),
	regexp.MustCompile(`OLD`),
	regexp.MustCompile(`Deprecated`),
	regexp.MustCompile(`Deprecated: Keanna`),
	regexp.MustCompile(`Indalamar`),
	regexp.MustCompile(`Monster -`),
	regexp.MustCompile(`NEW`),
	regexp.MustCompile(`PH`),
	regexp.MustCompile(`QR XXXX`),
	regexp.MustCompile(`TEST`),
	regexp.MustCompile(`Test`),
	regexp.MustCompile(`Enchant Template`),
	regexp.MustCompile(`Arcane Amalgamation`),
	regexp.MustCompile(`Deleted`),
	regexp.MustCompile(`DELETED`),
	regexp.MustCompile(`zOLD`),
	regexp.MustCompile(`Archaic Spell`),
	regexp.MustCompile(`Well Repaired`),
	regexp.MustCompile(`Boss X`),
	regexp.MustCompile(`Adventurine`),
	regexp.MustCompile(`Sardonyx`),
	regexp.MustCompile(`Zyanite`),
}

If any of these match the item name, don't include it.

View Source 
var EnchantDenyList = map[int32]struct{}{
	4671: {},
	4687: {},
	4717: {},
	5029: {},
	5110: {},
}
View Source 
var EnchantDenyListItems = map[int32]struct{}{
	87583: {},
	89717: {},
	79061: {},
}
View Source 
var EnchantDenyListSpells = map[int32]struct{}{
	141168: {},
	141973: {},
	142173: {},
	142175: {},
	141170: {},
	141974: {},
	142177: {},
	141868: {},
	141984: {},
	141177: {},
	141981: {},
	141176: {},
	141978: {},
	141173: {},
	141975: {},
	141862: {},
	141983: {},
	141175: {},
	141977: {},
}
View Source 
var EnchantOverrides = []*proto.UIEnchant{
	{EffectId: 4419, SpellId: 104395},
	{EffectId: 4428, SpellId: 104409},
	{EffectId: 4429, SpellId: 104414},
	{EffectId: 4441, SpellId: 104425},
	{EffectId: 4442, SpellId: 104427},
	{EffectId: 4443, SpellId: 104430},
	{EffectId: 4444, SpellId: 104434},
	{EffectId: 4445, SpellId: 104040},
	{EffectId: 4446, SpellId: 104442},

	{EffectId: 4892, SpellId: 125481},
	{EffectId: 4893, SpellId: 125482},
	{EffectId: 4894, SpellId: 125483},
	{EffectId: 4895, SpellId: 125496},
	{EffectId: 4896, SpellId: 125497},
	{EffectId: 4898, SpellId: 126731},

	{EffectId: 5124, SpellId: 142469},
	{EffectId: 5125, SpellId: 142468},
}

Note: EffectId is required for all enchants, because they are used by various importers/exporters

View Source 
var ExtraItemIcons = []int32{}/* 116 elements not displayed */

Item icons to include in the DB, so they don't need to be separately loaded in the UI.

View Source 
var GemAllowList = map[int32]struct{}{}
View Source 
var GemDenyList = map[int32]struct{}{

	32735: {},
	34142: {},
	34143: {},
	35489: {},
	37430: {},
	38545: {},
	38546: {},
	38547: {},
	38548: {},
	38549: {},
	38550: {},
	63696: {},
	63697: {},
	97306: {},
	97534: {},
	97937: {},
	97313: {},
	98094: {},
	69922: {},
	69923: {},
	97311: {},
	98088: {},
	98026: {},
	98027: {},
	97938: {},
	97535: {},
	77134: {},
	77140: {},
	76714: {},
	97307: {},
	98090: {},
	97537: {},
	97941: {},
	97312: {},
	97308: {},
	98025: {},
	77130: {},
	77142: {},
	77137: {},
	77154: {},
	77143: {},
	77139: {},
	97310: {},
	77133: {},
	97536: {},
	97547: {},
	97939: {},
	98051: {},
	77144: {},
	97538: {},
	97943: {},
	98028: {},
	98089: {},
	77132: {},
	77141: {},
	77138: {},
	77136: {},
	76655: {},
}
View Source 
var GemOverrides = []*proto.UIGem{
	{Id: 33131, Stats: stats.Stats{stats.AttackPower: 32, stats.RangedAttackPower: 32}.ToProtoArray()},
}

Allows manual overriding for Gem fields in case WowHead is wrong.

View Source 
var IgnoreSpellEffectByAuraType = map[dbc.EffectAuraType][]int{
	dbc.A_MOD_MECHANIC_RESISTANCE: {},
	dbc.A_MOD_STEALTH:             {},
	dbc.A_MOD_STEALTH_DETECT:      {},
	dbc.A_MOD_STEALTH_LEVEL:       {},
	dbc.A_MOD_DECREASE_SPEED:      {},
	dbc.A_MOD_INVISIBILITY:        {},
	dbc.A_MOD_INVISIBILITY_DETECT: {},
	dbc.A_MOD_SKILL: {
		356,
		393,
	},
	dbc.A_MOD_INCREASE_MOUNTED_SPEED:        {},
	dbc.A_MOD_MOUNTED_SPEED_ALWAYS:          {},
	dbc.A_MOD_MOUNTED_SPEED_NOT_STACK:       {},
	dbc.A_MOD_INCREASE_MOUNTED_FLIGHT_SPEED: {},
	dbc.A_MOD_MOUNTED_FLIGHT_SPEED_ALWAYS:   {},
	dbc.A_TRANSFORM:                         {},
	dbc.A_MECHANIC_IMMUNITY:                 {},
	dbc.A_TRACK_CREATURES:                   {},
	dbc.A_TRACK_RESOURCES:                   {},
	dbc.A_FAR_SIGHT:                         {},
}

Allows you to ignore certain Spell Effects that the Sim does not support. This prevents them from being added to the missing effects list to prevent confusion towards users. Empty array means ignore all effects of that type, otherwise it will be ignored based on EffectMiscValue_0

View Source 
var IgnoreSpellEffectBySpellEffectType = map[dbc.SpellEffectType][]int{
	dbc.E_CREATE_ITEM:    {},
	dbc.E_SUMMON:         {},
	dbc.E_TELEPORT_UNITS: {},
}
View Source 
var ItemAllowList = map[int32]struct{}{
	2140: {},
	2505: {},

	45703: {},
}

Keep these sorted by item ID.

View Source 
var ItemDamageByTableAndItemLevel = make(map[string]map[int]dbc.ItemDamageTable)
View Source 
var ItemDenyList = map[int32]struct{}{}/* 542 elements not displayed */

Keep these sorted by item ID.

View Source 
var ItemOverrides = []*proto.UIItem{}/* 141 elements not displayed */
View Source 
var ItemUpgradesDisallowList = map[int32]struct{}{}
View Source 
var OtherItemIdsToFetch = []string{

	"211817",
	"211844",
	"211847",
	"211850",
	"211851",
}
View Source 
var RawRandomSuffixes []dbc.RandomSuffix
View Source 
var RawRandomSuffixesById map[int]dbc.RandomSuffix
View Source 
var SharedSpellsIcons = []int32{}/* 124 elements not displayed */

Raid buffs / debuffs

Functions

func BuildItemDifficultyPostfix 

func BuildItemDifficultyPostfix(itemSources map[int][]*proto.DropSource, itemId int, instance *dbc.DBC) string

func CacheBy 

func CacheBy[T any, K comparable](items []T, keyFunc func(T) K) map[K]T

func DifficultyToShortName 

func DifficultyToShortName(difficulty proto.DungeonDifficulty) string

func EnchantHasDummyEffect 

func EnchantHasDummyEffect(enchant *proto.UIEnchant, instance *dbc.DBC) bool

func GenerateEffectsFile 

func GenerateEffectsFile(groups []*Group, outFile string, templateString string) error

func GenerateEnchantEffects 

func GenerateEnchantEffects(instance *dbc.DBC, db *WowDatabase)

func GenerateItemEffectRandomPropPoints 

func GenerateItemEffectRandomPropPoints(instance *dbc.DBC, db *WowDatabase)

func GenerateItemEffects 

func GenerateItemEffects(instance *dbc.DBC, db *WowDatabase, itemSources map[int][]*proto.DropSource)

func GenerateMissingEffectsFile 

func GenerateMissingEffectsFile() error

func GenerateProtos 

func GenerateProtos(dbcData *dbc.DBC, db *WowDatabase)

func GenerateTalentJsonFromDB 

func GenerateTalentJsonFromDB(dbHelper *DBHelper) error

func GetEffectStatString 

func GetEffectStatString(itemEffect *proto.ItemEffect) string

func GetIconName 

func GetIconName(artPaths map[int]string, fdid int) string

func InferCelestialItemSource added in v0.0.74 

func InferCelestialItemSource(item *proto.UIItem) []*proto.UIItemSource

func InferFlexibleRaidItemSource added in v0.0.74 

func InferFlexibleRaidItemSource(item *proto.UIItem) []*proto.UIItemSource

func InferPhase added in v0.0.74 

func InferPhase(item *proto.UIItem) int32

func InferThroneOfThunderSource added in v0.0.113 

func InferThroneOfThunderSource(item *proto.UIItem) []*proto.UIItemSource

func ItemEffectIsSupported added in v0.0.221 

func ItemEffectIsSupported(instance *dbc.DBC, effectID int) bool

func LoadAndWriteArmorLocation 

func LoadAndWriteArmorLocation(dbHelper *DBHelper, inputsDir string) (map[int]dbc.ArmorLocation, error)

func LoadAndWriteConsumables 

func LoadAndWriteConsumables(dbHelper *DBHelper, inputsDir string) ([]dbc.Consumable, error)

func LoadAndWriteDropSources 

func LoadAndWriteDropSources(dbHelper *DBHelper, inputsDir string) (
	sourcesByItem map[int][]*proto.DropSource,
	namesByZone map[int]string,
	err error,
)

func LoadAndWriteEnchantDescriptions 

func LoadAndWriteEnchantDescriptions(outputPath string, db *WowDatabase, instance *dbc.DBC) error

func LoadAndWriteItemArmorQuality 

func LoadAndWriteItemArmorQuality(dbHelper *DBHelper, inputsDir string) (map[int]dbc.ItemArmorQuality, error)

func LoadAndWriteItemArmorShield 

func LoadAndWriteItemArmorShield(dbHelper *DBHelper, inputsDir string) (map[int]dbc.ItemArmorShield, error)

func LoadAndWriteItemArmorTotal 

func LoadAndWriteItemArmorTotal(dbHelper *DBHelper, inputsDir string) (map[int]dbc.ItemArmorTotal, error)

func LoadAndWriteItemDamageTables 

func LoadAndWriteItemDamageTables(dbHelper *DBHelper, inputsDir string) (map[string]map[int]dbc.ItemDamageTable, error)

func LoadAndWriteItemEffects 

func LoadAndWriteItemEffects(dbHelper *DBHelper, inputsDir string) ([]dbc.ItemEffect, error)

func LoadAndWriteItemStatEffects 

func LoadAndWriteItemStatEffects(dbHelper *DBHelper, inputsDir string) ([]dbc.ItemStatEffect, error)

func LoadAndWriteRandomPropAllocations 

func LoadAndWriteRandomPropAllocations(dbHelper *DBHelper, inputsDir string) (map[int32]RandPropAllocationRow, error)

func LoadAndWriteRawEnchants 

func LoadAndWriteRawEnchants(dbHelper *DBHelper, inputsDir string) ([]dbc.Enchant, error)

func LoadAndWriteRawGems 

func LoadAndWriteRawGems(dbHelper *DBHelper, inputsDir string) ([]dbc.Gem, error)

func LoadAndWriteRawItems 

func LoadAndWriteRawItems(dbHelper *DBHelper, filter string, inputsDir string) ([]dbc.Item, error)

func LoadAndWriteRawRandomSuffixes 

func LoadAndWriteRawRandomSuffixes(dbHelper *DBHelper, inputsDir string) ([]dbc.RandomSuffix, error)

func LoadAndWriteRawSpellEffects 

func LoadAndWriteRawSpellEffects(dbHelper *DBHelper, inputsDir string) (map[int]map[int]dbc.SpellEffect, error)

func LoadAndWriteSpells 

func LoadAndWriteSpells(dbHelper *DBHelper, inputsDir string) ([]dbc.Spell, error)

func LoadArtTexturePaths 

func LoadArtTexturePaths(filePath string) (map[int]string, error)

func LoadCraftedItems 

func LoadCraftedItems(dbHelper *DBHelper) (
	sourcesByItem map[int][]*proto.CraftedSource,
)

func LoadItemUpgradePath added in v0.0.126 

func LoadItemUpgradePath(dbHelper *DBHelper) (upgradePath map[int][]int, err error)

func LoadRepItems 

func LoadRepItems(dbHelper *DBHelper) (
	sourcesByItem map[int][]*proto.RepSource,
)

func LoadRows 

func LoadRows[T any](db *sql.DB, query string, scanFunc func(*sql.Rows) (T, error), args ...interface{}) ([]T, error)

func LoadSpellIcons 

func LoadSpellIcons(dbHelper *DBHelper) (map[int]SpellIcon, error)

func ParseRandomSuffixOptions 

func ParseRandomSuffixOptions(optionsString sql.NullString) ([]int32, error)

func ParseTooltipForMissingEffect added in v0.0.221 

func ParseTooltipForMissingEffect(parsed *proto.UIItem, itemEffect *proto.ItemEffect, instance *dbc.DBC, groupMap map[string]Group, groupMapName string)

func RunOverrides 

func RunOverrides(dbHelper *DBHelper, overridesFolder string) error

func ScanArmorLocation 

func ScanArmorLocation(rows *sql.Rows) (dbc.ArmorLocation, error)

func ScanConsumable 

func ScanConsumable(rows *sql.Rows) (dbc.Consumable, error)

func ScanCraftedItems 

func ScanCraftedItems(rows *sql.Rows) (itemID int, ds *proto.CraftedSource, err error)

func ScanDropRow 

func ScanDropRow(rows *sql.Rows) (itemID int, ds *proto.DropSource, instanceName string, err error)

func ScanEnchantsTable 

func ScanEnchantsTable(rows *sql.Rows) (dbc.Enchant, error)

func ScanGemTable 

func ScanGemTable(rows *sql.Rows) (dbc.Gem, error)

ItemDamage tables

func ScanItemArmorQualityTable 

func ScanItemArmorQualityTable(rows *sql.Rows) (dbc.ItemArmorQuality, error)

func ScanItemArmorShieldTable 

func ScanItemArmorShieldTable(rows *sql.Rows) (dbc.ItemArmorShield, error)

func ScanItemArmorTotalTable 

func ScanItemArmorTotalTable(rows *sql.Rows) (dbc.ItemArmorTotal, error)

func ScanItemDamageTable 

func ScanItemDamageTable(rows *sql.Rows) (dbc.ItemDamageTable, error)

func ScanItemEffect 

func ScanItemEffect(rows *sql.Rows) (dbc.ItemEffect, error)

func ScanItemStatEffects 

func ScanItemStatEffects(rows *sql.Rows) (dbc.ItemStatEffect, error)

func ScanItemUpgradePath added in v0.0.126 

func ScanItemUpgradePath(rows *sql.Rows) (UpgradeID int, upgradePathID int, ilvl int, err error)

func ScanRawItemData 

func ScanRawItemData(rows *sql.Rows) (dbc.Item, error)

func ScanRawRandomSuffix 

func ScanRawRandomSuffix(rows *sql.Rows) (dbc.RandomSuffix, error)

ScanRawRandomSuffix scans one row from the query result into a RawRandomSuffix struct.

func ScanRepItems 

func ScanRepItems(rows *sql.Rows) (itemID int, ds *proto.RepSource, err error)

func ScanSpellEffect 

func ScanSpellEffect(rows *sql.Rows) (dbc.SpellEffect, error)

func ScanSpells 

func ScanSpells(rows *sql.Rows) (dbc.Spell, error)

func SpellHasDummyEffect 

func SpellHasDummyEffect(spellId int, instance *dbc.DBC) bool

func SpellHasTriggerEffect 

func SpellHasTriggerEffect(spellId int, instance *dbc.DBC) bool

func SpellUsesStacks 

func SpellUsesStacks(spellId int, instance *dbc.DBC) bool

func StoreMissingEffect added in v0.0.221 

func StoreMissingEffect(effectType string, name string, variant Variant)

Types

type BlizzardAuthResponse 

type BlizzardAuthResponse struct {
	AccessToken string `json:"access_token"`
}

type BlizzardItemResponse 

type BlizzardItemResponse struct {
	ID   int    `json:"id"`
	Name string `json:"name"`

	Quality struct {
		Type string `json:"type"`
	} `json:"quality"`

	ItemClass struct {
		Id int `json:"id"`
	} `json:"item_class"`

	ItemSubclass struct {
		Id int `json:"id"`
	} `json:"item_subclass"`

	InventoryType struct {
		Type string `json:"type"`
	} `json:"inventory_type"`

	PreviewItem struct {
		Armor struct {
			Value int `json:"value"`
		} `json:"armor"`

		Stats []struct {
			Type struct {
				Type string `json:"type"`
			} `json:"type"`
			Value int `json:"value"`
		} `json:"stats"`
	} `json:"preview_item"`
}

There are more fields, these are just the ones we care about

func (BlizzardItemResponse) GetStatValue 

func (item BlizzardItemResponse) GetStatValue(statType string) int

type ClassData 

type ClassData struct {
	ClassName          string
	LowerCaseClassName string
	FileName           string
	Talents            []TalentConfig
	TalentTab          TalentTabConfig
	GlyphsMajor        []Glyph
	GlyphsMinor        []Glyph
}

type DBHelper 

type DBHelper struct {
	// contains filtered or unexported fields
}

func NewDBHelper 

func NewDBHelper() (*DBHelper, error)

func (*DBHelper) Close 

func (d *DBHelper) Close() error

type EffectParseResult 

type EffectParseResult byte
const (
	EffectParseResultInvalid     EffectParseResult = iota // Returned when the effect is invalid for the current parameters
	EffectParseResultUnsupported                          // Returned when the effect could be parsed but is not supported for effect generation
	EffectParseResultSuccess                              // Returned when the effect was parsed successfuly
)

func TryParseEnchantEffect 

func TryParseEnchantEffect(enchant *proto.UIEnchant, enchantEffect *proto.ItemEffect, groupMapProc map[string]Group, instance *dbc.DBC, enchantSpellEffects map[int]*dbc.SpellEffect) EffectParseResult

func TryParseOnUseEffect 

func TryParseOnUseEffect(parsed *proto.UIItem, itemEffect *proto.ItemEffect, instance *dbc.DBC, groupMap map[string]Group) EffectParseResult

func TryParseProcEffect 

func TryParseProcEffect(parsed *proto.UIItem, itemEffect *proto.ItemEffect, instance *dbc.DBC, groupMapProc map[string]Group) EffectParseResult

type Entry 

type Entry struct {
	Variants  []*Variant
	Tooltip   []string
	ProcInfo  ProcInfo
	Supported bool
}

func (*Entry) AddVariant 

func (entry *Entry) AddVariant(variant *Variant)

type Glyph 

type Glyph struct {
	EnumName    string
	Name        string
	Description string
	IconUrl     string
	ID          int
}

type Group 

type Group struct {
	Name    string
	Entries []*Entry
}

Group holds a category of effects.

type MissingItemEffect added in v0.0.221 

type MissingItemEffect struct {
	ItemID  int32
	Name    string
	Effects []Variant
}

type ProcInfo 

type ProcInfo struct {
	Outcome             core.HitOutcome
	Callback            core.AuraCallback
	ProcMask            core.ProcMask
	MaxCumulativeStacks int32
	RequireDamageDealt  bool
}

func BuildEnchantProcInfo 

func BuildEnchantProcInfo(enchant *proto.UIEnchant, instance *dbc.DBC, tooltip string) (ProcInfo, bool)

func BuildProcInfo 

func BuildProcInfo(parsed *proto.UIItem, itemEffectID int, instance *dbc.DBC, tooltip string) (ProcInfo, bool)

func BuildSpellProcInfo 

func BuildSpellProcInfo(procSpell *dbc.Spell, tooltip string, itemType proto.ItemType) (ProcInfo, bool)

type RandPropAllocationRow 

type RandPropAllocationRow struct {
	Ilvl       int32
	Allocation dbc.RandomPropAllocation
}

func ScanRandPropAllocationRow 

func ScanRandPropAllocationRow(rows *sql.Rows) (RandPropAllocationRow, error)

type RawGlyph 

type RawGlyph struct {
	ItemId      int32
	Name        string
	SpellId     int32
	Description string
	GlyphType   int32
	ClassMask   int32
	FDID        int32
}

func LoadGlyphs 

func LoadGlyphs(dbHelper *DBHelper) ([]RawGlyph, error)

func ScanGlyphs 

func ScanGlyphs(rows *sql.Rows) (RawGlyph, error)

type RawTalent 

type RawTalent struct {
	TierID      int
	TalentName  string
	ColumnIndex int
	ClassMask   int
	SpellID     int
}

func LoadTalents 

func LoadTalents(dbHelper *DBHelper) ([]RawTalent, error)

func ScanTalent 

func ScanTalent(rows *sql.Rows) (RawTalent, error)

type SpellIcon 

type SpellIcon struct {
	SpellID int
	FDID    int
	HasBuff bool
	Name    string
}

func ScanSpellIcon 

func ScanSpellIcon(rows *sql.Rows) (SpellIcon, error)

type TalentConfig 

type TalentConfig struct {
	FieldName        string         `json:"fieldName"`
	FancyName        string         `json:"fancyName"`
	Location         TalentLocation `json:"location"`
	SpellId          int            `json:"spellId"`
	ProtoFieldNumber int
}

type TalentLocation 

type TalentLocation struct {
	RowIdx int `json:"rowIdx"`
	ColIdx int `json:"colIdx"`
}

type TalentTabConfig 

type TalentTabConfig struct {
	BackgroundUrl string         `json:"backgroundUrl"`
	Talents       []TalentConfig `json:"talents"`
}

type TooltipManager 

type TooltipManager struct {
	FilePath   string
	UrlPattern string
}

Generic class for fetching tooltip info from the web.

func (*TooltipManager) Fetch 

func (tm *TooltipManager) Fetch(minId, maxId int32, otherIds []string)

func (*TooltipManager) FetchFromWeb 

func (tm *TooltipManager) FetchFromWeb(idsToFetch []string) map[string]string

func (*TooltipManager) Read 

func (tm *TooltipManager) Read() map[int32]string

type Variant 

type Variant struct {
	ID      int
	SpellID int
	Name    string
}

Entry represents a single effect with its ID and display name.

type WowDatabase 

type WowDatabase struct {
	Items          map[int32]*proto.UIItem
	RandomSuffixes map[int32]*proto.ItemRandomSuffix
	Enchants       map[int32]*proto.UIEnchant
	Gems           map[int32]*proto.UIGem

	Zones map[int32]*proto.UIZone
	Npcs  map[int32]*proto.UINPC

	ItemIcons                map[int32]*proto.IconData
	SpellIcons               map[int32]*proto.IconData
	ReforgeStats             map[int32]*proto.ReforgeStat
	ItemEffectRandPropPoints map[int32]*proto.ItemEffectRandPropPoints

	Encounters []*proto.PresetEncounter
	GlyphIDs   []*proto.GlyphID

	Consumables map[int32]*proto.Consumable
	Effects     map[int32]*proto.SpellEffect
}

func NewWowDatabase 

func NewWowDatabase() *WowDatabase

func ReadAtlasLootData 

func ReadAtlasLootData(dbHelper *DBHelper) *WowDatabase

func ReadDatabaseFromJson 

func ReadDatabaseFromJson(jsonStr string) *WowDatabase

func (*WowDatabase) AddItemIcon 

func (db *WowDatabase) AddItemIcon(id int32, icon string, name string)

func (*WowDatabase) AddSpellIcon 

func (db *WowDatabase) AddSpellIcon(id int32, icon string, name string)

func (*WowDatabase) Clone 

func (db *WowDatabase) Clone() *WowDatabase

func (*WowDatabase) MergeConsumable 

func (db *WowDatabase) MergeConsumable(src *proto.Consumable)

func (*WowDatabase) MergeEffect 

func (db *WowDatabase) MergeEffect(src *proto.SpellEffect)

func (*WowDatabase) MergeEnchant 

func (db *WowDatabase) MergeEnchant(src *proto.UIEnchant)

func (*WowDatabase) MergeEnchants 

func (db *WowDatabase) MergeEnchants(arr []*proto.UIEnchant)

func (*WowDatabase) MergeGem 

func (db *WowDatabase) MergeGem(src *proto.UIGem)

func (*WowDatabase) MergeGems 

func (db *WowDatabase) MergeGems(arr []*proto.UIGem)

func (*WowDatabase) MergeItem 

func (db *WowDatabase) MergeItem(src *proto.UIItem)

func (*WowDatabase) MergeItems 

func (db *WowDatabase) MergeItems(arr []*proto.UIItem)

func (*WowDatabase) MergeNpc 

func (db *WowDatabase) MergeNpc(src *proto.UINPC)

func (*WowDatabase) MergeNpcs 

func (db *WowDatabase) MergeNpcs(arr []*proto.UINPC)

func (*WowDatabase) MergeZone 

func (db *WowDatabase) MergeZone(src *proto.UIZone)

func (*WowDatabase) MergeZones 

func (db *WowDatabase) MergeZones(arr []*proto.UIZone)

func (*WowDatabase) ToUIProto 

func (db *WowDatabase) ToUIProto() *proto.UIDatabase

func (*WowDatabase) WriteBinary 

func (db *WowDatabase) WriteBinary(binFilePath string)

func (*WowDatabase) WriteBinaryAndJson 

func (db *WowDatabase) WriteBinaryAndJson(binFilePath, jsonFilePath string)

func (*WowDatabase) WriteJson 

func (db *WowDatabase) WriteJson(jsonFilePath string)

type WowheadReforgeStat 

type WowheadReforgeStat struct {
	ReforgeID         int     `json:"id"` // Reforge ID used by game
	FromID            int     `json:"i1"` // WH Stat ID to reforge from
	FromStat          string  `json:"s1"` // WH Stat string to reforge from
	ToID              int     `json:"i2"` // WH Stat ID to reforge to
	ToStat            string  `json:"s2"` // WH Stat string to reforge to
	ReforgeMultiplier float64 `json:"v"`  // Multiplier for reforge, always 0.4
}

type WowheadReforgeStats 

type WowheadReforgeStats map[string]WowheadReforgeStat

func ParseWowheadReforgeStats 

func ParseWowheadReforgeStats(contents string) WowheadReforgeStats

func (WowheadReforgeStats) ToProto 

func (reforgeStats WowheadReforgeStats) ToProto() map[int32]*proto.ReforgeStat

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.