snxxz_scripts.git

			@@ -1,44 +1,205 @@
			//--------------------------------------------------------
			// [Author]: 第二世界
			// [ Date ]: Tuesday, June 05, 2018
			//--------------------------------------------------------

			using UnityEngine;
			using System;

			namespace TableConfig {


			public partial class LoadingFunctionConfig : ConfigBase {

			public int ID { get ; private set ; }
			public string Icon { get ; private set; }
			public int Level { get ; private set ; }

			public override string getKey()
			{
			return ID.ToString();
			}

			public override void Parse() {
			try
			{
			ID=IsNumeric(rawContents[0]) ? int.Parse(rawContents[0]):0;

			Icon = rawContents[1].Trim();

			Level=IsNumeric(rawContents[2]) ? int.Parse(rawContents[2]):0;
			}
			catch (Exception ex)
			{
			DesignDebug.Log(ex);
			}
			}

			}

			}




			//--------------------------------------------------------
			// [Author]: Fish
			// [ Date ]: Thursday, February 14, 2019
			//--------------------------------------------------------

			using System.Collections.Generic;
			using System.IO;
			using System.Threading;
			using System;
			using UnityEngine;

			[XLua.LuaCallCSharp]
			public partial class LoadingFunctionConfig
			{

			public readonly int ID;
			public readonly string Icon;
			public readonly int Level;

			public LoadingFunctionConfig()
			{
			}

			public LoadingFunctionConfig(string input)
			{
			try
			{
			var tables = input.Split('\t');

			int.TryParse(tables[0],out ID);

			Icon = tables[1];

			int.TryParse(tables[2],out Level);
			}
			catch (Exception ex)
			{
			DebugEx.Log(ex);
			}
			}

			static Dictionary<string, LoadingFunctionConfig> configs = new Dictionary<string, LoadingFunctionConfig>();
			public static LoadingFunctionConfig Get(string id)
			{
			if (!inited)
			{
			Debug.Log("LoadingFunctionConfig 还未完成初始化。");
			return null;
			}

			if (configs.ContainsKey(id))
			{
			return configs[id];
			}

			LoadingFunctionConfig config = null;
			if (rawDatas.ContainsKey(id))
			{
			config = configs[id] = new LoadingFunctionConfig(rawDatas[id]);
			rawDatas.Remove(id);
			}

			return config;
			}

			public static LoadingFunctionConfig Get(int id)
			{
			return Get(id.ToString());
			}

			public static List<string> GetKeys()
			{
			var keys = new List<string>();
			keys.AddRange(configs.Keys);
			keys.AddRange(rawDatas.Keys);
			return keys;
			}

			public static List<LoadingFunctionConfig> GetValues()
			{
			var values = new List<LoadingFunctionConfig>();
			values.AddRange(configs.Values);

			var keys = new List<string>(rawDatas.Keys);
			foreach (var key in keys)
			{
			values.Add(Get(key));
			}

			return values;
			}

			public static bool Has(string id)
			{
			return configs.ContainsKey(id) \|\| rawDatas.ContainsKey(id);
			}

			public static bool Has(int id)
			{
			return Has(id.ToString());
			}

			public static bool inited { get; private set; }
			protected static Dictionary<string, string> rawDatas = new Dictionary<string, string>();
			public static void Init(bool sync=false)
			{
			inited = false;
			var path = string.Empty;
			if (AssetSource.refdataFromEditor)
			{
			path = ResourcesPath.CONFIG_FODLER +"/LoadingFunction.txt";
			}
			else
			{
			path = AssetVersionUtility.GetAssetFilePath("config/LoadingFunction.txt");
			}

			var tempConfig = new LoadingFunctionConfig();
			var preParse = tempConfig is IConfigPostProcess;

			if (sync)
			{
			var lines = File.ReadAllLines(path);
			if (!preParse)
			{
			rawDatas = new Dictionary<string, string>(lines.Length - 3);
			}
			for (int i = 3; i < lines.Length; i++)
			{
			try
			{
			var line = lines[i];
			var index = line.IndexOf("\t");
			if (index == -1)
			{
			continue;
			}
			var id = line.Substring(0, index);

			if (preParse)
			{
			var config = new LoadingFunctionConfig(line);
			configs[id] = config;
			(config as IConfigPostProcess).OnConfigParseCompleted();
			}
			else
			{
			rawDatas[id] = line;
			}
			}
			catch (System.Exception ex)
			{
			Debug.LogError(ex);
			}
			}
			inited = true;
			}
			else
			{
			ThreadPool.QueueUserWorkItem((object _object) =>
			{
			var lines = File.ReadAllLines(path);
			if (!preParse)
			{
			rawDatas = new Dictionary<string, string>(lines.Length - 3);
			}
			for (int i = 3; i < lines.Length; i++)
			{
			try
			{
			var line = lines[i];
			var index = line.IndexOf("\t");
			if (index == -1)
			{
			continue;
			}
			var id = line.Substring(0, index);

			if (preParse)
			{
			var config = new LoadingFunctionConfig(line);
			configs[id] = config;
			(config as IConfigPostProcess).OnConfigParseCompleted();
			}
			else
			{
			rawDatas[id] = line;
			}
			}
			catch (System.Exception ex)
			{
			Debug.LogError(ex);
			}
			}

			inited = true;
			});
			}
			}

			}