Added a Def to control queen offspring chances

CHANGELOG.md

@@ -30,6 +30,7 @@ In general, the logic is the following:
 - The assignemnt is done by xenotypes for queen and drones. The baby will get all xenogenes of their parents xenotypes. 
 - For workers, every queen can have a set of genes for their workers defined in [a special def](./Common/Defs/QueenWorkerMappingDefs/QueenWorkerMappingDefs_base.xml). These will be added as endogenes, so that pawns can still become xenotypes.
 - There is a default set for worker genes, making mentally dumb, sterile and servile pawns. 
+- Chances for Offsprings (Drone, Queen, Worker) is defined in an [XML-Def](./Common/Defs/HiveOffspringChanceDef/HiveOffspringChanceDefs.xml)
 
 I am not sure if I want to have a specific mapping defining that Queen can only mate with certain Drones, let me know how you feel about it. 
 *Queens can be male*. I just used the female-term, but implementation is gender-neutral. 

Common/Defs/HiveOffspringChanceDef/HiveOffspringChanceDefs.xml

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Defs>
+
+    <!-- 
+        For writing your own: 
+        1. specify your queenXenotype with an exactly matching name 
+        2. defName is not important
+        3. queen + drone + worker == 1
+
+        Otherwise, it should default to the ones specified for rjw_genes_default_hive_offspring_chances
+    -->
+
+	<RJW_Genes.HiveOffspringChanceDef>
+        <!-- Important: this default defName cannot be renamed! It is a protected keyword.-->
+        <!-- Changing the queenXenotype-Name will also throw an error.-->
+        <!-- But you can change the workerGenes list.-->
+		<defName>rjw_genes_default_hive_offspring_chances</defName>
+        <queenXenotype>default</queenXenotype>
+
+        <queenChance>0.02</queenChance>
+        <droneChance>0.48</droneChance>
+        <workerChance>0.5</workerChance>
+
+	</RJW_Genes.HiveOffspringChanceDef>
+
+	<RJW_Genes.HiveOffspringChanceDef>
+        <defName>rjw_genes_test_queen_offspring_chances</defName>
+        <queenXenotype>rjw_genes_test_queen_xenotype</queenXenotype>
+
+        <queenChance>0.02</queenChance>
+        <droneChance>0.28</droneChance>
+        <workerChance>0.7</workerChance>
+
+	</RJW_Genes.HiveOffspringChanceDef>
+	
+</Defs>

Source/Genes/Hive/Defs/HiveOffspringChanceDef.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Verse;
+
+namespace RJW_Genes
+{
+    public class HiveOffspringChanceDef : Def 
+    {
+
+        public string queenXenotype;
+
+        // Chance of the below should be 1 when summed up! 
+        // Otherwise the roll-logic fails.
+
+        public double queenChance;
+        public double droneChance;
+        public double workerChance;
+
+    }
+}

Source/Genes/Hive/Helpers/HiveUtility.cs

@@ -128,8 +128,6 @@ namespace RJW_Genes
             Dictionary<XenotypeDef,List<GeneDef>> dict = new Dictionary<XenotypeDef, List<GeneDef>>();
             IEnumerable<QueenWorkerMappingDef> mappingDefs = DefDatabase<QueenWorkerMappingDef>.AllDefs;
 
-            if (RJW_Genes_Settings.rjw_genes_detailed_debug) ModLog.Message($"Found {mappingDefs.Count()} Queen-Worker mappings in defs");
-
             // Dev-Note: I first a nice lambda here, but I used nesting in favour of logging.
             foreach (QueenWorkerMappingDef mappingDef in mappingDefs)
             {
@@ -204,5 +202,27 @@ namespace RJW_Genes
             return DefDatabase<XenotypeDef>.AllDefs.Where(type => type.genes.Contains(GeneDefOf.rjw_genes_drone));
         }
 
+
+        public static HiveOffspringChanceDef LookupDefaultHiveInheritanceChances()
+        {
+            IEnumerable<HiveOffspringChanceDef> offspringChanceDefs = DefDatabase<HiveOffspringChanceDef>.AllDefs;
+
+            List<GeneDef> workerGenes = new List<GeneDef>();
+
+            var defaultChance = offspringChanceDefs.First(m => m.defName == "rjw_genes_default_hive_offspring_chances");
+
+            if (defaultChance == null)
+                ModLog.Warning("Did not find `rjw_genes_default_hive_offspring_chances`. Someone likely changed the defname!");
+
+            return defaultChance;
+        }
+
+        public static HiveOffspringChanceDef LookupHiveInheritanceChances(XenotypeDef queenDef)
+        {
+            IEnumerable<HiveOffspringChanceDef> offspringChanceDefs = DefDatabase<HiveOffspringChanceDef>.AllDefs;
+
+            return offspringChanceDefs.FirstOrFallback(t => t.queenXenotype == queenDef.defName, LookupDefaultHiveInheritanceChances());
+        }
+
     }
 }

Source/Genes/Hive/Patches/Patch_BirthOutcome_SetHiveGenes.cs

@@ -18,9 +18,6 @@ namespace RJW_Genes
     [HarmonyPatch(typeof(PregnancyUtility), nameof(PregnancyUtility.ApplyBirthOutcome))]
     public class Patch_BirthOutcome_SetHiveGenes
     {
-        const double QUEEN_CHANCE = 0.01f;
-        const double DRONE_CHANCE = 0.49f;
-        const double WORKER_CHANCE = 1 - QUEEN_CHANCE - DRONE_CHANCE;
 
 
         [HarmonyPostfix]
@@ -45,6 +42,8 @@ namespace RJW_Genes
                 if (RJW_Genes_Settings.rjw_genes_detailed_debug) ModLog.Message($"PostFix PregnancyUtility::ApplyBirthOutcome - Checking Hive Inheritance because {pawn} has a queen parent.");
 
                 XenotypeDef queenDef = TryFindParentQueenXenotype(pawn);
+                HiveOffspringChanceDef hiveOffspringChanceDef = HiveUtility.LookupHiveInheritanceChances(queenDef);
+
                 // Case 1: Mother is Queen, Father is something else. Produce Worker.
                 if (!hasDroneParent)
                 {
@@ -56,22 +55,22 @@ namespace RJW_Genes
                 {
                     double roll = (new Random()).NextDouble();
                     // Case 2.a: New Queen born
-                    if (roll < QUEEN_CHANCE)
+                    if (roll < hiveOffspringChanceDef.queenChance)
                     {
                         pawn.genes.SetXenotype(queenDef);
-                        if (RJW_Genes_Settings.rjw_genes_detailed_debug) ModLog.Message($"{pawn} born as a new queen with xenotype {queenDef.defName} ({QUEEN_CHANCE*100}% chance,rolled {roll})");
+                        if (RJW_Genes_Settings.rjw_genes_detailed_debug) ModLog.Message($"{pawn} born as a new queen with xenotype {queenDef.defName} ({hiveOffspringChanceDef.queenChance * 100}% chance,rolled {roll})");
                         // TODO: Make a letter ? 
                     }
                     // Case 2.b: New Drone born
-                    else if (roll < DRONE_CHANCE + QUEEN_CHANCE)
+                    else if (roll < hiveOffspringChanceDef.droneChance + hiveOffspringChanceDef.queenChance)
                     {
                         XenotypeDef droneDef = TryFindParentDroneXenotype(pawn);
                         pawn.genes.SetXenotype(droneDef);
-                        if (RJW_Genes_Settings.rjw_genes_detailed_debug) ModLog.Message($"{pawn} born as a new drone with xenotype {droneDef.defName} ({(DRONE_CHANCE + QUEEN_CHANCE) * 100}% chance,rolled {roll}))");
+                        if (RJW_Genes_Settings.rjw_genes_detailed_debug) ModLog.Message($"{pawn} born as a new drone with xenotype {droneDef.defName} ({(hiveOffspringChanceDef.droneChance + hiveOffspringChanceDef.queenChance) * 100}% chance,rolled {roll}))");
                     }
                     // Case 2.c: Worker
                     else {
-                        if (RJW_Genes_Settings.rjw_genes_detailed_debug) ModLog.Message($"{pawn} born as a worker ({(WORKER_CHANCE) * 100}% chance,rolled {roll}))");
+                        if (RJW_Genes_Settings.rjw_genes_detailed_debug) ModLog.Message($"{pawn} born as a worker ({(hiveOffspringChanceDef.workerChance) * 100}% chance,rolled {roll}))");
                         MakeWorker(pawn, queenDef);
                     }
                 }

Source/RJW_Genes.cs

@@ -1,4 +1,5 @@
-using System.Linq;
+using System.Collections.Generic;
+using System.Linq;
 using Verse;
 
 namespace RJW_Genes
@@ -14,6 +15,11 @@ namespace RJW_Genes
                 ModLog.Message($"{HiveUtility.getQueenXenotypes().EnumerableCount()} Queen-Xenotypes ({string.Join(",", HiveUtility.getQueenXenotypes().Select(t => t.defName))})");
                 ModLog.Message($"{HiveUtility.getDroneXenotypes().EnumerableCount()} Drone-Xenotypes ({string.Join(",", HiveUtility.getDroneXenotypes().Select(t => t.defName))})");
                 ModLog.Message($"Found {HiveUtility.GetQueenWorkerMappings().Count} Queen-Worker Mappings  ({string.Join(",", HiveUtility.GetQueenWorkerMappings().Keys.Select(t => t.defName))} + Default) ");
+
+
+                IEnumerable<HiveOffspringChanceDef> offspringChanceDefs = DefDatabase<HiveOffspringChanceDef>.AllDefs;
+                IEnumerable<HiveOffspringChanceDef> faultOffspringDefs = offspringChanceDefs.Where(t => t.queenChance + t.workerChance + t.workerChance > 1.02 || t.queenChance + t.workerChance + t.workerChance < 0.98 );
+                ModLog.Message($"Found {offspringChanceDefs.Count()} OffspringChanceDefs, of which {faultOffspringDefs.Count()} had faulty chances ({string.Join(",", faultOffspringDefs.Select(t => t.defName))})");
             }
         }
     }

Source/Rjw-Genes.csproj

@@ -43,6 +43,7 @@
     <Compile Include="GeneDefOf.cs" />
     <Compile Include="Genes\Breeding\Gene_MechBreeder.cs" />
     <Compile Include="Genes\Breeding\PatchMechBirth.cs" />
+    <Compile Include="Genes\Hive\Defs\HiveOffspringChanceDef.cs" />
     <Compile Include="Genes\Hive\Genes\Gene_InsectIncubator.cs" />
     <Compile Include="Genes\Hive\Patches\Patch_InsectBreeder_EggFertilization.cs" />
     <Compile Include="Genes\Hive\Patches\Patch_InsectIncubator_PregnancyHelper.cs" />