public void LoadAll(Population pop,float curHouses)
    {
        LoadAllHouses(curHouses);
        LoadAllPeople(pop);
        LoadAllBiomes();

    }

        private void RunGA(){
            _teams = LoadTeams();
            _winners = _teams.FindAll(l => l.Winner == true);
            _losers = _teams.FindAll(l => l.Winner == false);

            const double crossoverProbability = 0.85;
            const double mutationProbability = 0.15;
            const int elitismPercentage = 5;

            var population = new Population(1000, 72, true, false, ParentSelectionMethod.TournamentSelection);

            var elite = new Elite(elitismPercentage);

            var crossover = new Crossover(crossoverProbability, true)
            {
                CrossoverType = CrossoverType.DoublePoint
            };

            var mutation = new BinaryMutate(mutationProbability, true);

            var ga = new GeneticAlgorithm(population, EvaluateFitness);

            ga.OnGenerationComplete += ga_OnGenerationComplete;

            ga.Operators.Add(elite);
            ga.Operators.Add(crossover);
            ga.Operators.Add(mutation);

            ga.Run(TerminateAlgorithm);

        }

 public override void FitnessFunction(Population population, GeneticAlgorithm.NextStepDelegate callback)
 {
     this.population = population;
     InitiateNewSimulation();
     simulating = true;
     doneCallback = callback;
 }

 public PopulationSimulator(int width, int height)
 {
     swarmInBirthOrder = new Species();
     swarmInXOrder = new Species();
     swarmInYOrder = new Species();
     Population = new Population();
 }

 private void LoadAllPeople(Population pop)
 {
     float errorCounter = 0;
     float totalError = 0;
     bool recklessPlacement = false;
     
     for (int i = 0; i < pop.currentPopulation; ++i)
     {
         Vector2 creationSpot = new Vector2(Random.Range(-Globals.mapRadiusX, Globals.mapRadiusX), Random.Range(-Globals.mapRadiusY, Globals.mapRadiusY));
         RaycastHit2D[] allHit = Physics2D.RaycastAll(creationSpot, -Vector2.up,0);
         if (allHit.Length == 0 || recklessPlacement)
         {
             GameObject go = Instantiate(Resources.Load("Villager"), creationSpot, Quaternion.identity) as GameObject;
             go.GetComponent<Villager>().Initialize(pop.averagePercentLifePoints, pop.averageHappiness, pop.averageHealthiness);
         } else {
             errorCounter++;
             totalError++;
             if (errorCounter > 10) //too much wait, that vilagers toast, next one
             {
                 errorCounter = 0;
                 ++i;
             }
             if (totalError > 40)  //too much thrashing, just place them ontop other objects and hope unity forces them out
             {
                 recklessPlacement = true;
             }                
         }            
     }        
 }

    public DemoPlayerInputStrategy()
    {
        var population = new Population (6, 6, new DemoPlayerChromosome ());
        var fitness = new DemoPlayerFitness ();
        var selection = new EliteSelection ();
        var crossover = new OnePointCrossover (0);
        var mutation = new UniformMutation (true);

        m_ga = new GeneticAlgorithm (
            population,
            fitness,
            selection,
            crossover,
            mutation);

        m_ga.MutationProbability = 0.5f;
        m_ga.GenerationRan += (sender, e) => {
            m_bestChromossome = m_ga.BestChromosome as DemoPlayerChromosome;

            if(m_bestChromossome.AvoidAliensProjectilesProbability > 0.9f) {
                HorizontalDirection = 1f;
            }
        };
        m_ga.Start ();

        SHThread.PingPong (.01f, 0, 1, (t) => {
            m_ga.Termination = new GenerationNumberTermination (m_ga.GenerationsNumber + 1);
            m_ga.Resume();

            return true;
        });
    }

    public override void Select(Population population, SelectionBuffer selection, GeneticAlgorithm.NextStepDelegate callback)
    {
        int size = 0;

        // TODO: Implement settings for how to truncate.
        float cutoff = 0;
        switch (truncationMode) {
        case TruncationMode.AboveMiddle:
            cutoff = population.MinFitness + (population.MaxFitness - population.MinFitness)/2;
            break;
        case TruncationMode.AboveMean:
            cutoff = population.MeanFitness;
            break;
        case TruncationMode.AboveMedian:
            cutoff = population.MedianFitness;
            break;
        }

        for (int i = 0; i < population.Size; i++) {
            if (population[i].Fitness > cutoff) {
                selection[size].CloneFrom(population[i].Genome);
                size++;
            }
        }

        selection.Size = size;
        callback();
    }

	public void InitializePanelWithTrainerData() {
		DebugBot.DebugFunctionCall("TPopUI; InitializePanelWithTrainerData(); ", debugFunctionCalls);
		Trainer trainer = trainerModuleScript.gameController.masterTrainer;
		if(trainer.PlayerList != null) {

			int curPlayer = trainer.CurPlayer;
			//Debug.Log ("InitializePanelWithTrainerData(), " + trainer.PlayerList[curPlayer-1].maxMaxPopulationSize.ToString());
			//sliderMaxPopulationSize.minValue = trainer.PlayerList[curPlayer-1].minMaxPopulationSize;
			//sliderMaxPopulationSize.maxValue = trainer.PlayerList[curPlayer-1].maxMaxPopulationSize;
			//sliderMaxPopulationSize.value = trainer.PlayerList[curPlayer-1].maxPopulationSize;
			if(trainer.PlayerList[curPlayer-1].masterPopulation != null) {  // if the current player has a Population instance:
				populationRef = trainer.PlayerList[curPlayer-1].masterPopulation; // get current population instance
				//Current Population text:
				textCurrentPopulationSize.text = "Current Population Size: " + (populationRef.isFunctional ? populationRef.masterAgentArray.Length.ToString() : "0"); // Update this later!!
				//Current Max Population Size:
				sliderMaxPopulationSize.minValue = minMaxPopulationSize; // set up slider bounds
				sliderMaxPopulationSize.maxValue = maxMaxPopulationSize;
				sliderMaxPopulationSize.value = populationRef.populationMaxSize;
				textMaxPopulationSize.text = populationRef.populationMaxSize.ToString();

			}
			else {  // Population hasn't been created yet:
				//textMaxPopulationSize.text = trainer.PlayerList[curPlayer-1].maxPopulationSize.ToString();
			}
		}

		valuesChanged = false;
		applyPressed = false;

		UpdateUIWithCurrentData();
	}

        public Population AdvancePopulation(Population population)
        {
            var chromosomes = new List<Chromosome>();
            population = new Population(population.Take((int)(TruncationRate * population.Count()))); // TRUNCATION

            do
            {
                Chromosome chosen1 = selection.Select(population),
                           chosen2 = selection.Select(population);

                if (random.NextDouble() < CrossoverRate)
                {
                    var children = crossover.Crossover(chosen1, chosen2); // CROSSOVER
                    chosen1 = children.Item1;
                    chosen2 = children.Item2;
                }

                if (random.NextDouble() < MutationRate)
                {
                    chosen1 = mutation.Mutate(chosen1); // MUTATION
                }

                if (random.NextDouble() < MutationRate)
                {
                    chosen2 = mutation.Mutate(chosen2); // MUTATION
                }

                chromosomes.Add(chosen1);
                chromosomes.Add(chosen2);
            } while (chromosomes.Count < ChromosomeCount);

            return new Population(chromosomes);
        }

 public Resource(ResourceType type, ResourceLevel level)
 {
     Type = type;
     Level = level;
     Population = new Population();
     StorageLevel = 20;
 }

 public static void display(Population p, int gen)
 {
     Tour best = p.findBest();
     System.Console.WriteLine("Generation {0}\n" +
         "Best fitness:  {1}\n" +
         "Best distance: {2}\n", gen, best.fitness, best.distance);
 }

        static Population AdvanceGeneration(Population population, ISelection selection, ICrossover crossover, IMutation mutation)
        {
            var chromosomes = new List<Chromosome>();
            population = new Population(population.Take((int)(truncationRate * population.Count()))); // TRUNCATION
            chromosomes.AddRange(population.Take((int)(elitismRate * chromosomeCount)));  //ELITE (assuming that the chromosomes in the population are sorted by fitness (the fitter are at the top of the list)

            do
            {
                Chromosome chosen1 = selection.Select(population),
                           chosen2 = selection.Select(population);

                if (random.NextDouble() < crossoverRate)
                {
                    var children = crossover.Crossover(chosen1, chosen2); // CROSSOVER
                    chosen1 = children.Item1;
                    chosen2 = children.Item2;
                }

                if (random.NextDouble() < mutationRate)
                {
                    chosen1 = mutation.Mutate(chosen1); // MUTATION
                }

                if (random.NextDouble() < mutationRate)
                {
                    chosen2 = mutation.Mutate(chosen2); // MUTATION
                }

                chromosomes.Add(chosen1);
                chromosomes.Add(chosen2);
            } while (chromosomes.Count < chromosomeCount);

            return new Population(chromosomes);
        }

    public void InitializePanelWithTrainerData() {
		
		Player currentPlayer = trainerModuleScript.gameController.masterTrainer.PlayerList[trainerModuleScript.gameController.masterTrainer.CurPlayer-1];
		populationRef = currentPlayer.masterPopulation;
		
		DebugBot.DebugFunctionCall("LoadPopulationUI; InitializePanelWithTrainerData(); ", debugFunctionCalls);
		
		UpdateUIWithCurrentData();
	}

 //    string name,
 //    float fullFoodAmt,
 //    float feedIntSec,
 //    float hungryWindow,
 //    float energyProduceVal
 public override Organism Create(Population population)
 {
     return new Organism(population,
                         "bacteria",
                         1f,
                         20f,
                         20f,
                         1f);
 }

 private void Scale(Population population)
 {
     foreach (var chromosome in population.Chromosomes)
     {
         double value = chromosome.Value + (population.AvgFitness - c * _sigma);
         if (value < 0) value = 0;
         chromosome.Value = value;
     }
 }

    public Agent(Population populationIn, int generationIn)
    {
        //	Debug.Log("Agent created " + Time.time);
        componentsList = new ArrayList();
        generation = generationIn;
        population = populationIn;

        CreateRandomComponents();
    }

 //    string name,
 //    float fullFoodAmt,
 //    float feedIntSec,
 //    float hungryWindow,
 //    float energyProduceVal
 public override Organism Create(Population population)
 {
     return new Organism(population,
                         "fish",
                         1f,
                         3f,
                         3f,
                         5f);
 }

        public Parametres(Population oldParam)
        {
            InitializeComponent();

            MaxNotes = oldParam.MaxNotes;
            MaxIndividus = oldParam.MaxIndividus;
            Crossover = oldParam.Crossover;
            Mutarate = oldParam.Mutarate;
        }

        public void SetUp()
        {
            PopulationGenerator = new Mock<IPopulationGenerator<string>>();
            FitnessEvaluator = new Mock<IFitnessEvaluator<string>>();
            Count = 1;

            PopulationMock = new Mock<Population<string>>(Count, PopulationGenerator.Object, FitnessEvaluator.Object);
            Population = new Population<string>(Count, PopulationGenerator.Object, FitnessEvaluator.Object);
        }

 // override this
 public virtual Organism Create(Population population)
 {
     return new Organism(population,
                         "unnamed",
                         0f,
                         0f,
                         0f,
                         0f);
 }