一般来说Bundle之间共同使用的资源会提取出来为一个公用Bundle，但是可能不注意的情况下会导致Bundle下的Prefab引用到了其他Bundle的资源，若这种情况一直积累，就有可能发生启动加载Bundle的时候连带引用加载了一堆Bundle，启动卡顿及占用内存。所以需要根据个项目不同的Bundle打包策略定制一个检测Bundle的错误引用关系，及时纠正。

一般来说都是按目录就区分Bundle的，大概的思路就是这样：

public void Start()
{
    //获取所有的Prefab和材质
    string[] listString = AssetDatabase.FindAssets("t:Prefab t:Material", new string[] { "Assets/AssetsPackage" });

    for (int i = 0; i < listString.Length; i++)
    {
        string cur = listString[i];

        List<string> refs = new List<string>();
        string assetPath = AssetDatabase.GUIDToAssetPath(cur);
        string headPath = GetHeadPath(assetPath);//获取当前资源应该在的Bundle

        string[] names = AssetDatabase.GetDependencies(new string[] { assetPath });  //依赖的东东
        foreach (var name in names)
        {
            bool is_common = false;
            //排除引用的是公用资源 commonRef需要定制（值为目录数组），有的第三方库，有的公用资源Bundle等，项目不同这个也不同
            foreach (var cc in commonRef)
            {
                if (name.Contains(cc))
                {
                    is_common = true;
                    break;
                }
            }

            if (!is_common)
            {
                if (name.Contains(headPath)) //不是用公用，看看引用的是不是自己所属的bundle
                {
                    is_common = true;
                }
            }

            //上面情况都不是的话应该是有问题的
            if (!is_common)
            {
                if (name == assetPath)
                {
                    is_common = true;
                }
            }

            if (!is_common)
                AddProblem(assetPath, name);
        }

        EditorUtility.DisplayProgressBar("Progress", (i + 1) + "/" + listString.Length, (i + 1) / listString.Length);

    }

    EditorUtility.ClearProgressBar();
    isDone = true;
    this.ShowNotification(new GUIContent("Done！"));
}

客户端的事件id可以用一个单例递增来，GetEventID每次都返回一个+1的id,区别对待就好了，这样可以有限防止内部通讯的id重复或者定义麻烦

Event.ON_WINDOW_CREATE = Messenger:GetEventId()
Event.ON_WINDOW_OPEN = Messenger:GetEventId()
Event.ON_WINDOW_CLOSE = Messenger:GetEventId()

在说UI系统的时候，先说一下有点关联的配置管理器，因为有着那么一个配置是ui配置，它记录了ui面板的名称对应的prefab和使用的lua文件，还有一些与其他面板的互斥信息，还有其他情况该不该显示的信息等。

public class GameTableMagr 
    : Singleton<GameTableMagr>
{

    // 加载表格
    public void LoadTable()
    {
        LoadTable("ui", typeof(TableUI));//TableUI
    }
}

在GameTableMagr加载了ui的配置文件后，在GameUIManager单例管理器中去把配置的ui解析为一个一个的UIAsset信息，它保存了配置信息和面板的GameObject和面板的Behaviour等。

public class UIAsset
{
    public TableUI.UI     ui             = null;
    public GameObject     oUIObject    = null;
    public PanelBase    panel         = null;
    public float        timer        = 0;
    public AssetBundle bundle = null;
    public UILuaBehaviour luaBehaviour = null;
}

public class GameUIManager
    : Singleton<GameUIManager>
{

    Dictionary<string, UIAsset>         uiMap         = new Dictionary<string, UIAsset>();
    List<UIAsset>                        uiAllList   = new List<UIAsset>();

    
    public void InitAfterLoadData()
    {
        TableUI table = GameTableMagr.Get().GetTable("ui") as TableUI;
        
        for(int i=0; i<table.uiList.Count; i++)
        {
            if ( i == 1 )
                continue;
            
            UIAsset asset = new UIAsset();
            
            asset.ui = table.uiList[i];
            
            uiMap.Add(asset.ui.name, asset);
            
            uiAllList.Add( asset );
        }

        Resources.UnloadUnusedAssets();
        GC.Collect();
    }
}

UI系统围绕这一个叫做UICmdSystem的单例管理器进行，首先是很多的命令数组，每个命令都是一个字符串，代表的是一个事件。而每一个命令都对应一个UI面板的名称，在所有资源都加载完成和配置加载完成的时候就会初始化命令信息，通过命令的事件为key，对应的面板名字对应的UIAsset为值，放置到一个列表中，多对多的关系。

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class UICmd
{
    public string         key = string.Empty;
    public string        values = string.Empty;
}

public class UICmdSystem 
    : Singleton<UICmdSystem>
{
    Hashtable        cmdList = null;
    Queue<UICmd>    cmdQueue = null;
    
    string []    regCmd =
    {
        "update_gold",
    };
    
    string[,]    regUI =
    {
        {"update_gold",                 "Main"},
    };
    
    public void Initial()
    {
        cmdList = new Hashtable();
        cmdQueue= new Queue<UICmd>();
        
        for(int i=0; i<regCmd.Length; i++)
            RegCmd(regCmd[i]);
    }
    
    public void InitAfterLoadData()
    {
        for(int i=0; i<regUI.GetLength(0); i++)
            RegUICmd(regUI[i,0], regUI[i,1]);
    }
    
    void RegCmd(string key)
    {
        if(cmdList.ContainsKey(key))
            return;
        cmdList.Add(key, new List<UIAsset>());
    }
    
    void RegUICmd(string key, string panel)
    {
        if(cmdList.ContainsKey(key) == false)
        {
            Debug.LogError("[UICmdSystem] UICmd:" + key + ",not register!" );
            return;
        }

        UIAsset asset = GameUIManager.Get().GetUIAsset(panel);
        if(asset == null)
        {
            Debug.LogError("[UICmdSystem] UICmd:" + key + ",Panel:" + panel + ",not ui" );
            return;
        }
        
        List<UIAsset> list = cmdList[key] as List<UIAsset>;
        if(list.Contains(asset))
        {
            Debug.LogError("[UICmdSystem] UICmd:" + key + ",Panel:" + panel + ",has register" );
            return;
        }
        
        list.Add(asset);
    }
    
    public void AddCommand(UICmd cmd)
    {
        if(cmd == null)
            return;
        if(cmdList.ContainsKey(cmd.key) == false)
            return;
        cmdQueue.Enqueue(cmd);
    }
    
    public void Tick()//Tick方法会在Main里面的Update方法调用
    {        
        while(cmdQueue.Count != 0)
        {
            UICmd cmd = cmdQueue.Dequeue();
            //Debug.LogError(cmd.key + " | " + cmd.values);
            if(cmd == null)
                continue;
            
            List<UIAsset> uiAsset = cmdList[cmd.key] as List<UIAsset>;

            for(int i=0; i<uiAsset.Count; i++)
            {
                UIAsset asset = uiAsset[i];
                if(asset == null)
                    continue;
                if ((asset.panel == null && asset.luaBehaviour == null) || asset.oUIObject == null)
                    continue;
                if (asset.luaBehaviour != null) {
                    asset.luaBehaviour.HandleCommand(cmd);
                }
                if (asset.panel != null) {
                    asset.panel.HandleCommand(cmd);
                }
            }
        }
        cmdQueue.Clear();
    }
    
    public bool HaveCommand(UICmd cmd)
    {
        if(cmd == null)
            return false;
        if(cmdList.ContainsKey(cmd.key) == false)
            return false;
        
        UICmd[] cmds = cmdQueue.ToArray();
        for(int i = 0; i < cmds.Length; i ++)
        {
            if(cmd.key == cmds[i].key)
                return true;
        }
        return false;
    }
}

看上面的UICmdSystem就知道了，它当前已经知道哪些命令归哪些UI去处理了，当我们需要通知一个事件的时候，通过单例的UICmdSystem的AddCommand方法添加到列表里面，在Update里面就会取出来，找到命令key对应的UIAsset，再在里面找到脚本（UI面板），调用其的HandleCommand方法处理事件，并将UICmd传递进去，通过UICmd.values区分命令处理。

public override void ValueChange(UICmd cmd)//HandleCommand方法调用了ValueChange虚方法，用来给具体的Panel重写的
{
    if (!m_isInit)
        initUI();
    if (cmd.key.Equals("loginselect_ver"))
    {
        if (cmd.values.Equals("loadLocVer"))
        {
            curVersion.gameObject.SetActive(true);
            curVersion.text = CorResMgr.Get().locVer;
        }
        else if (cmd.values.Equals("update"))
        {
            curProgTxt.gameObject.SetActive(true);
            curProgTxt.text = CorResMgr.Get().infoTxt;
            progBar.gameObject.SetActive(true);
            progBar.value = 0.0f;
            
            updateProgCheck = StartCoroutine(updateProg());
        }
    }
}

首先是资源（我这里是UI，一个Panel为一个资源），对应着一个MonoBehaviour的脚本和一个功能一致的Lua脚本，将资源打包成AssetBundle，lua脚本不需要打包(加密应该是必须的)，都放到远程服务器上。通过配置表Table(也是远程加载的)决定是使用MonoBehavoiur还是Lua脚本，使用一个UILuaBehaviour来承载保存lua的模块名，UILuaBehaviour是一些UI常用到的方法，从而在Lua脚本中可以获取这个脚本调用这些功能。

启动的时候，在GameLuaManager中初始化时实例化LuaState或LuaScriptMgr，调用Start方法开始，调用一个Lua脚本的管理器加载一些公用的依赖，以便后面lua脚本使用这些公用方法。

using UnityEngine;
using System.Collections;
using System.IO;
using System;

public class GameLuaManager : Singleton<GameLuaManager> {

	LuaScriptMgr luaScript = null;
	public void Initialize()
	{
        if (luaScript == null)
        {
            luaScript = new LuaScriptMgr();
            luaScript.Start();
            luaScript.DoFile("Logic/GameManager");
            Util.CallMethod("GameManager", "Main");
        }
	}

	public LuaScriptMgr LuaManager
	{
		get{return luaScript;}
	}
}

--Lua GameManager.lua
require "Common/define" --在这里就引入全局了，一些全局定义
require "Net/Network" --网络通信
require "Common/functions" --一些工具的方法
--管理器--
GameManager = {};
local this = GameManager;

function GameManager.Main()
	require("Net/Network").new()
end

--例如functions定义了一些打印日志的方法，Util是c#脚本warp映射到lua中的
--输出日志--
function log(str)
    Util.Log(str);
end

--错误日志--
function error(str) 
	Util.LogError(str);
end

--警告日志--
function warn(str) 
	Util.LogWarning(str);
end

然后各个管理器初始化完成，检查资源更新，会把需要的UI面板和对应的Lua脚本下载到本地上，GameUIManager会根据需求加载UI面板并通过配置查看是否使用lua从而添加UILuaBehaviour，UILuaBehaviour会根据面板的名字找到Lua模块，然后Awake,Start等方法触发是直接Call的Lua中的方法。

//GameUIManager
public PanelBase Show(string strName, bool useCoroutine = true, bool fromPakLoad = false, bool bNeedDarkFollow = false)
{
    UIAsset asset = GetUIAsset(strName);
    if (asset == null)
        return null;
    //控制主界面隐藏
    if (asset.ui.IsCloseMain)
    {
        GetUIAsset("Main").panel.gameObject.SetActive(false);
    }
    if (asset.ui.IsHideChar)
    {
        CharMagr.Get().GetLoader().IsVisible = false;
    }
    if (Main.gameState == Game_State_Type.GST_Fight)
    {
        if (asset.ui.fightShow == 0)
            return null;
    }

    HideAll(asset);

    if (asset.ui.enableDark)
        ShowDark(true , false ,asset);

    uiTimeList.Remove(asset);
    Main.Game.IsHoverUI = false;
    if (asset.oUIObject != null)
    {
        asset.oUIObject.SetActive(true);

        if (asset.panel != null)
        {
            asset.panel.OnShow();
        }
        else if (asset.luaBehaviour != null)
        {
            asset.luaBehaviour.OnShow();
        }

        uiActive.Add(asset);
        return asset.panel;
    }

    //主要在这里，首次加载的
    UnityEngine.Object obj = null;
    if (asset.ui.lua == "")
    {	// cs的界面
        obj = CorResMgr.Get().LoadResource(CONST_VALUE.UI_ROOT_PATH + asset.ui.prefab);
        if (obj == null)
            return null;

        asset.oUIObject = (GameObject)GameObject.Instantiate(obj);
        asset.oUIObject.transform.parent = root.transform;
        asset.oUIObject.transform.localScale = Vector3.one * CalcScale(asset);
        asset.oUIObject.transform.localPosition = Vector3.zero;
        asset.panel = asset.oUIObject.GetComponent<PanelBase>();
    }
    else
    {	// lua的界面
        obj = CorResMgr.Get().LoadResource(CONST_VALUE.UI_ROOT_PATH + asset.ui.prefab);
        if (obj == null)
            return null;

        asset.oUIObject = (GameObject)GameObject.Instantiate(obj);
        asset.oUIObject.transform.parent = root.transform;
        asset.oUIObject.transform.localScale = Vector3.one * CalcScale(asset);
        asset.oUIObject.transform.localPosition = Vector3.zero;

        GameLuaManager.Get().LuaManager.DoFile("UI/" + asset.ui.lua);//编译配置表指定Lua脚本
        //添加UILuaBehaviour脚本来做中间人去驱动调用lua方法
        asset.luaBehaviour = asset.oUIObject.AddComponent<UILuaBehaviour>();
    }

    UIPanel n_ObjPanel = asset.oUIObject.GetComponent<UIPanel>();
    if (n_ObjPanel)
        n_ObjPanel.depth = asset.ui.Depth;

    UIAnchor[] anchors = asset.oUIObject.GetComponentsInChildren<UIAnchor>();

    for (int i = 0; i < anchors.Length; i++)
    {
        anchors[i].uiCamera = uiCamera;
    }

    if (asset.panel != null)
    {
        asset.panel.OnShow();
    }
    else if (asset.luaBehaviour != null)
    {
        asset.luaBehaviour.OnShow();
    }
    
    uiActive.Add(asset);
    if (asset.panel != null)
    {
        asset.panel.m_UIName = strName;
    }
    obj = null;
    return asset.panel;
}

下面看一下UILuaBehaviour

public class UILuaBehaviour : PanelBase
{
    protected static bool initialize = false;

    private string data = null;

    private List<LuaFunction> buttons = new List<LuaFunction>();

    private string luaFileName = "";
    protected void Awake()
    {
        luaFileName = name.Split('_')[1]; //这里自动就知道模块lua的文件名了
        CallMethod("Awake", gameObject);//把gameobject传递给lua知道，然它知道控制的是谁
    }

    void Start()
    {
        if (initialize)
            return;

        CallMethod("Start");
        initialize = true;
    }

    public override void OnShow()
    {
        CallMethod("OnShow");
    }


    public virtual void OnHide()
    {
        CallMethod("OnHide");
    }

    public override void ValueChange(UICmd cmd)
    {
        CallMethod("ValueChange", cmd.key, cmd.values);
    }

    /// <summary>
    /// 添加单击事件
    /// </summary>
    public void AddClick(string ctrName, LuaFunction luafunc)
    {

        if (string.IsNullOrEmpty(ctrName))
            return;
        GameObject go = transform.FindChild(ctrName).gameObject;
        if (go == null)
            return;
        UIEventListener.Get(go).onClick = delegate (GameObject o)
        {
            luafunc.Call(go);
            buttons.Add(luafunc);
        };
    }

    /// <summary>
    /// 根据gameobject绑定按钮事件
    /// </summary>
    /// <param name="btn"></param>
    /// <param name="luafunc"></param>
    public void AddClickForObj(GameObject btn, LuaFunction luafunc)
    {
        if (btn == null)
            return;
        UIEventListener.Get(btn).onClick = delegate (GameObject o)
        {
            luafunc.Call(btn);
            buttons.Add(luafunc);
        };
    }


    /// <summary>
    /// 带一个整形参数的回调
    /// </summary>
    public void AddClickForObjWithIntParam(GameObject btn, LuaFunction luafunc, int iParam)
    {

        if (btn == null)
            return;
        UIEventListener.Get(btn).onClick = delegate (GameObject o)
        {
            luafunc.Call(iParam);
            buttons.Add(luafunc);
        };
    }

    /// <summary>
    /// 清除单击事件
    /// </summary>
    public void ClearClick()
    {
        for (int i = 0; i < buttons.Count; i++)
        {
            if (buttons[i] != null)
            {
                buttons[i].Dispose();
                buttons[i] = null;
            }
        }
    }

    /// <summary>
    /// 执行Lua方法
    /// </summary>
    protected object[] CallMethod(string func, params object[] args)
    {
        return Util.CallMethod(luaFileName, func, args);
    }

    public override void OnDestroy()
    {
        ClearClick();
        initialize = false;
        CallMethod("OnDestroy");
    }
}

最后看一下上面最常用到的Util.CallMethod方法，工具方法调用lua的方法

/// <summary>
/// 执行Lua方法
/// </summary>
public static object[] CallMethod(string module, string func, params object[] args) {
	LuaScriptMgr luaMgr = GameLuaManager.Get().LuaManager;
	if (luaMgr == null)
        return null;
	string funcName = module + "." + func;
	funcName = funcName.Replace("(Clone)", "");
        return luaMgr.CallLuaFunction(funcName, args);
}

最后看一个ui的lua脚本例子

--LoginZiJia.lua 
LoginZiJia = {} --这个模块，对应LoginZiJia这个UIPrefab
local this = LoginZiJia
local gameObject = nil
local playerName = ""
local playerSex = 0
local playerProfession = 0
local iP = ""
local port = 0

function LoginZiJia.Awake(obj)

	gameObject = obj --把实例化的GameObject传递过来了
end

function LoginZiJia.Start()

	playerName = GameObject.Find('Scale/Input_Name'):GetComponent('UIInput')
	playerName.text = "test2018"
	playerSex = GameObject.Find('Scale/Input_Sex'):GetComponent('UIInput')
	playerSex.text ='0'
	playerProfession = GameObject.Find('Scale/Input_Profession'):GetComponent('UIInput')
	playerProfession.text = '0'
	iP = GameObject.Find('Scale/Input_IP'):GetComponent('UIInput')
	iP.text = GameAPI.getZiJiaIP()
	port = GameObject.Find('Scale/Input_Port'):GetComponent('UIInput')
	port.text = tostring(GameAPI.getZiJiaPort())
	--获取UILuaBehaviour可以使用一些方便的方法
	local uilua = gameObject:GetComponent('UILuaBehaviour')
	uilua:AddClick('Scale/LoginBtn',this.onLogin)
	uilua:AddClick('Scale/LoginReturn',this.onBack)
end

抽象场景中活动的物体，添加上一个叫做Entity的脚本的，Entity是一个继承自MonoBehaviour的脚本组件，用来控制播放动画和检测进入泉水，Entity拥有一个ientity或则是继承自ientity的iplayer和iselfplayer，ientity用来保存同步信息（Transform组件，血值，攻击，模型id等）和提取了一些公共的方法（进入站立，进入移动，移动中，释放技能（进入，前摇，释放），击飞，下落，更新数据，打开商店，创建和显示隐藏血条等），如果是特殊的会声明为virtual在player那里重写并可以扩展新的方法。ientity已经有了很多的行为了，现在就需要在某种情况调用某种行为了，所以ientity会拥有一个EntityFSM状态机，这些状态机状态其实是一个工具类，他们直接调用的还是具体某个ientity的某个方法，只要将ientity的状态设置为具体的某个EntityFSM

public interface EntityFSM
{
	bool CanNotStateChange{set;get;}
	FsmState State { get; }
	void Enter(Ientity entity , float stateLast);
	bool StateChange(Ientity entity , EntityFSM state);
	void Execute(Ientity entity);
	void Exit(Ientity Ientity);
}

public class EntityIdleFSM : EntityFSM
{
    public static readonly EntityFSM Instance = new EntityIdleFSM();
		
	public FsmState State
	{
		get
        {
            return FsmState.FSM_STATE_IDLE;
		}
	}
		
	public bool CanNotStateChange{
		set;get;
	}
		
	public bool StateChange(Ientity entity , EntityFSM fsm)
    {
		return CanNotStateChange;
	}
		
	public void Enter(Ientity entity , float last)
    {
        entity.OnEnterIdle();
	}
		
	public void Execute(Ientity entity)
    {
        if (EntityStrategyHelper.IsTick(entity, 3.0f))
        {
            entity.OnFSMStateChange(EntityFreeFSM.Instance);
        }
	}
		
	public void Exit(Ientity entity){
			
	}
}

在ientity中维护这一个EntityFSM，提供了转换的接口，在转换时修改这个EntityFSM的引用实例并调用这个EntityFSM的Enter方法，随后在Entity组件的Update方法中调用的ientity的Update方法再调用的EntityFSM的Update方法，而实际Update和Enter方法都会传入ientity，然后调用的实际还是ientity里的具体方法，只是EntityFSM的不同，调用的不同！

EntityFSM的状态有：EntityFSM、EntityDeadFSM、EntityForceMoveFSM、EntityFreeFSM、EntityIdleFSM、EntityLastingFSM、EntityLeadingFSM、EntityReleaseSkillFSM、EntityReliveFSM、EntityRunFSM、EntitySingFSM。