public int Send(Coop_Model_Base model, Type type, int to_id, bool promise = true, Func <Coop_Model_ACK, bool> onReceiveAck = null, Func <Coop_Model_Base, bool> onPreResend = null)
{
model.ct = (int)Coop_Model_Base.GetClientType();
model.u = packetSendCount++;
int num = 0;
if (promise)
{
sequence++;
if (sequence >= 10000000)
{
sequence = 0;
}
num = ackPrefix * 10000000 + sequence;
}
CoopPacket coopPacket = CoopPacket.Create(model, fromId, to_id, promise, num);
PacketStream packetStream = serializer.Serialize(coopPacket);
if (model.c != 1000 && model.c != 3)
{
LogDebug("Send packet: {0} (stream: {1})", coopPacket, packetStream);
}
NativeSend(packetStream);
if (promise)
{
RegistResendPacket(coopPacket, onReceiveAck, onPreResend);
}
return(num);
}
public void Send <T>(T model, bool promise = true) where T : Coop_Model_Base
{
model.id = 1000;
CoopPacket packet = CoopPacket.Create(model, -1000, -2000, promise, 0);
MonoBehaviourSingleton <CoopOfflineManager> .I.Recv(packet);
}
protected override void PacketUpdate()
{
if (!base.stopPacketUpdate)
{
List <CoopPacket> list = rymTPool <List <CoopPacket> > .Get();
if (list.Capacity < base.packets.Count)
{
list.Capacity = base.packets.Count;
}
int i = 0;
for (int count = base.packets.Count; i < count; i++)
{
list.Add(base.packets[i]);
}
int j = 0;
for (int count2 = list.Count; j < count2; j++)
{
if (base.stopPacketUpdate)
{
break;
}
CoopPacket packet = list[j];
if (HandleCoopEvent(packet))
{
AddDeleteQueue(packet);
}
}
list.Clear();
rymTPool <List <CoopPacket> > .Release(ref list);
EraseUsedPacket();
}
}
private void CheckAndSendAck(CoopPacket packet)
{
if (packet != null && packet.packetType != PACKET_TYPE.ACK && packet.promise)
{
SendAck(packet);
}
}
public static CoopPacket CreateLoopBackRoomLeavedPacket()
{
Party_Model_RoomLeaved party_Model_RoomLeaved = new Party_Model_RoomLeaved();
party_Model_RoomLeaved.id = 1000;
party_Model_RoomLeaved.cid = MonoBehaviourSingleton<UserInfoManager>.I.userInfo.id;
party_Model_RoomLeaved.token = MonoBehaviourSingleton<UserInfoManager>.I.userInfo.id.ToString();
return CoopPacket.Create(party_Model_RoomLeaved, -1000, -2000, false, -8989);
}
private void SendAck(CoopPacket p)
{
Coop_Model_ACK coop_Model_ACK = new Coop_Model_ACK();
coop_Model_ACK.ack = p.sequenceNo;
coop_Model_ACK.positive = true;
Send(coop_Model_ACK, -1000, false);
}
public static CoopPacket Create(Coop_Model_Base model, int from_id, int to_id, bool promise, int sequence_no)
{
CoopPacket coopPacket = new CoopPacket();
CoopPacketHeader coopPacketHeader2 = coopPacket.header = new CoopPacketHeader(model.c, from_id, to_id, promise, sequence_no);
coopPacket.model = model;
return(coopPacket);
}
public void Recv(CoopPacket packet)
{
if (isActivate)
{
Logd("Send. {0}", packet);
packetReceiver.Set(packet);
packetReceiver.OnUpdate();
}
}
public void ForcePacketProcess(CoopPacket packet)
{
PacketReceiver packetReceiver = GetPacketReceiver(packet);
if (packetReceiver != null)
{
packetReceiver.ForcePacketProcess(packet);
}
}
public virtual PacketStream SerializeString(CoopPacket packet)
{
PacketStringStream packetStringStream = new PacketStringStream();
OnSerializeStringPrefix(packetStringStream);
OnSerializeStringHeader(packetStringStream, packet.header);
OnSerializeStringModel(packetStringStream, packet.model);
return(new PacketStream(packetStringStream.ToString()));
}
public void KickRoomLeave()
{
if (MonoBehaviourSingleton <CoopManager> .IsValid())
{
CoopPacket packet = CreateLoopBackRoomLeavedPacket();
Logd("KickRoomLeave. is_connect={0}", CoopWebSocketSingleton <KtbWebSocket> .IsValidConnected());
MonoBehaviourSingleton <CoopManager> .I.ForcePacketProcess(packet);
}
}
public static CoopPacket CreateLoopBackRoomLeavedPacket()
{
Lounge_Model_RoomLeaved lounge_Model_RoomLeaved = new Lounge_Model_RoomLeaved();
lounge_Model_RoomLeaved.id = 1000;
lounge_Model_RoomLeaved.cid = MonoBehaviourSingleton <UserInfoManager> .I.userInfo.id;
lounge_Model_RoomLeaved.token = MonoBehaviourSingleton <UserInfoManager> .I.userInfo.id.ToString();
return(CoopPacket.Create(lounge_Model_RoomLeaved, -1000, -2000, false, -8989));
}
protected override bool CheckFilterPacket(CoopPacket packet)
{
FILTER_MODE filterMode = base.filterMode;
if (filterMode == FILTER_MODE.WAIT_INITIALIZE && packet.packetType == PACKET_TYPE.ENEMY_INITIALIZE)
{
return(true);
}
return(base.CheckFilterPacket(packet));
}
public void RestoreRushInReentry()
{
Enemy boss = MonoBehaviourSingleton <StageObjectManager> .I.boss;
if (boss != null && rushBossBackup != null)
{
CoopPacket coopPacket = new CoopPacket();
coopPacket.model = rushBossBackup;
boss.enemyReceiver.Set(coopPacket);
}
}
public static CoopPacket CreateLoopBackRoomLeavedPacket()
{
Coop_Model_RoomLeaved coop_Model_RoomLeaved = new Coop_Model_RoomLeaved();
coop_Model_RoomLeaved.id = 1000;
coop_Model_RoomLeaved.cid = MonoBehaviourSingleton <CoopManager> .I.coopMyClient.clientId;
coop_Model_RoomLeaved.token = MonoBehaviourSingleton <CoopManager> .I.coopMyClient.userToken;
coop_Model_RoomLeaved.stgid = MonoBehaviourSingleton <CoopManager> .I.coopMyClient.stageId;
coop_Model_RoomLeaved.stghostid = MonoBehaviourSingleton <CoopManager> .I.coopMyClient.clientId;
return(CoopPacket.Create(coop_Model_RoomLeaved, -1000, -2000, false, -8989));
}
public bool PacketRelay(CoopPacket packet)
{
PacketReceiver packetReceiver = GetPacketReceiver(packet);
if (packetReceiver != null)
{
packetReceiver.Set(packet);
return(true);
}
return(false);
}
private void RegistResendPacket(CoopPacket packet, Func <Coop_Model_ACK, bool> onReceiveAck, Func <Coop_Model_Base, bool> onPreResend = null)
{
packet.model.r = true;
ResendPacket resendPacket = new ResendPacket();
resendPacket.resendCount = 0;
resendPacket.lastSendTime = Time.get_time();
resendPacket.onReceiveAck = onReceiveAck;
resendPacket.onPreResend = onPreResend;
resendPacket.packet = packet;
resendPackets.Add((uint)packet.sequenceNo, resendPacket);
}
private CoopPacket DeserializeString(string data, Type type)
{
PacketStringStream packetStringStream = new PacketStringStream(data);
CoopPacket coopPacket = new CoopPacket();
OnDeserializeStringPrefix(packetStringStream);
coopPacket.header = OnDeserializeStringHeader(packetStringStream);
coopPacket.model = OnDeserializeStringModel(packetStringStream, type, coopPacket.header);
packetStringStream.Close();
packetStringStream = null;
return(coopPacket);
}
public PacketStream SerializeBinary(CoopPacket packet)
{
PacketMemoryStream packetMemoryStream = new PacketMemoryStream();
OnSerializeBinaryPrefix(packetMemoryStream);
OnSerializeBinaryHeader(packetMemoryStream, packet.header);
OnSerializeBinaryModel(packetMemoryStream, packet.model);
byte[] stream = packetMemoryStream.ToArray();
packetMemoryStream.Close();
packetMemoryStream = null;
return(new PacketStream(stream));
}
protected virtual bool CheckFilterPacket(CoopPacket packet)
{
if (filterMode == FILTER_MODE.NONE)
{
return(true);
}
if (packet.packetType == PACKET_TYPE.OBJECT_DESTROY)
{
return(true);
}
return(false);
}
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);
}
}
public void EraseLostReceiverPackets()
{
int i = 0;
for (int count = base.packets.Count; i < count; i++)
{
CoopPacket coopPacket = base.packets[i];
if (coopPacket.destObjectId != 1000 && !(MonoBehaviourSingleton <CoopManager> .I.GetPacketReceiver(coopPacket) != null))
{
AddDeleteQueue(coopPacket);
}
}
EraseUsedPacket();
}
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);
}
}
}
public virtual void SetFilterMode(FILTER_MODE filter_mode)
{
filterMode = filter_mode;
if (filterMode != 0)
{
int i = 0;
for (int count = base.packets.Count; i < count; i++)
{
CoopPacket packet = base.packets[i];
if (!CheckFilterPacket(packet))
{
AddDeleteQueue(packet);
}
}
EraseUsedPacket();
}
}
private CoopPacket DeserializeBinary(byte[] data, Type type)
{
PacketMemoryStream packetMemoryStream = new PacketMemoryStream(data);
CoopPacket coopPacket = new CoopPacket();
OnDeserializeBinaryPrefix(packetMemoryStream);
coopPacket.header = OnDeserializeBinaryHeader(packetMemoryStream);
try
{
coopPacket.model = OnDeserializeBinaryModel(packetMemoryStream, type, coopPacket.header);
}
catch (Exception)
{
}
packetMemoryStream.Close();
packetMemoryStream = null;
return(coopPacket);
}
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.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);
}
public virtual bool OnRecvClientStatus(Coop_Model_ClientStatus model, CoopPacket packet)
{
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
if (isLeave)
{
MonoBehaviourSingleton <CoopManager> .I.coopMyClient.WelcomeClient(clientId);
}
SetStatus((CLIENT_STATUS)model.status);
joinType = (CLIENT_JOIN_TYPE)model.joinType;
if (model.status == 5)
{
if (isStageHost && MonoBehaviourSingleton <CoopManager> .I.coopStage.isRecvStageInfo && MonoBehaviourSingleton <InGameProgress> .IsValid())
{
MonoBehaviourSingleton <InGameProgress> .I.StartTimer(0f);
}
if (MonoBehaviourSingleton <StageObjectManager> .IsValid())
{
List <StageObject> list = new List <StageObject>(MonoBehaviourSingleton <StageObjectManager> .I.cacheList);
int i = 0;
for (int count = list.Count; i < count; i++)
{
Player player = list[i] as Player;
if (!(player == null) && player.coopClientId == clientId && player.isWaitBattleStart)
{
MonoBehaviourSingleton <StageObjectManager> .I.RemoveCacheObject(player);
player.get_gameObject().SetActive(true);
player.ActBattleStart(false);
}
}
}
}
if (isPartyOwner && model.status == 6)
{
MonoBehaviourSingleton <CoopManager> .I.coopRoom.SetOwnerCleared();
}
if (MonoBehaviourSingleton <CoopManager> .I.coopRoom.NeedsForceLeave())
{
MonoBehaviourSingleton <CoopNetworkManager> .I.Close(1000, "Bye!", null);
}
return(true);
}
protected virtual void PacketUpdate()
{
if (!stopPacketUpdate)
{
int i = 0;
for (int count = packets.Count; i < count; i++)
{
if (stopPacketUpdate)
{
break;
}
CoopPacket packet = packets[i];
if (HandleCoopEvent(packet))
{
AddDeleteQueue(packet);
}
}
EraseUsedPacket();
}
}
protected override void PacketUpdate()
{
if (!base.stopPacketUpdate)
{
List <CoopPacket> list = rymTPool <List <CoopPacket> > .Get();
if (list.Capacity < base.packets.Count)
{
list.Capacity = base.packets.Count;
}
int i = 0;
for (int count = base.packets.Count; i < count; i++)
{
list.Add(base.packets[i]);
}
int j = 0;
for (int count2 = list.Count; j < count2; j++)
{
if (base.stopPacketUpdate)
{
break;
}
CoopPacket coopPacket = list[j];
if (coopPacket.destObjectId == 1000)
{
if (HandleCoopEvent(coopPacket))
{
AddDeleteQueue(coopPacket);
}
}
else if (MonoBehaviourSingleton <CoopManager> .I.PacketRelay(coopPacket))
{
AddDeleteQueue(coopPacket);
}
}
list.Clear();
rymTPool <List <CoopPacket> > .Release(ref list);
EraseUsedPacket();
}
}
