wip

Author: JaggerJo

src/Examples/Component Examples/Examples.GeneticAlgorithm/Lib/Population.fs

@@ -13,25 +13,25 @@ module Population =
     let simulateFirstGeneration states random =
       buildInitialPopulation random |> simulateGeneration states
 
-    let mutateBrains (random: System.Random, brains: ActorChromosome[]): ActorChromosome[] =
+    let mutateBrains (random: System.Random, brains: ActorChromosome list): ActorChromosome list =
       let numBrains = brains.Length
-      let survivors = [| brains.[0]; brains.[1]; |]
-      let randos = Seq.init (numBrains - 4) (fun _ -> Genes.getRandomChromosome random) |> Seq.toArray
+      let survivors = [ brains.[0]; brains.[1]; ]
+      let randos = Seq.init (numBrains - 4) (fun _ -> Genes.getRandomChromosome random) |> Seq.toList
 
-      let children = [|
+      let children = [
         Genes.createChild(random, survivors.[0].genes, survivors.[1].genes, 0.25);
         Genes.createChild(random, survivors.[0].genes, survivors.[1].genes, 0.5);
-      |]
+      ]
 
-      Array.append children randos |> Array.append survivors
+      List.append children randos |> List.append survivors
 
-    let mutateAndSimulateGeneration (random: System.Random, worlds: World[], results: SimulationResult[]) =
-      let brains = Seq.map (fun b -> b.brain) results |> Seq.toArray
+    let mutateAndSimulateGeneration (random: System.Random, worlds: World list, results: SimulationResult list) =
+      let brains = Seq.map (fun b -> b.brain) results |> Seq.toList
       mutateBrains(random, brains) |> simulateGeneration worlds
 
-    let mutateAndSimulateMultiple (random: System.Random, worlds: World[], generations: int, results: SimulationResult[]) =
+    let mutateAndSimulateMultiple (random: System.Random, worlds: World list, generations: int, results: SimulationResult list) =
       let mutable currentResults = results
       for _ = 1 to generations do
-        let brains = Seq.map (fun b -> b.brain) currentResults |> Seq.toArray
-        currentResults <- mutateBrains(random, brains) |> simulateGeneration worlds |> Seq.toArray
+        let brains = Seq.map (fun b -> b.brain) currentResults |> Seq.toList
+        currentResults <- mutateBrains(random, brains) |> simulateGeneration worlds |> Seq.toList
       currentResults

src/Examples/Component Examples/Examples.GeneticAlgorithm/Program.fs

@@ -21,7 +21,7 @@ type App() =
         match this.ApplicationLifetime with
         | :? IClassicDesktopStyleApplicationLifetime as desktopLifetime ->
             let mainWindow = MainWindow()
-            //mainWindow.Renderer.DrawDirtyRects <- true
+            mainWindow.Renderer.DrawDirtyRects <- true
             desktopLifetime.MainWindow <- mainWindow
         | _ -> ()
 

src/Examples/Component Examples/Examples.GeneticAlgorithm/Views.fs

@@ -1,6 +1,7 @@
 namespace Examples.GeneticAlgorithm
 
 open System
+open System.Collections
 open Avalonia.Controls
 open Avalonia.Controls.Primitives
 open Avalonia.Controls.Shapes
@@ -12,7 +13,8 @@ open Avalonia.FuncUI
 open Examples.GeneticAlgorithm.Lib
 
 type StateStore =
-    { ShowHeatMap: IWritable<bool>
+    { Random: Random
+      ShowHeatMap: IWritable<bool>
       Worlds: IWritable<World list>
       Squirrels: IWritable<SimulationResult list>
 
@@ -25,6 +27,16 @@ type StateStore =
       SelectedGameStateIdx: IWritable<int>
       SelectedGameState: IReadable<GameState option> }
 
+    member this.NextGeneration () : unit =
+        let brains =
+            this.Squirrels.Current
+            |> List.map (fun squirrel -> squirrel.brain)
+
+        let brains = Population.mutateBrains(this.Random, brains)
+        let generation = Population.simulateGeneration this.Worlds.Current brains
+
+        this.Squirrels.Set (List.ofSeq generation)
+
     static member Init () =
         let seed = Random 42
         let worlds = WorldGeneration.makeWorlds(seed, 10)
@@ -68,12 +80,15 @@ type StateStore =
                 |> Option.defaultValue List.empty
             )
             |> State.readTryFindByKey (fun (idx, _) -> idx) selectedGameStateIdx
-            |> State.readMap (fun world ->
-                world
+            |> State.readMap (fun gameState ->
+                printfn $"game state changed {gameState}"
+
+                gameState
                 |> Option.map snd
             )
 
-        { ShowHeatMap = showHeatMap
+        { Random = seed
+          ShowHeatMap = showHeatMap
           Worlds = worlds
           Squirrels = population
           SelectedSquirrelId = selectedSimulationResultId
@@ -109,7 +124,7 @@ type Views =
                     (* Next Generation *)
                     Button.create [
                         Button.content "Next Generation"
-                        Button.onClick ignore
+                        Button.onClick (ignore >> StateStore.shared.NextGeneration)
                     ]
 
                     (* Next 10 Generation *)
@@ -198,19 +213,39 @@ type Views =
                     UniformGrid.columns world.MaxX
                     UniformGrid.rows world.MaxY
                     UniformGrid.children [
-                        for x = 0 to world.MaxX - 1 do
-                            for y = 0 to world.MaxY - 1 do
+                        (* world cords state at 1 *)
+                        for x = 1 to world.MaxX do
+                            for y = 1 to world.MaxY do
                                 let actor =
                                     world.Actors
                                     |> Array.tryFind (fun actor -> actor.Pos.X = x && actor.Pos.Y = y)
 
                                 match actor with
                                 | Some actor ->
-                                    Rectangle.create [
-                                        Rectangle.row y
-                                        Rectangle.column x
-                                        Rectangle.fill "red"
-                                        Rectangle.margin (2.0, 2.0)
+                                    ContentControl.create [
+                                        ContentControl.row y
+                                        ContentControl.column x
+                                        ContentControl.margin (2.0, 2.0)
+                                        ContentControl.background "#27ae60"
+                                        ContentControl.fontSize 24.0
+                                        ContentControl.verticalContentAlignment VerticalAlignment.Center
+                                        ContentControl.horizontalContentAlignment HorizontalAlignment.Center
+
+                                        yield! [
+                                            match actor.ActorKind with
+                                            | ActorKind.Acorn ->
+                                                ContentControl.content "🌰"
+                                            | ActorKind.Squirrel true ->
+                                                ContentControl.content "🐿🌰"
+                                            | ActorKind.Squirrel false ->
+                                                ContentControl.content "🐿"
+                                            | ActorKind.Tree ->
+                                                ContentControl.content "🌲"
+                                            | ActorKind.Rabbit ->
+                                                ContentControl.content "🐇"
+                                            | ActorKind.Doggo ->
+                                                ContentControl.content "🐕"
+                                        ]
                                     ]
                                 | None ->
                                     Rectangle.create [
@@ -231,41 +266,80 @@ type Views =
                     TextBlock.text "No Game State Selected"
                 ] :> _
         )
-    static member worldView (simulationResult: IReadable<SimulationResult>) =
+    static member simulationView () =
         Component.create ("content-view", fun ctx ->
-            let showHeatMap = ctx.usePassedStateReadOnly StateStore.shared.ShowHeatMap
-            let simulationResult = ctx.usePassedStateReadOnly simulationResult
+            let worldResult = ctx.usePassedStateReadOnly StateStore.shared.SelectedWorldResult
+            let gameStateIdx = ctx.usePassedState StateStore.shared.SelectedGameStateIdx
+
+            match worldResult.Current with
+            | Some worldResult ->
+                DockPanel.create [
+                    DockPanel.lastChildFill true
+                    DockPanel.children [
+                        DockPanel.create [
+                            DockPanel.dock Dock.Bottom
+                            DockPanel.children [
+
+                                Slider.create [
+                                    Slider.dock Dock.Top
+                                    Slider.minimum (double 0)
+                                    Slider.maximum (double (worldResult.states.Length - 1))
+                                    Slider.tickFrequency (double 1)
+                                    Slider.value (double gameStateIdx.Current)
+                                    Slider.onValueChanged (fun value ->
+                                        gameStateIdx.Set (int value)
+                                    )
+                                ]
 
-            DockPanel.create [
-                DockPanel.children [
-                    Views.selectedGameStateView ()
-                ]
+                                StackPanel.create [
+                                    StackPanel.dock Dock.Top
+                                    StackPanel.children [
+                                        TextBlock.create [
+                                            TextBlock.text $"world score: {worldResult.score}"
+                                        ]
+
+                                        TextBlock.create [
+                                            TextBlock.text (
+                                                let state =
+                                                    match int (List.last worldResult.states).SimState with
+                                                    | 0 ->
+                                                        "running"
+                                                    | 1 ->
+                                                        "won"
+                                                    | 2 ->
+                                                        "lost"
+                                                    | _ ->
+                                                        "unknown"
+
+                                                $"result: {state}"
+                                            )
 
-            ] :> IView
+
+
+                                        ]
+                                    ]
+
+                                ]
+                            ]
+                        ]
+
+                        Views.selectedGameStateView ()
+                    ]
+
+                ] :> IView
+            | None ->
+                TextBlock.create [
+                    TextBlock.text "No World Result Selected"
+                ] :> IView
         )
 
     static member contentView () =
         Component.create ("content-view", fun ctx ->
-            let selected = ctx.usePassedState StateStore.shared.SelectedSquirrel
-
 
             DockPanel.create [
                 DockPanel.lastChildFill true
                 DockPanel.children [
-                    match selected.Current with
-                    | Some _ ->
-                        let s =
-                            selected
-                            |> State.readMap (fun s -> s.Value)
-                            |> ctx.usePassedStateReadOnly
-
-                        Views.worldView s
-
-                    | None ->
-                        TextBlock.create [
-                            TextBlock.text "no inhabitant selected"
-                        ]
-
+                    Views.simulationView ()
                 ]
             ]
             :> IView