Ejemplo n.º 1
0
        public void Disconnect()
        {
            if (!connected)
            {
                throw new Exception("You are not connected already");
            }
            connected = false;


            ip   = "";
            port = 0;
            room = null;
            me   = null;


            try
            {
                TCPMessageHandler.CloseConnection(server_client);
            }
            catch { }
            try
            {
                listenerThread.Abort();
                listenerThread = null;
            }
            catch { }
        }
Ejemplo n.º 2
0
 public static bool Host(int Port, SharpRoom room, out HostResult result)
 {
     if (IsConnected)
     {
         result = HostResult.AlreadyHosted;
         return(false);
     }
     return(_ishost = isconnected = server.Host(out result, Port, room));
 }
Ejemplo n.º 3
0
        public void Disconnect()
        {
            if (!hosted)
            {
                throw new Exception("You are not hosted already");
            }
            hosted = false;

            foreach (var item in this.room.ConnectedClients)
            {
                try
                {
                    TCPMessageHandler.CloseConnection(item.Connection);
                }
                catch { }

                try
                {
                    item.ListeningThread.Abort();
                }
                catch { }

                item.ListeningThread = null;
            }

            port         = 0;
            serverclient = null;
            room         = null;



            try
            {
                listener.Stop();
            }
            catch { }
            try
            {
                listener = null;
            }
            catch { }

            try
            {
                S_StoppedHosted();
            }
            catch { }

            try
            {
                listenerThread.Abort();
                listenerThread = null;
            }
            catch { }
        }
Ejemplo n.º 4
0
        public bool Host(out HostResult result, int Port, SharpRoom room)
        {
            if (hosted)
            {
                result = HostResult.AlreadyHosted;
                return(false);
            }
            try
            {
                this.port = Port;
                this.room = room;

                IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, this.port);
                listener = new TcpListener(endPoint);
                listener.Start();

                serverclient = new SharpClient("ServerClient");
                room.AssignClient(serverclient);

                listenerThread = new Thread(ListenClients);
                listenerThread.Start();

                hosted = true;

                S_OnHosted();
                result = HostResult.Succes;
                return(true);
            }
            catch (Exception e)
            {
                try { listener.Stop(); } catch { }
                try { listenerThread.Abort(); } catch { }

                listenerThread = null;
                listener       = null;
                hosted         = false;

                result = HostResult.UnhandledException;
                return(false);
            }
        }
Ejemplo n.º 5
0
 void C_OnConnected(SharpRoom room)
 {
     //Console.WriteLine("Connected To Server : Room name => " + room.RoomName);
     SharpNetworking.Instance._OnNetworkEvent(SharpNetworkEvent.Connected);
 }
Ejemplo n.º 6
0
        public bool Connect(string IP, int Port, string Password, SharpClient Self, out ConnectResults result)
        {
            if (Password == null)
            {
                Password = "";
            }
            if (this.connected)
            {
                result = ConnectResults.AlreadyConnected;
                return(false);
            }
            try
            {
                server_client = new TcpClient();
                IPAddress address = null;
                #region IP Parse
                try
                {
                    address = IPAddress.Parse(IP);
                }
                catch
                {
                    result = ConnectResults.InvalidIpAddress;
                    return(false);
                }
                #endregion
                IPEndPoint remoteAddress = new IPEndPoint(address, Port);

                #region Physical Connetion
                try
                {
                    server_client.Connect(remoteAddress);
                }
                catch
                {
                    result = ConnectResults.UnhandledException;
                    return(false);
                }
                #endregion

                #region ID Self
                SharpSerializer hailMessage = SharpSerializer.Create();

                hailMessage.Write((byte)IncomingConnectionRequests.ConnectionApprove);
                Self.Write(ref hailMessage);
                hailMessage.Write(Password);

                TCPMessageHandler.Write(server_client, hailMessage.DataAndPost());
                #endregion

                #region Wait For Response
                byte[]          responseRaw = TCPMessageHandler.Read(server_client);
                SharpSerializer response    = SharpSerializer.Create(responseRaw);
                #endregion

                IncomingConnectionResponse message = (IncomingConnectionResponse)response.ReadByte();
                if (message == IncomingConnectionResponse.WrongPassword)
                {
                    TCPMessageHandler.CloseConnection(server_client);
                    result = ConnectResults.InvalidPassword;
                    return(false);
                }
                if (message == IncomingConnectionResponse.ServerIsFull)
                {
                    TCPMessageHandler.CloseConnection(server_client);
                    result = ConnectResults.ServerIsFull;
                    return(false);
                }
                if (message == IncomingConnectionResponse.NameIsExist)
                {
                    TCPMessageHandler.CloseConnection(server_client);
                    result = ConnectResults.NameIsExist;
                    return(false);
                }


                short myID = response.ReadInt16();
                Self.AssingNetID(myID);

                this.room = new SharpRoom(ref response);

                this.listenerThread = new Thread(ListenServer);
                this.listenerThread.Start();

                connected = true;

                me = Self;
                room.AssignClient(me);

                room.Server.Connection      = server_client;
                room.Server.ListeningThread = listenerThread;

                C_OnConnected(room);

                result = ConnectResults.Succes;
                return(true);
            }
            catch (Exception e)
            {
                try
                {
                    TCPMessageHandler.CloseConnection(server_client);
                }
                catch { }
                server_client = null;

                connected = false;

                try
                {
                    listenerThread.Abort();
                }
                catch { }
                listenerThread = null;

                me = null;

                room = null;

                result = ConnectResults.UnhandledException;
                return(false);
            }
        }