Exemple #1
0
 private IEnumerator OnApplicationPause(bool paused)
 {
     if (CoopWebSocketSingleton <KtbWebSocket> .IsValidOpen())
     {
         Logd("OnApplicationPause. pause={0}, is_connect={1}", paused, CoopWebSocketSingleton <KtbWebSocket> .IsValidOpen());
         if (paused)
         {
             if (MonoBehaviourSingleton <CoopNetworkManager> .IsValid())
             {
                 MonoBehaviourSingleton <CoopNetworkManager> .I.LoopBackRoomLeave(true);
             }
             if (PartyManager.IsValidInParty() && !InGameManager.IsReentryNotLeaveParty())
             {
                 Protocol.Force(delegate
                 {
                     MonoBehaviourSingleton <PartyManager> .I.SendLeave(delegate(bool is_leave)
                     {
                         Logd("PartyLeave. {0}", is_leave);
                     });
                 });
             }
             MonoBehaviourSingleton <KtbWebSocket> .I.Close(1000, "Bye!");
         }
         else
         {
             MonoBehaviourSingleton <KtbWebSocket> .I.ClearLastPacketReceivedTime();
         }
     }
     yield break;
 }
 public void KickRoomLeave()
 {
     if (MonoBehaviourSingleton <CoopManager> .IsValid())
     {
         CoopPacket packet = CreateLoopBackRoomLeavedPacket();
         Logd("KickRoomLeave. is_connect={0}", CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected());
         MonoBehaviourSingleton <CoopManager> .I.ForcePacketProcess(packet);
     }
 }
Exemple #3
0
 public void SendInLounge()
 {
     if (CoopWebSocketSingleton <LoungeWebSocket> .IsValidConnected())
     {
         Lounge_Model_MemberLounge lounge_Model_MemberLounge = new Lounge_Model_MemberLounge();
         lounge_Model_MemberLounge.id  = 1005;
         lounge_Model_MemberLounge.cid = MonoBehaviourSingleton <UserInfoManager> .I.userInfo.id;
         MonoBehaviourSingleton <LoungeNetworkManager> .I.SendBroadcast(lounge_Model_MemberLounge, false, null, null);
     }
 }
    public void SwitchOfflinePlay()
    {
        if (isOfflinePlay)
        {
            Logd("already offline.");
        }
        else
        {
            isOfflinePlay = true;
            Logd("SwitchOfflinePlay.");
            if ((!MonoBehaviourSingleton <InGameProgress> .IsValid() || !MonoBehaviourSingleton <InGameProgress> .I.isEnding) && (!QuestManager.IsValidInGameExplore() || (MonoBehaviourSingleton <InGameProgress> .IsValid() && !MonoBehaviourSingleton <InGameProgress> .I.isEnding)))
            {
                if (CoopWebSocketSingleton <KtbWebSocket> .IsValidOpen())
                {
                    MonoBehaviourSingleton <CoopNetworkManager> .I.Close(1000, "Bye!", delegate
                    {
                    });
                }
                if (isOwnerFirstClear && !MonoBehaviourSingleton <CoopManager> .I.coopMyClient.isPartyOwner && !MonoBehaviourSingleton <CoopManager> .I.coopStage.isQuestClose)
                {
                    forceRetire = true;
                }
                else if (NeedsForceLeave() && !MonoBehaviourSingleton <CoopManager> .I.coopStage.isQuestClose)
                {
                    forceRetire = true;
                    if (PartyManager.IsValidInParty())
                    {
                        Protocol.Force(delegate
                        {
                            MonoBehaviourSingleton <PartyManager> .I.SendLeave(delegate(bool is_leave)
                            {
                                Logd("PartyLeave. {0}", is_leave);
                            });
                        });
                    }
                }
                else
                {
                    MonoBehaviourSingleton <CoopManager> .I.coopStage.OnSwitchOfflinePlay();

                    if (PartyManager.IsValidInParty() && !InGameManager.IsReentryNotLeaveParty())
                    {
                        Protocol.Force(delegate
                        {
                            MonoBehaviourSingleton <PartyManager> .I.SendLeave(delegate(bool is_leave)
                            {
                                Logd("PartyLeave. {0}", is_leave);
                            });
                        });
                    }
                    DestroyAllGuestClient();
                }
            }
        }
    }
Exemple #5
0
 public void SendStartArena(int arenaId)
 {
     if (CoopWebSocketSingleton <LoungeWebSocket> .IsValidConnected())
     {
         Lounge_Model_MemberArena lounge_Model_MemberArena = new Lounge_Model_MemberArena();
         lounge_Model_MemberArena.id  = 1005;
         lounge_Model_MemberArena.cid = MonoBehaviourSingleton <UserInfoManager> .I.userInfo.id;
         lounge_Model_MemberArena.aid = arenaId;
         MonoBehaviourSingleton <LoungeNetworkManager> .I.SendBroadcast(lounge_Model_MemberArena, false, null, null);
     }
 }
Exemple #6
0
    private void Update()
    {
        bool flag = Protocol.strict && CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected() && !MonoBehaviourSingleton <KtbWebSocket> .I.IsCompleteSendAll();

        if (visibleConnectingByKtbWebSocket != flag)
        {
            visibleConnectingByKtbWebSocket = flag;
            UpdateConnecting();
        }
        TouchScreen();
    }
Exemple #7
0
 private void Update()
 {
     packetReceiver.OnUpdate();
     if (CoopWebSocketSingleton <LoungeWebSocket> .IsValidConnected())
     {
         float num = Time.get_time() - MonoBehaviourSingleton <LoungeWebSocket> .I.packetSendTime;
         if (num >= 20f)
         {
             Alive();
         }
     }
 }
Exemple #8
0
	private IEnumerator OnApplicationPause(bool paused)
	{
		if (PartyManager.IsValidInParty() && MonoBehaviourSingleton<PartyWebSocket>.IsValid())
		{
			Logd("OnApplicationPause. pause={0}, is_connect={1}", paused, CoopWebSocketSingleton<PartyWebSocket>.IsValidConnected());
			if (paused)
			{
				MonoBehaviourSingleton<PartyWebSocket>.I.Close(1000, "Bye!");
			}
		}
		yield break;
	}
Exemple #9
0
	public void LoopBackRoomLeave()
	{
		CoopPacket coopPacket = CreateLoopBackRoomLeavedPacket();
		Logd("LoopBackRoomLeave. is_connect={0}", CoopWebSocketSingleton<PartyWebSocket>.IsValidConnected());
		if (CoopWebSocketSingleton<PartyWebSocket>.IsValidConnected())
		{
			MonoBehaviourSingleton<PartyWebSocket>.I.ReceivePacketAction(coopPacket);
		}
		else
		{
			packetReceiver.ForcePacketProcess(coopPacket);
		}
	}
Exemple #10
0
 public void SendStartQuest(PartyModel.Party party)
 {
     if (CoopWebSocketSingleton <LoungeWebSocket> .IsValidConnected() && MonoBehaviourSingleton <PartyManager> .IsValid())
     {
         Lounge_Model_MemberQuest lounge_Model_MemberQuest = new Lounge_Model_MemberQuest();
         lounge_Model_MemberQuest.id  = 1005;
         lounge_Model_MemberQuest.cid = MonoBehaviourSingleton <UserInfoManager> .I.userInfo.id;
         int.TryParse(party.id, out lounge_Model_MemberQuest.pid);
         lounge_Model_MemberQuest.qid = party.quest.questId;
         lounge_Model_MemberQuest.h   = (party.ownerUserId == MonoBehaviourSingleton <UserInfoManager> .I.userInfo.id);
         MonoBehaviourSingleton <LoungeNetworkManager> .I.SendBroadcast(lounge_Model_MemberQuest, false, null, null);
     }
 }
 private void UpdateCharaList()
 {
     infoList.Clear();
     if (CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected())
     {
         MonoBehaviourSingleton <FieldManager> .I.SendFieldCharaList(delegate(bool is_success, List <FriendCharaInfo> list)
         {
             if (is_success)
             {
                 infoList = list;
                 SetDirty(UI.GRD_LIST);
                 RefreshUI();
             }
         });
     }
 }
 public void LoopBackRoomLeave(bool is_force = false)
 {
     if (MonoBehaviourSingleton <CoopManager> .IsValid())
     {
         CoopPacket coopPacket = CreateLoopBackRoomLeavedPacket();
         Logd("LoopBackRoomLeave. is_connect={0}", CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected());
         if (CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected() && !is_force)
         {
             MonoBehaviourSingleton <KtbWebSocket> .I.ReceivePacketAction(coopPacket);
         }
         else
         {
             MonoBehaviourSingleton <CoopManager> .I.ForcePacketProcess(coopPacket);
         }
     }
 }
Exemple #13
0
    public void SendStartField()
    {
        if (CoopWebSocketSingleton <LoungeWebSocket> .IsValidConnected() && FieldManager.IsValidInField())
        {
            Lounge_Model_MemberField lounge_Model_MemberField = new Lounge_Model_MemberField();
            lounge_Model_MemberField.id  = 1005;
            lounge_Model_MemberField.cid = MonoBehaviourSingleton <UserInfoManager> .I.userInfo.id;
            int.TryParse(MonoBehaviourSingleton <FieldManager> .I.GetFieldId(), out lounge_Model_MemberField.fid);
            lounge_Model_MemberField.fmid = MonoBehaviourSingleton <FieldManager> .I.GetMapId();

            if (MonoBehaviourSingleton <PartyManager> .I.IsInParty())
            {
                int.TryParse(MonoBehaviourSingleton <PartyManager> .I.GetPartyId(), out lounge_Model_MemberField.pid);
                lounge_Model_MemberField.qid = (int)MonoBehaviourSingleton <PartyManager> .I.GetQuestId();

                lounge_Model_MemberField.h = (MonoBehaviourSingleton <PartyManager> .I.GetOwnerUserId() == MonoBehaviourSingleton <UserInfoManager> .I.userInfo.id);
            }
            MonoBehaviourSingleton <LoungeNetworkManager> .I.SendBroadcast(lounge_Model_MemberField, false, null, null);
        }
    }
 public void DestroyClient(CoopClient client)
 {
     //IL_0075: Unknown result type (might be due to invalid IL or missing references)
     if (!(client == null))
     {
         Logd("destory client:{0}", client.clientId);
         if (CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected())
         {
             MonoBehaviourSingleton <KtbWebSocket> .I.RemoveResendPackets(client.clientId);
         }
         clients.Remove(client);
         client.Clear();
         if (!(client is CoopMyClient))
         {
             Logd("object destory client");
             Object.Destroy(client.get_gameObject());
             client = null;
         }
     }
 }
 public void Gather()
 {
     if (CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected())
     {
         isGathered = true;
         UpdateView();
         MonoBehaviourSingleton <FieldManager> .I.SendFieldGather((int)pointData.pointID, delegate(bool b, FieldGatherRewardList list)
         {
             if (MonoBehaviourSingleton <UIDropAnnounce> .IsValid())
             {
                 int i = 0;
                 for (int count = list.fieldGather.skillItem.Count; i < count; i++)
                 {
                     QuestCompleteReward.SkillItem skillItem = list.fieldGather.skillItem[i];
                     bool is_rare = false;
                     MonoBehaviourSingleton <UIDropAnnounce> .I.Announce(UIDropAnnounce.DropAnnounceInfo.CreateSkillItemInfo((uint)skillItem.skillItemId, skillItem.num, out is_rare));
                     int se_id = 40000154;
                     SoundManager.PlayOneShotUISE(se_id);
                 }
                 int j = 0;
                 for (int count2 = list.fieldGather.equipItem.Count; j < count2; j++)
                 {
                     QuestCompleteReward.EquipItem equipItem = list.fieldGather.equipItem[j];
                     bool is_rare2 = false;
                     MonoBehaviourSingleton <UIDropAnnounce> .I.Announce(UIDropAnnounce.DropAnnounceInfo.CreateEquipItemInfo((uint)equipItem.equipItemId, equipItem.num, out is_rare2));
                     int se_id2 = 40000154;
                     SoundManager.PlayOneShotUISE(se_id2);
                 }
                 int k = 0;
                 for (int count3 = list.fieldGather.item.Count; k < count3; k++)
                 {
                     QuestCompleteReward.Item item = list.fieldGather.item[k];
                     bool is_rare3 = false;
                     MonoBehaviourSingleton <UIDropAnnounce> .I.Announce(UIDropAnnounce.DropAnnounceInfo.CreateItemInfo((uint)item.itemId, item.num, out is_rare3));
                     int se_id3 = (!is_rare3) ? 40000153 : 40000154;
                     SoundManager.PlayOneShotUISE(se_id3);
                 }
             }
         });
     }
 }
 public void Activate()
 {
     if (CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected())
     {
         Logd("Activate failed with online.");
     }
     else if (!isActivate)
     {
         isActivate = true;
         packetReceiver.EraseAllPackets();
         Logd("Activate.");
         if (mapId != 0)
         {
             svSocket.InitStage(mapId, enemyPopParams, nowEnemyId);
         }
         if (MonoBehaviourSingleton <CoopManager> .I.coopStage.isActivateStart)
         {
             MonoBehaviourSingleton <CoopNetworkManager> .I.RoomStageRequest();
         }
     }
 }
Exemple #17
0
    private static void StartCoopOffline(Action <bool, bool, bool> call_back = null)
    {
        if (!CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected())
        {
            StageObjectManager.CreatePlayerInfo createPlayerInfo = MonoBehaviourSingleton <StatusManager> .I.GetCreatePlayerInfo();

            if (createPlayerInfo != null)
            {
                CharaInfo chara_info = createPlayerInfo.charaInfo;
                if (MonoBehaviourSingleton <CoopOfflineManager> .IsValid())
                {
                    MonoBehaviourSingleton <CoopOfflineManager> .I.Activate();
                }
                CoopNetworkManager.ConnectData conn_data = new CoopNetworkManager.ConnectData();
                MonoBehaviourSingleton <CoopNetworkManager> .I.Regist(conn_data, delegate(bool is_regist)
                {
                    if (is_regist)
                    {
                        List <FieldModel.SlotInfo> slot_infos = new List <FieldModel.SlotInfo>
                        {
                            new FieldModel.SlotInfo
                            {
                                userId   = chara_info.userId,
                                userInfo = (chara_info as FriendCharaInfo)
                            }
                        };
                        MonoBehaviourSingleton <CoopManager> .I.coopRoom.Activate(slot_infos);
                    }
                    if (call_back != null)
                    {
                        call_back(true, true, is_regist);
                    }
                });
            }
        }
    }
 public static bool IsValidInOnline()
 {
     return(MonoBehaviourSingleton <CoopManager> .IsValid() && CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected());
 }
Exemple #19
0
    public static Type GetModelType(PACKET_TYPE type)
    {
        switch (type)
        {
        case PACKET_TYPE.REGISTER:
            return(typeof(Coop_Model_Register));

        case PACKET_TYPE.REGISTER_ACK:
            return(typeof(Coop_Model_RegisterACK));

        case PACKET_TYPE.ACK:
            return(typeof(Coop_Model_ACK));

        case PACKET_TYPE.DISCONNECT:
            return(typeof(Coop_Model_Disconnect));

        case PACKET_TYPE.ALIVE:
            return(typeof(Coop_Model_Alive));

        case PACKET_TYPE.ROOM_ENTRY_CLOSE:
            return(typeof(Coop_Model_RoomEntryClose));

        case PACKET_TYPE.ROOM_JOINED:
            return(typeof(Coop_Model_RoomJoined));

        case PACKET_TYPE.ROOM_LEAVED:
            return(typeof(Coop_Model_RoomLeaved));

        case PACKET_TYPE.ROOM_STAGE_CHANGE:
            return(typeof(Coop_Model_RoomStageChange));

        case PACKET_TYPE.ROOM_STAGE_CHANGED:
            return(typeof(Coop_Model_RoomStageChanged));

        case PACKET_TYPE.ROOM_STAGE_REQUEST:
            return(typeof(Coop_Model_RoomStageRequest));

        case PACKET_TYPE.ROOM_STAGE_REQUESTED:
            return(typeof(Coop_Model_RoomStageRequested));

        case PACKET_TYPE.ROOM_STAGE_HOST_CHANGED:
            return(typeof(Coop_Model_RoomStageHostChanged));

        case PACKET_TYPE.BATTLE_START:
            return(typeof(Coop_Model_BattleStart));

        case PACKET_TYPE.ENEMY_POP:
            return(typeof(Coop_Model_EnemyPop));

        case PACKET_TYPE.ENEMY_ATTACK:
            return(typeof(Coop_Model_EnemyAttack));

        case PACKET_TYPE.ENEMY_OUT:
            return(typeof(Coop_Model_EnemyOut));

        case PACKET_TYPE.ENEMY_DEFEAT:
            return(typeof(Coop_Model_EnemyDefeat));

        case PACKET_TYPE.REWARD_GET:
            return(typeof(Coop_Model_RewardGet));

        case PACKET_TYPE.REWARD_PICKUP:
            return(typeof(Coop_Model_RewardPickup));

        case PACKET_TYPE.ENEMY_EXTERMINATION:
            return(typeof(Coop_Model_EnemyExtermination));

        case PACKET_TYPE.UPDATE_BOOST:
            return(typeof(Coop_Model_UpdateBoost));

        case PACKET_TYPE.UPDATE_BOOST_COMPLETE:
            return(typeof(Coop_Model_UpdateBoostComplete));

        case PACKET_TYPE.ROOM_TIME_CHECK:
            return(typeof(Coop_Model_RoomTimeCheck));

        case PACKET_TYPE.ROOM_TIME_UPDATE:
            return(typeof(Coop_Model_RoomTimeUpdate));

        case PACKET_TYPE.EVENT_HAPPEN_QUEST:
            return(typeof(Coop_Model_EventHappenQuest));

        case PACKET_TYPE.CLIENT_STATUS:
            return(typeof(Coop_Model_ClientStatus));

        case PACKET_TYPE.CLIENT_BECAME_HOST:
            return(typeof(Coop_Model_ClientBecameHost));

        case PACKET_TYPE.CLIENT_LOADING_PROGRESS:
            return(typeof(Coop_Model_ClientLoadingProgress));

        case PACKET_TYPE.CLIENT_CHANGE_EQUIP:
            return(typeof(Coop_Model_ClientChangeEquip));

        case PACKET_TYPE.CLIENT_BATTLE_RETIRE:
            return(typeof(Coop_Model_ClientBattleRetire));

        case PACKET_TYPE.CLIENT_SERIES_PROGRESS:
            return(typeof(Coop_Model_ClientSeriesProgress));

        case PACKET_TYPE.ROOM_UPDATE_PORTAL_POINT:
            return(typeof(Coop_Model_RoomUpdatePortalPoint));

        case PACKET_TYPE.ROOM_SYNC_EXPLORE_BOSS:
            return(typeof(Coop_Model_RoomSyncExploreBoss));

        case PACKET_TYPE.ROOM_SYNC_EXPLORE_BOSS_MAP:
            return(typeof(Coop_Model_RoomSyncExploreBossMap));

        case PACKET_TYPE.ROOM_EXPLORE_BOSS_DEAD:
            return(typeof(Coop_Model_RoomExploreBossDead));

        case PACKET_TYPE.ROOM_SYNC_DEFENSE_BATTLE:
            return(typeof(Coop_Model_RoomSyncDefenseBattle));

        case PACKET_TYPE.ROOM_NOTIFY_ENCOUNTER_BOSS:
            return(typeof(Coop_Model_RoomNotifyEncounterBoss));

        case PACKET_TYPE.ROOM_SYNC_PLAYER_STATUS:
            return(typeof(Coop_Model_RoomSyncPlayerStatus));

        case PACKET_TYPE.ROOM_CHAT_STAMP:
            return(typeof(Coop_Model_RoomChatStamp));

        case PACKET_TYPE.ROOM_EXPLORE_BOSS_DAMAGE:
            return(typeof(Coop_Model_RoomExploreBossDamage));

        case PACKET_TYPE.ROOM_EXPLORE_ALIVE:
            return(typeof(Coop_Model_RoomExploreAlive));

        case PACKET_TYPE.ROOM_EXPLORE_ALIVE_REQUEST:
            return(typeof(Coop_Model_RoomExploreAliveRequest));

        case PACKET_TYPE.ROOM_SYNC_ALL_PORTAL_POINT:
            return(typeof(Coop_Model_RoomSyncAllPortalPoint));

        case PACKET_TYPE.ROOM_MOVE_FIELD:
            return(typeof(Coop_Model_RoomMoveField));

        case PACKET_TYPE.ROOM_RUSH_REQUEST:
            return(typeof(Coop_Model_RushRequest));

        case PACKET_TYPE.ROOM_RUSH_REQUESTED:
            return(typeof(Coop_Model_RushRequested));

        case PACKET_TYPE.ROOM_NOTIFY_TRACE_BOSS:
            return(typeof(Coop_Model_RoomNotifyTraceBoss));

        case PACKET_TYPE.STAGE_REQUEST:
            return(typeof(Coop_Model_StageRequest));

        case PACKET_TYPE.STAGE_PLAYER_POP:
            return(typeof(Coop_Model_StagePlayerPop));

        case PACKET_TYPE.STAGE_INFO:
            return(typeof(Coop_Model_StageInfo));

        case PACKET_TYPE.STAGE_RESPONSE_END:
            return(typeof(Coop_Model_StageResponseEnd));

        case PACKET_TYPE.STAGE_QUEST_CLOSE:
            return(typeof(Coop_Model_StageQuestClose));

        case PACKET_TYPE.STAGE_TIMEUP:
            return(typeof(Coop_Model_StageTimeup));

        case PACKET_TYPE.STAGE_CHAT:
            return(typeof(Coop_Model_StageChat));

        case PACKET_TYPE.OBJECT_DESTROY:
            return(typeof(Coop_Model_ObjectDestroy));

        case PACKET_TYPE.OBJECT_ATTACKED_HIT_OWNER:
            return(typeof(Coop_Model_ObjectAttackedHitOwner));

        case PACKET_TYPE.OBJECT_ATTACKED_HIT_FIX:
            return(typeof(Coop_Model_ObjectAttackedHitFix));

        case PACKET_TYPE.OBJECT_KEEP_WAITING_PACKET:
            return(typeof(Coop_Model_ObjectKeepWaitingPacket));

        case PACKET_TYPE.CHARACTER_ACTION_TARGET:
            return(typeof(Coop_Model_CharacterActionTarget));

        case PACKET_TYPE.CHARACTER_UPDATE_ACTION_POSITION:
            return(typeof(Coop_Model_CharacterUpdateActionPosition));

        case PACKET_TYPE.CHARACTER_UPDATE_DIRECTION:
            return(typeof(Coop_Model_CharacterUpdateDirection));

        case PACKET_TYPE.CHARACTER_PERIODIC_SYNC_ACTION_POSITION:
            return(typeof(Coop_Model_CharacterPeriodicSyncActionPosition));

        case PACKET_TYPE.CHARACTER_IDLE:
            return(typeof(Coop_Model_CharacterIdle));

        case PACKET_TYPE.CHARACTER_MOVE_VELOCITY:
            return(typeof(Coop_Model_CharacterMoveVelocity));

        case PACKET_TYPE.CHARACTER_MOVE_VELOCITY_END:
            return(typeof(Coop_Model_CharacterMoveVelocityEnd));

        case PACKET_TYPE.CHARACTER_MOVE_TO_POSITION:
            return(typeof(Coop_Model_CharacterMoveToPosition));

        case PACKET_TYPE.CHARACTER_MOVE_HOMING:
            return(typeof(Coop_Model_CharacterMoveHoming));

        case PACKET_TYPE.CHARACTER_ROTATE:
            return(typeof(Coop_Model_CharacterRotate));

        case PACKET_TYPE.CHARACTER_ROTATE_MOTION:
            return(typeof(Coop_Model_CharacterRotateMotion));

        case PACKET_TYPE.CHARACTER_ATTACK:
            return(typeof(Coop_Model_CharacterAttack));

        case PACKET_TYPE.CHARACTER_CONTINUS_ATTACK_SYNC:
            return(typeof(Coop_Model_CharacterContinusAttackSync));

        case PACKET_TYPE.CHARACTER_BUFFSYNC:
            return(typeof(Coop_Model_CharacterBuffSync));

        case PACKET_TYPE.CHARACTER_BUFFRECEIVE:
            return(typeof(Coop_Model_CharacterBuffReceive));

        case PACKET_TYPE.CHARACTER_BUFFROUTINE:
            return(typeof(Coop_Model_CharacterBuffRoutine));

        case PACKET_TYPE.CHARACTER_REACTION:
            return(typeof(Coop_Model_CharacterReaction));

        case PACKET_TYPE.CHARACTER_REACTION_DELAY:
            return(typeof(Coop_Model_CharacterReactionDelay));

        case PACKET_TYPE.PLAYER_LOAD_COMPLETE:
            return(typeof(Coop_Model_PlayerLoadComplete));

        case PACKET_TYPE.PLAYER_INITIALIZE:
            return(typeof(Coop_Model_PlayerInitialize));

        case PACKET_TYPE.PLAYER_ATTACK_COMBO:
            return(typeof(Coop_Model_PlayerAttackCombo));

        case PACKET_TYPE.PLAYER_CHARGE_RELEASE:
            return(typeof(Coop_Model_PlayerChargeRelease));

        case PACKET_TYPE.PLAYER_RESTRAINT:
            return(typeof(Coop_Model_PlayerRestraint));

        case PACKET_TYPE.PLAYER_RESTRAINT_END:
            return(typeof(Coop_Model_PlayerRestraintEnd));

        case PACKET_TYPE.PLAYER_AVOID:
            return(typeof(Coop_Model_PlayerAvoid));

        case PACKET_TYPE.PLAYER_WARP:
            return(typeof(Coop_Model_PlayerWarp));

        case PACKET_TYPE.PLAYER_BLOW_CLEAR:
            return(typeof(Coop_Model_PlayerBlowClear));

        case PACKET_TYPE.PLAYER_STUNNED_END:
            return(typeof(Coop_Model_PlayerStunnedEnd));

        case PACKET_TYPE.PLAYER_DEAD_COUNT:
            return(typeof(Coop_Model_PlayerDeadCount));

        case PACKET_TYPE.PLAYER_DEAD_STANDUP:
            return(typeof(Coop_Model_PlayerDeadStandup));

        case PACKET_TYPE.PLAYER_GATHER:
            return(typeof(Coop_Model_PlayerGather));

        case PACKET_TYPE.PLAYER_STOP_COUNTER:
            return(typeof(Coop_Model_PlayerStopCounter));

        case PACKET_TYPE.PLAYER_SKILL_ACTION:
            return(typeof(Coop_Model_PlayerSkillAction));

        case PACKET_TYPE.PLAYER_GET_HEAL:
            return(typeof(Coop_Model_PlayerGetHeal));

        case PACKET_TYPE.PLAYER_SPECIAL_ACTION:
            return(typeof(Coop_Model_PlayerSpecialAction));

        case PACKET_TYPE.PLAYER_SHOT_ARROW:
            return(typeof(Coop_Model_PlayerShotArrow));

        case PACKET_TYPE.PLAYER_SHOT_SOUL_ARROW:
            return(typeof(Coop_Model_PlayerShotSoulArrow));

        case PACKET_TYPE.PLAYER_UPDATE_SKILL_INFO:
            return(typeof(Coop_Model_PlayerUpdateSkillInfo));

        case PACKET_TYPE.PLAYER_PRAYER_START:
            return(typeof(Coop_Model_PlayerPrayerStart));

        case PACKET_TYPE.PLAYER_PRAYER_END:
            return(typeof(Coop_Model_PlayerPrayerEnd));

        case PACKET_TYPE.PLAYER_PRAYER_BOOST:
            return(typeof(Coop_Model_PlayerPrayerBoost));

        case PACKET_TYPE.PLAYER_CHANGE_WEAPON:
            return(typeof(Coop_Model_PlayerChangeWeapon));

        case PACKET_TYPE.PLAYER_APPLY_CHANGE_WEAPON:
            return(typeof(Coop_Model_PlayerApplyChangeWeapon));

        case PACKET_TYPE.PLAYER_SETSTATUS:
            return(typeof(Coop_Model_PlayerSetStatus));

        case PACKET_TYPE.PLAYER_GET_RAREDROP:
            return(typeof(Coop_Model_PlayerGetRareDrop));

        case PACKET_TYPE.ENEMY_LOAD_COMPLETE:
            return(typeof(Coop_Model_EnemyLoadComplete));

        case PACKET_TYPE.ENEMY_INITIALIZE:
            return(typeof(Coop_Model_EnemyInitialize));

        case PACKET_TYPE.ENEMY_STEP:
            return(typeof(Coop_Model_EnemyStep));

        case PACKET_TYPE.ENEMY_ANGRY:
            return(typeof(Coop_Model_EnemyAngry));

        case PACKET_TYPE.ENEMY_REVIVE_REGION:
            return(typeof(Coop_Model_EnemyReviveRegion));

        case PACKET_TYPE.ENEMY_WARP:
            return(typeof(Coop_Model_EnemyWarp));

        case PACKET_TYPE.ENEMY_TARGRTSHOT_EVENT:
            return(typeof(Coop_Model_EnemyTargetShotEvent));

        case PACKET_TYPE.ENEMY_RANDOMSHOT_EVENT:
            return(typeof(Coop_Model_EnemyRandomShotEvent));

        case PACKET_TYPE.ENEMY_UPDATE_BLEED_DAMAGE:
            return(typeof(Coop_Model_EnemyUpdateBleedDamage));

        case PACKET_TYPE.ENEMY_UPDATE_SHADOWSEALING:
            return(typeof(Coop_Model_EnemyUpdateShadowSealing));

        case PACKET_TYPE.ENEMY_SYNC_TARGET:
            return(typeof(Coop_Model_EnemySyncTarget));

        case PACKET_TYPE.CHARACTER_DEAD:
            return(typeof(Coop_Model_CharacterDead));

        case PACKET_TYPE.STAGE_REQUEST_POP:
            return(typeof(Coop_Model_StageRequestPop));

        case PACKET_TYPE.CHAT_MESSAGE:
            return(typeof(Coop_Model_StageChatMessage));

        case PACKET_TYPE.STAGE_CHAT_STAMP:
            return(typeof(Coop_Model_StageChatStamp));

        case PACKET_TYPE.PARTY_REGISTER:
            return(typeof(Party_Model_Register));

        case PACKET_TYPE.PARTY_REGISTER_ACK:
            return(typeof(Party_Model_RegisterACK));

        case PACKET_TYPE.PARTY_ROOM_JOINED:
            return(typeof(Party_Model_RoomJoined));

        case PACKET_TYPE.PARTY_ROOM_LEAVED:
            return(typeof(Party_Model_RoomLeaved));

        case PACKET_TYPE.PLAYER_GRABBED:
            return(typeof(Coop_Model_PlayerGrabbed));

        case PACKET_TYPE.PLAYER_GRABBED_END:
            return(typeof(Coop_Model_PlayerGrabbedEnd));

        case PACKET_TYPE.ENEMY_RELEASE_GRABBED_PLAYER:
            return(typeof(Coop_Model_EnemyReleasedGrabbedPlayer));

        case PACKET_TYPE.ENEMY_SHOT:
            return(typeof(Coop_Model_EnemyShot));

        case PACKET_TYPE.CREATE_ICE_FLOOR:
            return(typeof(Coop_Model_CreateIceFloor));

        case PACKET_TYPE.ACTION_MINE:
            return(typeof(Coop_Model_ActionMine));

        case PACKET_TYPE.STAGE_SYNC_PLAYER_RECORD:
            return(typeof(Coop_Model_StageSyncPlayerRecord));

        case PACKET_TYPE.ENEMY_RECOVER_HP:
            return(typeof(Coop_Model_EnemyRecoverHp));

        case PACKET_TYPE.CHARACTER_MOVE_SIDEWAYS:
            return(typeof(Coop_Model_CharacterMoveSideways));

        case PACKET_TYPE.ENEMY_TURN_UP:
            return(typeof(Coop_Model_EnemyTurnUp));

        case PACKET_TYPE.PLAYER_SET_PRESENT_BULLET:
            return(typeof(Coop_Model_PlayerSetPresentBullet));

        case PACKET_TYPE.PLAYER_PICK_PRESENT_BULLET:
            return(typeof(Coop_Model_PlayerPickPresentBullet));

        case PACKET_TYPE.PLAYER_SHOT_ZONE_BULLET:
            return(typeof(Coop_Model_PlayerShotZoneBullet));

        case PACKET_TYPE.PLAYER_SHOT_DECOY_BULLET:
            return(typeof(Coop_Model_PlayerShotDecoyBullet));

        case PACKET_TYPE.PLAYER_EXPLODE_DECOY_BULLET:
            return(typeof(Coop_Model_PlayerExplodeDecoyBullet));

        case PACKET_TYPE.CHARACTER_MOVE_POINT:
            return(typeof(Coop_Model_CharacterMovePoint));

        case PACKET_TYPE.CHARACTER_MOVE_LOOKAT:
            return(typeof(Coop_Model_CharacterMoveLookAt));

        case PACKET_TYPE.PLAYER_CANNON_STANDBY:
            return(typeof(Coop_Model_PlayerCannonStandby));

        case PACKET_TYPE.PLAYER_CANNON_SHOT:
            return(typeof(Coop_Model_PlayerCannonShot));

        case PACKET_TYPE.PLAYER_CANNON_ROTATE:
            return(typeof(Coop_Model_PlayerCannonRotate));

        case PACKET_TYPE.LOUNGE_REGISTER:
            return(typeof(Lounge_Model_Register));

        case PACKET_TYPE.LOUNGE_REGISTER_ACK:
            return(typeof(Lounge_Model_RegisterACK));

        case PACKET_TYPE.LOUNGE_ROOM_JOINED:
            return(typeof(Lounge_Model_RoomJoined));

        case PACKET_TYPE.LOUNGE_ROOM_LEAVED:
            return(typeof(Lounge_Model_RoomLeaved));

        case PACKET_TYPE.LOUNGE_ROOM_ENTRY_CLOSE:
            return(typeof(Lounge_Model_RoomEntryClose));

        case PACKET_TYPE.LOUNGE_ROOM_HOST_CHANGED:
            return(typeof(Lounge_Model_RoomHostChanged));

        case PACKET_TYPE.LOUNGE_ROOM_KICK:
            return(typeof(Lounge_Model_RoomKick));

        case PACKET_TYPE.LOUNGE_ROOM_AFK_KICK:
            return(typeof(Lounge_Model_AFK_Kick));

        case PACKET_TYPE.LOUNGE_ROOM_MOVE:
            return(typeof(Lounge_Model_RoomMove));

        case PACKET_TYPE.LOUNGE_ROOM_POSITION:
            return(typeof(Lounge_Model_RoomPosition));

        case PACKET_TYPE.LOUNGE_ROOM_ACTION:
            return(typeof(Lounge_Model_RoomAction));

        case PACKET_TYPE.LOUNGE_MEMBER_LOUNGE:
            return(typeof(Lounge_Model_MemberLounge));

        case PACKET_TYPE.LOUNGE_MEMBER_FIELD:
            return(typeof(Lounge_Model_MemberField));

        case PACKET_TYPE.LOUNGE_MEMBER_QUEST:
            return(typeof(Lounge_Model_MemberQuest));

        case PACKET_TYPE.LOUNGE_MEMBER_ARENA:
            return(typeof(Lounge_Model_MemberArena));

        case PACKET_TYPE.PLAYER_GET_CHARGE_SKILLGAUGE:
            return(typeof(Coop_Model_PlayerGetChargeSkillGauge));

        case PACKET_TYPE.PLAYER_RESURRECT:
            return(typeof(Coop_Model_PlayerResurrect));

        case PACKET_TYPE.PLAYER_GET_RESURRECT:
            return(typeof(Coop_Model_PlayerGetResurrect));

        case PACKET_TYPE.PLAYER_SPECIAL_ACTION_CONTINUE:
            return(typeof(Coop_Model_PlayerSpecialActionContinue));

        case PACKET_TYPE.PLAYER_SPECIAL_ACTION_GAUGE_SYNC:
            return(typeof(Coop_Model_PlayerSpecialActionGaugeSync));

        case PACKET_TYPE.PLAYER_CHARGE_EXPAND_RELEASE:
            return(typeof(Coop_Model_PlayerChargeExpandRelease));

        case PACKET_TYPE.PLAYER_JUMP_RIZE:
            return(typeof(Coop_Model_PlayerJumpRize));

        case PACKET_TYPE.PLAYER_JUMP_END:
            return(typeof(Coop_Model_PlayerJumpEnd));

        case PACKET_TYPE.PLAYER_SOUL_BOOST:
            return(typeof(Coop_Model_PlayerSoulBoost));

        case PACKET_TYPE.PLAYER_EVOLVE_ACTION_SYNC:
            return(typeof(Coop_Model_PlayerEvolveActionSync));

        case PACKET_TYPE.PLAYER_EVOLVE_SPECIAL_ACTION:
            return(typeof(Coop_Model_PlayerEvolveSpecialAction));

        case PACKET_TYPE.ENEMY_BOSS_POP:
            return(typeof(Coop_Model_EnemyBossPop));

        case PACKET_TYPE.ENEMY_BOSS_ESCAPE:
            return(typeof(Coop_Model_EnemyBossEscape));

        case PACKET_TYPE.ENEMY_BOSS_ALIVE_REQUEST:
            return(typeof(Coop_Model_EnemyBossAliveRequest));

        case PACKET_TYPE.ENEMY_BOSS_ALIVE_REQUESTED:
            return(typeof(Coop_Model_EnemyBossAliveRequested));

        case PACKET_TYPE.PLAYER_SNATCH_POS:
            return(typeof(Coop_Model_PlayerSnatchPos));

        case PACKET_TYPE.PLAYER_SNATCH_MOVE_START:
            return(typeof(Coop_Model_PlayerSnatchMoveStart));

        case PACKET_TYPE.PLAYER_SNATCH_MOVE_END:
            return(typeof(Coop_Model_PlayerSnatchMoveEnd));

        case PACKET_TYPE.WAVEMATCH_INFO:
            return(typeof(Coop_Model_WaveMatchInfo));

        case PACKET_TYPE.PLAYER_PAIR_SWORDS_LASER_END:
            return(typeof(Coop_Model_PlayerPairSwordsLaserEnd));

        case PACKET_TYPE.ENEMY_REGION_NODE_ACTIVATE:
            return(typeof(Coop_Model_EnemyRegionNodeActivate));

        case PACKET_TYPE.PLAYER_SHOT_HEALING_HOMING:
            return(typeof(Coop_Model_PlayerShotHealingHoming));

        case PACKET_TYPE.OBJECT_BULLET_OBSERVABLE_SET:
            return(typeof(Coop_Model_ObjectBulletObservableSet));

        case PACKET_TYPE.OBJECT_BULLET_OBSERVABLE_BROKEN:
            return(typeof(Coop_Model_ObjectBulletObservableBroken));

        default:
            if (CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected())
            {
                Log.Warning(LOG.WEBSOCK, "not found packet type. " + type);
            }
            return(typeof(Coop_Model_Base));
        }
    }
    private IEnumerator DoInitialize()
    {
        yield return((object)null);

        if (MonoBehaviourSingleton <InputManager> .IsValid())
        {
            MonoBehaviourSingleton <InputManager> .I.SetDisable(INPUT_DISABLE_FACTOR.INGAME_GRAB, false);

            MonoBehaviourSingleton <InputManager> .I.SetDisable(INPUT_DISABLE_FACTOR.INGAME_COMMAND, false);
        }
        MonoBehaviourSingleton <InGameManager> .I.ResumeQuestTransferInfo();

        bool keep_record          = false;
        bool is_back_transition   = false;
        bool is_back_online_field = false;

        if (MonoBehaviourSingleton <InGameManager> .I.isTransitionQuestToField)
        {
            MonoBehaviourSingleton <InGameManager> .I.isTransitionQuestToField = false;
            if (MonoBehaviourSingleton <QuestManager> .IsValid())
            {
                MonoBehaviourSingleton <QuestManager> .I.ClearPlayData();
            }
            if (MonoBehaviourSingleton <InGameManager> .I.isQuestGate && MonoBehaviourSingleton <InGameRecorder> .I.isVictory)
            {
                MonoBehaviourSingleton <FieldManager> .I.SetCurrentFieldMapPortalID(MonoBehaviourSingleton <InGameManager> .I.beforePortalID);

                MonoBehaviourSingleton <InGameManager> .I.isGateQuestClear = true;
            }
            else if (MonoBehaviourSingleton <InGameManager> .I.backTransitionInfo != null)
            {
                FieldManager.FieldTransitionInfo trans_info = MonoBehaviourSingleton <InGameManager> .I.backTransitionInfo;
                MonoBehaviourSingleton <FieldManager> .I.SetCurrentFieldMapPortalID(trans_info.portalID, trans_info.mapX, trans_info.mapZ, trans_info.mapDir);

                is_back_transition = true;
                if (MonoBehaviourSingleton <InGameManager> .I.isQuestHappen)
                {
                    is_back_online_field = true;
                }
            }
            MonoBehaviourSingleton <InGameManager> .I.backTransitionInfo = null;
            MonoBehaviourSingleton <InGameManager> .I.isQuestHappen      = false;
            MonoBehaviourSingleton <InGameManager> .I.isQuestPortal      = false;
            MonoBehaviourSingleton <InGameManager> .I.isQuestGate        = false;
            MonoBehaviourSingleton <InGameManager> .I.isStoryPortal      = false;
        }
        bool          matching_flag       = false;
        Action <bool> matching_end_action = delegate(bool is_connect)
        {
            if (!is_connect)
            {
                ((_003CDoInitialize_003Ec__IteratorAE) /*Error near IL_01ba: stateMachine*/)._003C_003Ef__this.coopServerInvalidFlag = true;
            }
            else
            {
                ((_003CDoInitialize_003Ec__IteratorAE) /*Error near IL_01ba: stateMachine*/)._003Cmatching_flag_003E__4 = true;
            }
        };

        if (MonoBehaviourSingleton <InGameManager> .I.isTransitionFieldToQuest)
        {
            MonoBehaviourSingleton <InGameManager> .I.isTransitionFieldToQuest = false;
            if (MonoBehaviourSingleton <InGameManager> .I.isQuestGate)
            {
                if (MonoBehaviourSingleton <FieldManager> .IsValid())
                {
                    MonoBehaviourSingleton <FieldManager> .I.ClearCurrentFieldData();
                }
                if (MonoBehaviourSingleton <QuestManager> .IsValid() && MonoBehaviourSingleton <QuestManager> .I.GetVorgonQuestType() != 0)
                {
                    CoopApp.EnterQuestOffline(delegate(bool is_m, bool is_c, bool is_r, bool is_s)
                    {
                        ((_003CDoInitialize_003Ec__IteratorAE) /*Error near IL_0221: stateMachine*/)._003Cmatching_end_action_003E__5(is_c);
                    });
                }
                else if (MonoBehaviourSingleton <QuestManager> .I.IsForceDefeatQuest())
                {
                    CoopApp.EnterQuest(delegate(bool is_m, bool is_c, bool is_r, bool is_s)
                    {
                        ((_003CDoInitialize_003Ec__IteratorAE) /*Error near IL_0246: stateMachine*/)._003Cmatching_end_action_003E__5(is_c);
                    });
                }
                else
                {
                    CoopApp.EnterQuestRandomMatching(delegate(bool is_m, bool is_c, bool is_r, bool is_s)
                    {
                        ((_003CDoInitialize_003Ec__IteratorAE) /*Error near IL_025c: stateMachine*/)._003Cmatching_end_action_003E__5(is_s);
                    });
                }
            }
            else if (MonoBehaviourSingleton <InGameManager> .I.isQuestHappen)
            {
                int now_stage_id4 = MonoBehaviourSingleton <CoopManager> .I.coopStage.stageId;
                MonoBehaviourSingleton <CoopNetworkManager> .I.RoomStageChange((int)MonoBehaviourSingleton <QuestManager> .I.currentQuestID, 0);

                while (CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected() && now_stage_id4 == MonoBehaviourSingleton <CoopManager> .I.coopStage.stageId)
                {
                    yield return((object)null);
                }
                CoopApp.EnterQuestOnly(delegate
                {
                    ((_003CDoInitialize_003Ec__IteratorAE) /*Error near IL_02e7: stateMachine*/)._003Cmatching_end_action_003E__5(CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected());
                });
                if (MonoBehaviourSingleton <CoopManager> .IsValid())
                {
                    MonoBehaviourSingleton <CoopManager> .I.OnStageChangeInterval();
                }
            }
            else
            {
                if (MonoBehaviourSingleton <FieldManager> .IsValid())
                {
                    MonoBehaviourSingleton <FieldManager> .I.ClearCurrentFieldData();
                }
                CoopApp.EnterQuest(delegate(bool is_m, bool is_c, bool is_r, bool is_s)
                {
                    ((_003CDoInitialize_003Ec__IteratorAE) /*Error near IL_0325: stateMachine*/)._003Cmatching_end_action_003E__5(is_c);
                });
            }
            if (MonoBehaviourSingleton <InGameManager> .I.isQuestGate)
            {
                isEncounterBoss = true;
            }
        }
        else if (MonoBehaviourSingleton <InGameManager> .I.isTransitionQuestToQuest)
        {
            MonoBehaviourSingleton <InGameManager> .I.isTransitionQuestToQuest = false;
            if (MonoBehaviourSingleton <FieldManager> .IsValid())
            {
                MonoBehaviourSingleton <FieldManager> .I.ClearCurrentFieldData();
            }
            CoopApp.EnterPartyQuest(delegate(bool is_m, bool is_c, bool is_r, bool is_s)
            {
                ((_003CDoInitialize_003Ec__IteratorAE) /*Error near IL_0384: stateMachine*/)._003Cmatching_end_action_003E__5(is_c);
            });
        }
        else if (QuestManager.IsValidInGame())
        {
            if (MonoBehaviourSingleton <QuestManager> .I.IsExplore() || MonoBehaviourSingleton <InGameManager> .I.IsRush())
            {
                if (MonoBehaviourSingleton <QuestManager> .I.IsExplore())
                {
                    isTransitionFieldMap = true;
                }
                bool is_stage_change = true;
                if (MonoBehaviourSingleton <InGameManager> .I.isTransitionFieldReentry)
                {
                    MonoBehaviourSingleton <InGameManager> .I.isTransitionFieldReentry = false;
                    isTransitionFieldMap = false;
                    is_stage_change      = false;
                    bool  wait             = true;
                    uint  currentMapID     = MonoBehaviourSingleton <FieldManager> .I.currentMapID;
                    float currentStartMapX = MonoBehaviourSingleton <FieldManager> .I.currentStartMapX;
                    float currentStartMapZ = MonoBehaviourSingleton <FieldManager> .I.currentStartMapZ;
                    CoopApp.EnterPartyField(delegate(bool is_m, bool is_c, bool is_r)
                    {
                        ((_003CDoInitialize_003Ec__IteratorAE) /*Error near IL_0448: stateMachine*/)._003Cwait_003E__8 = false;
                        if (is_r)
                        {
                            ((_003CDoInitialize_003Ec__IteratorAE) /*Error near IL_0448: stateMachine*/)._003Cis_stage_change_003E__7 = true;
                        }
                        if (((_003CDoInitialize_003Ec__IteratorAE) /*Error near IL_0448: stateMachine*/)._003Cbefore_map_id_003E__9 != MonoBehaviourSingleton <FieldManager> .I.currentMapID)
                        {
                            MonoBehaviourSingleton <FieldManager> .I.SetCurrentFieldMapID(((_003CDoInitialize_003Ec__IteratorAE) /*Error near IL_0448: stateMachine*/)._003Cbefore_map_id_003E__9, ((_003CDoInitialize_003Ec__IteratorAE) /*Error near IL_0448: stateMachine*/)._003Cbefore_map_x_003E__10, ((_003CDoInitialize_003Ec__IteratorAE) /*Error near IL_0448: stateMachine*/)._003Cbefore_map_z_003E__11, 0f);
                        }
                    }, true);
                    while (wait)
                    {
                        yield return((object)null);
                    }
                }
                else
                {
                    MonoBehaviourSingleton <CoopManager> .I.coopRoom.SnedMoveField((int)MonoBehaviourSingleton <QuestManager> .I.GetLastPortalId());
                }
                int  mapIndex = 0;
                int  questId  = 0;
                uint dstMapId = MonoBehaviourSingleton <FieldManager> .I.currentMapID;
                if (MonoBehaviourSingleton <QuestManager> .I.IsExplore())
                {
                    questId  = (int)MonoBehaviourSingleton <QuestManager> .I.currentQuestID;
                    mapIndex = MonoBehaviourSingleton <QuestManager> .I.ExploreMapIdToIndex(dstMapId);
                }
                else if (MonoBehaviourSingleton <InGameManager> .I.IsRush())
                {
                    questId = (int)MonoBehaviourSingleton <PartyManager> .I.GetQuestId();

                    mapIndex = MonoBehaviourSingleton <InGameManager> .I.GetRushIndex();
                }
                if (is_stage_change && MonoBehaviourSingleton <CoopManager> .I.coopStage.stageIndex != mapIndex)
                {
                    int now_stage_id2 = MonoBehaviourSingleton <CoopManager> .I.coopStage.stageId;
                    MonoBehaviourSingleton <CoopNetworkManager> .I.RoomStageChange(questId, mapIndex);

                    while (CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected() && now_stage_id2 == MonoBehaviourSingleton <CoopManager> .I.coopStage.stageId)
                    {
                        yield return((object)null);
                    }
                }
                matching_end_action(true);
                keep_record = true;
                if (MonoBehaviourSingleton <InGameManager> .I.IsRush())
                {
                    uint map_id = MonoBehaviourSingleton <QuestManager> .I.GetCurrentMapId();

                    if (MonoBehaviourSingleton <FieldManager> .I.currentMapID != map_id)
                    {
                        MonoBehaviourSingleton <FieldManager> .I.SetCurrentFieldMapID(map_id, 0f, 0f, 0f);
                    }
                }
                if (MonoBehaviourSingleton <CoopManager> .IsValid())
                {
                    MonoBehaviourSingleton <CoopManager> .I.OnStageChangeInterval();
                }
                if (dstMapId == MonoBehaviourSingleton <QuestManager> .I.GetExploreBossBatlleMapId() && isTransitionFieldMap)
                {
                    isEncounterBoss = true;
                }
                if (MonoBehaviourSingleton <InGameManager> .I.isTransitionQuestToFieldExplore)
                {
                    fromBossExplore = true;
                    MonoBehaviourSingleton <InGameManager> .I.isTransitionQuestToFieldExplore = false;
                }
            }
            else
            {
                int now_stage_id3 = MonoBehaviourSingleton <CoopManager> .I.coopStage.stageId;
                MonoBehaviourSingleton <CoopNetworkManager> .I.RoomStageChange((int)MonoBehaviourSingleton <QuestManager> .I.currentQuestID, (int)MonoBehaviourSingleton <QuestManager> .I.currentQuestSeriesIndex);

                while (CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected() && now_stage_id3 == MonoBehaviourSingleton <CoopManager> .I.coopStage.stageId)
                {
                    yield return((object)null);
                }
                matching_end_action(true);
                uint map_id2 = MonoBehaviourSingleton <QuestManager> .I.GetCurrentMapId();

                if (MonoBehaviourSingleton <FieldManager> .I.currentMapID != map_id2)
                {
                    MonoBehaviourSingleton <FieldManager> .I.SetCurrentFieldMapID(map_id2, 0f, 0f, 0f);
                }
                keep_record = true;
                if (MonoBehaviourSingleton <CoopManager> .IsValid())
                {
                    MonoBehaviourSingleton <CoopManager> .I.OnQuestSeriesInterval();
                }
            }
        }
        else if (FieldManager.IsValidInGame())
        {
            isNewField = !MonoBehaviourSingleton <FieldManager> .I.CanJumpToMap(MonoBehaviourSingleton <FieldManager> .I.currentMapID);

            portalID = MonoBehaviourSingleton <FieldManager> .I.currentPortalID;
            if (!is_back_transition && !MonoBehaviourSingleton <InGameManager> .I.isTransitionFieldReentry)
            {
                isTransitionFieldMap = true;
            }
            MonoBehaviourSingleton <InGameManager> .I.isTransitionFieldReentry = false;
            if (is_back_online_field && CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected())
            {
                int now_stage_id = MonoBehaviourSingleton <CoopManager> .I.coopStage.stageId;
                MonoBehaviourSingleton <CoopNetworkManager> .I.RoomStageChange(0, 0);

                while (CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected() && now_stage_id == MonoBehaviourSingleton <CoopManager> .I.coopStage.stageId)
                {
                    yield return((object)null);
                }
                matching_end_action(CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected());
                if (MonoBehaviourSingleton <CoopManager> .IsValid())
                {
                    MonoBehaviourSingleton <CoopManager> .I.OnStageChangeInterval();
                }
            }
            else
            {
                uint portal_id = MonoBehaviourSingleton <FieldManager> .I.currentPortalID;
                CoopApp.EnterField(portal_id, 0u, delegate(bool is_m, bool is_c, bool is_r)
                {
                    ((_003CDoInitialize_003Ec__IteratorAE) /*Error near IL_0889: stateMachine*/)._003Cmatching_end_action_003E__5(is_c);
                });
            }
        }
        while (!matching_flag && !coopServerInvalidFlag)
        {
            yield return((object)null);
        }
        if (coopServerInvalidFlag)
        {
            base.Initialize();
        }
        else
        {
            if (MonoBehaviourSingleton <UIManager> .IsValid() && MonoBehaviourSingleton <UIManager> .I.mainChat != null)
            {
                MonoBehaviourSingleton <UIManager> .I.mainChat.Open(UITransition.TYPE.OPEN);
            }
            if (!keep_record && MonoBehaviourSingleton <InGameRecorder> .IsValid())
            {
                Object.DestroyImmediate(MonoBehaviourSingleton <InGameRecorder> .I);
            }
            MonoBehaviourSingleton <StageManager> .I.UnloadStage();

            yield return((object)MonoBehaviourSingleton <AppMain> .I.UnloadUnusedAssets(true));

            if (MonoBehaviourSingleton <InGameManager> .IsValid())
            {
                MonoBehaviourSingleton <InGameManager> .I.ClearAllDrop();
            }
            MonoBehaviourSingleton <AppMain> .I.mainCamera.get_gameObject().SetActive(true);

            base.Initialize();
        }
    }