Unity 之 Redux 模式 (Flux)

using UnityEngine;
using System.Collections;

public class PlayerMovement : MonoBehaviour
{
    [SerializeField]
    float speed = 3f;

    Rigidbody2D rigid;

    float ax, ay;

    void Start ()
    {
        rigid = GetComponent<Rigidbody2D> ();
    }

    void FixedUpdate ()
    {
        getInput ();
        rotate ();
        move ();
    }

    // 获取摇杆输入
    void getInput ()
    {
        ax = Input.GetAxis ("Horizontal");
        ay = Input.GetAxis ("Vertical");
    }

    // 处理旋转
    void rotate ()
    {
        if (ax == 0 && ay == 0)
            return;

        float r = Mathf.Atan2 (ay, ax) * Mathf.Rad2Deg;

        rigid.MoveRotation (r);
    }

    // 处理移动
    void move ()
    {
        Vector2 m = new Vector2 (ax, ay);
        m = Vector2.ClampMagnitude (m, 1);

        Vector2 dest = (Vector2)transform.position + m;
        Vector2 p = Vector2.MoveTowards (transform.position, dest, speed * Time.fixedDeltaTime);

        rigid.MovePosition (p);
    }

}

public interface IAction
{

}

public interface IReducer
{
    State Reduce (State state, IAction action);
}

using UnityEngine;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

public class Store
{
    // 保存 State 数据
    public static State State { get; private set; }

    // Reducer 列表
    static List<IReducer> reducerList;

    // 静态构造函数
    static Store ()
    {
        State = new State ();

        // 反射获取项目中所有继承 IReducer 的类，生成实例，并加入 reducerList 列表
        reducerList = AppDomain.CurrentDomain.GetAssemblies ()
            .SelectMany (a => a.GetTypes ().Where (t => t.GetInterfaces ().Contains (typeof(IReducer))))
            .Select (t => Activator.CreateInstance (t) as IReducer)
            .ToList ();
    }

    // ViewProvider 调用 Dispatch 方法，传入 Action
    // 循环调用所有的 Reducer，传入当前的 State 与 Action
    // 将 Reducer 返回的 State 保存
    public static void Dispatch (IAction action)
    {
        foreach (IReducer reducer in reducerList) {
            State = reducer.Reduce (State, action);
        }
    }

}

// State 根。用于存放其他模块定义的 State。
public class State
{
    // 变更标记。Reducer 如果更改了 State 中的数据，需要将此值设置为 True。
    public bool IsChanged { get; set; }

    // Player 模块定义的 State
    public Player.PlayerState Player { get; private set; }

    public State ()
    {
        Player = new Player.PlayerState ();
    }
}

using UnityEngine;

// 继承了 MonoBehaviour，可用于附加到 GameObject 上
public class ViewProvider : MonoBehaviour
{
    // 定义一个 LateUpdate 虚方法，它会在 LateUpdate 时被调用
    protected virtual void LateUpdate ()
    {
        // 判断 State 是否被改变，如果被改变，则调用 OnStateChanged
        if (Store.State.IsChanged) {
            Store.State.IsChanged = false;
            OnStateChanged (Store.State);
        }
    }

    // 虚方法，需要在子类中实现 GameObject 的数据更新
    protected virtual void OnStateChanged (State state)
    {
        
    }

}

using UnityEngine;

namespace Player
{
    // Player 初始化，设置坐标、旋转角度与移动速度
    public class InitAction : IAction
    {
        public Vector2 position { get; set; }

        public float rotation { get; set; }

        public float speed { get; set; }
    }

    // 移动轴
    public class AxisAction : IAction
    {
        public float x { get; set; }

        public float y { get; set; }
    }
}

using UnityEngine;

namespace Player
{
    // 处理初始化过程
    public class InitReducer : IReducer
    {
        public State Reduce (State state, IAction action)
        {
            // 检测 action 类型是不是自己想要的，如果不是，则说明自己不需要做什么，直接返回 state 即可。
            if (!(action is InitAction))
                return state;

            InitAction a = action as InitAction;

            // 初始化 PlayerState
            state.Player.Position = a.position;
            state.Player.Rotation = a.rotation;
            state.Player.Speed = a.speed;

            return state;
        }
    }

    // 处理摇杆数据
    public class AxisReducer : IReducer
    {
        public State Reduce (State state, IAction action)
        {
            // 检测 action 类型是不是自己想要的，如果不是，则说明自己不需要做什么，直接返回 state 即可。
            if (!(action is AxisAction))
                return state;
            
            AxisAction a = action as AxisAction;

            // 如果摇杆在 0 点，则不需要处理数据，直接返回 state。
            if (a.x == 0 && a.y == 0)
                return state;

            // 根据 action 传入的摇杆数据修改 state
            float speed = state.Player.Speed;
            Vector2 position = state.Player.Position;

            // 旋转
            state.Player.Rotation = Mathf.Atan2 (a.y, a.x) * Mathf.Rad2Deg;

            // 位移
            Vector2 m = new Vector2 (a.x, a.y);
            m = Vector2.ClampMagnitude (m, 1);

            Vector2 dest = position + m;
            state.Player.Position = Vector2.MoveTowards (position, dest, speed * Time.fixedDeltaTime);

            // 每次修改 state 之后，需要告诉 state 已经被修改过了
            state.IsChanged = true;

            return state;
        }
    }

}

using UnityEngine;

namespace Player
{
    public class PlayerState
    {
        // 玩家坐标
        public Vector2 Position { get; set; }

        // 玩家面向的方向
        public float Rotation { get; set; }

        // 移动速度
        public float Speed { get; set; }
    }
}

using UnityEngine;

namespace Player
{
    public class PlayerViewProvider: ViewProvider
    {
        [SerializeField]
        float speed = 3f;

        Rigidbody2D rigid = null;

        void Start ()
        {
            rigid = GetComponent<Rigidbody2D> ();

            // 执行初始化
            Store.Dispatch (new InitAction () {
                position = transform.position,
                rotation = transform.rotation.eulerAngles.z,
                speed = this.speed,
            });
        }

        void FixedUpdate ()
        {
            // 获取轴数据，并传递 Action
            float ax = Input.GetAxis ("Horizontal");
            float ay = Input.GetAxis ("Vertical");

            if (ax != 0 || ay != 0) {
                Store.Dispatch (new AxisAction () { x = ax, y = ay });
            }
        }
            
        protected override void OnStateChanged (State state)
        {
            if (rigid != null) {
                // 刚体旋转和移动
                rigid.MoveRotation (state.Player.Rotation);
                rigid.MovePosition (state.Player.Position);
            }
        }

    }
}