Fixed merge conflict'

Author: EliasH-E

source/Organism.h

@@ -185,7 +185,6 @@ class Organism {
     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/CPUState.h

@@ -58,8 +58,6 @@ struct CPUState {
   // If this organism is queued for reproduction, this stores its position in
   // the queue. When the organism dies, its queue slot will be invalidated.
   int in_progress_repro = -1;
-  emp::Ptr<emp::vector<uint32_t>> internal_environment =
-      emp::NewPtr<emp::vector<uint32_t>>();
   emp::vector<size_t> jump_table;
 
   emp::Ptr<Organism> organism;

source/sgp_mode/GenomeLibrary.h

@@ -51,6 +51,14 @@ class ProgramBuilder : emp::vector<sgpl::Instruction<Spec>> {
     push_back(inst);
   }
 
+   void AddNop(uint8_t arg0 = 0, uint8_t arg1 = 0,
+           uint8_t arg2 = 0) {
+    sgpl::Instruction<Spec> inst;
+    inst.op_code = 0;
+    inst.args = {arg0, arg1, arg2};
+    push_back(inst);
+  }
+
   sgpl::Program<Spec> Build(size_t length) {
     Add("Reproduce");
 
@@ -257,14 +265,36 @@ class ProgramBuilder : emp::vector<sgpl::Instruction<Spec>> {
     Add("SharedIO");
   }
 
-  void AddSteal(){
+  void AddStartSteal(int steal_count){
+    
+    int diff = 96/steal_count;
+   
+    for (int i = 0; i < steal_count; i++){
+      
+      for (int x = 1; x < diff; x++){
+      AddNop();
+      
+      }
+      Add("Steal");
+      
+    }
 
-    Add("Steal");
-    //std::cout << "Adding Steal" << std::endl;
   }
 
-  void AddDonate(){
-    Add("Donate");
+  void AddStartDonate(int donate_count){
+    
+    int diff = 96/donate_count;
+    int index = 1;
+    for (int i = 0; i < donate_count; i++){
+      
+      for (int x = 1; x < diff; x++){
+      AddNop();
+      
+      
+      }
+      Add("Donate");
+      
+    }
   }
 };
 
@@ -279,22 +309,57 @@ sgpl::Program<Spec> CreateNotProgram(size_t length) {
   return program.Build(length);
 }
 
-sgpl::Program<Spec> CreateMutualistStart(size_t length) {
+sgpl::Program<Spec> CreateParasiteNotProgram(size_t length, int steal_count) {
+  ProgramBuilder program;
+  program.Add("Steal");
+  program.Add("Steal");
+  program.AddStartSteal(steal_count);
+  program.AddNot();
+  
+  return program.Build(length);
+}
+
+sgpl::Program<Spec> CreateMutualistNotProgram(size_t length, int donate_count) {
   ProgramBuilder program;
-  program.AddNand();
-  return program.BuildNoRepro(length);
+  
+  program.Add("Donate");
+  program.Add("Donate");
+  program.AddStartDonate(donate_count);
+  program.AddNot();
+  return program.Build(length);
 }
 
+sgpl::Program<Spec> CreateEquProgram(size_t length) {
+  ProgramBuilder program;
+  program.AddEqu();
+  return program.Build(length);
+}
+
+
 /**
  * Picks what type of starting program should be created based on the config and
  * creates it.
  */
 sgpl::Program<Spec> CreateStartProgram(emp::Ptr<SymConfigSGP> config) {
   if (config->TASK_TYPE() == 1) {
-    return CreateNotProgram(PROGRAM_LENGTH);
-  } else {
-    return CreateReproProgram(PROGRAM_LENGTH);
+    if(config->DONATION_STEAL_INST() == 1){
+      if(config->STRESS_TYPE() == 1){
+        return CreateParasiteNotProgram(PROGRAM_LENGTH, config->CPU_TRANSFER_AMOUNT());
+      }
+      else if(config->STRESS_TYPE() == 0){
+        return CreateMutualistNotProgram(PROGRAM_LENGTH, config->CPU_TRANSFER_AMOUNT());
+      }
+      else{
+        return CreateNotProgram(PROGRAM_LENGTH);
+      }
+    }
+    else{
+        return CreateNotProgram(PROGRAM_LENGTH);
+      }
+    
   }
+  return CreateReproProgram(PROGRAM_LENGTH);
+  
 }
 
 #endif

source/sgp_mode/HealthHost.h

@@ -7,8 +7,14 @@ class HealthHost : public SGPHost {
 
     public:
 
-    int cycles_given = 0;
-
+    //Tracks whether an update needs to be given to a symbiont or received from a symbiont
+    int cycles_given = 1;
+
+    //Test variables that are currently used to give symbionts some starting cycles and then give them scraps throughout
+    //the rest of their updates.
+    int honoray_cycles = 0;
+    int starting_updates = 1;
+    emp::Ptr<Organism> last_sym = NULL; 
       /**
    * 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
@@ -57,7 +63,17 @@ class HealthHost : public SGPHost {
         random, GetWorld(), sgp_config, GetCPU().GetProgram(), GetIntVal());
     return host_baby;
   }
-  
+    void CycleTransfer(int amount) override {
+      cycles_given += amount;
+    }
+
+    int GetCyclesGiven(){
+      return cycles_given;
+    }
+
+    std::string const GetName() override{
+      return "HealthHost";
+    }
     /** 
      * Input: The location of the host.
      * 
@@ -78,19 +94,58 @@ class HealthHost : public SGPHost {
         if (HasSym()) {
 
           if(sgp_config->DONATION_STEAL_INST()){
-            sym_cycle = 1;
-
-            if(cycles_given >= int(sgp_config->CYCLES_PER_UPDATE())){
-              host_cycle += 1;
-              sym_cycle -= 1;
-              cycles_given -= int(sgp_config->CYCLES_PER_UPDATE());
+            
+            
+            if(cycles_given >= 1){
+              if(random->P(sgp_config->CPU_TRANSFER_CHANCE())){
+                host_cycle += 1;
+                sym_cycle -= 1;
+                cycles_given = 0;
+              }
 
+              
+              //cycles_given = 0;
+            }
+            if(cycles_given <= -1){
+              
+             
+              if(random->P(sgp_config->CPU_TRANSFER_CHANCE())){
+                host_cycle = 0;
+                sym_cycle += 1;
+                cycles_given = 0;
+              }
+              //cycles_given = 0;
+
             }
-            else if(cycles_given <= (-1 * int(sgp_config->CYCLES_PER_UPDATE()))){
-              host_cycle -= 1;
-              sym_cycle += 1;
-              cycles_given += int(sgp_config->CYCLES_PER_UPDATE());
 
+            //This sequence checks if the symbiont will receive a cycle, if it has not then it checks if
+          //one of its bonus updates is left, if so it uses one, if not it ticks up the counter
+          //for when it receives said bonus update. 
+          //Allows for symbiont to reach steals but to still need them
+            emp::vector<emp::Ptr<Organism>> &syms = GetSymbionts();
+              emp::Ptr<Organism> curSym = syms[0];
+              if(last_sym != curSym){
+                last_sym = curSym;
+                cycles_given = 0;
+                starting_updates = sgp_config->STARTING_BONUS();
+              }
+
+            if(sym_cycle == 0 && sgp_config->DONATION_STEAL_INST()){
+              
+              
+              
+              if(starting_updates > 0){
+                sym_cycle += 1;
+                starting_updates -= 1;
+              }
+              
+            }
+            if(starting_updates < 1){
+              honoray_cycles += 1;
+                if(honoray_cycles == sgp_config->BONUS_UPDATE_WAIT()){
+                  starting_updates += 1;
+                  honoray_cycles = 0;
+                }
             }
           }
           else{
@@ -115,8 +170,12 @@ class HealthHost : public SGPHost {
             }
           }
           }
+
+  
         }
 
+        
+        
         //Loops running CPU steps
         for(int i = 0; i < host_cycle; i++){
           GetCPU().RunCPUStep(pos, sgp_config->CYCLES_PER_UPDATE());
@@ -149,13 +208,6 @@ class HealthHost : public SGPHost {
       GrowOlder();
     }
 
-    void CycleTransfer(int amount) override {
-      cycles_given += amount; 
-    }
-
-    int GetCyclesGiven(){
-      return cycles_given;
-    }
 };
 
 

source/sgp_mode/Instructions.h

@@ -116,51 +116,38 @@ INST(SharedIO, {
   *a = next;
   state.input_buf.push(next);
 });
+
 INST(Donate, {
   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){
-
+    if (state.organism->IsHost()){
       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);
-      state.organism->AddPoints(-to_donate);
     }
-    if (emp::Ptr<Organism> host = state.organism->GetHost()) {
-  
-      //New Donate implementation:
-      host->CycleTransfer(int(state.world->GetConfig()->CYCLES_PER_UPDATE()));
-
-
+    emp::Ptr<Organism> host = state.organism->GetHost();
+    if(host->GetCyclesGiven() <= 0){
+      host->CycleTransfer(1);
+      state.world->GetDonateCount().WithMonitor(
+          [=](auto &m) { m.AddDatum(1); });
     }
+    
+    
   }
 
-}});
+});
 INST(Steal, {
   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){
+    if (state.organism->IsHost()){
       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);
-      state.organism->AddPoints(to_steal);
     }
+    emp::Ptr<Organism> host = state.organism->GetHost();
+    if(host->GetCyclesGiven() >= 0){
+        host->CycleTransfer(-1);
+        state.world->GetStealCount().WithMonitor(
+          [=](auto &m) { m.AddDatum(1); });
+      }
+    }
+   
   }
-}});
+);
 
 } // namespace inst
 

source/sgp_mode/SGPConfigSetup.h

@@ -11,7 +11,7 @@ EMP_EXTEND_CONFIG(SymConfigSGP, SymConfigBase,
   VALUE(CYCLES_PER_UPDATE, size_t, 4, "Number of CPU cycles that organisms run every update"),
   VALUE(THREAD_COUNT, size_t, 1, "Number of threads used to process organisms in parallel"),
   VALUE(TASK_TYPE, bool, 1, "1 for NOT + repro starting genome, 0 for repro starting program"),
-  VALUE(DONATION_STEAL_INST, bool, 1, "1 if you want donate and steal instructions in the instruction set, 0 if not"),
+  VALUE(DONATION_STEAL_INST, bool, 0, "1 if you want donate and steal instructions in the instruction set, 0 if not"),
   VALUE(RANDOM_IO_INPUT, bool, true, "1 to give organisms random input when they IO, 0 to give them only ones"),
   VALUE(ORGANISM_TYPE, size_t, DEFAULT, "What sgp organisms should population the world? (0 for default SGP, 1 for Health organisms, 2 for stress organisms)"),
   VALUE(VT_TASK_MATCH, bool, 0, "Should task matching be required for vertical transmission? (0 for no, 1 for yes)"),
@@ -24,8 +24,11 @@ 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(ALLOW_TRANSITION_EVOLUTION, int, 0, "Should symbionts be allowed to evolve from mutalists to parasties and vice versa")
+  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 organisms only get credit for their first task"),
+  VALUE(ALLOW_TRANSITION_EVOLUTION, int, 0, "Should symbionts be allowed to evolve from mutualists to parasties and vice versa"),
+  VALUE(BONUS_UPDATE_WAIT, int, 5, "If DONATION_STEAL_INST is 1 how many updates till a symbiont receives a free extra update"),
+  VALUE(STARTING_BONUS, int, 1, "How many bonus updates do symbionts start with")
 )
 
 #endif