CatStation/Content.Server/Physics/Controllers/ChasingWalkSystem.cs

using System.Linq;
using System.Numerics;
using Content.Server.Physics.Components;
using Robust.Shared.Random;
using Robust.Shared.Timing;
using Robust.Shared.Physics.Systems;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Controllers;

namespace Content.Server.Physics.Controllers;

/// <summary>
/// A system which makes its entity chasing another entity with selected component.
/// </summary>
public sealed partial class ChasingWalkSystem : VirtualController
{
    [Dependency] private IGameTiming _gameTiming = default!;
    [Dependency] private IRobustRandom _random = default!;
    [Dependency] private SharedTransformSystem _transform = default!;
    [Dependency] private EntityLookupSystem _lookup = default!;
    [Dependency] private SharedPhysicsSystem _physics = default!;

    private readonly HashSet<Entity<IComponent>> _potentialChaseTargets = new();

    public override void Initialize()
    {
        base.Initialize();

        SubscribeLocalEvent<ChasingWalkComponent, MapInitEvent>(OnChasingMapInit);
    }

    private void OnChasingMapInit(EntityUid uid, ChasingWalkComponent component, MapInitEvent args)
    {
        component.NextImpulseTime = _gameTiming.CurTime;
        component.NextChangeVectorTime = _gameTiming.CurTime;
    }

    public override void UpdateBeforeSolve(bool prediction, float frameTime)
    {
        base.UpdateBeforeSolve(prediction, frameTime);

        var query = EntityQueryEnumerator<ChasingWalkComponent>();
        while (query.MoveNext(out var uid, out var chasing))
        {
            //Set Velocity to Target
            if (chasing.NextImpulseTime <= _gameTiming.CurTime)
            {
                ForceImpulse(uid, chasing);
                chasing.NextImpulseTime += TimeSpan.FromSeconds(chasing.ImpulseInterval);
            }
            //Change Target
            if (chasing.NextChangeVectorTime <= _gameTiming.CurTime)
            {
                ChangeTarget(uid, chasing);

                var delay = TimeSpan.FromSeconds(_random.NextFloat(chasing.ChangeVectorMinInterval, chasing.ChangeVectorMaxInterval));
                chasing.NextChangeVectorTime += delay;
            }
        }
    }

    private void ChangeTarget(EntityUid uid, ChasingWalkComponent component)
    {
        if (component.ChasingComponent.Count <= 0)
            return;

        //We find our coordinates and calculate the radius of the target search.
        var xform = Transform(uid);
        var range = component.MaxChaseRadius;
        var compType = _random.Pick(component.ChasingComponent.Values).Component.GetType();
        _potentialChaseTargets.Clear();
        _lookup.GetEntitiesInRange(compType, _transform.GetMapCoordinates(xform), range, _potentialChaseTargets, LookupFlags.Uncontained);

        //If there are no required components in the radius, don't moving.
        if (_potentialChaseTargets.Count <= 0)
            return;

        //In the case of finding required components, we choose a random one of them and remember its uid.
        component.ChasingEntity = _random.Pick(_potentialChaseTargets).Owner;
        component.Speed = _random.NextFloat(component.MinSpeed, component.MaxSpeed);
    }

    //pushing the entity toward its target
    private void ForceImpulse(EntityUid uid, ChasingWalkComponent component)
    {
        if (Deleted(component.ChasingEntity) || component.ChasingEntity == null)
        {
            ChangeTarget(uid, component);
            return;
        }

        if (!TryComp<PhysicsComponent>(uid, out var physics))
            return;

        //Calculating direction to the target.
        var pos1 = _transform.GetWorldPosition(uid);
        var pos2 = _transform.GetWorldPosition(component.ChasingEntity.Value);

        var currentDirection = _physics.GetLinearVelocity(uid, Vector2.Zero);

        var targetVector = pos2 - pos1;

        var angleToChange = targetVector.ToAngle() - currentDirection.ToAngle();

        // Make sure we rotate to the smallest direction
        if (angleToChange > Angle.FromDegrees(180))
            angleToChange -= Angle.FromDegrees(360);
        else if (angleToChange < Angle.FromDegrees(-180))
            angleToChange += Angle.FromDegrees(360);

        angleToChange = Math.Clamp(angleToChange,
            -component.MaxAngleVectorChangePerImpulse,
            component.MaxAngleVectorChangePerImpulse);

        var newDirection = currentDirection.ToAngle() + angleToChange;

        var speed = !component.StopAtTarget || targetVector.Length() > 0
            ? newDirection.ToVec() * component.Speed
            : Vector2.Zero;

        _physics.SetLinearVelocity(uid, speed);
        _physics.SetBodyStatus(uid, physics, BodyStatus.InAir); //If this is not done, from the explosion up close, the tesla will "Fall" to the ground, and almost stop moving.

        if (component.RotateWithImpulse)
        {
            var ang = speed.ToAngle() + Angle.FromDegrees(90); // we want "Up" to be forward, bullet convention.
            _transform.SetWorldRotation(uid, ang + component.RotationAngleOffset);
        }
    }
}