コード例 #1
0
 public void evaluateShip(PopulationManager populationManager)
 {
     if (lastShip != null)
     {
         ShipArchive shipArchive = new ShipArchive(lastShip.rootNode, lastShip.getFitness());
         populationManager.shipEvaluated(shipArchive);
         GameObject.Destroy(lastShip.gameObject);
     }
 }
コード例 #2
0
    public int CompareTo(object o)
    {
        ShipArchive sa2 = (ShipArchive)o;

        if (fitness < sa2.fitness)
        {
            return(-1);
        }
        else if (fitness > sa2.fitness)
        {
            return(1);
        }
        else
        {
            return(0);
        }
    }
コード例 #3
0
    //string lastFitnessesOutput = "";

    void Start()
    {
        Time.timeScale = Config.SIMULATION_TIME_SCALE;

        generations           = new List <Generation>();
        shipCreators          = new List <RandomShipCreator>(GetComponentsInChildren <RandomShipCreator>());
        generationTimeCounter = 0;
        currentGeneration     = new Generation();
        bestOfAllTime         = new ShipArchive(null, double.MaxValue);

        foreach (RandomShipCreator r in shipCreators)
        {
            r.setOrbsRoot(orbs);
            r.generateRandomShip();
        }
        activateGeneration();
    }
コード例 #4
0
 public void addShipArchive(ShipArchive shipArchive)
 {
     shipArchives.Add(shipArchive);
 }
コード例 #5
0
    void Update()
    {
        if (useTimer)
        {
            generationTimeCounter += Time.deltaTime;
            if (generationTimeCounter >= Config.STANDARD_GENERATION_TIME)
            {
                generationTimeCounter = 0;
                startNextGeneration   = true;
            }
        }

        if (startNextGeneration)
        {
            if (!evaluationFramePassed)
            {
                //EVALUATE SHIPS
                foreach (RandomShipCreator r in shipCreators)
                {
                    r.evaluateShip(this);
                }
                evaluationFramePassed = true;
            }
            else
            {
                //ALWAYS KEEP THE BEST OF ALL TIME
                foreach (ShipArchive s in currentGeneration.getShipArchives())
                {
                    if (s.fitness < bestOfAllTime.fitness)
                    {
                        bestOfAllTime = new ShipArchive(s.root.copyTree(), s.fitness);
                    }
                }

                //PERFORM SELECTION
                List <ShipChromosomeNode> selectionList = currentGeneration.SUS((uint)shipCreators.Count);

                //PERFORM CROSSOVER
                List <ShipChromosomeNode> nextGeneration =
                    CrossoverAndMutationManager.TreeCrossover(selectionList);

                //PERFORM MUTATION
                CrossoverAndMutationManager.TreeMutate(nextGeneration);                //NodeMutate(nextGeneration);

                //RESET THE CURRENT GENERATION AND STORE THE OLD ONE
                generations.Add(currentGeneration);
                currentGeneration = new Generation();

                //INITIALIZE THE NEXT GENERATION
                shipCreators[0].generatePhysicalShip(bestOfAllTime.root);
                for (int i = 1; i < shipCreators.Count; ++i)
                {
                    shipCreators[i].generatePhysicalShip(nextGeneration[i]);
                }
                activateGeneration();
                //generationTimeCounter = 0;
                evaluationFramePassed = false;
                startNextGeneration   = false;
            }
        }
    }
コード例 #6
0
 public void shipEvaluated(ShipArchive shipArchive)
 {
     currentGeneration.addShipArchive(shipArchive);
 }