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(); } }