protected override bool CanFireNowSub(IIncidentTarget target)
{
Faction faction;
Faction faction2;
int num;
return(base.CanFireNowSub(target) && this.TryFindFactions(out faction, out faction2) && TileFinder.TryFindNewSiteTile(out num, 8, 30, false, true, -1));
}
public override IEnumerable <FiringIncident> MakeIntervalIncidents(IIncidentTarget target)
{
foreach (FiringIncident item in ThreatsGenerator.MakeIntervalIncidents(Props.parms, target, (target as Map)?.generationTick ?? 0))
{
item.source = this;
yield return(item);
}
}
private void GenerateForcedIncidents(IIncidentTarget target, IncidentParms parms)
{
List <IncidentDef> defs = (from def in base.UsableIncidentsInCategory(this.Props.IncidentCategory, parms)
where parms.points >= def.minThreatPoints
select def).ToList();
GenerateVotesFromDefs(defs, parms);
}
protected override bool CanFireNowSub(IIncidentTarget target)
{
if (target is Map)
{
return(true);
}
return(CaravanIncidentUtility.CanFireIncidentWhichWantsToGenerateMapAt(target.Tile));
}
protected override bool CanFireNowSub(IIncidentTarget target)
{
int num;
SitePartDef sitePartDef;
Faction faction;
return(base.CanFireNowSub(target) && Find.AnyPlayerHomeMap != null && CommsConsoleUtility.PlayerHasPoweredCommsConsole() && this.TryFindTile(out num) && SiteMakerHelper.TryFindSiteParams_SingleSitePart(SiteCoreDefOf.PrisonerWillingToJoin, IncidentWorker_QuestPrisonerWillingToJoin.PrisonerWillingToJoinQuestThreatTag, out sitePartDef, out faction, null, true, null));
}
protected override bool CanFireNowSub(IIncidentTarget target)
{
if (!this.PotentialVictims(target).Any())
{
return(false);
}
return(true);
}
public string DebugString()
{
if (Time.frameCount % 60 == 0)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine("GLOBAL STORYTELLER STATS");
stringBuilder.AppendLine("------------------------");
stringBuilder.AppendLine("Storyteller: ".PadRight(40) + def.label);
stringBuilder.AppendLine("Adaptation days: ".PadRight(40) + Find.StoryWatcher.watcherAdaptation.AdaptDays.ToString("F1"));
stringBuilder.AppendLine("Adapt points factor: ".PadRight(40) + Find.StoryWatcher.watcherAdaptation.TotalThreatPointsFactor.ToString("F2"));
stringBuilder.AppendLine("Time points factor: ".PadRight(40) + Find.Storyteller.def.pointsFactorFromDaysPassed.Evaluate(GenDate.DaysPassed).ToString("F2"));
stringBuilder.AppendLine();
stringBuilder.AppendLine("Ally incident fraction (neutral or ally): ".PadRight(40) + StorytellerUtility.AllyIncidentFraction(fullAlliesOnly: false).ToString("F2"));
stringBuilder.AppendLine("Ally incident fraction (ally only): ".PadRight(40) + StorytellerUtility.AllyIncidentFraction(fullAlliesOnly: true).ToString("F2"));
stringBuilder.AppendLine();
stringBuilder.AppendLine(StorytellerUtilityPopulation.DebugReadout().TrimEndNewlines());
IIncidentTarget incidentTarget = Find.WorldSelector.SingleSelectedObject as IIncidentTarget;
if (incidentTarget == null)
{
incidentTarget = Find.CurrentMap;
}
if (incidentTarget != null)
{
Map map = incidentTarget as Map;
stringBuilder.AppendLine();
stringBuilder.AppendLine("STATS FOR INCIDENT TARGET: " + incidentTarget);
stringBuilder.AppendLine("------------------------");
stringBuilder.AppendLine("Progress score: ".PadRight(40) + StorytellerUtility.GetProgressScore(incidentTarget).ToString("F2"));
stringBuilder.AppendLine("Base points: ".PadRight(40) + StorytellerUtility.DefaultThreatPointsNow(incidentTarget).ToString("F0"));
stringBuilder.AppendLine("Points factor random range: ".PadRight(40) + incidentTarget.IncidentPointsRandomFactorRange);
stringBuilder.AppendLine("Wealth: ".PadRight(40) + incidentTarget.PlayerWealthForStoryteller.ToString("F0"));
if (map != null)
{
stringBuilder.AppendLine("- Items: ".PadRight(40) + map.wealthWatcher.WealthItems.ToString("F0"));
stringBuilder.AppendLine("- Buildings: ".PadRight(40) + map.wealthWatcher.WealthBuildings.ToString("F0"));
stringBuilder.AppendLine("- Floors: ".PadRight(40) + map.wealthWatcher.WealthFloorsOnly.ToString("F0"));
stringBuilder.AppendLine("- Pawns: ".PadRight(40) + map.wealthWatcher.WealthPawns.ToString("F0"));
}
stringBuilder.AppendLine("Pawn count human: ".PadRight(40) + incidentTarget.PlayerPawnsForStoryteller.Where((Pawn p) => p.def.race.Humanlike).Count());
stringBuilder.AppendLine("Pawn count animal: ".PadRight(40) + incidentTarget.PlayerPawnsForStoryteller.Where((Pawn p) => p.def.race.Animal).Count());
if (map != null)
{
stringBuilder.AppendLine("StoryDanger: ".PadRight(40) + map.dangerWatcher.DangerRating);
stringBuilder.AppendLine("FireDanger: ".PadRight(40) + map.fireWatcher.FireDanger.ToString("F2"));
stringBuilder.AppendLine("LastThreatBigTick days ago: ".PadRight(40) + (Find.TickManager.TicksGame - map.storyState.LastThreatBigTick).ToStringTicksToDays());
}
}
stringBuilder.AppendLine();
stringBuilder.AppendLine("LIST OF ALL INCIDENT TARGETS");
stringBuilder.AppendLine("------------------------");
for (int i = 0; i < AllIncidentTargets.Count; i++)
{
stringBuilder.AppendLine(i + ". " + AllIncidentTargets[i].ToString());
}
debugStringCached = stringBuilder.ToString();
}
return(debugStringCached);
}
public string DebugString()
{
if (Time.frameCount % 60 == 0)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine("Storyteller : " + this.def.label);
stringBuilder.AppendLine("------------- Global threats data ---------------");
stringBuilder.AppendLine(" NumRaidsEnemy: " + Find.StoryWatcher.statsRecord.numRaidsEnemy);
stringBuilder.AppendLine(" TotalThreatPointsFactor: " + Find.StoryWatcher.watcherRampUp.TotalThreatPointsFactor.ToString("F5"));
stringBuilder.AppendLine(" ShortTermFactor: " + Find.StoryWatcher.watcherRampUp.ShortTermFactor.ToString("F5"));
stringBuilder.AppendLine(" LongTermFactor: " + Find.StoryWatcher.watcherRampUp.LongTermFactor.ToString("F5"));
stringBuilder.AppendLine(" AllyAssistanceMTBMultiplier (ally): " + StorytellerUtility.AllyIncidentMTBMultiplier(false).ToString());
stringBuilder.AppendLine(" AllyAssistanceMTBMultiplier (non-hostile): " + StorytellerUtility.AllyIncidentMTBMultiplier(true).ToString());
stringBuilder.AppendLine();
stringBuilder.AppendLine("-------------- Global population data --------------");
stringBuilder.AppendLine(this.intenderPopulation.DebugReadout);
stringBuilder.AppendLine("------------- All incident targets --------------");
for (int i = 0; i < this.AllIncidentTargets.Count; i++)
{
stringBuilder.AppendLine(" " + this.AllIncidentTargets[i].ToString());
}
IIncidentTarget incidentTarget = Find.WorldSelector.SingleSelectedObject as IIncidentTarget;
if (incidentTarget == null)
{
incidentTarget = Find.CurrentMap;
}
if (incidentTarget != null)
{
stringBuilder.AppendLine();
stringBuilder.AppendLine("---------- Selected: " + incidentTarget + " --------");
stringBuilder.AppendLine(" Wealth: " + incidentTarget.PlayerWealthForStoryteller.ToString("F0"));
stringBuilder.AppendLine(" IncidentPointsRandomFactorRange: " + incidentTarget.IncidentPointsRandomFactorRange);
stringBuilder.AppendLine(" Pawns-Humanlikes: " + (from p in incidentTarget.PlayerPawnsForStoryteller
where p.def.race.Humanlike
select p).Count <Pawn>());
stringBuilder.AppendLine(" Pawns-Animals: " + (from p in incidentTarget.PlayerPawnsForStoryteller
where p.def.race.Animal
select p).Count <Pawn>());
Map map = incidentTarget as Map;
if (map != null)
{
stringBuilder.AppendLine(" StoryDanger: " + map.dangerWatcher.DangerRating);
stringBuilder.AppendLine(" FireDanger: " + map.fireWatcher.FireDanger.ToString("F2"));
stringBuilder.AppendLine(" DaysSinceSeriousDamage: " + map.damageWatcher.DaysSinceSeriousDamage.ToString("F1"));
stringBuilder.AppendLine(" LastThreatBigQueueTick: " + map.storyState.LastThreatBigTick.ToStringTicksToPeriod());
}
stringBuilder.AppendLine(" Current points (ignoring early raid factors): " + StorytellerUtility.DefaultThreatPointsNow(incidentTarget).ToString("F0"));
stringBuilder.AppendLine(" Current points for specific IncidentMakers:");
for (int j = 0; j < this.storytellerComps.Count; j++)
{
IncidentParms incidentParms = this.storytellerComps[j].GenerateParms(IncidentCategoryDefOf.ThreatBig, incidentTarget);
stringBuilder.AppendLine(" " + this.storytellerComps[j].GetType().ToString().Substring(23) + ": " + incidentParms.points.ToString("F0"));
}
}
this.debugStringCached = stringBuilder.ToString();
}
return(this.debugStringCached);
}
public override bool IsPossible(string message, Viewer viewer, bool separateChannel = false)
{
ToolkitPatchLogger.Log(incidentDef.defName, "Checking if possible..");
this.separateChannel = separateChannel;
this.Viewer = viewer;
string[] command = message.Split(' ');
if (command.Length < 3)
{
Toolkit.client.SendMessage($"@{viewer.username} syntax is {this.storeIncident.syntax}", separateChannel);
return(false);
}
if (!VariablesHelpers.PointsWagerIsValid(
command[2],
viewer,
ref pointsWager,
ref storeIncident,
separateChannel
))
{
return(false);
}
ToolkitPatchLogger.Log(incidentDef.defName, $"Got the points wager of '{pointsWager}' and incident of '{storeIncident.abbreviation}:{storeIncident.defName}'");
target = Current.Game.AnyPlayerHomeMap;
if (target == null)
{
return(false);
}
ToolkitPatchLogger.Log(incidentDef.defName, $"Target found '{target.Tile}'");
parms = StorytellerUtility.DefaultParmsNow(categoryDef, target);
parms.points = IncidentHelper_PointsHelper.RollProportionalGamePoints(storeIncident, pointsWager, parms.points);
if (raidStratDef != null)
{
parms.raidStrategy = raidStratDef;
}
if (pawnArrivalModeDef != null)
{
parms.raidArrivalMode = pawnArrivalModeDef;
}
worker = Activator.CreateInstance <T>();
worker.def = incidentDef;
bool success = worker.CanFireNow(parms);
if (!success)
{
WorkerCanFireCheck.CheckDefaultFireNowConditions(worker, parms, incidentDef);
}
ToolkitPatchLogger.Log(incidentDef.defName, $"Can fire with params '{parms.ToString()}' on worker {worker.ToString()}? {success}");
return(success);
}
public void Update()
{
IIncidentTarget incidentTarget = Find.CurrentMap;
if (incidentTarget != null)
{
rps = RadePointsSummary.Get(Find.CurrentMap);
}
}
public static bool DoExecuteIncidentDebugAction_PreFix(Dialog_DebugActionsMenu __instance, IIncidentTarget target, IIncidentTarget altTarget)
{
//Log.Message("1");
if (Find.Storyteller?.storytellerComps?.FirstOrDefault(x => x is StorytellerComp_OmenThreatCycle) != null)
{
//Log.Message("2");
AccessTools.Method(typeof(Dialog_DebugActionsMenu), "DebugAction").Invoke(__instance, new object[]
{
"Execute incident...", new Action(delegate
{
//Log.Message("3");
List <DebugMenuOption> list = new List <DebugMenuOption>();
foreach (IncidentDef current in from d in DefDatabase <IncidentDef> .AllDefs
where d.TargetAllowed(target) || (altTarget != null && d.TargetAllowed(altTarget))
orderby !d.TargetAllowed(target), d.defName
select d)
{
IIncidentTarget arg_98_1;
if (current.TargetAllowed(target))
{
IIncidentTarget target2 = target;
arg_98_1 = target2;
}
else
{
arg_98_1 = altTarget;
}
var thisIncidentTarget = arg_98_1;
string text = current.defName;
if (!current.Worker.CanFireNow(thisIncidentTarget))
{
text += " [NO]";
}
if (thisIncidentTarget == altTarget)
{
text = text + " (" + altTarget.GetType().Name.Truncate(52f, null) + ")";
}
list.Add(new DebugMenuOption(text, DebugMenuOptionMode.Action, delegate
{
IncidentParms incidentParms = StorytellerUtility.DefaultParmsNow(Find.Storyteller.def, current.category, thisIncidentTarget);
if (current.pointsScaleable)
{
StorytellerComp storytellerComp = Find.Storyteller.storytellerComps.First((StorytellerComp x) => x is StorytellerComp_ThreatCycle || x is StorytellerComp_RandomMain || x is StorytellerComp_OmenThreatCycle);
incidentParms = storytellerComp.GenerateParms(current.category, incidentParms.target);
}
current.Worker.TryExecute(incidentParms);
}));
}
;
Find.WindowStack.Add(new Dialog_DebugOptionListLister(list));
})
});
return(false);
}
return(true);
}
public override IEnumerable <FiringIncident> MakeIntervalIncidents(IIncidentTarget target)
{
if (this.Props.incident.TargetAllowed(target) && Rand.MTBEventOccurs(this.Props.mtbDays, 60000f, 1000f))
{
yield return(new FiringIncident(this.Props.incident, this, this.GenerateParms(this.Props.incident.category, target)));
/*Error: Unable to find new state assignment for yield return*/;
}
}
public override IEnumerable <FiringIncident> MakeIntervalIncidents(IIncidentTarget target)
{
if (!ToolkitSettings.UseToryTalkerWithHodlBot)
{
return(null);
}
return(base.MakeIntervalIncidents(target));
}
public override IEnumerable <FiringIncident> MakeIntervalIncidents(IIncidentTarget target)
{
IncidentDef selectedDef;
if (Rand.MTBEventOccurs(this.Props.mtbDays, 60000f, 1000f) && this.UsableIncidentsInCategory(this.Props.category, target).TryRandomElementByWeight((IncidentDef incDef) => this.$this.IncidentChanceFinal(incDef), out selectedDef))
{
yield return(new FiringIncident(selectedDef, this, this.GenerateParms(selectedDef.category, target)));
}
}
private Lord lord; //The Star Vampire AI manager
protected override bool CanFireNowSub(IIncidentTarget target)
{
if (GenDate.DaysPassed < (ModInfo.cosmicHorrorRaidDelay + this.def.earliestDay))
{
Log.Message("Cosmic Horrors :: CantFireDueTo Time :: " + GenDate.DaysPassed + " days passed, but we need " + ModInfo.cosmicHorrorRaidDelay.ToString() + " days + " + this.def.earliestDay);
return(false);
}
return(true);
}
static void Prefix(IIncidentTarget target, ref Map __state)
{
if (MultiplayerWorldComp.tickingWorld && target is Map map)
{
MapAsyncTimeComp.tickingMap = map;
map.AsyncTime().PreContext();
__state = map;
}
}
//
// (( B18 ))
// private FiringIncident GenerateQueuedThreatSmall(IIncidentTarget target)
// {
// IncidentDef incidentDef;
// if (!this.UsableIncidentsInCategory(IncidentCategoryDefOf.ThreatSmall, target)
// .TryRandomElementByWeight(new Func<IncidentDef, float>(base.IncidentChanceFinal), out incidentDef))
// {
// return null;
// }
// return new FiringIncident(incidentDef, this, null)
// {
// parms = this.GenerateParms(incidentDef.category, target)
// };
// }
private FiringIncident GenerateIncident(IIncidentTarget target)
{
var parms = GenerateParms(Props.IncidentCategory, target);
return(new FiringIncident(IncidentDef.Named("HPLovecraft_OmenIncident"), this)
{
parms = parms
});
}
protected override bool CanFireNowSub(IIncidentTarget target)
{
Map map = (Map)target;
PawnKindDef pawnKindDef;
IntVec3 intVec;
IntVec3 intVec2;
return(this.TryFindAnimalKind(map.Tile, out pawnKindDef) && this.TryFindStartAndEndCells(map, out intVec, out intVec2));
}
public override IEnumerable <FiringIncident> MakeIntervalIncidents(IIncidentTarget target)
{
if (target is World)
{
yield break;
}
List <IncidentDef> allIncidents = DefDatabase <IncidentDef> .AllDefsListForReading;
int i = 0;
while (i < allIncidents.Count)
{
IncidentDef inc = allIncidents[i];
if (inc.category == this.Props.category)
{
BiomeDef biome = Find.WorldGrid[target.Tile].biome;
if (inc.mtbDaysByBiome != null)
{
MTBByBiome entry = inc.mtbDaysByBiome.Find((MTBByBiome x) => x.biome == biome);
if (entry != null)
{
float mtb = entry.mtbDays;
if (this.Props.applyCaravanVisibility)
{
Caravan caravan = target as Caravan;
if (caravan != null)
{
mtb /= caravan.Visibility;
}
else
{
Map map = target as Map;
if (map != null && map.Parent.def.isTempIncidentMapOwner)
{
IEnumerable <Pawn> pawns = map.mapPawns.SpawnedPawnsInFaction(Faction.OfPlayer).Concat(map.mapPawns.PrisonersOfColonySpawned);
mtb /= CaravanVisibilityCalculator.Visibility(pawns, false, null);
}
}
}
if (Rand.MTBEventOccurs(mtb, 60000f, 1000f))
{
IncidentParms parms = this.GenerateParms(inc.category, target);
if (inc.Worker.CanFireNow(parms))
{
yield return(new FiringIncident(inc, this, parms));
}
}
}
}
}
IL_24E:
i++;
continue;
goto IL_24E;
}
yield break;
}
public override IEnumerable <FiringIncident> MakeIntervalIncidents(IIncidentTarget target)
{
if (!(target is World))
{
List <IncidentDef> allIncidents = DefDatabase <IncidentDef> .AllDefsListForReading;
int i = 0;
IncidentDef inc;
while (true)
{
if (i < allIncidents.Count)
{
inc = allIncidents[i];
if (inc.category == this.Props.category)
{
_003CMakeIntervalIncidents_003Ec__Iterator0 _003CMakeIntervalIncidents_003Ec__Iterator = (_003CMakeIntervalIncidents_003Ec__Iterator0) /*Error near IL_0095: stateMachine*/;
BiomeDef biome = Find.WorldGrid[target.Tile].biome;
if (inc.mtbDaysByBiome != null)
{
MTBByBiome entry = inc.mtbDaysByBiome.Find((MTBByBiome x) => x.biome == biome);
if (entry != null)
{
float mtb = entry.mtbDays;
if (this.Props.applyCaravanStealthFactor)
{
Caravan caravan = target as Caravan;
if (caravan != null)
{
mtb *= CaravanIncidentUtility.CalculateCaravanStealthFactor(caravan.PawnsListForReading.Count);
}
else
{
Map map = target as Map;
if (map != null && map.info.parent.def.isTempIncidentMapOwner)
{
int pawnCount = map.mapPawns.SpawnedPawnsInFaction(Faction.OfPlayer).Count + map.mapPawns.PrisonersOfColonySpawnedCount;
mtb *= CaravanIncidentUtility.CalculateCaravanStealthFactor(pawnCount);
}
}
}
if (Rand.MTBEventOccurs(mtb, 60000f, 1000f) && inc.Worker.CanFireNow(target))
{
break;
}
}
}
}
i++;
continue;
}
yield break;
}
yield return(new FiringIncident(inc, this, this.GenerateParms(inc.category, target)));
/*Error: Unable to find new state assignment for yield return*/;
}
}
protected override bool CanFireNowSub(IIncidentTarget target)
{
if (!base.CanFireNowSub(target))
{
return(false);
}
Map map = (Map)target;
return(map.mapTemperature.SeasonalTemp >= 20f);
}
public override IEnumerable <FiringIncident> MakeIntervalIncidents(IIncidentTarget target)
{
if (this.Props.incident.TargetAllowed(target))
{
if (Rand.MTBEventOccurs(this.Props.mtbDays, 60000f, 1000f))
{
yield return(new FiringIncident(this.Props.incident, this, this.GenerateParms(this.Props.incident.category, target)));
}
}
}
public override IncidentParms GenerateParms(IncidentCategoryDef incCat, IIncidentTarget target)
{
IncidentParms incidentParms = StorytellerUtility.DefaultParmsNow(incCat, target);
if (incidentParms.points >= 0f)
{
incidentParms.points *= Props.randomPointsFactorRange.RandomInRange;
}
return(incidentParms);
}
protected override bool CanFireNowSub(IIncidentTarget target)
{
Map map = (Map)target;
if (map.gameConditionManager.ConditionIsActive(GameConditionDefOf.PsychicDrone))
{
return(false);
}
return(base.CanFireNowSub(target));
}
protected override bool CanFireNowSub(IIncidentTarget target)
{
Map map = (Map)target;
if (GenDate.DaysPassed < (ModInfo.cosmicHorrorRaidDelay + this.def.earliestDay))
{
return(false);
}
return(base.CanFireNowSub(target));
}
protected override bool CanFireNowSub(IIncidentTarget target)
{
if (!base.CanFireNowSub(target))
{
return(false);
}
Map map = (Map)target;
return(GenCelestial.CurCelestialSunGlow(map) <= 0.5f && GenCelestial.CelestialSunGlow(map, Find.TickManager.TicksAbs + 5000) <= 0.5f);
}
private IEnumerable <Pawn> PotentialVictimCandidates(IIncidentTarget target)
{
if (target is Map map)
{
return(map.mapPawns.FreeColonistsAndPrisoners);
}
return(from x in ((Caravan)target).PawnsListForReading
where x.IsFreeColonist || x.IsPrisonerOfColony
select x);
}
protected override bool CanFireNowSub(IIncidentTarget target)
{
if (!base.CanFireNowSub(target))
{
return(false);
}
Map map = (Map)target;
return(TryFindRootCell(map, out IntVec3 c));
}
protected override bool CanFireNowSub(IIncidentTarget target)
{
Map map = (Map)target;
if (map.Biome == Util_CaveBiome.CaveBiomeDef)
{
return(false);
}
return(base.CanFireNowSub(target));
}
protected override bool CanFireNowSub(IIncidentTarget target)
{
Map map = (Map)target;
if (map.gameConditionManager.ConditionIsActive(GameConditionDefOf.ToxicFallout))
{
return(false);
}
return(true);
}
protected override bool CanFireNowSub(IIncidentTarget target)
{
return UsableBatteries((Map)target).Any();
}
