示例#1
0
 public void AddMember(Client memberToAdd)
 {
     lock (roomLock)
     {
         _members.Add(memberToAdd);
     }
 }
示例#2
0
        public void AddMemberToRoom(Client roomHost, ref Client memberToAdd)
        {
            Room room;

            lock (_roomListLock)
            {
                room = _roomList.FirstOrDefault(myRoom => myRoom.Host == roomHost);
            }

            if (room == null) return;

            //
            // First, remove the member from his previous room.
            //

            RemoveMemberfromRoom(memberToAdd.Room.Host, memberToAdd);

            //
            // Now add the member to the new room.
            //

            room.Members.Add(memberToAdd);
            memberToAdd.Room = room;

            //
            // Send a message to all the existing members in the room indicating who has joined.
            //

            MessageSender.BroadcastMessage(
                room.Members,
                PacketType.s_UserJoinedRoom,
                memberToAdd.UserInfo,
                memberToAdd);

            //
            // Now send a message to the person who has joined containing the list of room
            // members.
            //

            var friendList = new FriendList();

            foreach (var c in room.Members)
            {
                friendList.Friends.Add(c.UserInfo);
            }

            MessageSender.SendMessage(
                memberToAdd,
                PacketType.s_RoomList,
                friendList);

            //
            // Now tell the joining person who the room host is.
            //

            MessageSender.SendMessage(
                memberToAdd,
                PacketType.s_HostTransfer,
                room.Host.UserInfo);
        }
示例#3
0
        internal Room(Client host)
        {
            _host = host;
            _members = new List<Client> {_host};
            _clientsReadyForGame = new List<Client>();

            roomLock = new object();
        }
示例#4
0
 /// <summary>
 /// Sends a message to everyone on the list of the recipients, with the exception of the 
 /// sender client, as you don't want to send a message to yourself.
 /// </summary>
 /// <param name="recipients"></param>
 /// <param name="packetType"></param>
 /// <param name="data"></param>
 /// <param name="sender">Client that is sending this message, set to null if this is not a
 /// user-initiated message</param>
 public static void BroadcastMessage(IEnumerable<Client> recipients, PacketType packetType, object data, Client sender)
 {
     foreach (var c in recipients)
     {
         if (c != sender)
         {
             SendMessage(c, packetType, data);
         }
     }
 }
        public void Initialize()
        {
            //
            // Generate the client manager and add a number of clients to the server.
            //

            clientManager = ClientManager.GetInstance();

            for (int i = 0; i < k_clientCount; i++)
            {
                var newClient = new Client(null);
                newClient.UserInfo.EmailAddress = "TestUser" + i.ToString();

                clientManager.AddClient(newClient);
            }
        }
示例#6
0
        public void AddClient(Client client)
        {
            lock (clientListLock)
            {
                _globalClientList.Add(client);
            }

            var db = Database.GetInstance();

            var user = db.GetUserByEmail(client.UserInfo.EmailAddress);

            if (user == null)
            {
                return;
            }

            var friend = MessageReceiver.GetFriendFromUser(user);

            //
            // Send a message saying that the user logged on to all of his friends who are online.
            //

            var friends = db.GetFriends(client.UserInfo.EmailAddress);
            var onlineFriends = new List<Client>();

            if (friends == null)
            {
                return;
            }

            foreach (user frd in friends)
            {
                var c = GetClientFromEmailAddress(frd.email);
                if (null != c)
                {
                    onlineFriends.Add(c);
                }
            }

            MessageSender.BroadcastMessage(
                onlineFriends,
                PacketType.s_UserLoggedIn,
                friend,
                client);
        }
示例#7
0
        /// <summary>
        /// TCP thread that listens for incoming connections.
        /// </summary>
        public static async void TcpListenerProcess()
        {
            Trace.WriteLine("TCP: Starting TcpListener...");

            //IPAddress addr = IPAddress.Loopback;

            try
            {


#if DEBUG
                const int port = 4032;
                var addr = new IPAddress(new byte[] { 192, 168, 1, 2 });
                var listener = new TcpListener(addr, port);
                Trace.WriteLine(string.Format("TCP: Listening on {0}:{1}...", addr, port));
#else
                var listener = new TcpListener(
                    RoleEnvironment.CurrentRoleInstance.InstanceEndpoints["Endpoint1"].IPEndpoint);

                listener.ExclusiveAddressUse = false;
#endif

                listener.Start();

                while (true)
                {
                    var socket = await listener.AcceptSocketAsync();
                    var newClient = new Client(socket);
                    newClient.OnDisconnected += OnClientDisconnected;

                    //WorkerRole.ClientManager.GlobalClientList.Add(newClient);
                    newClient.ReceiveAsync();
                }
            }
            catch (Exception e)
            {
                Trace.WriteLine(string.Format("TCP: Caught exception!! '{0}'\n{1}", e.Message, e.StackTrace));
                Trace.WriteLine("TcpListener shutting down.");
            }
        }
示例#8
0
        public void HandleMessage(ref Client client, byte[] msgBytes)
        {
            var packetBase = new PacketBase();

            using (var stream = new MemoryStream(msgBytes))
            {
                try
                {
                    var reader = new BinaryReader(stream);

                    packetBase.Read(reader);
                }
                catch (Exception e)
                {
            #if DEBUG
                    throw;
            #else
                    Trace.WriteLine(string.Format("[IncomingMessageHandler.HandleMessage] - " +
                            "Invalid packet from client! Deserialization failed: {0}, Trace: {1}",
                            e.Message,
                            e.StackTrace));
            #endif
                }
            }

            var handler = PacketHandlerFactory.GetPacketHandler(packetBase);

            if (handler != null)
            {
                handler.DoActions(ref client);
            }
        }
示例#9
0
        public void RemoveMember(Client memberToRemove)
        {
            lock (roomLock)
            {
                var member =
                    _members.FirstOrDefault(m => m.UserInfo.EmailAddress == memberToRemove.UserInfo.EmailAddress);

                if (null != member)
                {
                    _members.Remove(member);
                }
            }
        }
示例#10
0
        public void ChangeToRandomNewHost()
        {
            var random = new Random();

            lock (roomLock)
            {
                if (_members.Count > 0)
                {
                    var index = random.Next(0, _members.Count - 1);
                    _host = _members[index];
                }

                MessageSender.BroadcastMessage(
                    _members,
                    PacketType.s_HostTransfer,
                    _host.UserInfo);
            }
        }
示例#11
0
        public void RemoveClient(Client client)
        {
            lock (clientListLock)
            {
                _globalClientList.Remove(client);
            }

            var db = Database.GetInstance();

            if (client.UserInfo == null)
            {
                return;
            }

            var user = db.GetUserByEmail(client.UserInfo.EmailAddress);

            var friend = MessageReceiver.GetFriendFromUser(user);

            //
            // Remove the user from his room in case he is still part of one.
            //

            var roomManager = RoomManager.GetInstance();

            roomManager.RemoveMemberfromRoom(client.Room.Host, client);

            //
            // Send a message saying that the user logged off to all of his friends who are online.
            //

            var friends = db.GetFriends(client.UserInfo.EmailAddress);

            if (null == friends)
            {
                return;
            }

            var onlineFriends = new List<Client>();

            foreach (user frd in friends)
            {
                var c = GetClientFromEmailAddress(frd.email);
                if (null != c)
                {
                    onlineFriends.Add(c);
                }
            }

            MessageSender.BroadcastMessage(
                    onlineFriends,
                    PacketType.s_UserLoggedOut,
                    friend,
                    client);
        }
示例#12
0
        public Room CreateNewRoom(Client host)
        {
            var newRoom = new Room(host);

            lock (_roomListLock)
            {
                _roomList.Add(newRoom);
            }

            return newRoom;
        }
示例#13
0
 public void ChangeHost(Client host)
 {
     lock (roomLock)
     {
         _host = host;
     }
 }
示例#14
0
        public List<Client> GetRoomMembers(Client host)
        {
            var roomMembers = new List<Client>();

            lock (_roomListLock)
            {
                foreach (var room in _roomList.Where(room => room.Host == host))
                {
                    roomMembers = room.Members;
                    break;
                }
            }

            return roomMembers;
        }
示例#15
0
        public void SignalClientIsReadyForGame(Client client)
        {
            // ToDo: Add some sort of time out guard here and drop clients if they take too long to respond.
            _clientsReadyForGame.Add(client);

            //
            //  If this condition has been met, it means that all of the clients are ready.
            //

            if (_clientsReadyForGame.Count == _members.Count)
            {
                MessageSender.BroadcastMessage(_members, PacketType.s_GameStart, null);

                _clientsReadyForGame.Clear();

                RoomStatus = RoomStatus.InGame;
            }
        }
示例#16
0
        /// <summary>
        /// Helper method that sends two messages to the user: A complete friend list,
        /// and then a list of friends that are online.
        /// </summary>
        /// <param name="client"></param>
        public static void SendOnlineAndCompleteFriendList(Client client)
        {
            //
            // Send the user a list of all of their friends.
            //

            var db = Database.GetInstance();
            var friendList = db.GetFriends(client.UserInfo.EmailAddress);

            if (null != friendList)
            {
                var friendListString = CreateFriendListFromUserList(friendList);

                MessageSender.SendMessage(
                        client,
                        PacketType.s_FriendList,
                        friendListString);

                //
                // Send the user a list of all of their friends who are online.
                //

                var onlineUsers = new List<user>();

                foreach (var frd in friendList)
                {
                    var clientManager = ClientManager.GetInstance();
                    var onlineClient = clientManager.GetClientFromEmailAddress(frd.email);

                    if (null != onlineClient)
                    {
                        onlineUsers.Add(frd);
                    }
                }

                var onlineFriends = CreateFriendListFromUserList(onlineUsers);

                MessageSender.SendMessage(
                    client,
                    PacketType.s_OnlineFriendList,
                    onlineFriends);
            }
        }
示例#17
0
        public static void SendMessage(Client recipient, PacketType packetType, object data)
        {
            if (recipient == null)
            {
                return;
            }

            #if DEBUG
            //
            // If we're debugging, make sure that the data type matches that required by the packetType, or else throw an exception.
            //

            var type = DataPacket.PacketTypeMap[packetType];

            if (type != null)
            {
                var testObject = Convert.ChangeType(data, type);
            }
            else
            {
                if (data != null)
                {
                    throw new ArgumentException("Data from this packet type was expected to be null, but wasn't.");
                }
            }
            #endif

            // ToDo: Don't hardcode Packet Version 1 here.  Instead, add a packet version property to Client, and switch on that.
            var packetBase = new PacketBase {PacketVersion = PacketVersion.Version1};

            var packetV1 = new PacketV1
            {
                PacketType = packetType,
                Data = data,
                Sender = ServerName
            };

            packetV1.Recipients.Add(recipient.UserInfo.EmailAddress);

            packetBase.Data = packetV1;

            dynamic baseBuffer;

            using (var stream = new MemoryStream())
            {
                var binaryWriter = new BinaryWriter(stream);

                packetBase.Write(binaryWriter);

                baseBuffer = stream.ToArray();
            }

            var messageSize = baseBuffer.Length;

            byte[] bytes = BitConverter.GetBytes(messageSize);

            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(bytes);
            }

            var offset = 0;

            var messageBuffer = new byte[sizeof(uint) + messageSize];

            bytes.CopyTo(messageBuffer, offset);

            offset += sizeof(uint);

            baseBuffer.CopyTo(messageBuffer, offset);

            recipient.Send(messageBuffer);
        }
示例#18
0
        public void RemoveMemberfromRoom(Client roomHost, Client memberToRemove)
        {
            Room room;

            lock (_roomListLock)
            {
                room = _roomList.FirstOrDefault(myRoom => myRoom.Host == roomHost);
            }

            if (room == null) return;

            room.Members.Remove(memberToRemove);

            if (roomHost == memberToRemove)
            {
                room.ChangeToRandomNewHost();
            }

            if (0 == room.Members.Count)
            {
                lock (_roomListLock)
                {
                    _roomList.Remove(room);
                }
            }
            else
            {
                MessageSender.BroadcastMessage(
                    room.Members,
                    PacketType.s_UserLeftRoom,
                    memberToRemove.UserInfo,
                    memberToRemove);
            }
        }