// Token: 0x06000122 RID: 290 RVA: 0x00003BB8 File Offset: 0x00001DB8
public MiscSizes(PartyTemplateObject pt)
{
this._partyTemplate = pt;
bool flag = this._partyTemplate.StringId.Contains("mercenary") && ModSettings.Instance.mercenaryFactionsMultiplierEnabled;
if (flag)
{
base.processParties(ModSettings.Instance.mercenaryFactionsMinMultiplier, ModSettings.Instance.mercenaryFactionsMaxMultiplier);
}
else
{
bool flag2 = this._partyTemplate.StringId.Contains("outlaw") && ModSettings.Instance.outlawFactionsMultiplierEnabled;
if (flag2)
{
base.processParties(ModSettings.Instance.outlawFactionsMinMultiplier, ModSettings.Instance.outlawFactionsMaxMultiplier);
}
else
{
bool flag3 = this._partyTemplate.StringId.Contains("villager") && ModSettings.Instance.villagersPesantsMultiplierEnabled;
if (flag3)
{
base.processParties(ModSettings.Instance.villagersPesantsMinMultiplier, ModSettings.Instance.villagersPesantsMaxMultiplier);
}
}
}
}
public static bool Prefix(MobileParty __instance, PartyTemplateObject pt, int troopNumberLimit)
{
if (__instance.IsBandit) // TaleWorlds hardcoding strikes again
{
double num1 = 0.4 + 0.8 * MiscHelper.GetGameProcess();
int num2 = MBRandom.RandomInt(2);
double num3 = num2 == 0 ? MBRandom.RandomFloat : (MBRandom.RandomFloat * MBRandom.RandomFloat * MBRandom.RandomFloat * 4.0);
double num4 = num2 == 0 ? (num3 * 0.8 + 0.2) : 1 + num3;
foreach (PartyTemplateStack stack in pt.Stacks)
{
int numTroopsToAdd = MBRandom.RoundRandomized((float)(stack.MinValue + num1 * num4 * MBRandom.RandomFloat * (stack.MaxValue - stack.MinValue)));
__instance.AddElementToMemberRoster(stack.Character, numTroopsToAdd);
}
}
else if (__instance.IsVillager)
{
int index = MBRandom.RandomInt(pt.Stacks.Count);
for (int troopCount = 0; troopCount < troopNumberLimit; troopCount++)
{
__instance.AddElementToMemberRoster(pt.Stacks[index].Character, 1);
index = MBRandom.RandomInt(pt.Stacks.Count);
}
}
else // everything else looks fine; hand stack filling to original method
{
return(true);
}
return(false);
}
// Token: 0x06000004 RID: 4 RVA: 0x0000215C File Offset: 0x0000035C
public override void OnGameInitializationFinished(Game game)
{
base.OnGameInitializationFinished(game);
bool flag = !(game.GameType is Campaign);
if (!flag)
{
Campaign campaign = game.GameType as Campaign;
bool flag2 = campaign != null;
if (flag2)
{
bool flag3 = MBObjectManager.Instance.GetObjectTypeList <PartyTemplateObject>() != null;
if (flag3)
{
MBReadOnlyList <PartyTemplateObject> partyTemplateList = MBObjectManager.Instance.GetObjectTypeList <PartyTemplateObject>();
for (int index = 0; index < partyTemplateList.Count; index++)
{
PartyTemplateObject pt = partyTemplateList[index];
new PartyTemplateSizes(pt);
}
}
bool bPrintTroopLimits = ModSettings.Instance.bPrintTroopLimits;
if (bPrintTroopLimits)
{
bool flag4 = MBObjectManager.Instance.GetObjectTypeList <PartyTemplateObject>() != null;
if (flag4)
{
MBReadOnlyList <PartyTemplateObject> partyTemplateList2 = MBObjectManager.Instance.GetObjectTypeList <PartyTemplateObject>();
Logging.lm("-------------------------------------------");
Logging.lm("Printing Party Template Troop Limits ");
for (int index2 = 0; index2 < partyTemplateList2.Count; index2++)
{
Logging.lm("");
PartyTemplateObject pt2 = partyTemplateList2[index2];
Logging.lm("Party String Id: " + pt2.StringId.ToString());
foreach (PartyTemplateStack ps in pt2.Stacks)
{
string[] array = new string[6];
array[0] = "Character: ";
array[1] = ps.Character.StringId.ToString();
array[2] = " Min: ";
int num = 3;
int num2 = ps.MinValue;
array[num] = num2.ToString();
array[4] = " Max: ";
int num3 = 5;
num2 = ps.MaxValue;
array[num3] = num2.ToString();
Logging.lm(string.Concat(array));
}
Logging.lm("");
}
}
}
}
}
}
public PartyTemplateSizes(PartyTemplateObject pt)
{
bool flag = pt.StringId.Contains("looter") || pt.StringId.Contains("bandit") || pt.StringId.Contains("raider");
if (flag)
{
new BanditSizes(pt);
}
else
{
bool flag2 = pt.StringId.Contains("mercenary") || pt.StringId.Contains("outlaw") || pt.StringId.Contains("villager");
if (flag2)
{
new MiscSizes(pt);
}
else
{
bool flag3 = pt.StringId.Contains("caravan") && !pt.StringId.Contains("char_");
if (flag3)
{
new Caravan(pt);
}
else
{
bool flag4 = pt.StringId.Contains("kingdom_hero") && this.isNotRestrictedParty(pt);
if (flag4)
{
new KingdomSizes(pt);
}
else
{
bool flag5 = pt.StringId.Contains("char_") || (pt.StringId.Contains("gamescom_player") && !pt.StringId.Contains("caravan"));
if (flag5)
{
new PlayerSizes(pt);
}
else
{
bool flag6 = pt.StringId.Contains("kingdom_hero_ai") || pt.StringId.Contains("kingdom_hero_minor");
if (flag6)
{
new KingdomOtherSizes(pt);
}
else
{
bool flag7 = pt.StringId.Contains("cs_");
if (flag7)
{
new csSizes(pt);
}
}
}
}
}
}
}
}
public csSizes(PartyTemplateObject pt)
{
this._partyTemplate = pt;
bool csFactionsMultiplierEnabled = ModSettings.Instance.csFactionsMultiplierEnabled;
if (csFactionsMultiplierEnabled)
{
base.processParties(ModSettings.Instance.csFactionsMinMultiplier, ModSettings.Instance.csFactionsMaxMultiplier);
}
}
public bool isNotRestrictedParty(PartyTemplateObject pt)
{
bool isRestricted = true;
bool flag = pt.StringId.Contains("militia") && pt.StringId.Contains("quest") && pt.StringId.Contains("rebels");
if (flag)
{
isRestricted = false;
}
return(isRestricted);
}
private static bool Prefix(PartyTemplateObject pt)
{
if (pt == null)
{
Mod.Log("BROKEN");
Debug.PrintError("Bandit Militias is broken please notify @gnivler via Nexus");
return(false);
}
return(true);
}
public static TroopRoster ConstructTroopRoster(PartyTemplateObject template, PartyBase party)
{
TroopRoster roster = new TroopRoster(party);
foreach (PartyTemplateStack stack in template.Stacks)
{
int num = MBRandom.RandomInt(stack.MinValue, stack.MaxValue);
roster.AddToCounts(stack.Character, num);
}
return(roster);
}
public PlayerSizes(PartyTemplateObject pt)
{
this._partyTemplate = pt;
bool flag = this._partyTemplate.StringId.Contains("char_") && ModSettings.Instance.charKingdomMultiplierEnabled;
if (flag)
{
base.processParties(ModSettings.Instance.charKingdomMinMultiplier, ModSettings.Instance.charKingdomMaxMultiplier);
}
else
{
bool flag2 = this._partyTemplate.StringId.Contains("gamescom_player") && ModSettings.Instance.gamescomMultiplierEnabled;
if (flag2)
{
base.processParties(ModSettings.Instance.gamescomMinMultiplier, ModSettings.Instance.gamescomMaxMultiplier);
}
}
}
// Token: 0x0600011E RID: 286 RVA: 0x000037EC File Offset: 0x000019EC
public Caravan(PartyTemplateObject pt)
{
this._partyTemplate = pt;
bool flag = this._partyTemplate.StringId.Contains("elite") && ModSettings.Instance.eliteCaravansMultiplierEnabled;
if (flag)
{
base.processParties(ModSettings.Instance.eliteCaravansMinMultiplier, ModSettings.Instance.eliteCaravansMaxMultiplier);
}
else
{
bool caravansMultiplierEnabled = ModSettings.Instance.caravansMultiplierEnabled;
if (caravansMultiplierEnabled)
{
base.processParties(ModSettings.Instance.caravansMinMultiplier, ModSettings.Instance.caravansMaxMultiplier);
}
}
}
public MobileParty spawnPatrol(Settlement settlement, Clan clan, int amount)
{
PartyTemplateObject partyTemplate = clan.Culture.DefaultPartyTemplate;
int numberOfCreated = partyTemplate.NumberOfCreated;
partyTemplate.IncrementNumberOfCreated();
MobileParty mobileParty = MBObjectManager.Instance.CreateObject <MobileParty>(clan.StringId + "_" + numberOfCreated);
TextObject textObject;
textObject = new TextObject("{BASILPATROL_SETTLEMENT_NAME} Patrol", null);
textObject.SetTextVariable("BASILPATROL_SETTLEMENT_NAME", settlement.Name);
mobileParty.InitializeMobileParty(textObject, partyTemplate, settlement.GatePosition, 0, 0, 0, rand.Next((int)(amount * 0.9), (int)Math.Ceiling((amount + 1) * 1.1)));
InitPatrolParty(mobileParty, textObject, clan, settlement);
mobileParty.Aggressiveness = 1f;
mobileParty.SetMovePatrolAroundSettlement(settlement);
return(mobileParty);
}
// Token: 0x06000120 RID: 288 RVA: 0x000038C4 File Offset: 0x00001AC4
public KingdomOtherSizes(PartyTemplateObject pt)
{
this._partyTemplate = pt;
bool flag = this._partyTemplate.StringId.Contains("kingdom_hero_ai") && ModSettings.Instance.otherKingdomMultiplierEnabled;
if (flag)
{
base.processParties(ModSettings.Instance.otherKingdomMinMultiplier, ModSettings.Instance.otherKingdomMaxMultiplier);
}
else
{
bool flag2 = this._partyTemplate.StringId.Contains("kingdom_hero_minor") && ModSettings.Instance.otherMinorFactionsMultiplierEnabled;
if (flag2)
{
base.processParties(ModSettings.Instance.otherMinorFactionsMinMultiplier, ModSettings.Instance.otherMinorFactionsMaxMultiplier);
}
}
}
public static bool Prefix(ref MobileParty __instance, PartyTemplateObject pt, MobileParty.PartyTypeEnum partyType, int troopNumberLimit = -1)
{
bool result = true;
if (partyType == MobileParty.PartyTypeEnum.Bandit)
{
int num = 0;
for (int i = 0; i < pt.Stacks.Count; i++)
{
num = Support.Random(pt.Stacks[i].MinValue, pt.Stacks[i].MaxValue);
if (num > 0 && pt.Stacks[i].Character != null)
{
__instance.AddElementToMemberRoster(pt.Stacks[i].Character, num);
}
}
result = false;
}
return(result);
}
public MobileParty spawnRecruiter(Settlement settlement, int cash, RecruiterProperties props)
{
PartyTemplateObject defaultPartyTemplate = settlement.Culture.DefaultPartyTemplate;
int numberOfCreated = defaultPartyTemplate.NumberOfCreated;
defaultPartyTemplate.IncrementNumberOfCreated();
MobileParty mobileParty = MBObjectManager.Instance.CreateObject <MobileParty>(settlement.OwnerClan.StringId + "_" + numberOfCreated);
TextObject textObject = new TextObject("{RECRUITER_SETTLEMENT_NAME} Recruiter", null);
textObject.SetTextVariable("RECRUITER_SETTLEMENT_NAME", settlement.Name);
mobileParty.InitializeMobileParty(textObject, defaultPartyTemplate, settlement.GatePosition, 0f, 0f, MobileParty.PartyTypeEnum.Default, 1);
mobileParty.PartyTradeGold = cash;
this.InitRecruiterParty(mobileParty, textObject, settlement.OwnerClan, settlement);
mobileParty.Aggressiveness = 0f;
props.party = mobileParty;
recruiterProperties.Add(props);
mobileParty.SetMoveGoToSettlement(findNearestSettlementWithRecruitableRecruits(mobileParty));
return(mobileParty);
}
private static TroopRoster ConstructTroopRoster(PartyTemplateObject pt, int troopNumberLimit = -1) //TODO implement troop number limit.
{
TroopRoster returned = new TroopRoster();
float gameProcess = MiscHelper.GetGameProcess();
float num = 0.25f + 0.75f * gameProcess;
int num2 = MBRandom.RandomInt(2);
float num3 = (num2 == 0) ? MBRandom.RandomFloat : (MBRandom.RandomFloat * MBRandom.RandomFloat * MBRandom.RandomFloat * 4f);
float num4 = (num2 == 0) ? (num3 * 0.8f + 0.2f) : (1f + num3);
float randomFloat = MBRandom.RandomFloat;
float randomFloat2 = MBRandom.RandomFloat;
float randomFloat3 = MBRandom.RandomFloat;
for (int i = 0; i < pt.Stacks.Count; i++)
{
float f = (pt.Stacks.Count > 0) ? ((float)pt.Stacks[i].MinValue + num * num4 * randomFloat * (float)(pt.Stacks[i].MaxValue - pt.Stacks[i].MinValue)) : 0f;
returned.AddToCounts(pt.Stacks[i].Character, MBRandom.RoundRandomized(f), false);
}
return(returned);
}
public static MobileParty CreateBanditParty(string cultureObjectID = null, string partyName = null)
{
MobileParty banditParty = null;
try
{
List <Settlement> hideouts = Settlement.FindAll((s) => { return(s.IsHideout()); }).ToList();
Settlement closestHideout = hideouts.MinBy((s) => { return(MobileParty.MainParty.GetPosition().DistanceSquared(s.GetPosition())); });
CultureObject banditCultureObject = null;
if (cultureObjectID != null)
{
banditCultureObject = MBObjectManager.Instance.GetObject <CultureObject>(cultureObjectID);
}
else
{
banditCultureObject = closestHideout.Culture;
}
if (partyName == null)
{
partyName = $"{banditCultureObject.Name} (Random Event)";
}
PartyTemplateObject partyTemplate = MBObjectManager.Instance.GetObject <PartyTemplateObject>($"{banditCultureObject.StringId}_template");
banditParty = MBObjectManager.Instance.CreateObject <MobileParty>($"randomevent_{banditCultureObject.StringId}_{MBRandom.RandomInt(int.MaxValue)}");
TextObject partyNameTextObject = new TextObject(partyName, null);
Clan banditClan = Clan.BanditFactions.FirstOrDefault(clan => clan.StringId == banditCultureObject.StringId);
banditParty.InitializeMobileParty(partyTemplate, MobileParty.MainParty.Position2D, 0.2f, 0.1f);
banditParty.SetCustomName(partyNameTextObject);
banditParty.HomeSettlement = closestHideout;
}
catch (Exception ex)
{
MessageBox.Show($"Error while trying to create a mobile bandit party :\n\n {ex.Message} \n\n { ex.StackTrace}");
}
return(banditParty);
}
private static TownPatrolData SpawnTownPatrol(string name, string size, PatrolData dat, bool isPlayerSpawn, Settlement spawnSettlement = null)
{
MBObjectManager objManager = Game.Current.ObjectManager;
TextObject pName = new TextObject(name);
PartyTemplateObject templateObject = (PartyTemplateObject)objManager.GetObject <PartyTemplateObject>(dat.templateName + "_" + size);
spawnSettlement = isPlayerSpawn ? Settlement.CurrentSettlement : spawnSettlement;
MobileParty patrol = objManager.CreateObject <MobileParty>(dat.templateName + "_" + size + "_" + 1);
patrol.InitializeMobileParty(MenuUtils.ConstructTroopRoster(templateObject, patrol.Party), new TroopRoster(patrol.Party), isPlayerSpawn ? Settlement.CurrentSettlement.GatePosition : spawnSettlement.GatePosition, 0);
patrol.SetCustomName(pName);
patrol.Party.Owner = spawnSettlement.MapFaction.Leader == null?spawnSettlement.OwnerClan.Heroes.ToList().First() : spawnSettlement.OwnerClan.Leader;
patrol.Party.Visuals.SetMapIconAsDirty();
patrol.ActualClan = spawnSettlement.OwnerClan;
patrol.HomeSettlement = spawnSettlement;
MenuUtils.CreatePartyTrade(patrol);
foreach (ItemObject obj in ItemObject.All)
{
if (obj.IsFood)
{
int num = MBRandom.RandomInt(patrol.MemberRoster.TotalManCount / 3, patrol.MemberRoster.TotalManCount);
if (num > 0)
{
patrol.ItemRoster.AddToCounts(obj, num);
}
}
}
patrol.SetMovePatrolAroundSettlement(spawnSettlement);
return(new TownPatrolData(pName.ToString(), size, patrol));
}
public static MobileParty SpawnParty(Settlement spawnedSettlement, Clan clan, PartyTemplateObject templateObject, MobileParty.PartyTypeEnum partyType, TextObject partyName = null)
{
//get name and show message.
TextObject textObject = partyName ?? clan.Name;
ModDebug.ShowMessage("CustomSpawns: Spawning " + textObject.ToString() + " at " + spawnedSettlement.GatePosition + " in settlement " + spawnedSettlement.Name.ToString());
//create.
MobileParty mobileParty = MBObjectManager.Instance.CreateObject <MobileParty>(templateObject.StringId + "_" + 1);
mobileParty.InitializeMobileParty(textObject, ConstructTroopRoster(templateObject), new TroopRoster(), spawnedSettlement.GatePosition, 0);
//initialize
Spawner.InitParty(mobileParty, textObject, clan, spawnedSettlement);
return(mobileParty);
}
// Token: 0x0600011D RID: 285 RVA: 0x00003420 File Offset: 0x00001620
public BanditSizes(PartyTemplateObject pt)
{
this._partyTemplate = pt;
bool flag = this._partyTemplate.StringId.Contains("looter");
if (flag)
{
bool lootersMultiplierEnabled = ModSettings.Instance.lootersMultiplierEnabled;
if (lootersMultiplierEnabled)
{
base.processParties(ModSettings.Instance.lootersMinMultiplier, ModSettings.Instance.lootersMaxMultiplier);
}
}
else
{
bool flag2 = this._partyTemplate.StringId.Contains("sea");
if (flag2)
{
bool flag3 = base.isBossParty() && ModSettings.Instance.seaBossBanditsMultiplierEnabled;
if (flag3)
{
base.processBanditBoss(ModSettings.Instance.seaBossBanditMinMultiplier, ModSettings.Instance.seaBossBanditMaxMultiplier);
}
else
{
bool flag4 = ModSettings.Instance.seaBanditsMultiplierEnabled && !base.isBossParty();
if (flag4)
{
base.processParties(ModSettings.Instance.seaBanditMinMultiplier, ModSettings.Instance.seaBanditMaxMultiplier);
}
}
}
else
{
bool flag5 = this._partyTemplate.StringId.Contains("forest");
if (flag5)
{
bool flag6 = base.isBossParty() && ModSettings.Instance.forestBossBanditMultiplierEnabled;
if (flag6)
{
base.processBanditBoss(ModSettings.Instance.forestBossBanditMinMultiplier, ModSettings.Instance.forestBossBanditMaxMultiplier);
}
else
{
bool flag7 = ModSettings.Instance.forestBanditMultiplierEnabled && !base.isBossParty();
if (flag7)
{
base.processParties(ModSettings.Instance.forestBanditMinMultiplier, ModSettings.Instance.forestBanditMaxMultiplier);
}
}
}
else
{
bool flag8 = this._partyTemplate.StringId.Contains("mountain");
if (flag8)
{
bool flag9 = base.isBossParty() && ModSettings.Instance.mountainBossBanditsMultiplierEnabled;
if (flag9)
{
base.processBanditBoss(ModSettings.Instance.mountainBossBanditMinMultiplier, ModSettings.Instance.mountainBossBanditMaxMultiplier);
}
else
{
bool flag10 = ModSettings.Instance.mountainBanditsMultiplierEnabled && !base.isBossParty();
if (flag10)
{
base.processParties(ModSettings.Instance.mountainBanditMinMultiplier, ModSettings.Instance.mountainBanditMaxMultiplier);
}
}
}
else
{
bool flag11 = this._partyTemplate.StringId.Contains("desert");
if (flag11)
{
bool flag12 = base.isBossParty() && ModSettings.Instance.desertBossBanditsMultiplierEnabled;
if (flag12)
{
base.processBanditBoss(ModSettings.Instance.desertBossBanditMinMultiplier, ModSettings.Instance.desertBossBanditMaxMultiplier);
}
else
{
bool flag13 = ModSettings.Instance.desertBanditsMultiplierEnabled && !base.isBossParty();
if (flag13)
{
base.processParties(ModSettings.Instance.desertBanditMinMultiplier, ModSettings.Instance.desertBanditMaxMultiplier);
}
}
}
else
{
bool flag14 = this._partyTemplate.StringId.Contains("steppe");
if (flag14)
{
bool flag15 = base.isBossParty() && ModSettings.Instance.steppeBossBanditsMultiplierEnabled;
if (flag15)
{
base.processBanditBoss(ModSettings.Instance.steppeBossBanditMinMultiplier, ModSettings.Instance.steppeBossBanditMaxMultiplier);
}
else
{
bool flag16 = ModSettings.Instance.steppeBanditsMultiplierEnabled && !base.isBossParty();
if (flag16)
{
base.processParties(ModSettings.Instance.steppeBanditMinMultiplier, ModSettings.Instance.steppeBanditMaxMultiplier);
}
}
}
else
{
bool flag17 = base.isBossParty() && ModSettings.Instance.otherBanditsBossMultiplierEnabled;
if (flag17)
{
base.processBanditBoss(ModSettings.Instance.otherBanditsBossMinMultiplier, ModSettings.Instance.otherBanditsBossMaxMultiplier);
}
else
{
bool flag18 = ModSettings.Instance.otherBanditsMultiplierEnabled && !base.isBossParty();
if (flag18)
{
base.processParties(ModSettings.Instance.otherBanditsMinMultiplier, ModSettings.Instance.otherBanditsMaxMultiplier);
}
}
}
}
}
}
}
}
}
public static MobileParty SpawnParty(Settlement spawnedSettlement, Clan clan, PartyTemplateObject templateObject, Track.PartyTypeEnum partyType, TextObject partyName = null)
{
try
{
//get name and show message.
TextObject textObject = partyName ?? clan.Name;
ModDebug.ShowMessage("CustomSpawns: Spawning " + textObject.ToString() + " at " + spawnedSettlement.GatePosition + " in settlement " + spawnedSettlement.Name.ToString(), DebugMessageType.Spawn);
//create.
MobileParty mobileParty = MBObjectManager.Instance.CreateObject <MobileParty>(templateObject.StringId + "_" + 1);
mobileParty.InitializeMobileParty(textObject, ConstructTroopRoster(templateObject, mobileParty.Party), new TroopRoster(mobileParty.Party), spawnedSettlement.GatePosition, 0);
//initialize
Spawner.InitParty(mobileParty, textObject, clan, spawnedSettlement);
return(mobileParty);
}
catch (Exception e) {
ErrorHandler.ShowPureErrorMessage("Possible invalid spawn data. Spawning of party terminated.");
ErrorHandler.HandleException(e, "party spawning");
return(null);
}
}
internal void CECaptorHuntPrisoners(MenuCallbackArgs args, int amount = 20)
{
CEPersistence.animationPlayEvent = false;
TroopRoster releasedPrisoners = TroopRoster.CreateDummyTroopRoster();
if (CESettings.Instance != null)
{
amount = CESettings.Instance.AmountOfTroopsForHunt;
}
try
{
for (int i = 0; i < amount; i++)
{
TroopRosterElement test = MobileParty.MainParty.PrisonRoster.GetTroopRoster().Where(troop => !troop.Character.IsHero).GetRandomElementInefficiently();
if (test.Character == null)
{
continue;
}
MobileParty.MainParty.PrisonRoster.RemoveTroop(test.Character);
releasedPrisoners.AddToCounts(test.Character, 1, true);
}
}
catch (Exception)
{
CECustomHandler.LogToFile("Couldn't find anymore prisoners.");
}
if (!releasedPrisoners.GetTroopRoster().IsEmpty())
{
CECaptorContinue(args);
try
{
Clan clan = Clan.BanditFactions.First(clanLooters => clanLooters.StringId == "looters");
clan.Banner.SetBannerVisual(Banner.CreateRandomBanner().BannerVisual);
Settlement nearest = SettlementHelper.FindNearestSettlement(settlement => { return(true); });
MobileParty prisonerParty = BanditPartyComponent.CreateBanditParty("CustomPartyCE_Hunt_" + MBRandom.RandomInt(int.MaxValue), clan, nearest.Hideout, false);
PartyTemplateObject defaultPartyTemplate = clan.DefaultPartyTemplate;
prisonerParty.InitializeMobileParty(defaultPartyTemplate, MobileParty.MainParty.Position2D, 0.5f, 0.1f, -1);
prisonerParty.SetCustomName(new TextObject("{=CEEVENTS1107}Escaped Captives"));
prisonerParty.MemberRoster.Clear();
prisonerParty.MemberRoster.Add(releasedPrisoners.ToFlattenedRoster());
prisonerParty.RecentEventsMorale = -100;
prisonerParty.IsActive = true;
prisonerParty.ActualClan = clan;
prisonerParty.Party.Owner = clan.Leader;
prisonerParty.Party.Visuals.SetMapIconAsDirty();
prisonerParty.HomeSettlement = nearest;
prisonerParty.InitializePartyTrade(0);
Hero.MainHero.HitPoints += 40;
CECustomHandler.LogToFile(prisonerParty.Leader.Name.ToString());
PlayerEncounter.RestartPlayerEncounter(prisonerParty.Party, MobileParty.MainParty.Party, true);
StartBattleAction.Apply(MobileParty.MainParty.Party, prisonerParty.Party);
PlayerEncounter.Update();
CEPersistence.huntState = CEPersistence.HuntState.StartHunt;
CampaignMission.OpenBattleMission(PlayerEncounter.GetBattleSceneForMapPosition(MobileParty.MainParty.Position2D));
}
catch (Exception)
{
CECaptorKillPrisoners(args, amount);
}
}
else
{
CECaptorContinue(args);
}
}
// Token: 0x06000121 RID: 289 RVA: 0x0000396C File Offset: 0x00001B6C
public KingdomSizes(PartyTemplateObject pt)
{
this._partyTemplate = pt;
bool flag = this._partyTemplate.StringId.Contains("empire") && ModSettings.Instance.empireKingdomMultiplierEnabled;
if (flag)
{
base.processParties(ModSettings.Instance.empireKingdomMinMultiplier, ModSettings.Instance.empireKingdomMaxMultiplier);
}
else
{
bool flag2 = this._partyTemplate.StringId.Contains("aserai") && ModSettings.Instance.aseraiKingdomMultiplierEnabled;
if (flag2)
{
base.processParties(ModSettings.Instance.aseraiKingdomMinMultiplier, ModSettings.Instance.aseraiKingdomMaxMultiplier);
}
else
{
bool flag3 = this._partyTemplate.StringId.Contains("sturgia") && ModSettings.Instance.sturgiaKingdomMultiplierEnabled;
if (flag3)
{
base.processParties(ModSettings.Instance.sturgiaKingdomMinMultiplier, ModSettings.Instance.sturgiaKingdomMaxMultiplier);
}
else
{
bool flag4 = this._partyTemplate.StringId.Contains("vlandia") && ModSettings.Instance.vlandiaKingdomMultiplierEnabled;
if (flag4)
{
base.processParties(ModSettings.Instance.vlandiaKingdomMinMultiplier, ModSettings.Instance.vlandiaKingdomMaxMultiplier);
}
else
{
bool flag5 = this._partyTemplate.StringId.Contains("battania") && ModSettings.Instance.battaniaKingdomMultiplierEnabled;
if (flag5)
{
base.processParties(ModSettings.Instance.battaniaKingdomMinMultiplier, ModSettings.Instance.battaniaKingdomMaxMultiplier);
}
else
{
bool flag6 = this._partyTemplate.StringId.Contains("khuzait") && ModSettings.Instance.khuzaitKingdomMultiplierEnabled;
if (flag6)
{
base.processParties(ModSettings.Instance.khuzaitKingdomMinMultiplier, ModSettings.Instance.khuzaitKingdomMaxMultiplier);
}
else
{
bool flag7 = ModSettings.Instance.minorFactionsMultiplierEnabled && !this._partyTemplate.StringId.Contains("cs_");
if (flag7)
{
base.processParties(ModSettings.Instance.minorFactionsMinMultiplier, ModSettings.Instance.minorFactionsMaxMultiplier);
}
else
{
bool flag8 = this._partyTemplate.StringId.Contains("cs_");
if (flag8)
{
new csSizes(pt);
}
}
}
}
}
}
}
}
}
private static MobileParty CreatePartyInstance(Settlement spawnedSettlement, Clan clan, PartyTemplateObject templateObject,
Track.PartyTypeEnum partyType, TextObject partyName = null)
{
if (clan.IsBanditFaction)
{
return(BanditPartyComponent.CreateBanditParty(templateObject.StringId + "_" + 1, clan,
spawnedSettlement.Hideout, false));
}
return(MobileParty.CreateParty(templateObject.StringId + "_" + 1, null));
}
public static MobileParty SpawnParty(Settlement spawnedSettlement, Clan clan, PartyTemplateObject templateObject, Track.PartyTypeEnum partyType, TextObject partyName = null)
{
try
{
if (templateObject == null)
{
ErrorHandler.ShowPureErrorMessage(
"Party Template with ID " + templateObject.StringId + " possibly does not exist. It was tried to be assigned to "
+ templateObject.StringId);
return(null);
}
//get name and show message.
TextObject textObject = partyName ?? clan.Name;
ModDebug.ShowMessage("CustomSpawns: Spawning " + textObject.ToString() + " at " + spawnedSettlement.GatePosition + " in settlement " + spawnedSettlement.Name.ToString(), DebugMessageType.Spawn);
//create.
MobileParty mobileParty = CreatePartyInstance(spawnedSettlement, clan, templateObject, partyType, partyName);
if (mobileParty == null)
{
return(null); //must have had some issue. or maybe it was just the wind.
}
mobileParty.InitializeMobilePartyAroundPosition(ConstructTroopRoster(templateObject, mobileParty.Party),
new TroopRoster(mobileParty.Party), spawnedSettlement.GatePosition, 0);
//initialize
InitParty(mobileParty, textObject, clan, spawnedSettlement);
return(mobileParty);
}
catch (Exception e) {
ErrorHandler.ShowPureErrorMessage("Possible invalid spawn data. Spawning of party terminated.");
ErrorHandler.HandleException(e, "party spawning");
return(null);
}
}
private void ConstructListFromXML(string filePath)
{
XmlDocument doc = new XmlDocument();
doc.Load(filePath);
try
{
foreach (XmlNode node in doc.DocumentElement)
{
if (node.NodeType == XmlNodeType.Comment)
{
continue;
}
SpawnData dat = new SpawnData();
dat.PartyTemplate = (PartyTemplateObject)MBObjectManager.Instance.ReadObjectReferenceFromXml("party_template", typeof(PartyTemplateObject), node);
if (node.Attributes["spawn_clan"] == null)
{
dat.SpawnClan = (Clan)MBObjectManager.Instance.ReadObjectReferenceFromXml("bandit_clan", typeof(Clan), node);
}
else
{
dat.SpawnClan = (Clan)MBObjectManager.Instance.ReadObjectReferenceFromXml("spawn_clan", typeof(Clan), node);
}
//have bannerlord read attributes
int i = 0;
string s = "overriden_spawn_clan";
while (true)
{
string s1 = s + "_" + i.ToString();
if (node.Attributes[s1] == null || node.Attributes[s1].InnerText == "")
{
break;
}
else
{
dat.OverridenSpawnClan.Add((Clan)MBObjectManager.Instance.ReadObjectReferenceFromXml(s1, typeof(Clan), node));
}
i++;
}
int j = 0;
string st = "overriden_spawn_culture";
while (true)
{
string s1 = st + "_" + j.ToString();
if (node.Attributes[s1] == null || node.Attributes[s1].InnerText == "")
{
break;
}
else
{
dat.OverridenSpawnCultures.Add(((CultureObject)MBObjectManager.Instance.ReadObjectReferenceFromXml(s1, typeof(CultureObject), node)).GetCultureCode());
}
j++;
}
j = 0;
st = "overriden_spawn_settlement";
while (true)
{
string s1 = st + "_" + j.ToString();
if (node.Attributes[s1] == null || node.Attributes[s1].InnerText == "")
{
break;
}
else
{
dat.OverridenSpawnSettlements.Add(((Settlement)MBObjectManager.Instance.ReadObjectReferenceFromXml(s1, typeof(Settlement), node)));
}
j++;
}
//get elements
dat.MaximumOnMap = node["MaximumOnMap"] == null? 0 : int.Parse(node["MaximumOnMap"].InnerText);
if (dat.MaximumOnMap < 1)
{
throw new Exception("the node 'MaximumOnMap' cannot be less than 1!");
}
dat.PartyType = node["PartyType"] == null ? MobileParty.PartyTypeEnum.Bandit : StringToPartyTypeEnumIfInvalidBandit(node["PartyType"].InnerText);
dat.ChanceOfSpawn = node["ChanceOfSpawn"] == null? 1 : float.Parse(node["ChanceOfSpawn"].InnerText);
dat.Name = node["Name"] == null ? "Unnamed" : node["Name"].InnerText;
dat.ChanceInverseConstant = node["ChanceInverseConstant"] == null? 0 : float.Parse(node["ChanceInverseConstant"].InnerText);
dat.RepeatSpawnRolls = node["RepeatSpawnRolls"] == null? 1 : int.Parse(node["RepeatSpawnRolls"].InnerText);
dat.PatrolAroundSpawn = node["PatrolAroundSpawn"] == null ? false : bool.Parse(node["PatrolAroundSpawn"].InnerText);
dat.MinimumNumberOfDaysUntilSpawn = node["MinimumNumberOfDaysUntilSpawn"] == null ? -1 : int.Parse(node["MinimumNumberOfDaysUntilSpawn"].InnerText);
dat.AttackClosestIfIdleForADay = node["AttackClosestIfIdleForADay"] == null ? true : bool.Parse(node["AttackClosestIfIdleForADay"].InnerText);
//try spawn at list creation
if (node["TrySpawnAt"] != null && node["TrySpawnAt"].InnerText != "")
{
dat.TrySpawnAtList = ConstructTrySettlementList(node["TrySpawnAt"].InnerText);
}
//message
string msg = node["SpawnMessage"] == null? "" : node["SpawnMessage"].InnerText;
string color = node["SpawnMessageColor"] == null ? "" : node["SpawnMessageColor"].InnerText;
if (msg != "")
{
if (color == "")
{
dat.spawnMessage = new InformationMessage(msg, Color.Black);
}
else
{
Color c = UX.GetMessageColour(color) == "" ? (color[0] == '#'? Color.ConvertStringToColor(color) : Color.Black) : Color.ConvertStringToColor(UX.GetMessageColour(color));
dat.spawnMessage = new InformationMessage(msg, c);
}
}
//handle extra linear speed.
float extraSpeed = float.MinValue;
if (node["ExtraLinearSpeed"] != null)
{
if (!float.TryParse(node["ExtraLinearSpeed"].InnerText, out extraSpeed))
{
throw new Exception("ExtraLinearSpeed must be a float value! ");
}
Main.customSpeedModel.RegisterPartyExtraSpeed(dat.PartyTemplate.StringId, extraSpeed);
}
//handle base speed override
float baseSpeedOverride = float.MinValue;
if (node["BaseSpeedOverride"] != null)
{
if (!float.TryParse(node["BaseSpeedOverride"].InnerText, out baseSpeedOverride))
{
throw new Exception("BaseSpeedOverride must be a float value! ");
}
Main.customSpeedModel.RegisterPartyBaseSpeed(dat.PartyTemplate.StringId, baseSpeedOverride);
}
else
{
Main.customSpeedModel.RegisterPartyBaseSpeed(dat.PartyTemplate.StringId, float.MinValue);
}
//patrol around closest lest interrupted and switch
if (node["PatrolAroundClosestLestInterruptedAndSwitch"] != null)
{
bool val = false;
if (!bool.TryParse(node["PatrolAroundClosestLestInterruptedAndSwitch"].InnerText, out val))
{
break;
}
if (!val)
{
break;
}
XmlNode innerNode = node["PatrolAroundClosestLestInterruptedAndSwitch"];
float minDays = 0;
float maxDays = 10;
List <SpawnSettlementType> TryPatrolAround = new List <SpawnSettlementType>();
try
{
if (!float.TryParse(innerNode.Attributes["min_stable_days"].InnerText, out minDays))
{
throw new Exception("min_stable_days must be a float value!");
}
if (!float.TryParse(innerNode.Attributes["max_stable_days"].InnerText, out maxDays))
{
throw new Exception("max_stable_days must be a float value!");
}
if (innerNode.Attributes["try_patrol_around"] != null && innerNode.Attributes["try_patrol_around"].InnerText != "")
{
TryPatrolAround = ConstructTrySettlementList(innerNode.Attributes["try_patrol_around"].InnerText);
}
}catch
{
throw new Exception("not all attributes in PatrolAroundClosestLestInterruptedAndSwitch were filled properly!");
}
dat.PatrolAroundClosestLestInterruptedAndSwitch =
new AI.PatrolAroundClosestLestInterruptedAndSwitchBehaviour.PatrolAroundClosestLestInterruptedAndSwitchBehaviourData(null, minDays, maxDays, TryPatrolAround);
}
//min max party speed modifiers
float minSpeed = float.MinValue;
if (node["MinimumFinalSpeed"] != null)
{
if (!float.TryParse(node["MinimumFinalSpeed"].InnerText, out minSpeed))
{
throw new Exception("MinimumFinalSpeed must be a float value! ");
}
Main.customSpeedModel.RegisterPartyMinimumSpeed(dat.PartyTemplate.StringId, minSpeed);
}
float maxSpeed = float.MinValue;
if (node["MaximumFinalSpeed"] != null)
{
if (!float.TryParse(node["MaximumFinalSpeed"].InnerText, out maxSpeed))
{
throw new Exception("MaximumFinalSpeed must be a float value! ");
}
Main.customSpeedModel.RegisterPartyMaximumSpeed(dat.PartyTemplate.StringId, maxSpeed);
}
//Spawn along with
int k = 0;
string str = "spawn_along_with";
while (true)
{
string s1 = str + "_" + k.ToString();
if (node.Attributes[s1] == null || node.Attributes[s1].InnerText == "")
{
break;
}
else
{
PartyTemplateObject pt = (PartyTemplateObject)MBObjectManager.Instance.ReadObjectReferenceFromXml(s1, typeof(PartyTemplateObject), node);
dat.SpawnAlongWith.Add(new AccompanyingParty(pt, NameSignifierData.Instance.GetPartyNameFromID(pt.StringId),
NameSignifierData.Instance.GetPartyFollowBehaviourFlagFromID(pt.StringId)));
Main.customSpeedModel.RegisterPartyExtraSpeed(pt.StringId, NameSignifierData.Instance.GetSpeedModifierFromID(pt.StringId));
Main.customSpeedModel.RegisterPartyBaseSpeed(pt.StringId, NameSignifierData.Instance.GetBaseSpeedModifierOverrideFromID(pt.StringId));
if (minSpeed != float.MinValue)
{
Main.customSpeedModel.RegisterPartyMinimumSpeed(pt.StringId, minSpeed);
}
if (maxSpeed != float.MinValue)
{
Main.customSpeedModel.RegisterPartyMaximumSpeed(pt.StringId, maxSpeed);
}
}
k++;
}
data.Add(dat);
if (!partyIDtoData.ContainsKey(dat.PartyTemplate.StringId)) //TODO add way to alert modder that he should use one party template for one AI
{
partyIDtoData.Add(dat.PartyTemplate.StringId, dat);
}
}
}
catch (Exception e)
{
ErrorHandler.HandleException(e, "Spawn Data Parsing of " + filePath);
}
}
public static MobileParty SpawnParty(Settlement spawnedSettlement, Clan clan, PartyTemplateObject templateObject, MobileParty.PartyTypeEnum partyType, TextObject partyName = null, PartyTemplateObject templatePrisoners = null, bool IsInheritClan = false)
{
//get name and show message.
TextObject textObject = partyName ?? clan.Name;
ModDebug.ShowMessage("CustomSpawns: Spawning " + textObject.ToString() + " at " + spawnedSettlement.GatePosition + " in settlement " + spawnedSettlement.Name.ToString(), DebugMessageType.Spawn);
//create.
MobileParty mobileParty = MBObjectManager.Instance.CreateObject <MobileParty>(templateObject.StringId + "_" + 1);
if (templatePrisoners != null)
{
mobileParty.InitializeMobileParty(textObject, ConstructTroopRoster(templateObject, mobileParty.Party), ConstructTroopRoster(templatePrisoners, mobileParty.Party), spawnedSettlement.GatePosition, 0);
}
else
{
mobileParty.InitializeMobileParty(textObject, ConstructTroopRoster(templateObject, mobileParty.Party), new TroopRoster(mobileParty.Party), spawnedSettlement.GatePosition, 0);
}
//initialize
Clan settlementClan = spawnedSettlement.OwnerClan;
if (IsInheritClan == true)
{
Spawner.InitParty(mobileParty, textObject, settlementClan, spawnedSettlement);
}
else
{
Spawner.InitParty(mobileParty, textObject, clan, spawnedSettlement);
}
return(mobileParty);
}
public bool accompanyMainParty; //TODO implement this!!
public AccompanyingParty(PartyTemplateObject pt, string n, bool accompanyMainParty)
{
templateObject = pt;
name = n;
this.accompanyMainParty = accompanyMainParty;
}
internal void CECaptorPrisonerRebel(MenuCallbackArgs args)
{
CEPersistence.animationPlayEvent = false;
TroopRoster releasedPrisoners = TroopRoster.CreateDummyTroopRoster();
try
{
foreach (TroopRosterElement element in MobileParty.MainParty.PrisonRoster.GetTroopRoster())
{
if (element.Character.IsHero)
{
element.Character.HeroObject.ChangeState(Hero.CharacterStates.Active);
}
}
releasedPrisoners.Add(MobileParty.MainParty.PrisonRoster.ToFlattenedRoster());
MobileParty.MainParty.PrisonRoster.Clear();
}
catch (Exception)
{
CECustomHandler.LogToFile("Couldn't find anymore prisoners.");
}
if (!releasedPrisoners.GetTroopRoster().IsEmpty())
{
try
{
TroopRosterElement leader = releasedPrisoners.GetTroopRoster().FirstOrDefault(hasHero => hasHero.Character.IsHero);
Clan clan = null;
Settlement nearest = null;
MobileParty prisonerParty = null;
if (leader.Character != null)
{
clan = leader.Character.HeroObject.Clan;
nearest = SettlementHelper.FindNearestSettlement(settlement => settlement.OwnerClan == clan) ?? SettlementHelper.FindNearestSettlement(settlement => true);
prisonerParty = LordPartyComponent.CreateLordParty("CustomPartyCE_" + MBRandom.RandomInt(int.MaxValue), leader.Character.HeroObject, MobileParty.MainParty.Position2D, 0.5f, nearest);
}
else
{
clan = Clan.BanditFactions.First(clanLooters => clanLooters.StringId == "looters");
clan.Banner.SetBannerVisual(Banner.CreateRandomBanner().BannerVisual);
nearest = SettlementHelper.FindNearestSettlement(settlement => true);
prisonerParty = BanditPartyComponent.CreateBanditParty("CustomPartyCE_" + MBRandom.RandomInt(int.MaxValue), clan, nearest.Hideout, false);
}
PartyTemplateObject defaultPartyTemplate = clan.DefaultPartyTemplate;
prisonerParty.InitializeMobileParty(defaultPartyTemplate, MobileParty.MainParty.Position2D, 0.5f, 0.1f, -1);
prisonerParty.SetCustomName(new TextObject("{=CEEVENTS1107}Escaped Captives"));
prisonerParty.MemberRoster.Clear();
prisonerParty.ActualClan = clan;
prisonerParty.MemberRoster.Add(releasedPrisoners.ToFlattenedRoster());
prisonerParty.IsActive = true;
prisonerParty.HomeSettlement = nearest;
prisonerParty.SetMovePatrolAroundPoint(nearest.IsTown
? nearest.GatePosition
: nearest.Position2D);
if (leader.Character != null)
{
prisonerParty.Party.Owner = leader.Character.HeroObject;
#if BETA
prisonerParty.ChangePartyLeader(leader.Character);
#else
prisonerParty.ChangePartyLeader(leader.Character, true);
#endif
}
else
{
prisonerParty.Party.Owner = clan.Leader;
}
prisonerParty.RecentEventsMorale = -100;
prisonerParty.Aggressiveness = 0.2f;
prisonerParty.InitializePartyTrade(0);
Hero.MainHero.HitPoints += 40;
CECustomHandler.LogToFile(prisonerParty.Leader.Name.ToString());
PlayerEncounter.RestartPlayerEncounter(MobileParty.MainParty.Party, prisonerParty.Party);
GameMenu.SwitchToMenu("encounter");
}
catch (Exception)
{
CECaptorContinue(args);
}
}
else
{
CECaptorContinue(args);
}
}
