Strategy

using UnityEngine;

namespace Patterns.Behavioral.Strategy
{
    /// <summary>
    /// Client: picks strategies at runtime and tells the attacker to
    /// attack. Swapping weapons is just reassigning a reference.
    /// </summary>
    public class StrategyTester : MonoBehaviour
    {
        [SerializeField] private Attacker attacker;
        [SerializeField] private Transform dummy; // must have an IDamageable component
        [SerializeField] private Rigidbody arrowPrefab;

        private IAttackStrategy melee;
        private IAttackStrategy ranged;
        private IAttackStrategy magic;

        private void Awake()
        {
            melee = new MeleeAttack();
            ranged = new RangedAttack(arrowPrefab);
            magic = new MagicAttack();
            attacker.SetStrategy(melee);
        }

        private void Update()
        {
            if (Input.GetKeyDown(KeyCode.Alpha1)) attacker.SetStrategy(melee);
            if (Input.GetKeyDown(KeyCode.Alpha2)) attacker.SetStrategy(ranged);
            if (Input.GetKeyDown(KeyCode.Alpha3)) attacker.SetStrategy(magic);

            if (Input.GetKeyDown(KeyCode.Space) && dummy.TryGetComponent(out IDamageable target))
                attacker.AttackTarget(target);
        }
    }
}

using UnityEngine;

namespace Patterns.Behavioral.Strategy
{
    /// <summary>
    /// The strategy contract. The attacker calls this without knowing
    /// which concrete attack it is holding.
    /// </summary>
    public interface IAttackStrategy
    {
        string Name { get; }
        float Range { get; }

        void Attack(Transform attacker, IDamageable target);
    }

    /// <summary>Anything that can be hit.</summary>
    public interface IDamageable
    {
        Transform Transform { get; }
        void TakeDamage(int amount);
    }
}

using UnityEngine;

namespace Patterns.Behavioral.Strategy
{
    /// <summary>Close-range, high-damage swing.</summary>
    public class MeleeAttack : IAttackStrategy
    {
        public string Name => "Melee";
        public float Range => 1.5f;

        public void Attack(Transform attacker, IDamageable target)
        {
            target.TakeDamage(25);
        }
    }

    /// <summary>Launches an arrow toward the target from a distance.</summary>
    public class RangedAttack : IAttackStrategy
    {
        private readonly Rigidbody arrowPrefab;

        public RangedAttack(Rigidbody arrowPrefab) => this.arrowPrefab = arrowPrefab;

        public string Name => "Ranged";
        public float Range => 15f;

        public void Attack(Transform attacker, IDamageable target)
        {
            Vector3 direction = (target.Transform.position - attacker.position).normalized;
            Rigidbody arrow = Object.Instantiate(arrowPrefab, attacker.position, Quaternion.LookRotation(direction));
            arrow.linearVelocity = direction * 30f;
            Object.Destroy(arrow.gameObject, 2f);

            target.TakeDamage(12); // hitscan damage; the arrow is visual
        }
    }

    /// <summary>Damages the target and everything near it.</summary>
    public class MagicAttack : IAttackStrategy
    {
        private const float BlastRadius = 3f;

        public string Name => "Magic";
        public float Range => 10f;

        public void Attack(Transform attacker, IDamageable target)
        {
            Collider[] hits = Physics.OverlapSphere(target.Transform.position, BlastRadius);
            foreach (Collider hit in hits)
            {
                if (hit.TryGetComponent(out IDamageable victim))
                    victim.TakeDamage(18);
            }
        }
    }
}

using UnityEngine;

namespace Patterns.Behavioral.Strategy
{
    /// <summary>
    /// Context. Holds one attack strategy and delegates to it.
    /// It never checks which kind of attack it is.
    /// </summary>
    public class Attacker : MonoBehaviour
    {
        private IAttackStrategy strategy;

        public IAttackStrategy Strategy => strategy;

        public void SetStrategy(IAttackStrategy next)
        {
            if (next == null || next == strategy) return;

            strategy = next;
            Debug.Log($"{name} switched to {strategy.Name}");
        }

        public void AttackTarget(IDamageable target)
        {
            if (strategy == null) return;

            float distance = Vector3.Distance(transform.position, target.Transform.position);
            if (distance > strategy.Range)
            {
                Debug.Log($"{strategy.Name}: target out of range ({distance:0.0}m)");
                return;
            }

            strategy.Attack(transform, target);
        }
    }
}