Added functionality for Steal/Donate instructions to HealthHosts

source/Organism.h

@@ -176,7 +176,14 @@ class Organism {
   virtual void ClearReproSyms() {
     std::cout << "ClearReproSyms called from Organism" << std::endl;
     throw "Organism method called!";}
-
+  virtual void CycleTransfer(int _in){
+    std::cout << "CycleTransfer called from Organism" << std::endl;
+    throw "Organism method called!";
+  }
+  virtual int GetCyclesGiven(){
+    std::cout << "GetCyclesGiven called from Organism" << std::endl;
+    throw "Organism method called!";
+  }
   //Bacterium functions
   virtual double ProcessLysogenResources(double phage_inc_val){
     std::cout << "ProcessLysogenResources called from Organism" << std::endl;

source/sgp_mode/GenomeLibrary.h

@@ -30,8 +30,9 @@ using Library = sgpl::OpLibrary<
     //inst::Infect,
     // if-label doesn't make sense for SGP, same with *-head
     // and set-flow but this is required
-    sgpl::global::Anchor 
-    //inst::Steal
+    sgpl::global::Anchor,
+    inst::Steal,
+    inst::Donate
     >;
 
 using Spec = sgpl::Spec<Library, CPUState>;
@@ -263,6 +264,24 @@ class ProgramBuilder : emp::vector<sgpl::Instruction<Spec>> {
     Add("Nand", 0, 0, 0);
     Add("SharedIO");
   }
+
+  void AddSteal(int steal_count){
+
+    for (int i = 0; i < steal_count; i++){
+    Add("Steal");
+
+    Add("Donate");
+    Add("Donate");
+    Add("Donate");
+
+    }
+    Add("Steal");
+    //std::cout << "Adding Steal" << std::endl;
+  }
+
+  void AddDonate(){
+    Add("Donate");
+  }
 };
 
 sgpl::Program<Spec> CreateRandomProgram(size_t length) {
@@ -280,6 +299,27 @@ sgpl::Program<Spec> CreateNotProgram(size_t length) {
   return program.Build(length);
 }
 
+sgpl::Program<Spec> CreateParasiteNotProgram(size_t length, int steal_count) {
+  ProgramBuilder program;
+  program.AddSteal(steal_count);
+  program.AddNot();
+
+  return program.Build(length);
+}
+
+sgpl::Program<Spec> CreateMutualistNotProgram(size_t length) {
+  ProgramBuilder program;
+  program.AddNot();
+  program.AddDonate();
+  return program.Build(length);
+}
+
+sgpl::Program<Spec> CreateEquProgram(size_t length) {
+  ProgramBuilder program;
+  program.AddEqu();
+  return program.Build(length);
+}
+
 
 sgpl::Program<Spec> CreatePrivateNotProgram(size_t length) {
   ProgramBuilder program;
@@ -308,7 +348,19 @@ sgpl::Program<Spec> CreateStartProgram(emp::Ptr<SymConfigSGP> config) {
   if (config->RANDOM_ANCESTOR()) {
     return CreateRandomProgram(PROGRAM_LENGTH);
   } else if (config->TASK_TYPE() == 1) {
-    return CreateNotProgram(PROGRAM_LENGTH);
+    if(config->DONATION_STEAL_INST() == 1){
+      if(config->STRESS_TYPE() == 1){
+         std::cout << "eyyy its parasite time" << std::endl;
+        return CreateParasiteNotProgram(PROGRAM_LENGTH, config->CPU_TRANSFER_AMOUNT());
+      }
+      else if(config->STRESS_TYPE() == 0){
+        return CreateMutualistNotProgram(PROGRAM_LENGTH);
+      }
+    }
+    else{
+      std::cout << "U said I cant steal.." << std::endl;
+      return CreateNotProgram(PROGRAM_LENGTH);
+    }
   } else {
     return CreateReproProgram(PROGRAM_LENGTH);
   }

source/sgp_mode/HealthHost.h

@@ -7,6 +7,8 @@ class HealthHost : public SGPHost {
 
     public:
 
+    int cycles_given = 0;
+
       /**
    * Constructs a new SGPHost as an ancestor organism, with either a random
    * genome or a blank genome that knows how to do a simple task depending on
@@ -62,9 +64,32 @@ class HealthHost : public SGPHost {
         int host_cycle = 1;
         int sym_cycle = 0;
         if (HasSym()) {
-          if (sgp_config->STRESS_TYPE() == MUTUALIST) {
+
+          if(sgp_config->DONATION_STEAL_INST()){
+            sym_cycle = 1;
+
+            if(cycles_given >= 1){
+              if(random->P(sgp_config->CPU_TRANSFER_CHANCE())){
+                host_cycle += 1;
+                sym_cycle -= 1;
+                //std::cout << "here a donation" << std::endl;
+              }
+              cycles_given = 0;
+
+            }
+            else if(cycles_given <= -1){
+              if(random->P(sgp_config->CPU_TRANSFER_CHANCE())){
+                host_cycle -= 1;
+                sym_cycle += 1;
+                //std::cout << "here a steal >:)" << std::endl;
+              }
+              cycles_given = 0;
+
+            }
+          }
+          else{
+            if (sgp_config->STRESS_TYPE() == MUTUALIST) {
             //Host with mutualist gains 50% of CPU from mutualist
-
             if (random->P(sgp_config->CPU_TRANSFER_CHANCE())) {
               host_cycle = 2;
               sym_cycle = 0;
@@ -83,6 +108,7 @@ class HealthHost : public SGPHost {
               sym_cycle = 0;
             }
           }
+          }
         }
 
         //Loops running CPU steps
@@ -116,5 +142,27 @@ class HealthHost : public SGPHost {
       }
       GrowOlder();
     }
+
+    void CycleTransfer(int amount) override {
+      // for (int i = 0; i < abs(amount/4); i++){
+      //   if(random->P(sgp_config->CPU_TRANSFER_CHANCE())){
+      //     cycles_given += amount/(abs(amount)) * 4; 
+      //   }
+      //   else{
+      //     break;
+      //   }
+      // }
+      cycles_given += amount;
+    }
+
+    int GetCyclesGiven(){
+      return cycles_given;
+    }
+
+    std::string const GetName() override{
+      return "HealthHost";
+    }
 };
+
+
 #endif // HEALTHHOST_H

source/sgp_mode/Instructions.h

@@ -1,9 +1,12 @@
 #ifndef INSTRUCTIONS_H
 #define INSTRUCTIONS_H
 
+
 #include "CPUState.h"
 #include "SGPWorld.h"
 #include "Tasks.h"
+
+
 #include "sgpl/hardware/Cpu.hpp"
 #include "sgpl/operations/flow_global/Anchor.hpp"
 #include "sgpl/program/Program.hpp"
@@ -135,43 +138,37 @@ INST(SharedIO, {
   state.input_buf.push(next);
 });
 INST(Donate, {
-  if (state.world->GetConfig()->DONATION_STEAL_INST()) {
-    if (state.organism->IsHost() || state.organism->GetHost() == nullptr)
+  if (state.world->GetConfig()->DONATION_STEAL_INST() && (state.world->GetConfig()->STRESS_TYPE() == 0 || state.world->GetConfig()->ALLOW_TRANSITION_EVOLUTION() == 1)) {
+    if (state.organism->IsHost() || state.organism->GetHost() == nullptr){
+
       return;
+    }
     if (emp::Ptr<Organism> host = state.organism->GetHost()) {
-      // Donate 20% of the total points of the symbiont-host system
-      // This way, a sym can donate e.g. 40 or 60 percent of their points in a
-      // couple of instructions
-      double to_donate =
-          fmin(state.organism->GetPoints(),
-               (state.organism->GetPoints() + host->GetPoints()) * 0.20);
-      state.world->GetSymDonatedDataNode().WithMonitor(
-          [=](auto &m) { m.AddDatum(to_donate); });
-      host->AddPoints(to_donate *
-                      (1.0 - state.world->GetConfig()->DONATE_PENALTY()));
-      state.organism->AddPoints(-to_donate);
+
+      //New Donate implementation:
+      if(host->GetCyclesGiven() <= 0){
+        host->CycleTransfer(1);
+      }
     }
   }
+  else{
+  }
 });
 INST(Steal, {
-  if (state.world->GetConfig()->DONATION_STEAL_INST()) {
-    if (state.organism->IsHost() || state.organism->GetHost() == nullptr)
+  if (state.world->GetConfig()->DONATION_STEAL_INST() && (state.world->GetConfig()->STRESS_TYPE() == 1 || state.world->GetConfig()->ALLOW_TRANSITION_EVOLUTION() == 1)) {
+    if (state.organism->IsHost() || state.organism->GetHost() == nullptr){
       return;
+    }
     if (emp::Ptr<Organism> host = state.organism->GetHost()) {
-      // Steal 20% of the total points of the symbiont-host system
-      // This way, a sym can steal e.g. 40 or 60 percent of the host's points in
-      // a couple of instructions
-      double to_steal =
-          fmin(host->GetPoints(),
-               (state.organism->GetPoints() + host->GetPoints()) * 0.20);
-      state.world->GetSymStolenDataNode().WithMonitor(
-          [=](auto &m) { m.AddDatum(to_steal); });
-      host->AddPoints(-to_steal);
-      // 10% of the stolen resources are lost
-      state.organism->AddPoints(
-          to_steal * (1.0 - state.world->GetConfig()->STEAL_PENALTY()));
+
+      //New Steal Implementation
+      if(host->GetCyclesGiven() >= 0){
+       host->CycleTransfer(-1);
+      }
     }
   }
+  else{
+  }
 });
 
 INST(Reuptake, {

source/sgp_mode/SGPConfigSetup.h

@@ -30,8 +30,9 @@ EMP_EXTEND_CONFIG(SymConfigSGP, SymConfigBase,
   VALUE(MUTUALIST_DEATH_CHANCE, double, 0.125, "What death chance does a mutualist confer?"),
   VALUE(BASE_DEATH_CHANCE, double, 0.25, "What death chance does a host have in the absence of symbionts?"),
   VALUE(CPU_TRANSFER_CHANCE, double, 0.5, "What is the chance for cycles to be stolen/donated?"),
-  VALUE(ONLY_FIRST_TASK_CREDIT, int, 0, "Should symbionts only get credit for their first task")
-
+  VALUE(CPU_TRANSFER_AMOUNT, double, 1, "How many updates should be stolen/donated by instruction based symbionts"),
+  VALUE(ONLY_FIRST_TASK_CREDIT, int, 0, "Should symbionts only get credit for their first task"),
+  VALUE(ALLOW_TRANSITION_EVOLUTION, int, 0, "Should symbionts be allowed to evolve from mutalists to parasties and vice versa")
 )
 
 #endif

source/test/sgp_mode_test/HealthHost.test.cc

@@ -1,3 +1,5 @@
+#include "../../sgp_mode/GenomeLibrary.h"
+#include "../../sgp_mode/CPU.h"
 #include "../../sgp_mode/HealthHost.h"
 #include "../../sgp_mode/SGPWorld.h"
 #include "../../sgp_mode/SGPWorldSetup.cc"
@@ -146,3 +148,107 @@ TEST_CASE("Health hosts evolve", "[sgp-integration]") {
     }
   }
 } 
+
+TEST_CASE("When DONATION_STEAL_INST is 1 then Symbiont with 'Steal' instruction properly takes CPU cycles from HealthHost", "[sgp]"){
+
+  emp::Random random(1);
+  SymConfigSGP config;
+  config.RANDOM_ANCESTOR(false);
+  config.SEED(0);
+  config.ORGANISM_TYPE(HEALTH);
+  config.STRESS_TYPE(1);
+  config.MUTATION_RATE(0.0);
+  config.MUTATION_SIZE(0.00);
+  config.TRACK_PARENT_TASKS(1);
+  config.VT_TASK_MATCH(1);
+  config.ONLY_FIRST_TASK_CREDIT(1);
+  config.HOST_REPRO_RES(10000);
+  config.DONATION_STEAL_INST(1);
+  config.CPU_TRANSFER_CHANCE(1);
+
+
+  SGPWorld world(random, &config, LogicTasks);
+
+  //Builds program that does both NOT and NAND operations
+
+
+  //Creates a host that only does NOT operations
+  emp::Ptr<HealthHost> host = emp::NewPtr<HealthHost>(&random, &world, &config, CreateNotProgram(100));
+  //Creates a symbiont that does both Not and Nand operations
+  emp::Ptr<SGPSymbiont> sym = emp::NewPtr<SGPSymbiont>(&random, &world, &config, CreateParasiteNotProgram(100));
+
+  //Adds host to world and sym to host.
+  world.AddOrgAt(host, 0);
+  host->AddSymbiont(sym);
+
+  WHEN("A symbiont performs a Steal instruction"){
+  sym->GetCPU().RunCPUStep(0, 100);
+  (*(sym->GetCPU().state.tasks_performed))[0] = 0;
+  THEN("The host should be set to lose 4 cycles to the symbiont"){
+    REQUIRE(host->GetCyclesGiven() == -4);
+  }
+  for (size_t i = 0; i < 24; i++) {
+    world.Update();
+    }
+THEN("The symbiont should complete its task one update early"){
+  REQUIRE(sym->GetCPU().state.tasks_performed->Get(0) == true);
+}
+  world.Update();
+  THEN("The host should be unable to complete its task in 25 updates"){
+    REQUIRE(host->GetCPU().state.tasks_performed->Get(0) == false);
+  }
+}
+
+}
+
+TEST_CASE("When DONATION_STEAL_INST is 1 then Symbiont with 'Donate' instruction properly gives CPU cycles to HealthHost", "[sgp]"){
+
+  emp::Random random(1);
+  SymConfigSGP config;
+  config.RANDOM_ANCESTOR(false);
+  config.SEED(0);
+  config.ORGANISM_TYPE(HEALTH);
+  config.STRESS_TYPE(0);
+  config.MUTATION_RATE(0.0);
+  config.MUTATION_SIZE(0.00);
+  config.TRACK_PARENT_TASKS(1);
+  config.VT_TASK_MATCH(1);
+  config.ONLY_FIRST_TASK_CREDIT(1);
+  config.DONATION_STEAL_INST(1);
+  config.CPU_TRANSFER_CHANCE(1);
+
+  config.HOST_REPRO_RES(10000);
+
+  SGPWorld world(random, &config, LogicTasks);
+
+  //Builds program that does both NOT and NAND operations
+
+
+  //Creates a host that only does NOT operations
+  emp::Ptr<HealthHost> host = emp::NewPtr<HealthHost>(&random, &world, &config, CreateNotProgram(100));
+  //Creates a symbiont that does both Not and Nand operations
+  emp::Ptr<SGPSymbiont> sym = emp::NewPtr<SGPSymbiont>(&random, &world, &config, CreateMutualistNotProgram(100));
+
+  //Adds host to world and sym to host.
+  world.AddOrgAt(host, 0);
+  host->AddSymbiont(sym);
+
+WHEN("A symbiont performs a Donate instruction"){
+  sym->GetCPU().RunCPUStep(0, 100);
+  (*(sym->GetCPU().state.tasks_performed))[0] = 0;
+  THEN("The host should be set to gain 4 cycles from the symbiont"){
+    REQUIRE(host->GetCyclesGiven() == 4);
+  }
+  for (size_t i = 0; i < 24; i++) {
+    world.Update();
+    }
+THEN("The host should complete its task one update early"){
+  REQUIRE(host->GetCPU().state.tasks_performed->Get(0) == true);
+}
+  world.Update();
+  THEN("The symbiont should be unable to complete its task in 25 updates"){
+    REQUIRE(sym->GetCPU().state.tasks_performed->Get(0) == false);
+  }
+
+}
+}