Simulator/SimulatedGame.cs

Go to the documentation of this file.

#region #Usings

using System.Collections.Generic;
using Britbot.PriorityQueue;
using Pirates;
using System;
using System.Threading;

#endregion

namespace Britbot.Simulator
{
    class SimulatedGame
    {
        #region Fields & Properies

        private HeapPriorityQueue<SimulatedEvent> CommingEvents;

        public Dictionary<int,SimulatedGroup> EnemyGroups;

        public Dictionary<int,SimulatedIsland> Islands;

        public Dictionary<int, SimulatedGroup> MyGroups;

        public double Score { get; private set; }

        public int CurrentTurn { get; set; }


        public double MyIslandCount;
        public double EnemyIslandCount;
        public double MyDeadPirates;
        public double EnemyDeadPirates;

        public double OriginalMyIslandCount;
        public double OriginalEnemyIslandCount;
        public double OriginalMyDeadPirates;
        public double OriginalEnemyDeadPirates;

        public List<SimulatedEvent> ConstantEvents;

        #endregion

        #region Constructors & Initializers

        public SimulatedGame()
        {
            //initialize stuff
            this.CommingEvents = new HeapPriorityQueue<SimulatedEvent>((int) (2 * Magic.MaxCalculableDistance));
            this.ConstantEvents = new List<SimulatedEvent>();
            this.Islands = new Dictionary<int,SimulatedIsland>();
            this.MyGroups = new Dictionary<int, SimulatedGroup>();
            this.EnemyGroups = new Dictionary<int, SimulatedGroup>();

            //add the ending Event
            this.ConstantEvents.Add(new SimulationEndEvent(Magic.SimulationLength));

            this.OriginalEnemyDeadPirates = 0;
            this.OriginalMyDeadPirates = 0;
            this.OriginalMyIslandCount = 0;
            this.OriginalEnemyIslandCount = 0;

            //set my groups
            foreach (Group group in Commander.Groups)
            {
                //check if capturing
                bool isCapturing = false;
                foreach(SmartIsland sIsland in SmartIsland.IslandList)
                {
                    if(group.MinimalETATo(sIsland.Loc) == 0)
                    {
                        isCapturing = true;
                        break;
                    }
                }
                this.MyGroups.Add(group.Id, new SimulatedGroup(group.Id, Consts.ME, group.LiveCount(), isCapturing));
            }

            //set enemy group
            foreach (EnemyGroup eGroup in Enemy.Groups)
            {
                //check if capturing
                bool isCapturing = false;
                foreach (SmartIsland sIsland in SmartIsland.IslandList)
                {
                    if (eGroup.MinimalETATo(sIsland.Loc) == 0)
                    {
                        isCapturing = true;
                        break;
                    }
                }
                this.EnemyGroups.Add(eGroup.Id, new SimulatedGroup(eGroup.Id, Consts.ENEMY, eGroup.GetMaxFightPower(), isCapturing));
            }

            //set up islands
            foreach (SmartIsland sIsland in SmartIsland.IslandList)
            {
                SimulatedIsland newIsland = new SimulatedIsland(id: sIsland.Id,
                                                                owner: sIsland.Owner,
                                                                turnsBeingCaptured: sIsland.TurnsBeingCaptured,
                                                                value: sIsland.Value);

                //we set capturing teams through events

                this.Islands.Add(newIsland.Id, newIsland);

                if (sIsland.Owner == Consts.ME)
                    OriginalMyIslandCount+= sIsland.Value;
                if (sIsland.Owner == Consts.ENEMY)
                    OriginalEnemyIslandCount += sIsland.Value;
            }

            //set constant events
            foreach (SmartIsland sIsland in SmartIsland.IslandList)
            {
                //go over the enemy list of each island
                foreach (KeyValuePair<EnemyGroup, bool> enemy in sIsland.approachingEnemies)
                {
                    SimulatedEvent newEvent;
                    //if it is likely that he will come to the island
                    if (enemy.Value)
                    {
                        newEvent = new GroupArrivalEvent((int)enemy.Key.MinimalETATo(sIsland.Loc),
                                      this.Islands[sIsland.Id],
                                      this.EnemyGroups[enemy.Key.Id]);
                        this.ConstantEvents.Add(newEvent);
                    }
                    else if ((int)enemy.Key.MinimalETATo(sIsland.Loc) < 0 || Commander.IsDefensive() )
                    {
                        newEvent = new PossibleArrivalEvent((int)enemy.Key.MinimalETATo(sIsland.Loc),
                                      this.Islands[sIsland.Id],
                                      this.EnemyGroups[enemy.Key.Id]);
                        this.ConstantEvents.Add(newEvent);
                    }
                 }


                    //add the event
                    
            

                //check if there are ships on the islands
                foreach(Group g in Commander.Groups)
                {
                    if(g.MinimalETATo(sIsland.Loc) <= 1)
                    {
                        this.Islands[sIsland.Id].CapturingGroup = this.MyGroups[g.Id];
                        break;
                    }
                }
            }

        }

        public void ResetSimulation()
        {
            //reset general stuff
            this.CurrentTurn = Bot.Game.GetTurn();
            this.Score = 0;
            this.EnemyDeadPirates = this.OriginalEnemyDeadPirates;
            this.MyDeadPirates = this.OriginalMyDeadPirates;
            this.EnemyIslandCount = this.OriginalEnemyIslandCount;
            this.MyIslandCount = this.OriginalMyIslandCount;

            //reset islands
            foreach(KeyValuePair<int, SimulatedIsland> sIsland in this.Islands)
            {
                sIsland.Value.Owner = sIsland.Value.OriginalOwner;
                sIsland.Value.TurnsBeingCaptured = sIsland.Value.OriginalTrunsBeingCaptured;
                sIsland.Value.CapturingGroup = sIsland.Value.OriginalCapturingGroup;
            }

            //reset my groups
            foreach(KeyValuePair<int,SimulatedGroup> sGroup in this.MyGroups)
            {
                sGroup.Value.IsBusy = false;
                sGroup.Value.IsAlive = sGroup.Value.OriginalIsAlive;
                sGroup.Value.IsCapturing = sGroup.Value.OriginalIsCapturing;
                sGroup.Value.ReviveTurn = sGroup.Value.OriginalReviveTurn;
            }

            //reset enemy groups
            foreach (KeyValuePair<int, SimulatedGroup> sGroup in this.EnemyGroups)
            {
                sGroup.Value.IsBusy = false;
                sGroup.Value.IsAlive = sGroup.Value.OriginalIsAlive;
                sGroup.Value.IsCapturing = sGroup.Value.OriginalIsCapturing;
                sGroup.Value.ReviveTurn = sGroup.Value.OriginalReviveTurn;
            }

            //reset events
            this.CommingEvents.Clear();
            foreach(SimulatedEvent sEvent in this.ConstantEvents)
            {
                this.CommingEvents.Enqueue(sEvent, sEvent.Turn);
            }
        }
        #endregion

        public void AddEvent(SimulatedEvent newEvent)
        {
            this.CommingEvents.Enqueue(newEvent, newEvent.Turn);
        }

        public double RunSimulation(CancellationToken cancellationToken)
        {
            int nextTurn = 0;

            //variables for PPT
            double PPT;

            int count = 0;

            //start going over events
            while(this.CommingEvents.Count > 0)
            {
                count++;
                //calculate PPT
                PPT = this.CalculatePpt();

                nextTurn = this.CommingEvents.First.Turn;

                //update score
                this.Score += (nextTurn - this.CurrentTurn) * PPT;

                //update iteration      
                this.CurrentTurn = nextTurn;

                //activate the comming event, if it is the end then break
                if (this.CommingEvents.Dequeue().Activate(this))
                    break;
            }

            //Logger.Write(this.MyIslandCount.ToString(),true);
            //Logger.Write(this.EnemyIslandCount.ToString(),true);


            Logger.Write("COUNT: " + count);
            return Score;
        }

        public double CalculatePpt()
        {
            //calc score
            double friendlyPPT = Math.Floor(Math.Pow(2, this.MyIslandCount - 1));
            double enemyPPT = Math.Floor(Math.Pow(2, this.EnemyIslandCount - 1));

            //account for dead ships
            friendlyPPT -= Math.Pow(Magic.FriendlyBaseFactor, this.MyDeadPirates);

            //account for dead enemy ships
            enemyPPT -= Math.Pow(Magic.EnemyBaseFactor, this.EnemyDeadPirates);

            return friendlyPPT - enemyPPT;
        }
    }
}