public Task<Option<IPlayer>> RequestAvailablePlayerAsync(IRoom room)
        {
            var player = players.Values.FirstOrDefault(p => !p.CurrentRoom.HasValue);
            player?.AssignToRoom(room);

            return Task.FromResult(Option.Create((IPlayer)player));
        }

        public static PostHandlerOutput[] OOCMessage(
            IDocumentSession documentSession,
            IMember sender,
            IRoom room,
            string source)
        {
            documentSession.Ensure("documentSession");
            sender.Ensure("sender");
            room.Ensure("room");
            source.Ensure("source");

            var match = oocMessageRegex.Match(source);
            if (!match.Success)
                return null;

            var message = match.Groups[1].Value;

            var text = string.Concat(
                "(( ",
                sender.Alias,
                ": ",
                message,
                " ))");

            documentSession.CreatePost(room.Id, sender.Id, sender.EmailAddress.GravatarUrl(), source, "ooc-message", text);

            return PostHandlerOutput.Empty;
        }

 public void updateCurrentRoom(IRoom model)
 {
     if (currentRoom)
         Destroy(currentRoom.gameObject);
     currentRoom = makeCurrent(model);
     currentRoom.roomeEnabled = true;
 }

        public static bool IsRoomPlayer(this IMember member, IRoom room)
        {
            room.Ensure("room");
            member.Ensure("member");

            return room.Players.Any(player => player.MemberId == member.Id);
        }

        public static PostHandlerOutput[] HandlePost(
            IDocumentSession documentSession,
            IMember sender,
            IRoom room,
            string source)
        {
            documentSession.Ensure("documentSession");
            sender.Ensure("sender");
            room.Ensure("room");
            source.Ensure("source");

            if (_postHandlers == null)
                throw new InvalidOperationException("Post handlers haven't been set yet.");

            if (!CanPost(room, sender))
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.InvariantCulture,
                        "Member '{0}' cannot post to room '{1}'.",
                        sender.Id,
                        room.Id));
            }

            return _postHandlers
                .Select(slashCommand => slashCommand(
                    documentSession,
                    sender,
                    room,
                    source))
                .FirstOrDefault(result => result != null);
        }

        public static void NotifyRoom(IRoom room, IPost post, IMailSender mailSender)
        {
            var context = GlobalHost.ConnectionManager.GetHubContext<RoomHub>();

            context.Clients.Group(String.Concat("room-", post.RoomId))
                .post(post.Id, post.Type, post.AuthorAlias, post.AvatarUrl, post.Text, post.Timestamp.ToString("MMM dd yy @ hh:mm tt"));

            IEnumerable<string> emailAddresses;
            if (post.AuthorId == room.OwnerId)
                emailAddresses = room.Players.Select(x => x.MemberEmailAddress);
            else
                emailAddresses =
                    room.Players
                        .Where(x => x.MemberId != post.AuthorId)
                        .Select(x => x.MemberEmailAddress)
                        .Concat(new[] { room.OwnerEmailAddress });

            var subject = String.Concat("[", room.Slug, "] ", "New Post");
            const string bodyFormat = @"There's a new post to {0}:

            {1}

            Visit the room at {2}.";
            var body = String.Format(CultureInfo.CurrentUICulture, bodyFormat, room.Title, post.Text, MakeAbsoluteUri(Paths.Room(room.Slug)));

            emailAddresses.ForEach(x => SendMail(x, subject, body));
        }

        public static PostHandlerOutput[] RollCommand(
            IDocumentSession documentSession,
            IMember sender,
            IRoom room,
            string source)
        {
            documentSession.Ensure("documentSession");
            sender.Ensure("sender");
            room.Ensure("room");
            source.Ensure("source");

            var match = rollCommandRegex.Match(source);
            if (!match.Success)
                return null;

            var number = int.Parse(match.Groups[1].Value);
            var sides = int.Parse(match.Groups[2].Value);

            var diceRolled = string.Join(
                ", ",
                fn.RollDice(number, sides).ToArray());

            var text = string.Format(
                CultureInfo.CurrentUICulture,
                "{0} rolled {1}d{2} with the result: {3}.",
                sender.Alias,
                number,
                sides,
                diceRolled);

            documentSession.CreatePost(room.Id, sender.Id, null, source, "roll-result", text);

            return PostHandlerOutput.Empty;
        }

        public static PostHandlerOutput[] GMNarration(
            IDocumentSession documentSession,
            IMember sender,
            IRoom room,
            string source)
        {
            documentSession.Ensure("documentSession");
            sender.Ensure("sender");
            room.Ensure("room");
            source.Ensure("source");

            if (!sender.IsRoomOwner(room))
                return null;

            source = source.Trim();

            if (source.StartsWith("/", StringComparison.OrdinalIgnoreCase))
                return null;

            var text = string.Concat(
                "GM: ",
                source);

            documentSession.CreatePost(room.Id, sender.Id, null, source, "gm-narration", text);

            return PostHandlerOutput.Empty;
        }

        public static bool IsRoomOwner(this IMember member, IRoom room)
        {
            room.Ensure("room");
            member.Ensure("member");

            return room.OwnerId == member.Id;
        }

    public TranscriptViewModel(IRoom room, ISite site, string searchTerm, 
      DateTime searchDate, MessageViewModelFactory messageViewModelFactory, IEventAggregator eventAggregator)
    {
      this.room = room;
      this.site = site;

      this.SearchTerm = searchTerm;
      this.SearchDate = searchDate;

      this.dispatcher = Dispatcher.CurrentDispatcher;

      this.messageViewModelFactory = messageViewModelFactory;
      this.Messages = new ObservableCollection<ViewModelBase>();
      this.Rooms = new ObservableCollection<RoomViewModel>();

      if (!string.IsNullOrWhiteSpace(this.SearchTerm))
        SearchByString();
      else if (this.SearchDate != DateTime.MinValue)
        SearchByDate();

      if (SearchDate == DateTime.MinValue)
        SearchDate = DateTime.Today;

      this.SearchByStringCommand = new RelayCommand(SearchByString);
      this.SearchByDateCommand = new RelayCommand(SearchByDate);

      foreach (var r in this.site.Rooms)
        this.Rooms.Add(new RoomViewModel(site, null, r, eventAggregator));
    }

        public static PostHandlerOutput[] PCNarration(
            IDocumentSession documentSession,
            IMember sender,
            IRoom room,
            string source)
        {
            documentSession.Ensure("documentSession");
            sender.Ensure("sender");
            room.Ensure("room");
            source.Ensure("source");

            source = source.Trim();
            if (source.StartsWith("/", StringComparison.OrdinalIgnoreCase))
                return null;

            if (!sender.IsRoomPlayer(room))
                return null;

            var player = room.Players.SingleOrDefault(x => x.MemberId == sender.Id);
            if (player == null)
                return null;

            var text = string.Concat(
                player.CharacterName,
                ": ",
                source);

            documentSession.CreatePost(room.Id, sender.Id, null, source, "pc-narration", text);

            return PostHandlerOutput.Empty;
        }

 public void Render(IRoom room)
 {
     for (int i = 0; i < room.Length; i++)
     {
         for(int j = 0; j < room.Length; j++)
             Console.WriteLine("a");
     }
 }

        /// <summary>
        /// Joins the room.
        /// </summary>
        /// <param name="session">The session.</param>
        /// <param name="room">The room.</param>
        /// <returns></returns>
        /// Permite a un usuario en sesión ingresar a una sala,
        /// si el usuario en sesión no está autentificado, se lanzará una
        /// excepción de seguridad
        /// *
        /// <remarks>TODO: Pruebas unitarias para este método.</remarks>
        public IOperationResult<IRoomUser> JoinRoom(IUserSession session, IRoom room)
        {
            RoomUser rUser = new RoomUser(session, room);
              this.roomsUserLists[room].Add(rUser);
              messaging.Publish(room, Tuple.Create(session, RoomAction.Join));

              return new OperationResult<IRoomUser>(ResultValue.Success, "", rUser);
        }

 public UserManager(IRoom room)
 {
     mRoom = (Room)room;
     mSocketHander = mRoom.SocketHander;
     mSocketHander.AddListener(this, ENUM_SOCKET_EVENT.EVENT_MESSAGE, OnUserEnterEvent, (ushort)MAIN_CMD.MDM_GR_USER, (ushort)USER_SUB_CMD.SUB_GR_USER_ENTER, typeof(tagUserInfo));
     mSocketHander.AddListener(this, ENUM_SOCKET_EVENT.EVENT_MESSAGE, OnUserStatusEvent, (ushort)MAIN_CMD.MDM_GR_USER, (ushort)USER_SUB_CMD.SUB_GR_USER_STATUS, typeof(CMD_GR_UserStatus));
     mSocketHander.AddListener(this, ENUM_SOCKET_EVENT.EVENT_MESSAGE, OnUserScoreEvent, (ushort)MAIN_CMD.MDM_GR_USER, (ushort)USER_SUB_CMD.SUB_GR_USER_SCORE, typeof(CMD_GR_UserScore));
 }

        public async Task<IDoorway> CreateDoor(string doorwayName, IRoom departureRoom, ITravelDirection travelDirection)
        {
            var doorway = new MudDoor();
            await doorway.ConnectRoom(travelDirection, departureRoom);
            doorway.SetName(doorwayName);

            return doorway;
        }

        public IOperationResult<IRoomUser> JoinRoom(IUserSession session, IRoom room)
        {
            Contract.Requires(room != null, "room is null.");
            Contract.Requires(session != null, "session is null.");
            Contract.Ensures(Contract.Result<IOperationResult<IRoomUser>>() != null);

            return default(IOperationResult<IRoomUser>);
        }

			public RoomCrossFader(RoomMusicCrossFading crossFading, IRoom room)
			{
				_crossFading = crossFading;
				Room = room;

				room.Events.OnBeforeFadeOut.Subscribe(onBeforeFadeOut);
				room.Events.OnBeforeFadeIn.Subscribe(onBeforeFadeIn);
			}

        //called from the LOOK command
        private static string DisplayPlayersInRoom(IRoom room, ObjectId ignoreId) {
            StringBuilder sb = new StringBuilder();

            if (!room.IsDark) {
                foreach (var id in room.GetObjectsInRoom(RoomObjects.Players)) {
                    if (!id.Equals(ignoreId)) {
                        IUser otherUser = Server.GetAUser(id);
                        if (otherUser != null && otherUser.CurrentState == UserState.TALKING) {
                            if (otherUser.Player.ActionState != CharacterActionState.Hiding && otherUser.Player.ActionState != CharacterActionState.Sneaking){  //(string.IsNullOrEmpty(PassesHideCheck(otherUser, ignoreId, out spot))) { //player should do a spot check this should not be a given
                                sb.AppendLine(otherUser.Player.FirstName + " is " + otherUser.Player.StanceState.ToString().ToLower() + " here.");
                            }  
                        }
                    }
                }
                Dictionary<string, int> npcGroups = new Dictionary<string, int>();

                foreach (var id in room.GetObjectsInRoom(RoomObjects.Npcs)) {
                    var npc = Character.NPCUtils.GetAnNPCByID(id);

                    if (!npcGroups.ContainsKey(npc.FirstName + "$" + npc.LastName + "$" + npc.StanceState)) {
                        npcGroups.Add(npc.FirstName + "$" + npc.LastName + "$" + npc.StanceState, 1);
                    }
                    else {
                        npcGroups[npc.FirstName + "$" + npc.LastName + "$" + npc.StanceState] += 1;
                    }
                }

                foreach (KeyValuePair<string, int> pair in npcGroups) {
                    string[] temp = pair.Key.Split('$');
                    sb.AppendLine(temp[0] + " is " + temp[2].Replace("_", " ").ToLower() + " here. " + (pair.Value > 1 ? ("[x" + pair.Value + "]") : ""));
                }
            }
            else {
                int count = 0;
                foreach (var id in room.GetObjectsInRoom(RoomObjects.Players)) {
                    if (!id.Equals(ignoreId)) {
                        IUser otherUser = Server.GetAUser(id);
                        if (otherUser != null && otherUser.CurrentState == UserState.TALKING) {
                            if (otherUser.Player.ActionState != CharacterActionState.Hiding && otherUser.Player.ActionState != CharacterActionState.Sneaking) {  //player should do a spot check this should not be a given
                                count++;
                            }
                        }
                    }
                }
                count += room.GetObjectsInRoom(RoomObjects.Npcs).Count;

                if (count == 1) {
                    sb.AppendLine("A presence is here.");
                }
                else if (count > 1) {
                    sb.AppendLine("Several presences are here.");
                }
            }

            return sb.ToString();
        }

        private static void addWalls(GameObject room, IRoom model)
        {
            addCeiling(room, model.walls[0]);
            addFloor(room, model.walls[2]);

            if (model.walls[1])
                addRightWall(room);
            if (model.walls[3])
                addLeftWall(room);
        }

        public TableManager(IRoom room)
        {
            mRoom = (Room)room;
            mSocketHander = mRoom.SocketHander;

            //桌子信息
            mSocketHander.AddListener(this, ENUM_SOCKET_EVENT.EVENT_MESSAGE, OnTableStatusEvent, (ushort)MAIN_CMD.MDM_GR_STATUS, (ushort)STATUS_SUB_CMD.SUB_GR_TABLE_STATUS, typeof(CMD_GR_TableStatus));
            mSocketHander.AddListener(this, ENUM_SOCKET_EVENT.EVENT_MESSAGE, OnTableInfoEvent, (ushort)MAIN_CMD.MDM_GR_STATUS, (ushort)STATUS_SUB_CMD.SUB_GR_TABLE_INFO, typeof(CMD_GR_TableInfo));
            mSocketHander.AddListener(this, ENUM_SOCKET_EVENT.EVENT_MESSAGE, OnSystemMessageEvent, (ushort)MAIN_CMD.MDM_CM_SYSTEM, (ushort)SYSTEM_SUB_CMD.SUB_CM_SYSTEM_MESSAGE, typeof(CMD_CM_SystemMessage));
        }