make DarwinWorld compilable again (test may fail)

src/main/kotlin/backend/GenMutator.kt

@@ -21,7 +21,7 @@ class GenMutator(private val config: Config) {
       .distinct()
       .take(2 * switchMutations)
       .windowed(2)
-      .forEach {indicators ->
+      .forEach { indicators ->
         newGenes[indicators[0]] = newGenes[indicators[1]].also { newGenes[indicators[1]] = newGenes[indicators[0]] }
       }
 

src/main/kotlin/backend/Simulation.kt

@@ -49,8 +49,8 @@ class Simulation(
     map.growPlants(config.plantsPerDay)
 
 //    launchIO {
-    statisticsService.registerPlants(day.value, plants.value.size)
-    statisticsService.registerAnimals(day.value, animals.value.flattenValues())
+    statisticsService.registerPlants(plants.value.size)
+    statisticsService.registerAnimals(animals.value.flattenValues())
 //    }
   }
 

src/main/kotlin/backend/config/Config.kt → src/main/kotlin/backend/config/ConfigBuilder.kt

@@ -1,87 +1,90 @@
 package backend.config
 
-import backend.config.AnimalGroup.*
 import backend.config.ConfigField.Companion.default
-import backend.config.GenomeGroup.*
-import backend.config.MapGroup.MapHeight
-import backend.config.MapGroup.MapWidth
-import backend.config.PlantGroup.*
 import backend.config.PlantGrowthVariant.EQUATOR
 import tornadofx.*
 import kotlin.reflect.full.companionObjectInstance
 import kotlin.reflect.full.createInstance
 
-
-class Config(
-  mapGroup: MapGroup,
-  plantGroup: PlantGroup,
-  animalGroup: AnimalGroup,
-  genomeGroup: GenomeGroup,
-  val statisticsConfig: StatisticsConfig,
+data class Config(
+  val mapWidth: Int,
+  val mapHeight: Int,
+  val initialPlants: Int,
+  val nutritionScore: Int,
+  val plantsPerDay: Int,
+  val plantGrowthVariant: PlantGrowthVariant,
+  val initialAnimals: Int,
+  val initialAnimalEnergy: Int,
+  val satietyEnergy: Int,
+  val reproductionEnergyRatio: Double,
+  val minMutations: Int,
+  val maxMutations: Int,
+  val mutationVariant: Double,
+  val genomeLength: Int,
+
+  val births: Boolean,
+  val deaths: Boolean,
+  val population: Boolean,
+  val plantDensity: Boolean,
+  val dailyAverageEnergy: Boolean,
+  val dailyAverageAge: Boolean,
+  val gens: Boolean,
+  val genomes: Boolean,
 ) {
 
-  val mapWidth = mapGroup.mapWidth.value
-  val mapHeight = mapGroup.mapHeight.value
-  val initialPlants = plantGroup.initialPlants.value
-  val nutritionScore = plantGroup.nutritionScore.value
-  val plantsPerDay = plantGroup.plantsPerDay.value
-  val plantGrowthVariant = plantGroup.plantGrowthVariant.value
-  val initialAnimals = animalGroup.initialAnimals.value
-  val initialAnimalEnergy = animalGroup.initialAnimalEnergy.value
-  val satietyEnergy = animalGroup.satietyEnergy.value
-  val reproductionEnergyRatio = genomeGroup.reproductionEnergyRatio.value
-  val minMutations = genomeGroup.minMutations.value
-  val maxMutations = genomeGroup.maxMutations.value
-  val mutationVariant = genomeGroup.mutationVariant.value
-  val genomeLength = genomeGroup.genomeLength.value
-
-  val births = statisticsConfig.births.value
-  val deaths = statisticsConfig.deaths.value
-  val population = statisticsConfig.population.value
-  val plantDensity = statisticsConfig.plantDensity.value
-  val dailyAverageEnergy = statisticsConfig.dailyAverageEnergy.value
-  val dailyAverageAge = statisticsConfig.dailyAverageAge.value
-  val gens = statisticsConfig.gens.value
-  val genomes = statisticsConfig.genomes.value
-
   init {
     require(initialPlants <= mapWidth * mapHeight) { "Initial plants must be less or equal to map size" }
     require(initialAnimals <= mapWidth * mapHeight) { "Initial animals must be less or equal to map size" }
   }
 
   companion object {
-    fun default() = Config(
-      MapGroup(),
-      PlantGroup(),
-      AnimalGroup(),
-      GenomeGroup(),
-      StatisticsConfig(),
+    val test = Config(
+      mapWidth = 10,
+      mapHeight = 10,
+      initialPlants = 10,
+      nutritionScore = 10,
+      plantsPerDay = 10,
+      plantGrowthVariant = EQUATOR,
+      initialAnimals = 10,
+      initialAnimalEnergy = 10,
+      satietyEnergy = 10,
+      reproductionEnergyRatio = 0.5,
+      minMutations = 0,
+      maxMutations = 8,
+      mutationVariant = 0.0,
+      genomeLength = 8,
+      births = false,
+      deaths = false,
+      population = false,
+      plantDensity = false,
+      dailyAverageEnergy = false,
+      dailyAverageAge = false,
+      gens = false,
+      genomes = false,
     )
-
-    fun test() = Config(
-      MapGroup(
-        MapWidth(100),
-        MapHeight(100),
-      ),
-      PlantGroup(
-        InitialPlants(100),
-        NutritionScore(100),
-        PlantsPerDay(1),
-        PlantGrowthVariantField(EQUATOR),
-      ),
-      AnimalGroup(
-        InitialAnimals(100),
-        InitialAnimalEnergy(2000),
-        SatietyEnergy(10),
-      ),
-      GenomeGroup(
-        GenomeLength(8),
-        MutationVariant(0.0),
-        MinMutations(0),
-        MaxMutations(8),
-        ReproductionEnergyRatio(0.5),
-      ),
-      StatisticsConfig(),
+    val default = Config(
+      mapWidth = default<MapGroup.MapWidth>().value,
+      mapHeight = default<MapGroup.MapHeight>().value,
+      initialPlants = default<PlantGroup.InitialPlants>().value,
+      nutritionScore = default<PlantGroup.NutritionScore>().value,
+      plantsPerDay = default<PlantGroup.PlantsPerDay>().value,
+      plantGrowthVariant = default<PlantGroup.PlantGrowthVariantField>().value,
+      initialAnimals = default<AnimalGroup.InitialAnimals>().value,
+      initialAnimalEnergy = default<AnimalGroup.InitialAnimalEnergy>().value,
+      satietyEnergy = default<AnimalGroup.SatietyEnergy>().value,
+      reproductionEnergyRatio = default<GenomeGroup.ReproductionEnergyRatio>().value,
+      minMutations = default<GenomeGroup.MinMutations>().value,
+      maxMutations = default<GenomeGroup.MaxMutations>().value,
+      mutationVariant = default<GenomeGroup.MutationVariant>().value,
+      genomeLength = default<GenomeGroup.GenomeLength>().value,
+      births = default<Births>().value,
+      deaths = default<Deaths>().value,
+      population = default<Population>().value,
+      plantDensity = default<PlantDensity>().value,
+      dailyAverageEnergy = default<DailyAverageEnergy>().value,
+      dailyAverageAge = default<DailyAverageAge>().value,
+      gens = default<Gens>().value,
+      genomes = default<Genomes>().value,
     )
   }
 }
@@ -206,7 +209,7 @@ class PlantGroup(
       override val description = "Variant of plant growth"
       override val errorMessage: String = "Must be one of ${PlantGrowthVariant.entries.map { it.name }}"
 
-      override fun isValid(it: String) = PlantGrowthVariant.entries.any { e -> e.name == it }
+      override fun isValid(it: String) = PlantGrowthVariant.entries.map { it.name }.contains(it)
     }
   }
 }

src/main/kotlin/backend/map/AbstractMap.kt

@@ -9,6 +9,7 @@ import kotlinx.coroutines.flow.*
 import shared.*
 import kotlin.random.Random
 
+@Suppress("PropertyName")
 abstract class AbstractMap(protected val config: Config) {
 
   private val mutator = GenMutator(config)

src/main/kotlin/backend/model/Animal.kt

@@ -1,15 +1,14 @@
 package backend.model
 
 import backend.GenMutator
-import backend.map.MapElement
 
 data class Animal(
   val energy: Int,
   val genome: Genome,
   val direction: Direction,
   val age: Int = 0,
-  private val children: Set<Animal> = setOf(),
-) : MapElement, Comparable<Animal> {
+  val children: Set<Animal> = setOf(),
+) : Comparable<Animal> {
 
   fun isDead() = energy <= 0
 

src/main/kotlin/backend/statistics/StatisticsService.kt

@@ -1,8 +1,9 @@
 package backend.statistics
 
-import backend.config.StatisticsConfig
+import backend.config.Config
 import backend.model.Animal
 import backend.model.Gen
+import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
 import metrics.Day
 import metrics.collector.Collector
@@ -16,11 +17,11 @@ import kotlin.collections.component1
 import kotlin.collections.component2
 
 
-class StatisticsService(statisticsConfig: StatisticsConfig) {
+class StatisticsService(simulationConfig: Config) {
 
   val range = 20
 
-  val isBirthsMetricsEnabled = statisticsConfig.births.value
+  val isBirthsMetricsEnabled = simulationConfig.births
   private val _birthMetrics by lazy { MutableACounter<Int>(range) }
   private val _minBirthMetrics by lazy(::MutableAMinimumMetrics)
   private val _maxBirthMetrics by lazy(::MutableAMaximumMetrics)
@@ -30,7 +31,7 @@ class StatisticsService(statisticsConfig: StatisticsConfig) {
     combine(_minBirthMetrics, _maxBirthMetrics, _avgBirthMetrics, ::Triple)
   }
 
-  val isDeathsMetricsEnabled = statisticsConfig.deaths.value
+  val isDeathsMetricsEnabled = simulationConfig.deaths
   private val _deathMetrics by lazy { MutableACounter<Int>(range) }
   private val _minDeathMetrics by lazy(::MutableMinimumMetrics)
   private val _maxDeathMetrics by lazy(::MutableMaximumMetrics)
@@ -40,47 +41,47 @@ class StatisticsService(statisticsConfig: StatisticsConfig) {
     combine(_minDeathMetrics, _maxDeathMetrics, _avgDeathMetrics, ::Triple)
   }
 
-  val isPopulationMetricsEnabled = statisticsConfig.population.value
+  val isPopulationMetricsEnabled = simulationConfig.population
   private val _populationMetrics by lazy { MutableCounter<Int>(range) }
   private val _minPopulationMetrics by lazy(::MutableMinimumMetrics)
   private val _maxPopulationMetrics by lazy(::MutableMaximumMetrics)
   private val _avgPopulationMetrics by lazy(::MutableAverageMetrics)
   val populationMetrics: Counter<Int> by lazy { _populationMetrics }
-  val populationTripleMetrics by lazy {
+  val populationTripleMetrics: Flow<MinMaxAvgTriple> by lazy {
     combine(_minPopulationMetrics, _maxPopulationMetrics, _avgPopulationMetrics, ::Triple)
   }
 
-  val isPlantDensityMetricsEnabled = statisticsConfig.plantDensity.value
+  val isPlantDensityMetricsEnabled = simulationConfig.plantDensity
   private val _plantDensityMetrics by lazy { MutableCounter<Int>(range) }
   private val _minPlantDensityMetrics by lazy(::MutableMinimumMetrics)
   private val _maxPlantMetrics by lazy(::MutableMaximumMetrics)
   private val _avgPlantMetrics by lazy(::MutableAverageMetrics)
   val plantDensityMetrics: Counter<Int> by lazy { _plantDensityMetrics }
-  val plantDensityTriple by lazy {
+  val plantDensityTriple: Flow<MinMaxAvgTriple> by lazy {
     combine(_minPlantDensityMetrics, _maxPlantMetrics, _avgPlantMetrics, ::Triple)
   }
 
-  val isDailyAverageAgeMetricsEnabled = statisticsConfig.dailyAverageAge.value
+  val isDailyAverageAgeMetricsEnabled = simulationConfig.dailyAverageAge
   private val _dailyAverageAgeMetrics by lazy { MutableCounter<Double>(range) }
   private val _minDailyAverageAgeMetrics by lazy(::MutableMinimumMetrics)
   private val _maxDailyAverageAgeMetrics by lazy(::MutableMaximumMetrics)
   private val _avgDailyAverageAgeMetrics by lazy(::MutableAverageMetrics)
   val dailyAverageAgeMetrics: Counter<Double> by lazy { _dailyAverageAgeMetrics }
-  val dailyAverageAgeTriple by lazy {
+  val dailyAverageAgeTriple: Flow<MinMaxAvgTriple> by lazy {
     combine(_minDailyAverageAgeMetrics, _maxDailyAverageAgeMetrics, _avgDailyAverageAgeMetrics, ::Triple)
   }
 
-  val isDailyAverageEnergyMetricsEnabled = statisticsConfig.dailyAverageEnergy.value
+  val isDailyAverageEnergyMetricsEnabled = simulationConfig.dailyAverageEnergy
   private val _dailyAverageEnergyMetrics by lazy { MutableCounter<Double>(range) }
   private val _minDailyAverageEnergyMetrics by lazy(::MutableMinimumMetrics)
   private val _maxDailyAverageEnergyMetrics by lazy(::MutableMaximumMetrics)
   private val _avgDailyAverageEnergyMetrics by lazy(::MutableAverageMetrics)
   val dailyAverageEnergyMetrics: Counter<Double> by lazy { _dailyAverageEnergyMetrics }
-  val dailyAverageEnergyTriple by lazy {
+  val dailyAverageEnergyTriple: Flow<MinMaxAvgTriple> by lazy {
     combine(_minDailyAverageEnergyMetrics, _maxDailyAverageEnergyMetrics, _avgDailyAverageEnergyMetrics, ::Triple)
   }
 
-  val isGenCollectorEnabled = statisticsConfig.gens.value
+  val isGenCollectorEnabled = simulationConfig.gens
   private val _genCollector by lazy { MutableCollector<Gen>(range) }
   val genCollector: Collector<Gen> by lazy { _genCollector }
 
@@ -102,7 +103,7 @@ class StatisticsService(statisticsConfig: StatisticsConfig) {
     }
   }
 
-  fun registerPlants(day: Day, n: Int) {
+  fun registerPlants(n: Int) {
     if (isPlantDensityMetricsEnabled) {
       _plantDensityMetrics.register(n)
       _minPlantDensityMetrics.register(n)
@@ -111,7 +112,7 @@ class StatisticsService(statisticsConfig: StatisticsConfig) {
     }
   }
 
-  fun registerAnimals(day: Day, animals: List<Animal>) {
+  fun registerAnimals(animals: List<Animal>) {
     if (isPopulationMetricsEnabled) {
       _populationMetrics.register(animals.size)
       _minPopulationMetrics.register(animals.size)
@@ -126,7 +127,7 @@ class StatisticsService(statisticsConfig: StatisticsConfig) {
     if (isGenCollectorEnabled)
       _genCollector.register(
         animals
-          .flatMap { it.genome.count().toList() }
+          .flatMap { it.genome.frequencyMap.toList() }
           .groupBy({ it.first }, { it.second })
           .map { (key, values) -> key to values.sum() }
       )

src/main/kotlin/frontend/config/ConfigViewModel.kt

@@ -8,7 +8,7 @@ import shared.component6
 import shared.component7
 import shared.ifTrue
 
-class ConfigViewModel(currentConfig: Config = Config.test()) : ViewModel() {
+class ConfigViewModel(currentConfig: Config = Config.default) : ViewModel() {
 
   val mapWidth: MutableStateFlow<Int?> = MutableStateFlow(currentConfig.mapWidth)
   val mapHeight: MutableStateFlow<Int?> = MutableStateFlow(currentConfig.mapHeight)
@@ -145,14 +145,31 @@ class ConfigViewModel(currentConfig: Config = Config.test()) : ViewModel() {
         animalGroup,
         genomeGroup,
         statisticsConfig,
-      ) { mapField, plantField, animalField, genomeField, statisticsConfig ->
+      ) { mapGroup, plantGroup, animalGroup, genomeGroup, statisticsConfig ->
         isValid.value.ifTrue {
           Config(
-            mapField!!,
-            plantField!!,
-            animalField!!,
-            genomeField!!,
-            statisticsConfig,
+            mapWidth = mapGroup!!.mapWidth.value,
+            mapHeight = mapGroup.mapHeight.value,
+            initialPlants = plantGroup!!.initialPlants.value,
+            nutritionScore = plantGroup.nutritionScore.value,
+            plantsPerDay = plantGroup.plantsPerDay.value,
+            plantGrowthVariant = plantGroup.plantGrowthVariant.value,
+            initialAnimals = animalGroup!!.initialAnimals.value,
+            initialAnimalEnergy = animalGroup.initialAnimalEnergy.value,
+            satietyEnergy = animalGroup.satietyEnergy.value,
+            reproductionEnergyRatio = genomeGroup!!.reproductionEnergyRatio.value,
+            minMutations = genomeGroup.minMutations.value,
+            maxMutations = genomeGroup.maxMutations.value,
+            mutationVariant = genomeGroup.mutationVariant.value,
+            genomeLength = genomeGroup.genomeLength.value,
+            births = statisticsConfig.births.value,
+            deaths = statisticsConfig.deaths.value,
+            population = statisticsConfig.population.value,
+            plantDensity = statisticsConfig.plantDensity.value,
+            dailyAverageEnergy = statisticsConfig.dailyAverageEnergy.value,
+            dailyAverageAge = statisticsConfig.dailyAverageAge.value,
+            gens = statisticsConfig.gens.value,
+            genomes = statisticsConfig.genomes.value,
           )
         }
       }.stateIn(this)

src/main/kotlin/frontend/simulation/SimulationViewModel.kt

@@ -12,7 +12,7 @@ import kotlinx.coroutines.flow.stateIn
 
 class SimulationViewModel(simulationConfig: Config) : ViewModel() {
 
-  val statisticsService = StatisticsService(simulationConfig.statisticsConfig)
+  val statisticsService = StatisticsService(simulationConfig)
   val simulation = Simulation(simulationConfig, statisticsService)
 
   private val energyStep = simulationConfig.satietyEnergy / 4