240 lines
10 KiB
C#
240 lines
10 KiB
C#
using HarmonyLib;
|
|
using RimWorld;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Reflection.Emit;
|
|
using Verse;
|
|
|
|
namespace RJW_Menstruation
|
|
{
|
|
[HarmonyPatch(typeof(Hediff_Pregnant), "Miscarry")]
|
|
public class Miscarry_Patch
|
|
{
|
|
public static void Postfix(Hediff_Pregnant __instance)
|
|
{
|
|
HediffComp_Menstruation comp = __instance.GetMenstruationCompFromPregnancy();
|
|
if (comp == null) return;
|
|
comp.Pregnancy = null;
|
|
}
|
|
}
|
|
|
|
[HarmonyPatch(typeof(Hediff_Pregnant), nameof(Hediff_Pregnant.StartLabor))]
|
|
public class StartLabor_Patch
|
|
{
|
|
public static void Postfix(Hediff_Pregnant __instance)
|
|
{
|
|
HediffComp_Menstruation comp = __instance.GetMenstruationCompFromPregnancy();
|
|
if (comp == null) return;
|
|
comp.Pregnancy = __instance.pawn.health.hediffSet.GetFirstHediffOfDef(HediffDefOf.PregnancyLabor);
|
|
}
|
|
}
|
|
|
|
[HarmonyPatch(typeof(Hediff_Labor), nameof(Hediff_Labor.PreRemoved))]
|
|
public class Labor_PreRemoved_Patch
|
|
{
|
|
public static void Postfix(Hediff_Labor __instance)
|
|
{
|
|
HediffComp_Menstruation comp = __instance.GetMenstruationCompFromPregnancy();
|
|
if (comp == null) return;
|
|
comp.Pregnancy = __instance.pawn.health.hediffSet.GetFirstHediffOfDef(HediffDefOf.PregnancyLaborPushing);
|
|
}
|
|
}
|
|
|
|
[HarmonyPatch(typeof(Hediff_LaborPushing), nameof(Hediff_LaborPushing.PreRemoved))]
|
|
public class LaborPushing_PreRemoved_Patch
|
|
{
|
|
public static void Postfix(Hediff_LaborPushing __instance)
|
|
{
|
|
HediffComp_Menstruation comp = __instance.GetMenstruationCompFromPregnancy();
|
|
if (comp == null) return;
|
|
comp.Pregnancy = null;
|
|
}
|
|
}
|
|
|
|
// Prevents a pregnancy from going into labor if another pregnancy already is
|
|
[HarmonyPatch(typeof(Hediff_Pregnant), nameof(Hediff_Pregnant.GestationProgress), MethodType.Getter)]
|
|
public class Hediff_Pregnant_GestationProgess_Patch
|
|
{
|
|
public static void Postfix(Hediff_Pregnant __instance, ref float __result)
|
|
{
|
|
if (__result < 1f) return;
|
|
Pawn pawn = __instance.pawn;
|
|
if (pawn.health.hediffSet.hediffs.Any(hediff => hediff.def == HediffDefOf.PregnancyLabor || hediff.def == HediffDefOf.PregnancyLaborPushing))
|
|
__result = 0.999f;
|
|
}
|
|
}
|
|
|
|
[HarmonyPatch(typeof(Recipe_ExtractOvum), nameof(Recipe_ExtractOvum.AvailableReport))]
|
|
public class ExtractOvum_AvailableReport_Patch
|
|
{
|
|
public static void Postfix(Thing thing, ref AcceptanceReport __result)
|
|
{
|
|
if (!__result.Accepted) return;
|
|
Pawn pawn = (Pawn)thing;
|
|
if (pawn.IsRJWPregnant())
|
|
{
|
|
__result = "CannotPregnant".Translate();
|
|
return;
|
|
}
|
|
List<HediffComp_Menstruation> comps = pawn.GetMenstruationComps().ToList();
|
|
if (!comps.Any()) return;
|
|
if (comps.All(comp => comp.ovarypower <= 0))
|
|
{
|
|
__result = Translations.CannotNoEggs;
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
[HarmonyPatch(typeof(Recipe_ExtractOvum), "OnSurgerySuccess")]
|
|
public class ExtractOvum_OnSurgerySuccess_Patch
|
|
{
|
|
public static void Postfix(Pawn pawn)
|
|
{
|
|
List<HediffComp_Menstruation> comps = pawn.GetMenstruationComps().ToList();
|
|
if (!comps.Any()) return;
|
|
HediffComp_Menstruation mostEggs = comps.MaxBy(comp => comp.ovarypower);
|
|
if (mostEggs.ovarypower <= 0) return; // Shouldn't happen
|
|
mostEggs.ovarypower--;
|
|
}
|
|
}
|
|
|
|
[HarmonyPatch(typeof(Recipe_ImplantEmbryo), nameof(Recipe_ImplantEmbryo.ApplyOnPawn))]
|
|
public class ImplantEmbryo_ApplyOnPawn_Patch
|
|
{
|
|
public static void Postfix(Pawn pawn)
|
|
{
|
|
foreach (HediffComp_Menstruation comp in pawn.GetMenstruationComps())
|
|
comp.TakeLoosePregnancy();
|
|
}
|
|
}
|
|
|
|
[HarmonyPatch(typeof(PregnancyUtility), nameof(PregnancyUtility.ApplyBirthOutcome))]
|
|
public class ApplyBirthOutcome_Breast_Patch
|
|
{
|
|
public static void Postfix(Thing birtherThing)
|
|
{
|
|
if (birtherThing is Pawn pawn && !pawn.Dead)
|
|
pawn.GetBreastComp()?.GaveBirth();
|
|
}
|
|
}
|
|
|
|
[HarmonyPatch]
|
|
public class TerminatePregnancy_Patch
|
|
{
|
|
public static IEnumerable<MethodBase> TargetMethods()
|
|
{
|
|
yield return AccessTools.Method(typeof(PregnancyUtility), nameof(PregnancyUtility.TryTerminatePregnancy));
|
|
yield return AccessTools.Method(typeof(Recipe_TerminatePregnancy), nameof(Recipe_TerminatePregnancy.ApplyOnPawn));
|
|
}
|
|
|
|
private static PregnancyAttitude? GetAttitude(Hediff pregnancy)
|
|
{
|
|
if (pregnancy is Hediff_Pregnant preg) return preg.Attitude;
|
|
else return null;
|
|
}
|
|
|
|
private static Hediff GetEarliestPregnancy(Pawn pawn)
|
|
{
|
|
Hediff Earliest_Pregnancy = PregnancyUtility.GetPregnancyHediff(pawn);
|
|
foreach (HediffComp_Menstruation comp in pawn.GetMenstruationComps())
|
|
{
|
|
Hediff pregnancy = comp.Pregnancy;
|
|
if (pregnancy == null) continue;
|
|
if (Earliest_Pregnancy == null || Earliest_Pregnancy.Severity > pregnancy.Severity) Earliest_Pregnancy = pregnancy;
|
|
}
|
|
|
|
return Earliest_Pregnancy;
|
|
}
|
|
|
|
private static readonly MethodInfo GetPregnancyHediff = AccessTools.Method(typeof(PregnancyUtility), nameof(PregnancyUtility.GetPregnancyHediff), new Type[] { typeof(Pawn) });
|
|
private static readonly MethodInfo Get_Attitude = AccessTools.DeclaredPropertyGetter(typeof(Hediff_Pregnant), nameof(Hediff_Pregnant.Attitude));
|
|
|
|
public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
|
|
{
|
|
if (GetPregnancyHediff?.ReturnType != typeof(Hediff)) throw new InvalidOperationException("GetPregnancyHediff not found");
|
|
if (Get_Attitude == null || Nullable.GetUnderlyingType(Get_Attitude.ReturnType) != typeof(PregnancyAttitude)) throw new InvalidOperationException("get_Attitude not found");
|
|
foreach (CodeInstruction instruction in instructions)
|
|
{
|
|
if (instruction.Calls(GetPregnancyHediff))
|
|
yield return CodeInstruction.Call(typeof(TerminatePregnancy_Patch), nameof(TerminatePregnancy_Patch.GetEarliestPregnancy));
|
|
// Menstruation pregnancies don't have an attitude, so skip the cast to Hediff_Pregnant and call a version that handles it
|
|
else if (instruction.opcode == OpCodes.Castclass && (Type)instruction.operand == typeof(Hediff_Pregnant))
|
|
yield return new CodeInstruction(OpCodes.Nop);
|
|
else if (instruction.Calls(Get_Attitude))
|
|
yield return CodeInstruction.Call(typeof(TerminatePregnancy_Patch), nameof(TerminatePregnancy_Patch.GetAttitude));
|
|
else yield return instruction;
|
|
}
|
|
}
|
|
}
|
|
|
|
[HarmonyPatch(typeof(PregnancyUtility), nameof(PregnancyUtility.TryTerminatePregnancy))]
|
|
public class PregnancyUtility_TryTerminatePregnancy_Patch
|
|
{
|
|
public static void Postfix(bool __result, Pawn pawn)
|
|
{
|
|
if (__result)
|
|
foreach (HediffComp_Menstruation comp in pawn.GetMenstruationComps())
|
|
_ = comp.Pregnancy; // get_Pregnancy will remove the hediff attached to the comp that doesn't have it anymore
|
|
}
|
|
}
|
|
|
|
[HarmonyPatch(typeof(Recipe_TerminatePregnancy), nameof(Recipe_TerminatePregnancy.AvailableOnNow))]
|
|
public class TerminatePregnancy_AvailableOnNow_Patch
|
|
{
|
|
public static void Postfix(ref bool __result, Thing thing)
|
|
{
|
|
if (!ModsConfig.BiotechActive || !(thing is Pawn pawn)) return;
|
|
__result |= pawn.GetMenstruationComps().Any(comp => comp.Pregnancy != null);
|
|
}
|
|
}
|
|
|
|
[HarmonyPatch(typeof(Pawn_GeneTracker), "Notify_GenesChanged")]
|
|
public class Notify_GenesChanged_Patch
|
|
{
|
|
public static void Postfix(Pawn_GeneTracker __instance, GeneDef addedOrRemovedGene)
|
|
{
|
|
if (!addedOrRemovedGene.HasModExtension<MenstruationModExtension>()) return;
|
|
foreach (HediffComp_Menstruation comp in __instance.pawn.GetMenstruationComps())
|
|
comp.Notify_UpdatedGenes();
|
|
}
|
|
}
|
|
|
|
[HarmonyPatch(typeof(StatPart_FertilityByGenderAge), "AgeFactor")]
|
|
public class AgeFactor_Patch
|
|
{
|
|
public static void Postfix(ref float __result, Pawn pawn)
|
|
{
|
|
if (__result <= 0.0f) return;
|
|
if (pawn.GetMenstruationComps().Any(comp => comp.CalculatingOvulationChance))
|
|
__result = 1.0f;
|
|
}
|
|
}
|
|
|
|
//[HarmonyPatch(typeof(ChildcareUtility), nameof(ChildcareUtility.SuckleFromLactatingPawn))]
|
|
//public class GreedyConsume_Patch
|
|
//{
|
|
// private static float ConsumeAndAdjustNipples(HediffComp_Chargeable instance, float desiredCharge)
|
|
// {
|
|
// // Pulling breast comp every tick might be too much for performance.
|
|
// const float averageNippleChangePerTick = 0.0025f / 50000f;
|
|
// instance.Pawn.GetBreastComp()?.AdjustNippleProgress(Rand.Range(0.0f, averageNippleChangePerTick * 2) * Configurations.MaxBreastIncrementFactor);
|
|
// return instance.GreedyConsume(desiredCharge);
|
|
// }
|
|
|
|
// private static readonly MethodInfo GreedyConsume = AccessTools.Method(typeof(HediffComp_Chargeable), nameof(HediffComp_Chargeable.GreedyConsume), new Type[] { typeof(HediffComp_Chargeable), typeof(float) });
|
|
// public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
|
|
// {
|
|
// if(GreedyConsume == null) throw new InvalidOperationException("GreedyConsume not found");
|
|
// foreach (var instruction in instructions)
|
|
// {
|
|
// if (instruction.Calls(GreedyConsume))
|
|
// yield return CodeInstruction.Call(typeof(GreedyConsume_Patch), nameof(GreedyConsume_Patch.ConsumeAndAdjustNipples));
|
|
// yield return instruction;
|
|
// }
|
|
// }
|
|
//}
|
|
} |