private Faction DoNewFaction()
{
Faction faction = new Faction();
faction.def = Faction.def;
faction.colorFromSpectrum = FactionGenerator.NewRandomColorFromSpectrum(faction);
faction.Name = NameGenerator.GenerateName(faction.def.factionNameMaker, from fac in Find.FactionManager.AllFactionsVisible
select fac.Name);
faction.centralMelanin = Rand.Value;
foreach (Faction item in Find.FactionManager.AllFactions)
{
faction.TryMakeInitialRelationsWith(item);
}
Pawn p = PawnGenerator.GeneratePawn(PawnKindDefOf.AncientSoldier);
string leaderName = p.Name.ToStringFull;
faction.GenerateNewLeader();
faction.leader.Name = new NameSingle(leaderName, true);
faction.loadID = Find.UniqueIDsManager.GetNextFactionID();
Find.FactionManager.Add(faction);
return(faction);
}
protected void ValidateVariables(IncidentParms parms)
{
Map map = (Map)parms.target;
if (BossFightDefOf.AllowedBossKinds == null)
{
BossFightDefOf.AllowedBossKinds = DefDatabase <PawnKindDef> .AllDefs.Where(def =>
def.RaceProps?.Animal ?? false && CombatPowerCalculator.BodyMoveCoverages.Keys.Contains(def.RaceProps?.body?.defName)
).ToList();
}
if (BossFightDefOf.AllowedBossDefs == null)
{
BossFightDefOf.AllowedBossDefs = new List <ThingDef>(DefDatabase <ThingDef> .AllDefs.Where(def =>
def.race?.Animal ?? false && CombatPowerCalculator.BodyMoveCoverages.Keys.Contains(def.race?.body?.defName))
);
}
//fix for having different factions across different games in same playthrough
faction = Find.FactionManager.FirstFactionOfDef(BossFightDefOf.BossFaction);
if (faction == null)
{
faction = FactionGenerator.NewGeneratedFaction(BossFightDefOf.BossFaction);
Find.FactionManager.Add(faction);
map.pawnDestinationReservationManager.RegisterFaction(faction);
}
bossLord = Find.VisibleMap.lordManager.lords.FirstOrDefault(lord => lord == bossLord);
if (bossLord == null)
{
bossLord = LordMaker.MakeNewLord(faction, new LordJob_BossAssault(faction), (Map)parms.target);
map.lordManager.AddLord(bossLord);
}
}
private void SendDrop()
{
GenDate.DayOfYear(ticks, Find.WorldGrid.LongLatOf(map.Tile).x);
List <Thing> thingList = new List <Thing>();
thingList.Add(ThingMaker.MakeThing(AvaliDefs.AvaliNexus));
Scribe_Values.Look(ref hasDropped, "hasDropped", false);
Map target = map;
List <Faction> newFactions = new List <Faction>();
IntVec3 intVec3 = DropCellFinder.TradeDropSpot(target);
if (RimValiUtility.PawnOfRaceCount(Faction.OfPlayer, AvaliDefs.RimVali) >= 5 && !hasDropped)
{
hasDropped = true;
for (int a = 0; a < random.Next(2, 5); a++)
{
Faction faction = FactionGenerator.NewGeneratedFaction(AvaliDefs.AvaliFaction);
faction.Name = "IlluminateFactionName".Translate() + ": #" + a.ToString();
faction.SetRelationDirect(Faction.OfPlayer, FactionRelationKind.Ally);
newFactions.Add(faction);
}
DropPodUtility.DropThingsNear(intVec3, target, (IEnumerable <Thing>)thingList);
ChoiceLetter choiceLetter = LetterMaker.MakeLetter("IlluminateAirdrop".Translate(), "AirdropEventDesc".Translate(), AvaliMod.AvaliDefs.IlluminateAirdrop, newFactions[random.Next(newFactions.Count)]);
Find.LetterStack.ReceiveLetter(choiceLetter, null);
}
}
public override void OnComplete()
{
var faction = Find.FactionManager.RandomNonHostileFaction(minTechLevel: TechLevel.Industrial);
if (faction == null)
{
faction = FactionGenerator.NewGeneratedFaction();
}
faction.TryAffectGoodwillWith(Faction.OfPlayer, 50);
target.Faction.TryAffectGoodwillWith(Faction.OfPlayer, -50);
faction.TryAffectGoodwillWith(target.Faction, -200);
target.SetFaction(faction);
var map = target.Map;
if (map == null)
{
return;
}
var storyComp = Find.Storyteller.storytellerComps.First(x => x is StorytellerComp_OnOffCycle || x is StorytellerComp_RandomMain);
var parms = storyComp.GenerateParms(IncidentCategoryDefOf.ThreatBig, map);
parms.faction = faction;
parms.raidStrategy = RaidStrategyDefOf.ImmediateAttack;
parms.raidArrivalMode = PawnsArrivalModeDefOf.EdgeWalkIn;
parms.raidArrivalModeForQuickMilitaryAid = true;
parms.points = 4000;
IncidentDefOf.RaidFriendly.Worker.TryExecute(parms);
}
public override void LoadedGame()
{
base.LoadedGame();
PurpleIvyData.TotalFogProgress = new Dictionary <WorldObjectComp_InfectedTile, float>();
PurpleIvyData.TotalPollutedBiomes = new List <int>();
foreach (var worldObject in Find.WorldObjects.AllWorldObjects)
{
var comp = worldObject.GetComponent <WorldObjectComp_InfectedTile>();
if (comp != null)
{
PurpleIvyData.TotalFogProgress[comp] = PurpleIvyUtils.getFogProgress(comp.counter);
//comp.fillRadius(forced: true); // causes crash when loading a save with infected sites
}
}
for (int i = 0; i < Find.WorldGrid.TilesCount; i++)
{
if (Find.WorldGrid[i].biome.defName.Contains("PI_"))
{
PurpleIvyData.TotalPollutedBiomes.Add(i);
}
}
if (Find.FactionManager.AllFactions.Where(x => x.def == PurpleIvyDefOf.Genny).Count() == 0)
{
Log.Message("No alien faction in the game, fixing it");
Faction faction = FactionGenerator.NewGeneratedFaction(PurpleIvyDefOf.Genny);
faction.TrySetRelationKind(Faction.OfPlayer, FactionRelationKind.Hostile, false, null, null);
Find.FactionManager.Add(faction);
}
}
public static void FactionManagerPostLoadInit()
{
if (ModsConfig.RoyaltyActive && Find.FactionManager.FirstFactionOfDef(FactionDefOf.Empire) == null)
{
Faction faction = FactionGenerator.NewGeneratedFaction(FactionDefOf.Empire);
Find.FactionManager.Add(faction);
}
}
public void SetPlayerFactionVarsToNewGeneratedFaction(FactionDef def)
{
var generatedFaction = FactionGenerator.NewGeneratedFaction(def);
generatedFaction.loadID = this.WorldData.FactionManager.OfPlayer.loadID;
SetFactionVars(generatedFaction, this.WorldData.FactionManager.OfPlayer, FactionMode.Reset, true);
}
private void GiveRewardsAndSendLetter(bool giveTech, bool newFaction)
{
string text = "RD_GratefulSurvivors".Translate();
string text2 = "RD_GratefulSurvivorsDesc".Translate(); //"The survivors of the crash are very thankful for your help, and have send some supplies as a gesture of gratitude.";
if (giveTech)
{
ThingDef.Named("Gun_ChargeRifle");
ThingDef thingDef = this.RandomHiTechReward();
ThingDef stuff = null;
if (thingDef.MadeFromStuff)
{
stuff = GenStuff.DefaultStuffFor(thingDef);
}
this.rewards.TryAdd(ThingMaker.MakeThing(thingDef, stuff), true);
text2 = "RD_GratefulSurvivorsAmazedDesc".Translate(); //"The survivors of the crash are amazed by your rapid and professional emergency medical response, thanks to which no-one died. In gratitude, they have included a special system removed form the wreck.";
}
Find.LetterStack.ReceiveLetter(text, text2, LetterDefOf.PositiveEvent, null);
Map map = Find.AnyPlayerHomeMap ?? ((MapParent)this.parent).Map;
QuestComp_MedicalEmergency.tmpRewards.AddRange(this.rewards);
this.rewards.Clear();
IntVec3 dropCenter = DropCellFinder.TradeDropSpot(map);
DropPodUtility.DropThingsNear(dropCenter, map, QuestComp_MedicalEmergency.tmpRewards, 110, false, false, true);
QuestComp_MedicalEmergency.tmpRewards.Clear();
if (newFaction)
{
int tile = this.parent.Tile;
this.CloseMapImmediate();
Faction faction = FactionGenerator.NewGeneratedFaction(FactionDefOf.Ancients);
map.pawnDestinationReservationManager.GetPawnDestinationSetFor(faction);
Find.FactionManager.Add(faction);
Settlement settlement = (Settlement)WorldObjectMaker.MakeWorldObject(WorldObjectDefOf.Settlement);
settlement.SetFaction(faction);
settlement.Tile = tile;
settlement.Name = SettlementNameGenerator.GenerateSettlementName(settlement, null);
Find.WorldObjects.Add(settlement);
faction.leader = null;
foreach (Pawn pawn in this.injured)
{
if (!pawn.Dead && pawn.Faction != Faction.OfPlayer)
{
pawn.SetFactionDirect(faction);
if (faction.leader == null)
{
faction.leader = pawn;
}
}
}
faction.TryAffectGoodwillWith(Faction.OfPlayer, 100);
string text3 = "RD_NewFaction".Translate(); //New Faction!
string text4 = "RD_NewFactionDesc".Translate() + faction.Name; //"The survivors of the crash have decided to make a life for themselves here, and have founded a new faction"
Find.LetterStack.ReceiveLetter(text3, text4, LetterDefOf.PositiveEvent, null);
}
}
private void GenerateFaction()
{
FactionInstance faction = FactionGenerator.GenerateFaction();
for (int h = 0; h < Random.Range(2, 6); h++)
{
HeroInstance hero = HeroGenerator.GenerateHero(Random.Range(1, 16));
hero.Experience = Random.Range(0, 1000);
ServiceLocator.AllegianceService.SetHeroAllegiance(hero, faction);
}
}
public override void StartedNewGame()
{
base.StartedNewGame();
PurpleIvyData.TotalFogProgress = new Dictionary <WorldObjectComp_InfectedTile, float>();
PurpleIvyData.TotalPollutedBiomes = new List <int>();
if (Find.FactionManager.AllFactions.Where(x => x.def == PurpleIvyDefOf.Genny).Count() == 0)
{
Log.Message("No alien faction in the game, fixing it");
Faction faction = FactionGenerator.NewGeneratedFaction(PurpleIvyDefOf.Genny);
faction.TrySetRelationKind(Faction.OfPlayer, FactionRelationKind.Hostile, false, null, null);
Find.FactionManager.Add(faction);
}
}
private Faction GenerateFaction()
{
if (newFaction != null && newFaction.leader != null)
{
Find.WorldPawns.RemoveAndDiscardPawnViaGC(newFaction.leader);
}
Faction faction = new Faction();
FactionDef facDef = null;
if (selectedFaction == null)
{
selectedFaction = avaliableFactions.RandomElement();
}
facDef = selectedFaction;
faction.def = facDef;
faction.colorFromSpectrum = FactionGenerator.NewRandomColorFromSpectrum(faction);
if (!facDef.isPlayer)
{
if (facDef.fixedName != null)
{
faction.Name = facDef.fixedName;
}
else
{
faction.Name = NameGenerator.GenerateName(facDef.factionNameMaker, from fac in Find.FactionManager.AllFactionsVisible
select fac.Name);
}
}
faction.centralMelanin = Rand.Value;
foreach (Faction item in Find.FactionManager.AllFactions)
{
faction.TryMakeInitialRelationsWith(item);
}
Pawn p = PawnGenerator.GeneratePawn(PawnKindDefOf.AncientSoldier);
leaderName = p.Name.ToStringFull;
FieldInfo relations = typeof(Faction).GetField("relations", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
newFactionRelation = relations.GetValue(faction) as List <FactionRelation>;
newFactionGoodwillBuff = new string[newFactionRelation.Count];
for (int i = 0; i < newFactionRelation.Count; i++)
{
newFactionGoodwillBuff[i] = newFactionRelation[i].goodwill.ToString();
}
return(faction);
}
public static Faction CreateFaction(FactionRelationKind kind, Func <FactionDef, bool> qualifier, bool isGameStart)
{
//Log.Message("Creating faction...");
var factionDefs = (from fa in DefDatabase <FactionDef> .AllDefs
where fa.canMakeRandomly && qualifier(fa) &&
(!isGameStart || AllFactions.Count(f => f.def == fa) < fa.maxCountAtGameStart)
select fa).ToArray();
var facDef = !AllFactions.Any()
? factionDefs.RandomElement()
: factionDefs.RandomElementByWeight(FactionChance);
Faction faction = FactionGenerator.NewGeneratedFaction(facDef);
InitializeFaction(faction, kind);
return(faction);
}
public static Faction SpawnWithoutSettlements(FactionDef factionDef)
{
// Temporarily set to hidden, so FactionGenerator doesn't spawn a base
var hidden = factionDef.hidden;
factionDef.hidden = true;
var faction = FactionGenerator.NewGeneratedFaction(new FactionGeneratorParms(factionDef, default(IdeoGenerationParms), null));
factionDef.hidden = hidden;
var relationKind = GetFactionKind(faction, true);
InitializeFaction(faction, relationKind);
return(faction);
}
public override bool TryExecuteWorker(IncidentParms parms)
{
if (def.mechClusterBuilding == null)
{
return(false);
}
if (!def.mechClusterBuilding.HasModExtension <HiveDefExtension>())
{
return(false);
}
HiveDefExtension ext = def.mechClusterBuilding.GetModExtension <HiveDefExtension>();
Map map = (Map)parms.target;
if (parms.faction == null)
{
try
{
IEnumerable <Faction> factions = Find.FactionManager.AllFactions.Where(x => x.def.defName.Contains(ext.Faction.defName));
if (!factions.EnumerableNullOrEmpty())
{
parms.faction = factions.RandomElement();
}
else
{
parms.faction = FactionGenerator.NewGeneratedFaction(new FactionGeneratorParms(ext.Faction));
}
// Log.Message(parms.faction.def.defName);
}
catch (System.Exception)
{
Faction faction = Find.FactionManager.FirstFactionOfDef(ext.Faction);
if (faction == null)
{
faction = FactionGenerator.NewGeneratedFaction(new FactionGeneratorParms(ext.Faction));
}
parms.faction = faction;
}
}
CompProperties_SpawnerPawn spawnerPawn = def.mechClusterBuilding.GetCompProperties <CompProperties_SpawnerPawn>();
float points = spawnerPawn?.initialPawnsPoints ?? 250f;
int count = Mathf.Max(GenMath.RoundRandom(parms.points / points), 1);
Thing t = InfestationUtility.SpawnTunnels(def.mechClusterBuilding, count, map, true, true, faction: parms.faction);
SendStandardLetter(parms, t);
Find.TickManager.slower.SignalForceNormalSpeedShort();
return(true);
}
static bool Prefix(ScenPart_PlayerFaction __instance)
{
if (!PersistentWorldManager.GetInstance().PersistentWorldNotNull())
{
return(true);
}
// In order to prevent cloned factions :/
PersistentWorldManager.GetInstance().PersistentWorld
.SetPlayerFactionVarsToNewGeneratedFaction((FactionDef)FactionDefField.GetValue(__instance));
Find.GameInitData.playerFaction = PersistentWorldManager.GetInstance().PersistentWorld.WorldData.FactionManager.OfPlayer;
FactionGenerator.EnsureRequiredEnemies(Find.GameInitData.playerFaction);
return(false);
}
public static World GenerateWorld(float planetCoverage, string seedString, OverallRainfall overallRainfall, OverallTemperature overallTemperature)
{
Rand.Seed = (GenText.StableStringHash(seedString) ^ 4323276);
Current.CreatingWorld = new World();
Current.CreatingWorld.info.planetCoverage = planetCoverage;
Current.CreatingWorld.info.seedString = seedString;
Current.CreatingWorld.info.overallRainfall = overallRainfall;
Current.CreatingWorld.info.overallTemperature = overallTemperature;
Current.CreatingWorld.info.name = NameGenerator.GenerateName(RulePackDefOf.NamerWorld, null, false);
WorldGenerator_Grid.GenerateGridIntoWorld(seedString);
Current.CreatingWorld.ConstructComponents();
FactionGenerator.GenerateFactionsIntoWorld(seedString);
Current.CreatingWorld.FinalizeInit();
World creatingWorld = Current.CreatingWorld;
Current.CreatingWorld = null;
return(creatingWorld);
}
private static void DynamicallyAddFactions()
{
// Check if any carnival factions. If not, generate them.
if (!Find.FactionManager.AllFactionsListForReading.Any(f => f.IsCarnival()))
{
var fdef = _DefOf.Carn_Faction_Roaming;
int num = Rand.RangeInclusive(fdef.requiredCountAtGameStart, fdef.maxCountAtGameStart);
for (int i = 0; i < num; i++)
{
var faction = FactionGenerator.NewGeneratedFaction(fdef);
Find.FactionManager.Add(faction);
Find.VisibleMap.pawnDestinationManager.RegisterFaction(faction);
if (Prefs.DevMode)
{
Log.Message("[Carnivale] Dynamically added new carnival faction " + faction + " to game.");
}
}
}
}
public static bool Prefix(FactionDef facDef, ref Faction __result)
{
if (Controller.Settings.usingFactionControl.Equals(true))
{
return(true);
}
Faction faction = new Faction();
faction.def = facDef;
faction.loadID = Find.UniqueIDsManager.GetNextFactionID();
faction.colorFromSpectrum = FactionGenerator.NewRandomColorFromSpectrum(faction);
if (!facDef.isPlayer)
{
if (facDef.fixedName == null)
{
faction.Name = NameGenerator.GenerateName(facDef.factionNameMaker,
from fac in Find.FactionManager.AllFactionsVisible
select fac.Name, false, null);
}
else
{
faction.Name = facDef.fixedName;
}
}
faction.centralMelanin = Rand.Value;
foreach (Faction allFactionsListForReading in Find.FactionManager.AllFactionsListForReading)
{
faction.TryMakeInitialRelationsWith(allFactionsListForReading);
}
faction.GenerateNewLeader();
if (!facDef.hidden && !facDef.isPlayer)
{
Settlement settlement = (Settlement)WorldObjectMaker.MakeWorldObject(WorldObjectDefOf.Settlement);
settlement.SetFaction(faction);
settlement.Tile = TileFinder.RandomSettlementTileFor(faction, false, null);
settlement.Name = SettlementNameGenerator.GenerateSettlementName(settlement, null);
Find.WorldObjects.Add(settlement);
}
__result = faction;
return(false);
}
public static void AddNewFaction(FactionOnline factionOnline)
{
FactionDef facDef = DefDatabase <FactionDef> .GetNamed(factionOnline.DefName);
Faction faction = new Faction();
faction.def = facDef;
faction.loadID = factionOnline.loadID;
faction.colorFromSpectrum = FactionGenerator.NewRandomColorFromSpectrum(faction);
faction.Name = factionOnline.Name;
faction.centralMelanin = Rand.Value;
foreach (Faction current in Find.FactionManager.AllFactionsListForReading)
{
faction.TryMakeInitialRelationsWith(current);
}
faction.TryGenerateNewLeader();
Find.FactionManager.Add(faction);
typeof(FactionManager).GetMethod("RecacheFactions", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Invoke(Find.FactionManager, null);
}
public static Faction SpawnNewFactionIntoWorld(CustomFactionDef newFaction)
{
if (Find.FactionManager.AllFactionsListForReading.Any(x => x.def == newFaction))
{
Log.Error($"Attempted to spawn existing faction, {newFaction.defName}, into the world.");
return(null);
}
Faction faction = FactionGenerator.NewGeneratedFaction(newFaction);
faction.GenerateNewLeader();
if (faction.leader != null)
{
Log.Message($"{faction.Name} {faction.def.leaderTitle}, {faction.leader.Name} now exists.");
}
else
{
Log.Message($"{faction.Name} {faction.def.leaderTitle} failed to generate.");
}
Find.FactionManager.Add(faction);
return(faction);
}
public static void EnsureAllFactionsArePresent()
{
foreach (FactionDef current in DefDatabase <FactionDef> .AllDefs)
{
//if (!current.hidden) continue;
if (current.isPlayer)
{
continue;
}
var count = Find.FactionManager.AllFactions.Count(f => f.def == current);
if (count >= Settings.minOfAnyFaction)
{
continue;
}
if (count >= Settings.maxOfAnyFaction)
{
continue;
}
int amount = current.requiredCountAtGameStart + (current.canMakeRandomly ? Rand.RangeInclusive(0, 1) : 0);
amount = Mathf.Clamp(amount, Settings.minOfAnyFaction, Settings.maxOfAnyFaction);
for (int j = count; j < amount; j++)
{
Faction faction = FactionGenerator.NewGeneratedFaction(current);
var relationKind = GetFactionKind(faction, j == 0);
InitializeFaction(faction, relationKind);
Log.Message("Created faction for " + faction.def.LabelCap);
if (!faction.def.hidden)
{
CreateSettlements(faction);
}
}
}
}
private Faction NewGeneratedFaction(FactionDef facDef)
{
Faction faction = new Faction();
faction.def = facDef;
faction.loadID = Find.UniqueIDsManager.GetNextFactionID();
faction.colorFromSpectrum = FactionGenerator.NewRandomColorFromSpectrum(faction);
if (!facDef.isPlayer)
{
if (facDef.fixedName != null)
{
faction.Name = facDef.fixedName;
}
else
{
faction.Name = NameGenerator.GenerateName(facDef.factionNameMaker, from fac in Find.FactionManager.AllFactionsVisible
select fac.Name);
}
}
faction.centralMelanin = Rand.Value;
foreach (Faction item in Find.FactionManager.AllFactions)
{
faction.TryMakeInitialRelationsWith(item);
}
faction.GenerateNewLeader();
if (!facDef.hidden && !facDef.isPlayer)
{
Settlement settlement = (Settlement)WorldObjectMaker.MakeWorldObject(WorldObjectDefOf.Settlement);
settlement.SetFaction(faction);
settlement.Tile = TileFinder.RandomSettlementTileFor(faction);
settlement.Name = SettlementNameGenerator.GenerateSettlementName(settlement);
Find.WorldObjects.Add(settlement);
}
return(faction);
}
public static void Main(string[] args)
{
var nameOne = CitizenGenerator.Generate();
var randomFaction = FactionGenerator.RandomFaction();
var nameTwo = CitizenGenerator.Generate();
var secondRandomFaction = FactionGenerator.RandomFaction();
var nameThree = CitizenGenerator.Generate();
var thirdRandomFaction = FactionGenerator.RandomFaction();
Console.WriteLine($"Faction 1: {randomFaction}.
Profile: {randomFaction.Description}
Contact: {nameOne}
");
Console.WriteLine($"Faction 2: {secondRandomFaction}.
Profile: {secondRandomFaction.Description}
Contact: {nameTwo}
");
Console.WriteLine($"Faction 3: {thirdRandomFaction}.
Profile: {thirdRandomFaction.Description}
Contact: {nameThree}
");
Console.WriteLine("The Plot:");
Console.WriteLine(Plot.Generate(randomFaction, secondRandomFaction, thirdRandomFaction));
}
public override void SpawnSetup(Map map, bool respawningAfterLoad)
{
base.SpawnSetup(map, respawningAfterLoad);
if (!respawningAfterLoad)
{
this.equipment = new Pawn_EquipmentTracker(this);
if (this.Faction is null)
{
var faction = Find.FactionManager.FirstFactionOfDef(WendigoDefOf.RCW_Wendigos);
if (faction is null)
{
faction = FactionGenerator.NewGeneratedFaction(new FactionGeneratorParms(WendigoDefOf.RCW_Wendigos));
Find.FactionManager.Add(faction);
}
this.SetFactionDirect(faction);
}
}
else if (this.equipment is null)
{
Log.Error("Wendigo has no equipment... It is a bug");
}
this.needs.food.CurLevel = 0.1f;
}
private bool TryResolveRaidFaction(IncidentParms parms)
{
parms.faction = Find.FactionManager.FirstFactionOfDef(DefOfs_ShiaSurprise.HollywoodCannibals);
if (parms.faction == null)
{
Log.Message("Trying to generate new faction");
var newfac =
FactionGenerator.NewGeneratedFaction(
new FactionGeneratorParms(DefOfs_ShiaSurprise.HollywoodCannibals));
Find.FactionManager.Add(newfac);
parms.faction = newfac;
if (newfac != null && newfac.def == DefOfs_ShiaSurprise.HollywoodCannibals)
{
Log.Message("Generated successfully");
}
else
{
return(false);
}
}
Find.TickManager.slower.SignalForceNormalSpeedShort();
return(true);
}
public static void InitializeServices(GameSetupData data)
{
//Factions and heroes
for (int i = 0; i < data.factionCount; i++)
{
FactionInstance faction = FactionGenerator.GenerateFaction();
foreach (HeroType heroType in Enum.GetValues(typeof(HeroType)))
{
HeroInstance hero = HeroGenerator.GenerateHero(1, heroType);
ServiceLocator.AllegianceService.SetHeroAllegiance(hero, faction);
}
/*for (int h = 0; h < Random.Range(data.heroesPerFactionMin, data.heroesPerFactionMax + 1); h++) {
* HeroInstance hero = HeroGenerator.GenerateHero(1);
* ServiceLocator.AllegianceService.SetHeroAllegiance(hero, faction);
* }*/
for (int q = 0; q < data.startQuests; q++)
{
QuestInstance quest = QuestGenerator.GenerateQuest(1, QuestMakeupType.SOLO);
ServiceLocator.QuestService.RegisterQuest(quest, faction);
}
}
}
/*
* Destructive prefix
*/
public static bool Prefix()
{
int num = 0;
// track actual faction count
int actualFactionCount = 0;
// track faction centers
Controller.factionCenters.Clear();
// Use CustomFaction instead, use Main.CustomFactions instead
foreach (CustomFaction cf in Main.CustomFactions)
{
cf.FactionDef.requiredCountAtGameStart = (int)cf.RequiredCount;
if (cf.RequiredCount == 0)
{
cf.FactionDef.maxCountAtGameStart = 0;
}
else
{
cf.FactionDef.maxCountAtGameStart = (int)cf.MaxCountAtStart;
}
}
// Refactor into method
// SetFactionCounts()
// {
foreach (FactionDef def in DefDatabase <FactionDef> .AllDefs)
{
if (def.isPlayer)
{
continue;
}
switch (def.defName)
{
case "OutlanderCivil":
SetFactionCount(def, (int)Controller_FactionOptions.Settings.outlanderCivilMin);
break;
case "OutlanderRough":
SetFactionCount(def, (int)Controller_FactionOptions.Settings.outlanderHostileMin);
break;
case "TribeCivil":
SetFactionCount(def, (int)Controller_FactionOptions.Settings.tribalCivilMin);
break;
case "TribeRough":
SetFactionCount(def, (int)Controller_FactionOptions.Settings.tribalHostileMin);
break;
case "TribeSavage":
SetFactionCount(def, (int)Controller_FactionOptions.Settings.tribalSavageMin);
break;
case "Empire":
SetFactionCount(def, (int)Controller_FactionOptions.Settings.empireMin);
break;
case "Pirate":
SetFactionCount(def, (int)Controller_FactionOptions.Settings.pirateMin);
break;
}
// }
actualFactionCount += def.requiredCountAtGameStart;
for (int i = 0; i < def.requiredCountAtGameStart; i++)
{
Faction faction = FactionGenerator.NewGeneratedFaction(def);
Find.FactionManager.Add(faction);
if (!def.hidden)
{
num++;
}
}
}
if (Controller_FactionOptions.Settings.MinFactionCount == 0 &&
Main.CustomFactions.Count == 0)
{
/*Log.Error("Faction Control: No factions were selected. To prevent the game from going into an infinite loop a tribe was added.");
* FactionDef def = DefDatabase<FactionDef>.GetNamed("TribeCivil");
* def.requiredCountAtGameStart = 1;
* Controller.maxFactionSprawl = 1;
* Faction faction = FactionGenerator.NewGeneratedFaction(def);
* Find.FactionManager.Add(faction);
* actualFactionCount = 1;*/
return(false);
}
double sqrtTiles = Math.Sqrt(Find.WorldGrid.TilesCount);
double sqrtFactionCount = Math.Sqrt(actualFactionCount);
Controller.minFactionSeparation = sqrtTiles / (sqrtFactionCount * 2);
Controller.maxFactionSprawl = sqrtTiles / (sqrtFactionCount * Controller.Settings.factionGrouping);
Controller.pirateSprawl = Controller.maxFactionSprawl;
if (Controller.Settings.spreadPirates)
{
Controller.pirateSprawl = sqrtTiles / (sqrtFactionCount * 0.5f);
}
while (num < (int)Controller_FactionOptions.Settings.factionCount)
{
FactionDef facDef = (from fa in DefDatabase <FactionDef> .AllDefs
where fa.canMakeRandomly && Find.FactionManager.AllFactions.Count((Faction f) => f.def == fa) < fa.maxCountAtGameStart
select fa).RandomElement <FactionDef>();
Faction faction2 = FactionGenerator.NewGeneratedFaction(facDef);
Find.World.factionManager.Add(faction2);
num++;
}
float tilesCount = (float)Find.WorldGrid.TilesCount / 100000f;
float minBP100K = 75f * Controller.Settings.factionDensity;
float maxBP100K = 85f * Controller.Settings.factionDensity;
FloatRange factionBasesPer100kTiles = new FloatRange(minBP100K, maxBP100K);
int maxCount = 0;
int count = GenMath.RoundRandom(tilesCount * factionBasesPer100kTiles.RandomInRange);
count -= Find.WorldObjects.SettlementBases.Count;
for (int j = 0; j < count && maxCount < 2000; j++)
{
Faction faction2 = (
from x in Find.World.factionManager.AllFactionsListForReading
where !x.def.isPlayer && !x.def.hidden
select x).RandomElementByWeight <Faction>((Faction x) => x.def.settlementGenerationWeight);
Settlement factionBase = (Settlement)WorldObjectMaker.MakeWorldObject(WorldObjectDefOf.Settlement);
factionBase.SetFaction(faction2);
factionBase.Tile = TileFinder.RandomSettlementTileFor(faction2, false, null);
if (factionBase.Tile < 1)
{
j--;
}
else
{
factionBase.Name = SettlementNameGenerator.GenerateSettlementName(factionBase);
Find.WorldObjects.Add(factionBase);
}
++maxCount;
}
return(false);
}
public override void GenerateFresh(string seed)
{
FactionGenerator.GenerateFactionsIntoWorld();
}
public override void GenerateFresh(string seed)
{
Rand.Seed = GenText.StableStringHash(seed);
FactionGenerator.GenerateFactionsIntoWorld();
Rand.RandomizeStateFromTime();
}
private bool doConquest()
{
Settlement AttackerBase = RandomSettlement();
if (AttackerBase == null)
{
return(false);
}
Faction AttackerFaction = AttackerBase.Faction;
if (AttackerFaction == null)
{
return(false);
}
List <Settlement> settlements = Find.WorldObjects.Settlements.ToList <Settlement>();
List <Settlement> prox1 = new List <Settlement>();
List <Settlement> prox2 = new List <Settlement>();
List <Settlement> prox3 = new List <Settlement>();
List <Settlement> prox4 = new List <Settlement>();
List <Settlement> prox5 = new List <Settlement>();
List <Settlement> prox6 = new List <Settlement>();
List <Settlement> prox7 = new List <Settlement>();
double attackerBaseCount = 0;
double totalBaseCount = 0;
List <Settlement> attackerSettlementList = new List <Settlement>();
for (int i = 0; i < settlements.Count; i++)
{
Settlement DefenderBase = settlements[i];
if (DefenderBase.Faction == AttackerBase.Faction)
{
attackerBaseCount++;
attackerSettlementList.Add(DefenderBase);
}
if (DefenderBase.Faction != null && !DefenderBase.Faction.IsPlayer && DefenderBase.Faction.def.settlementGenerationWeight > 0f && !DefenderBase.def.defName.Equals("City_Faction") && !DefenderBase.def.defName.Equals("City_Abandoned") && !DefenderBase.def.defName.Equals("City_Ghost") && !DefenderBase.def.defName.Equals("City_Citadel"))
{
totalBaseCount++;
if (AttackerBase.Faction.HostileTo(DefenderBase.Faction))
{
int attackDistance = Find.WorldGrid.TraversalDistanceBetween(AttackerBase.Tile, DefenderBase.Tile, true);
if (attackDistance < 30)
{
prox1.Add(DefenderBase);
}
else if (attackDistance < 60)
{
prox2.Add(DefenderBase);
}
else if (attackDistance < 90)
{
prox3.Add(DefenderBase);
}
else if (attackDistance < 120)
{
prox4.Add(DefenderBase);
}
else if (attackDistance < 150)
{
prox5.Add(DefenderBase);
}
else if (attackDistance < 180)
{
prox6.Add(DefenderBase);
}
else if (attackDistance < 210)
{
prox7.Add(DefenderBase);
}
}
}
}
// Rebellion code
if (attackerBaseCount >= 10 && attackerBaseCount >= (totalBaseCount * 0.1))
{
int num = Rand.Range(1, 100);
if (num <= (int)(attackerBaseCount / totalBaseCount * 20) || attackerBaseCount >= (totalBaseCount * 0.8))
{
List <Faction> allFactionList = (from x in Find.FactionManager.AllFactionsVisible
where x.def.settlementGenerationWeight > 0f && !x.def.hidden && !x.IsPlayer && !x.defeated && x != AttackerFaction && x.leader != null && !x.leader.IsPrisoner && !x.leader.Spawned
select x).ToList <Faction>();
for (int i = 0; i < allFactionList.Count; i++)
{
if (!IncidentWorker_NPCConquest.HasAnyOtherBase(allFactionList[i]))
{
for (int j = 0; j < attackerSettlementList.Count; j++)
{
int num2 = Rand.Range(1, 100);
bool resistancechance = num2 < 41;
if (resistancechance)
{
Settlement rebelSettlement = (Settlement)WorldObjectMaker.MakeWorldObject(WorldObjectDefOf.Settlement);
rebelSettlement.SetFaction(allFactionList[i]);
rebelSettlement.Tile = attackerSettlementList[j].Tile;
rebelSettlement.Name = SettlementNameGenerator.GenerateSettlementName(rebelSettlement, null);
Find.WorldObjects.Remove(attackerSettlementList[j]);
Find.WorldObjects.Add(rebelSettlement);
}
}
FactionRelation factionRelation = allFactionList[i].RelationWith(AttackerBase.Faction, false);
factionRelation.kind = FactionRelationKind.Hostile;
FactionRelation factionRelation2 = AttackerBase.Faction.RelationWith(allFactionList[i], false);
factionRelation2.kind = FactionRelationKind.Hostile;
Find.LetterStack.ReceiveLetter("LabelRebellion".Translate(), "DescRebellion".Translate(allFactionList[i], AttackerBase.Faction), LetterDefOf.NeutralEvent, null);
return(true);
}
}
if (IncidentWorker_NPCConquest.allowCloneFaction && AttackerFaction != Faction.OfEmpire)
{
Faction clonefaction = FactionGenerator.NewGeneratedFaction(new FactionGeneratorParms(AttackerFaction.def, default(IdeoGenerationParms), null));
clonefaction.color = Random.ColorHSV(0f, 1f, 1f, 1f, 0.5f, 1f);
Find.FactionManager.Add(clonefaction);
for (int i = 0; i < attackerSettlementList.Count; i++)
{
int num3 = Rand.Range(1, 100);
bool resistancechance = num3 < 41;
if (resistancechance)
{
Settlement rebelSettlement = (Settlement)WorldObjectMaker.MakeWorldObject(WorldObjectDefOf.Settlement);
rebelSettlement.SetFaction(clonefaction);
rebelSettlement.Tile = attackerSettlementList[i].Tile;
rebelSettlement.Name = SettlementNameGenerator.GenerateSettlementName(rebelSettlement, null);
Find.WorldObjects.Remove(attackerSettlementList[i]);
Find.WorldObjects.Add(rebelSettlement);
}
}
FactionRelation factionRelation = clonefaction.RelationWith(AttackerBase.Faction, false);
factionRelation.kind = FactionRelationKind.Hostile;
FactionRelation factionRelation2 = AttackerBase.Faction.RelationWith(clonefaction, false);
factionRelation2.kind = FactionRelationKind.Hostile;
Ideo newIdeo = IdeoGenerator.GenerateIdeo(FactionIdeosTracker.IdeoGenerationParmsForFaction_BackCompatibility(clonefaction.def));
clonefaction.ideos.SetPrimary(newIdeo);
Find.IdeoManager.Add(newIdeo);
clonefaction.leader.ideo.SetIdeo(newIdeo);
Find.LetterStack.ReceiveLetter("LabelRebellion".Translate(), "DescRebellion".Translate(clonefaction, AttackerBase.Faction), LetterDefOf.NeutralEvent, null);
return(true);
}
}
}
// Conquest code
Settlement FinalDefenderBase;
if (prox1.Count != 0)
{
FinalDefenderBase = prox1.RandomElement <Settlement>();
}
else if (prox2.Count != 0)
{
FinalDefenderBase = prox2.RandomElement <Settlement>();
}
else if (prox3.Count != 0)
{
FinalDefenderBase = prox3.RandomElement <Settlement>();
}
else if (prox4.Count != 0)
{
FinalDefenderBase = prox4.RandomElement <Settlement>();
}
else if (prox5.Count != 0)
{
FinalDefenderBase = prox5.RandomElement <Settlement>();
}
else if (prox6.Count != 0)
{
FinalDefenderBase = prox6.RandomElement <Settlement>();
}
else if (prox7.Count != 0)
{
FinalDefenderBase = prox7.RandomElement <Settlement>();
}
else
{
return(false);
}
if (FinalDefenderBase.HasMap)
{
Log.Message("attack target has generated map. Event dropped.");
return(false);
}
// Determine whether to raze or take control, distance-based
int razeroll = Rand.Range(1, 100);
if (razeroll <= IncidentWorker_NPCConquest.razeChance)
{
if (IncidentWorker_NPCConquest.allowRazeClear)
{
List <DestroyedSettlement> clearRuinTarget = Find.WorldObjects.DestroyedSettlements;
for (int i = 0; i < clearRuinTarget.Count; i++)
{
Find.WorldObjects.Remove(clearRuinTarget[i]);
}
}
DestroyedSettlement destroyedSettlement = (DestroyedSettlement)WorldObjectMaker.MakeWorldObject(WorldObjectDefOf.DestroyedSettlement);
destroyedSettlement.Tile = FinalDefenderBase.Tile;
Find.WorldObjects.Remove(FinalDefenderBase);
Find.WorldObjects.Add(destroyedSettlement);
}
else
{
Settlement settlementConquest = (Settlement)WorldObjectMaker.MakeWorldObject(WorldObjectDefOf.Settlement);
settlementConquest.SetFaction(AttackerBase.Faction);
settlementConquest.Tile = FinalDefenderBase.Tile;
settlementConquest.Name = SettlementNameGenerator.GenerateSettlementName(settlementConquest, null);
Find.WorldObjects.Remove(FinalDefenderBase);
Find.WorldObjects.Add(settlementConquest);
}
// Defeat check for distance conquest
if (IncidentWorker_NPCConquest.allowCloneFaction && !HasAnyOtherBase(FinalDefenderBase))
{
List <Faction> clonefactioncheck = (from x in Find.FactionManager.AllFactionsVisible
where !x.def.hidden && !x.IsPlayer && !x.defeated && x != FinalDefenderBase.Faction && x.def == FinalDefenderBase.Faction.def
select x).ToList <Faction>();
if (clonefactioncheck.Count > 0)
{
FinalDefenderBase.Faction.defeated = true;
Find.LetterStack.ReceiveLetter("LetterLabelFactionBaseDefeated".Translate(), "LetterFactionBaseDefeated_FactionDestroyed".Translate(FinalDefenderBase.Faction.Name), LetterDefOf.NeutralEvent, null);
}
}
int defeatroll = Rand.Range(1, 100);
if (defeatroll <= IncidentWorker_NPCConquest.defeatChance && !HasAnyOtherBase(FinalDefenderBase))
{
FinalDefenderBase.Faction.defeated = true;
Find.LetterStack.ReceiveLetter("LetterLabelFactionBaseDefeated".Translate(), "LetterFactionBaseDefeated_FactionDestroyed".Translate(FinalDefenderBase.Faction.Name), LetterDefOf.NeutralEvent, null);
}
// Alliance code
if (IncidentWorker_NPCConquest.allowAlliance && Find.World.GetComponent <DiplomacyWorldComponent>().allianceCooldown <= 0)
{
List <Faction> alliance = (from x in Find.FactionManager.AllFactionsVisible
where x.def.settlementGenerationWeight > 0f && !x.def.hidden && !x.IsPlayer && !x.defeated && x != AttackerFaction && x.leader != null && !x.leader.IsPrisoner && !x.leader.Spawned
select x).ToList <Faction>();
List <Faction> finalAlliance = new List <Faction>();
if (alliance.Count >= 2 && attackerBaseCount >= (totalBaseCount * 0.4) && attackerBaseCount <= (totalBaseCount * 0.6) && attackerBaseCount > 9)
{
for (int i = 0; i < alliance.Count; i++)
{
int num = Rand.Range(1, 100);
bool havemysword = num < 81;
if (havemysword)
{
FactionRelation factionRelation = AttackerFaction.RelationWith(alliance[i], false);
factionRelation.kind = FactionRelationKind.Hostile;
FactionRelation factionRelation2 = alliance[i].RelationWith(AttackerFaction, false);
factionRelation2.kind = FactionRelationKind.Hostile;
finalAlliance.Add(alliance[i]);
}
}
StringBuilder allianceList = new StringBuilder();
for (int x = 0; x < finalAlliance.Count; x++)
{
for (int y = 0; y < finalAlliance.Count; y++)
{
if (finalAlliance[y] != finalAlliance[x])
{
FactionRelation factionRelation3 = finalAlliance[y].RelationWith(finalAlliance[x], false);
factionRelation3.kind = FactionRelationKind.Neutral;
FactionRelation factionRelation4 = finalAlliance[x].RelationWith(finalAlliance[y], false);
factionRelation4.kind = FactionRelationKind.Neutral;
}
}
allianceList.Append(finalAlliance[x].ToString()).Append(", ");
}
string allianceListString = allianceList.ToString();
allianceListString = allianceListString.Trim().TrimEnd(',');
Find.LetterStack.ReceiveLetter("LabelAlliance".Translate(), "DescAlliance".Translate(allianceListString, AttackerBase.Faction), LetterDefOf.NeutralEvent, null);
Find.World.GetComponent <DiplomacyWorldComponent>().allianceCooldown = 11;
}
}
if (Find.World.GetComponent <DiplomacyWorldComponent>().allianceCooldown > 0)
{
Find.World.GetComponent <DiplomacyWorldComponent>().allianceCooldown--;
}
return(true);
}
