private FiringIncident GenerateIncident(IIncidentTarget target) { IncidentParms parms = GenerateParms(Props.IncidentCategory, target); IncidentDef result; if ((float)GenDate.DaysPassed < Props.forceRaidEnemyBeforeDaysPassed) { if (!IncidentDefOf.RaidEnemy.Worker.CanFireNow(parms)) { return(null); } result = IncidentDefOf.RaidEnemy; } else if (Props.incident != null) { if (!Props.incident.Worker.CanFireNow(parms)) { return(null); } result = Props.incident; } else if (!(from def in UsableIncidentsInCategory(Props.IncidentCategory, parms) where parms.points >= def.minThreatPoints select def).TryRandomElementByWeight(base.IncidentChanceFinal, out result)) { return(null); } FiringIncident firingIncident = new FiringIncident(result, this); firingIncident.parms = parms; return(firingIncident); }
public override IEnumerable <FiringIncident> MakeIntervalIncidents(IIncidentTarget target) { float curCycleDays = (GenDate.DaysPassedFloat - this.Props.minDaysPassed) % this.Props.ThreatCycleTotalDays; if (!(curCycleDays > this.Props.threatOffDays)) { yield break; } float daysSinceThreatBig = (float)((float)(Find.TickManager.TicksGame - target.StoryState.LastThreatBigTick) / 60000.0); if (daysSinceThreatBig > this.Props.minDaysBetweenThreatBigs && ((daysSinceThreatBig > this.Props.ThreatCycleTotalDays * 0.89999997615814209 && curCycleDays > this.Props.ThreatCycleTotalDays * 0.949999988079071) || Rand.MTBEventOccurs(this.Props.mtbDaysThreatBig, 60000f, 1000f))) { FiringIncident bt = this.GenerateQueuedThreatBig(target); if (bt != null) { yield return(bt); /*Error: Unable to find new state assignment for yield return*/; } } if (!Rand.MTBEventOccurs(this.Props.mtbDaysThreatSmall, 60000f, 1000f)) { yield break; } FiringIncident st = this.GenerateQueuedThreatSmall(target); if (st == null) { yield break; } yield return(st); /*Error: Unable to find new state assignment for yield return*/; }
public override IEnumerable <FiringIncident> MakeIntervalIncidents(IIncidentTarget target) { float difficultyFactor = (!this.Props.applyRaidBeaconThreatMtbFactor) ? 1f : Find.Storyteller.difficulty.raidBeaconThreatCountFactor; float acceptFraction = 1f; if (this.Props.acceptFractionByDaysPassedCurve != null) { acceptFraction *= this.Props.acceptFractionByDaysPassedCurve.Evaluate(GenDate.DaysPassedFloat); } if (this.Props.acceptPercentFactorPerThreatPointsCurve != null) { acceptFraction *= this.Props.acceptPercentFactorPerThreatPointsCurve.Evaluate(StorytellerUtility.DefaultThreatPointsNow(target)); } int incCount = IncidentCycleUtility.IncidentCountThisInterval(target, Find.Storyteller.storytellerComps.IndexOf(this), this.Props.minDaysPassed, this.Props.onDays, this.Props.offDays, this.Props.minSpacingDays, this.Props.numIncidentsRange.min * difficultyFactor, this.Props.numIncidentsRange.max * difficultyFactor, acceptFraction); for (int i = 0; i < incCount; i++) { FiringIncident fi = this.GenerateIncident(target); if (fi != null) { yield return(fi); } } yield break; }
public override IEnumerable <FiringIncident> MakeIntervalIncidents(IIncidentTarget target) { float curCycleDays = (GenDate.DaysPassedFloat - this.Props.minDaysPassed) % this.Props.ThreatCycleTotalDays; if (curCycleDays > this.Props.threatOffDays) { float daysSinceThreatBig = (float)(Find.TickManager.TicksGame - target.StoryState.LastThreatBigTick) / 60000f; if (daysSinceThreatBig > this.Props.minDaysBetweenThreatBigs && ((daysSinceThreatBig > this.Props.ThreatCycleTotalDays * 0.9f && curCycleDays > this.Props.ThreatCycleTotalDays * 0.95f) || Rand.MTBEventOccurs(this.Props.mtbDaysThreatBig, 60000f, 1000f))) { FiringIncident bt = this.GenerateQueuedThreatBig(target); if (bt != null) { yield return(bt); } } if (Rand.MTBEventOccurs(this.Props.mtbDaysThreatSmall, 60000f, 1000f)) { FiringIncident st = this.GenerateQueuedThreatSmall(target); if (st != null) { yield return(st); } } } }
public override void Notify_PawnEvent(Pawn p, AdaptationEvent ev, DamageInfo?dinfo = default(DamageInfo?)) { if (p.RaceProps.Humanlike && p.IsColonist && (ev == AdaptationEvent.Died || ev == AdaptationEvent.Kidnapped || ev == AdaptationEvent.LostBecauseMapClosed || ev == AdaptationEvent.Downed)) { IEnumerable <Pawn> allMapsCaravansAndTravelingTransportPods_Alive_OfPlayerFaction = PawnsFinder.AllMapsCaravansAndTravelingTransportPods_Alive_OfPlayerFaction; foreach (Pawn item in allMapsCaravansAndTravelingTransportPods_Alive_OfPlayerFaction) { if (item.RaceProps.Humanlike && !item.Downed) { return; } } Map anyPlayerHomeMap = Find.AnyPlayerHomeMap; if (anyPlayerHomeMap != null) { IncidentParms parms = StorytellerUtility.DefaultParmsNow(Props.incident.category, anyPlayerHomeMap); if (Props.incident.Worker.CanFireNow(parms)) { FiringIncident firingInc = new FiringIncident(Props.incident, this, parms); QueuedIncident qi = new QueuedIncident(firingInc, Find.TickManager.TicksGame + Props.delayTicks); Find.Storyteller.incidentQueue.Add(qi); } } } }
public void TryFire(FiringIncident fi) { if ((fi.parms.forced || fi.def.Worker.CanFireNow(fi.parms.target)) && fi.def.Worker.TryExecute(fi.parms)) { fi.parms.target.StoryState.Notify_IncidentFired(fi); } }
public bool MoveNext() { uint num = (uint)this.$PC; this.$PC = -1; switch (num) { case 0u: if (base.IntervalsPassed == 840) { inc = IncidentDefOf.Quest_JourneyOffer; if (inc.TargetAllowed(target)) { fi = new FiringIncident(inc, this, this.GenerateParms(inc.category, target)); this.$current = fi; if (!this.$disposing) { this.$PC = 1; } return(true); } } break; case 1u: break; default: return(false); } this.$PC = -1; return(false); }
private FiringIncident GenerateQueuedThreatBig(IIncidentTarget target) { IncidentParms parms = this.GenerateParms(this.Props.threatBigCategory, target); IncidentDef raidEnemy = default(IncidentDef); if ((float)GenDate.DaysPassed < this.Props.minDaysBeforeNonRaidThreatBig) { if (IncidentDefOf.RaidEnemy.Worker.CanFireNow(target)) { raidEnemy = IncidentDefOf.RaidEnemy; goto IL_00a3; } return(null); } if (!(from def in DefDatabase <IncidentDef> .AllDefs where def.category == this.Props.threatBigCategory && parms.points >= def.minThreatPoints && def.Worker.CanFireNow(target) select def).TryRandomElementByWeight <IncidentDef>((Func <IncidentDef, float>)base.IncidentChanceFinal, out raidEnemy)) { return(null); } goto IL_00a3; IL_00a3: FiringIncident firingIncident = new FiringIncident(raidEnemy, this, null); firingIncident.parms = parms; return(firingIncident); }
public override IEnumerable <FiringIncident> MakeIntervalIncidents(IIncidentTarget target) { float num = 1f; if (Props.acceptFractionByDaysPassedCurve != null) { num *= Props.acceptFractionByDaysPassedCurve.Evaluate(GenDate.DaysPassedFloat); } if (Props.acceptPercentFactorPerThreatPointsCurve != null) { num *= Props.acceptPercentFactorPerThreatPointsCurve.Evaluate(StorytellerUtility.DefaultThreatPointsNow(target)); } if (Props.acceptPercentFactorPerProgressScoreCurve != null) { num *= Props.acceptPercentFactorPerProgressScoreCurve.Evaluate(StorytellerUtility.GetProgressScore(target)); } int incCount = IncidentCycleUtility.IncidentCountThisInterval(target, Find.Storyteller.storytellerComps.IndexOf(this), Props.minDaysPassed, Props.onDays, Props.offDays, Props.minSpacingDays, Props.numIncidentsRange.min, Props.numIncidentsRange.max, num); for (int i = 0; i < incCount; i++) { FiringIncident firingIncident = GenerateIncident(target); if (firingIncident != null) { yield return(firingIncident); } } }
public bool MoveNext() { uint num = (uint)this.$PC; this.$PC = -1; switch (num) { case 0u: if (Rand.MTBEventOccurs(base.ShipChunkDropMTBDays, 60000f, 1000f)) { def = IncidentDefOf.ShipChunkDrop; parms = this.GenerateParms(def.category, target); if (def.Worker.CanFireNow(parms, false)) { this.$current = new FiringIncident(def, this, parms); if (!this.$disposing) { this.$PC = 1; } return(true); } } break; case 1u: break; default: return(false); } this.$PC = -1; return(false); }
public void Notify_IncidentFired(FiringIncident qi) { if (!qi.parms.forced && qi.parms.target == this.target) { int ticksGame = Find.TickManager.TicksGame; if (qi.def.category == IncidentCategoryDefOf.ThreatBig || qi.def.category == IncidentCategoryDefOf.RaidBeacon) { if (this.lastThreatBigTick <= ticksGame) { this.lastThreatBigTick = ticksGame; } else { Log.Error("Queueing threats backwards in time (" + qi + ")", false); } Find.StoryWatcher.statsRecord.numThreatBigs++; } if (this.lastFireTicks.ContainsKey(qi.def)) { this.lastFireTicks[qi.def] = ticksGame; } else { this.lastFireTicks.Add(qi.def, ticksGame); } } }
public bool Add(IncidentDef def, int fireTick, IncidentParms parms = null, int retryDurationTicks = 0) { FiringIncident firingInc = new FiringIncident(def, null, parms); QueuedIncident qi = new QueuedIncident(firingInc, fireTick, retryDurationTicks); this.Add(qi); return(true); }
public bool TryFire(FiringIncident fi) { if (fi.def.Worker.CanFireNow(fi.parms, false) && fi.def.Worker.TryExecute(fi.parms)) { fi.parms.target.StoryState.Notify_IncidentFired(fi); return(true); } return(false); }
public override IEnumerable <FiringIncident> MakeIntervalIncidents(IIncidentTarget target) { if (this.IntervalsPassed == 840) { IncidentDef inc = IncidentDefOf.Quest_JourneyOffer; if (inc.TargetAllowed(target)) { FiringIncident fi = new FiringIncident(inc, this, this.GenerateParms(inc.category, target)); yield return(fi); } } }
public override IEnumerable <FiringIncident> MakeIntervalIncidents(IIncidentTarget target) { if (target != Find.Maps.Find((Map x) => x.IsPlayerHome)) { yield break; } if (IntervalsPassed == 150) { IncidentDef visitorGroup = IncidentDefOf.VisitorGroup; if (visitorGroup.TargetAllowed(target)) { FiringIncident firingIncident = new FiringIncident(visitorGroup, this); firingIncident.parms.target = target; firingIncident.parms.points = Rand.Range(40, 100); yield return(firingIncident); } } if (IntervalsPassed == 204) { IncidentCategoryDef threatCategory = (Find.Storyteller.difficultyValues.allowIntroThreats ? IncidentCategoryDefOf.ThreatSmall : IncidentCategoryDefOf.Misc); if (DefDatabase <IncidentDef> .AllDefs.Where((IncidentDef def) => def.TargetAllowed(target) && def.category == threatCategory).TryRandomElementByWeight(base.IncidentChanceFinal, out var result)) { FiringIncident firingIncident2 = new FiringIncident(result, this); firingIncident2.parms = StorytellerUtility.DefaultParmsNow(result.category, target); yield return(firingIncident2); } } if (IntervalsPassed == 264 && DefDatabase <IncidentDef> .AllDefs.Where((IncidentDef def) => def.TargetAllowed(target) && def.category == IncidentCategoryDefOf.Misc).TryRandomElementByWeight(base.IncidentChanceFinal, out var result2)) { FiringIncident firingIncident3 = new FiringIncident(result2, this); firingIncident3.parms = StorytellerUtility.DefaultParmsNow(result2.category, target); yield return(firingIncident3); } if (IntervalsPassed != 324) { yield break; } IncidentDef incidentDef = IncidentDefOf.RaidEnemy; if (!Find.Storyteller.difficultyValues.allowIntroThreats) { incidentDef = DefDatabase <IncidentDef> .AllDefs.Where((IncidentDef def) => def.TargetAllowed(target) && def.category == IncidentCategoryDefOf.Misc).RandomElementByWeightWithFallback(base.IncidentChanceFinal); } if (incidentDef != null && incidentDef.TargetAllowed(target)) { FiringIncident firingIncident4 = new FiringIncident(incidentDef, this); firingIncident4.parms = GenerateParms(incidentDef.category, target); firingIncident4.parms.points = 40f; firingIncident4.parms.raidForceOneIncap = true; firingIncident4.parms.raidNeverFleeIndividual = true; yield return(firingIncident4); } }
private FiringIncident GenerateQueuedThreatSmall(IIncidentTarget target) { IncidentDef incidentDef = default(IncidentDef); if (!this.UsableIncidentsInCategory(this.Props.threatSmallCategory, target).TryRandomElementByWeight <IncidentDef>((Func <IncidentDef, float>)base.IncidentChanceFinal, out incidentDef)) { return(null); } FiringIncident firingIncident = new FiringIncident(incidentDef, this, null); firingIncident.parms = this.GenerateParms(incidentDef.category, target); return(firingIncident); }
public static IEnumerable <FiringIncident> MakeIntervalIncidents(ThreatsGeneratorParams parms, IIncidentTarget target, int startTick) { float threatsGeneratorThreatCountFactor = Find.Storyteller.difficulty.threatsGeneratorThreatCountFactor; int incCount = IncidentCycleUtility.IncidentCountThisInterval(target, parms.randSeed, (float)startTick / 60000f, parms.onDays, parms.offDays, parms.minSpacingDays, parms.numIncidentsRange.min * threatsGeneratorThreatCountFactor, parms.numIncidentsRange.max * threatsGeneratorThreatCountFactor); for (int i = 0; i < incCount; i++) { FiringIncident firingIncident = MakeThreat(parms, target); if (firingIncident != null) { yield return(firingIncident); } } }
public override IEnumerable <FiringIncident> MakeIntervalIncidents(IIncidentTarget target) { if (IntervalsPassed == 840) { IncidentDef inc = IncidentDefOf.Quest_JourneyOffer; if (inc.TargetAllowed(target)) { FiringIncident fi = new FiringIncident(inc, this, GenerateParms(inc.category, target)); yield return(fi); /*Error: Unable to find new state assignment for yield return*/; } } }
private FiringIncident GenerateQueuedThreatSmall(IIncidentTarget target) { IncidentDef incidentDef; FiringIncident result; if (!base.UsableIncidentsInCategory(this.Props.threatSmallCategory, target).TryRandomElementByWeight(new Func<IncidentDef, float>(base.IncidentChanceFinal), out incidentDef)) { result = null; } else { result = new FiringIncident(incidentDef, this, null) { parms = this.GenerateParms(incidentDef.category, target) }; } return result; }
public void Notify_IncidentFired(FiringIncident fi) { if (!fi.parms.forced && fi.parms.target == target) { int ticksGame = Find.TickManager.TicksGame; if (fi.def.category == IncidentCategoryDefOf.ThreatBig || fi.def.category == IncidentCategoryDefOf.RaidBeacon) { lastThreatBigTick = ticksGame; Find.StoryWatcher.statsRecord.numThreatBigs++; } if (lastFireTicks.ContainsKey(fi.def)) { lastFireTicks[fi.def] = ticksGame; } else { lastFireTicks.Add(fi.def, ticksGame); } } }
public IEnumerable <FiringIncident> MakeIncidentsForInterval() { List <IIncidentTarget> targets = AllIncidentTargets; for (int i = 0; i < storytellerComps.Count; i++) { using (IEnumerator <FiringIncident> enumerator = MakeIncidentsForInterval(storytellerComps[i], targets).GetEnumerator()) { if (enumerator.MoveNext()) { FiringIncident incident = enumerator.Current; yield return(incident); /*Error: Unable to find new state assignment for yield return*/; } } } yield break; IL_011b: /*Error near IL_011c: Unexpected return in MoveNext()*/; }
public bool MoveNext() { uint num = (uint)this.$PC; this.$PC = -1; switch (num) { case 0u: if (!base.Props.incident.TargetAllowed(target)) { return(false); } if (Rand.MTBEventOccurs(base.Props.mtbDays, 60000f, 1000f)) { parms = this.GenerateParms(base.Props.incident.category, target); if (base.Props.incident.Worker.CanFireNow(parms, false)) { this.$current = new FiringIncident(base.Props.incident, this, parms); if (!this.$disposing) { this.$PC = 1; } return(true); } } break; case 1u: break; default: return(false); } this.$PC = -1; return(false); }
public bool MoveNext() { uint num = (uint)this.$PC; this.$PC = -1; switch (num) { case 0u: if (target != Find.Maps.Find((Map x) => x.IsPlayerHome)) { return(false); } if (base.IntervalsPassed == 150) { inc = IncidentDefOf.VisitorGroup; if (inc.TargetAllowed(target)) { FiringIncident qi = new FiringIncident(inc, this, null); qi.parms.target = target; qi.parms.points = (float)Rand.Range(40, 100); this.$current = qi; if (!this.$disposing) { this.$PC = 1; } return(true); } } break; case 1u: break; case 2u: goto IL_23E; case 3u: goto IL_2ED; case 4u: goto IL_41A; default: return(false); } if (base.IntervalsPassed == 204) { IncidentCategoryDef threatCategory = (!Find.Storyteller.difficulty.allowIntroThreats) ? IncidentCategoryDefOf.Misc : IncidentCategoryDefOf.ThreatSmall; if ((from def in DefDatabase <IncidentDef> .AllDefs where def.TargetAllowed(< MakeIntervalIncidents > c__AnonStorey.target) && def.category == threatCategory select def).TryRandomElementByWeight(new Func <IncidentDef, float>(base.IncidentChanceFinal), out incDef)) { FiringIncident qi2 = new FiringIncident(incDef, this, null); qi2.parms = StorytellerUtility.DefaultParmsNow(incDef.category, <MakeIntervalIncidents> c__AnonStorey.target); this.$current = qi2; if (!this.$disposing) { this.$PC = 2; } return(true); } } IL_23E: if (base.IntervalsPassed == 264 && (from def in DefDatabase <IncidentDef> .AllDefs where def.TargetAllowed(< MakeIntervalIncidents > c__AnonStorey.target) && def.category == IncidentCategoryDefOf.Misc select def).TryRandomElementByWeight(new Func <IncidentDef, float>(base.IncidentChanceFinal), out incDef2)) { FiringIncident qi3 = new FiringIncident(incDef2, this, null); qi3.parms = StorytellerUtility.DefaultParmsNow(incDef2.category, <MakeIntervalIncidents> c__AnonStorey.target); this.$current = qi3; if (!this.$disposing) { this.$PC = 3; } return(true); } IL_2ED: if (base.IntervalsPassed == 324) { inc2 = IncidentDefOf.RaidEnemy; if (!Find.Storyteller.difficulty.allowIntroThreats) { inc2 = (from def in DefDatabase <IncidentDef> .AllDefs where def.TargetAllowed(< MakeIntervalIncidents > c__AnonStorey.target) && def.category == IncidentCategoryDefOf.Misc select def).RandomElementByWeightWithFallback(new Func <IncidentDef, float>(base.IncidentChanceFinal), null); } if (inc2 != null && inc2.TargetAllowed(< MakeIntervalIncidents > c__AnonStorey.target)) { FiringIncident fi = new FiringIncident(inc2, this, null); fi.parms = this.GenerateParms(inc2.category, <MakeIntervalIncidents> c__AnonStorey.target); fi.parms.points = 40f; fi.parms.raidForceOneIncap = true; fi.parms.raidNeverFleeIndividual = true; this.$current = fi; if (!this.$disposing) { this.$PC = 4; } return(true); } } IL_41A: this.$PC = -1; return(false); }
public override IEnumerable<FiringIncident> MakeIntervalIncidents(IIncidentTarget target) { _003CMakeIntervalIncidents_003Ec__Iterator0 _003CMakeIntervalIncidents_003Ec__Iterator = (_003CMakeIntervalIncidents_003Ec__Iterator0)/*Error near IL_003e: stateMachine*/; if (target == Find.Maps.Find((Map x) => x.IsPlayerHome)) { if (IntervalsPassed == 150) { IncidentDef inc2 = IncidentDefOf.VisitorGroup; if (inc2.TargetAllowed(target)) { yield return new FiringIncident(inc2, this) { parms = { target = target, points = (float)Rand.Range(40, 100) } }; /*Error: Unable to find new state assignment for yield return*/; } } if (IntervalsPassed == 204) { _003CMakeIntervalIncidents_003Ec__Iterator0 _003CMakeIntervalIncidents_003Ec__Iterator2 = (_003CMakeIntervalIncidents_003Ec__Iterator0)/*Error near IL_015f: stateMachine*/; IncidentCategoryDef threatCategory = (!Find.Storyteller.difficulty.allowIntroThreats) ? IncidentCategoryDefOf.Misc : IncidentCategoryDefOf.ThreatSmall; if ((from def in DefDatabase<IncidentDef>.AllDefs where def.TargetAllowed(target) && def.category == threatCategory select def).TryRandomElementByWeight(base.IncidentChanceFinal, out IncidentDef incDef2)) { yield return new FiringIncident(incDef2, this) { parms = StorytellerUtility.DefaultParmsNow(incDef2.category, target) }; /*Error: Unable to find new state assignment for yield return*/; } } if (IntervalsPassed == 264 && (from def in DefDatabase<IncidentDef>.AllDefs where def.TargetAllowed(target) && def.category == IncidentCategoryDefOf.Misc select def).TryRandomElementByWeight(base.IncidentChanceFinal, out IncidentDef incDef)) { yield return new FiringIncident(incDef, this) { parms = StorytellerUtility.DefaultParmsNow(incDef.category, target) }; /*Error: Unable to find new state assignment for yield return*/; } if (IntervalsPassed == 324) { IncidentDef inc = IncidentDefOf.RaidEnemy; if (!Find.Storyteller.difficulty.allowIntroThreats) { inc = (from def in DefDatabase<IncidentDef>.AllDefs where def.TargetAllowed(target) && def.category == IncidentCategoryDefOf.Misc select def).RandomElementByWeightWithFallback(base.IncidentChanceFinal); } if (inc != null && inc.TargetAllowed(target)) { FiringIncident fi = new FiringIncident(inc, this); fi.parms = GenerateParms(inc.category, target); fi.parms.points = 40f; fi.parms.raidForceOneIncap = true; fi.parms.raidNeverFleeIndividual = true; yield return fi; /*Error: Unable to find new state assignment for yield return*/; } } } }
public QueuedIncident(FiringIncident firingInc, int fireTick) { this.firingInc = firingInc; this.fireTick = fireTick; }
public QueuedIncident(FiringIncident firingInc, int fireTick, int retryDurationTicks = 0) { this.firingInc = firingInc; this.fireTick = fireTick; this.retryDurationTicks = retryDurationTicks; }