Files

377 lines
11 KiB
Go

package game
import (
"aeternalis/server/content"
p "aeternalis/server/internal/protocol"
"encoding/json"
"errors"
"math"
"slices"
)
type PendingCast struct {
Power string `json:"power"`
Target string `json:"target"`
Origin p.Vec3 `json:"origin"`
Finish float64 `json:"finish"`
}
type CombatCredit struct {
Power string `json:"power"`
Weapon string `json:"weapon"`
Rewarded bool `json:"rewarded"`
}
func (w *World) refreshPowers(c *Character) {
if c.View.Powers == nil {
c.View.Powers = map[string]p.LearnedPower{}
}
if c.View.Weapons == nil {
c.View.Weapons = map[string]p.WeaponProgress{}
}
if w.Balance.Powers == nil {
return
}
for _, s := range w.Balance.Powers.Weapons {
v := c.View.Weapons[s.ID]
v.ID = s.ID
v.Name = s.Name
v.Level, v.XPToNextLevel = content.SkillLevel(s, v.XP)
c.View.Weapons[s.ID] = v
}
for id, v := range c.View.Powers {
d := v.Definition
v.Level, v.XPToNextLevel = content.SkillLevel(content.GatheringSkill{BaseXP: d.BaseXP, XPPerLevel: d.XPPerLevel, MaxLevel: d.MaxLevel}, v.XP)
c.View.Powers[id] = v
}
for id, name := range (content.Catalog{Powers: w.Balance.Powers}).PowerItems() {
if c.View.Inventory[id] > 0 {
c.View.StackNames[id] = name
}
}
c.View.Casting = nil
if c.PendingCast != nil {
message := "Casting " + c.View.Powers[c.PendingCast.Power].Definition.Name
c.View.Casting = &message
}
}
func (w *World) restorePowers(c *Character) error {
if len(c.View.Powers) > 256 || len(c.View.Weapons) > 64 {
return errors.New("invalid learned power history")
}
for id, v := range c.View.Powers {
if id != v.Definition.ID || v.XP < 0 || v.XP > 10000000000000 || !finiteCraft(v.ReadyAt) || v.Definition.BaseXP < 1 || v.Definition.XPPerLevel < 1 || v.Definition.MaxLevel < 1 || v.Definition.MaxLevel > 1000 {
return errors.New("invalid learned spell")
}
d := v.Definition
if len(id) > 64 || !finiteCraft(d.Mana) || d.Mana > 10000 || !finiteCraft(d.BasePower) || d.BasePower > 100000 || !finiteCraft(d.RankScaling) || d.RankScaling > 1 || !finiteCraft(d.Cooldown) || d.Cooldown < .1 || d.Cooldown > 120 || !finiteCraft(d.CastSeconds) || d.CastSeconds > 30 || len(d.Parents) > 16 || len(d.Requirements.Stats) > 32 || len(d.Requirements.Titles) > 16 {
return errors.New("invalid saved power definition")
}
if !d.Resurrection {
raw, _ := json.Marshal(v.Attack)
var attack content.CombatAttack
_ = json.Unmarshal(raw, &attack)
if e := attack.Validate(); e != nil {
return e
}
}
}
for _, v := range c.View.Weapons {
if v.XP < 0 || v.XP > 10000000000000 {
return errors.New("invalid weapon XP")
}
}
// Casts cancel on reconnect/restart/travel; no cast cost is taken until resolution.
c.PendingCast = nil
c.View.Casting = nil
for i := range c.View.Items {
if c.View.Items[i].WeaponType == nil {
for _, d := range w.Balance.Items {
if d.ID == c.View.Items[i].DefinitionID && d.WeaponType != "" {
v := d.WeaponType
c.View.Items[i].WeaponType = &v
}
}
}
}
return nil
}
func (w *World) powerRequirements(c *Character, d p.PowerDefinition) bool {
if c.View.Level < d.Requirements.Level {
return false
}
stats := w.statValues(c, false)
for key, n := range d.Requirements.Stats {
if stats[key].Final < n {
return false
}
}
for _, id := range d.Requirements.Titles {
if !slices.ContainsFunc(c.View.Titles, func(t p.TitleAward) bool { return t.ID == id }) {
return false
}
}
if d.Kind == "ability" && c.View.Weapons[d.Weapon].Level < d.WeaponLevel {
return false
}
return true
}
func (w *World) acquirePower(c *Character, d content.PowerDefinition) {
if d.Kind == "ability" && d.MaxLevel == 1 {
d.MaxLevel = 1000
}
var definition p.PowerDefinition
raw, _ := json.Marshal(d)
_ = json.Unmarshal(raw, &definition)
v := p.LearnedPower{Definition: definition, Level: 1, XPToNextLevel: content.XPForLevel(2)}
for _, a := range w.Balance.Combat.Attacks {
if a.ID == d.AttackID {
v.Attack = protocolAttack(a)
}
}
c.View.Powers[d.ID] = v
w.dirty = true
}
func (w *World) unlockPowers(c *Character) {
w.refreshPowers(c)
if w.Balance.Powers == nil {
return
}
// Topological fixed point is bounded by the validated catalog size.
for pass := 0; pass < len(w.Balance.Powers.Powers); pass++ {
changed := false
for _, d := range w.Balance.Powers.Powers {
if _, ok := c.View.Powers[d.ID]; ok || d.Book {
continue
}
var definition p.PowerDefinition
raw, _ := json.Marshal(d)
_ = json.Unmarshal(raw, &definition)
if !w.powerRequirements(c, definition) {
continue
}
ready := true
for id, rank := range d.Parents {
if c.View.Powers[id].Level < rank {
ready = false
}
}
if ready {
w.acquirePower(c, d)
changed = true
}
}
if !changed {
break
}
}
w.refreshPowers(c)
}
func (w *World) LearnPower(c *Character, book string) error {
if c == nil || !c.Online || c.Sheltered || c.View.RemainingSeconds <= 0 || (c.View.Entity.State != "alive" && c.View.Entity.State != "eligible") || w.Phase == "lost" {
return errors.New("cannot learn a spell now")
}
if c.View.Inventory[book] < 1 {
return errors.New("spell book not owned")
}
for _, d := range w.Balance.Powers.Powers {
if d.Book && "book_"+d.ID == book {
if _, ok := c.View.Powers[d.ID]; ok {
return errors.New("spell already learned; book retained")
}
var definition p.PowerDefinition
raw, _ := json.Marshal(d)
_ = json.Unmarshal(raw, &definition)
if !w.powerRequirements(c, definition) {
return errors.New("spell requirements not met")
}
for id, rank := range d.Parents {
if c.View.Powers[id].Level < rank {
return errors.New("predecessor spell rank required")
}
}
TakeStack(c, book, 1)
w.acquirePower(c, d)
w.unlockPowers(c)
c.Message = "Learned " + d.Name
return nil
}
}
return errors.New("unknown spell book")
}
func (w *World) weaponType(c *Character) string {
for _, i := range c.View.Items {
if i.ID == c.View.Equipment["weapon"] && i.WeaponType != nil {
return *i.WeaponType
}
}
return ""
}
func (w *World) awardCombatCredit(shot Projectile) {
credit := shot.Credit
if credit == nil || credit.Rewarded || !shot.Player || !w.AllowsXP() {
return
}
c := w.Characters[shot.Source]
if c == nil || c.View.Entity.State != "alive" {
return
}
credit.Rewarded = true
if credit.Power != "" {
v, ok := c.View.Powers[credit.Power]
if ok {
v.XP = min(int64(10000000000000), v.XP+w.Balance.Powers.SpellXP)
c.View.Powers[credit.Power] = v
}
}
if credit.Weapon != "" {
v, ok := c.View.Weapons[credit.Weapon]
if ok {
v.XP = min(int64(10000000000000), v.XP+w.Balance.Powers.WeaponXP)
c.View.Weapons[credit.Weapon] = v
}
}
w.unlockPowers(c)
w.dirty = true
}
func (w *World) CastPower(c *Character, id, target string) error {
w.unlockPowers(c)
v, ok := c.View.Powers[id]
if !ok {
return errors.New("power not learned")
}
d := v.Definition
if d.Resurrection {
return errors.New("use corpse resurrection")
}
if c.PendingCast != nil {
return errors.New("already casting")
}
if err := w.checkPower(c, v, target); err != nil {
return err
}
if d.CastSeconds > 0 {
c.PendingCast = &PendingCast{Power: id, Target: target, Origin: c.View.Entity.Position, Finish: float64(w.now.UnixMilli())/1000 + d.CastSeconds}
w.refreshPowers(c)
w.dirty = true
return nil
}
return w.releasePower(c, id, target)
}
func (w *World) checkPower(c *Character, v p.LearnedPower, target string) error {
d := v.Definition
if !c.Online || c.Sheltered || c.View.Entity.State != "alive" || c.View.RemainingSeconds <= 0 || w.Phase == "lost" || w.Phase == "won" {
return errors.New("cannot cast here")
}
if w.IsHub() && v.Attack.Effect != "heal" {
return errors.New("damage powers unavailable in hub")
}
if !w.powerRequirements(c, d) || (d.Kind == "ability" && w.weaponType(c) != d.Weapon) {
return errors.New("power requirements or equipped weapon not met")
}
if c.View.Mana < d.Mana || c.View.Stamina < v.Attack.Stamina {
return errors.New("not enough mana or stamina")
}
if float64(w.now.UnixMilli())/1000 < v.ReadyAt {
return errors.New("power cooldown")
}
if d.Targeting == "self" || d.Targeting == "aura" {
target = c.View.Entity.ID
}
found := false
for _, e := range w.combatTargets(true, v.Attack.Effect) {
if e.ID == target {
if length3(body(c.View.Entity.Position), body(e.Position)) > v.Attack.Range+func() float64 {
if e.Kind == "structure" {
return math.Max(*e.Width, *e.Depth) / 2
}
if target == "boss" {
return 4
}
return 0
}() {
return errors.New("power target out of range")
}
if _, blocked := w.combatLine(body(c.View.Entity.Position), body(e.Position), e.ID); blocked {
return errors.New("terrain blocks power")
}
found = true
}
}
if d.Targeting == "aura" {
found = true
}
if !found {
return errors.New("invalid power target")
}
if v.Attack.Delivery == "projectile" && len(w.Projectiles) >= w.Balance.CombatRules.MaxProjectiles {
return errors.New("projectile limit")
}
if v.Attack.Duration > 0 && len(w.Areas)+w.pendingAreas() >= w.Balance.CombatRules.MaxAreas {
return errors.New("area limit")
}
return nil
}
func (w *World) releasePower(c *Character, id, target string) error {
v := c.View.Powers[id]
if err := w.checkPower(c, v, target); err != nil {
return err
}
d := v.Definition
if d.Targeting == "self" || d.Targeting == "aura" {
target = c.View.Entity.ID
}
to := body(c.View.Entity.Position)
for _, e := range w.combatTargets(true, v.Attack.Effect) {
if e.ID == target {
to = body(e.Position)
}
}
a := v.Attack
if a.Delivery == "projectile" {
if a.DexteritySpeed != nil {
a.Speed += c.View.Stats["dexterity"].Final * *a.DexteritySpeed
}
if a.StrengthSpeed != nil {
a.Speed += c.View.Stats["strength"].Final * *a.StrengthSpeed
}
a.Speed = math.Min(100, math.Max(1, a.Speed))
}
c.View.Mana -= d.Mana
c.View.Stamina -= a.Stamina
v.ReadyAt = float64(w.now.UnixMilli())/1000 + d.Cooldown
c.View.Powers[id] = v
credit := &CombatCredit{Power: id}
if d.Kind == "ability" {
credit.Weapon = w.weaponType(c)
}
shot := Projectile{ID: w.combatID("projectile"), Source: c.View.Entity.ID, Player: true, Target: target, Position: body(c.View.Entity.Position), Destination: to, Attack: a, Power: (d.BasePower + c.View.Stats[a.Stat].Final*a.Multiplier) * (1 + float64(v.Level-1)*d.RankScaling), Credit: credit, MovingAura: d.Targeting == "aura"}
if a.Delivery == "projectile" {
w.Projectiles[shot.ID] = &shot
w.projectileVisual(shot, "launch", "")
} else {
shot.Position = to
w.impact(shot, target)
}
c.Message = "Used " + d.Name
w.dirty = true
return nil
}
func (w *World) updatePowers() {
for _, c := range w.orderedCharacters() {
if cast := c.PendingCast; cast != nil {
if !c.Online || c.Sheltered || c.View.Entity.State != "alive" || length3(c.View.Entity.Position, cast.Origin) > .1 {
c.PendingCast = nil
c.Message = "Casting interrupted"
w.dirty = true
} else if float64(w.now.UnixMilli())/1000 >= cast.Finish {
c.PendingCast = nil
if e := w.releasePower(c, cast.Power, cast.Target); e != nil {
c.Message = e.Error()
}
w.dirty = true
}
w.refreshPowers(c)
}
}
}