package content import ( "fmt" "slices" ) // Powers reuse combat attacks. Knowledge is copied on acquisition; later catalog // publications cannot rewrite a learned spell or weapon ability. type PowerDefinition struct { BasePower float64 `json:"basePower" yaml:"basePower"` ID string `json:"id" yaml:"id"` Name string `json:"name" yaml:"name"` Description string `json:"description" yaml:"description"` Kind string `json:"kind" yaml:"kind"` AttackID string `json:"attackId" yaml:"attackId"` Targeting string `json:"targeting" yaml:"targeting"` Resurrection bool `json:"resurrection" yaml:"resurrection"` Weapon string `json:"weapon" yaml:"weapon"` WeaponLevel int64 `json:"weaponLevel" yaml:"weaponLevel"` Requirements ItemRequirements `json:"requirements" yaml:"requirements"` Parents map[string]int64 `json:"parents" yaml:"parents"` Book bool `json:"book" yaml:"book"` Mana float64 `json:"mana" yaml:"mana"` CastSeconds float64 `json:"castSeconds" yaml:"castSeconds"` Cooldown float64 `json:"cooldown" yaml:"cooldown"` RankScaling float64 `json:"rankScaling" yaml:"rankScaling"` BaseXP int64 `json:"baseXp" yaml:"baseXp"` XPPerLevel int64 `json:"xpPerLevel" yaml:"xpPerLevel"` MaxLevel int64 `json:"maxLevel" yaml:"maxLevel"` } type PowerContent struct { Weapons []GatheringSkill `json:"weapons" yaml:"weapons"` Powers []PowerDefinition `json:"powers" yaml:"powers"` WeaponXP int64 `json:"weaponXp" yaml:"weaponXp"` SpellXP int64 `json:"spellXp" yaml:"spellXp"` RevivalRange float64 `json:"revivalRange" yaml:"revivalRange"` RevivalHealth float64 `json:"revivalHealth" yaml:"revivalHealth"` } func (c Catalog) PowerItems() map[string]string { out := map[string]string{"revival_stone": "Revival stone"} if c.Powers != nil { for _, p := range c.Powers.Powers { if p.Book { out["book_"+p.ID] = p.Name + " spell book" } } } return out } func (c Catalog) validatePowers() error { v := c.Powers if v == nil { return nil } if len(v.Powers) > 256 || len(v.Weapons) > 64 || v.WeaponXP < 1 || v.WeaponXP > 1000 || v.SpellXP < 1 || v.SpellXP > 1000 || !finiteRange(v.RevivalRange, 1, 5) || !finiteRange(v.RevivalHealth, .01, 1) { return fmt.Errorf("invalid power content limits") } weapons := map[string]bool{} for _, s := range v.Weapons { if !validSetIdentity(s.ID, s.Name, s.Description) || weapons[s.ID] || s.BaseXP < 1 || s.BaseXP > 1000000 || s.XPPerLevel < 1 || s.XPPerLevel > 1000000 || s.MaxLevel < 1 || s.MaxLevel > 1000 { return fmt.Errorf("invalid weapon profession") } weapons[s.ID] = true } attacks := map[string]CombatAttack{} if c.Combat != nil { for _, a := range c.Combat.Attacks { attacks[a.ID] = a } } powers := map[string]PowerDefinition{} titles := map[string]bool{} for _, t := range c.Titles { titles[t.ID] = true } for _, p := range v.Powers { if !validSetIdentity(p.ID, p.Name, p.Description) || powers[p.ID].ID != "" || !slices.Contains([]string{"spell", "ability"}, p.Kind) || !slices.Contains([]string{"target", "self", "aura"}, p.Targeting) || !finiteRange(p.BasePower, 0, 100000) || !finiteRange(p.Mana, 0, 10000) || !finiteRange(p.CastSeconds, 0, 30) || !finiteRange(p.Cooldown, .1, 120) || !finiteRange(p.RankScaling, 0, 1) || p.BaseXP < 1 || p.BaseXP > 1000000 || p.XPPerLevel < 1 || p.XPPerLevel > 1000000 || p.MaxLevel < 1 || p.MaxLevel > 1000 || len(p.Parents) > 16 { return fmt.Errorf("invalid spell/ability %q", p.Name) } if p.Resurrection { if p.Kind != "spell" || p.Targeting != "target" || p.AttackID != "" || p.CastSeconds != 0 { return fmt.Errorf("resurrection requires an instant corpse-targeted spell") } } else { a, ok := attacks[p.AttackID] if !ok || (p.Targeting == "aura" && (a.Radius <= 0 || a.Duration <= 0 || a.Delivery != "melee")) || (p.Targeting == "self" && a.Effect != "heal") { return fmt.Errorf("invalid power attack/targeting") } } if p.Kind == "ability" { if !weapons[p.Weapon] || p.WeaponLevel < 1 || p.WeaponLevel > 1000 || p.Book || len(p.Parents) > 0 { return fmt.Errorf("ability requires a weapon proficiency") } } else if p.Weapon != "" || (!p.Book && len(p.Parents) == 0) { return fmt.Errorf("spell requires a book or predecessor") } r := p.Requirements if r.Level < 1 || r.Level > 1000 || len(r.Stats) > 32 || len(r.Titles) > 16 { return fmt.Errorf("invalid power requirements") } for stat, n := range r.Stats { if !KnownStat(stat) || !finiteRange(n, 0, 1000000) { return fmt.Errorf("invalid power stat requirement") } } for _, id := range r.Titles { if !titles[id] { return fmt.Errorf("unknown power title") } } powers[p.ID] = p } for _, p := range v.Powers { for id, rank := range p.Parents { parent, ok := powers[id] if !ok || parent.Kind != "spell" || rank < 1 || rank > parent.MaxLevel { return fmt.Errorf("invalid spell unlock predecessor") } } } visiting, done := map[string]bool{}, map[string]bool{} var visit func(string) bool visit = func(id string) bool { if visiting[id] { return false } if done[id] { return true } visiting[id] = true for parent := range powers[id].Parents { if !visit(parent) { return false } } visiting[id] = false done[id] = true return true } for id := range powers { if !visit(id) { return fmt.Errorf("spell unlock graph contains a cycle") } } for _, i := range c.Items { if i.WeaponType != "" && !weapons[i.WeaponType] { return fmt.Errorf("unknown equipment weapon type") } if _, ok := c.PowerItems()[i.ID]; ok { return fmt.Errorf("equipment conflicts with power item") } } return nil } func (c *Catalog) RestorePowers(b Balance) { if c.Powers != nil { return } c.Powers = b.Powers if c.Combat == nil { c.Combat = b.Combat } else { combat := *c.Combat combat.Attacks = slices.Clone(combat.Attacks) for _, seed := range b.Combat.Attacks { if !slices.ContainsFunc(combat.Attacks, func(a CombatAttack) bool { return a.ID == seed.ID }) { combat.Attacks = append(combat.Attacks, seed) } } c.Combat = &combat } c.Items = slices.Clone(c.Items) for i := range c.Items { for _, seed := range b.Items { if c.Items[i].ID == seed.ID { c.Items[i].WeaponType = seed.WeaponType } } } }