377 lines
11 KiB
Go
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)
|
|
}
|
|
}
|
|
}
|