Aetheria/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeDaemonSimulation.cs

using System;
using System.Collections.Generic;
using System.Linq;

#nullable enable

namespace GameCult.Aetheria.State.Verse
{
    public static class AetheriaRuntimeDaemonSimulation
    {
        private const string Hull = "hull";
        private const string Shield = "shield";
        private const string Heat = "heat";

        public static void Step(
            AetheriaRuntimeRunCheckpointCommit run,
            AetheriaRuntimeDaemonIntentState intents,
            double deltaSeconds,
            AetheriaRuntimeDaemonSimulationSettings settings)
        {
            if (run == null || deltaSeconds <= 0)
                return;

            foreach (var zone in run.Zones ?? Array.Empty<AetheriaRuntimeZoneSnapshotCommit>())
            {
                if (zone == null)
                    continue;

                var entities = (zone.Entities ?? Array.Empty<AetheriaRuntimeEntitySnapshotCommit>())
                    .Where(entity => entity != null)
                    .ToArray();
                if (entities.Length == 0)
                    continue;

                EnsureStats(entities, settings);
                ApplyMovementIntent(run, entities, intents?.Movement, settings);
                StepRaiderAi(entities);
                StepTargetPursuit(entities, settings);
                StepMovement(entities, deltaSeconds);
                StepCombat(run, zone, entities, intents, deltaSeconds, settings);
                RefreshContacts(entities, settings);
            }
        }

        private static void ApplyMovementIntent(
            AetheriaRuntimeRunCheckpointCommit run,
            IReadOnlyList<AetheriaRuntimeEntitySnapshotCommit> entities,
            AetheriaRuntimeDaemonMovementIntent? movement,
            AetheriaRuntimeDaemonSimulationSettings settings)
        {
            if (movement == null || !TryParseEntityIndex(movement.ActorEntityKey, out var entityIndex))
                return;

            var entity = entities.FirstOrDefault(candidate => candidate.EntityIndex == entityIndex);
            if (entity == null || !IsPlayerOwned(entity) || !IsAlive(entity))
                return;

            var magnitude = Clamp01(movement.Magnitude);
            var normalized = Normalize(movement.DirectionX, movement.DirectionY);
            var speed = ResolveSpeed(entity, settings);
            entity.VelocityX = normalized.X * speed * magnitude;
            entity.VelocityY = normalized.Y * speed * magnitude;
            if (magnitude <= 0.001)
                entity.TargetEntityIndex = -1;
            else
                Face(entity, normalized.X, normalized.Y);
        }

        private static void StepRaiderAi(IReadOnlyList<AetheriaRuntimeEntitySnapshotCommit> entities)
        {
            foreach (var raider in entities.Where(entity => string.Equals(entity.FactionKey, "raider", StringComparison.OrdinalIgnoreCase)))
            {
                if (!IsAlive(raider))
                    continue;

                var target = entities
                    .Where(IsPlayerOwned)
                    .Where(IsAlive)
                    .OrderBy(candidate => DistanceSq(raider, candidate))
                    .FirstOrDefault();
                if (target == null)
                    continue;

                raider.TargetEntityIndex = target.EntityIndex;
            }
        }

        private static void StepTargetPursuit(
            IReadOnlyList<AetheriaRuntimeEntitySnapshotCommit> entities,
            AetheriaRuntimeDaemonSimulationSettings settings)
        {
            var byIndex = entities.ToDictionary(entity => entity.EntityIndex);
            foreach (var entity in entities)
            {
                if (!IsAlive(entity) ||
                    entity.TargetEntityIndex < 0 ||
                    !byIndex.TryGetValue(entity.TargetEntityIndex, out var target) ||
                    !IsAlive(target))
                {
                    continue;
                }

                var dx = target.PositionX - entity.PositionX;
                var dy = target.PositionZ - entity.PositionZ;
                var distance = Math.Sqrt(dx * dx + dy * dy);
                if (distance <= settings.AttackRange * settings.AttackHoldRatio)
                {
                    entity.VelocityX *= 0.72;
                    entity.VelocityY *= 0.72;
                    Face(entity, dx, dy);
                    continue;
                }

                if (string.Equals(entity.FactionKey, "raider", StringComparison.OrdinalIgnoreCase))
                {
                    var direction = Normalize(dx, dy);
                    var speed = ResolveSpeed(entity, settings);
                    entity.VelocityX = direction.X * speed;
                    entity.VelocityY = direction.Y * speed;
                    Face(entity, direction.X, direction.Y);
                }
            }
        }

        private static void StepMovement(
            IReadOnlyList<AetheriaRuntimeEntitySnapshotCommit> entities,
            double deltaSeconds)
        {
            foreach (var entity in entities)
            {
                if (!IsAlive(entity))
                    continue;

                entity.PositionX += entity.VelocityX * deltaSeconds;
                entity.PositionZ += entity.VelocityY * deltaSeconds;
                entity.VelocityX *= 0.992;
                entity.VelocityY *= 0.992;
                if (Math.Abs(entity.VelocityX) + Math.Abs(entity.VelocityY) > 0.01)
                    Face(entity, entity.VelocityX, entity.VelocityY);
            }
        }

        private static void StepCombat(
            AetheriaRuntimeRunCheckpointCommit run,
            AetheriaRuntimeZoneSnapshotCommit zone,
            IReadOnlyList<AetheriaRuntimeEntitySnapshotCommit> entities,
            AetheriaRuntimeDaemonIntentState intents,
            double deltaSeconds,
            AetheriaRuntimeDaemonSimulationSettings settings)
        {
            var byIndex = entities.ToDictionary(entity => entity.EntityIndex);
            foreach (var attacker in entities)
            {
                var weaponState = EnsureDaemonWeaponState(attacker, settings);
                weaponState.Firing = false;
                weaponState.CooldownProgress = Math.Max(0, weaponState.CooldownProgress - deltaSeconds);
                weaponState.CoolingDown = weaponState.CooldownProgress > 0;

                if (!IsAlive(attacker) ||
                    attacker.TargetEntityIndex < 0 ||
                    !byIndex.TryGetValue(attacker.TargetEntityIndex, out var target) ||
                    !IsAlive(target) ||
                    !Hostile(attacker, target))
                {
                    continue;
                }

                if (DistanceSq(attacker, target) > settings.AttackRange * settings.AttackRange)
                    continue;

                Face(attacker, target.PositionX - attacker.PositionX, target.PositionZ - attacker.PositionZ);
                weaponState.LockTargetEntityIndex = target.EntityIndex;
                weaponState.LockProgress = 1.0;

                if (weaponState.CooldownProgress > 0)
                    continue;

                if (IsPlayerOwned(attacker) && !WantsFire(run, zone, attacker, intents))
                    continue;

                SpawnProjectile(zone, attacker, target, settings);
                weaponState.Firing = true;
                weaponState.CoolingDown = true;
                weaponState.CooldownProgress = settings.WeaponCooldownSeconds;
                SetStat(attacker, Heat, Math.Min(100, GetStat(attacker, Heat) + ResolveProjectileDamage(attacker, settings) * settings.ProjectileHeatScale));
            }

            var projectileStep = AetheriaRuntimeYmirProjectilePhysics.Step(zone, entities, deltaSeconds);
            zone.Projectiles = projectileStep.Projectiles;
            foreach (var hit in projectileStep.Hits)
            {
                if (byIndex.TryGetValue(hit.TargetEntityIndex, out var target))
                    Damage(target, hit.Projectile.Damage);
            }

            foreach (var entity in entities)
            {
                SetStat(entity, Heat, Math.Max(0, GetStat(entity, Heat) - settings.HeatDissipationPerSecond * deltaSeconds));
                entity.IsActive = IsAlive(entity);
                if (!entity.IsActive)
                {
                    entity.VelocityX = 0;
                    entity.VelocityY = 0;
                    entity.TargetEntityIndex = -1;
                }
            }
        }

        private static bool WantsFire(
            AetheriaRuntimeRunCheckpointCommit run,
            AetheriaRuntimeZoneSnapshotCommit zone,
            AetheriaRuntimeEntitySnapshotCommit attacker,
            AetheriaRuntimeDaemonIntentState intents)
        {
            var actorKey = run.EntityRecordKey(zone.ZoneIndex, attacker.EntityIndex);
            return (intents == null
                    ? Enumerable.Empty<AetheriaRuntimeDaemonWeaponGroupIntent>()
                    : intents.WeaponGroups)
                .Any(intent => intent != null &&
                    string.Equals(intent.ActorEntityKey, actorKey, StringComparison.Ordinal) &&
                    intent.WeaponGroup == 0 &&
                    intent.Fire &&
                    intent.Active);
        }

        private static AetheriaRuntimeWeaponStateCommit EnsureDaemonWeaponState(
            AetheriaRuntimeEntitySnapshotCommit entity,
            AetheriaRuntimeDaemonSimulationSettings settings)
        {
            var states = (entity.WeaponStates ?? Array.Empty<AetheriaRuntimeWeaponStateCommit>()).ToList();
            var state = states.FirstOrDefault(candidate =>
                candidate != null &&
                string.Equals(candidate.OwnerKind, "daemon-simulation", StringComparison.Ordinal) &&
                candidate.OwnerIndex == entity.EntityIndex);
            if (state != null)
                return state;

            state = new AetheriaRuntimeWeaponStateCommit
            {
                OwnerKind = "daemon-simulation",
                OwnerIndex = entity.EntityIndex,
                BehaviorIndex = 0,
                BehaviorKind = "ProjectileWeapon",
                Ammo = -1,
                BurstRemaining = 0,
                BurstInterval = settings.WeaponCooldownSeconds,
                LockTargetEntityIndex = -1
            };
            states.Add(state);
            entity.WeaponStates = states.ToArray();
            return state;
        }

        private static void SpawnProjectile(
            AetheriaRuntimeZoneSnapshotCommit zone,
            AetheriaRuntimeEntitySnapshotCommit attacker,
            AetheriaRuntimeEntitySnapshotCommit target,
            AetheriaRuntimeDaemonSimulationSettings settings)
        {
            var direction = Normalize(target.PositionX - attacker.PositionX, target.PositionZ - attacker.PositionZ);
            if (Math.Abs(direction.X) + Math.Abs(direction.Y) <= 0.0001)
                direction = Normalize(attacker.DirectionX, attacker.DirectionY);
            if (Math.Abs(direction.X) + Math.Abs(direction.Y) <= 0.0001)
                direction = (0, 1);

            var projectiles = (zone.Projectiles ?? Array.Empty<AetheriaRuntimeProjectileCommit>())
                .Where(projectile => projectile != null && projectile.Active)
                .ToList();
            projectiles.Add(new AetheriaRuntimeProjectileCommit
            {
                ProjectileId = CreateProjectileId(zone, attacker, target, projectiles.Count),
                SourceEntityIndex = attacker.EntityIndex,
                TargetEntityIndex = target.EntityIndex,
                FactionKey = attacker.FactionKey ?? "",
                PositionX = attacker.PositionX + direction.X * settings.ProjectileSpawnOffset,
                PositionY = attacker.PositionY,
                PositionZ = attacker.PositionZ + direction.Y * settings.ProjectileSpawnOffset,
                DirectionX = direction.X,
                DirectionY = direction.Y,
                VelocityX = direction.X * settings.ProjectileSpeed,
                VelocityY = direction.Y * settings.ProjectileSpeed,
                Damage = ResolveProjectileDamage(attacker, settings),
                Radius = settings.ProjectileRadius,
                LifetimeSeconds = settings.ProjectileLifetimeSeconds,
                Guided = true,
                Active = true,
                WeaponKind = IsPlayerOwned(attacker) ? "vanguard-bolt" : "raider-bolt"
            });
            zone.Projectiles = projectiles.ToArray();
        }

        private static string CreateProjectileId(
            AetheriaRuntimeZoneSnapshotCommit zone,
            AetheriaRuntimeEntitySnapshotCommit attacker,
            AetheriaRuntimeEntitySnapshotCommit target,
            int ordinal)
        {
            var tick = Math.Max(0, (long)Math.Round(zone.SimulationTimeSeconds * 1000.0));
            return $"projectile:{zone.ZoneIndex}:{tick}:{attacker.EntityIndex}:{target.EntityIndex}:{ordinal}";
        }

        private static double ResolveProjectileDamage(
            AetheriaRuntimeEntitySnapshotCommit attacker,
            AetheriaRuntimeDaemonSimulationSettings settings)
        {
            return IsPlayerOwned(attacker) ? settings.PawnProjectileDamage : settings.RaiderProjectileDamage;
        }

        private static void RefreshContacts(
            IReadOnlyList<AetheriaRuntimeEntitySnapshotCommit> entities,
            AetheriaRuntimeDaemonSimulationSettings settings)
        {
            foreach (var observer in entities)
            {
                var contacts = new List<AetheriaRuntimeEntityContactCommit>();
                foreach (var target in entities)
                {
                    if (target.EntityIndex == observer.EntityIndex)
                        continue;

                    var distance = Math.Sqrt(DistanceSq(observer, target));
                    var visible = distance <= ResolveSensorRange(observer, settings);
                    if (!visible && !Hostile(observer, target))
                        continue;

                    contacts.Add(new AetheriaRuntimeEntityContactCommit
                    {
                        TargetEntityIndex = target.EntityIndex,
                        InfoGathered = visible ? 1.0 : 0.25,
                        Hostile = Hostile(observer, target),
                        Visible = visible
                    });
                }

                observer.Contacts = contacts;
                observer.Visibility = observer.IsActive ? ResolveSensorRange(observer, settings) : 0;
                observer.VisibilitySourceCount = observer.IsActive ? 1 : 0;
            }
        }

        private static void EnsureStats(
            IReadOnlyList<AetheriaRuntimeEntitySnapshotCommit> entities,
            AetheriaRuntimeDaemonSimulationSettings settings)
        {
            foreach (var entity in entities)
            {
                if (entity.StatGrids == null || entity.StatGrids.Count == 0)
                {
                    entity.StatGrids = new[]
                    {
                        Stat(Hull, DefaultHull(entity, settings)),
                        Stat(Shield, DefaultShield(entity, settings)),
                        Stat(Heat, 0)
                    };
                }

                if (!entity.IsActive && GetStat(entity, Hull) > 0)
                    entity.IsActive = true;
            }
        }

        private static void Damage(AetheriaRuntimeEntitySnapshotCommit target, double damage)
        {
            var shield = GetStat(target, Shield);
            var shieldDamage = Math.Min(shield, damage);
            if (shieldDamage > 0)
            {
                SetStat(target, Shield, shield - shieldDamage);
                damage -= shieldDamage;
            }

            if (damage > 0)
                SetStat(target, Hull, Math.Max(0, GetStat(target, Hull) - damage));
        }

        private static bool IsAlive(AetheriaRuntimeEntitySnapshotCommit entity)
        {
            return entity.IsActive && GetStat(entity, Hull) > 0;
        }

        private static bool IsPlayerOwned(AetheriaRuntimeEntitySnapshotCommit entity)
        {
            return string.Equals(entity.FactionKey, "player", StringComparison.OrdinalIgnoreCase);
        }

        private static bool Hostile(
            AetheriaRuntimeEntitySnapshotCommit left,
            AetheriaRuntimeEntitySnapshotCommit right)
        {
            return IsPlayerOwned(left) != IsPlayerOwned(right) &&
                (string.Equals(left.FactionKey, "raider", StringComparison.OrdinalIgnoreCase) ||
                 string.Equals(right.FactionKey, "raider", StringComparison.OrdinalIgnoreCase));
        }

        private static double ResolveSpeed(
            AetheriaRuntimeEntitySnapshotCommit entity,
            AetheriaRuntimeDaemonSimulationSettings settings)
        {
            if (string.Equals(entity.Kind, "station", StringComparison.OrdinalIgnoreCase))
                return 0;

            return string.Equals(entity.FactionKey, "raider", StringComparison.OrdinalIgnoreCase)
                ? settings.RaiderSpeed
                : settings.PawnSpeed;
        }

        private static double ResolveSensorRange(
            AetheriaRuntimeEntitySnapshotCommit entity,
            AetheriaRuntimeDaemonSimulationSettings settings)
        {
            return string.Equals(entity.Kind, "station", StringComparison.OrdinalIgnoreCase)
                ? settings.StationSensorRange
                : settings.EntitySensorRange;
        }

        private static double DefaultHull(
            AetheriaRuntimeEntitySnapshotCommit entity,
            AetheriaRuntimeDaemonSimulationSettings settings)
        {
            return string.Equals(entity.Kind, "station", StringComparison.OrdinalIgnoreCase)
                ? (IsPlayerOwned(entity) ? settings.PlayerStationHull : settings.HostileStationHull)
                : string.Equals(entity.FactionKey, "raider", StringComparison.OrdinalIgnoreCase)
                    ? settings.RaiderEntityHull
                    : settings.PlayerEntityHull;
        }

        private static double DefaultShield(
            AetheriaRuntimeEntitySnapshotCommit entity,
            AetheriaRuntimeDaemonSimulationSettings settings)
        {
            return string.Equals(entity.Kind, "station", StringComparison.OrdinalIgnoreCase)
                ? settings.StationShield
                : settings.EntityShield;
        }

        private static double GetStat(AetheriaRuntimeEntitySnapshotCommit entity, string name)
        {
            var grid = (entity.StatGrids ?? Array.Empty<AetheriaRuntimeEntityStatGridCommit>())
                .FirstOrDefault(candidate => string.Equals(candidate.Name, name, StringComparison.OrdinalIgnoreCase));
            return grid?.Values?.FirstOrDefault() ?? 0;
        }

        private static void SetStat(AetheriaRuntimeEntitySnapshotCommit entity, string name, double value)
        {
            var grids = (entity.StatGrids ?? Array.Empty<AetheriaRuntimeEntityStatGridCommit>()).ToList();
            var index = grids.FindIndex(candidate => string.Equals(candidate.Name, name, StringComparison.OrdinalIgnoreCase));
            var grid = Stat(name, value);
            if (index >= 0)
                grids[index] = grid;
            else
                grids.Add(grid);
            entity.StatGrids = grids;
        }

        private static AetheriaRuntimeEntityStatGridCommit Stat(string name, double value)
        {
            return new AetheriaRuntimeEntityStatGridCommit
            {
                Name = name,
                Width = 1,
                Height = 1,
                Values = new[] { value }
            };
        }

        private static double DistanceSq(
            AetheriaRuntimeEntitySnapshotCommit left,
            AetheriaRuntimeEntitySnapshotCommit right)
        {
            var dx = right.PositionX - left.PositionX;
            var dy = right.PositionZ - left.PositionZ;
            return dx * dx + dy * dy;
        }

        private static (double X, double Y) Normalize(double x, double y)
        {
            var magnitude = Math.Sqrt(x * x + y * y);
            return magnitude <= 0.0001 ? (0, 0) : (x / magnitude, y / magnitude);
        }

        private static void Face(AetheriaRuntimeEntitySnapshotCommit entity, double x, double y)
        {
            var direction = Normalize(x, y);
            if (Math.Abs(direction.X) + Math.Abs(direction.Y) <= 0.0001)
                return;

            entity.DirectionX = direction.X;
            entity.DirectionY = direction.Y;
        }

        private static double Clamp01(double value)
        {
            return value < 0 ? 0 : value > 1 ? 1 : value;
        }

        private static bool TryParseEntityIndex(string? entityKey, out int entityIndex)
        {
            entityIndex = -1;
            if (string.IsNullOrWhiteSpace(entityKey))
                return false;

            var marker = entityKey.LastIndexOf(".entity.", StringComparison.OrdinalIgnoreCase);
            if (marker < 0)
                return false;

            var start = marker + ".entity.".Length;
            var end = start;
            while (end < entityKey.Length && char.IsDigit(entityKey[end]))
                end++;

            return end > start && int.TryParse(entityKey.Substring(start, end - start), out entityIndex);
        }
    }
}