using System;

using System.Linq;

using PlanetWars.Shared;

using System.Collections.Generic;

​

namespace CSharpAgent

{

    public class Agent : AgentBase

    {

        public const int UnownedPlanetOwnerId = -1;

​

        public Agent() : base("The Empire", 0) { }

​

        public override void Update(StatusResult gs)

        {

            // do cool ai stuff

            Console.WriteLine($"[{DateTime.Now.ToShortTimeString()}]Current Turn: {gs.CurrentTurn}");

            Console.WriteLine($"Owned Planet Id's: {string.Join(", ", gs.Planets.Where(p => p.OwnerId == MyId).Select(p => p.Id))}");

            var MyPlanets = gs.Planets.Where(p => p.OwnerId == MyId);

​

            var AvailibleShips = MyPlanets.Sum(p => p.NumberOfShips);

​

            Planet targetPlanet = new Planet();

            Planet BigestPlanet = gs.Planets.Where(p => p.OwnerId != MyId).OrderByDescending(p => p.GrowthRate).FirstOrDefault();

​

            foreach (var planet in gs.Planets)

            {

                Console.WriteLine(planet.OwnerId);

            }

​

            // find the first planet we don't own

            var targetPlanets =

                gs.Planets.Where(p => (p.OwnerId == UnownedPlanetOwnerId || p.OwnerId != MyId) && p.NumberOfShips + 1 <= (int)Math.Floor(AvailibleShips / 2.0))

                .OrderBy(p => p.NumberOfShips)

                .ThenByDescending(p => p.GrowthRate);

​

            if (!targetPlanets.Any()) return; // WE OWN IT ALLLLLLLLL

​

            targetPlanet = targetPlanets.First();

​

            IEnumerable<Fleet> offendingFleets = new List<Fleet>();

            int reservedShips = 0;

​

            // send half rounded down of our ships from each planet we do own

            foreach (var planet in gs.Planets.Where(p => p.OwnerId == MyId))

            {

                reservedShips = 0;

​

                offendingFleets = gs.Fleets

                    .Where(p => p.SourcePlanetId == planet.Id && p.OwnerId != MyId);

​

                for (int i = 1, strikingShips = 0; i < 16; ++i)

                {

                    strikingShips = offendingFleets

                        .Where(f => f.NumberOfTurnsToDestination <= i)

                        .Sum(f => f.NumberOfShips);

​

                    if (strikingShips - planet.GrowthRate * i > reservedShips)

                    {

                        reservedShips = 1 + strikingShips - planet.GrowthRate * i;

                    }

                }

​

                if (reservedShips > planet.NumberOfShips)

                {

                    var friendlyPlanet = MyPlanets

                        .Where(p => p.Id != planet.Id)

                        .FirstOrDefault();

​

                    if(friendlyPlanet != null)

                    {

                        SendFleet(planet.Id, friendlyPlanet.Id, planet.NumberOfShips);

                    }

                }

​

                Console.WriteLine(string.Format("Targeting planet {0} which has {1} ships", targetPlanet.Id, targetPlanet.NumberOfShips));

​

                var ships = (int)Math.Floor(planet.NumberOfShips / 2.0);

                if (ships < reservedShips - 1)

                {

                    ships = planet.NumberOfShips - reservedShips - 1;

                }

​

                if (ships > 0)

                {

                    Console.WriteLine(string.Format("Sending {0} ships from {1}", ships, planet.Id));

                    SendFleet(planet.Id, targetPlanet.Id, ships);

​

                    if (BigestPlanet != null && BigestPlanet.OwnerId != MyId && ships > 1)

                    {

                        SendFleet(planet.Id, BigestPlanet.Id, 1);

                    }

                }

            }

        }

    }

}

​