database

package
v0.0.84 Latest Latest
Warning

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

 Go to latest Published: Sep 20, 2025 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 = `` /* 1273-byte string literal not displayed */
View Source 
const TmplStrMissingEffects = `` /* 305-byte string literal not displayed */
View Source 
const TmplStrOnUse = `` /* 279-byte string literal not displayed */
View Source 
const TmplStrProc = `` /* 2132-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},
}
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: {},
}
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 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{}{}/* 484 elements not displayed */

Keep these sorted by item ID.

View Source 
var ItemOverrides = []*proto.UIItem{}/* 141 elements not displayed */
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(item *proto.UIItem) string

func GetIconName 

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

func InferCelestialItemSource added in v0.0.75 

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

func InferFlexibleRaidItemSource added in v0.0.75 

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

func InferPhase added in v0.0.75 

func InferPhase(item *proto.UIItem) int32

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 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 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 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

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, groupMapProc map[string]Group, instance *dbc.DBC, enchantSpellEffects map[int]*dbc.SpellEffect) EffectParseResult

func TryParseOnUseEffect 

func TryParseOnUseEffect(parsed *proto.UIItem, groupMap map[string]Group) EffectParseResult

func TryParseProcEffect 

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

type Entry 

type Entry struct {
	Variants  []*Variant
	Tooltip   []string
	ProcInfo  ProcInfo
	Supported bool
	Harmful   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 ProcInfo 

type ProcInfo struct {
	Outcome  core.HitOutcome
	Callback core.AuraCallback
	ProcMask core.ProcMask
}

func BuildEnchantProcInfo 

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

func BuildProcInfo 

func BuildProcInfo(parsed *proto.UIItem, 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
	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.