341 lines
10 KiB
Go
341 lines
10 KiB
Go
package game
|
|
|
|
import (
|
|
"aeternalis/server/content"
|
|
p "aeternalis/server/internal/protocol"
|
|
"errors"
|
|
"fmt"
|
|
"math"
|
|
"slices"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
func (w *World) mobIDs() []string {
|
|
ids := make([]string, 0, len(w.Mobs))
|
|
for id := range w.Mobs {
|
|
ids = append(ids, id)
|
|
}
|
|
sort.Strings(ids)
|
|
return ids
|
|
}
|
|
func ParseMobSpawn(value string) (int, float64, float64, error) {
|
|
parts := strings.Split(value, ",")
|
|
if len(parts) != 3 {
|
|
return 0, 0, 0, errors.New("spawn requires count,x,z")
|
|
}
|
|
n, e1 := strconv.Atoi(parts[0])
|
|
x, e2 := strconv.ParseFloat(parts[1], 64)
|
|
z, e3 := strconv.ParseFloat(parts[2], 64)
|
|
if e1 != nil || e2 != nil || e3 != nil || n < 1 || n > 32 || math.IsNaN(x) || math.IsNaN(z) || math.IsInf(x, 0) || math.IsInf(z, 0) || math.Abs(x) > 100000 || math.Abs(z) > 100000 {
|
|
return 0, 0, 0, errors.New("choose 1-32 mobs and finite world coordinates")
|
|
}
|
|
return n, x, z, nil
|
|
}
|
|
func (w *World) mobDefinition(id string) *content.MobDefinition {
|
|
for i := range w.Balance.Combat.Mobs {
|
|
if w.Balance.Combat.Mobs[i].ID == id {
|
|
return &w.Balance.Combat.Mobs[i]
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
func (w *World) newMob(id string, d content.MobDefinition, pos p.Vec3, respawn float64) *Mob {
|
|
scale := float64(d.Level) * (1 + w.Age()/86400*d.ScalePerDay)
|
|
hp := d.HP * scale
|
|
home := pos
|
|
m := &Mob{Entity: p.Entity{ID: id, Kind: "mob", Model: stringPtr(d.Model), Appearance: d.Appearance, Name: d.Name, Position: pos, HP: hp, MaxHP: hp, State: "alive"}, Definition: &d, Home: &home, HomeX: ChunkCoord(pos.X, w.Balance.ChunkSize), HomeZ: ChunkCoord(pos.Z, w.Balance.ChunkSize), RespawnDelay: respawn, Power: d.Damage * scale}
|
|
for _, a := range w.Balance.Combat.Attacks {
|
|
if a.ID == d.AttackID {
|
|
m.Attack = protocolAttack(a)
|
|
}
|
|
}
|
|
for _, l := range w.Balance.Combat.Loot {
|
|
if l.ID == d.LootID {
|
|
m.Loot = l
|
|
}
|
|
}
|
|
return m
|
|
}
|
|
func (w *World) SpawnMobs(definition, value string) error {
|
|
if w.IsHub() {
|
|
return errors.New("combat is unavailable in the hub")
|
|
}
|
|
if w.Phase == "won" || w.Phase == "lost" {
|
|
return errors.New("world has ended")
|
|
}
|
|
n, x, z, err := ParseMobSpawn(value)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
d := w.mobDefinition(definition)
|
|
if d == nil {
|
|
return errors.New("unknown mob definition")
|
|
}
|
|
if len(w.Mobs)+n > w.Balance.CombatRules.MaxMobs {
|
|
return errors.New("world mob limit reached")
|
|
}
|
|
positions := []p.Vec3{}
|
|
for i := 0; i < n; i++ {
|
|
px, pz := x+float64(i%6)*2, z+float64(i/6)*2
|
|
if math.Hypot(px, pz) >= w.SafeRadius() {
|
|
return errors.New("spawn would leave the surviving world")
|
|
}
|
|
positions = append(positions, w.terrain.Position(px, pz))
|
|
if w.structureBlocked(positions[len(positions)-1], positions[len(positions)-1]) {
|
|
return errors.New("spawn intersects a structure")
|
|
}
|
|
}
|
|
for _, pos := range positions {
|
|
id := w.combatID("mob")
|
|
w.Mobs[id] = w.newMob(id, *d, pos, 0)
|
|
}
|
|
w.dirty = true
|
|
return nil
|
|
}
|
|
func (w *World) ensureMob(ch p.Chunk) {
|
|
id := "m:" + ch.Key
|
|
if _, ok := w.Mobs[id]; ok || len(w.Mobs) >= w.Balance.CombatRules.MaxMobs {
|
|
return
|
|
}
|
|
x, z := (float64(ch.X)+.55)*ch.Size, (float64(ch.Z)+.55)*ch.Size
|
|
if math.Hypot(x, z) > w.Balance.WorldRadius {
|
|
return
|
|
}
|
|
hp := w.Balance.MobHp * (1 + w.Age()/86400*w.Balance.MobScalePerDay)
|
|
home := w.terrain.Position(x, z)
|
|
if w.structureBlocked(home, home) {
|
|
return
|
|
}
|
|
w.Mobs[id] = &Mob{Entity: p.Entity{ID: id, Kind: "sentinel", Name: "Ash sentinel", Position: home, HP: hp, MaxHP: hp, State: "alive"}, HomeX: int(ch.X), HomeZ: int(ch.Z), Home: &home, RespawnDelay: w.Balance.MobRespawnSeconds}
|
|
w.dirty = true
|
|
}
|
|
func (w *World) updateSpawns(active map[string]bool) {
|
|
for _, rule := range w.Balance.Combat.Spawns {
|
|
d := w.mobDefinition(rule.MobID)
|
|
if d == nil {
|
|
continue
|
|
}
|
|
for i := int64(0); i < rule.Count; i++ {
|
|
id := fmt.Sprintf("spawn:%s:%d", rule.ID, i)
|
|
if _, ok := w.Mobs[id]; ok {
|
|
continue
|
|
}
|
|
if len(w.Mobs) >= w.Balance.CombatRules.MaxMobs {
|
|
return
|
|
}
|
|
angle := float64(i) * 2.399963229728653
|
|
radius := rule.Radius * math.Sqrt(float64(i+1)/float64(rule.Count))
|
|
x, z := rule.X+math.Cos(angle)*radius, rule.Z+math.Sin(angle)*radius
|
|
cx, cz := ChunkCoord(x, w.Balance.ChunkSize), ChunkCoord(z, w.Balance.ChunkSize)
|
|
if !active[Key(cx, cz)] || math.Hypot(x, z) > w.SafeRadius() {
|
|
continue
|
|
}
|
|
biomeID := w.mobBiome(cx, cz)
|
|
if len(rule.Biomes) > 0 && !slices.Contains(rule.Biomes, biomeID) {
|
|
continue
|
|
}
|
|
pos := w.terrain.Position(x, z)
|
|
if w.structureBlocked(pos, pos) {
|
|
continue
|
|
}
|
|
near := false
|
|
for _, c := range w.Characters {
|
|
if c.Online && c.View.Entity.State == "alive" && distance(pos, c.View.Entity.Position) < rule.MinPlayerDistance {
|
|
near = true
|
|
break
|
|
}
|
|
}
|
|
if near {
|
|
continue
|
|
}
|
|
w.Mobs[id] = w.newMob(id, *d, pos, rule.Respawn)
|
|
w.Mobs[id].MinPlayerDistance = rule.MinPlayerDistance
|
|
w.dirty = true
|
|
}
|
|
}
|
|
}
|
|
|
|
func (w *World) mobBiome(x, z int) string {
|
|
if layout, ok := w.ResourceLayouts[Key(x, z)]; ok {
|
|
if layout.BiomeID != "" {
|
|
return layout.BiomeID
|
|
}
|
|
// Older explored layouts persisted only the display name. Keep their
|
|
// established biome instead of recalculating from new catalog weights.
|
|
for _, biome := range w.Balance.Gathering.Biomes {
|
|
if biome.Name == layout.Biome {
|
|
return biome.ID
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
return w.terrain.biome(x, z).ID
|
|
}
|
|
|
|
// Local slope checks and deterministic side steps cross chunk edges. Future solid
|
|
// structures can extend this one movement/line-of-sight boundary.
|
|
func (w *World) mobStep(m *Mob, to p.Vec3, speed, dt float64) {
|
|
from := m.Entity.Position
|
|
d := distance(from, to)
|
|
if d < .01 {
|
|
return
|
|
}
|
|
step := math.Min(d, speed*dt)
|
|
angle := math.Atan2(to.Z-from.Z, to.X-from.X)
|
|
for _, offset := range []float64{0, .7, -.7, 1.3, -1.3} {
|
|
x, z := from.X+math.Cos(angle+offset)*step, from.Z+math.Sin(angle+offset)*step
|
|
if math.Hypot(x, z) >= w.SafeRadius() {
|
|
continue
|
|
}
|
|
dest := w.terrain.Position(x, z)
|
|
if w.structureBlocked(from, dest) || math.Abs(dest.Y-from.Y) > w.Balance.CombatRules.MaxSlope*step {
|
|
continue
|
|
}
|
|
m.Entity.Position = dest
|
|
return
|
|
}
|
|
}
|
|
func (w *World) updateMobs(active map[string]bool, dt float64) {
|
|
w.updateSpawns(active)
|
|
for _, id := range w.mobIDs() {
|
|
m := w.Mobs[id]
|
|
if m.Home == nil {
|
|
pos := w.terrain.Position((float64(m.HomeX)+.55)*w.Balance.ChunkSize, (float64(m.HomeZ)+.55)*w.Balance.ChunkSize)
|
|
m.Home = &pos
|
|
m.RespawnDelay = w.Balance.MobRespawnSeconds
|
|
}
|
|
homeActive := active[Key(m.HomeX, m.HomeZ)]
|
|
currentActive := active[Key(ChunkCoord(m.Entity.Position.X, w.Balance.ChunkSize), ChunkCoord(m.Entity.Position.Z, w.Balance.ChunkSize))]
|
|
if m.Entity.HP <= 0 {
|
|
if m.RespawnDelay == 0 {
|
|
delete(w.Mobs, id)
|
|
w.dirty = true
|
|
continue
|
|
}
|
|
if !homeActive || w.Age() < m.RespawnAt {
|
|
continue
|
|
}
|
|
blocked := false
|
|
for _, c := range w.Characters {
|
|
if c.Online && c.View.Entity.State == "alive" && distance(c.View.Entity.Position, *m.Home) < m.MinPlayerDistance {
|
|
blocked = true
|
|
break
|
|
}
|
|
}
|
|
if blocked {
|
|
continue
|
|
}
|
|
hp := w.Balance.MobHp * (1 + w.Age()/86400*w.Balance.MobScalePerDay)
|
|
if m.Definition != nil {
|
|
d := m.Definition
|
|
scale := float64(d.Level) * (1 + w.Age()/86400*d.ScalePerDay)
|
|
hp = d.HP * scale
|
|
m.Power = d.Damage * scale
|
|
}
|
|
m.Entity.HP = hp
|
|
m.Entity.MaxHP = hp
|
|
m.Entity.State = "alive"
|
|
m.Entity.Position = *m.Home
|
|
m.Target = ""
|
|
w.dirty = true
|
|
}
|
|
if !homeActive && !currentActive {
|
|
continue
|
|
}
|
|
speed, aggro, leash := w.Balance.MobSpeed, w.Balance.MobAggroRange, w.Balance.ChunkSize*2
|
|
behavior := "aggressive"
|
|
attack := p.CombatAttack{ID: "legacy_mob", Name: "Sentinel strike", Delivery: "melee", Effect: "damage", Stat: "meleeDamage", Range: w.Balance.MobAttackRange, Cooldown: w.Balance.MobCooldown, Multiplier: 1, Speed: 1, Interval: 1}
|
|
power := w.Balance.MobDamage * (1 + w.Age()/86400*w.Balance.MobScalePerDay)
|
|
if d := m.Definition; d != nil {
|
|
speed, aggro, leash, behavior = d.Speed, d.AggroRange, d.LeashRange, d.Behavior
|
|
attack = m.Attack
|
|
power = m.Power
|
|
}
|
|
if distance(m.Entity.Position, *m.Home) > leash {
|
|
m.Returning = true
|
|
m.Target = ""
|
|
}
|
|
if m.Returning {
|
|
if distance(m.Entity.Position, *m.Home) < 1 {
|
|
m.Returning = false
|
|
} else {
|
|
w.mobStep(m, *m.Home, speed, dt)
|
|
}
|
|
continue
|
|
}
|
|
if behavior != "passive" && w.attackNearbyStructure(m, attack, power, aggro, leash) {
|
|
continue
|
|
}
|
|
var target *Character
|
|
if c := w.Characters[m.Target]; c != nil && c.Online && !c.Sheltered && c.View.Entity.State == "alive" && distance(c.View.Entity.Position, *m.Home) <= leash {
|
|
target = c
|
|
}
|
|
if target == nil {
|
|
m.Target = ""
|
|
if behavior != "passive" {
|
|
nearest := aggro
|
|
for _, c := range w.orderedCharacters() {
|
|
if !c.Online || c.Sheltered || c.View.Entity.State != "alive" {
|
|
continue
|
|
}
|
|
d := distance(c.View.Entity.Position, m.Entity.Position)
|
|
if d < nearest && distance(c.View.Entity.Position, *m.Home) <= leash {
|
|
if _, blocked := w.combatLine(body(m.Entity.Position), body(c.View.Entity.Position), ""); blocked {
|
|
continue
|
|
}
|
|
target = c
|
|
nearest = d
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if target == nil {
|
|
if distance(m.Entity.Position, *m.Home) > 1 {
|
|
w.mobStep(m, *m.Home, speed, dt)
|
|
}
|
|
continue
|
|
}
|
|
m.Target = target.View.Entity.ID
|
|
if behavior == "guard" && distance(target.View.Entity.Position, *m.Home) > aggro {
|
|
m.Target = ""
|
|
w.mobStep(m, *m.Home, speed, dt)
|
|
continue
|
|
}
|
|
aim := target.View.Entity.Position
|
|
targetID := target.View.Entity.ID
|
|
if attack.Effect == "heal" {
|
|
aim = m.Entity.Position
|
|
targetID = m.Entity.ID
|
|
}
|
|
if length3(body(m.Entity.Position), body(aim)) <= attack.Range {
|
|
if w.Age()-m.LastAttack < attack.Cooldown {
|
|
continue
|
|
}
|
|
if _, blocked := w.combatLine(body(m.Entity.Position), body(aim), targetID); blocked {
|
|
w.mobStep(m, aim, speed, dt)
|
|
continue
|
|
}
|
|
if attack.Delivery == "projectile" && len(w.Projectiles) >= w.Balance.CombatRules.MaxProjectiles {
|
|
continue
|
|
}
|
|
if attack.Duration > 0 && len(w.Areas)+w.pendingAreas() >= w.Balance.CombatRules.MaxAreas {
|
|
continue
|
|
}
|
|
shot := Projectile{ID: w.combatID("projectile"), Source: id, Player: false, Position: body(m.Entity.Position), Destination: body(aim), Attack: attack, Power: power * attack.Multiplier, Target: targetID}
|
|
m.LastAttack = w.Age()
|
|
if attack.Delivery == "projectile" {
|
|
w.Projectiles[shot.ID] = &shot
|
|
w.projectileVisual(shot, "launch", "")
|
|
} else {
|
|
shot.Position = body(aim)
|
|
w.impact(shot, targetID)
|
|
}
|
|
w.dirty = true
|
|
} else {
|
|
w.mobStep(m, aim, speed, dt)
|
|
}
|
|
}
|
|
}
|