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;
}
