private IEnumerator LoadGameInitUI()
{
gameInitMod = ModManager.LoadGameMod(GamePathManager.GetResRealPath("core", "core.gameinit.ballance"), false);
gameInitMod.IsModInitByGameinit = true;
yield return(StartCoroutine(gameInitMod.LoadInternal()));
if (gameInitMod.LoadStatus != GameModStatus.InitializeSuccess)
{
GameErrorManager.ThrowGameError(GameError.GameInitPartLoadFailed, "加载 GameInit 资源包失败 ");
StopAllCoroutines();
}
gameInitUI = GameManager.UIManager.InitViewToCanvas(gameInitMod.GetPrefabAsset("UIGameInit.prefab"), "GameInitUI").gameObject;
GameManager.UIManager.MaskBlackSet(false);
UIProgress = gameInitUI.transform.Find("UIProgress").GetComponent <RectTransform>();
UIProgressValue = gameInitUI.transform.Find("UIProgress/UIValue").GetComponent <RectTransform>();
UIProgressText = gameInitUI.transform.Find("Text").GetComponent <Text>();
IntroAnimator = gameInitUI.GetComponent <Animator>();
TextError = gameInitUI.transform.Find("TextError").GetComponent <Text>();
loadedGameInitUI = true;
}
// 设置数据
// ====================================
/// <summary>
/// 设置数据的值
/// </summary>
/// <param name="context">数据安全上下文</param>
/// <param name="data">新值</param>
/// <returns></returns>
public bool SetData(int context, object data)
{
if (_StoreDataAccess != StoreDataAccess.GetAndSet && context != currentHolderContext)
{
GameErrorManager.SetLastErrorAndLog(GameError.ContextMismatch, "StoreData",
"上下文 {0} 没有操作此数据的权限", context);
return(false);
}
//类型检查
if (_DataType != StoreDataType.Custom && data.GetType().Name != _DataType.ToString())
{
GameErrorManager.SetLastErrorAndLog(GameError.ContextMismatch, "StoreData",
"输入 {0} 与设置的类型不符 {1}", data, _DataType.ToString());
return(false);
}
if (_DataRaw != data)
{
object old = _DataRaw;
_DataRaw = data;
NotificationDataObserver(old, data);
}
return(true);
}
//加载GameInit模块
private IEnumerator GameInitPackages(string GameInitTable)
{
StringSpliter sp = new StringSpliter(GameInitTable, '\n');
if (sp.Count >= 1)
{
int loadedCount = 0;
string[] args;
GameLogger.Log(TAG, "Gameinit table : {0}", sp.Count);
foreach (string ar in sp.Result)
{
if (ar.StartsWith(":"))
{
continue;
}
bool required = false;
string packageName = "";
GameModRunMask mask = GameModRunMask.GameBase;
args = ar.Split(':');
if (args.Length >= 3)
{
required = args[2] == "Required";
packageName = args[0];
System.Enum.TryParse(args[1], out mask);
}
bool modNeedRun = (mask & currentLoadMask) != GameModRunMask.None;
//状态
loadedCount++;
GameInitSetUIProgressValue(loadedCount / (float)sp.Count * 0.6f);
UIProgressText.text = "Loading " + packageName;
//加载
GameMod mod = ModManager.LoadGameModByPackageName(packageName, modNeedRun);
if (mod != null)
{
mod.IsModInitByGameinit = true;
yield return(new WaitUntil(mod.IsLoadComplete));
}
if ((mod == null || (modNeedRun && mod.LoadStatus != GameModStatus.InitializeSuccess)) && required)
{
GameErrorManager.ThrowGameError(GameError.GameInitPartLoadFailed, "加载模块 " + packageName + " 时发生错误");
}
}
}
UIProgressText.text = "Loading";
GameInitSetUIProgressValue(0.6f);
}
/// <summary>
/// 取消注册操作
/// </summary>
/// <param name="action">操作实例</param>
public void UnRegisterAction(GameAction action)
{
if (action == null)
{
GameErrorManager.SetLastErrorAndLog(GameError.ParamNotProvide, TAG, "UnRegisterAction action 参数未提供");
return;
}
action.Dispose();
actions.Remove(action.Name);
}
/// <summary>
/// 取消注册多个操作
/// </summary>
/// <param name="name">操作名称</param>
public void UnRegisterActions(string[] names)
{
if (CommonUtils.IsArrayNullOrEmpty(names))
{
GameErrorManager.SetLastErrorAndLog(GameError.ParamNotProvide, TAG, "UnRegisterActions names 参数未提供或数组为空");
return;
}
foreach (string s in names)
{
UnRegisterAction(s);
}
}
/// <summary>
/// 取消设置数据提供者
/// </summary>
/// <param name="context">数据安全上下文</param>
public void RemoveRegisterProvider(int context)
{
if (StoreDataProvider != null)
{
if (context != currentHolderContext)
{
GameErrorManager.SetLastErrorAndLog(GameError.ContextMismatch, "StoreData",
"上下文 {0} 没有操作此数据的权限", context);
return;
}
StoreDataProvider = null;
}
}
/// <summary>
/// 注册多个操作
/// </summary>
/// <param name="names">操作名称数组</param>
/// <param name="handlerNames">接收器名称数组</param>
/// <param name="luaFunctionHandlers">LUA接收函数数组</param>
/// <param name="self">LUA self （当前类，LuaTable），如无可填null</param>
/// <param name="callTypeChecks">函数参数检查，如果不需要，也可以为null</param>
/// <returns>返回注册成功的操作个数</returns>
public int RegisterActions(string[] names, string[] handlerNames, LuaFunction[] luaFunctionHandlers, LuaTable self, string[][] callTypeChecks)
{
int succCount = 0;
if (CommonUtils.IsArrayNullOrEmpty(names))
{
GameErrorManager.SetLastErrorAndLog(GameError.ParamNotProvide, TAG, "RegisterActions 参数 names 数组为空");
return(succCount);
}
if (CommonUtils.IsArrayNullOrEmpty(handlerNames))
{
GameErrorManager.SetLastErrorAndLog(GameError.ParamNotProvide, TAG, "RegisterActions 参数 handlerNames 数组为空");
return(succCount);
}
if (CommonUtils.IsArrayNullOrEmpty(luaFunctionHandlers))
{
GameErrorManager.SetLastErrorAndLog(GameError.ParamNotProvide, TAG, "RegisterActions 参数 luaFunctionHandlers 数组为空");
return(succCount);
}
if (names.Length != handlerNames.Length || handlerNames.Length != luaFunctionHandlers.Length ||
(callTypeChecks != null && callTypeChecks.Length != luaFunctionHandlers.Length))
{
GameErrorManager.SetLastErrorAndLog(GameError.ParamNotProvide, TAG,
"RegisterActions 参数数组长度不符\n{0}=={1}=={2}=={3}",
names.Length,
handlerNames.Length,
luaFunctionHandlers.Length,
callTypeChecks.Length);
return(succCount);
}
for (int i = 0, c = names.Length; i < c; i++)
{
if (RegisterAction(names[i], new GameHandler(handlerNames[i], luaFunctionHandlers[i], self),
callTypeChecks == null ? null : callTypeChecks[i]) != null)
{
succCount++;
}
}
return(succCount);
}
/// <summary>
/// 设置数据提供者
/// </summary>
/// <param name="context">数据安全上下文（注册成功后须使用此上下文才能进行私有数据更新）</param>
/// <param name="provider">数据提供者</param>
/// <returns></returns>
public int SetDataProvider(int context, StoreDataProvider provider)
{
if (StoreDataProvider == null)
{
StoreDataProvider = provider;
currentHolderContext = context;
return(context);
}
else if (context != currentHolderContext)
{
GameErrorManager.SetLastErrorAndLog(GameError.ContextMismatch, "StoreData",
"上下文 {0} 没有操作此数据的权限", context);
return(0);
}
else
{
StoreDataProvider = provider;
return(context);
}
}
/// <summary>
/// 取消注册操作
/// </summary>
/// <param name="name">操作名称</param>
public void UnRegisterAction(string name)
{
if (string.IsNullOrEmpty(name))
{
GameErrorManager.SetLastErrorAndLog(GameError.ParamNotProvide, TAG, "UnRegisterAction name 参数未提供");
return;
}
GameAction gameAction;
if (IsActionRegistered(name, out gameAction))
{
gameAction.Dispose();
actions.Remove(name);
}
else
{
GameLogger.Warning(TAG, "操作 {0} 未注册", name);
GameErrorManager.LastError = GameError.NotRegister;
}
}
/// <summary>
/// 调用操作
/// </summary>
/// <param name="name">目标操作名称</param>
/// <param name="param">调用参数</param>
/// <returns>返回操作调用结果，如果未找到操作，则返回 GameActionCallResult.FailResult </returns>
public GameActionCallResult CallAction(string name, params object[] param)
{
GameActionCallResult result = GameActionCallResult.FailResult;
if (string.IsNullOrEmpty(name))
{
GameErrorManager.SetLastErrorAndLog(GameError.ParamNotProvide, TAG, "CallAction name 参数未提供");
return(result);
}
GameAction gameAction;
if (IsActionRegistered(name, out gameAction))
{
return(CallAction(gameAction, param));
}
else
{
GameErrorManager.SetLastErrorAndLog(GameError.NotRegister, TAG, "操作 {0} 未注册", name);
}
return(result);
}
/// <summary>
/// 注册操作
/// </summary>
/// <param name="name">操作名称</param>
/// <param name="handler">接收器</param>
/// <param name="callTypeCheck">函数参数检查，数组长度规定了操作需要的参数，
/// 组值是一个或多个允许的类型名字，例如 UnityEngine.GameObject System.String 。
/// 如果一个参数允许多种类型，可使用/分隔。
/// 如果不需要参数检查，也可以为null，则当前操作将不会进行类型检查
/// </param>
/// <returns>返回注册的操作实例，如果注册失败则返回 null ，请查看 LastError 的值</returns>
public GameAction RegisterAction(string name, GameHandler handler, string[] callTypeCheck)
{
if (string.IsNullOrEmpty(name))
{
GameErrorManager.SetLastErrorAndLog(GameError.ParamNotProvide, TAG, "RegisterAction name 参数未提供");
return(null);
}
if (handler == null)
{
GameErrorManager.SetLastErrorAndLog(GameError.ParamNotProvide, TAG, "RegisterAction handler 参数未提供");
return(null);
}
if (IsActionRegistered(name))
{
GameLogger.Warning(TAG, "操作 {0} 已注册", name);
GameErrorManager.LastError = GameError.AlredayRegistered;
return(null);
}
GameAction gameAction = new GameAction(name, handler, callTypeCheck);
actions.Add(name, gameAction);
return(gameAction);
}
//加载主函数
private IEnumerator GameInitCore()
{
GameLogger.Log(TAG, "Gameinit start");
yield return(new WaitUntil(IsGameInitUILoaded));
//播放音乐和动画
if (GameManager.Mode == GameMode.Game)
{
IntroAnimator.Play("IntroAnimation");
IntroAudio.Play();
}
//选择加载包模式
switch (GameManager.Mode)
{
case GameMode.Game: currentLoadMask = GameModRunMask.GameBase; break;
case GameMode.Level: currentLoadMask = GameModRunMask.Level | GameModRunMask.LevelLoader; break;
case GameMode.LevelEditor: currentLoadMask = GameModRunMask.LevelEditor | GameModRunMask.Level; break;
case GameMode.MinimumDebug: currentLoadMask = GameModRunMask.GameBase; break;
case GameMode.LoaderDebug: currentLoadMask = GameModRunMask.Level | GameModRunMask.LevelLoader; break;
case GameMode.CoreDebug: currentLoadMask = GameModRunMask.GameCore; break;
}
UIProgressText.text = "Loading";
//加载 core.gameinit.txt 获得要加载的模块
string gameInitTxt = "";
#if UNITY_EDITOR // 编辑器中直接加载
TextAsset gameInitEditorAsset = null;
if (DebugSettings.Instance.GameInitLoadInEditor &&
(gameInitEditorAsset =
UnityEditor.AssetDatabase.LoadAssetAtPath <TextAsset>(
GamePathManager.DEBUG_MOD_FOLDER + "/core.gameinit.txt")) != null)
{
gameInitTxt = gameInitEditorAsset.text;
GameLogger.Log(TAG, "Load gameinit table in Editor : \n" + gameInitTxt);
}
#else
if (false)
{
}
#endif
else
{
//加载 gameinit
string gameinit_txt_path = GamePathManager.GetResRealPath("gameinit", "");
UnityWebRequest request = UnityWebRequest.Get(gameinit_txt_path);
yield return(request.SendWebRequest());
if (!string.IsNullOrEmpty(request.error))
{
GameErrorManager.ThrowGameError(GameError.GameInitReadFailed, "加载 GameInit.txt " + gameinit_txt_path + " 时发生错误：" + request.error);
yield break;
}
gameInitTxt = request.downloadHandler.text;
}
//加载包
yield return(StartCoroutine(GameInitPackages(gameInitTxt)));
//加载模组
yield return(StartCoroutine(GameInitUserMods()));
//加载关卡信息
yield return(StartCoroutine(GameInitLevels()));
UIProgressText.text = "Loading";
//加载游戏内核管理器
GameManager.RegisterManager(typeof(LevelLoader), false);
GameManager.RegisterManager(typeof(LevelManager), false);
GameManager.ICManager = (ICManager)GameManager.RegisterManager(typeof(ICManager), false);
BaseManager ballManager = GameCloneUtils.CloneNewObjectWithParent(
GameManager.FindStaticPrefabs("BallManager"),
GameManager.GameRoot.transform).GetComponent <BaseManager>();
BaseManager camManager = GameCloneUtils.CloneNewObjectWithParent(
GameManager.FindStaticPrefabs("CamManager"),
GameManager.GameRoot.transform).GetComponent <BaseManager>();
GameManager.RegisterManager(ballManager, false);
GameManager.RegisterManager(camManager, false);
//初始化管理器
GameManager.RequestAllManagerInitialization();
//正常情况下，等待动画播放完成
if (GameManager.Mode == GameMode.Game)
{
yield return(new WaitUntil(IsGameInitAnimPlayend));
//hide cp
GameManager.UIManager.UIFadeManager.AddFadeOut(GameObject.Find("GlobalCopyrightText").GetComponent <Text>(), 1.3f, true);
IntroAnimator.Play("IntroAnimationHide");
IntroAudio.Stop();
yield return(new WaitForSeconds(0.8f));
}
yield return(new WaitUntil(GameManager.IsManagersInitFinished));
//初始化模组启动代码（游戏初始化完成）
ModManager.ExecuteModEntry(GameModEntryCodeExecutionAt.AtStart);
yield return(new WaitUntil(GameManager.IsManagersInitFinished));
//分发接管事件
int hC = GameManager.GameMediator.DispatchGlobalEvent(GameEventNames.EVENT_GAME_INIT_TAKE_OVER_CONTROL, "*", (BooleanDelegate)GameInitContinueInit);
if (hC == 0)//无接管
{
if (GameInitContinueInit())
{
//正常模式，加载menulevel
GameManager.NotifyGameCurrentScenseChanged(GameCurrentScense.MenuLevel);
yield return(new WaitUntil(ModManager.IsNoneModLoading));
int initEventHandledCount = GameManager.GameMediator.DispatchGlobalEvent(GameEventNames.EVENT_ENTER_MENULEVEL, "*");
GameManager.GameMediator.UnRegisterGlobalEvent(GameEventNames.EVENT_ENTER_MENULEVEL);
if (initEventHandledCount == 0)
{
GameErrorManager.ThrowGameError(GameError.HandlerLost, "未找到 EVENT_ENTER_MENULEVEL 的下一步事件接收器\n此错误出现原因可能是配置不正确");
GameLogger.Warning(TAG, "None EVENT_GAME_INIT_FINISH handler was found, the game will not continue.");
}
else
{
GameInitHideGameInitUi(true);
}
}
}
else
{
GameInitHideGameInitUi(true);
}
}
/// <summary>
/// 调用操作
/// </summary>
/// <param name="action">目标操作实例</param>
/// <param name="param">调用参数</param>
/// <returns>返回操作调用结果，如果未找到操作，则返回 GameActionCallResult.FailResult </returns>
public GameActionCallResult CallAction(GameAction action, params object[] param)
{
GameErrorManager.LastError = GameError.None;
GameActionCallResult result = GameActionCallResult.FailResult;
if (action == null)
{
GameErrorManager.SetLastErrorAndLog(GameError.ParamNotProvide, TAG, "CallAction action 参数为空");
return(result);
}
if (action.Name == GameAction.Empty.Name)
{
GameErrorManager.SetLastErrorAndLog(GameError.Empty, TAG, "CallAction action 为空");
return(result);
}
if (action.CallTypeCheck != null && action.CallTypeCheck.Length > 0)
{
//参数类型检查
int argCount = action.CallTypeCheck.Length;
if (argCount > param.Length)
{
GameLogger.Warning(TAG, "操作 {0} 至少需要 {1} 个参数", action.Name, argCount);
return(result);
}
string allowType, typeName;
for (int i = 0; i < argCount; i++)
{
allowType = action.CallTypeCheck[i];
if (param[i] == null)
{
if (allowType != "null" &&
(!allowType.Contains("/") && !allowType.Contains("null")))
{
GameLogger.Warning(TAG, "操作 {0} 参数 {1} 不能为null", action.Name, i);
return(result);
}
}
else
{
typeName = param[i].GetType().Name;
if (allowType != typeName &&
(!allowType.Contains("/") && !allowType.Contains(typeName)))
{
GameLogger.Warning(TAG, "操作 {0} 参数 {1} 类型必须是 {2}", action.Name, i, action.CallTypeCheck[i]);
return(result);
}
}
}
}
param = LuaUtils.LuaTableArrayToObjectArray(param);
//GameLogger.Log(TAG, "CallAction {0} -> {1}", action.Name, StringUtils.ValueArrayToString(param));
result = action.GameHandler.CallActionHandler(param);
if (!result.Success)
{
GameLogger.Warning(TAG, "操作 {0} 执行失败 {1}", action.Name, GameErrorManager.LastError);
}
return(result);
}
