Scripts with Evolutionary Optimization (Experimental)

EvoParam<float> damageParam = EvoParam<float>({ 50.0f, 55.0f, 60.0f, 65.0f, 70.0f });

EvoParam<float> damageParam = new EvoParam<float>(50.0f, 55.0f, 60.0f, 65.0f, 70.0f);

//EvoScript.hh

class EvoScript
{
    ...

   /// <summary>
   /// Make and return a new copy of the type of your derived class from EvoScript - your complete player being optimized.
   /// You do not need to set concrete values of EvoParams, because they will be synchronized automatically.
   /// </summary>
   virtual std::unique_ptr<EvoScript> UserClone() const = 0;

   void RegisterParam(IEvoParam& parameter);

    ...
}

public abstract class EvoScript : IComparable<EvoScript>, IComparer<EvoScript>, IFitnessProvider
{
    ...

    /// <summary>
    /// Make and return a new copy of the type of your derived class from EvoScript - your complete player being optimized.
    /// You do not need to set concrete values of EvoParams, because they will be synchronized automatically.
    /// </summary>
    public abstract EvoScript UserClone();

    protected void RegisterParam(IEvoParam parameter);

    ...
}

#include "grail/EvoScripts/EvoScript.hh"
using namespace grail::evolution; //for simplicity of the example

struct TestBot : public EvoScript
{
  EvoParam<int> Attack = EvoParam<int>({ 50, 100, 150 });
  EvoParam<int> Health = EvoParam<int>({ 100, 200, 300 });

  TestBot();

  virtual std::unique_ptr<EvoScript> UserClone() const override;
};

TestBot::TestBot()
{
    RegisterParam(Attack);
    RegisterParam(Health);
}

//no need to clone anything inside because the only fields are EvoParams which are cloned automatically by SystemClone()
std::unique_ptr<EvoScript> TestBot::UserClone() const
{
  return std::unique_ptr<EvoScript>(new TestBot());
}

using Grail.Evolution;

public class TestBot : EvoScript
{
    public EvoParam<int> Attack { get; private set} = new EvoParam<int>(50, 100, 150);
    public EvoParam<int> Health { get; private set} = new EvoParam<int>(50, 100, 150);

    public TestBot()
    {
        RegisterParams(Attack, Health);

        //or
        //RegisterParam(Attack);
        //RegisterParam(Health);
    }

    //no need to clone anything inside because the only fields are EvoParams which are cloned automatically by SystemClone()
    public override EvoScript UserClone() => new TestBot();
}

//grail/Evolution/Arena.hh
namespace grail
{
  namespace evolution
  {
    class EvoScript;
    /**
    The Arena class is an interface for the evaluator of the quality of players represented by EvoScripts.
    It is used either stand-alone or in the in the evaluation phase of Evolutionary Algorithm optimization */
    class Arena
    {
    public:
      /// <summary>
      /// This function's responsibility is to evaluate EvoScripts and assign the value to them using setFitness().
      /// If your method of evaluation is deterministic and absolute (i.e. fitness only depends on the EvoScript object itself) then you might ignore the @onceEvaluatedList.
      /// If your method is non-deterministic or relative (e.g., tournament-based) to the whole population, then you might evaluate @onceEvaluatedList again within the scope of the current population.
      /// </summary>
      /// <param name="onceEvaluatedList">EvoScript objects that have been evaluated at least once in previous iterations. The evaluation might need to be updated.</param>
      /// <param name="neverEvaluatedList">EvoScript objects that have never been evaluated. Assign Fitness to them in this method.</param>
    virtual void Evaluate(std::vector<std::unique_ptr<EvoScript>>& onceEvaluatedPlayers, std::vector<std::unique_ptr<EvoScript>>& neverEvaluatedPlayers) = 0;

      virtual ~Arena();
    };
  }
}

namespace Grail.Evolution
{
  /** The Arena class is an interface for the evaluator of the quality of players represented by EvoScripts.
  It is used either stand-alone or in the in the evaluation phase of Evolutionary Algorithm optimization */
  public abstract class Arena
  {
    /// <summary>
    /// This function's responsibility is to evaluate EvoScripts and assign the value to them using the [.Fitness] getter.
    /// If your method of evaluation is deterministic and absolute (i.e. fitness only depends on the EvoScript object itself) then you might ignore the @onceEvaluatedList.
    /// If your method is non-deterministic or relative (e.g., tournament-based) to the whole population, then you might evaluate @onceEvaluatedList again within the scope of the current population.
    /// </summary>
    /// <param name="onceEvaluatedList">EvoScript objects that have been evaluated at least once in previous iterations. The evaluation might need to be updated.</param>
    /// <param name="neverEvaluatedList">EvoScript objects that have never been evaluated. Assign Fitness to them in this method.</param>
    public abstract void Evaluate(List<EvoScript> onceEvaluatedList, List<EvoScript> neverEvaluatedList);


    /// <summary>
    /// A helper class that will: for each *bot* in @bots test it against randomly chosen @trialCount another bots and call the compareTwoFunction to score the bot.
    /// This function will assign Fitness to each bot based on the average score obtained in the process.
    /// </summary>
    /// <param name="bots">The population of bots to be tested.</param>
    /// <param name="trialCount">The number of times, each bot is tested against some subset of population.</param>
    /// <param name="maxScoreInTrial">The maximum score that a bot can get in a single test.</param>
    /// <param name="compareTwoFunction">The function that test a pair of bots and returns score from the first one's perspective.</param>
    /// <param name="random">Random numbers generator.</param>
    protected virtual void TwoPlayerTournamentSelection(List<EvoScript> bots, int trialCount, float maxScoreInTrial, Func<EvoScript, EvoScript, float> compareTwoFunction, Random random)
    {
      float normalization = 1.0f / (trialCount * maxScoreInTrial);
      foreach (EvoScript bot in bots)
      {
        float wins = 0;
        for (int i = 0; i < trialCount; ++i)
        {
          wins += compareTwoFunction(bot, bots[random.Next(bots.Count)]);
        }
        bot.Fitness = wins * normalization;
      }
    }
  }
}

#include "grail/Evolution/Arena.hh"
using namespace grail::evolution; //for simplicity of the example

class BotArena : public Arena
{
public:
  virtual void Evaluate(std::vector<std::unique_ptr<EvoScript>>& onceEvaluatedList, std::vector<std::unique_ptr<EvoScript>>& neverEvaluatedList) override;
  virtual ~BotArena() { } override;
};

void BotArena::Evaluate(std::vector<std::unique_ptr<EvoScript>>& /*onceEvaluatedList*/, std::vector<std::unique_ptr<EvoScript>>& neverEvaluatedList)
{
  for (auto& script : neverEvaluatedList)
  {
    auto ourBot = static_cast<TestBot&>(*script);

    //the fitness is higher proportionally to the Health and Attack
    script->SetFitness(static_cast<float>(ourBot.Health*ourBot.Attack));
  }
}

using Grail.Evolution;

public class BotArena : Arena
{
  public override void Evaluate(List<EvoScript> onceEvaluatedList, List<EvoScript> neverEvaluatedList)
  {
    foreach (var script in neverEvaluatedList)
    {
      var ourBot = script as TestBot;

      //the fitness is higher proportionally to the Health and Attack
      script.Fitness = ourBot.Attack * ourBot.Health;
    }
  }
}

EAOptimizer(std::vector<std::unique_ptr<EvoScript>>& initialPopulation,
            std::unique_ptr<Arena> arenaEvaluation,
            std::unique_ptr<Crossover> crossover = std::make_unique<Crossover>(),
            std::unique_ptr<Mutation> mutation = std::make_unique<Mutation>(),
            std::unique_ptr<Selection> selection = std::make_unique<Selection>(),
            std::mt19937_64::result_type seed = std::random_device{}());

public EAOptimizer(List<EvoScript> initialPopulation, Arena arenaEvaluation,  Mutation mutation = null, Crossover crossover = null, Selection selection = null)
{
    this.selection = selection ?? new SelectionDeterministicTopN();
    this.mutation = mutation ?? new Mutation();
    this.crossover = crossover ?? new Crossover();
    this.tempPopulation = new List<EvoScript>();

    //additional internal initialization
    ...
}

#include "grail/Evolution/EAOptimizer.hh"
#include "grail/Evolution/Selection.hh"
#include "grail/Evolution/Crossover.hh"
#include "grail/Evolution/Mutation.hh"
#include "grail/Evolution/Arena.hh"

using namespace grail::evolution; //for simplicity of the example

//constructor with default mutation, crossover and selection
EAOptimizer ea(initialPopulation, std::make_unique<BotArena>());

//50 epochs of the algorithm
ea.Run(50);

//getting the winner script
auto winner = static_cast<TestBot&>(ea.GetBestIndividual());

using Grail.Evolution;

//constructor with default mutation, crossover and selection
EAOptimizer ea = new EAOptimizer(initialPopulation, new BotArena();

//50 epochs of the algorithm
ea.Run(50);

//getting the winner script
auto winner = ea.GetBestIndividual() as TestBot;