C# TasSayEventArgs类代码示例

        public void FindLinks(string[] words, FileType type, TasClient tas, TasSayEventArgs e)
        {
            if (words.Length == 0)
            {
                Battle b = tas.MyBattle;
                if (b == null) return;
                ah.Respond(e, string.Format("Getting Zero-K mirrors for currently hosted {0}", type));
                if (type == FileType.Map) GetLinksAsync(b.MapName, e);
                else GetLinksAsync(b.ModName, e);
            }
            else
            {
                int[] resultIndexes;
                string[] resultVals;
                int cnt;
                if (type == FileType.Map) cnt = ah.FilterMaps(words, out resultVals, out resultIndexes);
                else cnt = ah.FilterMods(words, out resultVals, out resultIndexes);

                if (cnt == 0) ah.Respond(e, string.Format("No such {0} found", type));
                else
                {
                    ah.Respond(e, string.Format("Getting Zero-K mirrors for {0}, please wait", resultVals[0]));
                    GetLinksAsync(resultVals[0], e);
                }
            }
        }

 protected override bool PerformInit(TasSayEventArgs e, string[] words, out string question, out int winCount) {
     winCount = 0;
     question = null;
     if (ah.config.Mode == PlasmaShared.AutohostMode.Serious)
     {
         AutoHost.Respond(tas, spring, e, "Serious host, no custom options");
         return false;
     }
     if (spring.IsRunning)
     {
         AutoHost.Respond(tas, spring, e, "Cannot set options while the game is running");
         return false;
     }
     else
     {
         var wordFormat = Utils.Glue(words);
         scriptTagsFormat = ah.GetOptionsDictionary(e, words);
         if (scriptTagsFormat.Count==0) return false;
         else
         {
             question  = "Set option " + wordFormat + "?";
             return true;
         }
     }
 }

        protected virtual bool AllowVote(TasSayEventArgs e) {
            if (tas.MyBattle == null) return false;

            if (spring.IsRunning)
            {
                var entry = spring.StartContext.Players.FirstOrDefault(x => x.Name == e.UserName);
                if (entry == null || entry.IsSpectator)
                {
                    ah.Respond(e, string.Format("You must be a player in the game"));
                    return false;
                }
                else return true;
            }
            else
            {
                UserBattleStatus entry;
                tas.MyBattle.Users.TryGetValue(e.UserName, out entry);
                if (entry == null || entry.IsSpectator)
                {
                    ah.Respond(e, string.Format("Only players can vote"));
                    return false;
                }
                else return true;
            }
        }

        protected override bool PerformInit(TasSayEventArgs e, string[] words, out string question, out int winCount) {
            winCount = 0;
            question = null;
            if (spring.IsRunning)
            {
                question = "Exit this game?";
                int cnt = 0;
                context = spring.StartContext;
                foreach (var p in context.Players.Where(x => !x.IsSpectator))
                {
                    if (p.IsIngame || tas.MyBattle.Users.ContainsKey(p.Name))
                    {
                        //Note: "ExistingUsers" is empty if users disconnected from lobby but still ingame.

                        bool afk = tas.ExistingUsers.ContainsKey(p.Name) && tas.ExistingUsers[p.Name].IsAway;
                        if (!afk) cnt++;
                    }
                }
                winCount = cnt / 2 + 1;
                return true;
            }
            else
            {
                AutoHost.Respond(tas, spring, e, "game not running");
                return false;
            }
        }

        protected override bool PerformInit(TasSayEventArgs e, string[] words, out string question, out int winCount)
        {
            winCount = (tas.MyBattle != null) ? (tas.MyBattle.Users.Count - 1) : 1;
            question = null;
            if (words.Length < 1)
            {
                ah.Respond(e, "<target hostname>");
                return false;
            }
            host = words[0];

            var target_battle = tas.ExistingBattles.Values.FirstOrDefault(x => x.Founder.Name == host);
            if (target_battle == null)
            {
                ah.Respond(e, string.Format("Host {0} not found", words[0]));
                return false;
            }

            if (target_battle.IsPassworded)
            {
                ah.Respond(e, string.Format("Move forbidden: host {0} is passworded.", words[0]));
                return false;
            }

            question = string.Format("Do you want to join {0}?", host);
            return true;

        }

        protected override bool PerformInit(TasSayEventArgs e, string[] words, out string question, out int winCount) {
            if (spring.IsRunning)
            {
                context = spring.StartContext;
                voteStarter = context.Players.FirstOrDefault(x => x.Name == e.UserName && !x.IsSpectator);
                if (voteStarter != null)
                {
                    question = string.Format("Resign team {0}?", voteStarter.AllyID + 1);
                    int cnt = 0, total = 0;
                    foreach (var p in context.Players.Where(x => x.AllyID == voteStarter.AllyID && !x.IsSpectator))
                    {
                        total++;
                        if (p.IsIngame || tas.MyBattle.Users.ContainsKey(p.Name))
                        {
                            //Note: "ExistingUsers" is empty if users disconnected from lobby but still ingame.

                            bool afk = tas.ExistingUsers.ContainsKey(p.Name) && tas.ExistingUsers[p.Name].IsAway;
                            if (!afk) cnt++;
                        }
                    }
                    winCount = (cnt * 3 / 5) + 1;
                    if (total > 1 && winCount == 1) winCount = 2; // prevents most pathological cases (like a falsely AFK partner in 2v2)
                    return true;
                }
            }
            AutoHost.Respond(tas, spring, e, "You cannot resign now");
            question = null;
            winCount = 0;
            return false;
        }

        protected override bool PerformInit(TasSayEventArgs e, string[] words, out string question, out int winCount)
        {
            question = null;
            winCount = 0;
            if (words.Length == 0)
            {
                ah.Respond(e, "You must specify player name");
                return false;
            }

            string[] players;
            int[] indexes;
            if (AutoHost.FilterUsers(new[] {words[0]}, tas, spring, out players, out indexes) > 0)
            {
                player = players[0];
                if (player == tas.UserName)
                {
                    ah.Respond(e, "won't kick myself, not in suicidal mood today");
                    return false;
                }
                else
                {
                    string reason = (words.Length > 1 && words[1] != "for") ? " for" : "";
                    for (var i = 1; i < words.Length; i++) reason += " " + words[i];
                    question = "Kick " + player + reason + "?";
                    return true;
                }
            }
            else
            {
                AutoHost.Respond(tas, spring, e, "Cannot find such player");
                return false;
            }
        }

 void OnSaid(object sender, TasSayEventArgs args)
 {
     var tas = (TasClient)sender;
     if (args.Place == SayPlace.Channel && channels.Contains(args.Channel) && args.UserName != tas.UserName) {
         var otherTas = springTas;
         otherTas.Say(LobbyClient.Legacy.TasClient.SayPlace.Channel, args.Channel, string.Format("<{0}> {1}", args.UserName, args.Text), args.IsEmote);
     }
 }

 protected override bool AllowVote(TasSayEventArgs e)
 {
     if (tas.MyBattle == null) return false;
     var entry = tas.MyBattle.Users.Values.FirstOrDefault(x => x.Name == e.UserName);
     if (entry == null || entry.IsSpectator)
     {
         ah.Respond(e, string.Format("Only players can vote"));
         return false;
     }
     else return true;
 }

 protected override bool AllowVote(TasSayEventArgs e)
 {
     if (tas.MyBattle == null) return false;
     UserBattleStatus entry;
     tas.MyBattle.Users.TryGetValue(e.UserName, out entry);
     if (entry == null || entry.IsSpectator)
     {
         ah.Respond(e, string.Format("Only players can vote"));
         return false;
     }
     else return true;
 }

        void tas_Said(object sender, TasSayEventArgs e)
        {
            if (e.UserName.Contains("Nightwatch")) return;

            if (e.Place == SayPlace.User)
            {
                if (e.Text.StartsWith("!move"))
                {
                    var db = new ZkDataContext();
                    var acc = db.Accounts.Find(tas.ExistingUsers[e.UserName].AccountID);
                    if (acc.IsZeroKAdmin)
                    {
                        var parts = e.Text.Split(' ');
                        if (parts.Length != 3) tas.Say(SayPlace.User, e.UserName, "!move [from] [to]", false);
                        else
                        {
                            var from = tas.ExistingBattles.Values.FirstOrDefault(x => x.Founder.Name == parts[1]);
                            var to = tas.ExistingBattles.Values.FirstOrDefault(x => x.Founder.Name == parts[2]);
                            if (from != null && to != null)
                            {
                                foreach (var b in from.Users.Values) if (!b.LobbyUser.IsInGame && b.Name != from.Founder.Name) tas.ForceJoinBattle(b.Name, to.BattleID);
                            }
                            else tas.Say(SayPlace.User, e.UserName, "Not a valid battle host name", false);
                        }
                    }
                }
                // split players evenly into two games by median elo -> expand to specify proportion to shunt?
                // TODO: split players and specs separately
                else if (e.Text.StartsWith("!splitplayers"))
                {
                    var db = new ZkDataContext();
                    var acc = db.Accounts.Find(tas.ExistingUsers[e.UserName].AccountID);
                    if (acc.IsZeroKAdmin)
                    {
                        var parts = e.Text.Split(' ');
                        if (parts.Length != 3) tas.Say(SayPlace.User, e.UserName, "!splitplayers [from] [to]", false);
                        else
                        {
                            var from = tas.ExistingBattles.Values.FirstOrDefault(x => x.Founder.Name == parts[1]);
                            var to = tas.ExistingBattles.Values.FirstOrDefault(x => x.Founder.Name == parts[2]);
                            if (from != null && to != null)
                            {
                                var list = from.Users.Values.Where(x=>!x.LobbyUser.IsInGame && x.Name != from.Founder.Name && !x.IsSpectator).OrderBy(x => x.LobbyUser.EffectiveElo);
                                var toMove = list.Take(list.Count() / 2);
                                foreach (var b in toMove) tas.ForceJoinBattle(b.Name, to.BattleID);
                            }
                            else tas.Say(SayPlace.User, e.UserName, "Not a valid battle host name", false);
                        }
                    }
                }
            }
        }

 protected override bool AllowVote(TasSayEventArgs e)
 {
     if (spring.IsRunning)
     {
         var entry = context.Players.FirstOrDefault(x => x.Name == e.UserName);
         if (entry == null || entry.IsSpectator)
         {
             ah.Respond(e, string.Format("You must be a player in the game"));
             return false;
         }
         else return true;
     }
     return false;
 }

 protected override bool AllowVote(TasSayEventArgs e)
 {
     if (spring.IsRunning)
     {
         var entry = spring.StartContext.Players.FirstOrDefault(x => x.Name == e.UserName);
         if (entry == null || entry.IsSpectator || entry.AllyID != voteStarter.AllyID)
         {
             ah.Respond(e, string.Format("Only team {0} can vote", voteStarter.AllyID + 1));
             return false;
         }
         else return true;
     }
     return false;
 }

 protected override bool PerformInit(TasSayEventArgs e, string[] words, out string question, out int winCount) {
     winCount = 0;
     question = null;
     if (!spring.IsRunning)
     {
         question = "Force start game?";
         winCount = tas.MyBattle.Users.Values.Count(x => !x.IsSpectator) / 2 + 1;
         return true;
     }
     else
     {
         AutoHost.Respond(tas, spring, e, "battle already started");
         return false;
     }
 }

 override protected bool PerformInit(TasSayEventArgs e, string[] words, out string question, out int winCount)
 {
     winCount = 0;
     question = null;
     if (spring.IsRunning)
     {
         question = "Force game?";
         return true;
     }
     else
     {
         AutoHost.Respond(tas, spring, e, "battle not started yet");
         return false;
     }
 }