C# IRoom.Ensure方法代码示例

        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 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 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[] 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 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 bool IsRoomOwner(this IMember member, IRoom room)
        {
            room.Ensure("room");
            member.Ensure("member");

            return room.OwnerId == member.Id;
        }

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

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

            if (!sender.IsRoomOwner(room))
                return new[]
                {
                    new PostHandlerOutput
                    {
                        message = "Only the room's owner can view unused invitations.",
                        type= "error"
                    }
                };

            var invitations = documentSession.GetInvitationsByRoom(room.Id)
                .ToArray();

            if (invitations.Length == 0)
                return new[]
                {
                    new PostHandlerOutput
                    {
                        message = "There are no unused invitations.",
                        type = "system"
                    }
                };

            var buffer = new StringBuilder();
            buffer.AppendLine("Unused invitations:");
            foreach (var invitation in invitations)
            {
                buffer.AppendFormat("- {0}?invitation-code={1}", fn.MakeAbsoluteUri(Paths.AcceptInvitationForm()), invitation.Code);
                buffer.AppendLine();
            }

            return new[]
            {
                new PostHandlerOutput
                {
                    message = buffer.ToString(),
                    type = "system"
                }
            };
        }

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

            source = source.Trim();

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

            if (!sender.IsRoomOwner(room))
                return new[]
                {
                    new PostHandlerOutput
                    {
                        message = "Only the room's owner can speak as an NPC.",
                        type= "error"
                    }
                };

            var npc = match.Groups[1].Value;
            var dialogue = match.Groups[2].Value.Trim();

            if (!dialogue.StartsWith("\"", StringComparison.OrdinalIgnoreCase))
                dialogue = String.Concat("\"", dialogue);

            if (!dialogue.EndsWith("\"", StringComparison.OrdinalIgnoreCase))
                dialogue = String.Concat(dialogue, "\"");

            var text = string.Concat(
                npc,
                ": ",
                dialogue);

            documentSession.CreatePost(room.Id, sender.Id, null, source, "npc-dialogue", text);

            return PostHandlerOutput.Empty;
        }

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

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

            if (!sender.IsRoomOwner(room))
                return new[]
                {
                    new PostHandlerOutput
                    {
                        message = "Only the room's owner can invite players.",
                        type= "error"
                    }
                };

            var playerInvitation = documentSession.CreatePlayerInvitation(room.Id);

            return new[]
            {
                new PostHandlerOutput
                {
                    message = string.Format(
                        CultureInfo.CurrentUICulture,
                        "Give this URL to someone to join the game:{0}{1}?invitation-code={2}",
                        Environment.NewLine,
                        fn.MakeAbsoluteUri(Paths.AcceptInvitationForm()),
                        playerInvitation.Code),
                    type= "system"
                }
            };
        }