C# Server.SendMessage方法代码示例

 public bool Ban(Server server, int sourceClientId, int targetClientId, string reason)
 {
     if (!server.PlayerHasPrivilege(sourceClientId, ServerClientMisc.Privilege.ban))
     {
         server.SendMessage(sourceClientId, string.Format(server.language.Get("Server_CommandInsufficientPrivileges"), server.colorError));
         return false;
     }
     if (!reason.Equals(""))
     {
         reason = server.language.Get("Server_CommandKickBanReason") + reason + ".";
     }
     ClientOnServer targetClient = server.GetClient(targetClientId);
     if (targetClient != null)
     {
         if (targetClient.clientGroup.IsSuperior(server.GetClient(sourceClientId).clientGroup) || targetClient.clientGroup.EqualLevel(server.GetClient(sourceClientId).clientGroup))
         {
             server.SendMessage(sourceClientId, string.Format(server.language.Get("Server_CommandTargetUserSuperior"), server.colorError));
             return false;
         }
         string targetName = targetClient.playername;
         string sourceName = server.GetClient(sourceClientId).playername;
         string targetNameColored = targetClient.ColoredPlayername(server.colorImportant);
         string sourceNameColored = server.GetClient(sourceClientId).ColoredPlayername(server.colorImportant);
         server.banlist.BanPlayer(targetName, sourceName, reason);
         SaveBanlist(server);
         server.SendMessageToAll(string.Format(server.language.Get("Server_CommandBanMessage"), server.colorImportant, targetNameColored, sourceNameColored, reason));
         server.ServerEventLog(string.Format("{0} bans {1}.{2}", sourceName, targetName, reason));
         server.SendPacket(targetClientId, ServerPackets.DisconnectPlayer(string.Format(server.language.Get("Server_CommandBanNotification"), reason)));
         server.KillPlayer(targetClientId);
         return true;
     }
     server.SendMessage(sourceClientId, string.Format(server.language.Get("Server_CommandNonexistantID"), server.colorError, targetClientId));
     return false;
 }

        public bool RestartMods(Server server, int sourceClientId)
        {
            if (!server.PlayerHasPrivilege(sourceClientId, ServerClientMisc.Privilege.restart))
            {
                server.SendMessage(sourceClientId, string.Format(server.language.Get("Server_CommandInsufficientPrivileges"), server.colorError));
                return false;
            }
            server.SendMessageToAll(string.Format(server.language.Get("Server_CommandRestartModsSuccess"), server.colorImportant, server.GetClient(sourceClientId).ColoredPlayername(server.colorImportant)));
            server.ServerEventLog(string.Format("{0} restarts mods.", server.GetClient(sourceClientId).playername));

            server.modEventHandlers = new ModEventHandlers();
            for (int i = 0; i < server.systemsCount; i++)
            {
                if (server.systems[i] == null) { continue; }
                server.systems[i].OnRestart(server);
            }

            LoadMods(server, true);
            return true;
        }

 public bool Unban(Server server, int sourceClientId, string type, string target)
 {
     if (!server.PlayerHasPrivilege(sourceClientId, ServerClientMisc.Privilege.unban))
     {
         server.SendMessage(sourceClientId, string.Format(server.language.Get("Server_CommandInsufficientPrivileges"), server.colorError));
         return false;
     }
     // unban a playername
     if (type.Equals("-p"))
     {
         // case insensitive
         bool exists = server.banlist.UnbanPlayer(target);
         SaveBanlist(server);
         if (!exists)
         {
             server.SendMessage(sourceClientId, string.Format(server.language.Get("Server_CommandPlayerNotFound"), server.colorError, target));
         }
         else
         {
             server.SendMessage(sourceClientId, string.Format(server.language.Get("Server_CommandUnbanSuccess"), server.colorSuccess, target));
             server.ServerEventLog(string.Format("{0} unbans player {1}.", server.GetClient(sourceClientId).playername, target));
         }
         return true;
     }
     // unban an IP
     else if (type.Equals("-ip"))
     {
         bool exists = server.banlist.UnbanIP(target);
         SaveBanlist(server);
         if (!exists)
         {
             server.SendMessage(sourceClientId, string.Format(server.language.Get("Server_CommandUnbanIPNotFound"), server.colorError, target));
         }
         else
         {
             server.SendMessage(sourceClientId, string.Format(server.language.Get("Server_CommandUnbanIPSuccess"), server.colorSuccess, target));
             server.ServerEventLog(string.Format("{0} unbans IP {1}.", server.GetClient(sourceClientId).playername, target));
         }
         return true;
     }
     server.SendMessage(sourceClientId, string.Format("{0}Invalid type: {1}", server.colorError, type));
     return false;
 }

    public override bool OnCommand(Server server, int sourceClientId, string command, string argument)
    {
        string[] ss;
        int id;
        int duration;

        Language language = server.language;
        string colorError = server.colorError;

        switch (command)
        {
            case "banip_id":
                ss = argument.Split(new[] { ' ' });
                if (!Int32.TryParse(ss[0], out id))
                {
                    server.SendMessage(sourceClientId, colorError + language.Get("Server_CommandInvalidArgs"));
                    return true;
                }
                if (ss.Length >= 2)
                {
                    BanIP(server, sourceClientId, id, string.Join(" ", ss, 1, ss.Length - 1));
                    return true;
                }
                BanIP(server, sourceClientId, id);
                return true;
            case "banip":
                ss = argument.Split(new[] { ' ' });
                if (ss.Length >= 2)
                {
                    BanIP(server, sourceClientId, ss[0], string.Join(" ", ss, 1, ss.Length - 1));
                    return true;
                }
                BanIP(server, sourceClientId, argument);
                return true;
            case "ban_id":
                ss = argument.Split(new[] { ' ' });
                if (!Int32.TryParse(ss[0], out id))
                {
                    server.SendMessage(sourceClientId, colorError + language.Get("Server_CommandInvalidArgs"));
                    return true;
                }
                if (ss.Length >= 2)
                {
                    Ban(server, sourceClientId, id, string.Join(" ", ss, 1, ss.Length - 1));
                    return true;
                }
                Ban(server, sourceClientId, id);
                return true;
            case "ban":
                ss = argument.Split(new[] { ' ' });
                if (ss.Length >= 2)
                {
                    Ban(server, sourceClientId, ss[0], string.Join(" ", ss, 1, ss.Length - 1));
                    return true;
                }
                Ban(server, sourceClientId, argument);
                return true;
            case "timebanip_id":  //Format: /timebanip_id <player_id> <duration> [reason]
                ss = argument.Split(new[] { ' ' });
                if (ss.Length < 2)
                {
                    server.SendMessage(sourceClientId, colorError + language.Get("Server_CommandInvalidArgs"));
                    return true;
                }
                if (!Int32.TryParse(ss[0], out id))
                {
                    server.SendMessage(sourceClientId, colorError + language.Get("Server_CommandInvalidArgs"));
                    return true;
                }
                if (!Int32.TryParse(ss[1], out duration))
                {
                    server.SendMessage(sourceClientId, colorError + language.Get("Server_CommandInvalidArgs"));
                    return true;
                }
                if (duration <= 0)
                {
                    server.SendMessage(sourceClientId, colorError + language.Get("Server_CommandTimeBanInvalidValue"));
                    return true;
                }
                if (ss.Length >= 3)
                {
                    this.TimeBanIP(server, sourceClientId, id, string.Join(" ", ss, 2, ss.Length - 2), duration);
                    return true;
                }
                this.TimeBanIP(server, sourceClientId, id, duration);
                return true;
            case "timebanip":  //Format: /timebanip <playername> <duration> [reason]
                ss = argument.Split(new[] { ' ' });
                if (ss.Length < 2)
                {
                    server.SendMessage(sourceClientId, colorError + language.Get("Server_CommandInvalidArgs"));
                    return true;
                }
                if (!Int32.TryParse(ss[1], out duration))
                {
                    server.SendMessage(sourceClientId, colorError + language.Get("Server_CommandInvalidArgs"));
                    return true;
                }
                if (duration <= 0)
                {
//.........这里部分代码省略.........

    public bool BanOffline(Server server, int sourceClientId, string target, string reason)
    {
        if (!server.PlayerHasPrivilege(sourceClientId, ServerClientMisc.Privilege.ban_offline))
        {
            server.SendMessage(sourceClientId, string.Format(server.language.Get("Server_CommandInsufficientPrivileges"), server.colorError));
            return false;
        }
        if (!reason.Equals(""))
        {
            reason = server.language.Get("Server_CommandKickBanReason") + reason;
        }

        if (server.GetClient(target) != null)
        {
            server.SendMessage(sourceClientId, string.Format(server.language.Get("Server_CommandBanOfflineTargetOnline"), server.colorError, target));
            return false;
        }

        // Target is at the moment not online. Check if there is an entry in ServerClient

        // Get related client from config file
        ManicDigger.Client targetClient = server.serverClient.Clients.Find(
            delegate(ManicDigger.Client client)
            {
                return client.Name.Equals(target, StringComparison.InvariantCultureIgnoreCase);
            }
        );

        // Entry exists.
        if (targetClient != null)
        {
            // Get target's group.
            ManicDigger.Group targetGroup = server.serverClient.Groups.Find(
                delegate(ManicDigger.Group grp)
                {
                    return grp.Name.Equals(targetClient.Group);
                }
            );
            if (targetGroup == null)
            {
                server.SendMessage(sourceClientId, string.Format(server.language.Get("Server_CommandInvalidGroup"), server.colorError));
                return false;
            }

            // Check if target's group is superior.
            if (targetGroup.IsSuperior(server.GetClient(sourceClientId).clientGroup) || targetGroup.EqualLevel(server.GetClient(sourceClientId).clientGroup))
            {
                server.SendMessage(sourceClientId, string.Format(server.language.Get("Server_CommandTargetUserSuperior"), server.colorError));
                return false;
            }

            // Remove target's entry.
            server.serverClient.Clients.Remove(targetClient);
            server.serverClientNeedsSaving = true;
        }

        // Finally ban user.
        server.banlist.BanPlayer(target, server.GetClient(sourceClientId).playername, reason);
        SaveBanlist(server);
        server.SendMessageToAll(string.Format(server.language.Get("Server_CommandBanOfflineMessage"), server.colorImportant, target, server.GetClient(sourceClientId).ColoredPlayername(server.colorImportant), reason));
        server.ServerEventLog(string.Format("{0} bans {1}.{2}", server.GetClient(sourceClientId).playername, target, reason));
        return true;
    }