/// <summary>
/// 使用反射产生对应表的List数据
/// </summary>
/// <param name="configTableDataTypeDefine"></param>
/// <param name="tableInfo"></param>
/// <returns></returns>
private System.Object FillDynamicListWithTableData(Type configTableDataTypeDefine, ConfigDataTableInfo tableInfo)
{
var listType = typeof(List <>).MakeGenericType(configTableDataTypeDefine);
var list = Activator.CreateInstance(listType);
var addMethod = listType.GetMethod("Add");
if (tableInfo.Row > 2)
{
for (int i = 2; i < tableInfo.Row; i++)
{
var data = Activator.CreateInstance(configTableDataTypeDefine);
foreach (var columnInfo in tableInfo.ColumnInfoList)
{
try
{
var filedInfo = configTableDataTypeDefine.GetField("m_" + columnInfo.ColumnName, BindingFlags.NonPublic | BindingFlags.Instance);
var value = ConfigDataColumnTypeSolver.GetValue(tableInfo.ReadCell(i, columnInfo.ColumnNo), columnInfo.TypeStr);
filedInfo.SetValue(data, value);
}catch (Exception e)
{
Debug.LogError(string.Format("FillDynamicListWithTableData while process table {0} column {1}, msg:{2}", tableInfo.TableName, columnInfo.ColumnName, e.Message));
}
}
addMethod.Invoke((object)list, new object[] { data });
}
}
return(list);
}
public void Play(string soundName, float delay = 0, float volume = 1, SoundChannel.SoundChannelType channel = SoundChannel.SoundChannelType.Default)
{
AudioClip clip = null;
if (m_cache.ContainsKey(soundName))
{
clip = m_cache[soundName];
}
else
{
clip = m_assetProvider.GetAsset <AudioClip>("Sound/" + soundName);
if (clip != null)
{
m_cache.Add(soundName, clip);
}
else
{
Debug.LogError("can't load audioClip: " + soundName);
}
}
if (clip == null)
{
return;
}
m_soundChannelDic[channel].Play(clip, volume, delay);
}
public static bool RegisterUITasks()
{
var gameManager = GameManager.Instance;
if (gameManager == null)
{
Debug.LogError("Mugen3DUITaskRegister:RegisterUITasks gameManager == null");
return(false);
}
var uiManager = gameManager.UIManager;
uiManager.RegisterUITask(new UITaskRegisterItem()
{
Name = "MainMenuUITask", TypeFullName = "bluebean.Mugen3D.UI.MainMenuUITask"
});
uiManager.RegisterUITask(new UITaskRegisterItem()
{
Name = "CharacterSelectUITask", TypeFullName = "bluebean.Mugen3D.UI.CharacterSelectUITask"
});
uiManager.RegisterUITask(new UITaskRegisterItem()
{
Name = "BattleUITask", TypeFullName = "bluebean.Mugen3D.UI.BattleUITask"
});
return(true);
}
/// <summary>
/// 开启一个UITask
/// </summary>
/// <param name="intent"></param>
/// <param name="onPrepareEnd"></param>
/// <param name="onViewUpdateComplete"></param>
/// <param name="redirectOnLoadAllAssetsComplete"></param>
/// <returns></returns>
public bool StartUITask(UIIntent intent, Action <bool> onPrepareEnd = null, Action onViewUpdateComplete = null, Action redirectOnLoadAllAssetsComplete = null)
{
if (!m_uiTaskRegistyerItemDic.ContainsKey(intent.Name))
{
Debug.LogError("StartUITask can't find UITaskRegisterItem name:" + intent.Name);
return(false);
}
var uiTaskRegisterItem = m_uiTaskRegistyerItemDic[intent.Name];
var uiTask = CreateOrGetUITaskInstance(uiTaskRegisterItem);
if (uiTask == null)
{
Debug.LogError("StartUITask Can't create UITask instance, typeFullName:" + uiTaskRegisterItem.TypeFullName);
}
if (redirectOnLoadAllAssetsComplete != null)
{
uiTask.UpdateCtx.SetRedirectOnLoadAssetComplete(redirectOnLoadAllAssetsComplete);
}
if (onViewUpdateComplete != null)
{
uiTask.UpdateCtx.m_onViewUpdateComplete = onViewUpdateComplete;
}
StartUITaskInternal(uiTask, intent, onPrepareEnd);
return(true);
}
private IEnumerator LoadAssetByResourceLoad(string path, bool hasSubAsset, Action <string, UnityEngine.Object[]> onEnd)
{
//从全路径中解析出相对Resources的路径
string pathInResoruces = PathHelper.GetSubPathInResources(path);
//去掉文件扩展名
pathInResoruces = PathHelper.RemoveExtension(pathInResoruces);
UnityEngine.Object[] assets;
if (hasSubAsset)
{
assets = Resources.LoadAll(pathInResoruces);
}
else
{
assets = new UnityEngine.Object[1];
assets[0] = Resources.Load(pathInResoruces);
}
yield return(null);
if (assets != null && assets[0] != null)
{
Debug.Log("Load Asset Success by ResourceLoad AssetPath:" + path);
}
onEnd(path, assets);
}
public bool GetAeeembly(out Assembly assembly)
{
assembly = null;
var compiler = new CSharpCodeProvider();
var comPara = new CompilerParameters();
comPara.GenerateExecutable = false;
comPara.GenerateInMemory = true;
comPara.OutputAssembly = "";
var assemblies = AppDomain.CurrentDomain
.GetAssemblies()
.Where(a => !a.IsDynamic)
.Select(a => a.Location);
comPara.ReferencedAssemblies.AddRange(assemblies.ToArray());
comPara.OutputAssembly = "Assembly-CSharp";
var result = compiler.CompileAssemblyFromDom(comPara, m_codeUnit);
//var result = compiler.CompileAssemblyFromFile(comPara, m_sourceFileName);
if (result.Errors.HasErrors)
{
foreach (var error in result.Errors)
{
Debug.LogError(error.ToString());
}
return(false);
}
assembly = result.CompiledAssembly;
return(true);
}
public void UnRegisterTask(Task task)
{
if (!m_taskList.Contains(task))
{
Debug.LogError(string.Format("TaskManager UnRegisterTask Failed do't contain the task {0}", task.Name));
}
m_toRemoveTaskList.Add(task);
}
public void StartLoadAllConfigData()
{
m_coroutineHelper.StartCorcoutine(m_configDataLoader.LoadAllConfigData((res) => {
if (!res)
{
Debug.Log("ConfigDataLoader Init Error");
}
}));
}
public bool Register(Task task)
{
if (m_taskList.Contains(task) || m_toAddTaskList.Contains(task))
{
Debug.LogError(string.Format("TaskManager Register Failed has registered the same task {0}", task.Name));
return(false);
}
m_toAddTaskList.Add(task);
return(true);
}
/// <summary>
/// 获取完整路径
/// </summary>
/// <param name="assetPath"></param>
/// <returns></returns>
public static string GetFullPath(string assetPath)
{
if (!assetPath.StartsWith("Assets"))
{
Debug.LogError(string.Format("GetFullPath assetPath:{0} is not start with 'Assets'", assetPath));
return(null);
}
assetPath = assetPath.Substring("Assets".Length);
return(Application.dataPath + assetPath);
}
/// <summary>
/// 去掉文件扩展名
/// </summary>
/// <param name="assetPath"></param>
/// <returns></returns>
public static string RemoveExtension(string assetPath)
{
int dotIndex = assetPath.LastIndexOf(".");
if (dotIndex == -1)
{
Debug.LogError("RemoveExtension error: can't find '.'");
return(null);
}
string path = assetPath.Substring(0, dotIndex);
return(path);
}
/// <summary>
/// 解析出相对Resources的路径
/// </summary>
/// <param name="assetPath"></param>
/// <returns></returns>
public static string GetSubPathInResources(string assetPath)
{
int index = assetPath.LastIndexOf("Resources");
if (index == -1)
{
Debug.LogError("GetSubPathInResources error: can't find 'Resources'");
return(null);
}
index += "Resources".Length;
string path = assetPath.Substring(index);
return(path);
}
public static int ParseInt(string s)
{
if (String.IsNullOrEmpty(s))
{
return(0);
}
int value = 0;
if (!Int32.TryParse(s, out value))
{
Debug.LogError(string.Format("ParseInt error while parse \"{0}\"", value));
}
return(value);
}
/// <summary>
/// 注册UITask条目
/// </summary>
/// <param name="uiTaskRegisterItem"></param>
public void RegisterUITask(UITaskRegisterItem uiTaskRegisterItem)
{
if (string.IsNullOrEmpty(uiTaskRegisterItem.Name))
{
Debug.LogError("uiTaskRegisterItem's name is null or empty");
return;
}
if (m_uiTaskRegistyerItemDic.ContainsKey(uiTaskRegisterItem.Name))
{
Debug.LogError("RegisterUITask, Already contain the same name UITask,name:" + uiTaskRegisterItem.Name);
return;
}
m_uiTaskRegistyerItemDic.Add(uiTaskRegisterItem.Name, uiTaskRegisterItem);
}
public void Pause()
{
if (m_state != TaskState.Runing)
{
Debug.LogError("TaskBase:Pause but state is't Running");
return;
}
m_state = TaskState.Paused;
OnPause();
if (EventOnPause != null)
{
EventOnPause();
}
}
public static GameManager CreateAndInitializeInstance()
{
var gameManager = new GameManager();
if (gameManager.Intialize())
{
m_instance = gameManager;
return(m_instance);
}
else
{
Debug.LogError("GameManager Initialize Failed!");
return(null);
}
}
protected virtual bool Initialize()
{
m_gameManager = GameManager.CreateAndInitializeInstance();
if (m_gameManager == null)
{
Debug.LogError("GameManager CreateAndInitializeInstance Failed!");
return(false);
}
m_gameManager.StartLoadAllConfigData();
Mugen3DUITaskRegister.RegisterUITasks();
UIIntent intent = new UIIntent("MainMenuUITask");
UIManager.Instance.StartUITask(intent);
return(true);
}
private static T _GetAsset <T>(Dictionary <string, UnityEngine.Object> assetDic, string path) where T : UnityEngine.Object
{
UnityEngine.Object asset;
T res = null;
if (assetDic.TryGetValue(path, out asset))
{
res = asset as T;
}
if (res == null)
{
Debug.LogError(string.Format("AssetUtility:_GetAsset asset is null, path:{0}", path));
}
return(res);
}
public bool Intialize()
{
m_configDataLoader = ConfigDataLoader.CreateInstance();
m_coroutineHelper = new CoroutineScheduler();
m_assetLoader = AssetLoader.CreateInstance();
m_taskManager = TaskManager.CreateInstance();
m_uiManager = UIManager.CreateInstance();
m_sceneTree = SceneTree.CreateInstance();
if (!m_sceneTree.Initialize())
{
Debug.LogError("SceneTree Initialize Failed");
return(false);
}
return(true);
}
/// <summary>
/// 开启UITask
/// </summary>
/// <param name="uiTask"></param>
/// <param name="intent"></param>
/// <param name="onPrepareEnd"></param>
private void StartUITaskInternal(UITask uiTask, UIIntent intent, Action <bool> onPrepareEnd = null)
{
uiTask.PrapareDataForStart((res) => {
if (onPrepareEnd != null)
{
onPrepareEnd(res);
}
if (res)
{
StartOrResumeUITask(uiTask, intent);
}
else
{
Debug.LogError(string.Format("PrapareDataForStart Failed UITask Name:", uiTask.Name));
}
});
}
public void Resume(Object param)
{
if (m_state != TaskState.Paused)
{
Debug.LogError("TaskBase:Resume but state is't Paused");
return;
}
m_state = TaskState.Runing;
if (!OnResume(param))
{
Pause();
Debug.LogError(string.Format("task {0} OnResume Failed!", m_name));
return;
}
if (EventOnResume != null)
{
EventOnResume();
}
}
private void OnEnsureKeyDown()
{
if (CurMode == Mode_Training)
{
if (m_trainingModeCharacterSelectStage == TrainingModeCharacterSelectStage.P1)
{
m_trainingModeCharacterSelectStage = TrainingModeCharacterSelectStage.P2;
}
else if (m_trainingModeCharacterSelectStage == TrainingModeCharacterSelectStage.P2)
{
m_trainingModeCharacterSelectStage = TrainingModeCharacterSelectStage.AllComplete;
}
if (m_trainingModeCharacterSelectStage == TrainingModeCharacterSelectStage.AllComplete)
{
Debug.Log("CharacterSelectUITask TraningMode:TrainingModeCharacterSelectStage == AllComplete");
Pause();
BattleUITask.StartUITask(m_curUIIntent, m_configDataCharacters[m_p1CharacterIndex], m_configDataCharacters[m_p2CharacterIndex], ConfigDataLoader.Instance.GetConfigDataStage(1));
}
}
}
public void Start(Object param)
{
if (m_state != TaskState.Init)
{
Debug.LogError("TaskBase:Start but state is't init");
return;
}
m_state = TaskState.Runing;
TaskManager.Instance.Register(this);
if (!OnStart(param))
{
Debug.LogError(string.Format("task {0} OnStart Failed", m_name));
Stop();
return;
}
if (EventOnStart != null)
{
EventOnStart();
}
}
public void AutoBindFields()
{
var type = this.GetType();
foreach (var fieldInfo in type.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance))
{
var autoBindAttribute = fieldInfo.GetCustomAttribute <AutoBindAttribute>();
if (autoBindAttribute != null)
{
var obj = BindFiledImpl(fieldInfo.FieldType, autoBindAttribute.path);
if (obj != null)
{
fieldInfo.SetValue(this, obj);
}
else
{
Debug.LogError(string.Format("BindFiledImpl error {0} path:{1}", type.Name, autoBindAttribute.path));
}
}
}
OnBindFieldsComplete();
}
private void LoadAssetByAssetDatabase(string path, bool hasSubAsset, Action <string, UnityEngine.Object[]> onEnd)
{
UnityEngine.Object[] assets;
if (hasSubAsset)
{
assets = AssetDatabase.LoadAllAssetsAtPath(path);
}
else
{
assets = new UnityEngine.Object[1];
assets[0] = AssetDatabase.LoadAssetAtPath(path, typeof(UnityEngine.Object));
}
if (assets != null && assets[0] != null)
{
Debug.Log("Load Asset Success by AssetDataBase AssetPath:" + path);
}
else
{
Debug.Log("Load Asset Fail by AssetDataBase AssetPath:" + path);
}
onEnd(path, assets);
}
private void OnDestroy()
{
Debug.Log("ConfigDataEditorWindow OnDestroy");
}
private void OnExitButtonClick()
{
Debug.Log("MainMenuUITask:OnExitButtonClick");
}
private void OnOptionButtonClick()
{
Debug.Log("MainMenuUITask:OnOptionButtonClick");
}
private void OnTrainButtonClick()
{
Debug.Log("MainMenuUITask:OnTrainButtonClick");
Pause();
CharacterSelectUITask.StartUITask(m_curUIIntent, CharacterSelectUITask.Mode_Training);
}
public void CreateCameraController(CameraComponent cameraComponent)
{
Debug.Log("ClientBattleWorld:CreateCameraController");
m_cameraController = new CameraController();
m_cameraController.Init(cameraComponent, m_sceneRoot.transform.Find("BattleCamera").GetComponent <Camera>());
}
