Esempio n. 1
0
        public void Recieve(byte[] bytes)
        {
            NetData message = NetData.RecoverBytes(bytes);

            if (message != null && message.number > lastMessageNumber)
            {
                if (ServerHandler.clients.Contains(message.sender.ID))
                {
                    if ((ServerHandler.clients[message.sender.ID] as NetUser).udpConnection == null)
                    {
                        NetUser.OnUserConnectedUDP(message.sender);
                    }
                    netUser = ServerHandler.clients[message.sender.ID] as NetUser;
                    netUser.udpConnection = this;
                }
                else
                {
                    netUser = new NetUser(message.sender);
                    netUser.udpConnection = this;
                    ServerHandler.AddConnection(netUser);
                    NetUser.OnUserConnectedUDP(message.sender);
                }
                NetUser.OnUdpMessageHandleCallback(bytes, message, netUser);
                lastMessageNumber = message.number;
            }
        }
Esempio n. 2
0
        public void GetMessage()
        {
            do
            {
                stream.Flush();
                byte[] bytes = new byte[2048];
                stream.Read(bytes, 0, bytes.Length);
                NetData message = NetData.RecoverBytes(bytes);

                if (message.number > lastMessageNumber)
                {
                    if (ServerHandler.clients.Contains(message.sender.ID))
                    {
                        if ((ServerHandler.clients[message.sender.ID] as NetUser).tcpConnection == null)
                        {
                            netUser = ServerHandler.clients[message.sender.ID] as NetUser;
                            netUser.tcpConnection = this;
                            NetUser.OnUserConnectedTCP(message.sender);
                        }
                    }
                    else
                    {
                        netUser = new NetUser(message.sender);
                        netUser.tcpConnection = this;
                        ServerHandler.AddConnection(netUser);
                        NetUser.OnUserConnectedTCP(message.sender);
                    }

                    if (netUser.info == null)
                    {
                        netUser.info = NetUser.server.GetUserData(message.sender.ID);
                    }
                    if (netUser.info == null)
                    {
                        netUser.info = ServerHandler.createUserBD(message.sender);
                    }

                    NetUser.OnTcpMessageHandleCallback(bytes, message, netUser);
                    lastMessageNumber = message.number;
                }
            }while (stream.DataAvailable);
        }
Esempio n. 3
0
        public void GetMessage()
        {
            do
            {
                byte[] bytes      = new byte[1024];
                int    bytesCount = 0;
                try
                {
                    bytesCount = stream.Read(bytes, 0, bytes.Length);
                    if (bytesCount < 2)
                    {
                        throw new Exception("null bytes");
                    }
                }
                catch
                {
                    if (user != null)
                    {
                        ServerHandler.OnUserDisconnectedTCP(user);
                        ServerHandler.OnUserDisconnectedUDP(user);
                        ServerHandler.RemoveConnection(user);
                    }
                    Close();
                    return;
                }

                ushort  type;
                bool    transitable;
                NetData message = NetData.RecoverBytes(bytes, bytesCount, out type, out transitable);

                if (!transitable)
                {
                    if (message != null)
                    {
                        if (ServerHandler.clients.ContainsKey(message.senderID))
                        {
                            if (ServerHandler.clients[message.senderID].tcpConnection == null)
                            {
                                user = ServerHandler.clients[message.senderID];
                                user.tcpConnection = this;
                                ServerHandler.OnUserConnectedTCP(user);
                            }
                        }
                        else
                        {
                            user = new User(message.senderID);
                            user.tcpConnection = this;
                            ServerHandler.AddConnection(user);
                            ServerHandler.OnUserConnectedTCP(user);

                            Matchmaking.DefaultRoom.instance.JoinToRoom(user);

                            if (user.info == null)
                            {
                                user.info = ServerHandler.DataBaseBehaivour.GetUserData(message.senderID);
                            }
                            if (user.info == null)
                            {
                                user.info = ServerHandler.DataBaseBehaivour.CreateUser(message.senderID);
                            }
                        }

                        SynchronizableTypes.InvokeTypeActionTCP(type, bytes, message, ServerHandler.clients[message.senderID]);
                    }
                    else
                    {
                        if (user != null)
                        {
                            ServerHandler.OnUserDisconnectedTCP(user);
                            ServerHandler.OnUserDisconnectedUDP(user);
                            ServerHandler.RemoveConnection(user);
                        }
                        Close();
                        return;
                    }
                }
                else
                {
                    user.currentRoom.BroadcastMessageTCP(bytes);
                }
            }while (stream.DataAvailable);
        }
Esempio n. 4
0
        private static void GetMessage(UdpClient client, IAsyncResult ar)
        {
            IPEndPoint iPEndPoint = new IPEndPoint(IPAddress.Any, 8001);
            UdpClient  udpClient  = (ar.AsyncState as UdpClient);

            byte[] bytes = null;
            try
            {
                bytes = udpClient.EndReceive(ar, ref iPEndPoint);
                if (bytes.Length < 2)
                {
                    throw new Exception("null bytes");
                }
            }
            catch
            {
                return;
            }
            finally
            {
                if (bytes != null)
                {
                    ushort  type;
                    bool    transitable;
                    NetData message = NetData.RecoverBytes(bytes, bytes.Length, out type, out transitable);
                    if (!transitable || !ServerHandler.udpConnections.ContainsKey(iPEndPoint))
                    {
                        if (message != null)
                        {
                            User udpUser = null;

                            if (ServerHandler.clients.ContainsKey(message.senderID))
                            {
                                if (ServerHandler.clients[message.senderID].udpConnection == null)
                                {
                                    ServerHandler.OnUserConnectedUDP(ServerHandler.clients[message.senderID]);
                                    UdpConnection udpConnection = new UdpConnection(iPEndPoint);
                                    udpConnection.user = ServerHandler.clients[message.senderID];
                                    ServerHandler.clients[message.senderID].udpConnection = udpConnection;
                                    ServerHandler.udpConnections.Add(iPEndPoint, udpConnection);
                                }
                                udpUser = ServerHandler.clients[message.senderID];
                            }
                            else
                            {
                                udpUser = new User(message.senderID);
                                udpUser.udpConnection = new UdpConnection(iPEndPoint);
                                ServerHandler.udpConnections.Add(iPEndPoint, udpUser.udpConnection);

                                ServerHandler.AddConnection(udpUser);

                                Matchmaking.DefaultRoom.instance.JoinToRoom(udpUser);

                                ServerHandler.OnUserConnectedUDP(udpUser);

                                if (udpUser.info == null)
                                {
                                    udpUser.info = ServerHandler.DataBaseBehaivour.GetUserData(message.senderID);
                                }
                                if (udpUser.info == null)
                                {
                                    udpUser.info = ServerHandler.DataBaseBehaivour.CreateUser(message.senderID);
                                }
                            }
                            SynchronizableTypes.InvokeTypeActionUDP(type, bytes, message, ServerHandler.clients[message.senderID]);
                        }
                    }
                    else
                    {
                        ServerHandler.udpConnections[iPEndPoint].user.currentRoom.BroadcastMessageUDP(bytes);
                    }
                }
            }
        }