/// <summary>
/// Returns item value based on the filter settings and item properties
/// </summary>
/// <param name="sourceItem">inventory item</param>
/// <param name="slot">equipment index slot</param>
/// <returns>item value</returns>
public float ItemIndexCalculation(EquipmentElement sourceItem, EquipmentIndex slot)
{
// Given a item is "empty", return with big negative number
if (sourceItem.IsEmpty)
{
return(-9999f);
}
float value = 0f;
CharacterSettings characterSettings = _characterData.GetCharacterSettings();
// Calculation for armor items
if (sourceItem.Item.HasArmorComponent)
{
return(_bestEquipmentCalculator.CalculateArmorValue(sourceItem,
_characterData.GetCharacterSettings().FilterArmor[GetEquipmentSlot(slot)]));
}
// Calculation for weapon items
if (sourceItem.Item.PrimaryWeapon != null)
{
return(_bestEquipmentCalculator.CalculateWeaponValue(sourceItem,
_characterData.GetCharacterSettings().FilterWeapon[GetEquipmentSlot(slot)]));
}
// Calculation for horse component
if (sourceItem.Item.HasHorseComponent)
{
return(_bestEquipmentCalculator.CalculateHorseValue(sourceItem,
_characterData.GetCharacterSettings().FilterMount));
}
return(value);
}
internal void WatchPlayerStuff(Player player, string selectedType)
{
EquipmentElement type = EquipmentElement.Unknown;
switch (selectedType)
{
case "smokes":
type = EquipmentElement.Smoke;
break;
case "flashbangs":
type = EquipmentElement.Flash;
break;
case "he":
type = EquipmentElement.HE;
break;
case "molotovs":
type = EquipmentElement.Molotov;
break;
case "decoys":
type = EquipmentElement.Decoy;
break;
}
GeneratePlayerStuffVdm(player, type);
StartGame();
}
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 void SetWeapon(EquipmentElement key)
{
currentWeapon = key;
EquipmentElement weaponKey = key;
if (!weapons.ContainsKey(weaponKey))
{
weaponKey = EquipmentElement.Unknown;
}
GameObject weaponGO = null;
foreach (var weapon in weapons)
{
weapon.Value.gameObject.SetActive(weapon.Key == weaponKey);
if (weapon.Key == weaponKey)
{
weaponGO = weapon.Value;
}
}
if (weaponGO)
{
foreach (Transform child in weaponGO.transform)
{
if (child.CompareTag("GunFlash"))
{
gunFlash = child.gameObject;
}
}
}
}
private static void AssignHighTierEquipment(Equipment heroEquipment, Equipment sourceEquipment)
{
if (heroEquipment == null || sourceEquipment == null)
{
return;
}
for (EquipmentIndex equipmentIndex = EquipmentIndex.WeaponItemBeginSlot; equipmentIndex < EquipmentIndex.NumEquipmentSetSlots; ++equipmentIndex)
{
EquipmentElement sourceElement = sourceEquipment[equipmentIndex];
EquipmentElement heroElement = heroEquipment[equipmentIndex];
if (sourceElement.IsEmpty || sourceElement.Item == null)
{
continue;
}
if (!heroElement.IsEmpty && heroElement.Item != null)
{
if (heroElement.Item.Type != sourceElement.Item.Type)
{
continue;
}
if (heroElement.Item.Tier >= sourceElement.Item.Tier)
{
continue;
}
}
heroEquipment[equipmentIndex] = sourceElement;
}
}
public static void WriteLootMessage(EquipmentElement _equipmentFromSlot, bool _isEnemy = true)
{
string message = _equipmentFromSlot.Item.Name.ToString();
string side = _isEnemy ? "enemy:" : "ally:";
if(LootOverhaulSettings.Instance.ShowLootMessages || LootOverhaulSettings.Instance.DebugEnabled)
InformationManager.DisplayMessage(new InformationMessage("Looted " + side+" "+message, Color.FromUint(4282569842U)));
}
protected override bool OnRead()
{
bool bufferReadValid = true;
this.Peer = GameNetworkMessage.ReadNetworkPeerReferenceFromPacket(ref bufferReadValid);
this.VisualsIndex = GameNetworkMessage.ReadIntFromPacket(CompressionMission.AgentOffsetCompressionInfo, ref bufferReadValid);
this.Character = (BasicCharacterObject)GameNetworkMessage.ReadObjectReferenceFromPacket(MBObjectManager.Instance, CompressionBasic.GUIDCompressionInfo, ref bufferReadValid);
this.Equipment = new Equipment();
bool flag = GameNetworkMessage.ReadBoolFromPacket(ref bufferReadValid);
for (EquipmentIndex equipmentIndex = EquipmentIndex.WeaponItemBeginSlot; equipmentIndex < (flag ? EquipmentIndex.NumEquipmentSetSlots : EquipmentIndex.ArmorItemEndSlot); ++equipmentIndex)
{
EquipmentElement itemRosterElement = ModuleNetworkData.ReadItemReferenceFromPacket(MBObjectManager.Instance, ref bufferReadValid);
if (bufferReadValid)
{
this.Equipment.AddEquipmentToSlotWithoutAgent(equipmentIndex, itemRosterElement);
}
else
{
break;
}
}
this.BodyPropertiesSeed = GameNetworkMessage.ReadIntFromPacket(CompressionGeneric.RandomSeedCompressionInfo, ref bufferReadValid);
this.IsFemale = GameNetworkMessage.ReadBoolFromPacket(ref bufferReadValid);
this.SelectedEquipmentSetIndex = GameNetworkMessage.ReadIntFromPacket(CompressionBasic.MissionObjectIDCompressionInfo, ref bufferReadValid);
this.TroopCountInFormation = GameNetworkMessage.ReadIntFromPacket(CompressionBasic.PlayerCompressionInfo, ref bufferReadValid);
return(bufferReadValid);
}
internal void WatchPlayerStuff(Demo demo, PlayerExtended player, string selectedType)
{
_arguments.Add("+playdemo");
_arguments.Add(demo.Path);
EquipmentElement type = EquipmentElement.Unknown;
switch (selectedType)
{
case "smokes":
type = EquipmentElement.Smoke;
break;
case "flashbangs":
type = EquipmentElement.Flash;
break;
case "he":
type = EquipmentElement.HE;
break;
case "molotovs":
type = EquipmentElement.Molotov;
break;
case "decoys":
type = EquipmentElement.Decoy;
break;
}
GeneratePlayerStuffVdm(demo, player, type);
StartGame();
}
public static void WriteLootMessage(EquipmentElement _equipmentFromSlot, bool _isEnemy = true)
{
string message = _equipmentFromSlot.Item.Name.ToString();
string side = _isEnemy ? "enemy:" : "ally:";
SubModule.WriteDebug(message, "Looted " + side, Color.FromUint(4282569842U));
}
public async void WatchPlayerStuff(Player player, string selectedType)
{
EquipmentElement type = EquipmentElement.Unknown;
switch (selectedType)
{
case "smokes":
type = EquipmentElement.Smoke;
break;
case "flashbangs":
type = EquipmentElement.Flash;
break;
case "he":
type = EquipmentElement.HE;
break;
case "molotovs":
type = EquipmentElement.Molotov;
break;
case "decoys":
type = EquipmentElement.Decoy;
break;
}
GeneratePlayerStuffVdm(player, type);
_config.DeleteVdmFileAtStratup = false;
await StartGame();
}
private static bool IsCouchWeapon(EquipmentElement weapon)
{
if (weapon.IsEmpty)
{
return(false);
}
if (weapon.Item.Weapons == null || weapon.Item.Weapons.Count == 0)
{
return(false);
}
foreach (var temp in weapon.Item.Weapons)
{
if (temp.ItemUsage == null)
{
continue;
}
if (temp.ItemUsage.Contains("couch"))
{
return(true);
}
}
return(false);
}
public static void GetPrice(EquipmentElement itemRosterElement, MobileParty clientParty, PartyBase merchant, bool isSelling, float inStoreValue, float supply, float demand, ref int __result)
{
if ((clientParty?.IsMainParty ?? false) &&
isSelling)
{
__result *= BannerlordCheatsSettings.Instance.SellingPriceMultiplier;
}
}
private bool EquipItem(Equipment equipment, ItemObject item, EquipmentIndex itemIndex)
{
if (!ItemData.CanItemToEquipmentDragPossible(item.StringId, (int)itemIndex))
{
return(false);
}
equipment[itemIndex] = new EquipmentElement(item);
return(true);
}
private static void InitializeHorseAgentStats(
Agent agent,
Equipment spawnEquipment,
AgentDrivenProperties agentDrivenProperties)
{
AgentDrivenProperties drivenProperties1 = agentDrivenProperties;
EquipmentElement equipmentElement1 = spawnEquipment[EquipmentIndex.ArmorItemEndSlot];
HorseComponent horseComponent1 = equipmentElement1.Item.HorseComponent;
int num1 = horseComponent1 != null ? horseComponent1.Monster.FamilyType : 0;
drivenProperties1.AiSpeciesIndex = num1;
AgentDrivenProperties drivenProperties2 = agentDrivenProperties;
equipmentElement1 = spawnEquipment[EquipmentIndex.HorseHarness];
double num2 = 0.800000011920929 + (equipmentElement1.Item != null ? 0.200000002980232 : 0.0);
drivenProperties2.AttributeRiding = (float)num2;
float num3 = 0.0f;
for (int index = 1; index < 12; ++index)
{
equipmentElement1 = spawnEquipment[index];
if (equipmentElement1.Item != null)
{
double num4 = (double)num3;
equipmentElement1 = spawnEquipment[index];
double modifiedMountBodyArmor = (double)equipmentElement1.GetModifiedMountBodyArmor();
num3 = (float)(num4 + modifiedMountBodyArmor);
}
}
agentDrivenProperties.ArmorTorso = num3;
equipmentElement1 = spawnEquipment[EquipmentIndex.ArmorItemEndSlot];
ItemObject itemObject = equipmentElement1.Item;
if (itemObject == null)
{
return;
}
HorseComponent horseComponent2 = itemObject.HorseComponent;
EquipmentElement mountElement = spawnEquipment[EquipmentIndex.ArmorItemEndSlot];
EquipmentElement equipmentElement2 = spawnEquipment[EquipmentIndex.HorseHarness];
agentDrivenProperties.MountManeuver = (float)mountElement.GetModifiedMountManeuver(in equipmentElement2) * 0.8f;
agentDrivenProperties.MountSpeed = (float)(mountElement.GetModifiedMountSpeed(in equipmentElement2) + 1) * 0.2f;
agentDrivenProperties.MountChargeDamage = (float)mountElement.GetModifiedMountCharge(in equipmentElement2) * 0.01f;
agentDrivenProperties.MountDifficulty = (float)mountElement.Item.Difficulty;
Agent riderAgent = agent.RiderAgent;
int ridingSkill = riderAgent != null?riderAgent.Character.GetSkillValue(DefaultSkills.Riding) : 0;
agentDrivenProperties.TopSpeedReachDuration = Game.Current.BasicModels.RidingModel.CalculateAcceleration(in mountElement, in equipmentElement2, ridingSkill);
if (agent.RiderAgent == null)
{
return;
}
agentDrivenProperties.MountSpeed *= (float)(1.0 + (double)ridingSkill * (2.0 / 625.0));
agentDrivenProperties.MountManeuver *= (float)(1.0 + (double)ridingSkill * 0.00350000010803342);
}
public Player(string name, Vector position, Vector lastPosition, int lastBulletNumber, EquipmentElement weapon,
Team teamSide, string teamName) : this(name) {
Position = position;
LastPosition = lastPosition;
LastBulletNumber = lastBulletNumber;
Weapon = weapon;
TeamSide = teamSide;
TeamName = teamName;
NotMovingPosition = new Vector(position.X, position.Y, position.Z);
}
/// <summary>
/// Adds a banner to the extra item slot in the agent's spawn equipment
/// Understand it as an instruction to equip a banner when the agent spawns
/// </summary>
/// <param name="agent"></param>
public static void AddBannerToSpawnEquipment(this Agent agent)
{
Equipment clonedEquipment = agent.SpawnEquipment.Clone(false);
EquipmentElement bannerElement = new EquipmentElement(MBObjectManager.Instance.GetObject <ItemObject>(CampaignBannerID));
clonedEquipment.AddEquipmentToSlotWithoutAgent(EquipmentIndex.ExtraWeaponSlot, bannerElement);
agent.UpdateSpawnEquipmentAndRefreshVisuals(clonedEquipment);
}
/// <summary>
/// Map item string coming from demos events with equipment.
/// Used for specials equipments such as kevlar and weapons that have special name such as molotov.
/// Others weapons detection is based on their item index definition.
/// </summary>
/// <param name="originalString"></param>
/// <returns></returns>
public static EquipmentElement MapEquipment(string originalString)
{
EquipmentElement weapon = EquipmentElement.Unknown;
if (!originalString.StartsWith(ITEM_PREFIX) && !originalString.StartsWith(WEAPON_PREFIX))
{
originalString = WEAPON_PREFIX + originalString;
}
EquipmentMapping equipment = Equipments.FirstOrDefault(e => e.OriginalName == originalString);
if (equipment.ItemIndex == 0)
{
switch (originalString)
{
case "item_kevlar":
case "item_vest":
weapon = EquipmentElement.Kevlar;
break;
case "item_assaultsuit":
case "item_vesthelm":
weapon = EquipmentElement.Helmet;
break;
case "item_defuser":
weapon = EquipmentElement.DefuseKit;
break;
case "weapon_world":
case "weapon_worldspawn":
weapon = EquipmentElement.World;
break;
case "weapon_inferno":
weapon = EquipmentElement.Incendiary;
break;
case "weapon_molotov_projectile":
case "weapon_molotovgrenade":
weapon = EquipmentElement.Molotov;
break;
default:
Trace.WriteLine("Unknown weapon. " + originalString, "Equipment.MapEquipment()");
break;
}
}
else
{
weapon = equipment.Element;
}
return(weapon);
}
public static void Postfix(Mission __instance, Agent affectedAgent, Agent affectorAgent, AgentState agentState, KillingBlow killingBlow)
{
try
{
DropChance dc = new DropChance();
if ((affectedAgent.IsMainAgent || affectedAgent.IsMount))
{
return;
}
if (!affectedAgent.IsEnemyOf(Agent.Main))
{
if (SubModule.debugEnabled)
{
SubModule.WriteDebugMessage("Killed an ally.");
}
if (!SubModule.LootAlliesEnabled)
{
return;
}
}
for (int index = 0; (long)index < (long)12; ++index)
{
EquipmentIndex equipmentIndex = (EquipmentIndex)index;
if (new Random().NextDouble() < dc.CalculateChance())
{
EquipmentElement equipmentFromSlot = affectedAgent.Character.Equipment.GetEquipmentFromSlot(equipmentIndex);
if (equipmentFromSlot.Item != null)
{
equipmentFromSlot = affectedAgent.Character.Equipment.GetEquipmentFromSlot(equipmentIndex);
if (SubModule.debugEnabled)
{
//SubModule.WriteDebugMessage("debugMessage");
}
MapEvent.PlayerMapEvent.ItemRosterForPlayerLootShare(PartyBase.MainParty).AddToCounts(equipmentFromSlot.Item, 1, true);
SubModule.WriteDebugMessage(equipmentFromSlot.Item.Name.ToString() + " was looted!");
}
}
else
{
if (SubModule.debugEnabled)
{
SubModule.WriteDebugMessage("No Luck! " + (new Random().NextDouble() * 100).ToString("0.##") + "% vs. " + (dc.CalculateChance() * 100).ToString("0.##") + "%");
}
}
}
}
catch (Exception ex)
{
SubModule.WriteDebugMessage(ex.Message);
}
}
/// <summary>
/// Returns the best equipment element
/// </summary>
/// <param name="slot">Equipment slot</param>
/// <param name="inventoryEquipmentElement">inventory equipment</param>
/// <param name="currentEquipmentElement">current equipment</param>
/// <param name="bestEquipmentElement">best equipment</param>
/// <returns></returns>
private EquipmentElement GetBestEquipmentElement(EquipmentIndex slot, EquipmentElement inventoryEquipmentElement, EquipmentElement currentEquipmentElement, EquipmentElement bestEquipmentElement)
{
float inventoryItemValue = ItemIndexCalculation(inventoryEquipmentElement, slot);
float currentItemValue = bestEquipmentElement.IsEmpty ? ItemIndexCalculation(currentEquipmentElement, slot) : ItemIndexCalculation(bestEquipmentElement, slot);
if (inventoryItemValue > currentItemValue && inventoryItemValue != 0f)
{
return(inventoryEquipmentElement);
}
return(bestEquipmentElement);
}
public static string TestModifiedAmmo(List <string> strings)
{
var item = HeroHelpers.AllItems.Where(i => i.ItemType == ItemObject.ItemTypeEnum.Arrows)
.Shuffle()
.OrderByDescending(i => i.Tier)
.FirstOrDefault();
var modifier = BLTCustomItemsCampaignBehavior.Current.CreateAmmoModifier("Test {ITEMNAME}", 100, 100);
var slotItem = new EquipmentElement(item, modifier);
Hero.MainHero.BattleEquipment[EquipmentIndex.Weapon2] = slotItem;
return($"Assigned {slotItem.GetModifiedItemName()} to {Hero.MainHero.Name}");
}
static public float getArmArmor(Agent agent)
{
for (EquipmentIndex equipmentIndex = EquipmentIndex.NumAllWeaponSlots; equipmentIndex < EquipmentIndex.ArmorItemEndSlot; equipmentIndex++)
{
EquipmentElement equipmentElement = agent.SpawnEquipment[equipmentIndex];
if (equipmentElement.Item != null && equipmentElement.Item.ItemType == ItemObject.ItemTypeEnum.HandArmor)
{
return((float)equipmentElement.Item.ArmorComponent.ArmArmor);
}
}
return(0f);
}
/// <summary>
/// Alters the equipment this an Agent will spawn with.
/// </summary>
/// <param name="agent"></param>
/// <param name="forbiddenWeapons">A set of weapon types that get removed from the agent's spawn equipment</param>
public static void RemoveFromSpawnEquipment(this Agent agent, HashSet <ItemObject.ItemTypeEnum> forbiddenWeapons)
{
Equipment clonedEquipment = agent.SpawnEquipment.Clone(false);
for (int i = 0; i < (int)EquipmentIndex.NumAllWeaponSlots; i++)
{
if (clonedEquipment[i].Item != null && forbiddenWeapons.Contains(clonedEquipment[i].Item.Type))
{
clonedEquipment[i] = new EquipmentElement(null, null);
}
}
}
public static void GetPrice(EquipmentElement itemRosterElement, MobileParty clientParty, PartyBase merchant, bool isSelling, float inStoreValue, float supply, float demand, ref int __result)
{
if ((clientParty?.IsMainParty ?? false) &&
!isSelling)
{
var factor = BannerlordCheatsSettings.Instance.ItemTradingCostPercentage / 100f;
var newValue = (int)Math.Round(factor * __result);
__result = newValue;
}
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="p"></param>
public Player(Player p)
{
Name = p.Name;
Position = p.Position;
LastPosition = p.LastPosition;
LastBulletNumber = p.LastBulletNumber;
Weapon = p.Weapon;
TeamSide = p.TeamSide;
NotMovingPosition = new Vector(p.Position.X, p.Position.Y, p.Position.Z);
AllDeaths = new List <Death>();
AllKills = new List <Kill>();
}
static public float getHorseBodyArmor(Agent agent)
{
float num = 0f;
EquipmentElement equipmentElement = agent.SpawnEquipment[11];
if (equipmentElement.Item != null && equipmentElement.Item.ItemType == ItemObject.ItemTypeEnum.HorseHarness)
{
num += (float)equipmentElement.Item.ArmorComponent.BodyArmor;
num += 10f;
}
return(num);
}
private static int ConvertLootToGold(IEnumerable <ItemRosterElement> lootedItemsRecoveredFromCasualties)
{
int num = 0;
foreach (ItemRosterElement lootedItemsRecoveredFromCasualty in lootedItemsRecoveredFromCasualties)
{
int amount = lootedItemsRecoveredFromCasualty.Amount;
EquipmentElement equipmentElement = lootedItemsRecoveredFromCasualty.EquipmentElement;
num = num + amount * MBMath.Round((float)equipmentElement.GetBaseValue() * 0.5f);
}
return(num);
}
internal static Equipment GetEquipmentWithValidItemsOnly()
{
Equipment equipment = new Equipment();
for (EquipmentIndex index = WeaponItemBeginSlot;
index < NumEquipmentSetSlots;
index++)
{
equipment[index] = new EquipmentElement(new ItemObject(), new ItemModifier());
}
return(equipment);
}
public WeaponInfo(int id, Equipment info)
{
weaponID = id;
magazineAmmo = info.AmmoInMagazine;
ammoType = info.AmmoType;
equipmentClass = info.Class;
entityID = info.EntityID;
originalString = info.OriginalString;
owner = info.Owner;
reserveAmmo = info.ReserveAmmo;
skinID = info.SkinID;
weapon = info.Weapon;
}
static public float getMyChestArmor(Agent agent)
{
float num = 0f;
for (EquipmentIndex equipmentIndex = EquipmentIndex.NumAllWeaponSlots; equipmentIndex < EquipmentIndex.ArmorItemEndSlot; equipmentIndex++)
{
EquipmentElement equipmentElement = agent.SpawnEquipment[equipmentIndex];
if (equipmentElement.Item != null && equipmentElement.Item.ItemType == ItemObject.ItemTypeEnum.BodyArmor)
{
num += (float)equipmentElement.Item.ArmorComponent.BodyArmor;
}
}
return(num);
}
public static void Postfix(ref Agent __result,
EquipmentElement horse,
EquipmentElement monsterHarness,
MatrixFrame initialFrame,
int forcedAgentMountIndex,
string horseCreationKey)
{
if (SubModule.Settings.Battle_WarStomp_UnstoppableHorseCharge ||
(SubModule.Settings.Battle_WarStomp_UnstoppableWarHorseCharge && horse.Item.ItemCategory == DefaultItemCategories.WarHorse))
{
var flags = __result.GetAgentFlags();
flags &= ~AgentFlag.CanRear;
__result.SetAgentFlags(flags);
}
}
internal NadeEventArgs(EquipmentElement type)
{
this.NadeType = type;
}
