Пример #1
0
 /// <summary> Restores the <see cref="packetHandlerMap"/> to the given state. </summary>
 /// <param name="packetHandlerMap"> The state to which to restore the internal <see cref="Connection.packetHandlerMap"/>. </param>
 internal void RestorePacketHandler(PacketHandlerMap packetHandlerMap)
 {
     this.packetHandlerMap.Restore(packetHandlerMap);
     ObjectMapRefreshed();
 }
Пример #2
0
        public NetworkConnection(bool isBlocking)
        {
            m_UID = Guid.NewGuid();

            m_BlockingMode = isBlocking;
            StandardReplyHandlerMap = new PacketHandlerMap();

            OnInitialize();

            NetworkConnection.m_ConnectionsInExistence++;
            Log.LogMsg("Connection allocated. " + NetworkConnection.m_ConnectionsInExistence + " connection(s) in memory.");
        }
Пример #3
0
        private void HandlePacket(LobbyClientGameServerOutboundConnection con, PacketReply msg, PacketHandlerMap map)
        {
            Action<INetworkConnection, Packet> handler = map.GetHandlerDelegate(msg.PacketSubTypeID);
            if (handler != null)
            {
                try
                {
                    handler(con, msg);
                }
                catch (Exception e)
                {
                    Log.LogMsg("Exception thrown whilst processing game packet type " + msg.PacketTypeID.ToString() + ", sub-type " + msg.PacketSubTypeID + ". Object = " + this.GetType().ToString() + ", Message: " + e.Message + ". Stack:\r\n " + e.StackTrace);
                }

                con.OnAfterPacketProcessed(msg);
                return;
            }

            con.KillConnection("Did not have a registered game packet handler for game packet. " + msg.PacketTypeID.ToString() + ", SubType " + msg.PacketSubTypeID.ToString() + ". ");
        }
Пример #4
0
        /// <summary>
        /// Opens the new UDP connection and applies any buffered (i.e. already registered) packet handlers.
        /// </summary>
        private async Task OpenNewUDPConnection()
        {
            Tuple <UdpConnection, ConnectionResult> result = await CreateUdpConnection();

            if (result.Item2 != ConnectionResult.Connected)
            {
                Reconnect();
                return;
            }

            udpConnection = result.Item1;
            //Restore old state by adding old packets
            udpConnection.RestorePacketHandler(udpPacketHandlerBackup);
            //Restore new state by adding packets the user wanted to register while the connection was dead.
            udpPacketHandlerBuffer.ForEach(t =>
            {
                MethodInfo registerPacketHandler = typeof(Connection).GetMethod(nameof(IPacketHandler.RegisterPacketHandler), BindingFlags.NonPublic | BindingFlags.Instance);
                registerPacketHandler            = registerPacketHandler.MakeGenericMethod(t.Item1);
                registerPacketHandler.Invoke(udpConnection, new object[2] {
                    t.Item2, t.Item3
                });
            });
            udpStaticPacketHandlerBuffer.ForEach(t =>
            {
                MethodInfo registerPacketHandler = typeof(Connection).GetMethod(nameof(IPacketHandler.RegisterStaticPacketHandler), BindingFlags.NonPublic | BindingFlags.Instance);
                registerPacketHandler            = registerPacketHandler.MakeGenericMethod(t.Item1);
                registerPacketHandler.Invoke(udpConnection, new object[] { t.Item2 });
            });
            udpConnection.ConnectionClosed += (c, cc) =>
            {
                udpPacketHandlerBackup = cc.BackupPacketHandler();
                connectionLost?.Invoke(udpConnection, ConnectionType.UDP, c);
                Reconnect();
            };
            sendFastBuffer.ForEach(udpConnection.Send);
            sendFastObjectBuffer.ForEach(p => udpConnection.Send(p.Item1, p.Item2));
            //Restore new state by removing the packets the user wanted to unregister while the connection was dead.
            udpUnPacketHandlerBuffer.ForEach(t =>
            {
                MethodInfo unRegisterPacketHandler = typeof(Connection).GetMethod(nameof(IPacketHandler.UnRegisterPacketHandler));
                unRegisterPacketHandler            = unRegisterPacketHandler.MakeGenericMethod(t.Item1);
                unRegisterPacketHandler.Invoke(udpConnection, new object[] { t.Item2 });
            });
            udpStaticUnPacketHandlerBuffer.ForEach(t =>
            {
                MethodInfo unRegisterPacketHandler = typeof(Connection).GetMethod(nameof(IPacketHandler.UnRegisterStaticPacketHandler));
                unRegisterPacketHandler            = unRegisterPacketHandler.MakeGenericMethod(t);
                unRegisterPacketHandler.Invoke(udpConnection, null);
            });

            KnownTypes.ForEach(UdpConnection.AddExternalPackets);
            //Clear the buffers since we added and removed the packet types.
            sendFastBuffer.Clear();
            sendFastObjectBuffer.Clear();
            udpPacketHandlerBuffer.Clear();
            udpUnPacketHandlerBuffer.Clear();
            udpStaticPacketHandlerBuffer.Clear();
            udpStaticUnPacketHandlerBuffer.Clear();

            if (!UdpConnection.IsAlive)
            {
                return;                         //Connection could already be dead because of the prePackets.
            }
            connectionEstablished?.Invoke(udpConnection, ConnectionType.UDP);
        }