Beispiel #1
0
    // Token: 0x06001282 RID: 4738 RVA: 0x00209900 File Offset: 0x00207B00
    public void CheckIndemnify(MessagePacket MP)
    {
        byte b = MP.ReadByte(-1);

        this.TriggerTime = MP.ReadLong(-1);
        for (int i = 0; i < 4; i++)
        {
            this.ResourceCache[i] = MP.ReadLong(-1);
            if (this.ResourceCache[i] != 0L && this.bTriggered == INDEMNIFY_STATE.None)
            {
                this.bTriggered = INDEMNIFY_STATE.Triggered;
            }
        }
        if (b != 0 && this.bTriggered == INDEMNIFY_STATE.Triggered)
        {
            if (this.CheckTriggered(this.TriggerTime))
            {
                this.bTriggered = INDEMNIFY_STATE.ShowButton;
            }
        }
        else
        {
            FBAdvanceManager.Instance.TriggerFbEvent(EFBEvent.SUPPLY_CHEST, 0L, 0UL);
        }
        this.SaveTriggerTime();
        if (!this.HasIndemnify() && this.bTriggered != INDEMNIFY_STATE.None)
        {
            this.bTriggered = INDEMNIFY_STATE.None;
            GUIManager.Instance.UpdateUI(EGUIWindow.Door, 21, 0);
        }
        GameManager.OnRefresh(NetworkNews.Refresh_IndemnifyResources, null);
        Indemnify.CheckShowIndemnify();
        Debug.LogWarning("CheckIndemnify");
        Debug.LogWarning(this.ResourceCache[0].ToString());
        Debug.LogWarning(this.ResourceCache[1].ToString());
        Debug.LogWarning(this.ResourceCache[2].ToString());
        Debug.LogWarning(this.ResourceCache[3].ToString());
    }
Beispiel #2
0
    // Token: 0x06002194 RID: 8596 RVA: 0x004003B4 File Offset: 0x003FE5B4
    public void Renew(byte[] Subject, byte[] meg)
    {
        GAME_PLAYER_NEWS game_PLAYER_NEWS = (GAME_PLAYER_NEWS)Subject[0];

        switch (game_PLAYER_NEWS)
        {
        case GAME_PLAYER_NEWS.Network_Update:
        {
            NetworkNews networkNews = (NetworkNews)Subject[1];
            if (networkNews != NetworkNews.Login)
            {
                if (networkNews == NetworkNews.Refresh_Hospital || networkNews == NetworkNews.Refresh_Trap)
                {
                    DataManager.msgBuffer[0] = 9;
                    this.notifyNews(DataManager.msgBuffer);
                }
            }
            else if (this.WorldInputLockCount > 0)
            {
                for (int i = 0; i < this.WorldInputLockCount; i++)
                {
                    GUIManager.Instance.ShowUILock(EUILock.Normal);
                }
            }
            break;
        }

        default:
            if (game_PLAYER_NEWS == GAME_PLAYER_NEWS.ORIGIN_CameraReSetPressPosition)
            {
                this.cameraController.ReSetPressPosition();
            }
            break;

        case GAME_PLAYER_NEWS.ORIGIN_DoorOpenUp:
        case GAME_PLAYER_NEWS.ORIGIN_WildOpenUp:
        {
            DataManager.msgBuffer[0] = 12;
            this.notifyNews(DataManager.msgBuffer);
            DataManager.Instance.WorldCameraPos   = Camera.main.transform.position;
            DataManager.Instance.WorldCameraLimit = this.cameraController.Limit;
            DataManager.Instance.bWorldF          = false;
            byte leveL = (DataManager.StageDataController._stageMode == StageMode.Corps) ? ((byte)(DataManager.StageDataController.StageRecord[2] + 1)) : DataManager.StageDataController.currentChapterID;
            this.cameraController.SetCameraState(CameraState.Area, leveL, true);
            AudioManager.Instance.PlayUISFX(UIKind.ArmyExpewdition);
            break;
        }

        case GAME_PLAYER_NEWS.ORIGIN_DoorWild:
            if (this.nextWorldMode == WorldMode.OpenUp)
            {
                DataManager.Instance.bWorldF = true;
                if (DataManager.StageDataController._stageMode == StageMode.Corps)
                {
                    DataManager.msgBuffer[0] = 2;
                    this.notifyNews(DataManager.msgBuffer);
                }
                else
                {
                    GUIManager.Instance.pDVMgr.NextTransitions(eTrans.BEGIN, eTransFunc.DoorWild);
                }
                GUIManager.Instance.m_HUDMessage.MapHud.ThisTransform.gameObject.SetActive(false);
            }
            break;

        case GAME_PLAYER_NEWS.ORIGIN_DoorNext:
            if (this.nextWorldMode == WorldMode.OpenUp)
            {
                StageManager stageDataController = DataManager.StageDataController;
                stageDataController.currentChapterID          += 1;
                DataManager.StageDataController.currentPointID = (ushort)(DataManager.StageDataController.currentChapterID - 1) * GameConstants.StagePointNum[(int)DataManager.StageDataController._stageMode] + 1;
                DataManager.StageDataController.SaveUserStage(DataManager.StageDataController._stageMode);
                DataManager.Instance.lastBattleResult = -1;
                this.cameraController.SetCameraPos((int)DataManager.StageDataController.currentChapterID);
                DataManager.msgBuffer[0] = 6;
                this.notifyNews(DataManager.msgBuffer);
                GUIManager.Instance.m_HUDMessage.MapHud.AddChapterMsg();
            }
            break;

        case GAME_PLAYER_NEWS.ORIGIN_DoorLast:
            if (this.nextWorldMode == WorldMode.OpenUp)
            {
                StageManager stageDataController2 = DataManager.StageDataController;
                stageDataController2.currentChapterID         -= 1;
                DataManager.StageDataController.currentPointID = (ushort)DataManager.StageDataController.currentChapterID * GameConstants.StagePointNum[(int)DataManager.StageDataController._stageMode];
                DataManager.StageDataController.SaveUserStage(DataManager.StageDataController._stageMode);
                DataManager.Instance.lastBattleResult = -1;
                this.cameraController.SetCameraPos((int)DataManager.StageDataController.currentChapterID);
                DataManager.msgBuffer[0] = 6;
                this.notifyNews(DataManager.msgBuffer);
                GUIManager.Instance.m_HUDMessage.MapHud.AddChapterMsg();
            }
            break;

        case GAME_PLAYER_NEWS.ORIGIN_CameraOpenUp:
            if (DataManager.StageDataController._stageMode != StageMode.Corps || DataManager.StageDataController.isNotFirstInChapter[2] == 1)
            {
                this.SwitchWorldMode(WorldMode.OpenUp);
                DataManager.msgBuffer[0] = 14;
                GameManager.notifyObservers(1, 0, DataManager.msgBuffer);
                GUIManager.Instance.m_HUDMessage.MapHud.AddChapterMsg();
                GUIManager.Instance.m_HUDMessage.MapHud.ShowMsg();
                GUIManager.Instance.m_HUDMessage.MapHud.ShowTime = 0.8f;
                GUIManager.Instance.m_HUDMessage.MapHud.StartCountdown();
                this.WorldUIQueueLockRelease();
            }
            else
            {
                DataManager.msgBuffer[0] = 47;
                GameManager.notifyObservers(1, 0, DataManager.msgBuffer);
            }
            break;

        case GAME_PLAYER_NEWS.ORIGIN_CameraWild:
            if (DataManager.StageDataController._stageMode == StageMode.Corps)
            {
                this.cameraController.Limit    = DataManager.Instance.WorldCameraLimit;
                this.cameraController.TmpV3Pos = DataManager.Instance.WorldCameraPos;
                this.cameraController.SetCameraState(CameraState.World, 0, false);
            }
            else if (DataManager.StageDataController._stageMode == StageMode.Count)
            {
                this.cameraController.SetCameraState(CameraState.World, 0, false);
                GUIManager.Instance.pDVMgr.NextTransitions(eTrans.END, eTransFunc.Max);
            }
            else
            {
                DataManager.Instance.WorldCameraLimit = 0f;
                this.cameraController.SetCamerPos_Out();
                GUIManager.Instance.pDVMgr.NextTransitions(eTrans.END, eTransFunc.Max);
            }
            break;

        case GAME_PLAYER_NEWS.ORIGIN_CameraForce:
            if (DataManager.StageDataController._stageMode == StageMode.Corps && DataManager.StageDataController.isNotFirstInChapter[2] == 0)
            {
                this.cloudController.MapClick();
            }
            break;

        case GAME_PLAYER_NEWS.ORIGIN_CloudOpenUp:
            this.SwitchWorldMode(WorldMode.OpenUp);
            DataManager.msgBuffer[0] = 14;
            GameManager.notifyObservers(1, 0, DataManager.msgBuffer);
            break;

        case GAME_PLAYER_NEWS.ORIGIN_LockInput:
            this.worldflag |= 1;
            break;

        case GAME_PLAYER_NEWS.ORIGIN_UnLockInput:
            this.worldflag &= -2;
            break;

        case GAME_PLAYER_NEWS.ORIGIN_CloseStageStory:
        case GAME_PLAYER_NEWS.ORIGIN_CloseTreasureInfo:
            if (DataManager.StageDataController.isNotFirstInChapter[(int)DataManager.StageDataController._stageMode] == 0)
            {
                if (DataManager.StageDataController._stageMode == StageMode.Corps)
                {
                    this.worldflag |= 4;
                    if (DataManager.StageDataController.StageRecord[2] == 2 && DataManager.StageDataController.StageRecord[1] == 0 && DataManager.StageDataController.StageRecord[0] == 18)
                    {
                        this.worldflag |= 2;
                    }
                }
                else if ((ushort)(DataManager.StageDataController.currentChapterID + 1) * GameConstants.LinePointNum[(int)DataManager.StageDataController._stageMode] < DataManager.StageDataController.limitRecord[(int)DataManager.StageDataController._stageMode])
                {
                    StageManager stageDataController3 = DataManager.StageDataController;
                    stageDataController3.currentChapterID += 1;
                }
                DataManager.DataBuffer[0] = 4;
                this.Renew(DataManager.DataBuffer, null);
                if (Subject[0] == 39)
                {
                    this.WorldUIQueueLockRelease();
                }
            }
            else if (DataManager.StageDataController.StageRecord[(int)DataManager.StageDataController._stageMode] == DataManager.StageDataController.limitRecord[(int)DataManager.StageDataController._stageMode])
            {
                if (DataManager.StageDataController._stageMode == StageMode.Corps)
                {
                    this.worldflag |= 4;
                }
                DataManager.DataBuffer[0] = 4;
                this.Renew(DataManager.DataBuffer, null);
                if (Subject[0] == 39)
                {
                    this.WorldUIQueueLockRelease();
                }
            }
            else
            {
                if (DataManager.StageDataController._stageMode == StageMode.Full && DataManager.StageDataController.StageRecord[0] == 18)
                {
                    this.worldflag |= 2;
                }
                DataManager.DataBuffer[0] = 0;
                DataManager.DataBuffer[1] = 1;
                this.notifyObservers(DataManager.DataBuffer, null);
                DataManager.msgBuffer[0] = 13;
                this.notifyNews(DataManager.msgBuffer);
                this.worldState = TickSubject.Ready;
                if (DataManager.StageDataController._stageMode == StageMode.Full || DataManager.StageDataController._stageMode == StageMode.Lean)
                {
                    this.WorldUIQueueLockRelease();
                }
            }
            GUIManager.Instance.m_HUDMessage.MapHud.AddChapterMsg();
            if (DataManager.StageDataController._stageMode != StageMode.Corps || this.nextWorldMode == WorldMode.OpenUp)
            {
                GUIManager.Instance.m_HUDMessage.MapHud.ShowMsg();
            }
            GUIManager.Instance.m_HUDMessage.MapHud.ShowTime = 0.8f;
            GUIManager.Instance.m_HUDMessage.MapHud.StartCountdown();
            break;

        case GAME_PLAYER_NEWS.ORIGIN_CameraStateWild:
            if ((this.worldflag & 4) != 0)
            {
                this.worldflag &= -5;
                GUIManager.Instance.OpenMenu(EGUIWindow.UI_NewTerritory, (int)DataManager.StageDataController.StageRecord[2], 0, false, true, false);
            }
            else
            {
                this.WorldUIQueueLockRelease();
            }
            NewbieManager.EntryTest();
            Indemnify.CheckShowIndemnify();
            ActivityGiftManager.Instance.CheckShowActivityGiftEffect();
            DataManager.msgBuffer[0] = 47;
            GameManager.notifyObservers(1, 0, DataManager.msgBuffer);
            break;

        case GAME_PLAYER_NEWS.ORIGIN_OpenUpWild:
            this.SwitchWorldMode(WorldMode.Wild);
            break;

        case GAME_PLAYER_NEWS.ORIGIN_OpenUpContinue:
            DataManager.msgBuffer[0] = 4;
            this.notifyNews(DataManager.msgBuffer);
            break;

        case GAME_PLAYER_NEWS.ORIGIN_ManorGuildCameraMove:
        {
            BuildManorData recordByKey    = DataManager.Instance.BuildManorData.GetRecordByKey(GameConstants.ConvertBytesToUShort(DataManager.msgBuffer, 3));
            float          num            = ((recordByKey.bPosionX <= 30000) ? ((float)recordByKey.bPosionX) : ((float)recordByKey.bPosionX - 65535f)) * 0.01f;
            float          y              = ((recordByKey.bPosionY <= 32768) ? ((float)recordByKey.bPosionY) : ((float)recordByKey.bPosionY - 65535f)) * 0.01f;
            float          num2           = ((recordByKey.bPosionZ <= 32768) ? ((float)recordByKey.bPosionZ) : ((float)recordByKey.bPosionZ - 65535f)) * 0.01f;
            Vector3        targetPosition = new Vector3(num + 4f, y, num2 - 23.5f);
            this.cameraController.CameraMoveTarget(CameraState.Build, targetPosition);
            DataManager.msgBuffer[0] = 11;
            this.notifyNews(DataManager.msgBuffer);
            break;
        }

        case GAME_PLAYER_NEWS.ORIGIN_ArneaGuildCameraMove:
        {
            Vector3 targetPosition2 = new Vector3(119.07f, 30.8f, 78.78f);
            this.cameraController.CameraMoveTarget(CameraState.Build, targetPosition2);
            break;
        }

        case GAME_PLAYER_NEWS.ORIGIN_DugoutGuildCameraMove:
        {
            Vector3 targetPosition3 = new Vector3(-22.22f, 13.39f, -22.2f);
            this.cameraController.CameraMoveTarget(CameraState.Build, targetPosition3);
            break;
        }

        case GAME_PLAYER_NEWS.ORIGIN_BlackMarketGuildCameraMove:
        {
            Vector3 targetPosition4 = new Vector3(51.5f, -0.5f, 87.44f);
            this.cameraController.CameraMoveTarget(CameraState.Build, targetPosition4);
            break;
        }

        case GAME_PLAYER_NEWS.ORIGIN_WarlobbyGuildCameraMove:
            if (GUIManager.Instance.BuildingData.ManorGride[6] != null)
            {
                this.cameraController.CameraMoveTarget(CameraState.Build, GUIManager.Instance.BuildingData.ManorGride[6].position);
            }
            break;

        case GAME_PLAYER_NEWS.ORIGIN_CasinoGuildCameraMove:
        {
            Vector3 targetPosition5 = new Vector3(131.5f, 9.1f, -7.7f);
            this.cameraController.CameraMoveTarget(CameraState.Build, targetPosition5);
            break;
        }

        case GAME_PLAYER_NEWS.ORIGIN_LaboratoryGuildCameraMove:
        {
            Vector3 targetPosition6 = new Vector3(-5.2f, 0.6f, 130.1f);
            this.cameraController.CameraMoveTarget(CameraState.Build, targetPosition6);
            break;
        }

        case GAME_PLAYER_NEWS.ORIGIN_PetListGuildCameraMove:
        {
            Vector3 targetPosition7 = new Vector3(193.63f, 16.2f, -14.29f);
            this.cameraController.CameraMoveTarget(CameraState.Build, targetPosition7);
            break;
        }

        case GAME_PLAYER_NEWS.ORIGIN_UpdateBuild:
            DataManager.msgBuffer[0] = 5;
            this.notifyNews(DataManager.msgBuffer);
            break;

        case GAME_PLAYER_NEWS.ORIGIN_UpdateOpenUp:
            if (this.nextWorldMode == WorldMode.OpenUp)
            {
                this.UpdateWorldState();
            }
            break;

        case GAME_PLAYER_NEWS.ORIGIN_ChangeStageMode:
            if (this.nextWorldMode == WorldMode.OpenUp)
            {
                if (Subject[1] == 1)
                {
                    DataManager.StageDataController.resetStageMode(StageMode.Full);
                }
                else if (Subject[1] == 2)
                {
                    DataManager.StageDataController.resetStageMode(StageMode.Lean);
                }
                else if (Subject[1] == 3)
                {
                    DataManager.StageDataController.resetStageMode(StageMode.Dare);
                    if (DataManager.StageDataController.StageRecord[3] >= GameConstants.StagePointNum[3] && !NewbieManager.IsLeadNewbiePass)
                    {
                        DataManager.StageDataController.currentChapterID = 1;
                        DataManager.StageDataController.currentPointID   = (ushort)(DataManager.StageDataController.currentChapterID - 1) * GameConstants.StagePointNum[(int)DataManager.StageDataController._stageMode] + 1;
                        DataManager.StageDataController.SaveUserStage(DataManager.StageDataController._stageMode);
                    }
                }
                DataManager.StageDataController.SaveUserStageMode(DataManager.StageDataController._stageMode);
                DataManager.Instance.lastBattleResult = -1;
                this.cameraController.SetCameraPos((int)DataManager.StageDataController.currentChapterID);
                this.UpdateWorldState();
                GUIManager.Instance.m_HUDMessage.MapHud.AddChapterMsg();
                GUIManager.Instance.m_HUDMessage.MapHud.ShowMsg();
                GUIManager.Instance.m_HUDMessage.MapHud.ShowTime = 0.8f;
                GUIManager.Instance.m_HUDMessage.MapHud.StartCountdown();
            }
            break;

        case GAME_PLAYER_NEWS.ORIGIN_HideCampain:
            DataManager.msgBuffer[0] = 8;
            this.notifyNews(DataManager.msgBuffer);
            break;

        case GAME_PLAYER_NEWS.ORIGIN_OpenUpFirstRun:
            if (DataManager.StageDataController._stageMode == StageMode.Full)
            {
                if ((this.worldflag & 2) != 0)
                {
                    NewbieManager.CheckTeach(ETeachKind.ELITE_STAGE, null, true);
                    this.worldflag &= -3;
                }
                if ((DataManager.StageDataController.StageRecord[0] != 0 || !NewbieManager.CheckTeach(ETeachKind.BATTLE_BEFORE, null, true)) && NewbieManager.CheckPutOnEquipTeach())
                {
                    NewbieManager.CheckTeach(ETeachKind.PUTON_EQUIP, null, false);
                }
            }
            else if (DataManager.StageDataController._stageMode == StageMode.Corps)
            {
                NewbieManager.CheckTeach(ETeachKind.WAR_SCOUT, this, true);
            }
            break;

        case GAME_PLAYER_NEWS.ORIGIN_BuildOpenUp:
            if (DataManager.StageDataController._stageMode != StageMode.Corps || DataManager.StageDataController.isNotFirstInChapter[2] == 1)
            {
                if (DataManager.StageDataController._stageMode == StageMode.Dare && DataManager.StageDataController.StageRecord[3] >= GameConstants.StagePointNum[3] && !NewbieManager.IsLeadNewbiePass)
                {
                    DataManager.StageDataController.currentChapterID = 1;
                    DataManager.StageDataController.currentPointID   = (ushort)(DataManager.StageDataController.currentChapterID - 1) * GameConstants.StagePointNum[(int)DataManager.StageDataController._stageMode] + 1;
                    DataManager.StageDataController.SaveUserStage(DataManager.StageDataController._stageMode);
                }
                DataManager.Instance.WorldCameraPos   = GameConstants.GoldGuy;
                DataManager.Instance.WorldCameraLimit = 0f;
                DataManager.Instance.bWorldF          = false;
                this.cameraController.SetCameraPos((int)DataManager.StageDataController.currentChapterID);
                this.SwitchWorldMode(WorldMode.OpenUp);
                DataManager.msgBuffer[0] = 14;
                GameManager.notifyObservers(1, 0, DataManager.msgBuffer);
            }
            break;

        case GAME_PLAYER_NEWS.ORIGIN_UIQueueLock:
            this.WorldUIQueueLock();
            break;

        case GAME_PLAYER_NEWS.ORIGIN_UIQueueLockRelease:
            this.WorldUIQueueLockRelease();
            break;

        case GAME_PLAYER_NEWS.ORIGIN_UIInputLock:
            this.WorldInputLockCount++;
            GUIManager.Instance.ShowUILock(EUILock.Normal);
            break;

        case GAME_PLAYER_NEWS.ORIGIN_UIInputLockRelease:
            this.WorldInputLockCount--;
            GUIManager.Instance.HideUILock(EUILock.Normal);
            break;
        }
    }
Beispiel #3
0
    // Token: 0x060015C1 RID: 5569 RVA: 0x0024FD34 File Offset: 0x0024DF34
    protected override void UpdateNews(byte[] meg)
    {
        GAME_PLAYER_NEWS game_PLAYER_NEWS = (GAME_PLAYER_NEWS)meg[0];

        switch (game_PLAYER_NEWS)
        {
        case GAME_PLAYER_NEWS.ORIGIN_OpenStage:
            if (GUIManager.Instance.m_WindowStack.Count == 0)
            {
                if (DataManager.StageDataController._stageMode == StageMode.Corps)
                {
                    this.doorController.OpenMenu(EGUIWindow.UI_StageSelect2, (int)((DataManager.Instance.lastBattleResult != 1) ? (DataManager.StageDataController.StageRecord[2] + 1) : DataManager.StageDataController.StageRecord[2]), 0, false);
                }
                else
                {
                    this.doorController.OpenMenu(EGUIWindow.UI_StageSelect, (int)DataManager.StageDataController.currentChapterID, 0, false);
                }
            }
            break;

        case GAME_PLAYER_NEWS.ORIGIN_OpenStageStory:
            if (meg[1] == 1)
            {
                this.doorController.CloseMenu(false);
            }
            if (DataManager.StageDataController._stageMode == StageMode.Corps)
            {
                this.doorController.OpenMenu(EGUIWindow.UI_StageStory, (int)((meg[1] != 1) ? (DataManager.StageDataController.StageRecord[2] + 1) : DataManager.StageDataController.StageRecord[2]), (int)meg[1], true);
            }
            else
            {
                this.doorController.OpenMenu(EGUIWindow.UI_StageStory, (int)DataManager.StageDataController.currentChapterID, (int)meg[1], true);
            }
            GUIManager.Instance.m_HUDMessage.MapHud.SkipMsg();
            break;

        case GAME_PLAYER_NEWS.ORIGIN_CloseStageStory:
            this.doorController.CloseMenu(false);
            DataManager.msgBuffer[0] = 16;
            this.worldController.Renew(DataManager.msgBuffer, null);
            break;

        case GAME_PLAYER_NEWS.ORIGIN_OpenStageInfo:
            this.doorController.OpenMenu(EGUIWindow.UI_StageInfo, 0, 0, true);
            break;

        case GAME_PLAYER_NEWS.ORIGIN_OpenPve:
            this.doorController.m_GroundInfo.OpenPvePanel(true, DataManager.StageDataController.StageRecord[2] + 1);
            break;

        case GAME_PLAYER_NEWS.ORIGIN_CameraStateWild:
            this.worldController.Renew(meg, null);
            break;

        case GAME_PLAYER_NEWS.ORIGIN_CloseNewTerritory:
            GUIManager.Instance.CloseMenu(EGUIWindow.UI_NewTerritory);
            if (NewbieManager.CheckGoldGuy())
            {
                NewbieManager.CheckTeach(ETeachKind.GOLDGUY, null, false);
            }
            else if (NewbieManager.CheckArmyHole(true))
            {
                NewbieManager.CheckTeach(ETeachKind.ARMY_HOLE, null, false);
            }
            else
            {
                NewbieManager.CheckGambleNormal();
            }
            this.worldController.WorldUIQueueLockRelease();
            this.worldController.WorldUIQueueLockRelease();
            break;

        case GAME_PLAYER_NEWS.ORIGIN_OpenUpWild:
            GUIManager.Instance.CloseCheckCrystalBox();
            GUIManager.Instance.CloseOKCancelBox();
            this.doorController.CloseMenu(true);
            DataManager.msgBuffer[0] = 21;
            this.worldController.Renew(DataManager.msgBuffer, null);
            break;

        default:
            switch (game_PLAYER_NEWS)
            {
            case GAME_PLAYER_NEWS.Network_Update:
                if (meg[1] == 43)
                {
                    this.doorController.ViewKingdom();
                }
                else if (meg[1] == 42 && DataManager.MapDataController.FocusKingdomID != DataManager.MapDataController.OtherKingdomData.kingdomID)
                {
                    DataManager.MapDataController.FocusKingdomID = DataManager.MapDataController.OtherKingdomData.kingdomID;
                    GUIManager.Instance.HideUILock(EUILock.Normal);
                    DataManager.MapDataController.gotoKingdomState = 0;
                }
                this.worldController.Renew(meg, null);
                return;

            case GAME_PLAYER_NEWS.HeroTalk_Close:
                if (NewbieManager.IsNewbie)
                {
                    NewbieManager.Get().NextStep();
                }
                Indemnify.UpdateNetwork(meg);
                return;
            }
            this.worldController.Renew(meg, null);
            break;

        case GAME_PLAYER_NEWS.ORIGIN_OpenBuild:
            GUIManager.Instance.BuildingData.OpenUI(GameConstants.ConvertBytesToUShort(meg, 1), this.doorController);
            DataManager.msgBuffer[0] = 23;
            this.worldController.Renew(DataManager.msgBuffer, null);
            break;

        case GAME_PLAYER_NEWS.ORIGIN_UpdateBuild:
            this.worldController.Renew(meg, null);
            break;

        case GAME_PLAYER_NEWS.ORIGIN_CloseBuild:
            this.doorController.CloseMenu(false);
            DataManager.msgBuffer[0] = 33;
            this.worldController.Renew(DataManager.msgBuffer, null);
            break;

        case GAME_PLAYER_NEWS.ORIGIN_ChangeStageMode:
            if (this.worldController && this.doorController)
            {
                UIStageSelect uistageSelect = GUIManager.Instance.FindMenu(EGUIWindow.UI_StageSelect) as UIStageSelect;
                if (uistageSelect)
                {
                    if (uistageSelect.NFlash.activeSelf)
                    {
                        meg[1] = 1;
                    }
                    else if (uistageSelect.EFlash.activeSelf)
                    {
                        meg[1] = 2;
                    }
                    else if (uistageSelect.AFlash.activeSelf)
                    {
                        meg[1] = 3;
                    }
                    this.worldController.Renew(meg, null);
                }
            }
            break;

        case GAME_PLAYER_NEWS.ORIGIN_OpenTreasureInfo:
            if (meg[1] == 1)
            {
                this.doorController.CloseMenu(false);
            }
            this.doorController.OpenMenu(EGUIWindow.UI_ChapterRewards, (int)DataManager.StageDataController.currentChapterID, (int)meg[1], true);
            break;

        case GAME_PLAYER_NEWS.ORIGIN_CloseTreasureInfo:
            this.doorController.CloseMenu(false);
            DataManager.msgBuffer[0] = 39;
            this.worldController.Renew(DataManager.msgBuffer, null);
            break;

        case GAME_PLAYER_NEWS.ORIGIN_SetCastleLevel:
            AssetManager.OriginSetCastleLevel(meg[1], meg[2]);
            break;

        case GAME_PLAYER_NEWS.ORIGIN_ShowUI:
            this.HideUI = 0;
            this.doorController.m_TopLayer.gameObject.SetActive(true);
            for (int i = 1; i < GUIManager.Instance.m_WindowsTransform.childCount; i++)
            {
                GUIManager.Instance.m_WindowsTransform.GetChild(i).gameObject.SetActive(true);
            }
            if (GUIManager.Instance.m_WindowStack.Count == 0)
            {
                if (DataManager.StageDataController._stageMode == StageMode.Corps)
                {
                    GUIWindow x = GUIManager.Instance.FindMenu(EGUIWindow.UI_StageSelect2);
                    if (x == null)
                    {
                        this.doorController.OpenMenu(EGUIWindow.UI_StageSelect2, (int)((DataManager.Instance.lastBattleResult != 1) ? (DataManager.StageDataController.StageRecord[2] + 1) : DataManager.StageDataController.StageRecord[2]), 0, false);
                    }
                }
                else
                {
                    GUIWindow x = GUIManager.Instance.FindMenu(EGUIWindow.UI_StageSelect);
                    if (x == null)
                    {
                        this.doorController.OpenMenu(EGUIWindow.UI_StageSelect, (int)DataManager.StageDataController.currentChapterID, 0, false);
                    }
                }
            }
            this.doorController.HideFightButton();
            break;

        case GAME_PLAYER_NEWS.ORIGIN_HideUI:
            this.HideUI = 1;
            this.doorController.m_TopLayer.gameObject.SetActive(false);
            for (int j = 1; j < GUIManager.Instance.m_WindowsTransform.childCount; j++)
            {
                GUIManager.Instance.m_WindowsTransform.GetChild(j).gameObject.SetActive(false);
            }
            break;

        case GAME_PLAYER_NEWS.ORIGIN_BackgroundEnable:
            if (this.worldController && !this.worldController.gameObject.activeSelf)
            {
                this.worldController.gameObject.SetActive(true);
                if (LandWalkerManager.alive)
                {
                    LandWalkerManager.Instance.enabled = true;
                }
                GameManager.RemoveObserver(0, 3, this);
            }
            break;

        case GAME_PLAYER_NEWS.ORIGIN_BackgroundDisable:
            if (this.worldController && this.worldController.gameObject.activeSelf)
            {
                this.worldController.gameObject.SetActive(false);
                if (LandWalkerManager.alive)
                {
                    LandWalkerManager.Instance.enabled = false;
                }
                GameManager.RegisterObserver(0, 3, this, 1);
            }
            break;

        case GAME_PLAYER_NEWS.ORIGIN_DoorFadeOut:
            if (this.doorController != null)
            {
                this.doorController.BeginFadeInOut();
            }
            break;

        case GAME_PLAYER_NEWS.ORIGIN_DoorFadeIn:
            if (this.doorController != null)
            {
                this.doorController.BeginFadeIn();
            }
            break;
        }
    }