public override void Generate(Map map, GenStepParams parms)
{
float num = this.pointsRange.RandomInRange;
List <Pawn> list = new List <Pawn>();
for (int i = 0; i < 50; i++)
{
PawnKindDef pawnKindDef;
if (!ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(this.pointsRange.RandomInRange, map.Tile, out pawnKindDef))
{
return;
}
list.Add(PawnGenerator.GeneratePawn(pawnKindDef, null));
num -= pawnKindDef.combatPower;
if (num <= 0f)
{
break;
}
}
for (int j = 0; j < list.Count; j++)
{
IntVec3 intVec;
if (CellFinderLoose.TryGetRandomCellWith((IntVec3 x) => x.Standable(map) && x.Fogged(map) && GridsUtility.GetRoom(x, map, RegionType.Set_Passable).CellCount >= 4, map, 1000, out intVec))
{
IntVec3 intVec2 = CellFinder.RandomSpawnCellForPawnNear(intVec, map, 10);
GenSpawn.Spawn(list[j], intVec2, map, Rot4.Random, WipeMode.Vanish, false);
list[j].mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.ManhunterPermanent, null, false, false, null);
}
}
}
protected override bool TryExecuteWorker(IncidentParms parms)
{
if (!settings.Active)
{
return(false);
}
Map map = (Map)parms.target;
if (!ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(parms.points, map.Tile, out PawnKindDef animalKind))
{
return(false);
}
if (!FindHomeAreaCell(map, out IntVec3 result))
{
return(false);
}
parms.points = StorytellerUtility.DefaultThreatPointsNow(parms.target);
animals = GetAnimals(animalKind, map, parms.points);
DropPodUtilityPlus.DropThingsNear(result, map, animals, callback: DriveInsane);
SendStandardLetter(parms, null);
return(true);
}
protected override bool TryExecuteWorker(IncidentParms parms)
{
Map map = (Map)parms.target;
PawnKindDef pawnKindDef = PawnKindDef.Named("AA_ArcticLion");
IntVec3 intVec;
if (!RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Animal))
{
return(false);
}
List <Pawn> list = ManhunterPackIncidentUtility.GenerateAnimals(pawnKindDef, map.Tile, 300);
Rot4 rot = Rot4.FromAngleFlat((map.Center - intVec).AngleFlat);
for (int i = 0; i < list.Count; i++)
{
Pawn pawn = list[i];
IntVec3 loc = CellFinder.RandomClosewalkCellNear(intVec, map, 10, null);
GenSpawn.Spawn(pawn, loc, map, rot, WipeMode.Vanish, false);
pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.ManhunterPermanent, null, false, false, null, false);
pawn.mindState.exitMapAfterTick = Find.TickManager.TicksGame + Rand.Range(60000, 120000);
pawn.health.AddHediff(HediffDef.Named("AA_InvisibleArcticLion"));
}
Find.LetterStack.ReceiveLetter("LetterLabelManhuntingArcticLion".Translate(), "ManhuntingArcticLion".Translate(), LetterDefOf.ThreatBig, null, null, null);
Find.TickManager.slower.SignalForceNormalSpeedShort();
return(true);
}
protected override bool TryExecuteWorker(IncidentParms parms)
{
var map = (Map)parms.target;
if (!ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(parms.points, map.Tile, out var pawnKindDef))
{
return(false);
}
if (!RCellFinder.TryFindRandomPawnEntryCell(out var intVec, map, CellFinder.EdgeRoadChance_Animal))
{
return(false);
}
var list = ManhunterPackIncidentUtility.GenerateAnimals(pawnKindDef, map.Tile, parms.points * 0.2f);
var rot = Rot4.FromAngleFlat((map.Center - intVec).AngleFlat);
for (var i = 0; i < list.Count; i++)
{
var deviljho = PawnKindDefOf.Deviljho;
var pawn = PawnGenerator.GeneratePawn(deviljho);
var loc = CellFinder.RandomClosewalkCellNear(intVec, map, 10);
GenSpawn.Spawn(pawn, loc, map, rot);
pawn.mindState.exitMapAfterTick = Find.TickManager.TicksGame + Rand.Range(60000, 135000);
}
Find.LetterStack.ReceiveLetter("LetterLabelDeviljho".Translate(),
"Deviljholetter".Translate(pawnKindDef.GetLabelPlural()), LetterDefOf.ThreatBig, list[0]);
Find.TickManager.slower.SignalForceNormalSpeedShort();
LessonAutoActivator.TeachOpportunity(ConceptDefOf.ForbiddingDoors, OpportunityType.Critical);
LessonAutoActivator.TeachOpportunity(ConceptDefOf.AllowedAreas, OpportunityType.Important);
return(true);
}
protected override bool TryExecuteWorker(IncidentParms parms)
{
Map map = (Map)parms.target;
PawnKindDef bossKind = def.pawnKind;
PawnKindDef animalKind = GetAnimalKind(parms.points, map.Tile);
if (bossKind == null || animalKind == null || ManhunterPackIncidentUtility.GetAnimalsCount(animalKind, (parms.points * PointsFactor) - bossKind.combatPower) <= 0)
{
return(false);
}
IntVec3 result = parms.spawnCenter;
if (!result.IsValid && !RCellFinder.TryFindRandomPawnEntryCell(out result, map, CellFinder.EdgeRoadChance_Animal))
{
return(false);
}
List <Pawn> list = ManhunterPackIncidentUtility.GenerateAnimals(bossKind, map.Tile, bossKind.combatPower, 1);
list.AddRange(ManhunterPackIncidentUtility.GenerateAnimals(animalKind, map.Tile, (parms.points * PointsFactor) - bossKind.combatPower, parms.pawnCount));
Rot4 rot = Rot4.FromAngleFlat((map.Center - result).AngleFlat);
for (int i = 0; i < list.Count; i++)
{
Pawn pawn = list[i];
IntVec3 loc = CellFinder.RandomClosewalkCellNear(result, map, 10);
QuestUtility.AddQuestTag(GenSpawn.Spawn(pawn, loc, map, rot), parms.questTag);
pawn.health.AddHediff(HediffDefOf.Scaria);
pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.ManhunterPermanent);
pawn.mindState.exitMapAfterTick = Find.TickManager.TicksGame + Rand.Range(AnimalsStayDurationMin, AnimalsStayDurationMax);
}
TaggedString labelString = null;
if (def.letterLabel != null)
{
labelString = def.letterLabel;
}
else
{
labelString = "LetterLabelManhunterPackArrived".Translate();
}
TaggedString textString = null;
if (def.letterText != null)
{
textString = def.letterText;
}
else
{
textString = "ManhunterPackArrived".Translate(animalKind.GetLabelPlural());
}
SendStandardLetter(labelString, textString, LetterDefOf.ThreatBig, parms, list[0]);
Find.TickManager.slower.SignalForceNormalSpeedShort();
LessonAutoActivator.TeachOpportunity(ConceptDefOf.ForbiddingDoors, OpportunityType.Critical);
LessonAutoActivator.TeachOpportunity(ConceptDefOf.AllowedAreas, OpportunityType.Important);
return(true);
}
protected void CaravanAmbushManhuntersNoTreasure(Caravan caravan)
{
LongEventHandler.QueueLongEvent(delegate
{
IncidentParms incidentParms = StorytellerUtility.DefaultParmsNow(IncidentCategoryDefOf.ThreatBig, caravan);
//make sure a minimum point threshold is hit
if (incidentParms.points < MinimumPointThreshold)
{
incidentParms.points = MinimumPointThreshold;
}
PawnKindDef animalKind;
if (!ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(this.AdjustedPoints(incidentParms.points), incidentParms.target.Tile, out animalKind) && !ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(this.AdjustedPoints(incidentParms.points), -1, out animalKind))
{
Log.Warning("Could not find any valid animal kind for " + this.def + " incident. Going with Wargs", false);
animalKind = ThingDefOfVanilla.Warg;
}
List <Pawn> list = ManhunterPackIncidentUtility.GenerateAnimals(animalKind, incidentParms.target.Tile, this.AdjustedPoints(incidentParms.points));
Map map = CaravanIncidentUtility.SetupCaravanAttackMap(caravan, list, false);
for (int i = 0; i < list.Count; i++)
{
list[i].mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.ManhunterPermanent, null, false, false, null, false);
}
Find.TickManager.CurTimeSpeed = TimeSpeed.Paused;
GlobalTargetInfo lookTarget = (!list.Any <Pawn>()) ? GlobalTargetInfo.Invalid : new GlobalTargetInfo(list[0].Position, map, false);
Find.LetterStack.ReceiveLetter("LetterLabelIMAmbushLGE".Translate(), "LetterIMAmbushLGE".Translate(), LetterDefOf.ThreatBig, lookTarget, null);
}, "GeneratingMapForNewEncounter", false, null);
}
protected void TreasureWithManhunters(Caravan caravan)
{
List <Thing> rewardList = GenerateReward();
for (int i = 0; i < rewardList.Count; i++)
{
caravan.AddPawnOrItem(rewardList[i], true);
}
LongEventHandler.QueueLongEvent(delegate
{
IncidentParms incidentParms = StorytellerUtility.DefaultParmsNow(IncidentCategoryDefOf.ThreatBig, caravan);
//make sure a minimum point threshold is hit
if (incidentParms.points < MinimumPointThreshold)
{
incidentParms.points = MinimumPointThreshold + 100f;
}
PawnKindDef animalKind;
if (!ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(this.AdjustedPoints(incidentParms.points), incidentParms.target.Tile, out animalKind) && !ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(this.AdjustedPoints(incidentParms.points), -1, out animalKind))
{
Log.Warning("Could not find any valid animal kind for " + this.def + " incident. Going with Wargs", false);
animalKind = ThingDefOfVanilla.Warg;
}
List <Pawn> pawnList = ManhunterPackIncidentUtility.GenerateAnimals(animalKind, incidentParms.target.Tile, this.AdjustedPoints(incidentParms.points));
Map map = CaravanIncidentUtility.SetupCaravanAttackMap(caravan, pawnList, false);
for (int i = 0; i < pawnList.Count; i++)
{
pawnList[i].mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.ManhunterPermanent, null, false, false, null, false);
}
Find.TickManager.CurTimeSpeed = TimeSpeed.Paused;
GlobalTargetInfo lookTarget = (!pawnList.Any <Pawn>()) ? GlobalTargetInfo.Invalid : new GlobalTargetInfo(pawnList[0].Position, map, false);
Find.LetterStack.ReceiveLetter("LetterLabelTreasureAmbushLGE".Translate(), "LetterTreasureAmbushLGE".Translate(GenThing.GetMarketValue(rewardList).ToStringMoney(null), GenLabel.ThingsLabel(rewardList, string.Empty)), LetterDefOf.ThreatBig, lookTarget, null);
}, "GeneratingMapForNewEncounter", false, null);
}
static bool Prefix(ref bool __result, float points, int tile, out PawnKindDef animalKind)
{
MapExtensions.TileLookup.TryGetValue(tile, out Map map);
bool flag = DefDatabase <PawnKindDef> .AllDefs.Where(
(PawnKindDef k) =>
k.RaceProps.Animal && k.canArriveManhunter &&
(tile == -1 || Find.World.tileTemperatures.SeasonAndOutdoorTemperatureAcceptableFor(tile, k.race)) &&
(map == null || map.PawnKindCanEnter(k))
).TryRandomElementByWeight(
(PawnKindDef k) => ManhunterPackIncidentUtility.ManhunterAnimalWeight(k, points), out animalKind);
if (!flag)
{
List <PawnKindDef> tmpAnimalKinds = new List <PawnKindDef>();
tmpAnimalKinds.AddRange(DefDatabase <PawnKindDef> .AllDefs.Where((PawnKindDef k) => k.RaceProps.Animal && k.canArriveManhunter && map.PawnKindCanEnter(k)));
tmpAnimalKinds.Sort((PawnKindDef a, PawnKindDef b) => b.combatPower.CompareTo(a.combatPower));
animalKind = tmpAnimalKinds.Take(Math.Max(2, Mathf.FloorToInt(0.15f * (float)tmpAnimalKinds.Count))).RandomElement();
__result = animalKind != null;
}
else
{
__result = flag;
}
return(false);
}
protected override bool TryExecuteWorker(IncidentParms parms)
{
Map map = (Map)parms.target;
IntVec3 intVec;
if (!RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Animal, false, null))
{
Helper.Log($"Cant fire custom manhunter. No edge road chance entry cell");
return(false);
}
int count = ManhunterPackIncidentUtility.GetAnimalsCount(PawnKindDef, parms.points);
ToolkitPatchLogger.Log(LOGGER_NAME, $"Spawning {count} beasts based {parms.points}");
for (int i = 0; i < count; i++)
{
var loc = CellFinder.RandomClosewalkCellNear(intVec, map, 12, null);
var pawn = PawnGenerator.GeneratePawn(PawnKindDef, null);
GenSpawn.Spawn(pawn, loc, map, Rot4.Random, WipeMode.Vanish, false);
pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.Manhunter);
}
var text = "CustomManhunterEnteringLabel".Translate(PawnKindDef.GetLabelPlural(-1));
Find.LetterStack.ReceiveLetter("CustomManhunterStoriesLetterLabel".Translate(), text, LetterDefOf.NegativeEvent, new TargetInfo(intVec, map, false), null, null);
return(true);
}
// Token: 0x0600000E RID: 14 RVA: 0x0000221C File Offset: 0x0000041C
protected override bool TryExecuteWorker(IncidentParms parms)
{
Map map = (Map)parms.target;
PawnKindDef named = DefDatabase <PawnKindDef> .GetNamed("KillerRabbit", true);
IntVec3 intVec;
bool flag = !RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Animal, false, null);
bool result;
if (flag)
{
result = false;
}
else
{
List <Pawn> list = ManhunterPackIncidentUtility.GenerateAnimals(named, map.Tile, parms.points * 1f);
Rot4 rot = Rot4.FromAngleFlat((map.Center - intVec).AngleFlat);
for (int i = 0; i < list.Count; i++)
{
Pawn pawn = list[i];
IntVec3 loc = CellFinder.RandomClosewalkCellNear(intVec, map, 10, null);
GenSpawn.Spawn(pawn, loc, map, rot, WipeMode.Vanish, false);
pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.ManhunterPermanent, null, false, false, null, false);
pawn.mindState.exitMapAfterTick = Find.TickManager.TicksGame + Rand.Range(60000, 120000);
}
Find.LetterStack.ReceiveLetter(Translator.Translate("LetterLabelManhunterPackArrived"), TranslatorFormattedStringExtensions.Translate("ManhunterPackArrived", named.GetLabelPlural(-1)), LetterDefOf.ThreatBig, list[0], null, null);
Find.TickManager.slower.SignalForceNormalSpeedShort();
LessonAutoActivator.TeachOpportunity(ConceptDefOf.ForbiddingDoors, OpportunityType.Critical);
LessonAutoActivator.TeachOpportunity(ConceptDefOf.AllowedAreas, OpportunityType.Important);
result = true;
}
return(result);
}
public override bool IsPossible(string message, Viewer viewer, bool separateChannel = false)
{
this.separateChannel = separateChannel;
this.viewer = viewer;
string[] command = message.Split(' ');
if (command.Length < 4)
{
Toolkit.client.SendMessage($"@{viewer.username} syntax is {this.storeIncident.syntax}", separateChannel);
return(false);
}
if (!VariablesHelpers.PointsWagerIsValid(
command[3],
viewer,
ref pointsWager,
ref storeIncident,
separateChannel
))
{
return(false);
}
string animalKind = command[2].ToLower();
List <PawnKindDef> allAnimals = DefDatabase <PawnKindDef> .AllDefs.Where(
s => s.RaceProps.Animal &&
string.Join("", s.defName.Split(' ')).ToLower() == animalKind
).ToList();
if (allAnimals.Count < 1)
{
Toolkit.client.SendMessage($"@{viewer.username} no animal {animalKind} found.", separateChannel);
return(false);
}
target = Current.Game.AnyPlayerHomeMap;
if (target == null)
{
return(false);
}
float points = IncidentHelper_PointsHelper.RollProportionalGamePoints(storeIncident, pointsWager, StorytellerUtility.DefaultThreatPointsNow(target));
pawnKind = allAnimals[0];
int num = ManhunterPackIncidentUtility.GetAnimalsCount(pawnKind, points);
worker = new IncidentWorker_SpecificAnimalsWanderIn(null, pawnKind, true, num, false, true);
worker.def = IncidentDef.Named("FarmAnimalsWanderIn");
float defaultThreatPoints = StorytellerUtility.DefaultSiteThreatPointsNow();
parms = StorytellerUtility.DefaultParmsNow(worker.def.category, target);
parms.points = points;
return(worker.CanFireNow(parms));
}
protected override List <Pawn> GeneratePawns(IncidentParms parms)
{
PawnKindDef animalKind;
if (!ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(this.AdjustedPoints(parms.points), parms.target.Tile, out animalKind) && !ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(this.AdjustedPoints(parms.points), -1, out animalKind))
{
Log.Error("Could not find any valid animal kind for " + this.def + " incident.", false);
return(new List <Pawn>());
}
return(ManhunterPackIncidentUtility.GenerateAnimals(animalKind, parms.target.Tile, this.AdjustedPoints(parms.points)));
}
protected override bool CanFireNowSub(IncidentParms parms)
{
if (!base.CanFireNowSub(parms))
{
return(false);
}
Map map = (Map)parms.target;
PawnKindDef pawnKindDef;
IntVec3 intVec;
return(ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(parms.points, map.Tile, out pawnKindDef) && RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Animal, false, null));
}
protected override void RunInt()
{
Slate slate = QuestGen.slate;
Map map = QuestGen.slate.Get <Map>("map");
float points = QuestGen.slate.Get("points", 0f);
QuestPart_Incident questPart_Incident = new QuestPart_Incident();
questPart_Incident.incident = IncidentDefOf.ManhunterPack;
IncidentParms incidentParms = new IncidentParms();
incidentParms.forced = true;
incidentParms.target = map;
incidentParms.points = points;
incidentParms.questTag = QuestGenUtility.HardcodedTargetQuestTagWithQuestID(tag.GetValue(slate));
incidentParms.spawnCenter = walkInSpot.GetValue(slate) ?? QuestGen.slate.Get <IntVec3?>("walkInSpot") ?? IntVec3.Invalid;
incidentParms.pawnCount = animalCount.GetValue(slate);
if (ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(points, map.Tile, out var animalKind))
{
incidentParms.pawnKind = animalKind;
}
slate.Set("animalKindDef", animalKind);
int num = ((incidentParms.pawnCount > 0) ? incidentParms.pawnCount : ManhunterPackIncidentUtility.GetAnimalsCount(animalKind, points));
QuestGen.slate.Set("animalCount", num);
if (!customLetterLabel.GetValue(slate).NullOrEmpty() || customLetterLabelRules.GetValue(slate) != null)
{
QuestGen.AddTextRequest("root", delegate(string x)
{
incidentParms.customLetterLabel = x;
}, QuestGenUtility.MergeRules(customLetterLabelRules.GetValue(slate), customLetterLabel.GetValue(slate), "root"));
}
if (!customLetterText.GetValue(slate).NullOrEmpty() || customLetterTextRules.GetValue(slate) != null)
{
QuestGen.AddTextRequest("root", delegate(string x)
{
incidentParms.customLetterText = x;
}, QuestGenUtility.MergeRules(customLetterTextRules.GetValue(slate), customLetterText.GetValue(slate), "root"));
}
questPart_Incident.SetIncidentParmsAndRemoveTarget(incidentParms);
questPart_Incident.inSignal = QuestGenUtility.HardcodedSignalWithQuestID(inSignal.GetValue(slate)) ?? QuestGen.slate.Get <string>("inSignal");
QuestGen.quest.AddPart(questPart_Incident);
List <Rule> rules = new List <Rule>
{
new Rule_String("animalKind_label", animalKind.label),
new Rule_String("animalKind_labelPlural", animalKind.GetLabelPlural(num))
};
QuestGen.AddQuestDescriptionRules(rules);
QuestGen.AddQuestNameRules(rules);
}
// Token: 0x0600000D RID: 13 RVA: 0x000021A8 File Offset: 0x000003A8
protected override bool CanFireNowSub(IncidentParms parms)
{
//Log.Message("base: " + base.CanFireNowSub(parms) + " enabled: " + GrenadesExpendedMod.rabbitincident);
if (!base.CanFireNowSub(parms) || !GrenadesExpendedMod.rabbitincident)
{
return(false);
}
Map map = (Map)parms.target;
PawnKindDef named = DefDatabase <PawnKindDef> .GetNamed("KillerRabbit", true);
IntVec3 intVec;
return(ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(parms.points, map.Tile, out named) && RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Animal, false, null));
}
private void GenerateAnimals(Faction faction, List <Pawn> pawns, Map map, float points)
{
int numOfAnimals = (int)(pawns.Count * 0.7f);
float min = Mathf.Clamp(points * 0.35f, 100, 800);
FloatRange pointsRange = new FloatRange(min, Mathf.Clamp(points * 0.6f, min + 100, 2000));
for (int i = 0; i < numOfAnimals; i++)
{
if (ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(pointsRange.RandomInRange, map.Tile, out PawnKindDef animalKind))
{
PawnGenerationRequest request = new PawnGenerationRequest(animalKind, faction, PawnGenerationContext.NonPlayer);
Pawn item = PawnGenerator.GeneratePawn(request);
pawns.Add(item);
}
}
}
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);
}
public override bool ManualDeterminParams()
{
Map map = (Map)parms.target;
if (!ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(parms.points, map.Tile, out AnimalType))
{
return(false);
}
if (!RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Animal, false, null))
{
return(false);
}
pawnList = ManhunterPackIncidentUtility.GenerateAnimals(AnimalType, map.Tile, parms.points * 1f);
AnimalNum = pawnList.Count;
lookTargets = new TargetInfo(intVec, map, false);
return(true);
}
private List <Thing> GetAnimals(PawnKindDef animalKind, Map map, float points)
{
List <Thing> animals = new List <Thing>();
List <Pawn> pawns = ManhunterPackIncidentUtility.GenerateAnimals(animalKind, map.Tile, points * 1f);
foreach (var pawn in pawns)
{
if (animals.Count >= 30)
{
break;
}
animals.Add(pawn);
}
return(animals);
}
static bool Prefix(ref IncidentParms parms)
{
Map map = (Map)parms.target;
// Set downstream methods to toggle on preferences for avoiding deep water
PawnKindDef animalKind = parms.pawnKind;
if ((animalKind == null && !ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(parms.points, map.Tile, out animalKind)) || ManhunterPackIncidentUtility.GetAnimalsCount(animalKind, parms.points) == 0)
{
return(true);
}
// Set the animal manually since we need to know ahead of time to determine if it swims
parms.pawnKind = animalKind;
// Check if the animal involved prefers to swim over walk
if (animalKind.race.GetStatValueAbstract(StatDefOf.MoveSpeed) >= animalKind.race.GetStatValueAbstract(StatDef.Named(SwimmingLoader.SwimStat)) + 0.001)
{
DeepWaterNotPreferredForTryFindRandomPawnEntryCell.PreferNonDeepWater = true;
}
return(true);
}
protected virtual PawnKindDef GetAnimalKind(float points, int tile)
{
PawnKindDef result = null;
if (result == null && def is IncidentDefExpanded)
{
List <PawnKindDef> pawnKindDefs = (def as IncidentDefExpanded).pawnKinds;
if (pawnKindDefs != null && pawnKindDefs.Count > 0)
{
result = pawnKindDefs.RandomElement();
}
}
if (result == null)
{
ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(points, tile, out result);
}
return(result);
}
protected override bool TryExecuteWorker(IncidentParms parms)
{
Map map = (Map)parms.target;
PawnKindDef pawnKindDef;
if (!ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(parms.points, map.Tile, out pawnKindDef))
{
return(false);
}
IntVec3 intVec;
if (!RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Animal, false, null))
{
return(false);
}
List <Pawn> list = ManhunterPackIncidentUtility.GenerateAnimals(pawnKindDef, map.Tile, parms.points * 1f);
Rot4 rot = Rot4.FromAngleFlat((map.Center - intVec).AngleFlat);
for (int i = 0; i < list.Count; i++)
{
Pawn pawn = list[i];
IntVec3 loc = CellFinder.RandomClosewalkCellNear(intVec, map, 10, null);
GenSpawn.Spawn(pawn, loc, map, rot, WipeMode.Vanish, false);
pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.ManhunterPermanent, null, false, false, null, false);
pawn.mindState.exitMapAfterTick = Find.TickManager.TicksGame + Rand.Range(60000, 120000);
}
var text = "ManhunterPackArrived".Translate(pawnKindDef.GetLabelPlural(-1));
if (Quote != null)
{
text += "\n\n";
text += Helper.ReplacePlaceholder(Quote, animal: pawnKindDef.GetLabelPlural(-1));
}
Find.LetterStack.ReceiveLetter("LetterLabelManhunterPackArrived".Translate(), text, LetterDefOf.ThreatBig, list[0], null, null);
Find.TickManager.slower.SignalForceNormalSpeedShort();
LessonAutoActivator.TeachOpportunity(ConceptDefOf.ForbiddingDoors, OpportunityType.Critical);
LessonAutoActivator.TeachOpportunity(ConceptDefOf.AllowedAreas, OpportunityType.Important);
return(true);
}
protected override bool CanFireNowSub(IncidentParms parms)
{
PawnKindDef pawnKindDef;
return(base.CanFireNowSub(parms) && ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(this.AdjustedPoints(parms.points), -1, out pawnKindDef));
}
protected override bool TryExecuteWorker(IncidentParms parms)
{
Map map = (Map)parms.target;
float totalPoints = parms.points / 2;
HashSet <PawnKindDef> hybridsList;
if (StaticCollectionsClass.AnyMechAntennas())
{
hybridsList = DefDatabase <PawnKindDef> .AllDefsListForReading.Where(x => (x.race.tradeTags?.Contains("AnimalGenetic") == true) && (x.race.tradeTags?.Contains("AnimalGeneticFailure") == false) && (x.race.tradeTags?.Contains("AnimalGeneticCentipede") == false)).ToHashSet();
}
else
{
hybridsList = DefDatabase <PawnKindDef> .AllDefsListForReading.Where(x => (x.race.tradeTags?.Contains("AnimalGenetic") == true) && (x.race.tradeTags?.Contains("AnimalGeneticFailure") == false) && (x.race.tradeTags?.Contains("AnimalGeneticMechanoid") == false)).ToHashSet();
}
List <Pawn> list = new List <Pawn>();
PawnKindDef firstPawn;
hybridsList.TryRandomElementByWeight((PawnKindDef a) => ManhunterPackIncidentUtility.ManhunterAnimalWeight(a, parms.points), out firstPawn);
IntVec3 result = parms.spawnCenter;
if (firstPawn != null)
{
if (!result.IsValid && !RCellFinder.TryFindRandomPawnEntryCell(out result, map, CellFinder.EdgeRoadChance_Animal))
{
return(false);
}
Pawn item = PawnGenerator.GeneratePawn(new PawnGenerationRequest(firstPawn, null, PawnGenerationContext.NonPlayer, map.Tile));
list.Add(item);
totalPoints -= item.kindDef.combatPower;
while (totalPoints > 0)
{
PawnKindDef nextPawn;
hybridsList.TryRandomElementByWeight((PawnKindDef a) => ManhunterPackIncidentUtility.ManhunterAnimalWeight(a, totalPoints), out nextPawn);
Pawn nextitem = PawnGenerator.GeneratePawn(new PawnGenerationRequest(nextPawn, null, PawnGenerationContext.NonPlayer, map.Tile));
list.Add(nextitem);
totalPoints -= nextitem.kindDef.combatPower;
}
}
Rot4 rot = Rot4.FromAngleFlat((map.Center - result).AngleFlat);
for (int i = 0; i < list.Count; i++)
{
Pawn pawn = list[i];
IntVec3 loc = CellFinder.RandomClosewalkCellNear(result, map, 10);
QuestUtility.AddQuestTag(GenSpawn.Spawn(pawn, loc, map, rot), parms.questTag);
pawn.health.AddHediff(InternalDefOf.GR_GreaterScaria);
pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.ManhunterPermanent);
CompHybrid compHybrid = pawn.TryGetComp <CompHybrid>();
if (compHybrid != null)
{
compHybrid.quality = QualityUtility.GenerateQualityRandomEqualChance();
}
}
SendStandardLetter("GR_LetterLabelMonstrositiesArrived".Translate(), "GR_LetterMonstrositiesArrived".Translate(), LetterDefOf.ThreatBig, parms, list[0]);
Find.TickManager.slower.SignalForceNormalSpeedShort();
return(true);
}
