Finish DnaManager

inc/App.hpp

@@ -13,6 +13,8 @@ public:
   void deinit();
 
 private:
+  void upTex(Liked liked);
+
   int screenWidth, screenHeight;
   Canvas canvas;
   RenderTexture2D canvasTexure = {0};

inc/values/Dna.hpp

@@ -53,7 +53,8 @@ struct Dna
   uint8_t colorSet;
   Branch branches[MAX_DEPTH];
 };
-
-void newDna(Dna &dna);
-
+void newDna(Dna *dna, uint128 *state);
+void makeChild(Dna *p1, Dna *p2, Dna *c, uint128 *state);
+void clone(Dna *p1, Dna *c, uint128 *state);
+void mutate(Dna *dna, uint32_t num, uint128 *state);
 #endif /* DNA_H */

inc/values/DnaManager.hpp

@@ -1,4 +1,9 @@
 #include "values/Dna.hpp"
+#include <list>
+#include <vector>
+
+#define NUM_PER_GEN 10
+#define NUM_OF_MUT 1
 
 enum Liked
 {
@@ -22,5 +27,12 @@ public:
   void like(Unit unit);
 
 private:
-  Dna dna;
+  uint128 randSeed;
+  std::vector<Dna> vector;
+  std::list<Dna *> queued;
+  std::list<Dna *> showed;
+  std::vector<Dna *> liked;
+  std::vector<Dna *> disliked;
+
+  void newGen();
 };

inc/values/mrand.hpp

@@ -5,9 +5,9 @@ struct uint128;
 namespace mrand
 {
   void setSeed(unsigned long long seed);
-  int getValue(int min, int max);
+  // int getValue(int min, int max);
   float getFloat(uint128 *state);
-  float getFloat();
+  // float getFloat();
   int getValue(int min, int max, uint128 *state);
   uint32_t getInt();
 }

src/App.cpp

@@ -27,6 +27,23 @@ void App::init(int screenWidth, int screenHeight)
   likeBox = {screenWidth - recPosX, posY, (float)recPosX, (float)screenWidth};
 }
 
+void App::upTex(Liked liked)
+{
+  unit.liked = liked;
+  manager.like(unit);
+  unit = manager.next();
+  if (unit.dna != nullptr)
+  {
+    canvas.newGen(canvasTexure, unit.dna);
+    return;
+  }
+
+  BeginTextureMode(canvasTexure);
+  ClearBackground(WHITE);
+  DrawText("NEXT GEN", 10, 10, 20, BLACK);
+  EndTextureMode();
+}
+
 void App::update()
 {
   bool isDone = canvas.tick(canvasTexure);
@@ -35,17 +52,11 @@ void App::update()
     Vector2 mouse = GetMousePosition();
     if (CheckCollisionPointRec(mouse, disLikeBox))
     {
-      unit.liked = Liked::no;
-      manager.like(unit);
-      unit = manager.next();
-      canvas.newGen(canvasTexure, unit.dna);
+      upTex(Liked::no);
     }
     if (CheckCollisionPointRec(mouse, likeBox))
     {
-      unit.liked = Liked::yes;
-      manager.like(unit);
-      unit = manager.next();
-      canvas.newGen(canvasTexure, unit.dna);
+      upTex(Liked::yes);
     }
   }
 }

src/values/Dna.cpp

@@ -6,12 +6,59 @@
 
 #include <raymath.h>
 
-void newDna(Dna &dna)
+void newDna(Dna *dna, uint128 *state)
 {
-  uint8_t *array = (uint8_t *)&dna;
+  uint8_t *array = (uint8_t *)dna;
   for (size_t i = 0; i < sizeof(Dna); i++)
   {
-    array[i] = mrand::getValue(0, 255);
+    array[i] = mrand::getValue(0, 255, state);
   }
   return;
 }
+
+void makeChild(Dna *p1, Dna *p2, Dna *c, uint128 *state)
+{
+  uint8_t *p1a = (uint8_t *)p1;
+  uint8_t *p2a = (uint8_t *)p2;
+  uint8_t *ca = (uint8_t *)c;
+  for (size_t i = 0; i < sizeof(Dna); i++)
+  {
+    int val = mrand::getValue(0, 1, state);
+    if (val == 0)
+    {
+      ca[i] = p1a[i];
+    }
+    else
+    {
+      ca[i] = p2a[i];
+    }
+  }
+}
+
+void clone(Dna *p1, Dna *c, uint128 *state)
+{
+  uint8_t *p1a = (uint8_t *)p1;
+
+  uint8_t *ca = (uint8_t *)c;
+  for (size_t i = 0; i < sizeof(Dna); i++)
+  {
+    int val = mrand::getValue(0, 1, state);
+    if (val == 0)
+    {
+      ca[i] = p1a[i];
+    }
+    else
+    {
+      ca[i] = mrand::getValue(0, 255, state);
+    }
+  }
+}
+void mutate(Dna *dna, uint32_t num, uint128 *state)
+{
+  uint8_t *array = (uint8_t *)dna;
+  for (size_t i = 0; i < num; i++)
+  {
+    int pos = mrand::getValue(0, sizeof(Dna), state);
+    array[pos] = mrand::getValue(0, 255, state);
+  }
+}

src/values/DnaManager.cpp

@@ -1,7 +1,19 @@
 #include "values/DnaManager.hpp"
+#include "values/mrand.hpp"
 
 void DnaManager::init()
 {
+  randSeed.a = mrand::getInt();
+  randSeed.b = mrand::getInt();
+  randSeed.c = mrand::getInt();
+  randSeed.d = mrand::getInt();
+
+  vector.resize(NUM_PER_GEN);
+  for (std::size_t i = 0; i < NUM_PER_GEN; i++)
+  {
+    newDna(&vector[i], &randSeed);
+    queued.push_back(&vector[i]);
+  }
 }
 
 void DnaManager::deinit()
@@ -10,10 +22,110 @@ void DnaManager::deinit()
 
 Unit DnaManager::next()
 {
-  newDna(dna);
-  return {&dna, Liked::tbd};
+  if (queued.empty())
+  {
+    return {nullptr, Liked::tbd};
+  }
+
+  Dna *ret = queued.front();
+  queued.pop_front();
+  showed.push_back(ret);
+  return {ret, Liked::tbd};
 }
 
 void DnaManager::like(Unit unit)
 {
+  Dna *found = nullptr;
+  for (auto &&i : showed)
+  {
+    if (i == unit.dna)
+      found = unit.dna;
+  }
+
+  if (found == nullptr)
+  {
+    TraceLog(LOG_ERROR, "NOT FOUND UNIT");
+    return;
+  }
+  if (unit.liked == Liked::yes)
+  {
+    liked.push_back(found);
+  }
+  else if (unit.liked == Liked::no)
+  {
+    disliked.push_back(found);
+  }
+  else
+  {
+    TraceLog(LOG_ERROR, "LIKED WITH NO VAULE");
+    return;
+  }
+
+  showed.remove(found);
+
+  if (showed.size() == 0 && queued.size() == 0)
+  {
+    newGen();
+  }
+}
+
+void DnaManager::newGen()
+{
+  if (liked.size() == 0)
+  {
+    for (std::size_t i = 0; i < NUM_PER_GEN; i++)
+    {
+      newDna(&vector[i], &randSeed);
+      queued.push_back(&vector[i]);
+    }
+    disliked.clear();
+    return;
+  }
+
+  for (auto &&i : liked)
+  {
+    queued.push_back(i);
+  }
+
+  if (liked.size() == 1)
+  {
+    Dna *front = liked.front();
+
+    for (auto &&i : disliked)
+    {
+      clone(front, i, &randSeed);
+      queued.push_back(i);
+    }
+
+    disliked.clear();
+    liked.clear();
+    return;
+  }
+
+  if (liked.size() >= 2)
+  {
+    for (auto &&i : disliked)
+    {
+      size_t p1 = mrand::getValue(0, liked.size() - 1, &randSeed);
+      size_t p2 = mrand::getValue(0, liked.size() - 1, &randSeed);
+      while (p1 == p2)
+      {
+        p2 = mrand::getValue(0, liked.size(), &randSeed);
+      }
+
+      Dna *p1p = liked[p1];
+      Dna *p2p = liked[p2];
+      makeChild(p1p, p2p, i, &randSeed);
+      queued.push_back(i);
+    }
+  }
+
+  if (queued.size() == NUM_PER_GEN)
+  {
+    for (auto &&i : queued)
+    {
+      mutate(i, NUM_OF_MUT, &randSeed);
+    }
+    return;
+  }
 }

src/values/mrand.cpp

@@ -53,18 +53,6 @@ namespace mrand
     return my_rprand_xoshiro(rprand_state);
   }
 
-  int getValue(int min, int max)
-  {
-    int value = my_rprand_xoshiro(rprand_state) % (std::abs(max - min) + 1) + min;
-
-    return value;
-  }
-
-  float getFloat()
-  {
-    return my_rprand_xoshiro(rprand_state) / 4294967295.0f;
-  }
-
   int getValue(int min, int max, uint128 *state)
   {
     int value = my_rprand_xoshiro((uint32_t *)state) % (std::abs(max - min) + 1) + min;