public static void CheckPlantHarvested(Plant __instance)
{
if (__instance is Plant plant && Current.ProgramState == ProgramState.Playing)
{
foreach (var card in AchievementPointManager.GetCards <PlantTracker>())
{
if ((card.tracker as PlantTracker).Trigger(plant))
{
card.UnlockCard();
}
}
}
}
/// <summary>
/// Pawn PopulationAdaptation event
/// </summary>
/// <param name="p"></param>
/// <param name="ev"></param>
public static void PawnJoinedFaction(Pawn p, PopAdaptationEvent ev)
{
foreach (var card in AchievementPointManager.GetCards <PawnJoinedTracker>())
{
try
{
if (ev == PopAdaptationEvent.GainedColonist && (card.tracker as PawnJoinedTracker).Trigger(p))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
/// <summary>
/// Helper Method for UnfinishedThing crafted Transpiler
/// </summary>
/// <param name="thing"></param>
public static void ItemCraftedTrigger(Thing thing)
{
foreach (var card in AchievementPointManager.GetCards <ItemCraftTracker>())
{
try
{
if ((card.tracker as ItemCraftTracker).Trigger(thing))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
/// <summary>
/// Helper Method for MentalBreak Transpiler (Check if MentalBreak Initiated -> Trigger on Trackers)
/// </summary>
public static void MentalBreakTrigger(bool started, MentalBreakDef def)
{
foreach (var card in AchievementPointManager.GetCards <MentalBreakTracker>())
{
try
{
if (started && (card.tracker as MentalBreakTracker).Trigger(def))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
/// <summary>
/// Any incident being triggered event
/// </summary>
/// <param name="parms"></param>
/// <param name="__instance"></param>
/// <param name="__result"></param>
public static void IncidentTriggered(IncidentParms parms, IncidentWorker __instance, ref bool __result)
{
foreach (var card in AchievementPointManager.GetCards <IncidentTracker>())
{
try
{
if (__result && (card.tracker as IncidentTracker).Trigger(__instance.def, parms.target as Map))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
/// <summary>
/// ResearchProject event when project is finished
/// </summary>
/// <param name="proj"></param>
/// <param name="doCompletionDialog"></param>
/// <param name="researcher"></param>
public static void ResearchProjectFinished(ResearchProjectDef proj, bool doCompletionDialog, Pawn researcher)
{
foreach (var card in AchievementPointManager.GetCards <ResearchTracker>())
{
try
{
if ((card.tracker as ResearchTracker).Trigger(proj))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
/// <summary>
/// HelperMethod for LevelUp Mote Transpiler
/// </summary>
/// <param name="skill"></param>
public static void LevelUpTrigger(SkillDef skill, int level)
{
foreach (var card in AchievementPointManager.GetCards <SkillTracker>())
{
try
{
if ((card.tracker as SkillTracker).Trigger(skill, level))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
/// <summary>
/// Event on immunity ticker
/// </summary>
/// <param name="pawn"></param>
/// <param name="sick"></param>
/// <param name="diseaseInstance"></param>
public static void ImmunityTicking(Pawn pawn, bool sick, Hediff diseaseInstance, ImmunityRecord __instance)
{
foreach (var card in AchievementPointManager.GetCards <ImmunityHediffTracker>())
{
try
{
if ((card.tracker as ImmunityHediffTracker).Trigger(diseaseInstance, __instance.immunity))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
/// <summary>
/// Increment Event where Records are incremented by 1
/// </summary>
/// <param name="def"></param>
/// <param name="__instance"></param>
public static void RecordEvent(RecordDef def, Pawn_RecordsTracker __instance)
{
foreach (var card in AchievementPointManager.GetCards <RecordEventTracker>())
{
try
{
if ((card.tracker as RecordEventTracker).Trigger(def, __instance.pawn))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
/// <summary>
/// Grab average mood of colony from History event which triggers every 60000 ticks
/// </summary>
/// <param name="__result"></param>
public static void AverageMoodColony(float __result)
{
foreach (var card in AchievementPointManager.GetCards <MoodTracker>())
{
try
{
if ((card.tracker as MoodTracker).Trigger(__result))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
/// <summary>
/// Event whenever a Hediff gets added to a pawn
/// </summary>
/// <param name="dinfo"></param>
public static void HediffAdded(Hediff hediff, BodyPartRecord part = null, DamageInfo?dinfo = null, DamageWorker.DamageResult result = null)
{
foreach (var card in AchievementPointManager.GetCards <HediffTracker>())
{
try
{
if ((card.tracker as HediffTracker).Trigger(hediff))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
/// <summary>
/// Attaches to Quest End method to capture both quest and outcome
/// </summary>
/// <param name="outcome"></param>
/// <param name="__instance"></param>
/// <param name="sendLetter"></param>
public static void QuestEnded(QuestEndOutcome outcome, Quest __instance, bool sendLetter = true)
{
foreach (var card in AchievementPointManager.GetCards <QuestTracker>())
{
try
{
if ((card.tracker as QuestTracker).Trigger(__instance, outcome))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
/// <summary>
/// Pawn Kill event triggered whenever a pawn is killed
/// </summary>
/// <param name="dinfo"></param>
/// <param name="__instance"></param>
/// <param name="exactCulprit"></param>
public static void KillPawn(DamageInfo?dinfo, Pawn __instance, Hediff exactCulprit = null)
{
foreach (var card in AchievementPointManager.GetCards <KillTracker>())
{
try
{
if ((card.tracker as KillTracker).Trigger(__instance, dinfo))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
/// <summary>
/// DevMode event (when devMode is toggled)
/// </summary>
/// <param name="value"></param>
public static void DevModeToggled(bool value)
{
foreach (var card in AchievementPointManager.GetCards <DevModeTracker>())
{
try
{
if ((card.tracker as DevModeTracker).Trigger(value))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
public static void CheckItemCraftedMultiple(Pawn worker, List <Thing> things)
{
if (things != null && worker != null)
{
foreach (var card in AchievementPointManager.GetCards <ItemCraftTrackerMultipleSpartanFoundry>())
{
foreach (Thing thing in things)
{
if (thing != null && card != null)
{
if ((card.tracker as ItemCraftTrackerMultipleSpartanFoundry).Trigger(thing))
{
card.UnlockCard();
}
}
}
}
}
}
public static void CheckItemCraftedIngredients(Pawn worker, List <Thing> things)
{
if (things != null && worker != null)
{
foreach (var card in AchievementPointManager.GetCards <ItemCraftTrackerWithIngredientsAlpha>())
{
foreach (Thing thing in things)
{
if (thing != null && card != null)
{
if ((card.tracker as ItemCraftTrackerWithIngredientsAlpha).Trigger(thing))
{
card.UnlockCard();
}
}
}
}
}
}
/// <summary>
/// HelperMethod for Time based record event
/// </summary>
/// <param name="def"></param>
/// <param name="pawn"></param>
/// <param name="interval"></param>
public static void RecordTimeEvent(RecordDef def, Pawn pawn, int interval)
{
foreach (var card in AchievementPointManager.GetCards <RecordTimeTracker>())
{
try
{
var tracker = card.tracker as RecordTimeTracker;
if (tracker.def == def && tracker.Trigger(def, pawn, (float)interval))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
/// <summary>
/// SettlementDefeated Event
/// </summary>
/// <param name="map"></param>
/// <param name="faction"></param>
/// <param name="__result"></param>
/// <remarks>Only trigger on success</remarks>
public static void SettlementDefeatedEvent(Map map, Faction faction, ref bool __result)
{
if (__result)
{
foreach (var card in AchievementPointManager.GetCards <SettlementDefeatTracker>())
{
try
{
if ((card.tracker as SettlementDefeatTracker).Trigger(Find.World.worldObjects.SettlementAt(map.Tile)))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
}
/// <summary>
/// Hediff PawnDeath Event
/// </summary>
/// <param name="p"></param>
/// <param name="ev"></param>
/// <param name="dinfo"></param>
public static void HediffDeathEvent(Hediff __instance, ref bool __result)
{
if (__result)
{
foreach (var card in AchievementPointManager.GetCards <HediffDeathTracker>())
{
try
{
if ((card.tracker as HediffDeathTracker).Trigger(__instance))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
}
/// <summary>
/// TradeDeal event to retrieve what was exchanged
/// </summary>
/// <param name="actuallyTraded"></param>
/// <param name="__result"></param>
/// <param name="___tradeables"></param>
public static void TradeDealComplete(bool __result, List <Tradeable> ___tradeables)
{
if (__result)
{
foreach (var card in AchievementPointManager.GetCards <TraderTracker>())
{
try
{
if ((card.tracker as TraderTracker).Trigger(___tradeables))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
}
/// <summary>
/// Spawn event for Buildings
/// </summary>
/// <param name="newThing"></param>
/// <param name="loc"></param>
/// <param name="map"></param>
/// <param name="rot"></param>
/// <param name="wipeMode"></param>
/// <param name="respawningAfterLoad"></param>
public static void ThingBuildingSpawned(Thing newThing, IntVec3 loc, Map map, Rot4 rot, WipeMode wipeMode = WipeMode.Vanish, bool respawningAfterLoad = false)
{
if (newThing is Building building && building.Faction == Faction.OfPlayer && Current.ProgramState == ProgramState.Playing)
{
foreach (var card in AchievementPointManager.GetCards <BuildingTracker>())
{
try
{
if ((card.tracker as BuildingTracker).Trigger(building))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
}
/// <summary>
/// Animal being set to Bonded event
/// </summary>
/// <param name="humanlike"></param>
/// <param name="animal"></param>
/// <param name="baseChance"></param>
/// <param name="__result"></param>
public static void AnimalBondedEvent(Pawn humanlike, Pawn animal, float baseChance, ref bool __result)
{
if (__result)
{
foreach (var card in AchievementPointManager.GetCards <AnimalBondedTracker>())
{
try
{
if ((card.tracker as AnimalBondedTracker).Trigger(animal.kindDef))
{
card.UnlockCard();
}
}
catch (Exception ex)
{
Log.Error($"Unable to trigger event for card validation. To avoid further errors {card.def.LabelCap} has been automatically unlocked.\n\nException={ex.Message}");
card.UnlockCard();
}
}
}
}
