Unity游戏开发中，掌握这些编程模式让你代码更高效

在Unity游戏开发中，掌握一定的编程模式对于提升代码质量、降低维护成本和提高开发效率至关重要。以下是一些在Unity开发中常见的编程模式，掌握它们能让你的代码更加高效。

单例模式（Singleton）

单例模式确保一个类只有一个实例，并提供一个全局访问点。在Unity中，单例模式常用于管理游戏的全局状态，如游戏管理器（GameManager）或配置管理器（ConfigManager）。

public class GameManager : MonoBehaviour
{
    private static GameManager _instance;

    public static GameManager Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = FindObjectOfType<GameManager>();
                if (_instance == null)
                {
                    GameObject go = new GameObject("GameManager");
                    _instance = go.AddComponent<GameManager>();
                }
            }
            return _instance;
        }
    }

    void Awake()
    {
        if (_instance != null && _instance != this)
        {
            Destroy(this.gameObject);
        }
        else
        {
            _instance = this;
        }
    }
}

观察者模式（Observer）

观察者模式允许对象在状态变化时通知其他对象。在Unity中，观察者模式常用于处理事件监听和广播，如用户输入、游戏事件等。

public class EventManager
{
    private static EventManager _instance;
    private Dictionary<string, List<Action>> _eventTable = new Dictionary<string, List<Action>>();

    public static EventManager Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = new EventManager();
            }
            return _instance;
        }
    }

    public void AddListener(string eventName, Action listener)
    {
        if (!_eventTable.ContainsKey(eventName))
        {
            _eventTable[eventName] = new List<Action>();
        }
        _eventTable[eventName].Add(listener);
    }

    public void RemoveListener(string eventName, Action listener)
    {
        if (_eventTable.ContainsKey(eventName))
        {
            _eventTable[eventName].Remove(listener);
        }
    }

    public void Broadcast(string eventName)
    {
        if (_eventTable.ContainsKey(eventName))
        {
            foreach (Action action in _eventTable[eventName])
            {
                action.Invoke();
            }
        }
    }
}

装饰者模式（Decorator）

装饰者模式动态地给一个对象添加一些额外的职责，而不改变其接口。在Unity中，装饰者模式常用于处理资源加载、脚本扩展等。

public abstract class ComponentDecorator : MonoBehaviour
{
    protected Component decoratedComponent;

    public ComponentDecorator(Component component)
    {
        decoratedComponent = component;
    }

    public virtual void Update()
    {
        decoratedComponent.Update();
    }
}

public class HealthComponent : ComponentDecorator
{
    public int MaxHealth;

    public HealthComponent(Component component) : base(component)
    {
        MaxHealth = 100;
    }

    public void TakeDamage(int damage)
    {
        MaxHealth -= damage;
        if (MaxHealth <= 0)
        {
            Destroy(gameObject);
        }
    }
}

命令模式（Command）

命令模式将请求封装为一个对象，从而允许用户使用不同的请求、队列或日志请求，以及支持可撤销的操作。在Unity中，命令模式常用于处理用户输入和游戏控制。

public class MoveCommand : ICommand
{
    private readonly Transform _transform;
    private readonly float _distance;

    public MoveCommand(Transform transform, float distance)
    {
        _transform = transform;
        _distance = distance;
    }

    public void Execute()
    {
        _transform.position += _transform.forward * _distance;
    }
}

public class InputHandler : MonoBehaviour
{
    private ICommand _moveCommand;

    void Update()
    {
        if (Input.GetKey(KeyCode.W))
        {
            _moveCommand = new MoveCommand(transform, 1f);
            _moveCommand.Execute();
        }
    }
}

工厂模式（Factory）

工厂模式用于创建对象，而不暴露对象的创建逻辑。在Unity中，工厂模式常用于资源管理、对象池等。

public class ObjectPool<T> where T : MonoBehaviour
{
    private Stack<T> _pool = new Stack<T>();

    public T GetObject()
    {
        if (_pool.Count > 0)
        {
            return _pool.Pop();
        }
        else
        {
            return Instantiate<T>();
        }
    }

    public void ReleaseObject(T obj)
    {
        _pool.Push(obj);
    }
}

掌握这些编程模式，将有助于你在Unity游戏开发中写出更加高效、可维护的代码。当然，不同的模式和场景需要根据实际情况灵活运用。