Enemy.cs

Go to the documentation of this file.

#region #Usings

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Pirates;

#endregion

namespace Britbot
{
    public static class Enemy
    {
        #region Static Fields & Consts

        public static int EnemyIntelligenceSuspicionCounter = 0;

        #endregion

        #region Fields & Properies

        public static List<EnemyGroup> Groups { get; private set; }

        #endregion

        #region Constructors & Initializers

        static Enemy()
        {
            Enemy.Groups = new List<EnemyGroup>();
        }

        #endregion

        private static List<EnemyGroup> AnalyzeEnemyGroups(CancellationToken cancellationToken)
        {
            EnemyGroup[] analysis = Enemy.AnalyzeFull(cancellationToken).ToArray();

            if (Groups.Count == 0)
                return analysis.ToList();

            List<EnemyGroup> veteranGroups = new List<EnemyGroup>(analysis.Length);
            bool[] removeAtAnalysis = new bool[analysis.Length];

            for (int i = 0; i < analysis.Length; i++)
            {
                //Throwing an exception if cancellation was requested.
                cancellationToken.ThrowIfCancellationRequested();

                EnemyGroup enemyGroup = analysis[i];
                foreach (EnemyGroup veteran in Enemy.Groups)
                {
                    //Throwing an exception if cancellation was requested.
                    cancellationToken.ThrowIfCancellationRequested();

                    /*
                     * check if the groups are the same.
                     * Note that Equals() does a contextual comparison and not reference comparison
                     * (I overrided it to check if the pirates in each enemy group are the same)                    
                     */
                    if (veteran.Equals(enemyGroup))
                    {
                        /* 
                         * note that we are adding the group already in the old Groups list
                         * it's the same object
                         */
                        veteranGroups.Add(veteran);
                        removeAtAnalysis[i] = true;
                        break;
                    }
                }
            }

            //add the groups to the veteran list..
            veteranGroups.AddRange(analysis.Where((t, i) => !removeAtAnalysis[i]));

            //..and return
            return veteranGroups;
        }

        public static bool ShouldWeTryToCatchEnemyShips()
        {
            return Enemy.EnemyIntelligenceSuspicionCounter <= Magic.NumberOfTimesTillWeLearn;
        }

        private static List<EnemyGroup> AnalyzeFull(CancellationToken cancellationToken)
        {
            List<EnemyGroup> updatedGroups = new List<EnemyGroup>();
            IEnumerable<Pirate> enemyAlivePirates = Bot.Game.AllEnemyPirates().Where(p => !p.IsLost);

            //iterate over all the alive pirate of the enemy
            foreach (Pirate pete in enemyAlivePirates)
            {
                //Throwing an exception if cancellation was requested.
                cancellationToken.ThrowIfCancellationRequested();

                //create a new group and add the current pirate to it
                EnemyGroup newGroup = new EnemyGroup();
                newGroup.EnemyPirates.Add(pete.Id);

                //check if there are any older group already containing the current pirate
                List<EnemyGroup> containsPete = updatedGroups.Where(g => g.IsInGroup(pete.Id)).ToList();
                if (containsPete.Count > 0)
                {
                    //if there are, remove these groups
                    updatedGroups.RemoveAll(g => g.IsInGroup(pete.Id));

                    //Add the pirates from the groups we removed to the current new group
                    foreach (EnemyGroup gr in containsPete)
                    {
                        //Throwing an exception if cancellation was requested.
                        cancellationToken.ThrowIfCancellationRequested();

                        newGroup.EnemyPirates.AddRange(gr.EnemyPirates);
                    }
                }

                //important, it must be here or direction cant be calculated
                //Set location
                newGroup.PrevLoc = newGroup.GetLocation();

                //add the new group to the list of groups
                updatedGroups.Add(newGroup);
            }

            return updatedGroups;
        }

        public static void Update(CancellationToken cancellationToken)
        {
            //write out the enemy suspiction counter
            Logger.Write("Enemy Suspiction: " + Enemy.EnemyIntelligenceSuspicionCounter);

            //update the enemy data
            List<EnemyGroup> updated = Enemy.AnalyzeEnemyGroups(cancellationToken);

            //update the enemyGroups by logical stuff
            Enemy.Groups = Enemy.Groups.Intersect(updated).ToList();
            Enemy.Groups = Enemy.Groups.Union(updated).ToList();

            //update heading in all groups
            Enemy.Groups.ForEach(eGroup => eGroup.Update());
        }
    }
}