Finish DnaManager

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;