private bool SetVars(Slate slate)
{
Thing value = factionOf.GetValue(slate);
if (value == null)
{
return(false);
}
Faction faction = value.Faction;
if (faction == null)
{
return(false);
}
List <Choice> value2 = choices.GetValue(slate);
for (int i = 0; i < value2.Count; i++)
{
if (((value2[i].factionDef != null && faction.def == value2[i].factionDef) || (!value2[i].categoryTag.NullOrEmpty() && value2[i].categoryTag == faction.def.categoryTag)) && value2[i].pawnKinds.TryRandomElement(out var result))
{
slate.Set(storeAs.GetValue(slate), result);
return(true);
}
}
if (fallback.GetValue(slate) != null)
{
slate.Set(storeAs.GetValue(slate), fallback.GetValue(slate));
return(true);
}
return(false);
}
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 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 void DoWork(Slate slate)
{
if (mapOf.GetValue(slate) == null)
{
return;
}
Map mapHeld = mapOf.GetValue(slate).MapHeld;
if (mapHeld != null && mapHeld.IsPlayerHome)
{
slate.Set(storeAs.GetValue(slate), mapHeld);
return;
}
int tile = mapOf.GetValue(slate).Tile;
if (tile == -1)
{
return;
}
Map map = null;
List <Map> maps = Find.Maps;
for (int i = 0; i < maps.Count; i++)
{
if (maps[i].IsPlayerHome && (map == null || Find.WorldGrid.ApproxDistanceInTiles(tile, maps[i].Tile) < Find.WorldGrid.ApproxDistanceInTiles(tile, map.Tile)))
{
map = maps[i];
}
}
if (map != null)
{
slate.Set(storeAs.GetValue(slate), map);
}
}
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 void SetVars(Slate slate)
{
Option option = options.GetValue(slate).RandomElementByWeight((Option x) => x.weight);
slate.Set(storeHediffAs.GetValue(slate), option.def);
if (storePartsToAffectAs.GetValue(slate) != null)
{
slate.Set(storePartsToAffectAs.GetValue(slate), option.partsToAffect);
}
}
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);
}
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 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 DoWork(Slate slate)
{
if (!options.Where((Option x) => (!QuestGen.Working || x.challengeRating == QuestGen.quest.challengeRating) && PossibleNow(x.gameCondition, slate)).TryRandomElement(out Option result))
{
return(false);
}
int var = (int)(result.durationDaysRange.RandomInRange * 60000f);
slate.Set(storeGameConditionAs.GetValue(slate), result.gameCondition);
slate.Set(storeGameConditionDurationAs.GetValue(slate), var);
slate.Set(storeGameConditionDifficultyAs.GetValue(slate), result.difficulty);
return(true);
}
protected override void RunInt()
{
Slate slate = QuestGen.slate;
string var = QuestGenUtility.ResolveLocalTextWithDescriptionRules(rules.GetValue(slate), root.GetValue(slate));
slate.Set(storeAs.GetValue(slate), var);
}
private void SetVars(Slate slate)
{
if (options.TryRandomElementByWeight((Option x) => x.weight, out var result))
{
slate.Set(storeAs.GetValue(slate), result.element.GetValue(slate));
}
}
private void SetVars(Slate slate)
{
if (options.TryRandomElement(out var result))
{
slate.Set(storeAs.GetValue(slate), result.GetValue(slate));
}
}
private void DoWork(Slate slate)
{
if (mapOf.GetValue(slate) != null)
{
slate.Set(storeAs.GetValue(slate), mapOf.GetValue(slate).MapHeld);
}
}
protected override void RunInt()
{
Slate slate = QuestGen.slate;
float points = QuestGen.slate.Get("points", 0f);
GameCondition gameCondition = GameConditionMaker.MakeCondition(this.gameCondition.GetValue(slate), duration.GetValue(slate));
QuestPart_GameCondition questPart_GameCondition = new QuestPart_GameCondition();
questPart_GameCondition.gameCondition = gameCondition;
List <Rule> list = new List <Rule>();
Dictionary <string, string> dictionary = new Dictionary <string, string>();
if (targetWorld.GetValue(slate))
{
questPart_GameCondition.targetWorld = true;
gameCondition.RandomizeSettings(points, null, list, dictionary);
}
else
{
Map map = GetMap(QuestGen.slate);
questPart_GameCondition.mapParent = map.Parent;
gameCondition.RandomizeSettings(points, map, list, dictionary);
}
questPart_GameCondition.inSignal = (QuestGenUtility.HardcodedSignalWithQuestID(inSignal.GetValue(slate)) ?? QuestGen.slate.Get <string>("inSignal"));
QuestGen.quest.AddPart(questPart_GameCondition);
if (!storeGameConditionDescriptionFutureAs.GetValue(slate).NullOrEmpty())
{
slate.Set(storeGameConditionDescriptionFutureAs.GetValue(slate), gameCondition.def.descriptionFuture);
}
QuestGen.AddQuestNameRules(list);
QuestGen.AddQuestDescriptionRules(list);
QuestGen.AddQuestDescriptionConstants(dictionary);
}
protected override void RunInt()
{
Slate slate = QuestGen.slate;
float randomInRange = GetRangeFromRating().RandomInRange;
slate.Set(storeAs.GetValue(slate), roundRandom.GetValue(slate) ? ((float)GenMath.RoundRandom(randomInRange)) : randomInRange);
}
private void SetVars(Slate slate)
{
if (pawn.GetValue(slate) == null || otherPawns.GetValue(slate) == null)
{
return;
}
tmpRelations.Clear();
int num = 0;
foreach (Pawn item in otherPawns.GetValue(slate))
{
PawnRelationDef mostImportantRelation = pawn.GetValue(slate).GetMostImportantRelation(item);
if (mostImportantRelation != null)
{
tmpRelations.Add(mostImportantRelation.GetGenderSpecificLabel(item));
}
else
{
num++;
}
}
if (num == 1)
{
tmpRelations.Add(nonRelatedLabel.GetValue(slate));
}
else if (num >= 2)
{
tmpRelations.Add(num + " " + nonRelatedLabelPlural.GetValue(slate));
}
if (tmpRelations.Any())
{
slate.Set(storeAs.GetValue(slate), tmpRelations.ToCommaList(useAnd: true));
tmpRelations.Clear();
}
}
private void DoWork(Slate slate)
{
if (monumentMarker.GetValue(slate) != null)
{
slate.Set(storeAs.GetValue(slate), monumentMarker.GetValue(slate).Size);
}
}
protected override bool TestRunInt(Slate slate)
{
int largestSize = GetLargestSize(slate);
slate.Set(storeAs.GetValue(slate), largestSize);
return(largestSize >= failIfSmaller.GetValue(slate));
}
protected override void RunInt()
{
Slate slate = QuestGen.slate;
int largestSize = GetLargestSize(slate);
slate.Set(storeAs.GetValue(slate), largestSize);
}
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;
TryFindRootTile(out int tile);
TryFindDestinationTile(tile, out int tile2);
slate.Set(storeAs.GetValue(slate), tile2);
}
private void SetVars(Slate slate)
{
string value = storeAs.GetValue(slate);
int num = PawnsFinder.AllMaps_FreeColonistsSpawned.Count((Pawn c) => !c.IsQuestLodger());
int var = Mathf.Clamp((int)((float)num * colonyPercentage.GetValue(slate)), 1, num - 1);
slate.Set(value, var);
}
protected override void RunInt()
{
Slate slate = QuestGen.slate;
MonumentMarker monumentMarker = (MonumentMarker)ThingMaker.MakeThing(ThingDefOf.MonumentMarker);
monumentMarker.sketch = sketch.GetValue(slate);
slate.Set(storeAs.GetValue(slate), monumentMarker);
}
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);
}
public static void AddToOrMakeList(Slate slate, string name, object obj)
{
if (!slate.TryGet(name, out List <object> var))
{
var = new List <object>();
}
var.Add(obj);
slate.Set(name, var);
}
protected override void RunInt()
{
Slate slate = QuestGen.slate;
if (pawns.GetValue(slate) != null)
{
IEnumerable <Pawn> filteredPawns = GetFilteredPawns(pawns.GetValue(slate));
slate.Set(storeAs.GetValue(slate), filteredPawns);
if (storeCountAs.GetValue(slate) != null)
{
slate.Set(storeCountAs.GetValue(slate), filteredPawns.Count());
}
if (storePawnsLabelAs.GetValue(slate) != null)
{
slate.Set(storePawnsLabelAs.GetValue(slate), filteredPawns.Select((Pawn p) => p.LabelNoCountColored.Resolve()).ToCommaList(useAnd: true));
}
}
}
protected override bool TestRunInt(Slate slate)
{
if (!TryFindTile(slate, out var tile))
{
return(false);
}
slate.Set(storeAs.GetValue(slate), tile);
return(true);
}
