C# GameObjectTeam类代码示例

        public void InitializeComponent()
        {
            // Initialize texture references
            MasterMind.TextureLoader.Load(Resources.CooldownTracker, out _overlayRef);

            // Initialize menu
            Menu = MasterMind.Menu.AddSubMenu("Cooldown Tracker", longTitle: "Spell Cooldown Tracker");

            Menu.AddGroupLabel("Information");
            Menu.AddLabel("A spell cooldown tracker helps you in various ways ingame.");
            Menu.AddLabel("It lets you visually see the remaining time the spells are on cooldown.");
            Menu.AddLabel(string.Format("You can enable cooldown tracking for both, {0} and {1}.",
                MasterMind.IsSpectatorMode ? "blue" : "allies", MasterMind.IsSpectatorMode ? "red team" : "enemies"));
            Menu.AddSeparator();

            TrackAllies = Menu.Add("allies", new CheckBox(string.Format("Track {0}", MasterMind.IsSpectatorMode ? "blue team" : "allies")));
            TrackEnemies = Menu.Add("enemies", new CheckBox(string.Format("Track {0}", MasterMind.IsSpectatorMode ? "red team" : "enemies")));
            DrawText = Menu.Add("cooldownText", new CheckBox("Draw cooldown time below spell indicator"));

            // Initialize properties
            OverlaySprite = new EloBuddy.SDK.Rendering.Sprite(() => OverlayTextre);
            SpellCooldownText = new Text(string.Empty, new System.Drawing.Font(FontFamily.GenericSansSerif, 8, FontStyle.Regular))
            {
                Color = Color.GhostWhite
            };

            AlliedTeam = GameObjectTeam.Order;
            if (!MasterMind.IsSpectatorMode)
            {
                AlliedTeam = Player.Instance.Team;
            }

            // Listen to required events
            Drawing.OnEndScene += OnDraw;
        }

 //abstract stuff
 protected Camp(byte campID,Vector3 pos, GameObjectTeam team)
 {
     campId = campID;
     campPosition = pos;
     side = team;
     State = JungleCampState.Unknown;
 }

        public static bool IsInFountain(Vector3 position, GameObjectTeam team)
        {
            float fountainRange = 1050;

            if (Game.MapId == GameMapId.SummonersRift)
            {
                Vector3 vec3 = (team == GameObjectTeam.Order) ? new Vector3(363, 426, 182) : new Vector3(14340, 14390, 172);
                return position.IsInRange(vec3, fountainRange);
            }
            return false;
        }

        public Mobs(
                int respawnTime,
                Vector3 position,
                string[] mobNames,
                GameMapId MapID,
                GameObjectTeam team)
        {
            this.RespawnTime = respawnTime;
            this.Position = position;
            this.MobNames = mobNames;
            this.MapID = MapID;
            this.Team = team;

            this.ObjectsDead = new List<string>();
            this.ObjectsAlive = new List<string>();
        }

 public Gromp(byte campID, Vector3 pos, GameObjectTeam team)
     : base(campID, pos, team)
 {
     campId = campID;
     side = team;
     Minions = new List<JungleMinion>
     {
         get_SRU_Gromp(1)
     };
     SpawnTime = TimeSpan.FromSeconds(115);
     RespawnTimer = TimeSpan.FromSeconds(100);
     bonusPrioLowLvl = -50;
     bonusPrio = -20;
     onRespawn();
     worthSmiting = true;
 }

 public Senitels(byte campID, Vector3 pos, GameObjectTeam team)
     : base(campID, pos, team)
 {
     campId = campID;
     side = team;
     Minions = new List<JungleMinion>
     {
         get_SRU_Blue(1),
         get_SRU_BlueMini(2),
         get_SRU_BlueMini(3,true),
     };
     SpawnTime = TimeSpan.FromSeconds(115);
     RespawnTimer = TimeSpan.FromSeconds(300);
     useOverTime = false;
     onRespawn();
 }

        public static int CountEnemies(Vector3 from, float Range, GameObjectTeam team)
        {
            int Counter = 0;
            List<Obj_AI_Hero> Enemies = null;
            Enemies = ObjectHandler.Get<Obj_AI_Hero>().Where(t => t.IsEnemy && !t.IsDead).ToList();

            foreach (Obj_AI_Hero hero in Enemies)
            {
                if (from.Distance(hero.Position) < Range)
                {
                    Counter++;
                }
            }

            return Counter;
        }

 public RedBrambleback(byte campID, Vector3 pos, GameObjectTeam team)
     : base(campID, pos, team)
 {
     campId = campID;
     side = team;
     Minions = new List<JungleMinion>
     {
         get_SRU_Red(1),
         get_SRU_RedMini(2),
         get_SRU_RedMini(3),
     };
     SpawnTime = TimeSpan.FromSeconds(115);
     RespawnTimer = TimeSpan.FromSeconds(300);
     useOverTime = false;
     bonusPrioLowLvl = -1;
     onRespawn();
 }

 public Dragon(byte campID, Vector3 pos, GameObjectTeam team)
     : base(campID, pos, team)
 {
     campId = campID;
     side = team;
     Minions = new List<JungleMinion>
     {
         get_SRU_Dragon(1)
     };
     SpawnTime = TimeSpan.FromSeconds(150);
     RespawnTimer = TimeSpan.FromSeconds(360);
     bonusPrioLowLvl = -5;
     bonusPrio += 5;
     onRespawn();
     worthSmiting = false;
     isDrag = true;
 }

        public bool IsValidTeam(GameObjectTeam team)
        {
            if (team == GameObjectTeam.Unknown)
                return true;

            switch (TeamDetect)
            {
                case DetectionTeam.AllyTeam:
                    return team == Utils.PlayerTeam();
                case DetectionTeam.EnemyTeam:
                    return team != Utils.PlayerTeam();
                case DetectionTeam.AnyTeam:
                    return true;
            }

            return false;
        }

        public static int CountMinions(Vector3 from, float Range, GameObjectTeam team)
        {
            int Counter = 0;
            List<Obj_AI_Minion> Minions = null;

            Minions = GetMinions(ENEMY_TEAM);

            foreach (Obj_AI_Minion minion in Minions)
            {
                if (from.Distance(minion.Position) < Range && !minion.IsDead)
                {
                    Counter++;
                }
            }

            return Counter;
        }

 public Raptors(byte campID, Vector3 pos, GameObjectTeam team)
     : base(campID, pos, team)
 {
     campId = campID;
     side = team;
     Minions = new List<JungleMinion>
     {
         get_SRU_Razorbeak(1),
         get_SRU_RazorbeakMini(2),
         get_SRU_RazorbeakMini(3),
         get_SRU_RazorbeakMini(4)
     };
     SpawnTime = TimeSpan.FromSeconds(115);
     RespawnTimer = TimeSpan.FromSeconds(100);
     bonusPrioLowLvl = -5;
     onRespawn();
     worthSmiting = false;
 }

 public MurkWolfs(byte campID, Vector3 pos, GameObjectTeam team)
     : base(campID, pos, team)
 {
     campId = campID;
     side = team;
     Minions = new List<JungleMinion>
     {
         get_SRU_Murkwofl(1),
         get_SRU_MurkwoflMini(2),
         get_SRU_MurkwoflMini(3),
     };
     SpawnTime = TimeSpan.FromSeconds(115);
     RespawnTimer = TimeSpan.FromSeconds(100);
     bonusPrioLowLvl = 3;
     onRespawn();
     worthSmiting = false;
     useOverTime = true;
 }

 public Camp(string name,
     float spawnTime,
     int respawnTimer,
     Vector3 position,
     List<Mob> mobs,
     Utility.Map.MapType mapType,
     GameObjectTeam team,
     Color colour,
     Timers timer,
     bool isRanged = false,
     bool isDead = false,
     int state = 0,
     int respawnTime = 0,
     int lastChangeOnState = 0,
     bool shouldping = true,
     int lastPing = 0)
 {
     Name = name;
     IsDead = isDead;
     SpawnTime = spawnTime;
     RespawnTimer = respawnTimer;
     Position = position;
     ScreenPosition = Drawing.WorldToScreen(Position);
     MinimapPosition = Drawing.WorldToMinimap(Position);
     Mobs = mobs;
     MapType = mapType;
     Team = team;
     Colour = colour;
     IsRanged = isRanged;
     State = state;
     RespawnTime = respawnTime;
     LastChangeOnState = lastChangeOnState;
     Timer = timer;
     ShouldPing = shouldping;
     LastPing = lastPing;
 }

 public static IEnumerable<Obj_AI_Turret> GetTurrets(GameObjectTeam team, Lane lane)
 {
     switch (team)
     {
         case GameObjectTeam.Order:
         {
             switch (lane)
             {
                 case Lane.Base:
                 {
                     return
                         GameObjects.Turrets.Where(
                             turret =>
                                 orderBase.Any(
                                     orderBaseTurretPosition =>
                                         orderBaseTurretPosition.Distance(turret.Position) < 250));
                 }
                 case Lane.Bot:
                 {
                     return GameObjects.Turrets.Where(
                         turret =>
                             orderBot.Any(
                                 orderBotTurretPosition => orderBotTurretPosition.Distance(turret.Position) < 250));
                 }
                 case Lane.Mid:
                 {
                     return GameObjects.Turrets.Where(
                         turret =>
                             orderMid.Any(
                                 orderMidPosition => orderMidPosition.Distance(turret.Position) < 250));
                 }
                 case Lane.Top:
                 {
                     return GameObjects.Turrets.Where(
                         turret =>
                             orderTop.Any(
                                 orderTopTurretPosition => orderTopTurretPosition.Distance(turret.Position) < 250));
                 }
             }
             break;
         }
         case GameObjectTeam.Chaos:
         {
             switch (lane)
             {
                 case Lane.Base:
                 {
                     return
                         GameObjects.Turrets.Where(
                             turret =>
                                 chaosBase.Any(
                                     chaosBaseTurretPosition =>
                                         chaosBaseTurretPosition.Distance(turret.Position) < 250));
                 }
                 case Lane.Bot:
                 {
                     return GameObjects.Turrets.Where(
                         turret =>
                             chaosBot.Any(
                                 chaosBotTurretPosition => chaosBotTurretPosition.Distance(turret.Position) < 250));
                 }
                 case Lane.Mid:
                 {
                     return GameObjects.Turrets.Where(
                         turret =>
                             chaosMid.Any(
                                 chaosMidPosition => chaosMidPosition.Distance(turret.Position) < 250));
                 }
                 case Lane.Top:
                 {
                     return GameObjects.Turrets.Where(
                         turret =>
                             chaosTop.Any(
                                 chaosTopTurretPosition => chaosTopTurretPosition.Distance(turret.Position) < 250));
                 }
             }
             break;
         }
         default:
             return GameObjects.AllyTurrets;
     }
     return GameObjects.AllyTurrets;
 }