Esempio n. 1
0
 /// <summary>
 ///* Envia uma mensagem para o jogador.<br/>
 ///* (Server-Side).
 /// </summary>
 /// <param name="player"></param>
 /// <param name="packet"></param>
 /// <param name="message"></param>
 public static void Error(this NeutronPlayer player, Packet packet, string message, int errorCode = 0)
 {
     using (NeutronStream stream = Neutron.PooledNetworkStreams.Pull())
     {
         NeutronStream.IWriter writer = stream.Writer;
         writer.WritePacket((byte)Packet.Error);
         writer.WritePacket((byte)packet);
         writer.Write(message);
         writer.Write(errorCode);
         player.Write(writer);
     }
 }
Esempio n. 2
0
#pragma warning disable IDE1006
        protected void iRPCHandler(NeutronPlayer owner, NeutronPlayer sender, short viewId, byte rpcId, byte instanceId, byte[] buffer, RegisterMode registerType, TargetTo targetTo, CacheMode cache, Protocol protocol)
#pragma warning restore IDE1006
        {
            void Run((int, int, RegisterMode) key)
            {
                bool Send()
                {
                    MatchmakingTo matchmakingTo = MatchmakingTo.Auto;

                    if (targetTo == TargetTo.Me)
                    {
                        matchmakingTo = MatchmakingTo.Me;
                    }
                    using (NeutronStream stream = Neutron.PooledNetworkStreams.Pull())
                    {
                        NeutronStream.IWriter writer = stream.Writer;
                        writer.WritePacket((byte)Packet.iRPC);
                        writer.WritePacket((byte)registerType);
                        writer.Write(viewId);
                        writer.Write(rpcId);
                        writer.Write(instanceId);
                        writer.WriteNext(buffer);
                        MatchmakingHelper.Internal.AddCache(rpcId, viewId, writer, owner, cache, CachedPacket.iRPC);
                        owner.Write(sender, writer, targetTo, matchmakingTo, protocol);
                    }
                    return(true);
                }

                if (MatchmakingHelper.Server.GetNetworkObject(key, owner, out NeutronView neutronView))
                {
                    if (neutronView.iRPCs.TryGetValue((rpcId, instanceId), out RPCInvoker remoteProceduralCall))
                    {
                        try
                        {
                            iRPCAttribute iRPCAttribute = remoteProceduralCall.iRPC;
                            if (ReflectionHelper.iRPC(buffer, remoteProceduralCall, owner))
                            {
                                Send();
                            }
                        }
                        catch (Exception ex)
                        {
                            LogHelper.Stacktrace(ex);
                        }
                    }
                    else
                    {
                        Send();
                    }
                }
Esempio n. 3
0
 protected async void HandshakeHandler(NeutronPlayer player, double clientTime, Authentication authentication)
 {
     if (authentication.Pass.Decrypt(out string phrase))
     {
         authentication = new Authentication(authentication.User, phrase, false);
         try
         {
             if (await OnAuthentication.Invoke(player, authentication))             //* First packet
             {
                 using (NeutronStream stream = Neutron.PooledNetworkStreams.Pull()) //* Second First packet
                 {
                     NeutronStream.IWriter writer = stream.Writer;
                     writer.WritePacket((byte)Packet.Handshake);
                     writer.Write(LocalTime);
                     writer.Write(clientTime);
                     writer.Write(player.StateObject.UdpLocalEndPoint.Port);
                     writer.WriteWithInteger(player);
                     player.Write(writer);
                 }
                 OnPlayerConnected?.Invoke(player); //* Three packet
             }
         }
         catch (Exception ex) // Tasks manual catch exception.
         {
             LogHelper.Stacktrace(ex);
         }
     }
     else if (!LogHelper.Error("Auth decrypt failed!"))
     {
         DisconnectHandler(player);
     }
 }
Esempio n. 4
0
 protected void ChatHandler(NeutronPlayer player, ChatMode packet, MatchmakingTo matchmakingTo, int viewId, string message)
 {
     if (OnMessageReceived.Invoke(player, message))
     {
         using (NeutronStream stream = Neutron.PooledNetworkStreams.Pull())
         {
             NeutronStream.IWriter writer = stream.Writer;
             writer.WritePacket((byte)Packet.Chat);
             writer.Write(message);
             if (packet == ChatMode.Global)
             {
                 player.Write(writer, TargetTo.All, matchmakingTo, Protocol.Tcp);
             }
             else if (packet == ChatMode.Private)
             {
                 if (MatchmakingHelper.Server.GetPlayer(viewId, out NeutronPlayer playerFound))
                 {
                     playerFound.Write(player, writer, TargetTo.Me, MatchmakingTo.Me, Protocol.Tcp);
                 }
                 else
                 {
                     player.Error(Packet.Chat, "Player not found!", ErrorMessage.PLAYER_NOT_FOUND);
                 }
             }
         }
     }
 }
Esempio n. 5
0
 public static void Disconnect(NeutronPlayer player, string reason)
 {
     using (NeutronStream stream = Neutron.PooledNetworkStreams.Pull())
     {
         NeutronStream.IWriter writer = stream.Writer;
         writer.WritePacket((byte)Packet.Disconnection);
         writer.Write(player.Id);
         writer.Write(reason);
         player.Write(writer, Helper.GetHandlers().OnPlayerDisconnected);
     }
 }
Esempio n. 6
0
 protected void SetNicknameHandler(NeutronPlayer player, string nickname)
 {
     if (OnPlayerNicknameChanged.Invoke(player, nickname))
     {
         player.Nickname = nickname;
         using (NeutronStream stream = Neutron.PooledNetworkStreams.Pull())
         {
             NeutronStream.IWriter writer = stream.Writer;
             writer.WritePacket((byte)Packet.Nickname);
             writer.Write(nickname);
             player.Write(writer, Helper.GetHandlers().OnPlayerNicknameChanged);
         }
     }
 }
Esempio n. 7
0
        protected void SynchronizeHandler(NeutronPlayer player, Protocol protocol)
        {
            //* Envia todos os jogadores conectados para mim.
            using (NeutronStream stream = Neutron.PooledNetworkStreams.Pull())
            {
                NeutronStream.IWriter writer  = stream.Writer;
                NeutronPlayer[]       players = MatchmakingHelper.Internal.GetPlayersByMatchmakingTo(player, MatchmakingTo.Auto);
                players = players.Where(x => x.Id != player.Id).ToArray();
                writer.WritePacket((byte)Packet.Synchronize);
                writer.Write((byte)1);
                writer.WriteNext(players.Serialize().Compress(CompressionMode.Deflate));
                player.Write(writer, TargetTo.Me, MatchmakingTo.Me, protocol);
            }

            //* Envia-me para todos os jogadores conectados.
            using (NeutronStream stream = Neutron.PooledNetworkStreams.Pull())
            {
                NeutronStream.IWriter writer = stream.Writer;
                writer.WritePacket((byte)Packet.Synchronize);
                writer.Write((byte)2);
                writer.WriteNext(player.Serialize().Compress(CompressionMode.Deflate));
                player.Write(writer, TargetTo.Others, MatchmakingTo.Auto, protocol);
            }
        }
Esempio n. 8
0
        private void RunPacket(NeutronPacket neutronPacket)
        {
            byte[]        pBuffer  = neutronPacket.Buffer;       //* Get the packet buffer.
            bool          isServer = neutronPacket.IsServerSide; //* Get the packet is server side.
            Protocol      protocol = neutronPacket.Protocol;     //* Get the packet protocol.
            NeutronPlayer owner    = neutronPacket.Owner;        //* Get the packet owner.
            NeutronPlayer sender   = neutronPacket.Sender;       //* Get the packet sender.

            using (NeutronStream stream = Neutron.PooledNetworkStreams.Pull())
            {
                NeutronStream.IReader reader = stream.Reader;
                reader.SetBuffer(pBuffer);                      //* Set the buffer.
                Packet outPacket = (Packet)reader.ReadPacket(); //* Read the packet.
                if (OnReceivePacket(outPacket) || isServer)
                {
                    switch (outPacket)
                    {
                    case Packet.TcpKeepAlive:
                    {
                        using (NeutronStream tcpStream = Neutron.PooledNetworkStreams.Pull())
                        {
                            NeutronStream.IWriter writer = tcpStream.Writer;
                            writer.WritePacket((byte)Packet.TcpKeepAlive);
                            owner.Write(writer);
                        }
                    }
                    break;

                    case Packet.Handshake:
                    {
                        var appId          = reader.ReadString();                       //* Read the app id.
                        var time           = reader.ReadDouble();                       //* Read the time.
                        var authentication = reader.ReadWithInteger <Authentication>(); //* Read the authentication.
                        if (appId.Decrypt(out appId))
                        {
                            //* Decrypt the app id.
                            if (Helper.GetSettings().GlobalSettings.AppId == appId)
                            {
                                HandshakeHandler(owner, time, authentication);         //* Handshake the player.
                            }
                            else
                            {
                                owner.Error(Packet.Handshake, "Update your game version, it does not match the current server version.");
                                Task.Run(async() =>
                                    {
                                        await Task.Delay(150);     //* Submit the disconnect after receiving the error message.
                                        DisconnectHandler(owner);  //* Disconnect the player.
                                    });
                            }
                        }
                        else if (!LogHelper.Error("Failed to verify handshake!"))
                        {
                            DisconnectHandler(owner);         //* Disconnect the player.
                        }
                    }
                    break;

                    case Packet.Nickname:
                    {
                        var nickname = reader.ReadString();         //* Read the nickname.
                        SetNicknameHandler(owner, nickname);
                    }
                    break;

                    case Packet.Chat:
                    {
                        var matchmakingTo = default(MatchmakingTo);        //* Create the matchmaking to.
                        var viewId        = default(int);                  //* Read the view id.
                        var chatPacket    = (ChatMode)reader.ReadPacket(); //* Read the chat mode.
                        switch (chatPacket)
                        {
                        case ChatMode.Global:
                            matchmakingTo = (MatchmakingTo)reader.ReadPacket();             //* Read the matchmaking to.
                            break;

                        case ChatMode.Private:
                            viewId = reader.ReadInt();             //* Read the view id.
                            break;
                        }
                        string message = reader.ReadString();
                        ChatHandler(owner, chatPacket, matchmakingTo, viewId, message);
                    }
                    break;

                    case Packet.iRPC:
                    {
                        var   registerType = (RegisterMode)reader.ReadPacket();                                                 //* Read the register mode.
                        var   targetTo     = (TargetTo)reader.ReadPacket();                                                     //* Read the target to.
                        var   cache        = (CacheMode)reader.ReadPacket();                                                    //* Read the cache mode.
                        short viewId       = reader.ReadShort();                                                                //* Read the view id.
                        var   rpcId        = reader.ReadByte();                                                                 //* Read the rpc id.
                        var   instanceId   = reader.ReadByte();                                                                 //* Read the instance id.
                        var   buffer       = reader.ReadNext();                                                                 //* Read the buffer.
                        iRPCHandler(owner, sender, viewId, rpcId, instanceId, buffer, registerType, targetTo, cache, protocol); //* Handle the iRPC.
                    }
                    break;

                    case Packet.gRPC:
                    {
                        var id     = reader.ReadByte();                   //* Read the id.
                        var buffer = reader.ReadNext();                   //* Read the buffer.
                        gRPCHandler(owner, sender, id, buffer, protocol); //* Handle the gRPC.
                    }
                    break;

                    case Packet.GetChannels:
                    {
                        GetChannelsHandler(owner);         //* Handle the get channels.
                    }
                    break;

                    case Packet.JoinChannel:
                    {
                        var channelId = reader.ReadInt();         //* Read the channel id.
                        JoinChannelHandler(owner, channelId);     //* Handle the join channel.
                    }
                    break;

                    case Packet.GetCache:
                    {
                        var cachedPacket = (CachedPacket)reader.ReadPacket(); //* Read the cached packet.
                        var Id           = reader.ReadByte();                 //* Read the id.
                        var includeMe    = reader.ReadBool();                 //* Send packets to me?
                        GetCacheHandler(owner, cachedPacket, Id, includeMe);  //* Handle the get cache.
                    }
                    break;

                    case Packet.CreateRoom:
                    {
                        var password = reader.ReadString();                    //* Read the password.
                        var room     = reader.ReadWithInteger <NeutronRoom>(); //* Read the room.
                        CreateRoomHandler(owner, room, password);              //* Handle the create room.
                    }
                    break;

                    case Packet.GetRooms:
                    {
                        GetRoomsHandler(owner);         //* Handle the get rooms.
                    }
                    break;

                    case Packet.JoinRoom:
                    {
                        var roomId   = reader.ReadInt();          //* Read the room id.
                        var password = reader.ReadString();       //* Read the password.
                        JoinRoomHandler(owner, roomId, password); //* Handle the join room.
                    }
                    break;

                    case Packet.Leave:
                    {
                        var packet = (MatchmakingMode)reader.ReadPacket();         //* Read the matchmaking mode.
                        if (packet == MatchmakingMode.Room)
                        {
                            LeaveRoomHandler(owner);         //* Handle the leave room.
                        }
                        else if (packet == MatchmakingMode.Channel)
                        {
                            LeaveChannelHandler(owner);         //* Handle the leave channel.
                        }
                    }
                    break;

                    case Packet.Destroy:
                    {
                        DestroyPlayerHandler(owner);         //* Handle the destroy player.
                    }
                    break;

                    case Packet.SetPlayerProperties:
                    {
                        var properties = reader.ReadString();          //* Read the properties.
                        SetPlayerPropertiesHandler(owner, properties); //* Handle the set player properties.
                    }
                    break;

                    case Packet.SetRoomProperties:
                    {
                        var properties = reader.ReadString();         //* Read the properties.
                        SetRoomPropertiesHandler(owner, properties);  //* Handle the set room properties.
                    }
                    break;

                    case Packet.UdpKeepAlive:
                    {
                        var time = reader.ReadDouble();   //* Read the time.
                        PingHandler(owner, time);         //* Handle the ping.
                    }
                    break;

                    case Packet.CustomPacket:
                    {
                        // var isMine;
                        // TargetTo targetTo = default(TargetTo);
                        // MatchmakingTo matchmakingTo = default(MatchmakingTo);
                        // int viewId = reader.ReadInt();
                        // byte packet = reader.ReadPacket();
                        // if ((isMine = PlayerHelper.IsMine(owner, viewId)))
                        // {
                        //     targetTo = (TargetTo)reader.ReadPacket();
                        //     matchmakingTo = (MatchmakingTo)reader.ReadPacket();
                        // }
                        // byte[] buffer = reader.ReadWithInteger();
                        // CustomPacketHandler(owner, isMine, viewId, buffer, packet, targetTo, matchmakingTo, protocol);
                    }
                    break;

                    case Packet.AutoSync:
                    {
                        var registerMode = (RegisterMode)reader.ReadPacket();                           //* Read the register mode.
                        var viewId       = reader.ReadShort();                                          //* Read the view id.
                        var instanceId   = reader.ReadByte();                                           //* Read the instance id.
                        var parameters   = reader.ReadNext();                                           //* Read the parameters.
                        OnAutoSyncHandler(neutronPacket, viewId, instanceId, parameters, registerMode); //* Handle the auto sync.
                    }
                    break;

                    case Packet.Synchronize:
                    {
                        SynchronizeHandler(owner, protocol);         //* Handle the synchronize.
                    }
                    break;
                    }
                }
                else
                {
                    LogHelper.Error("Client is not allowed to run this packet.");
                }
            }
        }