Example #1
0
 public void OnNetworkReceiveUnconnected(NetEndPoint remoteEndPoint, NetDataReader reader, UnconnectedMessageType messageType)
 {
     Console.WriteLine("[Server] ReceiveUnconnected {0}. From: {1}. Data: {2}", messageType, remoteEndPoint, reader.GetString(100));
     NetDataWriter wrtier = new NetDataWriter();
     wrtier.Put("SERVER DISCOVERY RESPONSE :)");
     Server.SendDiscoveryResponse(wrtier, remoteEndPoint);
 }
Example #2
0
 public void OnNetworkReceiveUnconnected(NetEndPoint remoteEndPoint, NetDataReader reader, UnconnectedMessageType messageType)
 {
     if (messageType == UnconnectedMessageType.DiscoveryRequest)
     {
         Debug.Log("[SERVER] Received discovery request. Send discovery response");
         _netServer.SendDiscoveryResponse(new byte[] {1}, remoteEndPoint);
     }
 }
Example #3
0
 public void OnNetworkReceiveUnconnected(NetEndPoint remoteEndPoint, NetDataReader reader, UnconnectedMessageType messageType)
 {
     Console.WriteLine("[Client] ReceiveUnconnected {0}. From: {1}. Data: {2}", messageType, remoteEndPoint, reader.GetString(100));
     if (messageType == UnconnectedMessageType.DiscoveryResponse)
     {
         Client.Connect(remoteEndPoint);
     }
 }
Example #4
0
 public void OnNetworkReceiveUnconnected(NetEndPoint remoteEndPoint, NetDataReader reader, UnconnectedMessageType messageType)
 {
     if (messageType == UnconnectedMessageType.DiscoveryResponse && _netClient.Peer == null)
     {
         Debug.Log("[CLIENT] Received discovery response. Connecting to: " + remoteEndPoint);
         _netClient.Connect(remoteEndPoint);
     }
 }
Example #5
0
    public void OnNetworkReceive(NetPeer peer, NetDataReader reader)
    {
        _newBallPosX = reader.GetFloat();

        var pos = _clientBall.transform.position;

        _oldBallPosX = pos.x;
        pos.x = _newBallPosX;

        _clientBall.transform.position = pos;

        _lerpTime = 0f;
    }
Example #6
0
 public void OnNetworkReceive(NetPeer peer, NetDataReader reader)
 {
     if (reader.AvailableBytes == 13218)
     {
         Console.WriteLine("[{0}] TestFrag: {1}, {2}", peer.Handler.LocalEndPoint.Port, reader.Data[0], reader.Data[13217]);
     }
     else
     {
         int type = reader.GetInt();
         int num = reader.GetInt();
         _messagesReceivedCount++;
         Console.WriteLine("[{0}] CNT: {1}, TYPE: {2}, NUM: {3}", peer.Handler.LocalEndPoint.Port, _messagesReceivedCount, type, num);
     }
 }
 /// <summary>
 /// Считываем структуру в Reader(обертка над массивом байт)
 /// Только для структур(MarshalAs for pointers)
 /// </summary>
 public static bool FromReader <T>(this LiteNetLib.Utils.NetDataReader reader, out T obj, bool acceptOffset = true)
 {
     try
     {
         int size = Marshal.SizeOf(typeof(T));
         obj = reader.RawData.ToStruct <T>(reader.Position);
         if (acceptOffset)
         {
             reader.AddOffset(size);
         }
         return(true);
     }
     catch (Exception e) { Debug.LogError("FromReader is bad=" + e); }
     obj = default(T);
     return(false);
 }
Example #8
0
 private void HandleNatIntroductionRequest(NetEndPoint senderEndPoint, NetDataReader dr)
 {
     NetEndPoint localEp = dr.GetNetEndPoint();
     string token = dr.GetString(MaxTokenLength);
     lock (_requestEvents)
     {
         _requestEvents.Enqueue(new RequestEventData
         {
             LocalEndPoint = localEp,
             RemoteEndPoint = senderEndPoint,
             Token = token
         });
     }
 }
Example #9
0
        internal void ProcessMessage(NetEndPoint senderEndPoint, PacketProperty property, byte[] data)
        {
            NetDataReader dr = new NetDataReader(data);

            switch (property)
            {
                case PacketProperty.NatIntroductionRequest:
                    //We got request and must introduce
                    HandleNatIntroductionRequest(senderEndPoint, dr);
                    break;
                case PacketProperty.NatIntroduction:
                    //We got introduce and must punch
                    HandleNatIntroduction(dr);
                    break;
                case PacketProperty.NatPunchMessage:
                    //We got punch and can connect
                    HandleNatPunch(senderEndPoint, dr);
                    break;
            }
        }
Example #10
0
        private void HandleNatPunch(NetEndPoint senderEndPoint, NetDataReader dr)
        {
            byte fromHostByte = dr.GetByte();
            if (fromHostByte != HostByte && fromHostByte != ClientByte)
            {
                //garbage
                return;
            }

            //Read info
            string additionalInfo = dr.GetString(MaxTokenLength);
            NetUtils.DebugWrite(ConsoleColor.Green, "[NAT] punch received from {0} - additional info: {1}", senderEndPoint, additionalInfo);

            //Release punch success to client; enabling him to Connect() to msg.Sender if token is ok
            lock (_successEvents)
            {
                _successEvents.Enqueue(new SuccessEventData { TargetEndPoint = senderEndPoint, Token = additionalInfo });
            }
        }
Example #11
0
        private void HandleNatIntroduction(NetDataReader dr)
        {
            // read intro
            byte hostByte = dr.GetByte();
            NetEndPoint remoteInternal = dr.GetNetEndPoint();
            NetEndPoint remoteExternal = dr.GetNetEndPoint();
            string token = dr.GetString(MaxTokenLength);

            NetUtils.DebugWrite(ConsoleColor.Cyan, "[NAT] introduction received; we are designated " + (hostByte == HostByte ? "host" : "client"));
            NetDataWriter writer = new NetDataWriter();

            // send internal punch
            writer.Put(hostByte);
            writer.Put(token);
            _netBase.SendRaw(NetPacket.CreateRawPacket(PacketProperty.NatPunchMessage, writer), remoteInternal);
            NetUtils.DebugWrite(ConsoleColor.Cyan, "[NAT] internal punch sent to " + remoteInternal);

            // send external punch
            writer.Reset();
            writer.Put(hostByte);
            writer.Put(token);
            _netBase.SendRaw(NetPacket.CreateRawPacket(PacketProperty.NatPunchMessage, writer), remoteExternal);
            NetUtils.DebugWrite(ConsoleColor.Cyan, "[NAT] external punch sent to " + remoteExternal);
        }
Example #12
0
            public void OnNetworkReceive(NetPeer peer, NetDataReader reader)
            {

            }
Example #13
0
 /// <summary>
 /// Reads one packet from NetDataReader and calls OnReceive delegate
 /// </summary>
 /// <param name="reader">NetDataReader with packet</param>
 /// <param name="userData">Argument that passed to OnReceivedEvent</param>
 /// <exception cref="ParseException">Malformed packet</exception>
 public void ReadPacket(NetDataReader reader, object userData)
 {
     GetCallbackFromData(reader)(reader, userData);
 }
Example #14
0
            public void OnNetworkReceive(NetPeer peer, NetDataReader reader)
            {
                //echo
                peer.Send(reader.Data, SendOptions.ReliableUnordered);

                //fragment log
                if (reader.AvailableBytes == 13218)
                {
                    Console.WriteLine("[Server] TestFrag: {0}, {1}", reader.Data[0], reader.Data[13217]);
                }
            }
Example #15
0
 public override void Read(TClass inf, NetDataReader r)
 {
     Setter(inf, _reader(r));
 }
Example #16
0
 void INetEventListener.OnNetworkReceiveUnconnected(NetEndPoint remoteEndPoint, NetDataReader reader, UnconnectedMessageType messageType)
 {
     if (NetworkReceiveUnconnectedEvent != null)
         NetworkReceiveUnconnectedEvent(remoteEndPoint, reader, messageType);
 }
Example #17
0
 void INetEventListener.OnNetworkReceive(NetPeer peer, NetDataReader reader)
 {
     if (NetworkReceiveEvent != null)
         NetworkReceiveEvent(peer, reader);
 }
Example #18
0
 public override void ReadArray(T inf, NetDataReader r)
 {
     SetterArr(inf, r.GetIntArray());
 }
Example #19
0
 public override void Read(T inf, NetDataReader r)
 {
     Setter(inf, r.GetInt());
 }
Example #20
0
 public override void Read(TClass inf, NetDataReader r)
 {
     _p.Deserialize(r);
     Setter(inf, _p);
 }
Example #21
0
 public void OnNetworkReceiveUnconnected(NetEndPoint remoteEndPoint, NetDataReader reader, UnconnectedMessageType messageType)
 {
     Console.WriteLine("[Server] ReceiveUnconnected: {0}", reader.GetString(100));
 }
Example #22
0
 /// <summary>
 /// Reads one packet from NetDataReader and calls OnReceive delegate
 /// </summary>
 /// <param name="reader">NetDataReader with packet</param>
 /// <exception cref="ParseException">Malformed packet</exception>
 public void ReadPacket(NetDataReader reader)
 {
     ReadPacket(reader, null);
 }
Example #23
0
            public void OnNetworkReceiveUnconnected(NetEndPoint remoteEndPoint, NetDataReader reader, UnconnectedMessageType messageType)
            {

            }
        /// <summary>
        /// Register nested property type
        /// </summary>
        /// <typeparam name="T">INetSerializable structure</typeparam>
        /// <returns>True - if register successful, false - if type already registered</returns>
        //public bool RegisterNestedType<T>() where T : struct, INetSerializable
        //{
        //    return _netSerializer.RegisterNestedType<T>();
        //}

        /// <summary>
        /// Register nested property type
        /// </summary>
        /// <param name="writeDelegate"></param>
        /// <param name="readDelegate"></param>
        /// <returns>True - if register successful, false - if type already registered</returns>
        //public bool RegisterNestedType<T>(Action<NetDataWriter, T> writeDelegate, Func<NetDataReader, T> readDelegate)
        //{
        //    return _netSerializer.RegisterNestedType<T>(writeDelegate, readDelegate);
        //}

        /// <summary>
        /// Register nested property type
        /// </summary>
        /// <typeparam name="T">INetSerializable class</typeparam>
        /// <returns>True - if register successful, false - if type already registered</returns>
        //public bool RegisterNestedType<T>(Func<T> constructor) where T : class, INetSerializable
        //{
        //    return _netSerializer.RegisterNestedType(constructor);
        //}

        /// <summary>
        /// Reads all available data from NetDataReader and calls OnReceive delegates
        /// </summary>
        /// <param name="reader">NetDataReader with packets data</param>
        public void ReadAllPackets(NetDataReader reader)
        {
            ReadAllPackets(reader, null);
        }