C# IRoom类代码示例

        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;
        }