public static int GetMaxCounts(ref CraftingCampaignBehavior instance, Hero hero, Crafting.RefiningFormula refineFormula)
{
ItemRoster itemRoster = MobileParty.MainParty.ItemRoster;
int energyCostForRefining = Campaign.Current.Models.SmithingModel.GetEnergyCostForRefining(ref refineFormula, hero);
int result;
if (energyCostForRefining <= 0)
{
result = 2147483647;
}
else
{
result = instance.GetHeroCraftingStamina(hero) / energyCostForRefining;
}
if (refineFormula.Input1Count > 0)
{
ItemObject craftingMaterialItem1;
int input1result;
craftingMaterialItem1 = Campaign.Current.Models.SmithingModel.GetCraftingMaterialItem(refineFormula.Input1);
input1result = MaxForInput(itemRoster, craftingMaterialItem1, refineFormula.Input1Count);
result = input1result;
}
if (refineFormula.Input2Count > 0)
{
ItemObject craftingMaterialItem2;
int input2result;
craftingMaterialItem2 = Campaign.Current.Models.SmithingModel.GetCraftingMaterialItem(refineFormula.Input2);
input2result = MaxForInput(itemRoster, craftingMaterialItem2, refineFormula.Input2Count);
return(Math.Min(result, input2result));
}
return(result);
}
internal static void TrySplitParty(MobileParty mobileParty)
{
if (MilitiaPowerPercent > Globals.Settings.GlobalPowerPercent ||
mobileParty.MemberRoster.TotalManCount < MinSplitSize ||
!mobileParty.IsBM() ||
mobileParty.IsTooBusyToMerge())
{
return;
}
var roll = Rng.Next(0, 101);
if (roll > Globals.Settings.RandomSplitChance ||
mobileParty.Party.MemberRoster.TotalManCount > Math.Max(1, CalculatedMaxPartySize * ReductionFactor))
{
return;
}
var party1 = TroopRoster.CreateDummyTroopRoster();
var party2 = TroopRoster.CreateDummyTroopRoster();
var prisoners1 = TroopRoster.CreateDummyTroopRoster();
var prisoners2 = TroopRoster.CreateDummyTroopRoster();
var inventory1 = new ItemRoster();
var inventory2 = new ItemRoster();
SplitRosters(mobileParty, party1, party2, prisoners1, prisoners2, inventory1, inventory2);
CreateSplitMilitias(mobileParty, party1, party2, prisoners1, prisoners2, inventory1, inventory2);
}
public static int GetMaxCounts(ref CraftingCampaignBehavior instance, Hero hero, EquipmentElement equipmentElement)
{
ItemRoster itemRoster = MobileParty.MainParty.ItemRoster;
int energyCostForSmelting = Campaign.Current.Models.SmithingModel.GetEnergyCostForSmelting(equipmentElement.Item, hero);
int result;
if (energyCostForSmelting <= 0)
{
result = 2147483647;
}
else
{
result = instance.GetHeroCraftingStamina(hero) / energyCostForSmelting;
}
int[] smeltingOutputForItem = Campaign.Current.Models.SmithingModel.GetSmeltingOutputForItem(equipmentElement.Item);
for (int i = 0; i < 9; i++)
{
if (smeltingOutputForItem[i] < 0)
{
result = Math.Min(result, MaxForInput(itemRoster, Campaign.Current.Models.SmithingModel.GetCraftingMaterialItem((CraftingMaterials)i), smeltingOutputForItem[i]));
}
}
//return Math.Min(result, MaxForInput(itemRoster, item, 1));
return(result);
}
internal static void TrySplitParty(MobileParty mobileParty)
{
if (GlobalMilitiaPower + mobileParty.Party.TotalStrength > CalculatedGlobalPowerLimit ||
mobileParty.MemberRoster.TotalManCount < MinSplitSize ||
!IsBM(mobileParty) ||
mobileParty.IsTooBusyToMerge())
{
return;
}
var roll = Rng.NextDouble();
if (roll <= Globals.Settings.RandomSplitChance ||
!IsBM(mobileParty) ||
mobileParty.Party.TotalStrength <= CalculatedMaxPartyStrength * Globals.Settings.StrengthSplitFactor * Variance ||
mobileParty.Party.MemberRoster.TotalManCount <= CalculatedMaxPartySize * Globals.Settings.SizeSplitFactor * Variance)
{
return;
}
var party1 = TroopRoster.CreateDummyTroopRoster();
var party2 = TroopRoster.CreateDummyTroopRoster();
var prisoners1 = TroopRoster.CreateDummyTroopRoster();
var prisoners2 = TroopRoster.CreateDummyTroopRoster();
var inventory1 = new ItemRoster();
var inventory2 = new ItemRoster();
SplitRosters(mobileParty, party1, party2, prisoners1, prisoners2, inventory1, inventory2);
CreateSplitMilitias(mobileParty, party1, party2, prisoners1, prisoners2, inventory1, inventory2);
}
private void ArmouryOnConsequence(MenuCallbackArgs args)
{
ItemRoster itemRoster = new ItemRoster();
string culture = Settlement.CurrentSettlement.Culture.StringId;
List <string> cultureItems = new List <string>();
CULTURE_TO_ITEMS_DICT.TryGetValue(culture, out cultureItems);
int itemSelectionCount = RANDOM.Next(MIN_ITEM_SELECTION_COUNT, MAX_ITEM_SELECTION_COUNT);
for (int i = 0; i < itemSelectionCount; i++)
{
ItemObject cultureItem = MBObjectManager.Instance.GetObject <ItemObject>(cultureItems.GetRandomElement());
if (cultureItem != null)
{
itemRoster.AddToCounts(cultureItem, RANDOM.Next(MIN_ITEM_COUNT, MAX_ITEM_COUNT));
}
ItemObject swadianItem = MBObjectManager.Instance.GetObject <ItemObject>(SWADIAN_ITEMS.GetRandomElement());
if (swadianItem != null)
{
itemRoster.AddToCounts(swadianItem, RANDOM.Next(MIN_ITEM_COUNT, MAX_ITEM_COUNT));
}
}
InventoryManager.OpenScreenAsTrade(itemRoster, Settlement.CurrentSettlement.Town, InventoryManager.InventoryCategoryType.None, null);
}
public static bool DetermineTownHasSufficientInputsReplacement(WorkshopType.Production production, Town town, out int inputMaterialCost)
{
ItemRoster stashRoster = null;
for (int i = 0; i < town.Workshops.Length; i++)
{
if (town.Workshops[i].Owner == Hero.MainHero)
{
bool didWeFindIt = CampaignChanger.Current.QuickAccess.TryGetValue(town, out var stash);
if (didWeFindIt && stash.InputTrue)
{
stashRoster = stash.Stash;
}
}
}
inputMaterialCost = 0;
using (IEnumerator <ValueTuple <ItemCategory, int> > enumerator = production.Inputs.GetEnumerator())
{
while (enumerator.MoveNext())
{
ValueTuple <ItemCategory, int> current = enumerator.Current;
ItemCategory item1 = current.Item1;
int item2 = current.Item2;
ItemRoster itemRoster = town.Owner.ItemRoster;
int num1 = 0;
if (stashRoster != null)
{
for (int a = 0; a < stashRoster.Count; a++)
{
ItemObject itemAtIndex1 = stashRoster.GetItemAtIndex(a);
if (itemAtIndex1.ItemCategory == item1)
{
num1 = stashRoster.GetElementNumber(a);
}
}
}
for (int i = 0; i < itemRoster.Count; i++)
{
ItemObject itemAtIndex = itemRoster.GetItemAtIndex(i);
if (itemAtIndex.ItemCategory == item1)
{
int num = Math.Min(item2, itemRoster.GetElementNumber(i));
item2 = item2 + num1 - num;
inputMaterialCost = inputMaterialCost + town.GetItemPrice(itemAtIndex, null, false) * num;
}
}
if (item2 >= 0)
{
continue;
}
return(false);
}
return(true);
}
}
/// <summary>
/// Fills the <paramref name="armoury"/> with items of given <paramref name="cultureName"/>, if found.
/// </summary>
private void PopulateItemList(ItemRoster armoury, string cultureName)
{
XElement cultureElement = _settings.Descendants(cultureName.ToProper()).FirstOrDefault();
if (cultureElement is null)
{
return;
}
IEnumerable <XElement> cultureItems = cultureElement.Descendants("Item");
if (cultureItems.Count() < 1)
{
return;
}
foreach (XElement item in cultureItems)
{
try {
int rng = MBRandom.RandomInt(item.Attribute("minCount").ToInt(), item.Attribute("maxCount").ToInt());
string itemId = item.Attribute("name").Value;
ItemObject itemToAdd = MBObjectManager.Instance.GetObject <ItemObject>(itemId);
armoury.AddToCounts(itemToAdd, rng);
} catch { }
}
}
private static IEnumerable <ItemRosterElement> LootCasualties2(ICollection <TroopRosterElement> shareFromCasualties, float lootChance)
{
// MobileParty.GetMainPartySkillCounsellor(DefaultSkills.Roguery).GetSkillValue(DefaultSkills.Roguery)
ItemRoster itemRosters = new ItemRoster();
Dictionary <string, int> loots = new Dictionary <string, int>();
lootChance = MathF.Clamp(lootChance * 1.3f, 20f, 95f);
foreach (TroopRosterElement casualty in shareFromCasualties)
{
Equipment randomEquipment = GetRandomEquipment(casualty.Character);
var potentialLootItems = GetItemsFromEquipmentSlots(randomEquipment);
foreach (ItemObject item in potentialLootItems)
{
float rdm = MBRandom.RandomFloatRanged(100f);
if (rdm < lootChance)
{
if (loots.ContainsKey(item.StringId))
{
loots[item.StringId] += 1;
}
else
{
loots.Add(item.StringId, 1);
}
}
}
}
foreach (var stringId in loots.Keys)
{
itemRosters.Add(new ItemRosterElement(MBObjectManager.Instance.GetObject <ItemObject>(stringId), loots[stringId]));
}
return(itemRosters);
}
public static void Postfix(PartyScreenLogic.PartyCommand command)
{
DropChance dc = new DropChance();
double dropChance = dc.CalculateChance();
Random random = new Random();
CharacterObject character = command.Character;
for (int index = 0; index < 12; ++index)
{
try
{
if (random.NextDouble() < dropChance)
{
EquipmentElement equipmentElement = character.Equipment.GetEquipmentFromSlot((EquipmentIndex)index);
if (equipmentElement.Item != null)
{
ItemRoster itemRoster = PartyBase.MainParty.ItemRoster;
equipmentElement = character.Equipment.GetEquipmentFromSlot((EquipmentIndex)index);
itemRoster.AddToCounts(equipmentElement.Item, 1, true);
SubModule.WriteDebugMessage(equipmentElement.Item.Name.ToString() + " was looted");
}
}
}
catch (Exception ex)
{
SubModule.WriteDebugMessage(ex.Message);
}
}
}
public static void Initialize(
ref ItemRoster leftItemRoster,
ref MobileParty party,
ref bool isTrading,
ref bool isSpecialActionsPermitted,
ref CharacterObject initialCharacterOfRightRoster,
ref InventoryManager.InventoryCategoryType merchantItemType,
ref IMarketData marketData,
ref bool useBasePrices,
ref TextObject leftRosterName)
{
try
{
if (party.IsPlayerParty() &&
!isTrading &&
!Game.Current.CheatMode &&
BannerlordCheatsSettings.Instance?.NativeItemSpawning == true)
{
var objectTypeList = Game.Current.ObjectManager.GetObjectTypeList <ItemObject>();
for (var index = 0; index != objectTypeList.Count; ++index)
{
var itemObject = objectTypeList[index];
leftItemRoster.AddToCounts(itemObject, 10);
}
}
}
catch (Exception e)
{
SubModule.LogError(e, typeof(NativeItemSpawning));
}
}
public static void ConsumeFood(int amount, PartyBase party)
{
if (amount <= 0)
{
return;
}
else
{
ItemRoster itemRoster = party.ItemRoster;
int FoodAmount = MoreSettlementActionHelper.GetFoodAmount(PartyBase.MainParty);
int number = rng.Next(1, FoodAmount);
int count = 0;
for (int i = itemRoster.Count - 1; i >= 0; i--)
{
if (itemRoster[i].EquipmentElement.Item.IsFood)
{
count += itemRoster[i].Amount;
if (number <= count)
{
itemRoster.AddToCounts(itemRoster[i].EquipmentElement.Item, -1);
break;
}
}
}
ConsumeFood(amount - 1, party);
}
}
/*
* Private functions pulled from decompiled binary (unmodified)
*/
// Token: 0x06002007 RID: 8199 RVA: 0x00082F98 File Offset: 0x00081198
private static void AddCargoStats(MobileParty mobileParty, ref int numberOfAvailableMounts, ref float totalWeightCarried, ref int herdSize)
{
ItemRoster itemRoster = mobileParty.ItemRoster;
int numberOfPackAnimals = itemRoster.NumberOfPackAnimals;
int numberOfLivestockAnimals = itemRoster.NumberOfLivestockAnimals;
herdSize += numberOfPackAnimals + numberOfLivestockAnimals;
numberOfAvailableMounts += itemRoster.NumberOfMounts;
totalWeightCarried += itemRoster.TotalWeight;
}
public TournamentPrizePool(int rerolls = -1)
{
Prizes = new ItemRoster();
SelectedPrizeStringId = "";
RemainingRerolls = TournamentXPSettings.Instance.MaxNumberOfRerollsPerTournament;
if (rerolls >= 0)
{
RemainingRerolls = rerolls;
}
}
public void AddEquipmentItemsToItemRoster_WithANullEquipment_ReturnsAnEmptyItemRoster()
{
EquipmentToItemRosterHandler equipmentToItemRosterHandler = new EquipmentToItemRosterHandler();
Equipment equipment = null;
ItemRoster expected = new ItemRoster();
ItemRoster actual = equipmentToItemRosterHandler.AddEquipmentItemsToItemRoster(equipment);
CollectionAssert.AreEqual(expected, actual);
}
private static int MaxForInput(ItemRoster itemRoster, ItemObject inputitem, int inputcount)
{
int itemnumber = itemRoster.GetItemNumber(inputitem);
if (itemnumber <= 0)
{
return(0);
}
return(itemnumber / Math.Abs(inputcount));
}
public static bool DetermineTownHasSufficientInputsReplacement(WorkshopType.Production production, Town town, out int inputMaterialCost, Workshop workshop)
{
ItemRoster stashRoster = null;
if (workshop.Owner == Hero.MainHero)
{
var stash = MBObjectManager.Instance.GetObject <TownWorkshopStash>(x => x.Town == town);
if (stash != null && stash.InputFromStash)
{
stashRoster = stash.Stash;
}
}
IReadOnlyList <ValueTuple <ItemCategory, int> > inputs = production.Inputs;
inputMaterialCost = 0;
foreach (ValueTuple <ItemCategory, int> valueTuple in inputs)
{
ItemCategory itemCategory = valueTuple.Item1;
int val1 = valueTuple.Item2;
if (stashRoster != null)
{
for (int index = 0; index < stashRoster.Count; ++index)
{
ItemObject itemAtIndex = stashRoster.GetItemAtIndex(index);
if (itemAtIndex.ItemCategory == itemCategory)
{
int elementNumber = stashRoster.GetElementNumber(index);
int num = Math.Min(val1, elementNumber);
val1 -= num;
}
}
}
ItemRoster itemRoster = town.Owner.ItemRoster;
for (int index = 0; index < itemRoster.Count; ++index)
{
ItemObject itemAtIndex = itemRoster.GetItemAtIndex(index);
if (itemAtIndex.ItemCategory == itemCategory)
{
int elementNumber = itemRoster.GetElementNumber(index);
int num = Math.Min(val1, elementNumber);
val1 -= num;
inputMaterialCost += town.GetItemPrice(itemAtIndex, null, false) * num;
}
}
if (val1 > 0)
{
return(false);
}
}
return(true);
}
public SlaveEstate()
{
_village = Settlement.CurrentSettlement.Village;
_prisoners = TroopRoster.CreateDummyTroopRoster();
_stockpile = new ItemRoster();
_product = FindProduct(_village);
_logs = new List <DailyLog>();
_surgeon_house_level = 0;
_overseer_house_level = 0;
_tool_repair_workshop_level = 0;
}
public void ChangeAmountOfAllItemsTo_WithANullItemRoster_ReturnsAnEmptyItemRoster()
{
int itemAmount = 0;
ItemRoster input = null;
ItemRoster expected = GetEmptyItemRoster();
ItemRosterItemAmountHandler itemRosterItemAmountHandler = new ItemRosterItemAmountHandler();
ItemRoster actual = itemRosterItemAmountHandler.ChangeAmountOfAllItemsTo(input, itemAmount);
CollectionAssert.AreEqual(expected, actual);
}
public void AddEquipmentItemsToItemRoster_WithEquipmentHavingValidItemsOnly_ReturnsItemRosterWithTheSameEquipmentItems()
{
EquipmentToItemRosterHandler equipmentToItemRosterHandler = new EquipmentToItemRosterHandler();
Equipment equipment = GetEquipmentWithValidItemsOnly();
IEnumerable <EquipmentElement> expectedEquipmentElements = GetEquipmentElementsByEquipmentIndexOrder(equipment);
ItemRoster itemRoster = equipmentToItemRosterHandler.AddEquipmentItemsToItemRoster(equipment);
Assert.NotNull(expectedEquipmentElements);
CollectionAssert.AreEquivalent(expectedEquipmentElements, itemRoster); // Uses Equals(ItemRosterElement) method from EquipmentElement object. Ignore Order of items.
}
private static ItemRoster GetItemRosterWithInvalidItemObjectsOnly(int items)
{
ItemRoster itemRoster = GetEmptyItemRoster();
for (var index = 0; index < items; index++)
{
itemRoster.Add(ItemRosterElement.Invalid);
}
return(itemRoster);
}
public void ChangeAmountOfAllItemsTo_WithANegativeAmount_ReturnsAnEmptyItemRoster()
{
int maxItems = GetMaxItemsInEquipment();
int itemAmount = 0;
ItemRoster input = GetItemRosterWithInvalidItemRosterElements(maxItems);
ItemRoster expected = GetEmptyItemRoster();
ItemRosterItemAmountHandler itemRosterItemAmountHandler = new ItemRosterItemAmountHandler();
ItemRoster actual = itemRosterItemAmountHandler.ChangeAmountOfAllItemsTo(input, itemAmount);
CollectionAssert.AreEqual(expected, actual);
}
public void ChangeAmountOfAllItemsTo_WithAnAmountGreaterThanIntMax_ReturnsItemRosterWithIntMaxAmounts()
{
int maxItems = GetMaxItemsInEquipment();
int maxAmount = int.MaxValue;
ItemRoster input = GetItemRosterWithDefaultValidItemObjectsOnly(maxItems, 0);
ItemRoster expected = GetItemRosterWithDefaultValidItemObjectsOnly(maxItems, int.MaxValue);
ItemRosterItemAmountHandler itemRosterItemAmountHandler = new ItemRosterItemAmountHandler();
ItemRoster actual = itemRosterItemAmountHandler.ChangeAmountOfAllItemsTo(input, maxAmount + 1); // Int Overflow
CollectionAssert.AreEquivalent(expected, actual); // Order does not matter
}
private static ItemRoster GetItemRosterWithDefaultValidItemObjectsOnly(int items, int defaultAmount)
{
ItemRoster itemRoster = GetEmptyItemRoster();
for (var index = 0; index < items; index++)
{
ItemRosterElement defaultItemRosterElement = new ItemRosterElement(new ItemObject(), defaultAmount, new ItemModifier());
itemRoster.Add(defaultItemRosterElement);
}
return(itemRoster);
}
private static void Postfix(SmeltingVM __instance, ItemRoster ____playerItemRoster)
{
foreach (SmeltingItemVM item in __instance.SmeltableItemList)
{
int count = SmeltingHelper.GetNewPartsFromSmelting(item.Item).Count();
if (count > 0)
{
string parts = count == 1 ? "part" : "parts";
item.Name = item.Name + $" ({count} new {parts})";
}
}
}
private static void AddEquipmentToPartyInventory(Equipment equipment, ItemRoster partyInventory)
{
for (EquipmentIndex index = EquipmentIndex.WeaponItemBeginSlot; index < EquipmentIndex.NumEquipmentSetSlots; index++)
{
ItemObject itemObject = equipment[index].Item;
ItemModifier itemModifier = equipment[index].ItemModifier;
if (itemObject == null)
{
continue;
}
partyInventory.Add(new ItemRosterElement(itemObject, 1, itemModifier));
}
}
public static int GetFoodAmount(PartyBase party)
{
int amount = 0;
ItemRoster itemRoster = party.ItemRoster;
for (int i = itemRoster.Count - 1; i >= 0; i--)
{
if (itemRoster[i].EquipmentElement.Item.IsFood)
{
amount += itemRoster[i].Amount;
}
}
return(amount);
}
private static bool HasEnoughCraftingMaterial(ItemRoster roster, RefiningFormula formula)
{
bool result = true;
if (formula.Input1Count > 0)
{
result = result && roster.GetItemNumber(Campaign.Current.Models.SmithingModel.GetCraftingMaterialItem(formula.Input1)) >= formula.Input1Count;
}
if (formula.Input2Count > 0)
{
result = result && roster.GetItemNumber(Campaign.Current.Models.SmithingModel.GetCraftingMaterialItem(formula.Input2)) >= formula.Input2Count;
}
return(result);
}
public static void Postfix(PartyScreenLogic.PartyCommand command)
{
Random random = new Random();
CharacterObject character = command.Character;
for (int i = 0; i < 12; i++)
{
if (character.HeroObject.BattleEquipment[i].Item != null)
{
ItemRoster itemRoster = PartyBase.MainParty.ItemRoster;
EquipmentElement item = character.HeroObject.BattleEquipment[i];
itemRoster.AddToCounts(item.Item, 1, true);
item = character.HeroObject.BattleEquipment[i];
InformationManager.DisplayMessage(new InformationMessage(string.Concat(item.Item.Name.ToString(), " Added to inventory")));
}
}
}
private static void Postfix(SmeltingVM __instance, ItemRoster ____playerItemRoster)
{
// This appears to be how the game works out if an item is locked
// From TaleWorlds.CampaignSystem.ViewModelCollection.SPInventoryVM.InitializeInventory()
IEnumerable <EquipmentElement> locks = Campaign.Current.GetCampaignBehavior <TaleWorlds.CampaignSystem.SandBox.CampaignBehaviors.IInventoryLockTracker>().GetLocks();
// Updated line 24 to Line 25 which seems to be the updated way game works out item locks in v1.4.3 InitializeInventory()
// EquipmentElement[] locked_items = locks?.ToArray<EquipmentElement>();
EquipmentElement[] locked_items = (locks != null) ? locks.ToArray <EquipmentElement>() : null;
bool isLocked(EquipmentElement test_item)
{
return(locked_items != null && locked_items.Any(delegate(EquipmentElement x)
{
ItemObject lock_item = x.Item;
if (lock_item.StringId == test_item.Item.StringId)
{
ItemModifier itemModifier = x.ItemModifier;
string a = itemModifier?.StringId;
ItemModifier itemModifier2 = test_item.ItemModifier;
return a == (itemModifier2?.StringId);
}
return false;
}));
}
MBBindingList <SmeltingItemVM> filteredList = new MBBindingList <SmeltingItemVM>();
foreach (SmeltingItemVM sItem in __instance.SmeltableItemList)
{
if (!____playerItemRoster.Any(rItem =>
sItem.Item == rItem.EquipmentElement.Item && isLocked(rItem.EquipmentElement)
))
{
filteredList.Add(sItem);
}
}
__instance.SmeltableItemList = filteredList;
if (__instance.SmeltableItemList.Count == 0)
{
__instance.CurrentSelectedItem = null;
}
}
private void OnConsequence(MenuCallbackArgs args)
{
if (_paymentMethod == PaymentMethod.Disabled)
{
return;
}
switch (_paymentMethod)
{
case PaymentMethod.Gold:
int gold = Hero.MainHero.Gold;
if (gold < _entryCost)
{
return;
}
Hero.MainHero.ChangeHeroGold(_entryCost * -1);
break;
case PaymentMethod.Influence:
float influence = Hero.MainHero.Clan.Influence;
if (influence < _entryCost)
{
return;
}
Hero.MainHero.Clan.Influence -= _entryCost;
break;
}
ItemRoster armoury = new ItemRoster();
string townCulture = "vlandia";
try {
townCulture = Settlement.CurrentSettlement.OwnerClan.Kingdom.Culture.StringId;
} catch { }
PopulateItemList(armoury, townCulture);
PopulateItemList(armoury, "Any");
InventoryManager.OpenScreenAsTrade(armoury, Settlement.CurrentSettlement.Town);
}
