OldThink/Content.Server/Explosion/EntitySystems/ExplosionSystem.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Content.Server.Administration.Logs;
using Content.Server.Camera;
using Content.Server.Explosion.Components;
using Content.Shared.Acts;
using Content.Shared.Administration.Logs;
using Content.Shared.Database;
using Content.Shared.Interaction.Helpers;
using Content.Shared.Maps;
using Content.Shared.Physics;
using Content.Shared.Sound;
using Content.Shared.Tag;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
using Robust.Shared.Containers;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Map;
using Robust.Shared.Maths;
using Robust.Shared.Player;
using Robust.Shared.Random;
using Robust.Shared.Timing;

namespace Content.Server.Explosion.EntitySystems
{
    public class ExplosionSystem : EntitySystem
    {
        /// <summary>
        /// Distance used for camera shake when distance from explosion is (0.0, 0.0).
        /// Avoids getting NaN values down the line from doing math on (0.0, 0.0).
        /// </summary>
        private static readonly Vector2 EpicenterDistance = (0.1f, 0.1f);

        /// <summary>
        /// Chance of a tile breaking if the severity is Light and Heavy
        /// </summary>
        private const float LightBreakChance = 0.3f;
        private const float HeavyBreakChance = 0.8f;

        // TODO move this to the component
        private static readonly SoundSpecifier ExplosionSound = new SoundCollectionSpecifier("explosion");

        [Dependency] private readonly IEntityLookup _entityLookup = default!;
        [Dependency] private readonly IGameTiming _timing = default!;
        [Dependency] private readonly IMapManager _maps = default!;
        [Dependency] private readonly IRobustRandom _random = default!;
        [Dependency] private readonly ITileDefinitionManager _tiles = default!;

        [Dependency] private readonly ActSystem _acts = default!;
        [Dependency] private readonly EffectSystem _effects = default!;
        [Dependency] private readonly TriggerSystem _triggers = default!;
        [Dependency] private readonly AdminLogSystem _logSystem = default!;

        private bool IgnoreExplosivePassable(IEntity e)
        {
            return e.HasTag("ExplosivePassable");
        }

        private ExplosionSeverity CalculateSeverity(float distance, float devastationRange, float heavyRange)
        {
            if (distance < devastationRange)
            {
                return ExplosionSeverity.Destruction;
            }
            else if (distance < heavyRange)
            {
                return ExplosionSeverity.Heavy;
            }
            else
            {
                return ExplosionSeverity.Light;
            }
        }

        private void CameraShakeInRange(EntityCoordinates epicenter, float maxRange)
        {
            var players = Filter.Empty()
                .AddInRange(epicenter.ToMap(EntityManager), MathF.Ceiling(maxRange))
                .Recipients;

            foreach (var player in players)
            {
                if (player.AttachedEntity == null || !player.AttachedEntity.TryGetComponent(out CameraRecoilComponent? recoil))
                {
                    continue;
                }

                var playerPos = player.AttachedEntity.Transform.WorldPosition;
                var delta = epicenter.ToMapPos(EntityManager) - playerPos;

                //Change if zero. Will result in a NaN later breaking camera shake if not changed
                if (delta.EqualsApprox((0.0f, 0.0f)))
                    delta = EpicenterDistance;

                var distance = delta.LengthSquared;
                var effect = 10 * (1 / (1 + distance));
                if (effect > 0.01f)
                {
                    var kick = -delta.Normalized * effect;
                    recoil.Kick(kick);
                }
            }
        }

        /// <summary>
        /// Damage entities inside the range. The damage depends on a discrete
        /// damage bracket [light, heavy, devastation] and the distance from the epicenter
        /// </summary>
        /// <returns>
        /// A dictionary of coordinates relative to the parents of every grid of entities that survived the explosion,
        /// have an airtight component and are currently blocking air. Like a wall.
        /// </returns>
        private void DamageEntitiesInRange(
            EntityCoordinates epicenter,
            Box2 boundingBox,
            float devastationRange,
            float heavyRange,
            float maxRange,
            MapId mapId)
        {
            var entitiesInRange = _entityLookup.GetEntitiesInRange(mapId, boundingBox, 0).ToList();

            var impassableEntities = new List<(IEntity, float)>();
            var nonImpassableEntities = new List<(IEntity, float)>();
            // TODO: Given this seems to rely on physics it should just query directly like everything else.

            // The entities are paired with their distance to the epicenter
            // and splitted into two lists based on if they are Impassable or not
            foreach (var entity in entitiesInRange)
            {
                if (entity.Deleted || entity.IsInContainer())
                {
                    continue;
                }

                if (!entity.Transform.Coordinates.TryDistance(EntityManager, epicenter, out var distance) ||
                    distance > maxRange)
                {
                    continue;
                }

                if (!entity.TryGetComponent(out PhysicsComponent? body) || body.Fixtures.Count < 1)
                {
                    continue;
                }

                if ((body.CollisionLayer & (int) CollisionGroup.Impassable) != 0)
                {
                    impassableEntities.Add((entity, distance));
                }
                else
                {
                    nonImpassableEntities.Add((entity, distance));
                }
            }

            // The Impassable entities are sorted in descending order
            // Entities closer to the epicenter are first
            impassableEntities.Sort((x, y) => x.Item2.CompareTo(y.Item2));

            // Impassable entities are handled first. If they are damaged enough, they are destroyed and they may
            // be able to spawn a new entity. I.e Wall -> Girder.
            // Girder has a tag ExplosivePassable, and the predicate make it so the entities with this tag are ignored
            var epicenterMapPos = epicenter.ToMap(EntityManager);
            foreach (var (entity, distance) in impassableEntities)
            {
                if (!entity.InRangeUnobstructed(epicenterMapPos, maxRange, ignoreInsideBlocker: true, predicate: IgnoreExplosivePassable))
                {
                    continue;
                }

                _acts.HandleExplosion(epicenter, entity.Uid, CalculateSeverity(distance, devastationRange, heavyRange));
            }

            // Impassable entities were handled first so NonImpassable entities have a bigger chance to get hit. As now
            // there are probably more ExplosivePassable entities around
            foreach (var (entity, distance) in nonImpassableEntities)
            {
                if (!entity.InRangeUnobstructed(epicenterMapPos, maxRange, ignoreInsideBlocker: true, predicate: IgnoreExplosivePassable))
                {
                    continue;
                }

                _acts.HandleExplosion(epicenter, entity.Uid, CalculateSeverity(distance, devastationRange, heavyRange));
            }
        }

        /// <summary>
        /// Damage tiles inside the range. The type of tile can change depending on a discrete
        /// damage bracket [light, heavy, devastation], the distance from the epicenter and
        /// a probability bracket [<see cref="LightBreakChance"/>, <see cref="HeavyBreakChance"/>, 1.0].
        /// </summary>
        ///
        private void DamageTilesInRange(EntityCoordinates epicenter,
                                               GridId gridId,
                                               Box2 boundingBox,
                                               float devastationRange,
                                               float heaveyRange,
                                               float maxRange)
        {
            if (!_maps.TryGetGrid(gridId, out var mapGrid))
            {
                return;
            }

            if (!EntityManager.EntityExists(mapGrid.GridEntityId))
            {
                return;
            }

            var tilesInGridAndCircle = mapGrid.GetTilesIntersecting(boundingBox);
            var epicenterMapPos = epicenter.ToMap(EntityManager);

            foreach (var tile in tilesInGridAndCircle)
            {
                var tileLoc = mapGrid.GridTileToLocal(tile.GridIndices);
                if (!tileLoc.TryDistance(EntityManager, epicenter, out var distance) ||
                    distance > maxRange)
                {
                    continue;
                }

                if (tile.IsBlockedTurf(false))
                {
                    continue;
                }

                if (!tileLoc.ToMap(EntityManager).InRangeUnobstructed(epicenterMapPos, maxRange, ignoreInsideBlocker: false, predicate: IgnoreExplosivePassable))
                {
                    continue;
                }

                var tileDef = (ContentTileDefinition) _tiles[tile.Tile.TypeId];
                var baseTurfs = tileDef.BaseTurfs;
                if (baseTurfs.Count == 0)
                {
                    continue;
                }

                var zeroTile = new Tile(_tiles[baseTurfs[0]].TileId);
                var previousTile = new Tile(_tiles[baseTurfs[^1]].TileId);

                var severity = CalculateSeverity(distance, devastationRange, heaveyRange);

                switch (severity)
                {
                    case ExplosionSeverity.Light:
                        if (!previousTile.IsEmpty && _random.Prob(LightBreakChance))
                        {
                            mapGrid.SetTile(tileLoc, previousTile);
                        }
                        break;
                    case ExplosionSeverity.Heavy:
                        if (!previousTile.IsEmpty && _random.Prob(HeavyBreakChance))
                        {
                            mapGrid.SetTile(tileLoc, previousTile);
                        }
                        break;
                    case ExplosionSeverity.Destruction:
                        mapGrid.SetTile(tileLoc, zeroTile);
                        break;
                }
            }
        }

        private void FlashInRange(EntityCoordinates epicenter, float flashRange)
        {
            if (flashRange > 0)
            {
                var time = _timing.CurTime;
                var message = new EffectSystemMessage
                {
                    EffectSprite = "Effects/explosion.rsi",
                    RsiState = "explosionfast",
                    Born = time,
                    DeathTime = time + TimeSpan.FromSeconds(5),
                    Size = new Vector2(flashRange / 2, flashRange / 2),
                    Coordinates = epicenter,
                    Rotation = 0f,
                    ColorDelta = new Vector4(0, 0, 0, -1500f),
                    Color = Vector4.Multiply(new Vector4(255, 255, 255, 750), 0.5f),
                    Shaded = false
                };

                _effects.CreateParticle(message);
            }
        }

        public void SpawnExplosion(
            EntityUid entity,
            int devastationRange = 0,
            int heavyImpactRange = 0,
            int lightImpactRange = 0,
            int flashRange = 0,
            EntityUid? user = null,
            ExplosiveComponent? explosive = null,
            TransformComponent? transform = null)
        {
            if (!Resolve(entity, ref transform))
            {
                return;
            }

            Resolve(entity, ref explosive, false);

            if (explosive is { Exploding: false })
            {
                _triggers.Explode(entity, explosive, user);
            }
            else
            {
                while (EntityManager.TryGetEntity(entity, out var e) && e.TryGetContainer(out var container))
                {
                    entity = container.Owner.Uid;
                }

                if (!EntityManager.TryGetComponent(entity, out transform))
                {
                    return;
                }

                var epicenter = transform.Coordinates;

                SpawnExplosion(epicenter, devastationRange, heavyImpactRange, lightImpactRange, flashRange, entity, user);
            }
        }

        public void SpawnExplosion(
            EntityCoordinates epicenter,
            int devastationRange = 0,
            int heavyImpactRange = 0,
            int lightImpactRange = 0,
            int flashRange = 0,
            EntityUid? entity = null,
            EntityUid? user = null)
        {
            var mapId = epicenter.GetMapId(EntityManager);
            if (mapId == MapId.Nullspace)
            {
                return;
            }

            // logging
            var text = $"{epicenter} with range {devastationRange}/{heavyImpactRange}/{lightImpactRange}/{flashRange}";
            if (entity == null)
            {
                _logSystem.Add(LogType.Explosion, LogImpact.High, $"Explosion spawned at {text}");
            }
            else if (user == null)
            {
                _logSystem.Add(LogType.Explosion, LogImpact.High,
                    $"{EntityManager.GetEntity(entity.Value)} exploded at {text}");
            }
            else
            {
                _logSystem.Add(LogType.Explosion, LogImpact.High,
                    $"{EntityManager.GetEntity(user.Value)} caused {EntityManager.GetEntity(entity.Value)} to explode at {text}");
            }

            var maxRange = MathHelper.Max(devastationRange, heavyImpactRange, lightImpactRange, 0);
            var epicenterMapPos = epicenter.ToMapPos(EntityManager);
            var boundingBox = new Box2(epicenterMapPos - new Vector2(maxRange, maxRange),
                epicenterMapPos + new Vector2(maxRange, maxRange));

            SoundSystem.Play(Filter.Broadcast(), ExplosionSound.GetSound(), epicenter);
            DamageEntitiesInRange(epicenter, boundingBox, devastationRange, heavyImpactRange, maxRange, mapId);

            var mapGridsNear = _maps.FindGridsIntersecting(mapId, boundingBox);

            foreach (var gridId in mapGridsNear)
            {
                DamageTilesInRange(epicenter, gridId.Index, boundingBox, devastationRange, heavyImpactRange, maxRange);
            }

            CameraShakeInRange(epicenter, maxRange);
            FlashInRange(epicenter, flashRange);
        }
    }
}