WSHCommon/XmdsBattleClient/Battle/XmdsBattleManager.cs

using CommonAI.Zone;
using CommonAI.Zone.ZoneEditor;
using System;
using XmdsCommon.Plugin;
using CommonAI.Zone.Instance;
using System.IO;
using CommonLang.Log;
using XmdsCommon.EditorData;

namespace XmdsBattleClient.Battle
{
    public class XmdsBattleManager
    {
        private readonly static Logger log = LoggerFactory.GetLogger("XmdsBattleManager");

        private static EditorTemplates s_data_root;

        public static EditorTemplates DataRoot { get { return s_data_root; } }
        public static TemplateManager Templates { get { return s_data_root.Templates; } }

        /// <summary>
        /// 初始化所有模板以及工厂类，游戏启动时调用
        /// </summary>
        /// <param name="data_root"></param>
        /// <param name="factory"></param>
        public static void Init(string data_root, InstanceZoneFactory factory)
        {
            //联网模式，客户端不包含服务端DLL、技能DLL.
            TemplateManager.setFactory(factory);
            s_data_root = new EditorTemplates(data_root, TemplateManager.MessageCodec);
            s_data_root.LoadAllTemplates();
		}

        public static void InitWithoutLoadAllTemplates(string data_root, InstanceZoneFactory factory)
        {
            //联网模式，客户端不包含服务端DLL、技能DLL.
            TemplateManager.setFactory(factory);
            s_data_root = new EditorTemplates(data_root, TemplateManager.MessageCodec);
        }

        public static void LoadCFG_Step()
        {
            s_data_root.LoadCFG();
            s_data_root.LoadResVersion();
            s_data_root.LoadTerrainDefinitionMap();
            s_data_root.LoadUnitActionDefinitionMap();
        }

        public static void LoadUnits_Step()
        {
            foreach (string file in s_data_root.LoadList("/units"))
            {
                s_data_root.LoadTemplate<UnitInfo>(file);
            }
        }

        public static void LoadSkills_Step()
        {
            foreach (string file in s_data_root.LoadList("/skills"))
            {
                s_data_root.LoadTemplate<SkillTemplate>(file);
            }
        }

        public static void LoadSpells_Step()
        {
            foreach (string file in s_data_root.LoadList("/spells"))
            {
                s_data_root.LoadTemplate<SpellTemplate>(file);
            }
        }


        public static void loadBuffs_Step()
        {

            foreach (string file in s_data_root.LoadList("/buffs"))
            {
                s_data_root.LoadTemplate<BuffTemplate>(file);
            }
        }


        public static void loadItems_Step()
        {
            foreach (string file in s_data_root.LoadList("/items"))
            {
                s_data_root.LoadTemplate<ItemTemplate>(file);
            }
        }

        public static void loadTriggersAndEvents_Step(bool client = false)
        {
            if (!client)
            {
                foreach (string file in s_data_root.LoadList("/unit_triggers"))
                {
                    s_data_root.LoadTemplate<UnitTriggerTemplate>(file);
                }
                foreach (string file in s_data_root.LoadList("/unit_events"))
                {
                    s_data_root.LoadTemplate<UnitEventTemplate>(file);
                }
            }
        }

        public static void loadFormula_Step()
        {
            if (TemplateManager.Formula != null)
            {
                TemplateManager.Formula.InitPluginsData(s_data_root);
            }
        }

        public static void LoadCFG(byte[] dat)
        {
            s_data_root.LoadAllCFG(dat);
        }

        public static void LoadCFG(Stream stream)
        {
            s_data_root.LoadAllCFG(stream);
        }

        public static void LoadTemplate<T>(byte[] dat) where T : class, ITemplateData
        {
            using (var ms = new MemoryStream(dat))
            {
                LoadTemplates<T>(ms);
            }
        }

        public static void LoadTemplates<T>(Stream stream) where T : class, ITemplateData
        {
            try
            {
                var br = new BinaryReader(stream);
                var n = br.ReadInt32();
                for (var i = 0; i < n; i++)
                {
                    var name = br.ReadString();
                    var len = br.ReadInt32();
                    var rpos = stream.Position;
                    try
                    {
                        s_data_root.LoadTemplate<T>(stream);
                    }
                    catch (Exception err)
                    {
                        log.ErrorFormat("LoadTemplate:{0},{1}", typeof(T), name);
                        log.Error(err);
                    }
                    finally
                    {
                        stream.Position = rpos + len;
                    }
                }
            }
            catch (Exception e)
            {
                log.Error(e);
            }
        }

        public static void LoadSceneSnapData(byte[] dat)
        {
            LoadSceneSnapData(new MemoryStream(dat));
        }

        public static void LoadSceneSnapData(Stream stream)
        {
            try
            {
                var br = new BinaryReader(stream);
                var n = br.ReadInt32();
                for (var i = 0; i < n; i++)
                {
                    var _id = br.ReadInt32();
                    var _len = br.ReadInt32();
                    var _dat = br.ReadBytes(_len);
                    try
                    {
                        SceneSnapManager.LoadSceneSnapData(_id, _dat);
                    }
                    catch (Exception err)
                    {
                        log.Error(err);
                    }
                }
            }
            catch (Exception e)
            {
                log.Error(e);
            }
        }

        public static void LoadNewSceneSnapData(Stream stream)
        {
            try
            {
                var br = new BinaryReader(stream);
                var n = br.ReadInt32();
                for (var i = 0; i < n; i++)
                {
                    var _id = br.ReadInt32();
                    var _len = br.ReadInt32();
                    var _dat = br.ReadBytes(_len);
                    try
                    {
                        SceneSnapManager.LoadBinUnitSnapData(_id, _dat);
                    }
                    catch (Exception err)
                    {
                        log.Error(err);
                    }
                }
            }
            catch (Exception e)
            {
                log.Error(e);
            }
        }

        public static void loadFinish()
        {
            s_data_root.Templates.RehashAll();
        }
    }
}