res

Documentation

Index

• Variables
• func Add(r ResourcesData)
• func Clear()
• type AddItemModData
• type AddSkillModData
• type AreaCharData
• type AreaData
  • func Area(id string) *AreaData
• type AreaModData
• type AreaObjectData
• type ArmorData
  • func Armor(id string) *ArmorData
• type ArmorsData
• type AttitudeMemoryData
• type AttributeModData
• type AttributesData
• type CastedObjectData
• type ChapterData
• type ChapterModData
• type CharacterData
  • func Character(id, serial string) *CharacterData
• type CharactersData
• type CombatReqData
• type CraftingData
• type CraftingRecipeData
• type CurrencyReqData
• type DamageData
• type DialogAnswerData
• type DialogData
  • func Dialog(id string) *DialogData
• type DialogStageData
• type DialogsData
• type EffectData
  • func Effect(id string) *EffectData
• type EffectsData
• type EquipmentData
• type EquipmentItemData
• type FlagData
• type FlagModData
• type FlagReqData
• type GenderReqData
• type HealthModData
• type HealthPercentReqData
• type HealthReqData
• type InventoryData
• type InventoryItemData
• type ItemData
  • func Item(id string) ItemData
• type ItemReqData
• type ItemSlotData
• type KillData
• type KillReqData
• type LevelReqData
• type ManaModData
• type ManaPercentReqData
• type ManaReqData
• type MemoryModData
• type MiscItemData
  • func Misc(id string) *MiscItemData
• type MiscItemsData
• type ModifiersData
• type ModuleData
• type ObjectDialogData
• type ObjectEffectData
• type ObjectLogData
• type ObjectLogMessageData
• type ObjectSkillData
• type QuestData
  • func Quest(id string) *QuestData
• type QuestLogData
• type QuestLogQuestData
• type QuestModData
• type QuestObjectiveData
• type QuestReqData
• type QuestStageData
• type QuestsData
• type RaceData
  • func Race(id string) *RaceData
• type RacesData
• type RecipeData
  • func Recipe(id string) *RecipeData
• type RecipesData
• type RemoveItemModData
• type ReqsData
• type ResourcesData
• type RespawnData
• type RespawnObject
• type SerialObjectData
• type SkillData
  • func Skill(id string) *SkillData
• type SkillPassiveData
• type SkillsData
• type TargetRangeReqData
• type TrainerTrainingData
• type TrainingData
  • func Training(id string) *TrainingData
• type TrainingsData
• type TranslationBaseData
  • func TranslationBase(id string) *TranslationBaseData
• type TranslationData
• type UseActionData
• type UseActionEffectData
• type WeaponData
  • func Weapon(id string) *WeaponData
• type WeaponsData

Variables

var (
	Effects          []EffectData
	Skills           []SkillData
	Armors           []ArmorData
	Weapons          []WeaponData
	Miscs            []MiscItemData
	Characters       []CharacterData
	Dialogs          []DialogData
	Quests           []QuestData
	Recipes          []RecipeData
	Areas            []AreaData
	Races            []RaceData
	Trainings        []TrainingData
	TranslationBases []*TranslationBaseData
)

Functions

func Add

func Add(r ResourcesData)

Add adds resources from specified module data to resources base.

func Clear

func Clear()

Clear removes all resources from base.

Types

type AddItemModData

type AddItemModData struct {
	ItemID string `xml:"item-id,attr" json:"item-id"`
	Amount int    `xml:"amount,attr" json:"amount"`
}

Struct for add item modifier data.

type AddSkillModData

type AddSkillModData struct {
	SkillID string `xml:"skill-id,attr" json:"skill-id"`
}

Struct for add skill modifier data.

type AreaCharData

type AreaCharData struct {
	ID      string     `xml:"id,attr" json:"id"`
	Serial  string     `xml:"serial,attr" json:"serial"`
	InitX   float64    `xml:"init-x,attr" json:"init-pos-x"`
	InitY   float64    `xml:"init-y,attr" json:"init-pos-y"`
	PosX    float64    `xml:"x,attr" json:"pos-x"`
	PosY    float64    `xml:"y,attr" json:"pos-y"`
	DestX   float64    `xml:"dest-x,attr" json:"dest-pos-x"`
	DestY   float64    `xml:"dest-y,attr" json:"dest-pos-y"`
	DefX    float64    `xml:"def-x,attr" json:"def-pos-x"`
	DefY    float64    `xml:"def-y,attr" json:"def-pos-y"`
	Respawn int64      `xml:"respawn,attr" json:"respawn"`
	AI      bool       `xml:"ai,attr" json:"ai"`
	Flags   []FlagData `xml:"flags>flag" json:"flags"`
}

Struct for area character data.

type AreaData

type AreaData struct {
	XMLName    xml.Name         `xml:"area" json:"-"`
	ID         string           `xml:"id,attr" json:"id"`
	Time       string           `xml:"time,attr" json:"time"`
	Weather    string           `xml:"weather,attr" json:"weather"`
	Map        *tmx.Map         `xml:"map" json:"map"`
	Respawn    RespawnData      `xml:"respawn" json:"respawn"`
	Characters []AreaCharData   `xml:"characters>character" json:"character"`
	Objects    []AreaObjectData `xml:"objects>object" json:"objects"`
	Subareas   []AreaData       `xml:"subareas>area" json:"subareas"`
}

Struct for area data.

func Area

func Area(id string) *AreaData

Area returns area data for specified ID.

type AreaModData

type AreaModData struct {
	ID     string  `xml:"id,attr" json:"id"`
	EnterX float64 `xml:"enter-pos-x,attr" json:"enter-pos-x"`
	EnterY float64 `xml:"enter-pos-y,attr" json:"enter-pos-y"`
}

Struct for area modifier data.

type AreaObjectData

type AreaObjectData struct {
	ID      string  `xml:"id,attr" json:"id"`
	Serial  string  `xml:"serial,attr" json:"serial"`
	PosX    float64 `xml:"x,attr" json:"pos-x"`
	PosY    float64 `xml:"y,attr" json:"pos-y"`
	Respawn int64   `xml:"respawn,attr" json:"respawn"`
}

Struct for area object data.

type ArmorData

type ArmorData struct {
	ID        string         `xml:"id,attr" json:"id"`
	Value     int            `xml:"value,attr" json:"value"`
	Level     int            `xml:"level,attr" json:"level"`
	Armor     int            `xml:"armor,attr" json:"armor"`
	Loot      bool           `xml:"loot,attr" json:"loot"`
	EQEffects []EffectData   `xml:"eq>effects>effect" json:"eq-effects"`
	EQReqs    ReqsData       `xml:"eq>reqs" json:"eq-reqs"`
	Slots     []ItemSlotData `xml:"slots>slot" json:"slots"`
}

Struct for armor resource data.

func Armor

func Armor(id string) *ArmorData

Armor returns armor data for specified ID.

type ArmorsData

type ArmorsData struct {
	XMLName xml.Name    `xml:"armors" json:"-"`
	Armors  []ArmorData `xml:"armor" json:"armors"`
}

Struct for armors data.

type AttitudeMemoryData

type AttitudeMemoryData struct {
	ObjectID     string `xml:"id,attr" json:"id"`
	ObjectSerial string `xml:"serial,attr" json:"serial"`
	Attitude     string `xml:"attitude,attr" json:"attitude"`
}

Struct for attitude memory data.

type AttributeModData

type AttributeModData AttributesData

Type for attribute modifier data.

type AttributesData

type AttributesData struct {
	Str int `xml:"strength,attr" json:"str"`
	Con int `xml:"constitution,attr" json:"con"`
	Dex int `xml:"dexterity,attr" json:"dex"`
	Int int `xml:"inteligence,attr" json:"int"`
	Wis int `xml:"wisdom,attr" json:"wis"`
}

Struct for character attributes data.

type CastedObjectData

type CastedObjectData struct {
	ID    string           `xml:"id,attr" json:"id"`
	Owner SerialObjectData `xml:"owner" json:"owner"`
}

Struct for data of usable object casted by character.

type ChapterData

type ChapterData struct {
	ID        string              `xml:"id,attr" json:"id"`
	Config    map[string][]string `xml:"config" json:"config"`
	Resources ResourcesData       `xml:"resources" json:"resources"`
}

Struct for chapter data.

type ChapterModData

type ChapterModData struct {
	ID string `xml:"id,attr" json:"id"`
}

Struct for chapter modifier.

type CharacterData

type CharacterData struct {
	XMLName      xml.Name              `xml:"character" json:"-"`
	ID           string                `xml:"id,attr" json:"id"`
	Serial       string                `xml:"serial,attr" json:"serial"`
	Level        int                   `xml:"level,attr" json:"level"`
	Sex          string                `xml:"gender,attr" json:"sex"`
	Race         string                `xml:"race,attr" json:"race"`
	Attitude     string                `xml:"attitude,attr" json:"attitude"`
	Guild        string                `xml:"guild,attr" json:"guild"`
	Alignment    string                `xml:"alignment,attr" json:"alignment"`
	PosX         float64               `xml:"position-x,attr" json:"pos-x"`
	PosY         float64               `xml:"position-y,attr" json:"pos-y"`
	DefX         float64               `xml:"def-position-x,attr" json:"def-pos-x"`
	DefY         float64               `xml:"def-position-y,attr" json:"def-pos-y"`
	DestX        float64               `xml:"dest-point-x,attr" json:"dest-point-x"`
	DestY        float64               `xml:"dest-point-y,attr" json:"dest-point-y"`
	HP           int                   `xml:"hp,attr" json:"hp"`
	Mana         int                   `xml:"mana,attr" json:"mana"`
	Exp          int                   `xml:"exp,attr" json:"exp"`
	Restore      bool                  `xml:"restore,attr" json:"restore"`
	Action       UseActionData         `xml:"action" json:"action"`
	Area         string                `xml:"area,attr" json:"area"`
	Chapter      string                `xml:"chapter,attr" json:"chapter"`
	UseCooldown  int64                 `xml:"use-cooldown,attr" json:"use-cooldown"`
	MoveCooldown int64                 `xml:"move-cooldown,attr" json:"move-cooldown"`
	Attributes   AttributesData        `xml:"attributes" json:"attributes"`
	Inventory    InventoryData         `xml:"inventory" json:"inventory"`
	Equipment    EquipmentData         `xml:"equipment" json:"equipment"`
	QuestLog     QuestLogData          `xml:"quests" json:"quests"`
	Crafting     CraftingData          `xml:"crafting" json:"crafting"`
	ChatLog      ObjectLogData         `xml:"chat-log" json:"chat-log"`
	Casted       CastedObjectData      `xml:"casted" json:"casted"`
	Targets      []SerialObjectData    `xml:"targets" json:"targets"`
	Kills        []KillData            `xml:"kills" json:"kills"`
	Trainings    []TrainerTrainingData `xml:"trainings>training" json:"trainings"`
	Flags        []FlagData            `xml:"flags>flag" json:"flags"`
	Effects      []ObjectEffectData    `xml:"effects>effect" json:"effects"`
	Skills       []ObjectSkillData     `xml:"skills>skill" json:"skills"`
	Memory       []AttitudeMemoryData  `xml:"memory>target" json:"memory"`
	Dialogs      []ObjectDialogData    `xml:"dialogs>dialog" json:"dialogs"`
}

Struct for character data resource.

func Character

func Character(id, serial string) *CharacterData

Character returns character data for specified ID and serial value.

type CharactersData

type CharactersData struct {
	XMLName    xml.Name        `xml:"characters" json:"-"`
	Characters []CharacterData `xml:"character" json:"characters"`
}

Struct for characters data resource.

type CombatReqData

type CombatReqData struct {
	Combat bool `xml:"combat,attr" json:"combat"`
}

Struct for combat requirement data.

type CraftingData

type CraftingData struct {
	Recipes []CraftingRecipeData `xml:"recipe" json:"recipes"`
}

Struct for crafting data.

type CraftingRecipeData

type CraftingRecipeData struct {
	ID string `xml:"id,attr" json:"id"`
}

Struct for crafting recipe data.

type CurrencyReqData

type CurrencyReqData struct {
	Amount int  `xml:"amount,attr" json:"amount"`
	Charge bool `xml:"charge,attr" json:"charge"`
}

Struct for currency requirement data.

type DamageData

type DamageData struct {
	Type    string             `xml:"type,attr" json:"type"`
	Min     int                `xml:"min,attr" json:"min"`
	Max     int                `xml:"max,attr" json:"max"`
	Effects []ObjectEffectData `xml:"effects>effect" json:"effects"`
}

Struct for damage data.

type DialogAnswerData

type DialogAnswerData struct {
	ID         string        `xml:"id,attr" json:"id"`
	To         string        `xml:"to,attr" json:"to"`
	End        bool          `xml:"end,attr" json:"end"`
	Trade      bool          `xml:"trade,attr" json:"trade"`
	Training   bool          `xml:"train,attr" json:"training"`
	Reqs       ReqsData      `xml:"reqs" json:"reqs"`
	TargetMods ModifiersData `xml:"target>modifiers" json:"target-mods"`
	OwnerMods  ModifiersData `xml:"owner>modifiers" json:"owner-mods"`
}

Dialog answer data struct.

type DialogData

type DialogData struct {
	XMLName xml.Name          `xml:"dialog" json:"-"`
	ID      string            `xml:"id,attr" json:"id"`
	Stages  []DialogStageData `xml:"stage" json:"sages"`
	Reqs    ReqsData          `xml:"reqs" json:"reqs"`
}

Dialog data struct.

func Dialog

func Dialog(id string) *DialogData

Dialog returns dialog data for specified ID.

type DialogStageData

type DialogStageData struct {
	ID         string             `xml:"id,attr" json:"id"`
	OrdinalID  string             `xml:"ordinal,attr" json:"ordinal"`
	Start      bool               `xml:"start,attr" json:"start"`
	Answers    []DialogAnswerData `xml:"answer" json:"answers"`
	Reqs       ReqsData           `xml:"reqs" json:"reqs"`
	TargetMods ModifiersData      `xml:"target>modifiers" json:"target-mods"`
	OwnerMods  ModifiersData      `xml:"owner>modifiers" json:"owner-mods`
}

Dialog text data struct.

type DialogsData

type DialogsData struct {
	XMLName xml.Name     `xml:"dialogs" json:"-"`
	Dialogs []DialogData `xml:"dialog" json:"dialogs'`
}

Struct for dialogs data.

type EffectData

type EffectData struct {
	XMLName   xml.Name      `xml:"effect" json:"-"`
	ID        string        `xml:"id,attr" json:"id"`
	Duration  int64         `xml:"duration,attr" json:"duration"`
	MeleeHit  bool          `xml:"melee-hit,attr" json:"melee-hit"`
	Infinite  bool          `xml:"infinite,attr" json:"infinite"`
	Modifiers ModifiersData `xml:"modifiers" json:"modifiers"`
}

Struct for effect data resource.

func Effect

func Effect(id string) *EffectData

Effect returns effect data for specified ID.

type EffectsData

type EffectsData struct {
	XMLName xml.Name     `xml:"effects" json:"-"`
	Effects []EffectData `xml:"effect" json:"effects"`
}

Struct for effects data.

type EquipmentData

type EquipmentData struct {
	Items []EquipmentItemData `xml:"item" json:"items"`
}

Struct for character equipement data.

type EquipmentItemData

type EquipmentItemData struct {
	ID     string `xml:"id,attr" json:"id"`
	Serial string `xml:"serial,attr" json:"serial"`
	Slot   string `xml:"slot,attr" json:"slot"`
	SlotID int    `xml:"slot-id,attr" json:"slot-id"`
}

Struct for equipment item data resource.

type FlagData

type FlagData struct {
	ID string `xml:"id,attr" json:"id"`
}

Struct for flag data.

type FlagModData

type FlagModData struct {
	ID  string `xml:"id,attr" json:"id"`
	Off bool   `xml:"off,attr" json:"off"`
}

Struct for flag modifier data.

type FlagReqData

type FlagReqData struct {
	ID  string `xml:"id,attr" json:"id"`
	Off bool   `xml:"off,attr" json:"off"`
}

Struct for flag requirement data.

type GenderReqData

type GenderReqData struct {
	Gender string `xml:"type,attr" json:"gender"`
}

Struct for gender requirement data.

type HealthModData

type HealthModData struct {
	Min int `xml:"min,attr" json:"min"`
	Max int `xml:"max,attr" json:"max"`
}

Struct for health modifier data.

type HealthPercentReqData

type HealthPercentReqData struct {
	Value int  `xml:"value,attr" json:"value"`
	Less  bool `xml:"less,attr" json:"less"`
}

Struct for health percent requirement data.

type HealthReqData

type HealthReqData struct {
	Value  int  `xml:"value,attr" json:"value"`
	Less   bool `xml:"less,attr" json:"less"`
	Charge bool `xml:"charge,attr" json:"charge"`
}

Struct for health requirement data.

type InventoryData

type InventoryData struct {
	Items []InventoryItemData `xml:"item" json:"items"`
}

Struct for inventory data.

type InventoryItemData

type InventoryItemData struct {
	ID         string  `xml:"id,attr" json:"id"`
	Serial     string  `xml:"serial,attr" json:"serial"`
	Amount     int     `xml:"amount,attr" json:"amount"`
	NoLoot     bool    `xml:"no-loot,attr" json:"no-loot"`
	NoTrade    bool    `xml:"no-trade,attr" json:"no-trade"`
	TradeValue int     `xml:"trade-value,attr" json:"trade-value"`
	Random     float64 `xml:"random,attr" json:"random"`
}

Struct for inventory item data resource.

type ItemData

type ItemData interface{}

Empty interface for item data structs.

func Item

func Item(id string) ItemData

Item returns item resource data for item with specified ID or nil if data for specified ID was not found.

type ItemReqData

type ItemReqData struct {
	ID     string `xml:"id,attr" json:"id"`
	Amount int    `xml:"amount,attr" json:"amount"`
	Charge bool   `xml:"charge,attr" json:"charge"`
}

Struct for item requirement data.

type ItemSlotData

type ItemSlotData struct {
	ID string `xml:"id,attr" json:"id"`
}

Struct for item slot data.

type KillData

type KillData struct {
	ID         string `xml:"id,attr" json:"id"`
	Serial     string `xml:"serial,attr" json:"serial"`
	Experience int    `xml:"experience,attr" json:"experience"`
}

Struct for kill data.

type KillReqData

type KillReqData struct {
	ID     string `xml:"id,attr" json:"id"`
	Amount int    `xml:"amount,attr" json:"amount"`
}

Struct for kill requirement data.

type LevelReqData

type LevelReqData struct {
	Min int `xml:"min,attr" json:"min"`
	Max int `xml:"max,attr" json:"max"`
}

Struct for level requirement data.

type ManaModData

type ManaModData struct {
	Min int `xml:"min,attr" json:"min"`
	Max int `xml:"max,attr" json:"max"`
}

Struct for mana modifier data.

type ManaPercentReqData

type ManaPercentReqData struct {
	Value int  `xml:"value,attr" json:"value"`
	Less  bool `xml:"less,attr" json"less"`
}

Struct for mana percent requirement data.

type ManaReqData

type ManaReqData struct {
	Value  int  `xml:"value,attr" json:"value"`
	Less   bool `xml:"less,attr" json:"less"`
	Charge bool `xml:"charge,attr" json:"charge"`
}

Struct for mana requirement data.

type MemoryModData

type MemoryModData struct {
	Attitude string `xml:"attitude,attr" json:"attitude"`
}

Struct for memory modifier data.

type MiscItemData

type MiscItemData struct {
	ID         string        `xml:"id,attr" json:"id"`
	Value      int           `xml:"value,attr" json:"value"`
	Level      int           `xml:"level,attr" json:"level"`
	Loot       bool          `xml:"loot,attr" json:"loot"`
	Currency   bool          `xml:"currency,attr" json:"currency"`
	Consumable bool          `xml:"consumable,attr" json:"consumable"`
	UseAction  UseActionData `xml:"use" json:"use"`
}

Struct for miscellaneous items data.

func Misc

func Misc(id string) *MiscItemData

Misc returns misc data for specified ID.

type MiscItemsData

type MiscItemsData struct {
	XMLName xml.Name       `xml:"miscs" json:"-"`
	Miscs   []MiscItemData `xml:"misc" json:"miscs"`
}

Struct for misc items data.

type ModifiersData

type ModifiersData struct {
	XMLName        xml.Name            `xml:"modifiers" json:"-"`
	HealthMods     []HealthModData     `xml:"health-mod" json:"health-mods"`
	ManaMods       []ManaModData       `xml:"mana-mod" json:"mana-mods"`
	FlagMods       []FlagModData       `xml:"flag-mod" json:"flag-mods"`
	QuestMods      []QuestModData      `xml:"quest-mod" json:"quest-mods"`
	AreaMods       []AreaModData       `xml:"area-mod" json:"area-mods"`
	ChapterMods    []ChapterModData    `xml:"chapter-mod" json:"chapter-mods"`
	AddItemMods    []AddItemModData    `xml:"add-item-mod" json:"add-item-mods"`
	AddSkillMods   []AddSkillModData   `xml:"add-skill-mod" json:"add-skill-mods"`
	RemoveItemMods []RemoveItemModData `xml:"remove-item-mod" json:"remove-item-mods"`
	AttributeMods  []AttributeModData  `xml:"attribute-mod" json:"attribute-mods"`
	MemoryMods     []MemoryModData     `xml:"memory-mod" json:"memory-mods"`
}

Struct for modifiers data resource.

type ModuleData

type ModuleData struct {
	ID        string              `xml:"id,attr" json:"id"`
	Config    map[string][]string `xml:"config" json:"config"`
	Chapter   ChapterData         `xml:"chapter" json:"chapter"`
	Resources ResourcesData       `xml:"resources" json:"resources"`
}

Struct for module data.

type ObjectDialogData

type ObjectDialogData struct {
	ID    string `xml:"id,attr" json:"id"`
	Stage string `xml:"stage,attr" json:"stage"`
}

Struct for object dialog data.

type ObjectEffectData

type ObjectEffectData struct {
	ID           string `xml:"id,attr" json:"id"`
	Serial       string `xml:"serial,attr" json:"serial"`
	Time         int64  `xml:"time,attr" json:"time"`
	SourceID     string `xml:"source-id,attr" json:"source-id"`
	SourceSerial string `xml:"source-serial,attr" json:"source-serial"`
}

Struct for object effects data.

type ObjectLogData

type ObjectLogData struct {
	Messages []ObjectLogMessageData `xml:"message" json:"messages"`
}

Struct for object log data.

type ObjectLogMessageData

type ObjectLogMessageData struct {
	Translated bool      `xml:"translated,attr" json:"translated"`
	Text       string    `xml:"text,attr" json:"text"`
	Time       time.Time `xml:"time,attr" json:"time"`
}

Struct for object log message data.

type ObjectSkillData

type ObjectSkillData struct {
	ID       string `xml:"id,attr" json:"id"`
	Cooldown int64  `xml:"cooldown,attr" json:"cooldown"`
}

Struct for object skill data.

type QuestData

type QuestData struct {
	ID     string           `xml:"id,attr" json:"id"`
	Stages []QuestStageData `xml:"stage" json:"stages"`
}

Struct for quest data.

func Quest

func Quest(id string) *QuestData

Quest returns quest data for specified ID.

type QuestLogData

type QuestLogData struct {
	Quests []QuestLogQuestData `xml:"quest" json:"quests"`
}

Struct for quest log data.

type QuestLogQuestData

type QuestLogQuestData struct {
	ID    string `xml:"id,attr" json:"id"`
	Stage string `xml:"stage,attr" json:"stage"`
}

Struct for quest data from quest log.

type QuestModData

type QuestModData struct {
	ID string `xml:"start,attr" json:"id"`
}

Struct for quest modifier data.

type QuestObjectiveData

type QuestObjectiveData struct {
	ID       string   `xml:"id,attr" json:"id"`
	Finisher bool     `xml:"finisher,attr" json:"finisher"`
	Reqs     ReqsData `xml:"reqs" json:"reqs"`
}

Struct for quest objective data.

type QuestReqData

type QuestReqData struct {
	ID        string `xml:"id,attr" json:"id"`
	Completed bool   `xml:"completed,attr" json:"completed"`
}

Struct for quest requirement data.

type QuestStageData

type QuestStageData struct {
	ID            string               `xml:"id,attr" json:"attr"`
	Ordinal       int                  `xml:"ordinal,attr" json:"ordinal"`
	Next          string               `xml:"next,attr" json:"next"`
	Start         bool                 `xml:"start,attr" json:"start"`
	End           bool                 `xml:"end,attr" json:"end"`
	Objectives    []QuestObjectiveData `xml:"objectives>objective" json:"objectives"`
	CompleteFlags []FlagData           `xml:"on-complete>flags>flag" json:"complete-flags"`
}

Struct for quest stage data.

type QuestsData

type QuestsData struct {
	XMLName xml.Name    `xml:"quests" json:"-"`
	Quests  []QuestData `xml:"quest" json:"quests"`
}

Struct for quests data.

type RaceData

type RaceData struct {
	ID       string            `xml:"id,attr" json:"id"`
	Playable bool              `xml:"playable,attr" json:"playable"`
	Skills   []ObjectSkillData `xml:"skills>skill" json:"skills"`
}

Struct for race data.

func Race

func Race(id string) *RaceData

Race returns race data for specified ID.

type RacesData

type RacesData struct {
	XMLName xml.Name   `xml:"races" json:"-"`
	Races   []RaceData `xml:"race" json:"races"`
}

Struct for races data.

type RecipeData

type RecipeData struct {
	ID        string        `xml:"id,attr" json:"id"`
	Category  string        `xml:"category,attr" json:"category"`
	UseAction UseActionData `xml:"use" json:"use"`
}

Struct for recipe data.

func Recipe

func Recipe(id string) *RecipeData

Recipe returns recipe data for specified ID.

type RecipesData

type RecipesData struct {
	XMLName xml.Name     `xml:"recipes" json:"-"`
	Recipes []RecipeData `xml:"recipe" json:"recipes"`
}

Struct for recipes data.

type RemoveItemModData

type RemoveItemModData AddItemModData

Type for remove item modifier data.

type ReqsData

type ReqsData struct {
	XMLName           xml.Name               `xml:"reqs" json:"-"`
	LevelReqs         []LevelReqData         `xml:"level-req" json:"level-reqs"`
	GenderReqs        []GenderReqData        `xml:"gender-req" json:"gender-reqs"`
	FlagReqs          []FlagReqData          `xml:"flag-req" json:"flag-reqs"`
	ItemReqs          []ItemReqData          `xml:"item-req" json:"item-reqs"`
	CurrencyReqs      []CurrencyReqData      `xml:"currency-req" json:"currency-reqs"`
	TargetRangeReqs   []TargetRangeReqData   `xml:"target-range-req" json:"target-range-reqs"`
	KillReqs          []KillReqData          `xml:"kill-req" json:"kill-reqs"`
	QuestReqs         []QuestReqData         `xml:"quest-req" json:"quest-reqs"`
	HealthReqs        []HealthReqData        `xml:"health-req" json:"health-reqs"`
	HealthPercentReqs []HealthPercentReqData `xml:"health-percent-req" json:"health-percent-reqs"`
	ManaReqs          []ManaReqData          `xml:"mana-req" json:"mana-reqs"`
	ManaPercentReqs   []ManaPercentReqData   `xml:"mana-percent-req" json:"mana-percent-reqs"`
	CombatReqs        []CombatReqData        `xml:"combat-req" json:"combat-reqs"`
}

Struct for reqs data.

type ResourcesData

type ResourcesData struct {
	Characters       []CharacterData       `xml:"characters>character" json:"characters"`
	Effects          []EffectData          `xml:"effects>effect" json:"effects"`
	Skills           []SkillData           `xml:"skills>skill" json:"skills"`
	Armors           []ArmorData           `xml:"armors>armor" json:"armors"`
	Weapons          []WeaponData          `xml:"weapons>weapon" json:"weapons"`
	Miscs            []MiscItemData        `xml:"misc>misc" json:"miscs"`
	Dialogs          []DialogData          `xml:"dialogs>dialog" json:"dialogs"`
	Quests           []QuestData           `xml:"quests>quest" json:"quests"`
	Recipes          []RecipeData          `xml:"recipes>recipe" json:"recipes"`
	Areas            []AreaData            `xml:"areas>area" json:"areas"`
	Races            []RaceData            `xml:"races>race" json:"races"`
	Trainings        []TrainingData        `xml:"trainings>training" json:"trainings"`
	TranslationBases []TranslationBaseData `xml:"translations>base" json:"translation-base"`
}

Struct for module resouces data.

type RespawnData

type RespawnData struct {
	Queue []RespawnObject `xml:"queue" json:"queue"`
}

Struct for area respawn data.

type RespawnObject

type RespawnObject struct {
	SerialObjectData
	Time int64
}

Struct for area respawn object data.

type SerialObjectData

type SerialObjectData struct {
	ID     string `xml:"id,attr" json:"id"`
	Serial string `xml:"serial,attr" json:"serial"`
}

Struct for data of object with serial ID.

type SkillData

type SkillData struct {
	ID        string           `xml:"id,attr" json:"id"`
	UseAction UseActionData    `xml:"use" json:"use"`
	Passive   SkillPassiveData `xml:"passive" json:"passive"`
}

Struct for skill data.

func Skill

func Skill(id string) *SkillData

Skill returns skill data for specified ID.

type SkillPassiveData

type SkillPassiveData struct {
	Requirements ReqsData              `xml:"reqs" json:"reqs"`
	Effects      []UseActionEffectData `xml:"effects>effect" json:"passive-effects"`
}

Struct for passive skill data.

type SkillsData

type SkillsData struct {
	XMLName xml.Name    `xml:"skills" json:"-"`
	Skills  []SkillData `xml:"skill", json:"skills"`
}

Struct for skills data.

type TargetRangeReqData

type TargetRangeReqData struct {
	MinRange float64 `xml:"min-range,attr" json:"min-range"`
}

Struct for target requirement data.

type TrainerTrainingData

type TrainerTrainingData struct {
	ID   string   `xml:"id,attr" json:"id"`
	Reqs ReqsData `xml:"reqs" json:"reqs"`
}

Struct for trainer training data.

type TrainingData

type TrainingData struct {
	ID  string        `xml:"id,attr" json:"id"`
	Use UseActionData `xml:"use" json:"use"`
}

Struct for training data.

func Training

func Training(id string) *TrainingData

Training returns training data for specified ID.

type TrainingsData

type TrainingsData struct {
	XMLName   xml.Name       `xml:"trainings" json:"-"`
	Trainings []TrainingData `xml:"training" json:"trainings"`
}

Struct for trainings data.

type TranslationBaseData

type TranslationBaseData struct {
	ID           string            `xml:"id,attr" json:"id"`
	Translations []TranslationData `xml:"translations" json:"translations"`
}

Struct for translation base data.

func TranslationBase

func TranslationBase(id string) *TranslationBaseData

TranslationBase returns translation base for specified ID.

type TranslationData

type TranslationData struct {
	ID    string   `xml:"id,attr" json:"id"`
	Texts []string `xml:"texts" json:"texts"`
}

Struct for translation data.

type UseActionData

type UseActionData struct {
	CastMax           int64                 `xml:"cast-max,attr" json:"cast-max"`
	Cast              int64                 `xml:"cast,attr" json:"cast"`
	CooldownMax       int64                 `xml:"cooldown-max,attr" json:"cooldown-max"`
	Cooldown          int64                 `xml:"cooldown,attr" json:"cooldown"`
	UserMods          ModifiersData         `xml:"user>modifiers" json:"user-mods"`
	ObjectMods        ModifiersData         `xml:"object>modifiers" json:"object-mods"`
	TargetMods        ModifiersData         `xml:"target>modifiers" json:"target-mods"`
	TargetUserMods    ModifiersData         `xml:"target-user>modifiers" json:"target-user-mods"`
	UserEffects       []UseActionEffectData `xml:"user>effects>effect" json:"user-effects"`
	ObjectEffects     []UseActionEffectData `xml:"object>effects>effect" json:"object-effects"`
	TargetEffects     []UseActionEffectData `xml:"target>effects>effect" json:"target-effects"`
	TargetUserEffects []UseActionEffectData `xml:"target-user>effects>effect" json:"target-user-effects"`
	Requirements      ReqsData              `xml:"reqs" json:"reqs"`
}

Struct for use action data.

type UseActionEffectData

type UseActionEffectData struct {
	ID string `xml:"id,attr" json:"id"`
}

Struct for use action effect data.

type WeaponData

type WeaponData struct {
	ID     string         `xml:"id,attr" json:"id"`
	Value  int            `xml:"value,attr" json:"value"`
	Level  int            `xml:"level,attr" json:"level"`
	Damage DamageData     `xml:"damage" json:"damage"`
	EQReqs ReqsData       `xml:"reqs" json:"eq-reqs"`
	Loot   bool           `xml:"loot,attr" json:"loot"`
	Slots  []ItemSlotData `xml:"slots>slot" json:"slots"`
}

Struct for weapon resource data.

func Weapon

func Weapon(id string) *WeaponData

Weapon returns weapon data for specified ID.

type WeaponsData

type WeaponsData struct {
	XMLName xml.Name     `xml:"weapons" json:"-"`
	Weapons []WeaponData `xml:"weapon" json:"weapons"`
}

Struct for weapons data.