Play the best individual

neuralnetwork/genetic/genetic.go

@@ -55,6 +55,8 @@ type Population struct {
 	verifier         PopulationVerifier
 	mutagen          Mutagen
 	etalonsCount     int
+	bestFitness      *IndividalFitness
+	bestNetwork      *neuralnetwork.NeuralNetwork
 }
 
 // NewPopulation is constructor of new Population with specified PopulationVerifier, Mutagen and PopulationConfig.
@@ -70,6 +72,8 @@ func NewPopulation(verifier PopulationVerifier, mutagen Mutagen, populationConfi
 		verifier:         verifier,
 		mutagen:          mutagen,
 		etalonsCount:     int(float64(populationConfig.PopulationSize) * populationConfig.SelectionSize),
+		bestFitness:      nil,
+		bestNetwork:      nil,
 	}
 
 	if p.etalonsCount%2 != 0 {
@@ -94,11 +98,22 @@ func (p *Population) NaturalSelection(generationCount int) {
 	}
 }
 
+func (p *Population) GetBestNetwork() *neuralnetwork.NeuralNetwork {
+	return p.bestNetwork
+}
+
 func (p *Population) crossbreedPopulation(fitnesses []*IndividalFitness) {
 	sort.Slice(fitnesses, func(i, j int) bool {
 		return fitnesses[i].Fitness > fitnesses[j].Fitness //Descent order best will be on top, worst in the bottom
 	})
 
+	//Save best fitness individal
+	if p.bestFitness == nil || p.bestFitness.Fitness < fitnesses[0].Fitness {
+		p.bestFitness = fitnesses[0]
+		p.bestNetwork = p.Networks[fitnesses[0].Index].Copy()
+		fmt.Printf("New best Fitness %v \n", fitnesses[0].Fitness)
+	}
+
 	//Collect etalons from upper part of neural network list and crossbreed/mutate them
 	etalonNetworks := make([]*neuralnetwork.NeuralNetwork, p.etalonsCount)
 	for i := 1; i < p.etalonsCount; i += 2 {

snakesimulator/main.go

@@ -34,6 +34,10 @@ import (
 func main() {
 	s := snakesimulator.NewSnakeSimulator(400)
 	s.StartServer()
+
 	p := genetic.NewPopulation(s, mutagens.NewDummyMutagen(1.0, 1), genetic.PopulationConfig{PopulationSize: 2000, SelectionSize: 0.01, CrossbreedPart: 0.5}, []int{24, 18, 18, 4})
+
 	p.NaturalSelection(5000)
+
+	s.PlayBestNetwork(p.GetBestNetwork())
 }

snakesimulator/snakesimulator/snakesimulator.go

@@ -51,11 +51,14 @@ type SnakeSimulator struct {
 	remoteControl        *remotecontrol.RemoteControl
 
 	//GUI interface part
-	speed            uint32
-	fieldUpdateQueue chan bool
-	snakeUpdateQueue chan bool
-	statsUpdateQueue chan bool
-	speedQueue       chan uint32
+	speed                uint32
+	fieldUpdateQueue     chan bool
+	snakeUpdateQueue     chan bool
+	statsUpdateQueue     chan bool
+	isPlayingUpdateQueue chan bool
+	speedQueue           chan uint32
+	isPlaying            bool
+	repeatInLoop         bool
 
 	snakeReadMutex sync.Mutex
 	fieldReadMutex sync.Mutex
@@ -81,6 +84,7 @@ func NewSnakeSimulator(maxVerificationSteps int) (s *SnakeSimulator) {
 		fieldUpdateQueue:     make(chan bool, 2),
 		snakeUpdateQueue:     make(chan bool, 2),
 		statsUpdateQueue:     make(chan bool, 2),
+		isPlayingUpdateQueue: make(chan bool, 1),
 		speedQueue:           make(chan uint32, 1),
 		speed:                10,
 		remoteControl:        remotecontrol.NewRemoteControl(),
@@ -125,13 +129,51 @@ func (s *SnakeSimulator) Verify(population *genetic.Population) (fitnesses []*ge
 	s.fieldUpdateQueue <- true
 	prevSpeed := s.speed
 	s.speed = 5
-	population.Networks[fitnesses[0].Index].SetStateWatcher(s.remoteControl)
-	s.runSnake(population.Networks[fitnesses[0].Index], false)
-	population.Networks[fitnesses[0].Index].SetStateWatcher(nil)
+	if s.isPlaying == true {
+		// Play best of the best
+		s.isPlaying = false
+		s.isPlayingUpdateQueue <- s.isPlaying
+		population.GetBestNetwork().SetStateWatcher(s.remoteControl)
+		s.runSnake(population.GetBestNetwork(), false)
+		population.GetBestNetwork().SetStateWatcher(nil)
+	} else {
+		// Pley best from generation
+		population.Networks[fitnesses[0].Index].SetStateWatcher(s.remoteControl)
+		s.runSnake(population.Networks[fitnesses[0].Index], false)
+		population.Networks[fitnesses[0].Index].SetStateWatcher(nil)
+	}
 	s.speed = prevSpeed
 	return
 }
 
+func (s *SnakeSimulator) PlayBestNetwork(network *neuralnetwork.NeuralNetwork) {
+
+	for s.repeatInLoop {
+		s.remoteControl.Init(network)
+		s.stats.Generation++
+		s.statsUpdateQueue <- true
+
+		s.field.GenerateNextFood()
+		if s.speed > 0 {
+			s.fieldUpdateQueue <- true
+		}
+
+		//Best snake showtime!
+		s.fieldReadMutex.Lock()
+		s.field.GenerateNextFood()
+		s.fieldReadMutex.Unlock()
+		s.fieldUpdateQueue <- true
+		s.isPlaying = false
+		s.isPlayingUpdateQueue <- s.isPlaying
+		prevSpeed := s.speed
+		s.speed = 5
+		network.SetStateWatcher(s.remoteControl)
+		s.runSnake(network, false)
+		network.SetStateWatcher(nil)
+		s.speed = prevSpeed
+	}
+}
+
 func (s *SnakeSimulator) runSnake(inidividual *neuralnetwork.NeuralNetwork, randomStart bool) {
 	s.snakeReadMutex.Lock()
 	if randomStart {
@@ -447,3 +489,32 @@ func (s *SnakeSimulator) SetSpeed(ctx context.Context, speed *Speed) (*None, err
 	s.speedQueue <- speed.Speed
 	return &None{}, nil
 }
+
+// Ask to play requested from gRPC GUI client
+func (s *SnakeSimulator) PlayBest(ctx context.Context, _ *None) (*None, error) {
+	s.isPlaying = true
+	s.isPlayingUpdateQueue <- s.isPlaying
+	return &None{}, nil
+}
+
+// Play in loop
+func (s *SnakeSimulator) PlayBestInLoop(_ context.Context, playBest *PlayingBestState) (*None, error) {
+	s.repeatInLoop = playBest.State
+	return &None{}, nil
+}
+
+// State of playing
+func (s *SnakeSimulator) IsPlaying(_ *None, srv SnakeSimulator_IsPlayingServer) error {
+	ctx := srv.Context()
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		default:
+		}
+		srv.Send(&PlayingBestState{
+			State: s.isPlaying,
+		})
+		<-s.isPlayingUpdateQueue
+	}
+}

snakesimulator/snakesimulator/snakesimulator.proto

@@ -60,6 +60,10 @@ message Speed {
     uint32 speed = 1;
 }
 
+message PlayingBestState {
+    bool state = 1;
+}
+
 message None {
 }
 
@@ -68,4 +72,7 @@ service SnakeSimulator {
     rpc field(None) returns (stream Field) {}
     rpc stats(None) returns (stream Stats) {}
     rpc setSpeed(Speed) returns (None) {}
+    rpc playBest(None) returns (None) {}
+    rpc playBestInLoop(PlayingBestState) returns (None) {}
+    rpc isPlaying(None) returns (stream PlayingBestState) {}
 }

snakesimulator/snakesimulatorui/clientwrapper.h

@@ -39,6 +39,14 @@ public:
     Q_INVOKABLE void setSpeed(int speed) {
         m_client->setSpeed({(QtProtobuf::uint32)speed, nullptr});
     }
+
+    Q_INVOKABLE void playBest() {
+        m_client->playBest({nullptr});
+    }
+
+    Q_INVOKABLE void playBestInLoop(bool play) {
+        m_client->playBestInLoop({play, nullptr});
+    }
 private:
     snakesimulator::SnakeSimulatorClient* m_client;
 };

snakesimulator/snakesimulatorui/main.cpp

@@ -50,6 +50,7 @@ int main(int argc, char *argv[])
     qRegisterProtobufType<snakesimulator::Stats>();
     qRegisterProtobufType<snakesimulator::Point>();
     qRegisterProtobufType<snakesimulator::Speed>();
+    qRegisterProtobufType<snakesimulator::PlayingBestState>();
 \
     qmlRegisterUncreatableType<QtProtobuf::QGrpcAsyncReply>("snakesimulator", 1, 0, "QGrpcAsyncReply", "");
     std::shared_ptr<snakesimulator::SnakeSimulatorClient> client(new snakesimulator::SnakeSimulatorClient);
@@ -61,6 +62,11 @@ int main(int argc, char *argv[])
     snakesimulator::Snake *snake = new snakesimulator::Snake;
     snakesimulator::Field *field = new snakesimulator::Field;
     snakesimulator::Stats *stats = new snakesimulator::Stats;
+    snakesimulator::PlayingBestState *isPlaying = new snakesimulator::PlayingBestState;
+
+    QObject::connect(client.get(), &snakesimulator::SnakeSimulatorClient::isPlayingUpdated, [isPlaying](const snakesimulator::PlayingBestState & _isPlaying){
+        *isPlaying = _isPlaying;
+    });
 
     QObject::connect(client.get(), &snakesimulator::SnakeSimulatorClient::fieldUpdated, [field](const snakesimulator::Field & _field){
         *field = _field;
@@ -77,12 +83,15 @@ int main(int argc, char *argv[])
     client->subscribeFieldUpdates({});
     client->subscribeSnakeUpdates({});
     client->subscribeStatsUpdates({});
+    client->subscribeIsPlayingUpdates({});
 
     QQmlApplicationEngine engine;
     engine.rootContext()->setContextProperty("field", field);
     engine.rootContext()->setContextProperty("snake", snake);
     engine.rootContext()->setContextProperty("stats", stats);
     engine.rootContext()->setContextProperty("client", wrap);
+    engine.rootContext()->setContextProperty("isPlaying", isPlaying);
+
     engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
     if (engine.rootObjects().isEmpty())
         return -1;

snakesimulator/snakesimulatorui/main.qml

@@ -26,6 +26,7 @@
 import QtQuick 2.11
 import QtQuick.Window 2.11
 import QtQuick.Controls 1.4
+import QtQuick.Controls.Styles 1.0
 
 import snakesimulator 1.0
 
@@ -110,6 +111,56 @@ ApplicationWindow {
                 }
             }
         }
+
+
+        // it will play best in the loop afte naturel selection finished
+        CheckBox {
+            id: playBestCheckbox
+            anchors.margins: 10
+            anchors.bottom: bestBtn.top
+            anchors.right: parent.right
+
+            checked: true
+            onCheckedChanged: {
+                client.playBestInLoop(playBestCheckbox.checked)
+            }
+
+            style: CheckBoxStyle {
+                label: Text {
+                    color: "white"
+                    text: "Repeat Best"
+                }
+            }
+            Component.onCompleted: {
+                client.playBestInLoop(playBestCheckbox.checked)
+            }
+        }
+
+        Button {
+            id: bestBtn
+            anchors.margins: 10
+            anchors.bottom: parent.bottom
+            anchors.right: parent.right
+
+            width: 100
+            height: 50
+
+            Rectangle {
+                anchors.fill: parent
+                enabled: isPlaying.state
+                color: isPlaying.state ? "#003b6f" : "lightgreen"
+            }
+
+            Text {
+                anchors.centerIn: parent
+                horizontalAlignment: Text.AlignVCenter
+                text: "Play best"
+            }
+
+            onClicked: {
+                client.playBest()
+            }
+        }
     }
 
     Connections {