using System;
using System.Collections.Generic;
using System.IO;
using UnityEngine;
using XMainClient.UI;
using XMainClient.UI.UICommon;
using XUpdater;
using XUtliPoolLib;
namespace XMainClient
{
internal class XLevelScriptMgr : XSingleton<XLevelScriptMgr>
{
public uint CommandCount = 0u;
private List<LevelCmdDesc> _CmdQueue = new List<LevelCmdDesc>();
private LevelCmdDesc _currentCmd;
public List<string> _externalString = new List<string>();
public List<string> _onceString = new List<string>();
private Dictionary<string, List<LevelCmdDesc>> _LevelScripts = new Dictionary<string, List<LevelCmdDesc>>();
private List<XLevelInfo> _LevelInfos = new List<XLevelInfo>();
public void RunScript(string funcName)
{
XSingleton<XDebug>.singleton.AddGreenLog("add script ", funcName, null, null, null, null);
bool flag = !this._LevelScripts.ContainsKey(funcName);
if (!flag)
{
bool flag2 = this._CmdQueue != null && this._CmdQueue.Count > 0;
if (flag2)
{
XSingleton<XDebug>.singleton.AddGreenLog("script function append", null, null, null, null, null);
}
bool flag3 = this._CmdQueue.Count == 0;
if (flag3)
{
this._currentCmd = null;
}
List<LevelCmdDesc> list = this._LevelScripts[funcName];
for (int i = 0; i < list.Count; i++)
{
list[i].Reset();
this._CmdQueue.Add(list[i]);
}
this.Update();
}
}
public bool IsCurrentCmdFinished()
{
bool flag = this._currentCmd == null;
bool result;
if (flag)
{
result = true;
}
else
{
bool flag2 = this._currentCmd.state == XCmdState.Cmd_Finished;
result = flag2;
}
return result;
}
public void ClearWallInfo()
{
this._LevelInfos.Clear();
}
public void PreloadLevelScript(string file)
{
this.Reset();
this.ClearWallInfo();
Stream stream = XSingleton<XResourceLoaderMgr>.singleton.ReadText("Table/" + file, ".txt", true);
StreamReader streamReader = new StreamReader(stream);
string key = "";
for (;;)
{
string text = streamReader.ReadLine();
bool flag = text == null;
if (flag)
{
break;
}
text = text.Trim();
bool flag2 = text.StartsWith("func:");
if (flag2)
{
string text2 = text.Substring(5);
List<LevelCmdDesc> value = new List<LevelCmdDesc>();
this._LevelScripts.Add(text2, value);
key = text2;
}
bool flag3 = text.StartsWith("talkl");
if (flag3)
{
string[] array = text.Split(XGlobalConfig.TabSeparator);
LevelCmdDesc levelCmdDesc = new LevelCmdDesc();
levelCmdDesc.cmd = LevelCmd.Level_Cmd_TalkL;
levelCmdDesc.Param.Add(array[1]);
levelCmdDesc.Param.Add(array[2]);
bool flag4 = array.Length > 3;
if (flag4)
{
levelCmdDesc.Param.Add(array[3]);
}
this._LevelScripts[key].Add(levelCmdDesc);
}
else
{
bool flag5 = text.StartsWith("talkr");
if (flag5)
{
string[] array2 = text.Split(XGlobalConfig.TabSeparator);
LevelCmdDesc levelCmdDesc2 = new LevelCmdDesc();
levelCmdDesc2.cmd = LevelCmd.Level_Cmd_TalkR;
levelCmdDesc2.Param.Add(array2[1]);
levelCmdDesc2.Param.Add(array2[2]);
bool flag6 = array2.Length > 3;
if (flag6)
{
levelCmdDesc2.Param.Add(array2[3]);
}
this._LevelScripts[key].Add(levelCmdDesc2);
}
else
{
bool flag7 = text.StartsWith("stoptalk");
if (flag7)
{
LevelCmdDesc levelCmdDesc3 = new LevelCmdDesc();
levelCmdDesc3.cmd = LevelCmd.Level_Cmd_Notalk;
this._LevelScripts[key].Add(levelCmdDesc3);
}
else
{
bool flag8 = text.StartsWith("addbuff");
if (flag8)
{
string[] array3 = text.Split(XGlobalConfig.TabSeparator);
bool flag9 = array3.Length >= 4;
if (flag9)
{
LevelCmdDesc levelCmdDesc4 = new LevelCmdDesc();
levelCmdDesc4.cmd = LevelCmd.Level_Cmd_Addbuff;
levelCmdDesc4.Param.Add(array3[1]);
levelCmdDesc4.Param.Add(array3[2]);
levelCmdDesc4.Param.Add(array3[3]);
this._LevelScripts[key].Add(levelCmdDesc4);
}
}
else
{
bool flag10 = text.StartsWith("removebuff");
if (flag10)
{
string[] array4 = text.Split(XGlobalConfig.TabSeparator);
bool flag11 = array4.Length >= 3;
if (flag11)
{
LevelCmdDesc levelCmdDesc5 = new LevelCmdDesc();
levelCmdDesc5.cmd = LevelCmd.Level_Cmd_Removebuff;
levelCmdDesc5.Param.Add(array4[1]);
levelCmdDesc5.Param.Add(array4[2]);
this._LevelScripts[key].Add(levelCmdDesc5);
}
}
else
{
bool flag12 = text.StartsWith("hidebillboard");
if (flag12)
{
string[] array5 = text.Split(XGlobalConfig.TabSeparator);
bool flag13 = array5.Length >= 3;
if (flag13)
{
LevelCmdDesc levelCmdDesc6 = new LevelCmdDesc();
levelCmdDesc6.cmd = LevelCmd.Level_Cmd_HideBillboard;
levelCmdDesc6.Param.Add(array5[1]);
levelCmdDesc6.Param.Add(array5[2]);
this._LevelScripts[key].Add(levelCmdDesc6);
}
}
else
{
bool flag14 = text.StartsWith("changebody");
if (flag14)
{
string[] array6 = text.Split(XGlobalConfig.TabSeparator);
bool flag15 = array6.Length >= 2;
if (flag15)
{
LevelCmdDesc levelCmdDesc7 = new LevelCmdDesc();
levelCmdDesc7.cmd = LevelCmd.Level_Cmd_ChangeBody;
levelCmdDesc7.Param.Add(array6[1]);
this._LevelScripts[key].Add(levelCmdDesc7);
}
}
else
{
bool flag16 = text.StartsWith("justfx");
if (flag16)
{
string[] array7 = text.Split(XGlobalConfig.TabSeparator);
bool flag17 = array7.Length >= 2;
if (flag17)
{
LevelCmdDesc levelCmdDesc8 = new LevelCmdDesc();
levelCmdDesc8.cmd = LevelCmd.Level_Cmd_JustFx;
levelCmdDesc8.Param.Add(array7[1]);
this._LevelScripts[key].Add(levelCmdDesc8);
}
}
else
{
bool flag18 = text.StartsWith("playfx");
if (flag18)
{
string[] array8 = text.Split(XGlobalConfig.TabSeparator);
bool flag19 = array8.Length >= 3;
if (flag19)
{
LevelCmdDesc levelCmdDesc9 = new LevelCmdDesc();
levelCmdDesc9.cmd = LevelCmd.Level_Cmd_PlayFx;
levelCmdDesc9.Param.Add(array8[1]);
levelCmdDesc9.Param.Add(array8[2]);
this._LevelScripts[key].Add(levelCmdDesc9);
}
}
else
{
bool flag20 = text.StartsWith("settutorial");
if (flag20)
{
string[] array9 = text.Split(XGlobalConfig.TabSeparator);
bool flag21 = array9.Length >= 2;
if (flag21)
{
LevelCmdDesc levelCmdDesc10 = new LevelCmdDesc();
levelCmdDesc10.cmd = LevelCmd.Level_Cmd_Tutorial;
levelCmdDesc10.Param.Add(array9[1]);
this._LevelScripts[key].Add(levelCmdDesc10);
}
}
else
{
bool flag22 = text.StartsWith("notice");
if (flag22)
{
string[] array10 = text.Split(XGlobalConfig.TabSeparator);
bool flag23 = array10.Length >= 2;
if (flag23)
{
LevelCmdDesc levelCmdDesc11 = new LevelCmdDesc();
levelCmdDesc11.cmd = LevelCmd.Level_Cmd_Notice;
levelCmdDesc11.Param.Add(array10[1]);
bool flag24 = array10.Length >= 3;
if (flag24)
{
levelCmdDesc11.Param.Add(array10[2]);
}
this._LevelScripts[key].Add(levelCmdDesc11);
}
}
else
{
bool flag25 = text.StartsWith("stopnotice");
if (flag25)
{
LevelCmdDesc levelCmdDesc12 = new LevelCmdDesc();
levelCmdDesc12.cmd = LevelCmd.Level_Cmd_StopNotice;
this._LevelScripts[key].Add(levelCmdDesc12);
}
else
{
bool flag26 = text.StartsWith("opendoor");
if (flag26)
{
string[] array11 = text.Split(XGlobalConfig.TabSeparator);
bool flag27 = array11.Length >= 2;
if (flag27)
{
LevelCmdDesc levelCmdDesc13 = new LevelCmdDesc();
levelCmdDesc13.cmd = LevelCmd.Level_Cmd_Opendoor;
levelCmdDesc13.Param.Add(array11[1]);
bool flag28 = array11.Length > 2;
if (flag28)
{
levelCmdDesc13.Param.Add(array11[2]);
}
this._LevelScripts[key].Add(levelCmdDesc13);
}
}
else
{
bool flag29 = text.StartsWith("killspawn");
if (flag29)
{
string[] array12 = text.Split(XGlobalConfig.TabSeparator);
bool flag30 = array12.Length >= 2;
if (flag30)
{
LevelCmdDesc levelCmdDesc14 = new LevelCmdDesc();
levelCmdDesc14.cmd = LevelCmd.Level_Cmd_KillSpawn;
levelCmdDesc14.Param.Add(array12[1]);
this._LevelScripts[key].Add(levelCmdDesc14);
}
}
else
{
bool flag31 = text.StartsWith("killallspawn");
if (flag31)
{
LevelCmdDesc levelCmdDesc15 = new LevelCmdDesc();
levelCmdDesc15.cmd = LevelCmd.Level_Cmd_KillAllSpawn;
this._LevelScripts[key].Add(levelCmdDesc15);
}
else
{
bool flag32 = text.StartsWith("killally");
if (flag32)
{
LevelCmdDesc levelCmdDesc16 = new LevelCmdDesc();
levelCmdDesc16.cmd = LevelCmd.Level_Cmd_KillAlly;
this._LevelScripts[key].Add(levelCmdDesc16);
}
else
{
bool flag33 = text.StartsWith("killwave");
if (flag33)
{
string[] array13 = text.Split(XGlobalConfig.TabSeparator);
bool flag34 = array13.Length >= 2;
if (flag34)
{
LevelCmdDesc levelCmdDesc17 = new LevelCmdDesc();
levelCmdDesc17.cmd = LevelCmd.Level_Cmd_KillWave;
levelCmdDesc17.Param.Add(array13[1]);
this._LevelScripts[key].Add(levelCmdDesc17);
}
}
else
{
bool flag35 = text.StartsWith("showcutscene");
if (flag35)
{
string[] array14 = text.Split(XGlobalConfig.TabSeparator);
bool flag36 = array14.Length >= 2;
if (flag36)
{
LevelCmdDesc levelCmdDesc18 = new LevelCmdDesc();
levelCmdDesc18.cmd = LevelCmd.Level_Cmd_Cutscene;
levelCmdDesc18.Param.Add(array14[1]);
bool flag37 = array14.Length >= 6;
if (flag37)
{
levelCmdDesc18.Param.Add(array14[2]);
levelCmdDesc18.Param.Add(array14[3]);
levelCmdDesc18.Param.Add(array14[4]);
levelCmdDesc18.Param.Add(array14[5]);
bool flag38 = array14.Length >= 7;
if (flag38)
{
levelCmdDesc18.Param.Add(array14[6]);
}
}
else
{
bool flag39 = array14.Length == 3;
if (flag39)
{
levelCmdDesc18.Param.Add(array14[2]);
}
}
this._LevelScripts[key].Add(levelCmdDesc18);
}
}
else
{
bool flag40 = text.StartsWith("levelupfx");
if (flag40)
{
LevelCmdDesc levelCmdDesc19 = new LevelCmdDesc();
levelCmdDesc19.cmd = LevelCmd.Level_Cmd_LevelupFx;
this._LevelScripts[key].Add(levelCmdDesc19);
}
else
{
bool flag41 = text.StartsWith("continue_UI");
if (flag41)
{
LevelCmdDesc levelCmdDesc20 = new LevelCmdDesc();
levelCmdDesc20.cmd = LevelCmd.Level_Cmd_Continue;
this._LevelScripts[key].Add(levelCmdDesc20);
}
else
{
bool flag42 = text.StartsWith("showskillslot");
if (flag42)
{
string[] array15 = text.Split(XGlobalConfig.TabSeparator);
bool flag43 = array15.Length >= 2;
if (flag43)
{
LevelCmdDesc levelCmdDesc21 = new LevelCmdDesc();
levelCmdDesc21.cmd = LevelCmd.Level_Cmd_ShowSkill;
levelCmdDesc21.Param.Add(array15[1]);
this._LevelScripts[key].Add(levelCmdDesc21);
}
}
else
{
bool flag44 = text.StartsWith("bubble");
if (flag44)
{
string[] array16 = text.Split(XGlobalConfig.TabSeparator);
bool flag45 = array16.Length >= 4;
if (flag45)
{
LevelCmdDesc levelCmdDesc22 = new LevelCmdDesc();
levelCmdDesc22.cmd = LevelCmd.Level_Cmd_Bubble;
levelCmdDesc22.Param.Add(array16[1]);
levelCmdDesc22.Param.Add(array16[2]);
levelCmdDesc22.Param.Add(array16[3]);
this._LevelScripts[key].Add(levelCmdDesc22);
}
}
else
{
bool flag46 = text.StartsWith("showdirection");
if (flag46)
{
string[] array17 = text.Split(XGlobalConfig.TabSeparator);
bool flag47 = array17.Length >= 2;
if (flag47)
{
LevelCmdDesc levelCmdDesc23 = new LevelCmdDesc();
levelCmdDesc23.cmd = LevelCmd.Level_Cmd_Direction;
levelCmdDesc23.Param.Add(array17[1]);
this._LevelScripts[key].Add(levelCmdDesc23);
}
}
else
{
bool flag48 = text.StartsWith("outline");
if (flag48)
{
string[] array18 = text.Split(XGlobalConfig.TabSeparator);
bool flag49 = array18.Length >= 2;
if (flag49)
{
LevelCmdDesc levelCmdDesc24 = new LevelCmdDesc();
levelCmdDesc24.cmd = LevelCmd.Level_Cmd_Outline;
levelCmdDesc24.Param.Add(array18[1]);
this._LevelScripts[key].Add(levelCmdDesc24);
}
}
else
{
bool flag50 = text.StartsWith("clientrecord");
if (flag50)
{
string[] array19 = text.Split(XGlobalConfig.TabSeparator);
bool flag51 = array19.Length >= 2;
if (flag51)
{
LevelCmdDesc levelCmdDesc25 = new LevelCmdDesc();
levelCmdDesc25.cmd = LevelCmd.Level_Cmd_Record;
levelCmdDesc25.Param.Add(array19[1]);
this._LevelScripts[key].Add(levelCmdDesc25);
}
}
else
{
bool flag52 = text.StartsWith("callnewbiehelper");
if (flag52)
{
LevelCmdDesc levelCmdDesc26 = new LevelCmdDesc();
levelCmdDesc26.cmd = LevelCmd.Level_Cmd_NewbieHelper;
this._LevelScripts[key].Add(levelCmdDesc26);
}
else
{
bool flag53 = text.StartsWith("newbienotice");
if (flag53)
{
string[] array20 = text.Split(XGlobalConfig.TabSeparator);
bool flag54 = array20.Length >= 2;
if (flag54)
{
LevelCmdDesc levelCmdDesc27 = new LevelCmdDesc();
levelCmdDesc27.cmd = LevelCmd.Level_Cmd_NewbieNotice;
levelCmdDesc27.Param.Add(array20[1]);
this._LevelScripts[key].Add(levelCmdDesc27);
}
}
else
{
bool flag55 = text.StartsWith("summon");
if (flag55)
{
string[] array21 = text.Split(XGlobalConfig.TabSeparator);
bool flag56 = array21.Length >= 4;
if (flag56)
{
LevelCmdDesc levelCmdDesc28 = new LevelCmdDesc();
levelCmdDesc28.cmd = LevelCmd.Level_Cmd_Summon;
levelCmdDesc28.Param.Add(array21[1]);
levelCmdDesc28.Param.Add(array21[2]);
levelCmdDesc28.Param.Add(array21[3]);
this._LevelScripts[key].Add(levelCmdDesc28);
}
}
else
{
bool flag57 = text.StartsWith("npcpopspeek");
if (flag57)
{
string[] array22 = text.Split(XGlobalConfig.TabSeparator);
bool flag58 = array22.Length >= 5;
if (flag58)
{
LevelCmdDesc levelCmdDesc29 = new LevelCmdDesc();
levelCmdDesc29.cmd = LevelCmd.Level_Cmd_NpcPopSpeek;
levelCmdDesc29.Param.Add(array22[1]);
levelCmdDesc29.Param.Add(array22[2]);
levelCmdDesc29.Param.Add(array22[3]);
levelCmdDesc29.Param.Add(array22[4]);
bool flag59 = array22.Length >= 6;
if (flag59)
{
levelCmdDesc29.Param.Add(array22[5]);
}
this._LevelScripts[key].Add(levelCmdDesc29);
}
}
else
{
bool flag60 = text.StartsWith("aicommand");
if (flag60)
{
string[] array23 = text.Split(XGlobalConfig.TabSeparator);
bool flag61 = array23.Length >= 3;
if (flag61)
{
LevelCmdDesc levelCmdDesc30 = new LevelCmdDesc();
levelCmdDesc30.cmd = LevelCmd.Level_Cmd_SendAICmd;
levelCmdDesc30.Param.Add(array23[1]);
levelCmdDesc30.Param.Add(array23[2]);
bool flag62 = array23.Length >= 4;
if (flag62)
{
levelCmdDesc30.Param.Add(array23[3]);
}
else
{
levelCmdDesc30.Param.Add("0");
}
this._LevelScripts[key].Add(levelCmdDesc30);
}
}
else
{
bool flag63 = text.StartsWith("info");
if (flag63)
{
string[] array24 = text.Split(XGlobalConfig.TabSeparator);
string[] array25 = array24[1].Split(XGlobalConfig.ListSeparator);
XLevelInfo xlevelInfo = new XLevelInfo();
xlevelInfo.infoName = array24[0].Substring(5);
xlevelInfo.x = float.Parse(array25[0]);
xlevelInfo.y = float.Parse(array25[1]);
xlevelInfo.z = float.Parse(array25[2]);
xlevelInfo.face = float.Parse(array25[3]);
bool flag64 = array24.Length >= 3;
if (flag64)
{
xlevelInfo.enable = (array24[2] == "on");
}
bool flag65 = array24.Length >= 4;
if (flag65)
{
xlevelInfo.width = float.Parse(array24[3]);
}
bool flag66 = array24.Length >= 5;
if (flag66)
{
xlevelInfo.height = float.Parse(array24[4]);
}
else
{
xlevelInfo.height = float.MaxValue;
}
bool flag67 = array24.Length >= 6;
if (flag67)
{
xlevelInfo.thickness = float.Parse(array24[5]);
}
this._LevelInfos.Add(xlevelInfo);
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
XSingleton<XResourceLoaderMgr>.singleton.ClearStream(stream);
}
public List<XLevelInfo> GetLevelScriptInfos()
{
return this._LevelInfos;
}
public void Update()
{
bool flag = this._CmdQueue == null || this._CmdQueue.Count == 0;
if (!flag)
{
bool flag2 = this._currentCmd == null || this._currentCmd.state == XCmdState.Cmd_Finished;
if (flag2)
{
this._currentCmd = ((this._CmdQueue.Count > 0) ? this._CmdQueue[0] : null);
bool flag3 = this._currentCmd == null;
if (!flag3)
{
this._CmdQueue.RemoveAt(0);
this.CommandCount += 1u;
this.Execute(this._currentCmd);
}
}
}
}
public void ExecuteNextCmd()
{
bool flag = this._currentCmd != null;
if (flag)
{
this._currentCmd.state = XCmdState.Cmd_Finished;
}
bool flag2 = this._CmdQueue.Count == 0;
if (flag2)
{
this._currentCmd = null;
}
else
{
this._currentCmd = ((this._CmdQueue.Count > 0) ? this._CmdQueue[0] : null);
bool flag3 = this._currentCmd == null;
if (!flag3)
{
this._CmdQueue.RemoveAt(0);
this.Execute(this._currentCmd);
}
}
}
public void Reset()
{
this._externalString.Clear();
this._onceString.Clear();
this._CmdQueue.Clear();
this._currentCmd = null;
this._LevelScripts.Clear();
}
protected void Execute(LevelCmdDesc cmd)
{
switch (cmd.cmd)
{
case LevelCmd.Level_Cmd_TalkL:
{
bool flag = cmd.Param.Count > 2;
if (flag)
{
DlgBase<BattleDramaDlg, BattleDramaDlgBehaviour>.singleton.SetLeftAvatar(cmd.Param[0], cmd.Param[1], cmd.Param[2]);
}
else
{
DlgBase<BattleDramaDlg, BattleDramaDlgBehaviour>.singleton.SetLeftAvatar(cmd.Param[0], cmd.Param[1], string.Empty);
}
this._currentCmd.state = XCmdState.Cmd_In_Process;
break;
}
case LevelCmd.Level_Cmd_TalkR:
{
bool flag2 = cmd.Param.Count > 2;
if (flag2)
{
DlgBase<BattleDramaDlg, BattleDramaDlgBehaviour>.singleton.SetRightAvatar(cmd.Param[0], cmd.Param[1], cmd.Param[2]);
}
else
{
DlgBase<BattleDramaDlg, BattleDramaDlgBehaviour>.singleton.SetRightAvatar(cmd.Param[0], cmd.Param[1], string.Empty);
}
this._currentCmd.state = XCmdState.Cmd_In_Process;
break;
}
case LevelCmd.Level_Cmd_Notalk:
XSingleton<XLevelSpawnMgr>.singleton.BossExtarScriptExecuting = false;
DlgBase<BattleDramaDlg, BattleDramaDlgBehaviour>.singleton.SetVisible(false, true);
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
case LevelCmd.Level_Cmd_Addbuff:
{
XSingleton<XShell>.singleton.Pause = false;
int buffID = int.Parse(cmd.Param[1]);
int buffLevel = int.Parse(cmd.Param[2]);
int num = int.Parse(cmd.Param[0]);
bool flag3 = num == 0;
if (flag3)
{
XBuffAddEventArgs @event = XEventPool<XBuffAddEventArgs>.GetEvent();
@event.xBuffDesc.BuffID = buffID;
@event.xBuffDesc.BuffLevel = buffLevel;
@event.Firer = XSingleton<XEntityMgr>.singleton.Player;
@event.xBuffDesc.CasterID = XSingleton<XEntityMgr>.singleton.Player.ID;
XSingleton<XEventMgr>.singleton.FireEvent(@event);
}
else
{
List<XEntity> opponent = XSingleton<XEntityMgr>.singleton.GetOpponent(XSingleton<XEntityMgr>.singleton.Player);
for (int i = 0; i < opponent.Count; i++)
{
bool flag4 = (ulong)opponent[i].TypeID == (ulong)((long)num);
if (flag4)
{
XBuffAddEventArgs event2 = XEventPool<XBuffAddEventArgs>.GetEvent();
event2.xBuffDesc.BuffID = buffID;
event2.xBuffDesc.BuffLevel = buffLevel;
event2.Firer = opponent[i];
event2.xBuffDesc.CasterID = opponent[i].ID;
XSingleton<XEventMgr>.singleton.FireEvent(event2);
}
}
}
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
}
case LevelCmd.Level_Cmd_Tutorial:
{
bool needTutorail = XSingleton<XTutorialMgr>.singleton.NeedTutorail;
if (needTutorail)
{
XSingleton<XTutorialMgr>.singleton.SetExternalString(cmd.Param[0]);
}
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
}
case LevelCmd.Level_Cmd_Notice:
{
float duration = 3f;
bool flag5 = cmd.Param.Count > 1;
if (flag5)
{
duration = float.Parse(cmd.Param[1]);
}
bool flag6 = DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.IsLoaded();
if (flag6)
{
DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.ShowNotice(cmd.Param[0], duration, 1f);
}
bool flag7 = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded();
if (flag7)
{
DlgBase<BattleMain, BattleMainBehaviour>.singleton.ShowNotice(cmd.Param[0], duration, 1f);
}
bool flag8 = this._currentCmd != null;
if (flag8)
{
this._currentCmd.state = XCmdState.Cmd_Finished;
}
break;
}
case LevelCmd.Level_Cmd_StopNotice:
{
bool flag9 = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded();
if (flag9)
{
DlgBase<BattleMain, BattleMainBehaviour>.singleton.StopNotice();
}
bool flag10 = DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.IsLoaded();
if (flag10)
{
DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.StopNotice();
}
bool flag11 = this._currentCmd != null;
if (flag11)
{
this._currentCmd.state = XCmdState.Cmd_Finished;
}
break;
}
case LevelCmd.Level_Cmd_Opendoor:
{
GameObject gameObject = GameObject.Find(XSingleton<XSceneMgr>.singleton.GetSceneDynamicPrefix(XSingleton<XScene>.singleton.SceneID));
Transform transform = XSingleton<XCommon>.singleton.FindChildRecursively(gameObject.transform, cmd.Param[0]);
bool flag12 = transform == null;
if (flag12)
{
XSingleton<XDebug>.singleton.AddErrorLog("Wall no exists: ", cmd.Param[0], null, null, null, null);
}
bool flag13 = cmd.Param.Count > 1;
if (flag13)
{
bool flag14 = cmd.Param[1] == "on";
if (flag14)
{
transform.gameObject.SetActive(true);
bool flag15 = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded();
if (flag15)
{
DlgBase<BattleMain, BattleMainBehaviour>.singleton.IndicateHandler.MiniMapAddDoor(transform);
}
bool flag16 = DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.IsLoaded();
if (flag16)
{
DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.IndicateHandler.MiniMapAddDoor(transform);
}
this.SwitchWallState(cmd.Param[0], true);
}
else
{
bool flag17 = cmd.Param[1].Length == 0 || cmd.Param[1] == "off";
if (flag17)
{
transform.gameObject.SetActive(false);
this.SwitchWallState(cmd.Param[0], false);
}
}
}
else
{
transform.gameObject.SetActive(false);
this.SwitchWallState(cmd.Param[0], false);
}
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
}
case LevelCmd.Level_Cmd_Cutscene:
{
XSingleton<XDebug>.singleton.AddLog("play cutscene ", cmd.Param[0], null, null, null, null, XDebugColor.XDebug_None);
bool flag18 = cmd.Param.Count == 6;
if (flag18)
{
XSingleton<XCutScene>.singleton.GeneralMonsterID = uint.Parse(cmd.Param[5]);
}
else
{
bool flag19 = cmd.Param.Count == 2;
if (flag19)
{
XSingleton<XCutScene>.singleton.GeneralMonsterID = uint.Parse(cmd.Param[1]);
}
}
bool flag20 = this.CommandCount == 1u;
if (flag20)
{
XSingleton<XCutScene>.singleton.Start(cmd.Param[0], false, true);
}
else
{
XSingleton<XCutScene>.singleton.Start(cmd.Param[0], true, true);
}
bool flag21 = cmd.Param.Count >= 5;
if (flag21)
{
float num2 = float.Parse(cmd.Param[1]);
float num3 = float.Parse(cmd.Param[2]);
float num4 = float.Parse(cmd.Param[3]);
XSingleton<XCutScene>.singleton.EndWithDir = float.Parse(cmd.Param[4]);
XSingleton<XCutScene>.singleton.EndWithPos = new Vector3(num2, num3, num4);
}
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
}
case LevelCmd.Level_Cmd_LevelupFx:
{
XPlayer player = XSingleton<XEntityMgr>.singleton.Player;
XSingleton<XFxMgr>.singleton.CreateAndPlay(XSingleton<XGlobalConfig>.singleton.GetValue("LevelupFx"), player.EngineObject, Vector3.zero, Vector3.one, 1f, true, 5f, true);
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
}
case LevelCmd.Level_Cmd_ShowSkill:
{
int index = int.Parse(cmd.Param[0]);
bool flag22 = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded();
if (flag22)
{
DlgBase<BattleMain, BattleMainBehaviour>.singleton.SkillHandler.ShowSkillSlot(index);
}
XSingleton<XTutorialHelper>.singleton.MeetEnemy = false;
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
}
case LevelCmd.Level_Cmd_KillSpawn:
XSingleton<XDebug>.singleton.AddErrorLog("找小邹: kill spawn", null, null, null, null, null);
XSingleton<XLevelSpawnMgr>.singleton.CurrentSpawner.KillSpawn(int.Parse(cmd.Param[0]));
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
case LevelCmd.Level_Cmd_KillAlly:
XSingleton<XDebug>.singleton.AddErrorLog("找小邹: kill ally", null, null, null, null, null);
XSingleton<XEntityMgr>.singleton.KillAlly(XSingleton<XEntityMgr>.singleton.Player);
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
case LevelCmd.Level_Cmd_KillWave:
{
int num5 = int.Parse(cmd.Param[0]);
List<XEntity> all = XSingleton<XEntityMgr>.singleton.GetAll();
for (int j = 0; j < all.Count; j++)
{
bool flag23 = num5 == all[j].Wave;
if (flag23)
{
all[j].Attributes.ForceDeath();
}
}
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
}
case LevelCmd.Level_Cmd_Direction:
{
GameObject gameObject2 = GameObject.Find(XSingleton<XSceneMgr>.singleton.GetSceneDynamicPrefix(XSingleton<XScene>.singleton.SceneID));
Transform transform2 = XSingleton<XCommon>.singleton.FindChildRecursively(gameObject2.transform, cmd.Param[0]);
bool flag24 = transform2 != null;
if (flag24)
{
bool flag25 = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded();
if (flag25)
{
DlgBase<BattleMain, BattleMainBehaviour>.singleton.IndicateHandler.ShowDirection(transform2);
}
}
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
}
case LevelCmd.Level_Cmd_Outline:
{
int num6 = int.Parse(cmd.Param[0]);
List<XEntity> opponent2 = XSingleton<XEntityMgr>.singleton.GetOpponent(XSingleton<XEntityMgr>.singleton.Player);
for (int k = 0; k < opponent2.Count; k++)
{
bool flag26 = opponent2[k].Wave == num6;
if (flag26)
{
XHighlightEventArgs event3 = XEventPool<XHighlightEventArgs>.GetEvent();
event3.Enabled = true;
event3.Firer = opponent2[k];
XSingleton<XEventMgr>.singleton.FireEvent(event3);
}
}
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
}
case LevelCmd.Level_Cmd_Record:
XSingleton<XOperationRecord>.singleton.DoScriptRecord(cmd.Param[0]);
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
case LevelCmd.Level_Cmd_Continue:
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
case LevelCmd.Level_Cmd_NewbieHelper:
{
uint num7 = 0u;
uint num8 = 0u;
uint num9 = 0u;
XPlayer player2 = XSingleton<XEntityMgr>.singleton.Player;
XBoss boss = XSingleton<XEntityMgr>.singleton.Boss;
bool flag27 = player2 == null || boss == null;
if (!flag27)
{
bool flag28 = num7 > 0u;
if (flag28)
{
XSingleton<XLevelSpawnMgr>.singleton.SpawnExternalMonster(num7, new Vector3(104.3f, 9.93f, 104.5f), 0);
}
bool flag29 = num8 > 0u;
if (flag29)
{
XSingleton<XLevelSpawnMgr>.singleton.SpawnExternalMonster(num8, new Vector3(106f, 9.93f, 105f), 0);
}
bool flag30 = num9 > 0u;
if (flag30)
{
XSingleton<XLevelSpawnMgr>.singleton.SpawnExternalMonster(num9, new Vector3(103.83f, 9.93f, 101.12f), 0);
}
bool flag31 = this._currentCmd != null;
if (flag31)
{
this._currentCmd.state = XCmdState.Cmd_Finished;
}
}
break;
}
case LevelCmd.Level_Cmd_NewbieNotice:
{
bool flag32 = DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.IsLoaded();
if (flag32)
{
DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.ShowBigNotice(cmd.Param[0]);
}
bool flag33 = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded();
if (flag33)
{
DlgBase<BattleMain, BattleMainBehaviour>.singleton.ShowBigNotice(cmd.Param[0], true);
}
bool flag34 = this._currentCmd != null;
if (flag34)
{
this._currentCmd.state = XCmdState.Cmd_In_Process;
}
break;
}
case LevelCmd.Level_Cmd_Removebuff:
{
XSingleton<XShell>.singleton.Pause = false;
int xBuffID = int.Parse(cmd.Param[1]);
int num10 = int.Parse(cmd.Param[0]);
bool flag35 = num10 == 0;
if (flag35)
{
XBuffRemoveEventArgs event4 = XEventPool<XBuffRemoveEventArgs>.GetEvent();
event4.xBuffID = xBuffID;
event4.Firer = XSingleton<XEntityMgr>.singleton.Player;
XSingleton<XEventMgr>.singleton.FireEvent(event4);
}
else
{
List<XEntity> opponent3 = XSingleton<XEntityMgr>.singleton.GetOpponent(XSingleton<XEntityMgr>.singleton.Player);
for (int l = 0; l < opponent3.Count; l++)
{
bool flag36 = (ulong)opponent3[l].TypeID == (ulong)((long)num10);
if (flag36)
{
XBuffRemoveEventArgs event5 = XEventPool<XBuffRemoveEventArgs>.GetEvent();
event5.xBuffID = xBuffID;
event5.Firer = opponent3[l];
XSingleton<XEventMgr>.singleton.FireEvent(event5);
}
}
}
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
}
case LevelCmd.Level_Cmd_Summon:
{
uint enemyID = uint.Parse(cmd.Param[0]);
uint num11 = uint.Parse(cmd.Param[2]);
Vector3 pos = Vector3.zero;
int rot = 0;
bool flag37 = cmd.Param[1] == "[player]";
if (flag37)
{
pos = XSingleton<XEntityMgr>.singleton.Player.EngineObject.Position;
}
else
{
int num12 = int.Parse(cmd.Param[1]);
List<XEntity> opponent4 = XSingleton<XEntityMgr>.singleton.GetOpponent(XSingleton<XEntityMgr>.singleton.Player);
for (int m = 0; m < opponent4.Count; m++)
{
bool flag38 = (ulong)opponent4[m].TypeID == (ulong)((long)num12);
if (flag38)
{
pos = opponent4[m].EngineObject.Position;
rot = (int)opponent4[m].EngineObject.Rotation.eulerAngles.y;
}
}
}
int num13 = 0;
while ((long)num13 < (long)((ulong)num11))
{
XSingleton<XLevelSpawnMgr>.singleton.SpawnExternalMonster(enemyID, pos, rot);
num13++;
}
bool flag39 = this._currentCmd != null;
if (flag39)
{
this._currentCmd.state = XCmdState.Cmd_Finished;
}
break;
}
case LevelCmd.Level_Cmd_KillAllSpawn:
XSingleton<XLevelFinishMgr>.singleton.KillAllOpponent();
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
case LevelCmd.Level_Cmd_NpcPopSpeek:
{
int type = int.Parse(cmd.Param[0]);
int npcid = int.Parse(cmd.Param[1]);
string text = cmd.Param[2];
float time = float.Parse(cmd.Param[3]);
string fmod = "";
bool flag40 = cmd.Param.Count >= 5;
if (flag40)
{
fmod = cmd.Param[4];
}
DlgBase<NpcPopSpeekView, DlgBehaviourBase>.singleton.ShowNpcPopSpeek(type, npcid, text, time, fmod);
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
}
case LevelCmd.Level_Cmd_SendAICmd:
{
int num14 = int.Parse(cmd.Param[0]);
string eventArg = cmd.Param[1];
int typeId = int.Parse(cmd.Param[2]);
List<XEntity> list = new List<XEntity>();
bool flag41 = num14 == -1;
if (flag41)
{
bool flag42 = XSingleton<XLevelSpawnMgr>.singleton.AIGlobal != null && XSingleton<XLevelSpawnMgr>.singleton.AIGlobal.Host != null;
if (flag42)
{
list.Add(XSingleton<XLevelSpawnMgr>.singleton.AIGlobal.Host);
}
}
else
{
List<XEntity> ally = XSingleton<XEntityMgr>.singleton.GetAlly(XSingleton<XEntityMgr>.singleton.Player);
List<XEntity> opponent5 = XSingleton<XEntityMgr>.singleton.GetOpponent(XSingleton<XEntityMgr>.singleton.Player);
for (int n = 0; n < ally.Count; n++)
{
bool flag43 = ally[n].Attributes.TypeID == (uint)num14;
if (flag43)
{
list.Add(ally[n]);
}
}
for (int num15 = 0; num15 < opponent5.Count; num15++)
{
bool flag44 = opponent5[num15].Attributes.TypeID == (uint)num14;
if (flag44)
{
list.Add(opponent5[num15]);
}
}
}
for (int num16 = 0; num16 < list.Count; num16++)
{
XAIEventArgs event6 = XEventPool<XAIEventArgs>.GetEvent();
event6.DepracatedPass = false;
event6.Firer = list[num16];
event6.EventType = 1;
event6.EventArg = eventArg;
event6.TypeId = typeId;
XSingleton<XEventMgr>.singleton.FireEvent(event6, 0.05f);
}
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
}
case LevelCmd.Level_Cmd_Bubble:
XSingleton<XLevelSpawnMgr>.singleton.CurrentSpawner.ShowBubble(int.Parse(cmd.Param[0]), cmd.Param[1], float.Parse(cmd.Param[2]));
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
case LevelCmd.Level_Cmd_HideBillboard:
{
int num17 = int.Parse(cmd.Param[0]);
float hidetime = float.Parse(cmd.Param[1]);
List<XEntity> opponent6 = XSingleton<XEntityMgr>.singleton.GetOpponent(XSingleton<XEntityMgr>.singleton.Player);
for (int num18 = 0; num18 < opponent6.Count; num18++)
{
bool flag45 = (ulong)opponent6[num18].TypeID == (ulong)((long)num17);
if (flag45)
{
XBillboardHideEventArgs event7 = XEventPool<XBillboardHideEventArgs>.GetEvent();
event7.hidetime = hidetime;
event7.Firer = opponent6[num18];
XSingleton<XEventMgr>.singleton.FireEvent(event7);
}
}
break;
}
case LevelCmd.Level_Cmd_ChangeBody:
{
XPlayer player3 = XSingleton<XEntityMgr>.singleton.Player;
bool flag46 = player3 != null;
if (flag46)
{
player3.OnTransform(uint.Parse(cmd.Param[0]));
}
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
}
case LevelCmd.Level_Cmd_JustFx:
this.DoScriptJustFx(cmd.Param);
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
case LevelCmd.Level_Cmd_PlayFx:
{
Transform transform3 = XSingleton<UIManager>.singleton.UIRoot.Find("Camera").transform;
bool flag47 = transform3 != null;
if (flag47)
{
XSingleton<XFxMgr>.singleton.CreateAndPlay(cmd.Param[0], transform3, Vector3.zero, Vector3.one, 1f, true, float.Parse(cmd.Param[1]), true);
}
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
}
default:
this._currentCmd.state = XCmdState.Cmd_Finished;
break;
}
}
public void SetExternalString(string str, bool bOnce)
{
if (bOnce)
{
bool flag = this._onceString.Contains(str);
if (!flag)
{
this._externalString.Add(str);
this._onceString.Add(str);
}
}
else
{
this._externalString.Add(str);
}
}
public bool QueryExternalString(string str, bool autoRemove)
{
bool flag = false;
foreach (string a in this._externalString)
{
bool flag2 = a == str;
if (flag2)
{
flag = true;
break;
}
}
bool flag3 = flag && autoRemove;
if (flag3)
{
this._externalString.Remove(str);
}
return flag;
}
public bool IsTalkScript(string funcName)
{
bool flag = !this._LevelScripts.ContainsKey(funcName);
bool result;
if (flag)
{
XSingleton<XDebug>.singleton.AddErrorLog("invalid script func", null, null, null, null, null);
result = false;
}
else
{
LevelCmdDesc levelCmdDesc = this._LevelScripts[funcName][0];
bool flag2 = levelCmdDesc.cmd == LevelCmd.Level_Cmd_TalkL || levelCmdDesc.cmd == LevelCmd.Level_Cmd_TalkR;
result = flag2;
}
return result;
}
protected void SwitchWallState(string name, bool enabled)
{
for (int i = 0; i < this._LevelInfos.Count; i++)
{
bool flag = this._LevelInfos[i].infoName == name;
if (flag)
{
this._LevelInfos[i].enable = enabled;
}
}
}
public void SyncWallState(string name, bool isOn)
{
this.SetClientWallState(name, isOn);
this.SwitchWallState(name, isOn);
}
public void SetClientWallState(string name, bool isOn)
{
GameObject gameObject = GameObject.Find(XSingleton<XSceneMgr>.singleton.GetSceneDynamicPrefix(XSingleton<XScene>.singleton.SceneID));
bool flag = gameObject == null;
if (!flag)
{
Transform transform = XSingleton<XCommon>.singleton.FindChildRecursively(gameObject.transform, name);
bool flag2 = transform == null;
if (flag2)
{
XSingleton<XDebug>.singleton.AddErrorLog("Wall no exists: ", name, null, null, null, null);
}
else
{
transform.gameObject.SetActive(isOn);
}
}
}
public void ResetAirWallState()
{
for (int i = 0; i < this._LevelInfos.Count; i++)
{
this.SetClientWallState(this._LevelInfos[i].infoName, this._LevelInfos[i].enable);
}
}
public void DoScriptJustFx(List<string> param)
{
float time = float.Parse(param[0]);
XBattleDocument specificDocument = XDocuments.GetSpecificDocument<XBattleDocument>(XBattleDocument.uuID);
int num = 1 << LayerMask.NameToLayer("Resources");
num |= 1 << LayerMask.NameToLayer("QualityHigh");
num |= 1 << LayerMask.NameToLayer("QualityNormal");
num |= 1 << LayerMask.NameToLayer("QualityCullDistance");
specificDocument.SetCameraLayer(num, time);
}
}
}