cirnogodot/Scripts/AttackPatterns/ShootingPattern3D.cs

using Cirno.Scripts.Actors;
using Cirno.Scripts.Components;
using Cirno.Scripts.Enums;
using Cirno.Scripts.Resources;
using Cirno.Scripts.Utils;
using Godot;
using Godot.Collections;

namespace Cirno.Scripts.AttackPatterns;

[GlobalClass]
[Tool]
public partial class ShootingPattern3D : AttackPattern
{
    [Export] public float Delay { get; set; }
    [Export] public LoopType LoopType { get; set; }
    [Export] public BulletResource BulletResource { get; set; }

    [Export] public Vector3 EmitterOffset { get; set; } = Vector3.Zero;

    [Export] public int bulletCount = 16;
    [Export] public float rotationSpeed = 0f;
    [Export] public float BurstRotationSpeed = 0f;
    [Export] public bool UseParentRotationOffset { get; set; } = false;
    [Export] public float _rotationOffset = 0f;
    [Export] public float duration = -1f;
    [Export] public float spread = 360f;
    [Export] public float burstInterval = 0.5f;

    [ExportCategory("Burst")] [Export] public int ShotsPerBurst { get; private set; } = 100;

    [Export] public float BurstRate { get; private set; } = 0f;

    [ExportCategory("Other")] [Export] public bool _targetPlayer = false;
    [ExportCategory("Other")] [Export] public bool _predictPlayer = false;

    [ExportCategory("Overrides")]
    [ExportGroup("Override Damage")]
    [Export(PropertyHint.GroupEnable)]
    public bool OverrideDamage { get; private set; } = false;

    [Export] public float DamageOverride { get; private set; } = 10f;

    [ExportGroup("Override Speed")]
    [Export(PropertyHint.GroupEnable)]
    public bool OverrideSpeed { get; private set; } = false;

    [Export] public float SpeedOverride { get; private set; } = 10f;

    [ExportGroup("Override Owner")]
    [Export(PropertyHint.GroupEnable)]
    public bool OverrideOwner { get; private set; } = false;

    [Export] public BulletOwner Owner { get; private set; } = BulletOwner.None;

    [ExportGroup("Override Damage Type")]
    [Export(PropertyHint.GroupEnable)]
    public bool OverrideDamageType { get; private set; } = false;

    [Export] public DamageType DamageType { get; private set; } = DamageType.Neutral;

    [ExportGroup("Override Attributes")]
    [Export(PropertyHint.GroupEnable)]
    public bool OverrideAttributes { get; private set; } = false;

    [Export] public BulletFlags AttributesOverride { get; private set; }

    [ExportGroup("Override Controllable (deprecated)")]
    [Export(PropertyHint.GroupEnable)]
    public bool OverrideControllable { get; private set; } = false;

    [Export] public bool Controllable { get; private set; } = false;

    [ExportCategory("Extra Modifiers")]
    [ExportGroup("Override Creation Modifier")]
    [Export(PropertyHint.GroupEnable)]
    public bool OverrideCreationModifier { get; private set; } = false;

    [Export] public BulletCreationModifier Modifier;

    [ExportGroup("Time Modifiers")] [Export]
    public Array<TimeModifier> TimeModifiers = [];

    protected virtual BulletInfo MakeBullet(Vector2 position, int count = 1, float spread = 0f,
        float rotationOffset = 0f)
    {
        var bullet = this.BulletResource.MakeBullet(position, count,
            spread, rotationOffset);

        if (OverrideDamage)
        {
            bullet.Damage = this.DamageOverride;
        }

        if (OverrideSpeed)
        {
            bullet.Speed = this.SpeedOverride;
        }

        if (OverrideOwner)
        {
            bullet.Owner = this.Owner;
        }

        if (OverrideDamageType)
        {
            bullet.DamageType = DamageType;
        }

        if (OverrideAttributes)
        {
            bullet.Attributes = AttributesOverride;
        }

        // if (OverrideControllable)
        // {
        //     bullet.Controllabe = Controllable;
        // }

        if (OverrideCreationModifier)
        {
            bullet.Modifier = this.Modifier;
        }

        if (TimeModifiers.Count != 0)
        {
            bullet.TimeModifiers.AddRange(TimeModifiers);
        }

        return bullet;
    }

    public override IPatternMachine MakeMachine(Node parent)
    {
        return new SpiralPatternMachine(this, parent);
    }

    public class SpiralPatternMachine(ShootingPattern3D pattern, Node parent) : IPatternMachine
    {
        public Node Parent => parent;
        public IScriptHost3D ScriptHost { get; private set; }
        private double timer;

        private double burstTimer;

        //private double _burstRateTimer;
        private BulletSpawner3D spawner;

        private ShootStatus _state = ShootStatus.Idle;

        private int _burstBullets;

        private int _currentBurstOffset = 0;

        public void Start()
        {
            ScriptHost = Parent as IScriptHost3D;

            timer = 0;
            _burstBullets = pattern.ShotsPerBurst;
            burstTimer = pattern.burstInterval; // start immediately

            spawner = parent.GetNode<BulletSpawner3D>("BulletSpawner3D");

            _state = pattern.Delay == 0 ? ShootStatus.Shooting : ShootStatus.Idle;
        }

        private void WaitingBurstUpdate(double delta)
        {
            timer += delta;
            burstTimer += delta;

            if (burstTimer >= pattern.burstInterval)
            {
                _state = ShootStatus.Shooting;
            }
        }

        private void WaitingReloadUpdate(double delta)
        {
            timer += delta;
            burstTimer += delta;

            if (burstTimer >= pattern.BurstRate)
            {
                _burstBullets = pattern.ShotsPerBurst;
                _state = ShootStatus.Shooting;
            }
        }

        private void ShootingUpdate(double delta)
        {
            timer += delta;
            burstTimer = 0;
            Shoot();
            _burstBullets--;

            if (_burstBullets <= 0)
            {
                if (pattern.LoopType is LoopType.PlayOnce)
                {
                    _state = ShootStatus.Done;
                    return;
                }

                _state = ShootStatus.WaitingReload;
                _currentBurstOffset++;
            }
            else
            {
                _state = ShootStatus.WaitingBurst;
            }
        }

        private void IdleUpdate(double delta)
        {
            timer += delta;
            if (timer >= pattern.Delay)
            {
                _state = ShootStatus.Shooting;
            }
        }

        public void UpdatePattern(double delta)
        {
            switch (_state)
            {
                case ShootStatus.Idle:
                    IdleUpdate(delta);
                    break;
                case ShootStatus.Done:
                    return;
                case ShootStatus.Shooting:
                    ShootingUpdate(delta);
                    break;
                case ShootStatus.WaitingBurst:
                    WaitingBurstUpdate(delta);
                    break;
                case ShootStatus.WaitingReload:
                    WaitingReloadUpdate(delta);
                    break;
            }

            if (pattern.duration > -1 && timer >= pattern.duration)
            {
                _state = ShootStatus.Done;
            }
        }

        private void Shoot()
        {
            float angleOffset = pattern._rotationOffset + (float)(pattern.rotationSpeed * timer) +
                                (float)(pattern.BurstRotationSpeed * _currentBurstOffset);

            Vector2 direction = pattern.BulletResource.Direction;

            // Rotate with parent rotation
            if (pattern.UseParentRotationOffset)
            {
                direction = direction.Rotated(-spawner.GlobalRotation.Y + Mathf.DegToRad(90));
            }

            // TODO: Fix player aiming for 3D
            if (pattern._targetPlayer && GameController.Instance.PlayerPosition.HasValue)
            {
                if (pattern._predictPlayer && GameController.Instance.PlayerVelocity.HasValue)
                {
                    var predictedDirection = MathFunctions.PredictInterceptPosition(spawner.GlobalPosition.ToVector2(),
                        GameController.Instance.PlayerPosition.Value.ToVector2(),
                        GameController.Instance.PlayerVelocity.Value.ToVector2(),
                        pattern.BulletResource.BulletSpeed);
                    if (predictedDirection.HasValue)
                    {
                        direction = (predictedDirection.Value - spawner.GlobalPosition.ToVector2()).Normalized();
                    }
                }
                else
                {
                    direction = (GameController.Instance.PlayerPosition.Value.ToVector2() -
                                 spawner.GlobalPosition.ToVector2()).Normalized();
                }
            }

            var spawnPosition = spawner.GlobalPosition + pattern.EmitterOffset;

            var bullet = pattern.MakeBullet(spawnPosition.ToVector2(), pattern.bulletCount,
                pattern.spread, angleOffset);

            bullet.Direction = direction;

            //spawner.SpawnBullet(MakeBullet(Boss.GlobalPosition, direction, angleOffset));
            spawner.SpawnBullet(bullet, spawnPosition);
        }


        public bool IsComplete()
        {
            if (!pattern.WaitForCompletion) return _state is ShootStatus.Done;
            if (_state is not ShootStatus.Done) return false;
            // From now on the status is done
            if (pattern.duration > -1)
            {
                // Wait for timer
                return (timer >= pattern.duration);
            }

            // No timer, if it's done it's done
            return true;
        }

        private enum ShootStatus
        {
            Idle,
            Shooting,
            WaitingBurst,
            WaitingReload,
            Done
        }
    }
}