protected override void RunInt()
{
Slate slate = QuestGen.slate;
int value = duration.GetValue(slate);
_ = QuestGen.quest;
int value2 = startOffsetTicks.GetValue(slate);
IncidentDef value3 = incidentDef.GetValue(slate);
Map map = slate.Get <Map>("map");
float value4 = points.GetValue(slate);
Faction value5 = faction.GetValue(slate);
string delayInSignal = slate.Get <string>("inSignal");
string disableSignal = QuestGenUtility.HardcodedSignalWithQuestID(inSignalDisable.GetValue(slate));
int? value6 = randomIncidents.GetValue(slate);
if (value6.HasValue)
{
for (int i = 0; i < value6; i++)
{
CreateDelayedIncident(Rand.Range(value2, value), delayInSignal, disableSignal, value3, map, value4, value5);
}
}
int?value7 = intervalTicks.GetValue(slate);
if (value7.HasValue)
{
int num = Mathf.FloorToInt((float)value / (float)value7.Value);
for (int j = 0; j < num; j++)
{
int delayTicks = Mathf.Max(j * value7.Value, value2);
CreateDelayedIncident(delayTicks, delayInSignal, disableSignal, value3, map, value4, value5);
}
}
}
protected override void RunInt()
{
Quest quest = QuestGen.quest;
Slate slate = QuestGen.slate;
Map map = QuestGen_Get.GetMap();
Faction faction = slate.Get <Faction>("faction");
FloatRange marketValueRange = slate.Get <FloatRange>("marketValueRange");
Pawn val = slate.Get <Pawn>("rewardGiver");
quest.ReservePawns(Gen.YieldSingle(val));
quest.ReserveFaction(faction);
int num = Rand.Range(5, 20) * 60000;
slate.Set("rewardDelayTicks", num);
quest.Delay(num, delegate
{
ThingSetMakerParams parms = default(ThingSetMakerParams);
parms.totalMarketValueRange = marketValueRange;
parms.qualityGenerator = QualityGenerator.Reward;
parms.makingFaction = faction;
List <Thing> list = ThingSetMakerDefOf.Reward_ItemsStandard.root.Generate(parms);
slate.Set("listOfRewards", GenLabel.ThingsLabel(list));
quest.DropPods(map.Parent, list, null, null, "[rewardLetterText]", null, true);
QuestGen_End.End(quest, QuestEndOutcome.Unknown);
}, null, null, null, reactivatable: false, null, null, isQuestTimeout: false, null, null, "RewardDelay");
}
private bool DoWork(Slate slate)
{
Map map = slate.Get <Map>("map");
if (map == null)
{
return(false);
}
float x2 = slate.Get("points", 0f);
float animalDifficultyFromPoints = pointsToAnimalDifficultyCurve.GetValue(slate).Evaluate(x2);
if (!map.Biome.AllWildAnimals.Where((PawnKindDef x) => map.mapTemperature.SeasonAndOutdoorTemperatureAcceptableFor(x.race) && map.listerThings.ThingsOfDef(x.race).Any((Thing p) => p.Faction == null)).TryRandomElementByWeight((PawnKindDef x) => AnimalCommonalityByDifficulty(x, animalDifficultyFromPoints), out PawnKindDef result))
{
return(false);
}
int num = 0;
for (int i = 0; i < map.mapPawns.AllPawnsSpawned.Count; i++)
{
Pawn pawn = map.mapPawns.AllPawnsSpawned[i];
if (pawn.def == result.race && !pawn.IsQuestLodger() && pawn.Faction == null)
{
num++;
}
}
SimpleCurve value = pointsToAnimalsToHuntCountCurve.GetValue(slate);
float randomInRange = (animalsToHuntCountRandomFactorRange.GetValue(slate) ?? FloatRange.One).RandomInRange;
int a = Mathf.RoundToInt(value.Evaluate(x2) * randomInRange);
a = Mathf.Min(a, num);
a = Mathf.Max(a, 1);
slate.Set(storeAnimalToHuntAs.GetValue(slate), result.race);
slate.Set(storeCountToHuntAs.GetValue(slate), a);
return(true);
}
protected override bool TestRunInt(Slate slate)
{
if (slate.Get <Pawn>("rewardGiver") != null && slate.TryGet <FloatRange>("marketValueRange", out var _))
{
return(slate.Get <Faction>("faction") != null);
}
return(false);
}
private void SetVars(Slate slate)
{
SiteMakerHelper.GenerateDefaultParams(slate.Get("points", 0f), tile.GetValue(slate), faction.GetValue(slate), sitePartDefs.GetValue(slate), out List <SitePartDefWithParams> sitePartDefsWithParams);
for (int i = 0; i < sitePartDefsWithParams.Count; i++)
{
if (sitePartDefsWithParams[i].def == SitePartDefOf.PreciousLump)
{
sitePartDefsWithParams[i].parms.preciousLumpResources = slate.Get <ThingDef>("targetMineable");
}
}
slate.Set(storeSitePartsParamsAs.GetValue(slate), sitePartDefsWithParams);
}
private bool TrySetVars(Slate slate)
{
float points = slate.Get("points", 0f);
Faction factionToUse = slate.Get <Faction>("enemyFaction");
Pawn asker = slate.Get <Pawn>("asker");
Thing mustBeHostileToFactionOfResolved = mustBeHostileToFactionOf.GetValue(slate);
for (int i = 0; i < 2; i++)
{
tmpTags.Clear();
foreach (SitePartOption item in sitePartsTags.GetValue(slate))
{
if (Rand.Chance(item.chance) && (i != 1 || !(item.chance < 1f)))
{
tmpTags.Add(item.tag);
}
}
if (!SiteMakerHelper.TryFindSiteParams_MultipleSiteParts(tmpTags.Where((string x) => x != null).Select(delegate(string x)
{
IEnumerable <SitePartDef> enumerable = SiteMakerHelper.SitePartDefsWithTag(x);
IEnumerable <SitePartDef> enumerable2 = enumerable.Where((SitePartDef y) => points >= y.minThreatPoints);
return((!enumerable2.Any()) ? enumerable : enumerable2);
}), out List <SitePartDef> siteParts, out Faction faction, factionToUse, disallowNonHostileFactions: true, delegate(Faction x)
{
if (asker != null && asker.Faction != null && asker.Faction == x)
{
return(false);
}
return((mustBeHostileToFactionOfResolved == null || mustBeHostileToFactionOfResolved.Faction == null || (x != mustBeHostileToFactionOfResolved.Faction && x.HostileTo(mustBeHostileToFactionOfResolved.Faction))) ? true : false);
}))
{
continue;
}
slate.Set(storeAs.GetValue(slate), siteParts);
slate.Set("sitePartCount", siteParts.Count);
if (QuestGen.Working)
{
Dictionary <string, string> dictionary = new Dictionary <string, string>();
for (int j = 0; j < siteParts.Count; j++)
{
dictionary[siteParts[j].defName + "_exists"] = "True";
}
QuestGen.AddQuestDescriptionConstants(dictionary);
}
if (!storeFactionAs.GetValue(slate).NullOrEmpty())
{
slate.Set(storeFactionAs.GetValue(slate), faction);
}
return(true);
}
return(false);
}
private bool TrySetVars(Slate slate, bool test)
{
Pawn asker = slate.Get <Pawn>("asker");
Thing mustBeHostileToFactionOfResolved = mustBeHostileToFactionOf.GetValue(slate);
if (!SiteMakerHelper.TryFindRandomFactionFor(sitePartDefs.GetValue(slate), out Faction faction, disallowNonHostileFactions : true, delegate(Faction x)
{
if (asker != null && asker.Faction == x)
{
return(false);
}
return((mustBeHostileToFactionOfResolved == null || mustBeHostileToFactionOfResolved.Faction == null || (x != mustBeHostileToFactionOfResolved.Faction && x.HostileTo(mustBeHostileToFactionOfResolved.Faction))) ? true : false);
}))
{
return(false);
}
if (!Find.Storyteller.difficulty.allowViolentQuests && faction.HostileTo(Faction.OfPlayer))
{
return(false);
}
slate.Set(storeAs.GetValue(slate), faction);
if (!test && faction != null && !faction.def.hidden)
{
QuestPart_InvolvedFactions questPart_InvolvedFactions = new QuestPart_InvolvedFactions();
questPart_InvolvedFactions.factions.Add(faction);
QuestGen.quest.AddPart(questPart_InvolvedFactions);
}
return(true);
}
protected override void RunInt()
{
Slate slate = QuestGen.slate;
Map map = slate.Get <Map>("map");
QuestPart_ThreatsGenerator questPart_ThreatsGenerator = new QuestPart_ThreatsGenerator();
questPart_ThreatsGenerator.threatStartTicks = threatStartTicks.GetValue(slate);
questPart_ThreatsGenerator.inSignalEnable = (QuestGenUtility.HardcodedSignalWithQuestID(inSignalEnable.GetValue(slate)) ?? slate.Get <string>("inSignal"));
questPart_ThreatsGenerator.inSignalDisable = QuestGenUtility.HardcodedSignalWithQuestID(inSignalDisable.GetValue(slate));
ThreatsGeneratorParams value = parms.GetValue(slate);
value.faction = (faction.GetValue(slate) ?? value.faction);
questPart_ThreatsGenerator.parms = value;
questPart_ThreatsGenerator.mapParent = map.Parent;
QuestGen.quest.AddPart(questPart_ThreatsGenerator);
if (!storeThreatExampleAs.GetValue(slate).NullOrEmpty())
{
PawnGroupMakerParms pawnGroupMakerParms = new PawnGroupMakerParms();
pawnGroupMakerParms.groupKind = PawnGroupKindDefOf.Combat;
pawnGroupMakerParms.raidStrategy = RaidStrategyDefOf.ImmediateAttack;
pawnGroupMakerParms.faction = (value.faction ?? (from x in Find.FactionManager.GetFactions(allowHidden: false, allowDefeated: false, allowNonHumanlike: true, TechLevel.Industrial)
where x.HostileTo(Faction.OfPlayer)
select x).RandomElement());
float num = value.threatPoints ?? (StorytellerUtility.DefaultThreatPointsNow(map) * value.currentThreatPointsFactor);
if (value.minThreatPoints.HasValue)
{
num = Mathf.Max(num, value.minThreatPoints.Value);
}
pawnGroupMakerParms.points = IncidentWorker_Raid.AdjustedRaidPoints(num, PawnsArrivalModeDefOf.EdgeWalkIn, RaidStrategyDefOf.ImmediateAttack, pawnGroupMakerParms.faction, PawnGroupKindDefOf.Combat);
IEnumerable <PawnKindDef> pawnKinds = PawnGroupMakerUtility.GeneratePawnKindsExample(pawnGroupMakerParms);
slate.Set(storeThreatExampleAs.GetValue(slate), PawnUtility.PawnKindsToLineList(pawnKinds, " - "));
}
}
protected override void RunInt()
{
Slate slate = QuestGen.slate;
MapParent parent = slate.Get <Map>("map").Parent;
string text = QuestGen.GenerateNewSignal("PawnOfRaceKilled");
QuestPart_PawnsKilled questPart_PawnsKilled = new QuestPart_PawnsKilled();
questPart_PawnsKilled.inSignalEnable = (QuestGenUtility.HardcodedSignalWithQuestID(inSignalEnable.GetValue(slate)) ?? QuestGen.slate.Get <string>("inSignal"));
questPart_PawnsKilled.race = race.GetValue(slate);
questPart_PawnsKilled.requiredInstigatorFaction = Faction.OfPlayer;
questPart_PawnsKilled.count = count.GetValue(slate);
questPart_PawnsKilled.mapParent = parent;
questPart_PawnsKilled.outSignalPawnKilled = text;
if (node != null)
{
QuestGenUtility.RunInnerNode(node, questPart_PawnsKilled);
}
if (!outSignalComplete.GetValue(slate).NullOrEmpty())
{
questPart_PawnsKilled.outSignalsCompleted.Add(QuestGenUtility.HardcodedSignalWithQuestID(outSignalComplete.GetValue(slate)));
}
QuestGen.quest.AddPart(questPart_PawnsKilled);
QuestPart_PawnsAvailable questPart_PawnsAvailable = new QuestPart_PawnsAvailable();
questPart_PawnsAvailable.inSignalEnable = (QuestGenUtility.HardcodedSignalWithQuestID(inSignalEnable.GetValue(slate)) ?? QuestGen.slate.Get <string>("inSignal"));
if (!outSignalPawnsNotAvailable.GetValue(slate).NullOrEmpty())
{
questPart_PawnsAvailable.outSignalPawnsNotAvailable = QuestGenUtility.HardcodedSignalWithQuestID(outSignalPawnsNotAvailable.GetValue(slate));
}
questPart_PawnsAvailable.race = race.GetValue(slate);
questPart_PawnsAvailable.requiredCount = count.GetValue(slate);
questPart_PawnsAvailable.mapParent = parent;
questPart_PawnsAvailable.inSignalDecrement = text;
QuestGen.quest.AddPart(questPart_PawnsAvailable);
}
private bool TryFindTile(Slate slate, out int tile)
{
int nearThisTile = (slate.Get <Map>("map") ?? Find.RandomPlayerHomeMap)?.Tile ?? (-1);
int num = int.MaxValue;
bool?value = clampRangeBySiteParts.GetValue(slate);
if (value.HasValue && value.Value)
{
foreach (SitePartDef item in sitePartDefs.GetValue(slate))
{
if (item.conditionCauserDef != null)
{
num = Mathf.Min(num, item.conditionCauserDef.GetCompProperties <CompProperties_CausesGameCondition>().worldRange);
}
}
}
if (!slate.TryGet <IntRange>("siteDistRange", out var var))
{
var = new IntRange(7, Mathf.Min(27, num));
}
else if (num != int.MaxValue)
{
var = new IntRange(Mathf.Min(var.min, num), Mathf.Min(var.max, num));
}
return(TileFinder.TryFindNewSiteTile(out tile, var.min, var.max, allowCaravans.GetValue(slate), preferCloserTiles.GetValue(slate), nearThisTile));
}
protected override bool TestRunInt(Slate slate)
{
if (!Find.Storyteller.difficulty.allowViolentQuests)
{
return(false);
}
return(slate.Get <Map>("map") != null);
}
protected override bool TestRunInt(Slate slate)
{
if (slate.Get <Map>("map") == null)
{
return(false);
}
return(DoWork(slate));
}
protected override bool TestRunInt(Slate slate)
{
Map map = slate.Get <Map>("map");
slate.Set(storeAs.GetValue(slate), RandomOfferDurationTicks(map.Tile, settlement.GetValue(slate).Tile, out int travelTicks));
slate.Set(storeEstimatedTravelTimeAs.GetValue(slate), travelTicks);
return(true);
}
protected override void RunInt()
{
Slate slate = QuestGen.slate;
Map map = slate.Get <Map>("map");
slate.Set(storeAs.GetValue(slate), RandomOfferDurationTicks(map.Tile, settlement.GetValue(slate).Tile, out int travelTicks));
slate.Set(storeEstimatedTravelTimeAs.GetValue(slate), travelTicks);
}
private bool DoWork(Slate slate)
{
float num = slate.Get("points", 0f);
float value = pointsPerArea.GetValue(slate);
float num2 = Mathf.Min(num / value, 2500f);
float randomInRange = RandomAspectRatioRange.RandomInRange;
float f = Mathf.Sqrt(randomInRange * num2);
float f2 = Mathf.Sqrt(num2 / randomInRange);
int num3 = GenMath.RoundRandom(f);
int num4 = GenMath.RoundRandom(f2);
if (Rand.Bool)
{
int num5 = num3;
num3 = num4;
num4 = num5;
}
int?value2 = maxSize.GetValue(slate);
if (value2.HasValue)
{
num3 = Mathf.Min(num3, value2.Value);
num4 = Mathf.Min(num4, value2.Value);
}
num3 = Mathf.Max(num3, 3);
num4 = Mathf.Max(num4, 3);
IntVec2 value3 = new IntVec2(num3, num4);
ResolveParams parms = default(ResolveParams);
parms.sketch = new Sketch();
parms.monumentSize = value3;
parms.useOnlyStonesAvailableOnMap = useOnlyResourcesAvailableOnMap.GetValue(slate);
parms.onlyBuildableByPlayer = true;
if (useOnlyResourcesAvailableOnMap.GetValue(slate) != null)
{
parms.allowWood = (useOnlyResourcesAvailableOnMap.GetValue(slate).Biome.TreeDensity >= BiomeDefOf.BorealForest.TreeDensity);
}
parms.allowedMonumentThings = new ThingFilter();
parms.allowedMonumentThings.SetAllowAll(null, includeNonStorable: true);
parms.allowedMonumentThings.SetAllow(ThingDefOf.Urn, allow: false);
Sketch sketch = RimWorld.SketchGen.SketchGen.Generate(SketchResolverDefOf.Monument, parms);
if (clearStuff.GetValue(slate) ?? true)
{
List <SketchThing> things = sketch.Things;
for (int i = 0; i < things.Count; i++)
{
things[i].stuff = null;
}
List <SketchTerrain> terrain = sketch.Terrain;
for (int j = 0; j < terrain.Count; j++)
{
terrain[j].treatSimilarAsSame = true;
}
}
slate.Set(storeAs.GetValue(slate), sketch);
return(true);
}
private bool TryFindTile(Slate slate, out int tile)
{
int nearThisTile = (slate.Get <Map>("map") ?? Find.RandomPlayerHomeMap)?.Tile ?? (-1);
if (!slate.TryGet("siteDistRange", out IntRange var))
{
return(TileFinder.TryFindNewSiteTile(out tile, 7, 27, preferCloserTiles: preferCloserTiles.GetValue(slate), allowCaravans: allowCaravans.GetValue(slate), nearThisTile: nearThisTile));
}
return(TileFinder.TryFindNewSiteTile(out tile, var.min, var.max, allowCaravans.GetValue(slate), preferCloserTiles.GetValue(slate), nearThisTile));
}
protected override void RunInt()
{
Slate slate = QuestGen.slate;
QuestPart_DropMonumentMarkerCopy questPart_DropMonumentMarkerCopy = new QuestPart_DropMonumentMarkerCopy();
questPart_DropMonumentMarkerCopy.mapParent = slate.Get <Map>("map").Parent;
questPart_DropMonumentMarkerCopy.inSignal = (QuestGenUtility.HardcodedSignalWithQuestID(inSignal.GetValue(slate)) ?? slate.Get <string>("inSignal"));
questPart_DropMonumentMarkerCopy.outSignalResult = QuestGenUtility.HardcodedSignalWithQuestID(outSignalResult.GetValue(slate));
QuestGen.quest.AddPart(questPart_DropMonumentMarkerCopy);
}
private void SetVars(Slate slate)
{
int num = Mathf.RoundToInt(slate.Get("points", 0f) / 220f);
if (num < 1)
{
num = 1;
}
slate.Set(storeAs.GetValue(slate), num);
}
protected override bool TestRunInt(Slate slate)
{
if (TryFindRandomRequestedThingDef(slate.Get <Map>("map"), out ThingDef thingDef, out int count))
{
slate.Set(storeThingAs.GetValue(slate), thingDef);
slate.Set(storeThingCountAs.GetValue(slate), count);
slate.Set(storeMarketValueAs.GetValue(slate), thingDef.GetStatValueAbstract(StatDefOf.MarketValue) * (float)count);
return(true);
}
return(false);
}
private bool SetVars(Slate slate)
{
float points = slate.Get("points", 0f);
if (DefDatabase <PawnKindDef> .AllDefs.Where((PawnKindDef x) => x.RaceProps.Animal && x.combatPower < points).TryRandomElement(out var result))
{
slate.Set("animalKindDef", result);
return(true);
}
return(false);
}
private void ResolveParameters(Slate slate, out int requiredPawnCount, out int population, out Map colonyMap)
{
try
{
foreach (Map map in Find.Maps)
{
if (map.IsPlayerHome)
{
tmpMaps.Add(map);
}
}
colonyMap = tmpMaps.RandomElementWithFallback();
population = (slate.Exists("population") ? slate.Get("population", 0) : colonyMap.mapPawns.FreeColonists.Where((Pawn c) => DoesPawnCountAsAvailableForFight(c)).Count());
requiredPawnCount = GetRequiredPawnCount(population, slate.Get("points", 0));
}
finally
{
tmpMaps.Clear();
}
}
protected override void RunInt()
{
Slate slate = QuestGen.slate;
if (TryFindRandomRequestedThingDef(slate.Get <Map>("map"), out ThingDef thingDef, out int count))
{
slate.Set(storeThingAs.GetValue(slate), thingDef);
slate.Set(storeThingCountAs.GetValue(slate), count);
slate.Set(storeMarketValueAs.GetValue(slate), thingDef.GetStatValueAbstract(StatDefOf.MarketValue) * (float)count);
slate.Set(storeHasQualityAs.GetValue(slate), thingDef.HasComp(typeof(CompQuality)));
}
}
private bool DoWork(Slate slate)
{
Map map = slate.Get <Map>("map");
if (map == null)
{
return(false);
}
float x = slate.Get("points", 0f);
float seasonalTemp = Find.World.tileTemperatures.GetSeasonalTemp(map.Tile);
int ticksAbs = GenTicks.TicksAbs;
for (int i = 0; i < 15; i++)
{
int absTick = ticksAbs + 60000 * i;
float num = seasonalTemp + Find.World.tileTemperatures.OffsetFromDailyRandomVariation(map.Tile, absTick);
if (num <= 5f || num >= 53f)
{
return(false);
}
}
if (!DefDatabase <ThingDef> .AllDefs.Where((ThingDef def) => def.category == ThingCategory.Plant && !def.plant.cavePlant && def.plant.Sowable && def.plant.harvestedThingDef != null && def.plant.growDays <= (float)maxPlantGrowDays.GetValue(slate) && Command_SetPlantToGrow.IsPlantAvailable(def, map)).TryRandomElement(out var result))
{
return(false);
}
SimpleCurve value = pointsToRequiredWorkCurve.GetValue(slate);
float randomInRange = (workRandomFactorRange.GetValue(slate) ?? FloatRange.One).RandomInRange;
float num2 = value.Evaluate(x) * randomInRange;
float num3 = (result.plant.sowWork + result.plant.harvestWork) / result.plant.harvestYield;
int a = GenMath.RoundRandom(num2 / num3);
a = Mathf.Max(a, 1);
slate.Set(storeHarvestItemDefAs.GetValue(slate), result.plant.harvestedThingDef);
slate.Set(storeHarvestItemCountAs.GetValue(slate), a);
if (storeGrowDaysAs.GetValue(slate) != null)
{
slate.Set(storeGrowDaysAs.GetValue(slate), result.plant.growDays);
}
return(true);
}
protected override void RunInt()
{
Slate slate = QuestGen.slate;
QuestPart_InitiateTradeRequest questPart_InitiateTradeRequest = new QuestPart_InitiateTradeRequest();
questPart_InitiateTradeRequest.settlement = settlement.GetValue(slate);
questPart_InitiateTradeRequest.requestedThingDef = requestedThingDef.GetValue(slate);
questPart_InitiateTradeRequest.requestedCount = requestedThingCount.GetValue(slate);
questPart_InitiateTradeRequest.requestDuration = duration.GetValue(slate);
questPart_InitiateTradeRequest.keepAfterQuestEnds = false;
questPart_InitiateTradeRequest.inSignal = slate.Get <string>("inSignal");
QuestGen.quest.AddPart(questPart_InitiateTradeRequest);
}
private int GetLargestSize(Slate slate)
{
Map mapResolved = map.GetValue(slate) ?? slate.Get <Map>("map");
if (mapResolved == null)
{
return(0);
}
int value = max.GetValue(slate);
CellRect cellRect = LargestAreaFinder.FindLargestRect(mapResolved, (IntVec3 x) => IsClear(x, mapResolved), value);
return(Mathf.Min(cellRect.Width, cellRect.Height, value));
}
protected override void RunInt()
{
Slate slate = QuestGen.slate;
QuestGen.quest.AddPart(new QuestPart_RequirementsToAcceptBedroom
{
targetPawns = (from p in pawns.GetValue(QuestGen.slate)
where p.royalty != null && p.royalty.HighestTitleWithBedroomRequirements() != null
orderby p.royalty.HighestTitleWithBedroomRequirements().def.seniority descending
select p).ToList(),
mapParent = slate.Get <Map>("map").Parent
});
}
private bool PossibleNow(GameConditionDef def, Slate slate)
{
if (def == null)
{
return(false);
}
Map map = slate.Get <Map>("map");
if (map.gameConditionManager.ConditionIsActive(def))
{
return(false);
}
IncidentDef incidentDef = null;
List <IncidentDef> allDefsListForReading = DefDatabase <IncidentDef> .AllDefsListForReading;
for (int i = 0; i < allDefsListForReading.Count; i++)
{
if (allDefsListForReading[i].Worker is IncidentWorker_MakeGameCondition && allDefsListForReading[i].gameCondition == def)
{
incidentDef = allDefsListForReading[i];
break;
}
}
if (incidentDef != null)
{
if (Find.Storyteller.difficulty.difficulty < incidentDef.minDifficulty)
{
return(false);
}
if (GenDate.DaysPassed < incidentDef.earliestDay)
{
return(false);
}
if (incidentDef.Worker.FiredTooRecently(map))
{
return(false);
}
}
if (def == GameConditionDefOf.ColdSnap && !IncidentWorker_ColdSnap.IsTemperatureAppropriate(map))
{
return(false);
}
if (def == GameConditionDefOf.HeatWave && !IncidentWorker_HeatWave.IsTemperatureAppropriate(map))
{
return(false);
}
return(true);
}
private void SetVars(Slate slate)
{
float x = slate.Get("points", 0f);
float num = pointsCurve.GetValue(slate).Evaluate(x);
if (roundRandom.GetValue(slate))
{
num = GenMath.RoundRandom(num);
}
if (challengeRating.TryGetValue(slate, out int value))
{
switch (value)
{
case 1:
num = Mathf.Min(num, maxCountOneStar.GetValue(slate));
break;
case 2:
num = Mathf.Min(num, maxCountTwoStar.GetValue(slate));
break;
default:
num = Mathf.Min(num, maxCountThreeStar.GetValue(slate));
break;
}
}
SimpleCurve value2 = chancesCurve.GetValue(slate);
int num2 = value2.Points.Count - 1;
while (num2 >= 0)
{
if (value2.Points[num2].x > num)
{
value2.Points[num2] = new CurvePoint(0f, 0f);
num2--;
continue;
}
value2.Points.Insert(num2 + 1, new CurvePoint(num + 1f, 0f));
break;
}
float num3 = Rand.ByCurve(value2);
if (roundRandom.GetValue(slate))
{
num3 = GenMath.RoundRandom(num3);
}
slate.Set(storeAs.GetValue(slate), Mathf.Clamp(num3, 1f, num));
}
protected override void RunInt()
{
Slate slate = QuestGen.slate;
QuestPart_TrackWhenExitMentalState questPart_TrackWhenExitMentalState = new QuestPart_TrackWhenExitMentalState();
questPart_TrackWhenExitMentalState.mapParent = slate.Get <Map>("map").Parent;
questPart_TrackWhenExitMentalState.tag = QuestGenUtility.HardcodedTargetQuestTagWithQuestID(tag.GetValue(slate));
questPart_TrackWhenExitMentalState.mentalStateDef = mentalStateDef.GetValue(slate);
questPart_TrackWhenExitMentalState.outSignal = QuestGenUtility.HardcodedSignalWithQuestID(outSignal.GetValue(slate));
questPart_TrackWhenExitMentalState.inSignals = new List <string>();
foreach (string item in inSignals.GetValue(slate))
{
questPart_TrackWhenExitMentalState.inSignals.Add(QuestGenUtility.HardcodedSignalWithQuestID(item));
}
QuestGen.quest.AddPart(questPart_TrackWhenExitMentalState);
}
protected override bool TestRunInt(Slate slate)
{
if (!Find.Storyteller.difficultyValues.allowViolentQuests)
{
return(false);
}
if (!slate.Exists("map"))
{
return(false);
}
if (!ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(slate.Get("points", 0f), slate.Get <Map>("map").Tile, out var _))
{
return(false);
}
return(true);
}
