Example #1
0
 public void BringItIn()
 {
     foreach (var unit in AI.PLAYER.Units.Where(u => u.Mythicite > 0))
     {
         Solver.moveToward(unit, AI.PLAYER.HomeBase.X, AI.PLAYER.HomeBase.Y, AI.PLAYER.HomeBase.Radius, true);
     }
 }
Example #2
0
 public void EvasiveMineuvers()
 {
     foreach (var unit in AI.PLAYER.Units)
     {
         if (AI.OPPONENT.Units.Any(u => u.Job.Damage > 0 && u.distance(unit) < 100) || AI.OPPONENT.Projectiles.Any(p => Solver.distance(p.X - unit.X, p.Y - unit.Y) < 100))
         {
             var randV = new Vector(rand.NextDouble() * AI.GAME.SizeX, rand.NextDouble() * AI.GAME.SizeY);
             Solver.moveToward(unit, randV.x, randV.y);
         }
     }
 }
Example #3
0
        public void TransportLogic()
        {
            string[] order        = { "mythicite", "legendarium", "rarium", "genarium" };
            var      transporters = this.Player.Units.Where(u => u.Job == AI.TRANSPORT);

            foreach (var transporter in transporters)
            {
                //Console.WriteLine(transporter.remainingCapacity());
                Solver.transport(transporter, this.Player.Units, order);

                var baseBody = this.Game.CurrentPlayer.HomeBase;
                if (transporter.remainingCapacity() == 0)
                {
                    Solver.moveToward(transporter, baseBody.X, baseBody.Y, baseBody.Radius, true);
                }
            }
        }
Example #4
0
        public void MinerLogic(IEnumerable <Unit> miners)
        {
            var nextM = AI.MYTHICITE.next(3);

            foreach (var miner in miners)
            {
                if (miners.Count() > 15 && !Solver.sunCollision(miner, nextM.x, nextM.y) && AI.GAME.CurrentTurn >= (AI.GAME.OrbitsProtected - 2))
                {
                    Solver.mine(miner, new[] { AI.MYTHICITE }, true, true);
                }

                Solver.mine(miner, AI.GAME.Bodies.Where(b => b.MaterialType == "legendarium"), true, true);
                Solver.mine(miner, AI.GAME.Bodies.Where(b => b.MaterialType == "rarium"), true, true);
                Solver.mine(miner, AI.GAME.Bodies.Where(b => b.MaterialType == "genarium"), true, true);
                var baseBody = this.Game.CurrentPlayer.HomeBase;
                if (miner.remainingCapacity() == 0)
                {
                    Solver.moveToward(miner, baseBody.X, baseBody.Y, baseBody.Radius, true);
                }
            }
        }
Example #5
0
        public void OwnIt(Unit miner1, Unit miner2)
        {
            var transports = this.Player.Units.Where(u => u.Job == AI.TRANSPORT).ToArray();
            var didMine    = false;

            if (miner1.inMiningRangeThisTurn(AI.MYTHICITE) && !miner1.IsBusy)
            {
                if (miner1.remainingCapacity() > 0)
                {
                    Solver.mine(miner1, new[] { AI.MYTHICITE });
                    didMine = true;
                    if (miner2.Energy < 10)
                    {
                        Solver.moveToward(miner2, AI.PLAYER.HomeBase.X, AI.PLAYER.HomeBase.Y, 0, true);
                    }
                    else
                    {
                        Solver.moveAheadOf(miner2, AI.MYTHICITE, 2);
                    }
                }
                else
                {
                    var transport = transports.FirstOrDefault(t => t.canTransferThisTurn(miner1));
                    if (transport != null)
                    {
                        Solver.moveToward(transport, miner1.X, miner1.Y, transport.Job.Range);
                        Solver.transfer(transport, miner1, "mythicite", 1);
                        Solver.mine(miner1, new[] { AI.MYTHICITE });
                        didMine = true;
                        if (miner2.Energy < 10)
                        {
                            Solver.moveToward(miner2, AI.PLAYER.HomeBase.X, AI.PLAYER.HomeBase.Y, 0, true);
                        }
                        else
                        {
                            Solver.moveAheadOf(miner2, AI.MYTHICITE, 2);
                        }
                    }
                }
            }

            if (!didMine && miner2.inMiningRangeThisTurn(AI.MYTHICITE) && !miner2.IsBusy)
            {
                if (miner2.remainingCapacity() > 0)
                {
                    Solver.mine(miner2, new[] { AI.MYTHICITE });
                    if (miner1.Energy < 10)
                    {
                        Solver.moveToward(miner2, AI.PLAYER.HomeBase.X, AI.PLAYER.HomeBase.Y, 0, true);
                    }
                    else
                    {
                        Solver.moveAheadOf(miner1, AI.MYTHICITE, 2);
                    }
                }
                else
                {
                    var transport = transports.FirstOrDefault(t => t.canTransferThisTurn(miner2));
                    if (transport != null)
                    {
                        Solver.moveToward(transport, miner2.X, miner2.Y, transport.Job.Range);
                        Solver.transfer(transport, miner2, "mythicite", 1);
                        Solver.mine(miner2, new[] { AI.MYTHICITE });
                        if (miner1.Energy < 10)
                        {
                            Solver.moveToward(miner2, AI.PLAYER.HomeBase.X, AI.PLAYER.HomeBase.Y, 0, true);
                        }
                        else
                        {
                            Solver.moveAheadOf(miner1, AI.MYTHICITE, 2);
                        }
                    }
                }
            }
            else
            {
                Solver.mine(miner1, new[] { AI.MYTHICITE }, true, true);
                Solver.mine(miner2, new[] { AI.MYTHICITE }, true, true);
            }

            foreach (var transport in transports)
            {
                if (transport.remainingCapacity() == 0)
                {
                    Solver.moveToward(transport, AI.PLAYER.HomeBase.X, AI.PLAYER.HomeBase.Y, 0, true);
                }
                else
                {
                    Solver.moveAheadOf(transport, AI.MYTHICITE, 2);
                }
            }
        }