protected override bool HandleCoopEvent(CoopPacket packet)
{
bool result = false;
switch (packet.packetType)
{
case PACKET_TYPE.CLIENT_STATUS:
{
Coop_Model_ClientStatus model5 = packet.GetModel <Coop_Model_ClientStatus>();
result = coopClient.OnRecvClientStatus(model5, packet);
break;
}
case PACKET_TYPE.CLIENT_LOADING_PROGRESS:
{
Coop_Model_ClientLoadingProgress model4 = packet.GetModel <Coop_Model_ClientLoadingProgress>();
result = coopClient.OnRecvClientLoadingProgress(model4);
break;
}
case PACKET_TYPE.CLIENT_CHANGE_EQUIP:
{
Coop_Model_ClientChangeEquip model3 = packet.GetModel <Coop_Model_ClientChangeEquip>();
result = coopClient.OnRecvClientChangeEquip(model3);
break;
}
case PACKET_TYPE.CLIENT_BATTLE_RETIRE:
{
Coop_Model_ClientBattleRetire model2 = packet.GetModel <Coop_Model_ClientBattleRetire>();
result = coopClient.OnRecvClientBattleRetire(model2);
break;
}
case PACKET_TYPE.CLIENT_SERIES_PROGRESS:
{
Coop_Model_ClientSeriesProgress model = packet.GetModel <Coop_Model_ClientSeriesProgress>();
result = coopClient.OnRecvClientSeriesProgress(model);
break;
}
}
return(result);
}
protected override bool HandleCoopEvent(CoopPacket packet)
{
bool result = false;
switch (packet.packetType)
{
case PACKET_TYPE.PARTY_ROOM_JOINED:
{
Party_Model_RoomJoined model4 = packet.GetModel <Party_Model_RoomJoined>();
result = MonoBehaviourSingleton <PartyNetworkManager> .I.OnRecvRoomJoined(model4);
break;
}
case PACKET_TYPE.PARTY_ROOM_LEAVED:
{
Party_Model_RoomLeaved model3 = packet.GetModel <Party_Model_RoomLeaved>();
result = MonoBehaviourSingleton <PartyNetworkManager> .I.OnRecvRoomLeaved(model3);
break;
}
case PACKET_TYPE.CHAT_MESSAGE:
{
Coop_Model_StageChatMessage model2 = packet.GetModel <Coop_Model_StageChatMessage>();
result = MonoBehaviourSingleton <PartyNetworkManager> .I.OnRecvChatMessage(model2);
break;
}
case PACKET_TYPE.STAGE_CHAT_STAMP:
{
Coop_Model_StageChatStamp model = packet.GetModel <Coop_Model_StageChatStamp>();
result = MonoBehaviourSingleton <PartyNetworkManager> .I.OnRecvChatStamp(model);
break;
}
}
return(result);
}
public virtual bool GetPredictivePosition(out Vector3 pos)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
pos = Vector3.get_zero();
for (int num = base.packets.Count - 1; num >= 0; num--)
{
CoopPacket coopPacket = base.packets[num];
Coop_Model_ObjectBase model = coopPacket.GetModel <Coop_Model_ObjectBase>();
if (model != null && model.IsHaveObjectPosition())
{
pos = model.GetObjectPosition();
return(true);
}
}
return(false);
}
protected override bool HandleCoopEvent(CoopPacket packet)
{
bool result = false;
switch (packet.packetType)
{
case PACKET_TYPE.ROOM_SYNC_ALL_PORTAL_POINT:
{
Coop_Model_RoomSyncAllPortalPoint model16 = packet.GetModel <Coop_Model_RoomSyncAllPortalPoint>();
coopRoom.OnRecvSyncAllPortalPoint(model16);
result = true;
break;
}
case PACKET_TYPE.ROOM_UPDATE_PORTAL_POINT:
{
Coop_Model_RoomUpdatePortalPoint model15 = packet.GetModel <Coop_Model_RoomUpdatePortalPoint>();
coopRoom.OnRecvRoomUpdatePortalPoint(model15);
result = true;
break;
}
case PACKET_TYPE.ROOM_SYNC_EXPLORE_BOSS:
{
Coop_Model_RoomSyncExploreBoss model14 = packet.GetModel <Coop_Model_RoomSyncExploreBoss>();
coopRoom.OnRecvSyncExploreBoss(model14);
result = true;
break;
}
case PACKET_TYPE.ROOM_SYNC_EXPLORE_BOSS_MAP:
{
Coop_Model_RoomSyncExploreBossMap model13 = packet.GetModel <Coop_Model_RoomSyncExploreBossMap>();
coopRoom.OnRecvSyncExploreBossMap(model13);
result = true;
break;
}
case PACKET_TYPE.ROOM_EXPLORE_BOSS_DAMAGE:
{
Coop_Model_RoomExploreBossDamage model12 = packet.GetModel <Coop_Model_RoomExploreBossDamage>();
coopRoom.OnRecvExploreBossDamage(packet.fromClientId, model12);
result = true;
break;
}
case PACKET_TYPE.ROOM_EXPLORE_ALIVE:
{
Coop_Model_RoomExploreAlive model11 = packet.GetModel <Coop_Model_RoomExploreAlive>();
coopRoom.OnRecvExploreAlive();
result = true;
break;
}
case PACKET_TYPE.ROOM_EXPLORE_ALIVE_REQUEST:
{
Coop_Model_RoomExploreAliveRequest model10 = packet.GetModel <Coop_Model_RoomExploreAliveRequest>();
coopRoom.OnRecvExploreAliveRequest();
result = true;
break;
}
case PACKET_TYPE.ROOM_EXPLORE_BOSS_DEAD:
{
Coop_Model_RoomExploreBossDead model9 = packet.GetModel <Coop_Model_RoomExploreBossDead>();
result = coopRoom.OnRecvExploreBossDead(model9);
break;
}
case PACKET_TYPE.ROOM_NOTIFY_ENCOUNTER_BOSS:
{
Coop_Model_RoomNotifyEncounterBoss model8 = packet.GetModel <Coop_Model_RoomNotifyEncounterBoss>();
coopRoom.OnRecvNotifyEncounterBoss(packet.fromClientId, model8);
result = true;
break;
}
case PACKET_TYPE.ROOM_SYNC_PLAYER_STATUS:
{
Coop_Model_RoomSyncPlayerStatus model7 = packet.GetModel <Coop_Model_RoomSyncPlayerStatus>();
coopRoom.OnRecvSyncPlayerStatus(packet.fromClientId, model7);
result = true;
break;
}
case PACKET_TYPE.ROOM_CHAT_STAMP:
{
Coop_Model_RoomChatStamp model6 = packet.GetModel <Coop_Model_RoomChatStamp>();
coopRoom.OnRecvChatStamp(packet.fromClientId, model6);
result = true;
break;
}
case PACKET_TYPE.ROOM_MOVE_FIELD:
{
Coop_Model_RoomMoveField model5 = packet.GetModel <Coop_Model_RoomMoveField>();
coopRoom.OnRecvMoveField(model5);
result = true;
break;
}
case PACKET_TYPE.ROOM_RUSH_REQUEST:
{
Coop_Model_RushRequest model4 = packet.GetModel <Coop_Model_RushRequest>();
coopRoom.OnRecvRushRequest(packet.fromClientId, model4);
result = true;
break;
}
case PACKET_TYPE.ROOM_RUSH_REQUESTED:
{
Coop_Model_RushRequested model3 = packet.GetModel <Coop_Model_RushRequested>();
coopRoom.OnRecvRushRequested(model3);
result = true;
break;
}
case PACKET_TYPE.ROOM_SYNC_DEFENSE_BATTLE:
{
Coop_Model_RoomSyncDefenseBattle model2 = packet.GetModel <Coop_Model_RoomSyncDefenseBattle>();
coopRoom.OnRecvSyncDefenseBattle(model2);
result = true;
break;
}
case PACKET_TYPE.ROOM_NOTIFY_TRACE_BOSS:
{
Coop_Model_RoomNotifyTraceBoss model = packet.GetModel <Coop_Model_RoomNotifyTraceBoss>();
coopRoom.OnRecvNotifyTraceBoss(packet.fromClientId, model);
result = true;
break;
}
}
return(result);
}
protected override bool HandleCoopEvent(CoopPacket packet)
{
bool result = false;
switch (packet.packetType)
{
case PACKET_TYPE.ROOM_JOINED:
{
Coop_Model_RoomJoined model5 = packet.GetModel <Coop_Model_RoomJoined>();
result = MonoBehaviourSingleton <CoopManager> .I.coopRoom.OnRecvRoomJoined(model5);
break;
}
case PACKET_TYPE.ROOM_LEAVED:
{
Coop_Model_RoomLeaved model14 = packet.GetModel <Coop_Model_RoomLeaved>();
result = MonoBehaviourSingleton <CoopManager> .I.coopRoom.OnRecvRoomLeaved(model14);
break;
}
case PACKET_TYPE.ROOM_STAGE_CHANGED:
{
Coop_Model_RoomStageChanged model13 = packet.GetModel <Coop_Model_RoomStageChanged>();
result = MonoBehaviourSingleton <CoopManager> .I.coopRoom.OnRecvRoomStageChanged(model13);
break;
}
case PACKET_TYPE.ROOM_STAGE_REQUESTED:
{
Coop_Model_RoomStageRequested model12 = packet.GetModel <Coop_Model_RoomStageRequested>();
result = MonoBehaviourSingleton <CoopManager> .I.coopRoom.OnRecvRoomStageRequested(model12);
break;
}
case PACKET_TYPE.ROOM_STAGE_HOST_CHANGED:
{
Coop_Model_RoomStageHostChanged model11 = packet.GetModel <Coop_Model_RoomStageHostChanged>();
result = MonoBehaviourSingleton <CoopManager> .I.coopRoom.OnRecvRoomStageHostChanged(model11);
break;
}
case PACKET_TYPE.ENEMY_POP:
{
Coop_Model_EnemyPop model10 = packet.GetModel <Coop_Model_EnemyPop>();
result = MonoBehaviourSingleton <CoopManager> .I.coopStage.OnRecvEnemyPop(model10);
break;
}
case PACKET_TYPE.ENEMY_DEFEAT:
{
Coop_Model_EnemyDefeat model9 = packet.GetModel <Coop_Model_EnemyDefeat>();
result = MonoBehaviourSingleton <CoopManager> .I.coopStage.OnRecvEnemyDefeat(model9);
break;
}
case PACKET_TYPE.REWARD_PICKUP:
{
Coop_Model_RewardPickup model8 = packet.GetModel <Coop_Model_RewardPickup>();
result = MonoBehaviourSingleton <CoopManager> .I.coopStage.OnRecvRewardPickup(model8);
break;
}
case PACKET_TYPE.ENEMY_EXTERMINATION:
{
Coop_Model_EnemyExtermination model7 = packet.GetModel <Coop_Model_EnemyExtermination>();
result = MonoBehaviourSingleton <CoopManager> .I.coopStage.OnRecvEnemyExtermination(model7);
break;
}
case PACKET_TYPE.EVENT_HAPPEN_QUEST:
{
Coop_Model_EventHappenQuest model6 = packet.GetModel <Coop_Model_EventHappenQuest>();
result = MonoBehaviourSingleton <CoopManager> .I.coopStage.OnRecvEventHappenQuest(model6);
break;
}
case PACKET_TYPE.UPDATE_BOOST_COMPLETE:
{
Coop_Model_UpdateBoostComplete model4 = packet.GetModel <Coop_Model_UpdateBoostComplete>();
result = true;
if (!model4.success)
{
MonoBehaviourSingleton <KtbWebSocket> .I.Close(1000, "Bye!");
}
break;
}
case PACKET_TYPE.ROOM_TIME_UPDATE:
{
Coop_Model_RoomTimeUpdate model3 = packet.GetModel <Coop_Model_RoomTimeUpdate>();
result = MonoBehaviourSingleton <CoopManager> .I.coopRoom.OnRecvRoomTimeUpdate(model3);
break;
}
case PACKET_TYPE.ENEMY_BOSS_POP:
{
Coop_Model_EnemyBossPop model2 = packet.GetModel <Coop_Model_EnemyBossPop>();
result = MonoBehaviourSingleton <CoopManager> .I.coopStage.OnRecvEnemyBossPop(model2);
break;
}
case PACKET_TYPE.WAVEMATCH_INFO:
{
Coop_Model_WaveMatchInfo model = packet.GetModel <Coop_Model_WaveMatchInfo>();
result = MonoBehaviourSingleton <CoopManager> .I.coopStage.OnRecvWaveMatchInfo(model);
break;
}
}
return(result);
}
protected override bool HandleCoopEvent(CoopPacket packet)
{
bool result = false;
switch (packet.packetType)
{
case PACKET_TYPE.LOUNGE_ROOM_JOINED:
{
Lounge_Model_RoomJoined model14 = packet.GetModel <Lounge_Model_RoomJoined>();
result = MonoBehaviourSingleton <LoungeNetworkManager> .I.OnRecvRoomJoined(model14);
break;
}
case PACKET_TYPE.LOUNGE_ROOM_LEAVED:
{
Lounge_Model_RoomLeaved model13 = packet.GetModel <Lounge_Model_RoomLeaved>();
result = MonoBehaviourSingleton <LoungeNetworkManager> .I.OnRecvRoomLeaved(model13);
break;
}
case PACKET_TYPE.LOUNGE_ROOM_ACTION:
{
Lounge_Model_RoomAction model12 = packet.GetModel <Lounge_Model_RoomAction>();
result = MonoBehaviourSingleton <LoungeNetworkManager> .I.OnRecvRoomAction(model12);
break;
}
case PACKET_TYPE.LOUNGE_ROOM_MOVE:
{
Lounge_Model_RoomMove model11 = packet.GetModel <Lounge_Model_RoomMove>();
result = MonoBehaviourSingleton <LoungeNetworkManager> .I.OnRecvRoomMove(model11);
break;
}
case PACKET_TYPE.LOUNGE_ROOM_POSITION:
{
Lounge_Model_RoomPosition model10 = packet.GetModel <Lounge_Model_RoomPosition>();
result = MonoBehaviourSingleton <LoungeNetworkManager> .I.OnRecvRoomPoisition(model10);
break;
}
case PACKET_TYPE.LOUNGE_ROOM_KICK:
{
Lounge_Model_RoomKick model9 = packet.GetModel <Lounge_Model_RoomKick>();
result = MonoBehaviourSingleton <LoungeNetworkManager> .I.OnRecvRoomKick(model9);
break;
}
case PACKET_TYPE.LOUNGE_ROOM_AFK_KICK:
{
Lounge_Model_AFK_Kick model8 = packet.GetModel <Lounge_Model_AFK_Kick>();
result = MonoBehaviourSingleton <LoungeNetworkManager> .I.OnRecvRoomAFKKick(model8);
break;
}
case PACKET_TYPE.LOUNGE_ROOM_HOST_CHANGED:
{
Lounge_Model_RoomHostChanged model7 = packet.GetModel <Lounge_Model_RoomHostChanged>();
result = MonoBehaviourSingleton <LoungeNetworkManager> .I.OnRecvRoomHostChanged(model7);
break;
}
case PACKET_TYPE.LOUNGE_MEMBER_LOUNGE:
{
Lounge_Model_MemberLounge model6 = packet.GetModel <Lounge_Model_MemberLounge>();
result = MonoBehaviourSingleton <LoungeNetworkManager> .I.OnRecvMemberLounge(model6);
break;
}
case PACKET_TYPE.LOUNGE_MEMBER_FIELD:
{
Lounge_Model_MemberField model5 = packet.GetModel <Lounge_Model_MemberField>();
result = MonoBehaviourSingleton <LoungeNetworkManager> .I.OnRecvMemberField(model5);
break;
}
case PACKET_TYPE.LOUNGE_MEMBER_QUEST:
{
Lounge_Model_MemberQuest model4 = packet.GetModel <Lounge_Model_MemberQuest>();
result = MonoBehaviourSingleton <LoungeNetworkManager> .I.OnRecvMemberQuest(model4);
break;
}
case PACKET_TYPE.LOUNGE_MEMBER_ARENA:
{
Lounge_Model_MemberArena model3 = packet.GetModel <Lounge_Model_MemberArena>();
result = MonoBehaviourSingleton <LoungeNetworkManager> .I.OnRecvMemberArena(model3);
break;
}
case PACKET_TYPE.CHAT_MESSAGE:
{
Coop_Model_StageChatMessage model2 = packet.GetModel <Coop_Model_StageChatMessage>();
result = MonoBehaviourSingleton <LoungeNetworkManager> .I.OnRecvChatMessage(model2);
break;
}
case PACKET_TYPE.STAGE_CHAT_STAMP:
{
Coop_Model_StageChatStamp model = packet.GetModel <Coop_Model_StageChatStamp>();
result = MonoBehaviourSingleton <LoungeNetworkManager> .I.OnRecvChatStamp(model);
break;
}
}
return(result);
}
protected override bool HandleCoopEvent(CoopPacket packet)
{
//IL_012f: Unknown result type (might be due to invalid IL or missing references)
//IL_017a: Unknown result type (might be due to invalid IL or missing references)
//IL_017f: Unknown result type (might be due to invalid IL or missing references)
//IL_0195: Unknown result type (might be due to invalid IL or missing references)
//IL_019a: Unknown result type (might be due to invalid IL or missing references)
//IL_019f: Unknown result type (might be due to invalid IL or missing references)
//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
//IL_0217: Unknown result type (might be due to invalid IL or missing references)
//IL_0299: Unknown result type (might be due to invalid IL or missing references)
//IL_0307: Unknown result type (might be due to invalid IL or missing references)
//IL_0338: Unknown result type (might be due to invalid IL or missing references)
//IL_0358: Unknown result type (might be due to invalid IL or missing references)
//IL_039e: Unknown result type (might be due to invalid IL or missing references)
//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
//IL_0418: Unknown result type (might be due to invalid IL or missing references)
//IL_0450: Unknown result type (might be due to invalid IL or missing references)
//IL_047e: Unknown result type (might be due to invalid IL or missing references)
//IL_04b6: Unknown result type (might be due to invalid IL or missing references)
//IL_04d0: Unknown result type (might be due to invalid IL or missing references)
//IL_0501: Unknown result type (might be due to invalid IL or missing references)
//IL_051b: Unknown result type (might be due to invalid IL or missing references)
//IL_054d: Unknown result type (might be due to invalid IL or missing references)
//IL_0599: Unknown result type (might be due to invalid IL or missing references)
//IL_05f7: Unknown result type (might be due to invalid IL or missing references)
//IL_0625: Unknown result type (might be due to invalid IL or missing references)
//IL_06e8: Unknown result type (might be due to invalid IL or missing references)
//IL_0713: Unknown result type (might be due to invalid IL or missing references)
//IL_0718: Unknown result type (might be due to invalid IL or missing references)
//IL_076e: Unknown result type (might be due to invalid IL or missing references)
//IL_07b0: Unknown result type (might be due to invalid IL or missing references)
switch (packet.packetType)
{
case PACKET_TYPE.OBJECT_ATTACKED_HIT_OWNER:
if (character.isDead)
{
return(true);
}
return(base.HandleCoopEvent(packet));
case PACKET_TYPE.CHARACTER_ACTION_TARGET:
{
if (character.isDead)
{
return(true);
}
Coop_Model_CharacterActionTarget model17 = packet.GetModel <Coop_Model_CharacterActionTarget>();
StageObject target2 = null;
if (model17.target_id >= 0)
{
target2 = MonoBehaviourSingleton <StageObjectManager> .I.FindCharacter(model17.target_id);
}
character.SetActionTarget(target2, true);
break;
}
case PACKET_TYPE.CHARACTER_UPDATE_ACTION_POSITION:
{
if (character.isDead)
{
return(true);
}
Coop_Model_CharacterUpdateActionPosition model18 = packet.GetModel <Coop_Model_CharacterUpdateActionPosition>();
character.SetActionPosition(model18.act_pos, model18.act_pos_f);
character.UpdateActionPosition(model18.trigger);
break;
}
case PACKET_TYPE.CHARACTER_UPDATE_DIRECTION:
{
if (character.isDead)
{
return(true);
}
Coop_Model_CharacterUpdateDirection model5 = packet.GetModel <Coop_Model_CharacterUpdateDirection>();
character._rotation = Quaternion.AngleAxis(model5.dir, Vector3.get_up());
character.SetLerpRotation(Quaternion.AngleAxis(model5.lerp_dir, Vector3.get_up()) * Vector3.get_forward());
character.UpdateDirection(model5.trigger);
break;
}
case PACKET_TYPE.CHARACTER_PERIODIC_SYNC_ACTION_POSITION:
{
if (character.isDead)
{
return(true);
}
Coop_Model_CharacterPeriodicSyncActionPosition model22 = packet.GetModel <Coop_Model_CharacterPeriodicSyncActionPosition>();
character.AddPeriodicSyncActionPosition(model22.info);
break;
}
case PACKET_TYPE.CHARACTER_IDLE:
{
if (character.isDead)
{
return(true);
}
Coop_Model_CharacterIdle model4 = packet.GetModel <Coop_Model_CharacterIdle>();
character.ApplySyncPosition(model4.pos, model4.dir, false);
character.ActIdle(false, -1f);
break;
}
case PACKET_TYPE.CHARACTER_MOVE_VELOCITY:
{
if (character.isDead)
{
return(true);
}
Coop_Model_CharacterMoveVelocity model10 = packet.GetModel <Coop_Model_CharacterMoveVelocity>();
StageObject target = null;
if (model10.target_id >= 0)
{
target = MonoBehaviourSingleton <StageObjectManager> .I.FindCharacter(model10.target_id);
}
character.SetActionTarget(target, true);
character.ActMoveSyncVelocity(model10.time, model10.pos, model10.motion_id);
break;
}
case PACKET_TYPE.CHARACTER_MOVE_VELOCITY_END:
{
if (character.isDead)
{
return(true);
}
bool flag = false;
if (character.actionID == Character.ACTION_ID.MOVE && character.moveType == Character.MOVE_TYPE.SYNC_VELOCITY)
{
flag = true;
}
Coop_Model_CharacterMoveVelocityEnd model8 = packet.GetModel <Coop_Model_CharacterMoveVelocityEnd>();
if (flag)
{
character.SetMoveSyncVelocityEnd(model8.time, model8.pos, model8.direction, model8.sync_speed, model8.motion_id);
}
else
{
character.ActMoveSyncVelocity(0f, model8.pos, model8.motion_id);
character.SetMoveSyncVelocityEnd(model8.time, model8.pos, model8.direction, model8.sync_speed, model8.motion_id);
}
break;
}
case PACKET_TYPE.CHARACTER_MOVE_TO_POSITION:
{
if (character.isDead)
{
return(true);
}
Coop_Model_CharacterMoveToPosition model2 = packet.GetModel <Coop_Model_CharacterMoveToPosition>();
character.ApplySyncPosition(model2.pos, model2.dir, false);
character.ActMoveToPosition(model2.target_pos, false);
break;
}
case PACKET_TYPE.CHARACTER_MOVE_HOMING:
{
if (character.isDead)
{
return(true);
}
Coop_Model_CharacterMoveHoming model20 = packet.GetModel <Coop_Model_CharacterMoveHoming>();
character.ApplySyncPosition(model20.pos, model20.dir, false);
character.ActMoveHoming(model20.max_length);
character.SetActionPosition(model20.act_pos, model20.act_pos_f);
break;
}
case PACKET_TYPE.CHARACTER_MOVE_SIDEWAYS:
{
if (character.isDead)
{
return(true);
}
Coop_Model_CharacterMoveSideways model11 = packet.GetModel <Coop_Model_CharacterMoveSideways>();
character.ApplySyncPosition(model11.pos, model11.dir, false);
character.ActMoveSideways(model11.moveAngleSign, true);
character.SetActionPosition(model11.actionPos, model11.actionPosFlag);
break;
}
case PACKET_TYPE.CHARACTER_MOVE_POINT:
{
if (character.isDead)
{
return(true);
}
Coop_Model_CharacterMovePoint model7 = packet.GetModel <Coop_Model_CharacterMovePoint>();
character.ApplySyncPosition(model7.pos, model7.dir, false);
character.ActMovePoint(model7.targetPos);
break;
}
case PACKET_TYPE.CHARACTER_MOVE_LOOKAT:
{
if (character.isDead)
{
return(true);
}
Coop_Model_CharacterMoveLookAt model3 = packet.GetModel <Coop_Model_CharacterMoveLookAt>();
character.ApplySyncPosition(model3.pos, model3.dir, false);
character.ActMoveLookAt(model3.moveLookAtPos, true);
break;
}
case PACKET_TYPE.CHARACTER_ROTATE:
{
if (character.isDead)
{
return(true);
}
Coop_Model_CharacterRotate model21 = packet.GetModel <Coop_Model_CharacterRotate>();
character.ApplySyncPosition(model21.pos, model21.dir, false);
character.ActRotateToDirection(model21.target_dir);
break;
}
case PACKET_TYPE.CHARACTER_ROTATE_MOTION:
{
if (character.isDead)
{
return(true);
}
Coop_Model_CharacterRotateMotion model19 = packet.GetModel <Coop_Model_CharacterRotateMotion>();
character.ApplySyncPosition(model19.pos, model19.dir, false);
character.ActRotateMotionToDirection(model19.target_dir);
break;
}
case PACKET_TYPE.CHARACTER_ATTACK:
{
if (character.isDead)
{
return(true);
}
Coop_Model_CharacterAttack model16 = packet.GetModel <Coop_Model_CharacterAttack>();
character.SyncRandomSeed = model16.syncRandomSeed;
character.ApplySyncPosition(model16.pos, model16.dir, false);
character.ActAttack(model16.attack_id, true, false);
character.SetActionPosition(model16.act_pos, model16.act_pos_f);
break;
}
case PACKET_TYPE.CHARACTER_CONTINUS_ATTACK_SYNC:
{
Coop_Model_CharacterContinusAttackSync model15 = packet.GetModel <Coop_Model_CharacterContinusAttackSync>();
character.ReceiveContinusAttackParam(model15.sync_param);
break;
}
case PACKET_TYPE.CHARACTER_BUFFSYNC:
{
Coop_Model_CharacterBuffSync model14 = packet.GetModel <Coop_Model_CharacterBuffSync>();
character.buffParam.SetSyncParam(model14.sync_param, true);
break;
}
case PACKET_TYPE.CHARACTER_BUFFRECEIVE:
{
Coop_Model_CharacterBuffReceive model13 = packet.GetModel <Coop_Model_CharacterBuffReceive>();
BuffParam.BuffData buffData2 = model13.Deserialize();
character.OnBuffReceive(buffData2);
break;
}
case PACKET_TYPE.CHARACTER_BUFFROUTINE:
{
Coop_Model_CharacterBuffRoutine model12 = packet.GetModel <Coop_Model_CharacterBuffRoutine>();
BuffParam.BuffData buffData = model12.Deserialize();
character.OnBuffRoutine(buffData, true);
break;
}
case PACKET_TYPE.CHARACTER_REACTION:
{
if (character.isDead)
{
return(true);
}
Coop_Model_CharacterReaction model9 = packet.GetModel <Coop_Model_CharacterReaction>();
character.ApplySyncPosition(model9.pos, model9.dir, false);
Character.ReactionInfo reactionInfo = new Character.ReactionInfo();
reactionInfo.reactionType = (Character.REACTION_TYPE)model9.reactionType;
reactionInfo.blowForce = model9.blowForce;
reactionInfo.loopTime = model9.loopTime;
reactionInfo.targetId = model9.targetId;
character.ActReaction(reactionInfo, false);
break;
}
case PACKET_TYPE.CHARACTER_REACTION_DELAY:
{
if (character.isDead)
{
return(true);
}
Coop_Model_CharacterReactionDelay model6 = packet.GetModel <Coop_Model_CharacterReactionDelay>();
character.ApplySyncPosition(model6.pos, model6.dir, false);
character.OnReactionDelay(model6.reactionInfoList);
break;
}
case PACKET_TYPE.CHARACTER_DEAD:
{
Coop_Model_CharacterDead model = packet.GetModel <Coop_Model_CharacterDead>();
if (model == null)
{
return(true);
}
character.ApplySyncPosition(model.pos, model.dir, false);
if (character.isDead)
{
return(true);
}
character.ActDead(false, true);
break;
}
default:
return(base.HandleCoopEvent(packet));
}
return(true);
}
protected override bool HandleCoopEvent(CoopPacket packet)
{
//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
//IL_040b: Unknown result type (might be due to invalid IL or missing references)
//IL_0456: Unknown result type (might be due to invalid IL or missing references)
//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
switch (packet.packetType)
{
case PACKET_TYPE.ENEMY_LOAD_COMPLETE:
if (enemy.enemySender != null)
{
enemy.enemySender.OnRecvLoadComplete(packet.fromClientId);
}
break;
case PACKET_TYPE.ENEMY_INITIALIZE:
{
if (enemy.isLoading)
{
return(false);
}
Coop_Model_EnemyInitialize model8 = packet.GetModel <Coop_Model_EnemyInitialize>();
enemy.ApplySyncPosition(model8.pos, model8.dir, !enemy.isCoopInitialized);
enemy.hp = model8.hp;
enemy.hpMax = model8.hpMax;
enemy.damageHpRate = model8.hpDamageRate;
enemy.downTotal = model8.downTotal;
enemy.downCount = model8.downCount;
enemy.badStatusMax = model8.badStatusMax;
enemy.NowAngryID = model8.nowAngryId;
enemy.ExecAngryIDList = model8.execAngryIds;
enemy.BarrierHp = model8.barrierHp;
enemy.isHiding = model8.isHiding;
enemy.ShieldHp = model8.shieldHp;
enemy.GrabHp = model8.grabHp;
enemy.bulletIndex = model8.bulletIndex;
enemy.SetupAegis(model8.aegisSetupParam);
enemy.regionWorks.ApplyRegionWorks(model8);
enemy.UpdateRegionVisual();
StageObject target2 = null;
if (model8.target_id >= 0)
{
target2 = MonoBehaviourSingleton <StageObjectManager> .I.FindCharacter(model8.target_id);
}
enemy.SetActionTarget(target2, true);
enemy.buffParam.SetSyncParam(model8.buff_sync_param, true);
enemy.continusAttackParam.ApplySyncParam(model8.cntAtkSyncParam);
MonoBehaviourSingleton <StageObjectManager> .I.RemoveCacheObject(enemy);
enemy.get_gameObject().SetActive(true);
SetFilterMode(FILTER_MODE.NONE);
enemy.isCoopInitialized = true;
enemy.SetAppearPos(enemy._position);
if (enemy.IsValidShield())
{
enemy.RequestShieldShaderEffect();
}
if (enemy.tailController != null)
{
enemy.tailController.SetPreviousPositionList(model8.tailPosList);
}
if (MonoBehaviourSingleton <CoopManager> .IsValid() && MonoBehaviourSingleton <CoopManager> .I.coopStage.bossStartHpDamageRate == 0f)
{
MonoBehaviourSingleton <CoopManager> .I.coopStage.bossStartHpDamageRate = enemy.damageHpRate;
}
if (enemy.isHideSpawn)
{
if (enemy.isHiding)
{
enemy.InitHide();
}
else
{
enemy.TurnUpImmediate();
}
}
else
{
enemy.ActIdle(false, -1f);
}
break;
}
case PACKET_TYPE.ENEMY_UPDATE_BLEED_DAMAGE:
{
Coop_Model_EnemyUpdateBleedDamage model2 = packet.GetModel <Coop_Model_EnemyUpdateBleedDamage>();
enemy.OnUpdateBleedDamage(model2.sync_data);
break;
}
case PACKET_TYPE.ENEMY_UPDATE_SHADOWSEALING:
{
Coop_Model_EnemyUpdateShadowSealing model14 = packet.GetModel <Coop_Model_EnemyUpdateShadowSealing>();
enemy.OnUpdateShadowSealing(model14.sync_data);
break;
}
case PACKET_TYPE.ENEMY_STEP:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_EnemyStep model3 = packet.GetModel <Coop_Model_EnemyStep>();
enemy.ApplySyncPosition(model3.pos, model3.dir, false);
enemy.ActStep(model3.motion_id);
break;
}
case PACKET_TYPE.ENEMY_ANGRY:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_EnemyAngry model12 = packet.GetModel <Coop_Model_EnemyAngry>();
enemy.ApplySyncPosition(model12.pos, model12.dir, false);
enemy.ActAngry(model12.angryActionId, model12.angryId);
enemy.ExecAngryIDList = model12.execAngryIds;
break;
}
case PACKET_TYPE.ENEMY_REVIVE_REGION:
{
Coop_Model_EnemyReviveRegion model9 = packet.GetModel <Coop_Model_EnemyReviveRegion>();
enemy.ReviveRegion(model9.region_id);
break;
}
case PACKET_TYPE.ENEMY_WARP:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_EnemyWarp model6 = packet.GetModel <Coop_Model_EnemyWarp>();
enemy.ApplySyncPosition(model6.pos, model6.dir, true);
enemy.SetWarp();
break;
}
case PACKET_TYPE.ENEMY_TARGRTSHOT_EVENT:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_EnemyTargetShotEvent model15 = packet.GetModel <Coop_Model_EnemyTargetShotEvent>();
enemy.TargetRandamShotEvent(model15.targets);
break;
}
case PACKET_TYPE.ENEMY_RANDOMSHOT_EVENT:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_EnemyRandomShotEvent model11 = packet.GetModel <Coop_Model_EnemyRandomShotEvent>();
enemy.PointRandamShotEvent(model11.points);
break;
}
case PACKET_TYPE.ENEMY_RELEASE_GRABBED_PLAYER:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_EnemyReleasedGrabbedPlayer model7 = packet.GetModel <Coop_Model_EnemyReleasedGrabbedPlayer>();
enemy.ActReleaseGrabbedPlayers(false, false, true, model7.angle, model7.power);
break;
}
case PACKET_TYPE.ENEMY_SHOT:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_EnemyShot model5 = packet.GetModel <Coop_Model_EnemyShot>();
enemy.ActShotBullet(model5.atkName, model5.posList, model5.rotList);
break;
}
case PACKET_TYPE.ENEMY_RECOVER_HP:
{
if (enemy.isDead)
{
return(true);
}
Coop_Model_EnemyRecoverHp model16 = packet.GetModel <Coop_Model_EnemyRecoverHp>();
enemy.RecoverHp(model16.value);
break;
}
case PACKET_TYPE.CREATE_ICE_FLOOR:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_CreateIceFloor model13 = packet.GetModel <Coop_Model_CreateIceFloor>();
enemy.ActCreateIceFloor(model13.atkName, model13.posList, model13.rotList);
break;
}
case PACKET_TYPE.ACTION_MINE:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_ActionMine model10 = packet.GetModel <Coop_Model_ActionMine>();
switch (model10.type)
{
case 0:
enemy.ActDestroyActionMine(model10.objId, false);
break;
case 1:
enemy.ActDestroyActionMine(model10.objId, true);
break;
case 2:
enemy.ActCreateReflectBullet(model10.atkInfoName, model10.nodeName, model10.objId, model10.randSeed);
break;
case 3:
enemy.ActCreateActionMine(model10.atkInfoName, model10.randSeed);
break;
}
break;
}
case PACKET_TYPE.ENEMY_TURN_UP:
if (enemy.isDead)
{
return(true);
}
enemy.TurnUp();
break;
case PACKET_TYPE.ENEMY_SYNC_TARGET:
{
if (enemy.isDead)
{
return(true);
}
Coop_Model_EnemySyncTarget model4 = packet.GetModel <Coop_Model_EnemySyncTarget>();
StageObject target = null;
if (model4.targetId >= 0)
{
target = MonoBehaviourSingleton <StageObjectManager> .I.FindCharacter(model4.targetId);
}
enemy.SetActionTarget(target, true);
break;
}
case PACKET_TYPE.ENEMY_REGION_NODE_ACTIVATE:
{
if (enemy.isDead)
{
return(true);
}
Coop_Model_EnemyRegionNodeActivate model = packet.GetModel <Coop_Model_EnemyRegionNodeActivate>();
enemy.ActivateRegionNode(model.regionIDs, model.isRandom, model.randomSelectedID);
break;
}
default:
return(base.HandleCoopEvent(packet));
}
return(true);
}
protected override bool HandleCoopEvent(CoopPacket packet)
{
//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
//IL_0290: Unknown result type (might be due to invalid IL or missing references)
//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
//IL_037b: Unknown result type (might be due to invalid IL or missing references)
//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
//IL_04be: Unknown result type (might be due to invalid IL or missing references)
//IL_04c3: Unknown result type (might be due to invalid IL or missing references)
//IL_04e9: Unknown result type (might be due to invalid IL or missing references)
//IL_0533: Unknown result type (might be due to invalid IL or missing references)
//IL_0564: Unknown result type (might be due to invalid IL or missing references)
//IL_0569: Unknown result type (might be due to invalid IL or missing references)
//IL_056e: Unknown result type (might be due to invalid IL or missing references)
//IL_0573: Unknown result type (might be due to invalid IL or missing references)
//IL_0585: Unknown result type (might be due to invalid IL or missing references)
//IL_066e: Unknown result type (might be due to invalid IL or missing references)
//IL_06b2: Unknown result type (might be due to invalid IL or missing references)
//IL_0835: Unknown result type (might be due to invalid IL or missing references)
//IL_085c: Unknown result type (might be due to invalid IL or missing references)
//IL_0894: Unknown result type (might be due to invalid IL or missing references)
//IL_08c1: Unknown result type (might be due to invalid IL or missing references)
//IL_0931: Unknown result type (might be due to invalid IL or missing references)
//IL_0965: Unknown result type (might be due to invalid IL or missing references)
//IL_099d: Unknown result type (might be due to invalid IL or missing references)
//IL_09c3: Unknown result type (might be due to invalid IL or missing references)
//IL_09fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0a31: Unknown result type (might be due to invalid IL or missing references)
//IL_0a38: Unknown result type (might be due to invalid IL or missing references)
//IL_0a79: Unknown result type (might be due to invalid IL or missing references)
//IL_0a93: Unknown result type (might be due to invalid IL or missing references)
//IL_0a9a: Unknown result type (might be due to invalid IL or missing references)
//IL_0dd0: Unknown result type (might be due to invalid IL or missing references)
//IL_0e22: Unknown result type (might be due to invalid IL or missing references)
//IL_0e58: Unknown result type (might be due to invalid IL or missing references)
//IL_0ea9: Unknown result type (might be due to invalid IL or missing references)
//IL_0ef4: Unknown result type (might be due to invalid IL or missing references)
//IL_0f1a: Unknown result type (might be due to invalid IL or missing references)
//IL_0f56: Unknown result type (might be due to invalid IL or missing references)
//IL_102c: Unknown result type (might be due to invalid IL or missing references)
//IL_105d: Unknown result type (might be due to invalid IL or missing references)
//IL_1062: Unknown result type (might be due to invalid IL or missing references)
//IL_1067: Unknown result type (might be due to invalid IL or missing references)
//IL_106c: Unknown result type (might be due to invalid IL or missing references)
//IL_107e: Unknown result type (might be due to invalid IL or missing references)
//IL_10b6: Unknown result type (might be due to invalid IL or missing references)
//IL_10ee: Unknown result type (might be due to invalid IL or missing references)
//IL_117d: Unknown result type (might be due to invalid IL or missing references)
//IL_11cd: Unknown result type (might be due to invalid IL or missing references)
//IL_11fe: Unknown result type (might be due to invalid IL or missing references)
//IL_122f: Unknown result type (might be due to invalid IL or missing references)
//IL_1248: Unknown result type (might be due to invalid IL or missing references)
switch (packet.packetType)
{
case PACKET_TYPE.PLAYER_LOAD_COMPLETE:
if (!player.isSetAppearPos)
{
return(false);
}
if (player.playerSender != null)
{
player.playerSender.OnRecvLoadComplete(packet.fromClientId);
}
break;
case PACKET_TYPE.PLAYER_INITIALIZE:
{
if (player.isLoading)
{
return(false);
}
Coop_Model_PlayerInitialize model32 = packet.GetModel <Coop_Model_PlayerInitialize>();
player.ApplySyncPosition(model32.pos, model32.dir, true);
player.hp = model32.hp;
player.healHp = model32.healHp;
player.StopCounter(model32.stopcounter);
StageObject target = null;
if (model32.target_id >= 0)
{
target = MonoBehaviourSingleton <StageObjectManager> .I.FindCharacter(model32.target_id);
}
player.SetActionTarget(target, true);
player.buffParam.SetSyncParam(model32.buff_sync_param, true);
if (MonoBehaviourSingleton <InGameRecorder> .IsValid())
{
MonoBehaviourSingleton <InGameRecorder> .I.ApplySyncOwnerData(model32.id);
}
MonoBehaviourSingleton <StageObjectManager> .I.RemoveCacheObject(player);
player.get_gameObject().SetActive(true);
SetFilterMode(FILTER_MODE.NONE);
player.isCoopInitialized = true;
player.SetAppearPos(player._position);
bool flag = false;
if (player.weaponData == null != (model32.weapon_item == null))
{
flag = true;
}
else if (player.weaponData != null && player.weaponData.eId != model32.weapon_item.eId)
{
flag = true;
}
else if (player.weaponIndex != model32.weapon_index)
{
flag = true;
}
CoopClient coopClient = MonoBehaviourSingleton <CoopManager> .I.coopRoom.clients.FindByClientId(packet.fromClientId);
if (coopClient != null && !coopClient.IsBattleStart())
{
player.WaitBattleStart();
player.get_gameObject().SetActive(false);
MonoBehaviourSingleton <StageObjectManager> .I.AddCacheObject(player);
}
else if (flag)
{
player.LoadWeapon(model32.weapon_item, model32.weapon_index, delegate
{
player.ActBattleStart(true);
});
}
else
{
player.SetNowWeapon(model32.weapon_item, model32.weapon_index);
player.InitParameter();
if (player.hp <= 0)
{
player.ActBattleStart(true);
if (!player.isDead)
{
player.ActDeadLoop(false, 0f, 0f);
}
}
else if (model32.act_battle_start)
{
player.ActBattleStart(false);
}
else
{
player.ActBattleStart(true);
player.ActIdle(false, -1f);
}
}
player.SetSyncUsingCannon(model32.cannonId);
break;
}
case PACKET_TYPE.PLAYER_ATTACK_COMBO:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerAttackCombo model15 = packet.GetModel <Coop_Model_PlayerAttackCombo>();
base.owner._position = model15.pos;
base.owner._rotation = Quaternion.AngleAxis(model15.dir, Vector3.get_up());
player.ActAttack(model15.attack_id, true, false);
player.SetActionPosition(model15.act_pos, model15.act_pos_f);
break;
}
case PACKET_TYPE.PLAYER_CHARGE_RELEASE:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerChargeRelease model36 = packet.GetModel <Coop_Model_PlayerChargeRelease>();
player.ApplySyncExRush(model36.isExRushCharge);
player.ApplySyncPosition(model36.pos, model36.dir, false);
player.SetChargeRelease(model36.charge_rate);
player.SetLerpRotation(Quaternion.AngleAxis(model36.lerp_dir, Vector3.get_up()) * Vector3.get_forward());
player.SetActionPosition(model36.act_pos, model36.act_pos_f);
break;
}
case PACKET_TYPE.PLAYER_RESTRAINT:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerRestraint model33 = packet.GetModel <Coop_Model_PlayerRestraint>();
RestraintInfo restraintInfo = new RestraintInfo();
restraintInfo.enable = true;
restraintInfo.duration = model33.duration;
restraintInfo.damageInterval = model33.damageInterval;
restraintInfo.damageRate = model33.damageRate;
restraintInfo.reduceTimeByFlick = model33.reduceTimeByFlick;
restraintInfo.effectName = model33.effectName;
restraintInfo.isStopMotion = model33.isStopMotion;
player.ActRestraint(restraintInfo);
break;
}
case PACKET_TYPE.PLAYER_RESTRAINT_END:
if (base.character.isDead)
{
return(true);
}
player.ActRestraintEnd();
break;
case PACKET_TYPE.PLAYER_AVOID:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerAvoid model38 = packet.GetModel <Coop_Model_PlayerAvoid>();
player.ApplySyncPosition(model38.pos, model38.dir, false);
player.ActAvoid();
break;
}
case PACKET_TYPE.PLAYER_WARP:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerWarp model19 = packet.GetModel <Coop_Model_PlayerWarp>();
player.ApplySyncPosition(model19.pos, model19.dir, false);
player.ActWarp();
break;
}
case PACKET_TYPE.PLAYER_BLOW_CLEAR:
if (base.character.isDead)
{
return(true);
}
player.InputBlowClear();
break;
case PACKET_TYPE.PLAYER_STUNNED_END:
if (base.character.isDead)
{
return(true);
}
player.SetStunnedEnd();
break;
case PACKET_TYPE.PLAYER_DEAD_COUNT:
{
Coop_Model_PlayerDeadCount model3 = packet.GetModel <Coop_Model_PlayerDeadCount>();
player.DeadCount(model3.remaind_time, model3.stop);
break;
}
case PACKET_TYPE.PLAYER_DEAD_STANDUP:
{
Coop_Model_PlayerDeadStandup model47 = packet.GetModel <Coop_Model_PlayerDeadStandup>();
player.ActDeadStandup(model47.standupHp, model47.cType);
break;
}
case PACKET_TYPE.PLAYER_STOP_COUNTER:
{
Coop_Model_PlayerStopCounter model46 = packet.GetModel <Coop_Model_PlayerStopCounter>();
player.StopCounter(model46.stop);
break;
}
case PACKET_TYPE.PLAYER_GATHER:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerGather model13 = packet.GetModel <Coop_Model_PlayerGather>();
GatherPointObject gatherPointObject = null;
if (MonoBehaviourSingleton <InGameProgress> .IsValid() && MonoBehaviourSingleton <InGameProgress> .I.gatherPointList != null)
{
int i = 0;
for (int count = MonoBehaviourSingleton <InGameProgress> .I.gatherPointList.Count; i < count; i++)
{
if (model13.point_id == (int)MonoBehaviourSingleton <InGameProgress> .I.gatherPointList[i].pointData.pointID)
{
gatherPointObject = MonoBehaviourSingleton <InGameProgress> .I.gatherPointList[i];
break;
}
}
}
if (gatherPointObject != null)
{
player.ApplySyncPosition(model13.pos, model13.dir, false);
player.ActGather(gatherPointObject);
player.SetActionPosition(model13.act_pos, model13.act_pos_f);
}
break;
}
case PACKET_TYPE.PLAYER_SKILL_ACTION:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerSkillAction model8 = packet.GetModel <Coop_Model_PlayerSkillAction>();
player.ApplySyncPosition(model8.pos, model8.dir, false);
player.ActSkillAction(model8.skill_index);
player.SetActionPosition(model8.act_pos, model8.act_pos_f);
break;
}
case PACKET_TYPE.PLAYER_GET_HEAL:
{
Coop_Model_PlayerGetHeal model7 = packet.GetModel <Coop_Model_PlayerGetHeal>();
player.OnGetHeal(model7.heal_hp, (HEAL_TYPE)model7.heal_type, !model7.receive, (HEAL_EFFECT_TYPE)model7.effect_type, true);
break;
}
case PACKET_TYPE.PLAYER_SPECIAL_ACTION:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerSpecialAction model2 = packet.GetModel <Coop_Model_PlayerSpecialAction>();
player.ApplySyncPosition(model2.pos, model2.dir, false);
player.ActSpecialAction(model2.start_effect, model2.isSuccess);
player.SetActionPosition(model2.act_pos, model2.act_pos_f);
break;
}
case PACKET_TYPE.PLAYER_SPECIAL_ACTION_CONTINUE:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerSpecialActionContinue model39 = packet.GetModel <Coop_Model_PlayerSpecialActionContinue>();
player.ApplySyncPosition(model39.pos, model39.dir, false);
player.ActSpAttackContinue();
player.SetActionPosition(model39.act_pos, model39.act_pos_f);
break;
}
case PACKET_TYPE.PLAYER_SHOT_ARROW:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerShotArrow model35 = packet.GetModel <Coop_Model_PlayerShotArrow>();
player.ApplySyncPosition(model35.pos, model35.dir, false);
AttackInfo attack_info = player.FindAttackInfoExternal(model35.attack_name, true, model35.attack_rate);
player.ShotArrow(model35.shot_pos, model35.shot_rot, attack_info, model35.is_sit_shot, model35.is_aim_end);
break;
}
case PACKET_TYPE.PLAYER_SHOT_SOUL_ARROW:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerShotSoulArrow model26 = packet.GetModel <Coop_Model_PlayerShotSoulArrow>();
player.ApplySyncPosition(model26.pos, model26.dir, false);
player.ShotSoulArrowPuppet(model26.shotPos, model26.bowRot, model26.targetPosList);
break;
}
case PACKET_TYPE.PLAYER_UPDATE_SKILL_INFO:
{
Coop_Model_PlayerUpdateSkillInfo model25 = packet.GetModel <Coop_Model_PlayerUpdateSkillInfo>();
player.skillInfo.SetSettingsInfo(model25.settings_info, player.equipWeaponList);
break;
}
case PACKET_TYPE.PLAYER_PRAYER_START:
{
Coop_Model_PlayerPrayerStart model23 = packet.GetModel <Coop_Model_PlayerPrayerStart>();
player.OnPrayerStart(model23.sid);
break;
}
case PACKET_TYPE.PLAYER_PRAYER_END:
{
Coop_Model_PlayerPrayerEnd model22 = packet.GetModel <Coop_Model_PlayerPrayerEnd>();
player.OnPrayerEnd(model22.sid);
break;
}
case PACKET_TYPE.PLAYER_PRAYER_BOOST:
{
Coop_Model_PlayerPrayerBoost model20 = packet.GetModel <Coop_Model_PlayerPrayerBoost>();
player.OnPrayerBoost(model20.sid, model20.isBoost);
break;
}
case PACKET_TYPE.PLAYER_CHANGE_WEAPON:
if (base.character.isDead)
{
return(true);
}
player.ActChangeWeapon(null, -1);
break;
case PACKET_TYPE.PLAYER_APPLY_CHANGE_WEAPON:
{
Coop_Model_PlayerApplyChangeWeapon model12 = packet.GetModel <Coop_Model_PlayerApplyChangeWeapon>();
if (player.weaponData.eId == (uint)model12.item.eId && player.weaponIndex == model12.index)
{
return(true);
}
player.ApplyChangeWeapon(model12.item, model12.index);
break;
}
case PACKET_TYPE.PLAYER_SETSTATUS:
{
Coop_Model_PlayerSetStatus model10 = packet.GetModel <Coop_Model_PlayerSetStatus>();
player.OnSetPlayerStatus(model10.level, model10.atk, model10.def, model10.hp, true, null);
if (MonoBehaviourSingleton <UIPlayerAnnounce> .IsValid())
{
MonoBehaviourSingleton <UIPlayerAnnounce> .I.Announce(UIPlayerAnnounce.ANNOUNCE_TYPE.LEVEL_UP, player);
}
break;
}
case PACKET_TYPE.PLAYER_GET_RAREDROP:
if (MonoBehaviourSingleton <UIInGameMessageBar> .IsValid())
{
Coop_Model_PlayerGetRareDrop model5 = packet.GetModel <Coop_Model_PlayerGetRareDrop>();
string text = null;
switch (model5.type)
{
case 5:
{
SkillItemTable.SkillItemData skillItemData = Singleton <SkillItemTable> .I.GetSkillItemData((uint)model5.item_id);
if (skillItemData != null)
{
text = skillItemData.name;
}
break;
}
case 4:
{
EquipItemTable.EquipItemData equipItemData = Singleton <EquipItemTable> .I.GetEquipItemData((uint)model5.item_id);
if (equipItemData != null)
{
text = equipItemData.name;
}
break;
}
default:
{
ItemTable.ItemData itemData = Singleton <ItemTable> .I.GetItemData((uint)model5.item_id);
if (itemData != null)
{
text = itemData.name;
}
break;
}
}
if (text != null)
{
MonoBehaviourSingleton <UIInGameMessageBar> .I.Announce(player.charaName, StringTable.Format(STRING_CATEGORY.IN_GAME, 4000u, text));
}
}
break;
case PACKET_TYPE.PLAYER_GRABBED:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerGrabbed model48 = packet.GetModel <Coop_Model_PlayerGrabbed>();
GrabInfo grabInfo = new GrabInfo();
grabInfo.parentNode = model48.nodeName;
grabInfo.duration = model48.duration;
grabInfo.drainAttackId = model48.drainAtkId;
player.ActGrabbedStart(model48.enemyId, grabInfo);
break;
}
case PACKET_TYPE.PLAYER_GRABBED_END:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerGrabbedEnd model45 = packet.GetModel <Coop_Model_PlayerGrabbedEnd>();
player.ActGrabbedEnd(model45.angle, model45.power);
break;
}
case PACKET_TYPE.PLAYER_SET_PRESENT_BULLET:
{
Coop_Model_PlayerSetPresentBullet model44 = packet.GetModel <Coop_Model_PlayerSetPresentBullet>();
player.SetPresentBullet(model44.presentBulletId, (BulletData.BulletPresent.TYPE)model44.type, model44.position, model44.bulletName);
break;
}
case PACKET_TYPE.PLAYER_PICK_PRESENT_BULLET:
{
Coop_Model_PlayerPickPresentBullet model43 = packet.GetModel <Coop_Model_PlayerPickPresentBullet>();
player.DestroyPresentBulletObject(model43.presentBulletId);
break;
}
case PACKET_TYPE.PLAYER_SHOT_ZONE_BULLET:
{
Coop_Model_PlayerShotZoneBullet model42 = packet.GetModel <Coop_Model_PlayerShotZoneBullet>();
player.ShotZoneBullet(player, model42.bulletName, model42.position, false, false);
break;
}
case PACKET_TYPE.PLAYER_SHOT_DECOY_BULLET:
{
Coop_Model_PlayerShotDecoyBullet model41 = packet.GetModel <Coop_Model_PlayerShotDecoyBullet>();
player.ShotDecoyBullet(model41.id, model41.decoyId, model41.bulletName, model41.position, false);
break;
}
case PACKET_TYPE.PLAYER_EXPLODE_DECOY_BULLET:
{
Coop_Model_PlayerExplodeDecoyBullet model40 = packet.GetModel <Coop_Model_PlayerExplodeDecoyBullet>();
player.ExplodeDecoyBullet(model40.decoyId);
break;
}
case PACKET_TYPE.PLAYER_CANNON_STANDBY:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerCannonStandby model37 = packet.GetModel <Coop_Model_PlayerCannonStandby>();
player.ApplySyncPosition(model37.pos, model37.dir, false);
player.ActCannonStandby(model37.cannonId);
break;
}
case PACKET_TYPE.PLAYER_CANNON_SHOT:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerCannonShot model34 = packet.GetModel <Coop_Model_PlayerCannonShot>();
player.ApplySyncPosition(model34.pos, model34.dir, false);
player.SetCannonState(Player.CANNON_STATE.READY);
player.ApplyCannonVector(model34.cannonVec);
player.ActCannonShot();
break;
}
case PACKET_TYPE.PLAYER_CANNON_ROTATE:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerCannonRotate model31 = packet.GetModel <Coop_Model_PlayerCannonRotate>();
player.SetSyncCannonRotation(model31.cannonVec);
break;
}
case PACKET_TYPE.PLAYER_GET_CHARGE_SKILLGAUGE:
{
Coop_Model_PlayerGetChargeSkillGauge model30 = packet.GetModel <Coop_Model_PlayerGetChargeSkillGauge>();
player.OnGetChargeSkillGauge((BuffParam.BUFFTYPE)model30.buffType, model30.buffValue, model30.useSkillIndex, !model30.receive);
break;
}
case PACKET_TYPE.PLAYER_RESURRECT:
{
Coop_Model_PlayerResurrect model29 = packet.GetModel <Coop_Model_PlayerResurrect>();
player.OnResurrection(true);
break;
}
case PACKET_TYPE.PLAYER_GET_RESURRECT:
{
Coop_Model_PlayerGetResurrect model28 = packet.GetModel <Coop_Model_PlayerGetResurrect>();
player.OnGetResurrection();
break;
}
case PACKET_TYPE.PLAYER_SPECIAL_ACTION_GAUGE_SYNC:
{
Coop_Model_PlayerSpecialActionGaugeSync model27 = packet.GetModel <Coop_Model_PlayerSpecialActionGaugeSync>();
player.OnSyncSpecialActionGauge(model27.weaponIndex, model27.currentSpActionGauge);
player.pairSwordsCtrl.SetComboLv(model27.comboLv);
break;
}
case PACKET_TYPE.PLAYER_CHARGE_EXPAND_RELEASE:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerChargeExpandRelease model24 = packet.GetModel <Coop_Model_PlayerChargeExpandRelease>();
player.ApplySyncPosition(model24.pos, model24.dir, false);
player.SetChargeExpandRelease(model24.charge_rate);
player.SetLerpRotation(Quaternion.AngleAxis(model24.lerp_dir, Vector3.get_up()) * Vector3.get_forward());
player.SetActionPosition(model24.act_pos, model24.act_pos_f);
break;
}
case PACKET_TYPE.PLAYER_JUMP_RIZE:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerJumpRize model21 = packet.GetModel <Coop_Model_PlayerJumpRize>();
player.OnJumpRize(model21.dir, model21.level);
break;
}
case PACKET_TYPE.PLAYER_JUMP_END:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerJumpEnd model18 = packet.GetModel <Coop_Model_PlayerJumpEnd>();
player.OnJumpEnd(model18.pos, model18.isSuccess, model18.y);
break;
}
case PACKET_TYPE.PLAYER_SOUL_BOOST:
{
Coop_Model_PlayerSoulBoost model17 = packet.GetModel <Coop_Model_PlayerSoulBoost>();
player.OnSoulBoost(model17.isBoost);
break;
}
case PACKET_TYPE.PLAYER_EVOLVE_ACTION_SYNC:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerEvolveActionSync model16 = packet.GetModel <Coop_Model_PlayerEvolveActionSync>();
player.OnSyncEvolveAction(model16.isAction);
break;
}
case PACKET_TYPE.PLAYER_EVOLVE_SPECIAL_ACTION:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerEvolveSpecialAction model14 = packet.GetModel <Coop_Model_PlayerEvolveSpecialAction>();
player.ApplySyncPosition(model14.pos, model14.dir, false);
player.ActEvolveSpecialAction();
break;
}
case PACKET_TYPE.PLAYER_SNATCH_POS:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerSnatchPos model11 = packet.GetModel <Coop_Model_PlayerSnatchPos>();
player.snatchCtrl.OnHit(model11.enemyId, model11.hitPoint);
break;
}
case PACKET_TYPE.PLAYER_SNATCH_MOVE_START:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerSnatchMoveStart model9 = packet.GetModel <Coop_Model_PlayerSnatchMoveStart>();
player.OnSnatchMoveStart(model9.snatchPos);
break;
}
case PACKET_TYPE.PLAYER_SNATCH_MOVE_END:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerSnatchMoveEnd model6 = packet.GetModel <Coop_Model_PlayerSnatchMoveEnd>();
player.SetActionPosition(model6.act_pos, model6.act_pos_f);
player.ApplySyncPosition(model6.pos, model6.dir, false);
player.OnSnatchMoveEnd(model6.triggerIndex);
break;
}
case PACKET_TYPE.PLAYER_PAIR_SWORDS_LASER_END:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerPairSwordsLaserEnd model4 = packet.GetModel <Coop_Model_PlayerPairSwordsLaserEnd>();
player.OnSyncSpecialActionGauge(model4.weaponIndex, model4.currentSpActionGauge);
player.pairSwordsCtrl.OnLaserEnd(true);
break;
}
case PACKET_TYPE.PLAYER_SHOT_HEALING_HOMING:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerShotHealingHoming model = packet.GetModel <Coop_Model_PlayerShotHealingHoming>();
player.OnShotHealingHoming(model);
break;
}
default:
return(base.HandleCoopEvent(packet));
}
if (QuestManager.IsValidInGameExplore())
{
CoopClient coopClient2 = MonoBehaviourSingleton <CoopManager> .I.coopRoom.clients.FindByClientId(packet.fromClientId);
if (coopClient2 != null)
{
MonoBehaviourSingleton <QuestManager> .I.UpdateExplorePlayerStatus(coopClient2);
}
}
return(true);
}
protected override void PacketUpdate()
{
if (!base.stopPacketUpdate)
{
if (forceFlags == null)
{
forceFlags = new List <bool>(base.packets.Count);
}
else
{
forceFlags.Clear();
if (forceFlags.Capacity < base.packets.Count)
{
forceFlags.Capacity = base.packets.Count;
}
}
int i = 0;
for (int count = base.packets.Count; i < count; i++)
{
CoopPacket coopPacket = base.packets[i];
bool item = false;
Coop_Model_ObjectBase model = coopPacket.GetModel <Coop_Model_ObjectBase>();
if (model != null)
{
item = model.IsForceHandleBefore(owner);
}
forceFlags.Add(item);
}
int j = 0;
for (int count2 = base.packets.Count; j < count2; j++)
{
CoopPacket coopPacket2 = base.packets[j];
if (!CheckFilterPacket(coopPacket2))
{
AddDeleteQueue(coopPacket2);
}
else
{
bool flag = true;
Coop_Model_ObjectBase model2 = coopPacket2.GetModel <Coop_Model_ObjectBase>();
if (model2 != null)
{
bool flag2 = false;
for (int k = j + 1; k < count2; k++)
{
if (forceFlags[k])
{
flag2 = true;
break;
}
}
if (!flag2)
{
float num = 0f;
if (MonoBehaviourSingleton <InGameSettingsManager> .IsValid())
{
num = MonoBehaviourSingleton <InGameSettingsManager> .I.stageObject.packetHandleMarginTime;
}
if (Time.get_time() > model2.GetReceiveTime() + num)
{
flag = true;
if (!model2.IsHandleable(owner))
{
int num2 = -1;
Character character = owner as Character;
if (character != null)
{
num2 = (int)character.actionID;
}
Log.Warning(LOG.COOP, "ObjectPacketReceiver::PacketUpdate() Err. ( Over packetHandleMarginTime. ) type : " + coopPacket2.packetType + ", action_id : " + num2);
}
}
else
{
flag = model2.IsHandleable(owner);
}
}
}
if (!flag || !HandleCoopEvent(coopPacket2))
{
if (Time.get_time() > model2.GetReceiveTime() + 20f)
{
Log.Warning(LOG.COOP, "ObjectPacketReceiver::PacketUpdate() Err. ( Over 20 Second. ) type : " + coopPacket2.packetType);
}
break;
}
AddDeleteQueue(coopPacket2);
if (base.stopPacketUpdate)
{
break;
}
}
}
EraseUsedPacket();
}
}
public override void Set(CoopPacket packet)
{
base.Set(packet);
packet.GetModel <Coop_Model_ObjectBase>()?.SetReceiveTime(Time.get_time());
}
protected override bool HandleCoopEvent(CoopPacket packet)
{
switch (packet.packetType)
{
case PACKET_TYPE.OBJECT_DESTROY:
if (owner is Self)
{
return(true);
}
return(owner.DestroyObject());
case PACKET_TYPE.OBJECT_ATTACKED_HIT_OWNER:
{
Coop_Model_ObjectAttackedHitOwner model5 = packet.GetModel <Coop_Model_ObjectAttackedHitOwner>();
model5.CopyAttackedHitStatus(out AttackedHitStatusOwner status2);
if (owner.IsEnableAttackedHitOwner())
{
owner.OnAttackedHitOwner(status2);
AttackedHitStatusFix status3 = new AttackedHitStatusFix(status2.origin);
owner.OnAttackedHitFix(status3);
if (owner.packetSender != null)
{
owner.packetSender.OnAttackedHitFix(status3);
}
}
break;
}
case PACKET_TYPE.OBJECT_ATTACKED_HIT_FIX:
{
Coop_Model_ObjectAttackedHitFix model4 = packet.GetModel <Coop_Model_ObjectAttackedHitFix>();
model4.CopyAttackedHitStatus(out AttackedHitStatusFix status);
owner.OnAttackedHitFix(status);
break;
}
case PACKET_TYPE.OBJECT_KEEP_WAITING_PACKET:
{
Coop_Model_ObjectKeepWaitingPacket model3 = packet.GetModel <Coop_Model_ObjectKeepWaitingPacket>();
owner.KeepWaitingPacket((StageObject.WAITING_PACKET)model3.type);
break;
}
case PACKET_TYPE.OBJECT_BULLET_OBSERVABLE_SET:
{
Coop_Model_ObjectBulletObservableSet model2 = packet.GetModel <Coop_Model_ObjectBulletObservableSet>();
owner.RegisterObservableID(model2.observedID);
break;
}
case PACKET_TYPE.OBJECT_BULLET_OBSERVABLE_BROKEN:
{
Coop_Model_ObjectBulletObservableBroken model = packet.GetModel <Coop_Model_ObjectBulletObservableBroken>();
owner.OnBreak(model.observedID);
break;
}
default:
Log.Warning(LOG.COOP, "not valid packet");
return(true);
}
return(true);
}
protected override bool HandleCoopEvent(CoopPacket packet)
{
bool result = false;
switch (packet.packetType)
{
case PACKET_TYPE.STAGE_PLAYER_POP:
{
Coop_Model_StagePlayerPop model7 = packet.GetModel <Coop_Model_StagePlayerPop>();
result = coopStage.OnRecvStagePlayerPop(model7, packet);
break;
}
case PACKET_TYPE.STAGE_INFO:
{
Coop_Model_StageInfo model10 = packet.GetModel <Coop_Model_StageInfo>();
result = coopStage.OnRecvStageInfo(model10, packet);
break;
}
case PACKET_TYPE.STAGE_RESPONSE_END:
{
Coop_Model_StageResponseEnd model9 = packet.GetModel <Coop_Model_StageResponseEnd>();
result = coopStage.OnRecvStageResponseEnd(model9, packet);
break;
}
case PACKET_TYPE.STAGE_QUEST_CLOSE:
{
Coop_Model_StageQuestClose model8 = packet.GetModel <Coop_Model_StageQuestClose>();
result = coopStage.OnRecvQuestClose(model8.is_succeed);
break;
}
case PACKET_TYPE.STAGE_TIMEUP:
result = coopStage.OnRecvStageTimeup();
break;
case PACKET_TYPE.STAGE_CHAT:
{
Coop_Model_StageChat model6 = packet.GetModel <Coop_Model_StageChat>();
if (model6.r)
{
result = coopStage.OnRecvStageChat(model6);
}
break;
}
case PACKET_TYPE.CHAT_MESSAGE:
{
Coop_Model_StageChatMessage model5 = packet.GetModel <Coop_Model_StageChatMessage>();
result = coopStage.OnRecvChatMessage(packet.fromClientId, model5);
break;
}
case PACKET_TYPE.STAGE_CHAT_STAMP:
{
Coop_Model_StageChatStamp model4 = packet.GetModel <Coop_Model_StageChatStamp>();
result = coopStage.OnRecvChatStamp(model4);
break;
}
case PACKET_TYPE.STAGE_REQUEST_POP:
{
Coop_Model_StageRequestPop model3 = packet.GetModel <Coop_Model_StageRequestPop>();
result = coopStage.OnRecvRequestPop(model3, packet);
break;
}
case PACKET_TYPE.STAGE_SYNC_PLAYER_RECORD:
{
Coop_Model_StageSyncPlayerRecord model2 = packet.GetModel <Coop_Model_StageSyncPlayerRecord>();
coopStage.OnRecvSyncPlayerRecord(model2);
result = true;
break;
}
case PACKET_TYPE.ENEMY_BOSS_ESCAPE:
{
Coop_Model_EnemyBossEscape model = packet.GetModel <Coop_Model_EnemyBossEscape>();
result = MonoBehaviourSingleton <CoopManager> .I.coopStage.OnRecvEnemyBossEscape(model);
break;
}
case PACKET_TYPE.ENEMY_BOSS_ALIVE_REQUEST:
coopStage.OnRecvEnemyBossAliveRequest(packet);
result = true;
break;
case PACKET_TYPE.ENEMY_BOSS_ALIVE_REQUESTED:
coopStage.OnRecvEnemyBossAliveRequested();
result = true;
break;
}
return(result);
}