Composite

using UnityEngine;

namespace Patterns.Structural.Composite
{
    /// <summary>
    /// Builds a small army tree and calls the same methods on the root,
    /// a squad and a single soldier.
    /// </summary>
    public class ArmyTester : MonoBehaviour
    {
        private Squad army;

        private void Start()
        {
            var alpha = new Squad("Alpha");
            alpha.Add(new Soldier("Knight", 12));
            alpha.Add(new Soldier("Archer", 8));

            var bravo = new Squad("Bravo");
            bravo.Add(new Soldier("Pikeman", 10));

            army = new Squad("Army");
            army.Add(alpha);
            army.Add(bravo);

            Debug.Log($"Army power: {army.GetPower()}");   // 30
            Debug.Log($"Alpha power: {alpha.GetPower()}"); // 20
        }

        private void Update()
        {
            if (Input.GetKeyDown(KeyCode.Space))
                army.Attack(); // one call, every soldier swings
        }
    }
}

namespace Patterns.Structural.Composite
{
    /// <summary>
    /// Component interface shared by leaves (Soldier) and
    /// composites (Squad). Callers never need to know which they hold.
    /// </summary>
    public interface IUnit
    {
        string Name { get; }

        /// <summary>Total attack power of this unit and everything under it.</summary>
        int GetPower();

        /// <summary>Order this unit (and any children) to attack.</summary>
        void Attack();
    }
}

using UnityEngine;

namespace Patterns.Structural.Composite
{
    /// <summary>Leaf: a single fighter that does the actual work.</summary>
    public class Soldier : IUnit
    {
        private readonly int power;

        public Soldier(string name, int power)
        {
            Name = name;
            this.power = Mathf.Max(0, power);
        }

        public string Name { get; }

        public int GetPower() => power;

        public void Attack()
        {
            Debug.Log($"{Name} attacks for {power}!");
        }
    }
}

using System.Collections.Generic;
using UnityEngine;

namespace Patterns.Structural.Composite
{
    /// <summary>
    /// Composite: holds child units (soldiers or other squads) and
    /// forwards every call to them, aggregating results on the way up.
    /// </summary>
    public class Squad : IUnit
    {
        private readonly List<IUnit> children = new();

        public Squad(string name) => Name = name;

        public string Name { get; }
        public IReadOnlyList<IUnit> Children => children;

        public void Add(IUnit unit)
        {
            if (unit == this || children.Contains(unit)) return;
            children.Add(unit);
        }

        public bool Remove(IUnit unit) => children.Remove(unit);

        public int GetPower()
        {
            int total = 0;
            foreach (IUnit child in children)
                total += child.GetPower(); // recursion happens here
            return total;
        }

        public void Attack()
        {
            Debug.Log($"{Name}: charge! ({children.Count} units)");
            foreach (IUnit child in children)
                child.Attack();
        }
    }
}