Weapons¶

public abstract class BaseWeapon : GameObject, IHasCollider
{
    public override GameObject? Parent {
        get => base.Parent;
        set {
            if (value is not GameObjectList && value is not BaseEntity && value is not null)
                throw new InvalidOperationException($"Parent ({value.GetType().FullName}) of weapon must either be a world, an entity that can hold weapons or null.");

            base.Parent = value;
        }
    }

    public virtual Texture2D Texture { get; set; }
    public Vector2 Size { get; set; } = new(25f);
    public override Rectangle BoundingBox
        => new((Position - Size/2).ToPoint(), Size.ToPoint());

    public TimeSpan AttackCooldown { get; set; } = TimeSpan.FromSeconds(1);
    public TimeSpan AttackDuration { get; set; } = TimeSpan.FromSeconds(1);
    public int Damage { get; set; } = 10;

    public TimeSpan LastAttackTime { get; set; } = TimeSpan.Zero;
    public TimeSpan AttackProgress
        => App.LastUpdateTime.TotalGameTime - LastAttackTime;
    public virtual bool IsAttacking
        => AttackProgress <= AttackDuration && Parent is BaseEntity;
    public float GroundRotation { get; set; } = 0;
    public Vector2 AttackDirection { get; set; } = Vector2.UnitX;
    public HashSet<IHasCollider> hits = new();


    public BaseWeapon(Vector2 position = default, int layer = 0, string id = "") : base(layer, id)
        => Position = position;

    protected abstract void DrawInHand(GameTime gameTime, SpriteBatch spriteBatch, BaseEntity holder);

    public override void Draw(GameTime gameTime, SpriteBatch spriteBatch)
    {
        if (Parent is BaseEntity)
        {
            DrawInHand(gameTime, spriteBatch, (BaseEntity)Parent);
        }
        else
        {
            spriteBatch.BetterDraw(Texture, GlobalPosition, Size, GroundRotation);
        }
    }

    public override void HandleInput(InputHelper input)
    {
        if (Parent is not BaseEntity holder || IsAttacking)
            return;

        AttackDirection = Vector2.Normalize(input.MousePosition - holder.GlobalPosition);
    }

    public void Equip(BaseEntity equipper)
    {
        if (Parent is GameObjectList list)
            list.RemoveLazy(this);

        Parent = equipper;
    }

    public void Unequip()
    {
        Position = Parent!.GlobalPosition - (Parent.Parent?.GlobalPosition ?? Vector2.Zero);
        GroundRotation = App.Random.NextSingle() * 2 * MathF.PI;

        Parent = Parent.Parent;
        if (Parent is GameObjectList list)
            list.Add(this);
    }

    public virtual bool Attack(GameTime gameTime)
    {
        if (AttackProgress > AttackDuration + AttackCooldown)
        {
            LastAttackTime = gameTime.TotalGameTime;
            hits.Clear();

            App.Systems.GetSystem<EventBus>()
                .Publish(new WeaponsUsedEvent((BaseEntity)Parent!, this));

            return true;
        }

        return false;
    }

    public override void Update(GameTime gameTime)
    {
        if (IsAttacking)
        {
            var state = App.Systems.GetSystem<StateManager>().currentState;
            var holder = (BaseEntity)Parent!;

            foreach (var hit in GetHits(gameTime, holder, state!))
            {
                if (hits.Contains(hit))
                {
                    continue;
                }

                hits.Add(hit);

                ColliderHit(hit, holder);
            }
        }
    }

    protected abstract IEnumerable<IHasCollider> GetHits(GameTime gameTime, BaseEntity holder, GameObjectList world);

    public virtual void ColliderHit(IHasCollider hit, BaseEntity holder)
    {
        if (hit != Parent && hit is BaseEntity entity)
            entity.Damage(Damage * holder.Strength);
    }
}

public class Sword : BaseWeapon, IHasRectCollider
{
    public int armLength = 25;
    public int Range => (int)MathF.Round(Size.Length());
    public float swingAngle = MathF.PI * .65f;

    public Sword(Vector2 position = default, int layer = 0, string id = "")
        : base(position, layer, id)
    {
        Texture = App.AssetManager.GetSprite("Images/Weapons/Sword");
        AttackCooldown = TimeSpan.FromSeconds(.125);
        AttackDuration = TimeSpan.FromSeconds(.4);
        Damage = 3;
        Size = new(50f);
    }

    protected override void DrawInHand(GameTime gameTime, SpriteBatch spriteBatch, BaseEntity holder)
    {
        var angle = MathExtras.CartesianToPolar(AttackDirection.ToNumerics()).X;

        if (IsAttacking)
            angle += MathExtras.LinearConversion(
                (float)AttackProgress.TotalSeconds,
                0, (float)AttackDuration.TotalSeconds,
                -swingAngle/2, swingAngle/2
            );

        var dir = MathExtras.PolarToCartesian(new(angle, armLength + Range/2));

        spriteBatch.BetterDraw(Texture, holder.GlobalPosition + dir, Size, -angle - MathF.PI * .25f);
    }

    protected override IEnumerable<IHasCollider> GetHits(GameTime gameTime, BaseEntity holder, GameObjectList world)
    {
        var attackAngle = MathExtras.CartesianToPolar(AttackDirection.ToNumerics()).X;

        var attackDirection = MathExtras.PolarToCartesian(new(
                attackAngle + MathExtras.LinearConversion(
                    (float)AttackProgress.TotalSeconds,
                    0, (float)AttackDuration.TotalSeconds,
                    -swingAngle/2, swingAngle/2
                ),
                1
            ));

        var attackLine = new Line(
            holder.GlobalPosition + attackDirection * armLength,
            holder.GlobalPosition + attackDirection * (armLength + Range)
        );

        App.Systems.GetSystem<GizmoSystem>()
            .AddLine(attackLine, Color.Red);

        return CollisionHandler.QueryLine(attackLine, world);
    }
}