Alex
2241 lines
78 KiB
C#
2241 lines
78 KiB
C#
using System.Collections.Frozen;
|
|
using System.Text.Json.Serialization;
|
|
using SPTarkov.DI.Annotations;
|
|
using SPTarkov.Server.Core.Models.Eft.Common;
|
|
using SPTarkov.Server.Core.Models.Eft.Common.Tables;
|
|
using SPTarkov.Server.Core.Models.Enums;
|
|
using SPTarkov.Server.Core.Models.Utils;
|
|
using SPTarkov.Server.Core.Services;
|
|
using SPTarkov.Server.Core.Utils;
|
|
using SPTarkov.Server.Core.Utils.Cloners;
|
|
using SPTarkov.Server.Core.Utils.Collections;
|
|
using LogLevel = SPTarkov.Server.Core.Models.Spt.Logging.LogLevel;
|
|
|
|
namespace SPTarkov.Server.Core.Helpers;
|
|
|
|
[Injectable]
|
|
public class ItemHelper(
|
|
ISptLogger<ItemHelper> _logger,
|
|
HashUtil _hashUtil,
|
|
RandomUtil _randomUtil,
|
|
MathUtil _mathUtil,
|
|
DatabaseService _databaseService,
|
|
HandbookHelper _handbookHelper,
|
|
ItemBaseClassService _itemBaseClassService,
|
|
ItemFilterService _itemFilterService,
|
|
LocalisationService _localisationService,
|
|
LocaleService _localeService,
|
|
ICloner _cloner
|
|
)
|
|
{
|
|
protected static readonly FrozenSet<string> _defaultInvalidBaseTypes =
|
|
[
|
|
BaseClasses.LOOT_CONTAINER,
|
|
BaseClasses.MOB_CONTAINER,
|
|
BaseClasses.STASH,
|
|
BaseClasses.SORTING_TABLE,
|
|
BaseClasses.INVENTORY,
|
|
BaseClasses.STATIONARY_CONTAINER,
|
|
BaseClasses.POCKETS
|
|
];
|
|
|
|
protected static readonly FrozenSet<string> _slotsAsStrings =
|
|
[
|
|
EquipmentSlots.Headwear.ToString(),
|
|
EquipmentSlots.Earpiece.ToString(),
|
|
EquipmentSlots.FaceCover.ToString(),
|
|
EquipmentSlots.ArmorVest.ToString(),
|
|
EquipmentSlots.Eyewear.ToString(),
|
|
EquipmentSlots.ArmBand.ToString(),
|
|
EquipmentSlots.TacticalVest.ToString(),
|
|
EquipmentSlots.Pockets.ToString(),
|
|
EquipmentSlots.Backpack.ToString(),
|
|
EquipmentSlots.SecuredContainer.ToString(),
|
|
EquipmentSlots.FirstPrimaryWeapon.ToString(),
|
|
EquipmentSlots.SecondPrimaryWeapon.ToString(),
|
|
EquipmentSlots.Holster.ToString(),
|
|
EquipmentSlots.Scabbard.ToString()
|
|
];
|
|
|
|
protected static readonly FrozenSet<string> _dogTagTpls =
|
|
[
|
|
ItemTpl.BARTER_DOGTAG_BEAR,
|
|
ItemTpl.BARTER_DOGTAG_BEAR_EOD,
|
|
ItemTpl.BARTER_DOGTAG_BEAR_TUE,
|
|
ItemTpl.BARTER_DOGTAG_USEC,
|
|
ItemTpl.BARTER_DOGTAG_USEC_EOD,
|
|
ItemTpl.BARTER_DOGTAG_USEC_TUE,
|
|
ItemTpl.BARTER_DOGTAG_BEAR_PRESTIGE_1,
|
|
ItemTpl.BARTER_DOGTAG_BEAR_PRESTIGE_2,
|
|
ItemTpl.BARTER_DOGTAG_USEC_PRESTIGE_1,
|
|
ItemTpl.BARTER_DOGTAG_USEC_PRESTIGE_2
|
|
];
|
|
|
|
protected static readonly FrozenSet<string> _softInsertIds =
|
|
[
|
|
"groin",
|
|
"groin_back",
|
|
"soft_armor_back",
|
|
"soft_armor_front",
|
|
"soft_armor_left",
|
|
"soft_armor_right",
|
|
"shoulder_l",
|
|
"shoulder_r",
|
|
"collar",
|
|
"helmet_top",
|
|
"helmet_back",
|
|
"helmet_eyes",
|
|
"helmet_jaw",
|
|
"helmet_ears"
|
|
];
|
|
|
|
protected static readonly FrozenSet<string> _removablePlateSlotIds =
|
|
[
|
|
"front_plate",
|
|
"back_plate",
|
|
"left_side_plate",
|
|
"right_side_plate"
|
|
];
|
|
|
|
/**
|
|
* Does the provided pool of items contain the desired item
|
|
* @param itemPool Item collection to check
|
|
* @param item Item to look for
|
|
* @param slotId OPTIONAL - slotid of desired item
|
|
* @returns True if pool contains item
|
|
*/
|
|
public bool HasItemWithTpl(List<Item> itemPool, string item, string slotId = null)
|
|
{
|
|
// Filter the pool by slotId if provided
|
|
var filteredPool = slotId is not null ? itemPool.Where(item => item.SlotId?.StartsWith(slotId) ?? false) : itemPool;
|
|
|
|
// Check if any item in the filtered pool matches the provided item
|
|
return filteredPool.Any(poolItem => string.Equals(poolItem.Template, item, StringComparison.OrdinalIgnoreCase));
|
|
}
|
|
|
|
/**
|
|
* Get the first item from provided pool with the desired tpl
|
|
* @param itemPool Item collection to search
|
|
* @param item Item to look for
|
|
* @param slotId OPTIONAL - slotid of desired item
|
|
* @returns Item or null
|
|
*/
|
|
public Item GetItemFromPoolByTpl(List<Item> itemPool, string item, string slotId = null)
|
|
{
|
|
// Filter the pool by slotId if provided
|
|
var filteredPool = slotId is not null ? itemPool.Where(item => item.SlotId?.StartsWith(slotId) ?? false) : itemPool;
|
|
|
|
// Check if any item in the filtered pool matches the provided item
|
|
return filteredPool.FirstOrDefault(poolItem => poolItem.Template.Equals(item, StringComparison.OrdinalIgnoreCase));
|
|
}
|
|
|
|
/**
|
|
* This method will compare two items (with all its children) and see if they are equivalent.
|
|
* This method will NOT compare IDs on the items
|
|
* @param item1 first item with all its children to compare
|
|
* @param item2 second item with all its children to compare
|
|
* @param compareUpdProperties Upd properties to compare between the items
|
|
* @returns true if they are the same, false if they aren't
|
|
*/
|
|
public bool IsSameItems(List<Item> item1, List<Item> item2, HashSet<string>? compareUpdProperties = null)
|
|
{
|
|
if (item1.Count != item2.Count)
|
|
{
|
|
// Items have different mod counts
|
|
return false;
|
|
}
|
|
|
|
foreach (var itemOf1 in item1)
|
|
{
|
|
var itemOf2 = item2.FirstOrDefault(i2 => i2.Template.Equals(itemOf1.Template, StringComparison.OrdinalIgnoreCase));
|
|
if (itemOf2 is null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!IsSameItem(itemOf1, itemOf2, compareUpdProperties))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* This method will compare two items and see if they are equivalent.
|
|
* This method will NOT compare IDs on the items
|
|
* @param item1 first item to compare
|
|
* @param item2 second item to compare
|
|
* @param compareUpdProperties Upd properties to compare between the items
|
|
* @returns true if they are the same, false if they aren't
|
|
*/
|
|
public bool IsSameItem(Item item1, Item item2, HashSet<string>? compareUpdProperties = null)
|
|
{
|
|
// Different tpl == different item
|
|
if (item1.Template != item2.Template)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Both lack upd object + same tpl = same
|
|
if (item1.Upd is null && item2.Upd is null)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// item1 lacks upd, item2 has one
|
|
if (item1.Upd is null && item2.Upd is not null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// item1 has upd, item2 lacks one
|
|
if (item1.Upd is not null && item2.Upd is null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// key = Upd property Type as string, value = comparison function that returns bool
|
|
var comparers = new Dictionary<string, Func<Upd, Upd, bool>>
|
|
{
|
|
{ "Key", (upd1, upd2) => upd1.Key?.NumberOfUsages == upd2.Key?.NumberOfUsages },
|
|
{ "Buff", (upd1, upd2) => upd1.Buff?.Value == upd2.Buff?.Value && upd1.Buff?.BuffType == upd2.Buff?.BuffType },
|
|
{ "CultistAmulet", (upd1, upd2) => upd1.CultistAmulet?.NumberOfUsages == upd2.CultistAmulet?.NumberOfUsages },
|
|
{ "Dogtag", (upd1, upd2) => upd1.Dogtag?.ProfileId == upd2.Dogtag?.ProfileId },
|
|
{ "FaceShield", (upd1, upd2) => upd1.FaceShield?.Hits == upd2.FaceShield?.Hits },
|
|
{ "Foldable", (upd1, upd2) => upd1.Foldable?.Folded.GetValueOrDefault(false) == upd2.Foldable?.Folded.GetValueOrDefault(false) },
|
|
{ "FoodDrink", (upd1, upd2) => upd1.FoodDrink?.HpPercent == upd2.FoodDrink?.HpPercent },
|
|
{ "MedKit", (upd1, upd2) => upd1.MedKit?.HpResource == upd2.MedKit?.HpResource },
|
|
{ "RecodableComponent", (upd1, upd2) => upd1.RecodableComponent?.IsEncoded == upd2.RecodableComponent?.IsEncoded },
|
|
{ "RepairKit", (upd1, upd2) => upd1.RepairKit?.Resource == upd2.RepairKit?.Resource },
|
|
{ "Resource", (upd1, upd2) => upd1.Resource?.UnitsConsumed == upd2.Resource?.UnitsConsumed }
|
|
};
|
|
|
|
// Choose above keys or passed in keys to compare items with
|
|
var valuesToCompare = compareUpdProperties?.Count > 0 ? compareUpdProperties : comparers.Keys.ToHashSet();
|
|
foreach (var propertyName in valuesToCompare)
|
|
{
|
|
if (!comparers.TryGetValue(propertyName, out var comparer))
|
|
// Key not found, skip
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!comparer(item1.Upd, item2.Upd))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Helper method to generate a Upd based on a template
|
|
* @param itemTemplate the item template to generate a Upd for
|
|
* @returns A Upd with all the default properties set
|
|
*/
|
|
public Upd GenerateUpdForItem(TemplateItem itemTemplate)
|
|
{
|
|
Upd itemProperties = new();
|
|
|
|
// armors, etc
|
|
if (itemTemplate.Properties.MaxDurability is not null)
|
|
{
|
|
itemProperties.Repairable = new UpdRepairable
|
|
{
|
|
Durability = itemTemplate.Properties.MaxDurability,
|
|
MaxDurability = itemTemplate.Properties.MaxDurability
|
|
};
|
|
}
|
|
|
|
if (itemTemplate.Properties.HasHinge ?? false)
|
|
{
|
|
itemProperties.Togglable = new UpdTogglable
|
|
{
|
|
On = true
|
|
};
|
|
}
|
|
|
|
if (itemTemplate.Properties.Foldable ?? false)
|
|
{
|
|
itemProperties.Foldable = new UpdFoldable
|
|
{
|
|
Folded = false
|
|
};
|
|
}
|
|
|
|
if (itemTemplate.Properties.WeapFireType?.Any() ?? false)
|
|
{
|
|
if (itemTemplate.Properties.WeapFireType.Contains("fullauto"))
|
|
{
|
|
itemProperties.FireMode = new UpdFireMode
|
|
{
|
|
FireMode = "fullauto"
|
|
};
|
|
}
|
|
else
|
|
{
|
|
itemProperties.FireMode = new UpdFireMode
|
|
{
|
|
FireMode = _randomUtil.GetArrayValue(itemTemplate.Properties.WeapFireType)
|
|
};
|
|
}
|
|
}
|
|
|
|
if (itemTemplate.Properties.MaxHpResource is not null)
|
|
{
|
|
itemProperties.MedKit = new UpdMedKit
|
|
{
|
|
HpResource = itemTemplate.Properties.MaxHpResource
|
|
};
|
|
}
|
|
|
|
if (itemTemplate.Properties.MaxResource is not null && itemTemplate.Properties.FoodUseTime is not null)
|
|
{
|
|
itemProperties.FoodDrink = new UpdFoodDrink
|
|
{
|
|
HpPercent = itemTemplate.Properties.MaxResource
|
|
};
|
|
}
|
|
|
|
if (itemTemplate.Parent == BaseClasses.FLASHLIGHT)
|
|
{
|
|
itemProperties.Light = new UpdLight
|
|
{
|
|
IsActive = false,
|
|
SelectedMode = 0
|
|
};
|
|
}
|
|
else if (itemTemplate.Parent == BaseClasses.TACTICAL_COMBO)
|
|
{
|
|
itemProperties.Light = new UpdLight
|
|
{
|
|
IsActive = false,
|
|
SelectedMode = 0
|
|
};
|
|
}
|
|
|
|
if (itemTemplate.Parent == BaseClasses.NIGHTVISION)
|
|
{
|
|
itemProperties.Togglable = new UpdTogglable
|
|
{
|
|
On = false
|
|
};
|
|
}
|
|
|
|
// Togglable face shield
|
|
if ((itemTemplate.Properties.HasHinge ?? false) && (itemTemplate.Properties.FaceShieldComponent ?? false))
|
|
{
|
|
itemProperties.Togglable = new UpdTogglable
|
|
{
|
|
On = false
|
|
};
|
|
}
|
|
|
|
return itemProperties;
|
|
}
|
|
|
|
/**
|
|
* Checks if a tpl is a valid item. Valid meaning that it's an item that can be stored in stash
|
|
* Valid means:
|
|
* Not quest item
|
|
* 'Item' type
|
|
* Not on the invalid base types array
|
|
* Price above 0 roubles
|
|
* Not on item config blacklist
|
|
* @param tpl the template id / tpl
|
|
* @returns boolean; true for items that may be in player possession and not quest items
|
|
*/
|
|
public bool IsValidItem(string tpl, ICollection<string>? invalidBaseTypes = null)
|
|
{
|
|
var baseTypes = invalidBaseTypes ?? _defaultInvalidBaseTypes;
|
|
var itemDetails = GetItem(tpl);
|
|
|
|
if (!itemDetails.Key)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return !(itemDetails.Value.Properties.QuestItem ?? false) &&
|
|
string.Equals(itemDetails.Value.Type, "Item", StringComparison.OrdinalIgnoreCase) &&
|
|
baseTypes.All(x => !IsOfBaseclass(tpl, x)) &&
|
|
GetItemPrice(tpl) > 0 &&
|
|
!_itemFilterService.IsItemBlacklisted(tpl);
|
|
}
|
|
|
|
// Check if the tpl / template Id provided is a descendent of the baseclass
|
|
//
|
|
// @param string tpl the item template id to check
|
|
// @param string baseClassTpl the baseclass to check for
|
|
// @return bool is the tpl a descendent?
|
|
public bool IsOfBaseclass(string tpl, string baseClassTpl)
|
|
{
|
|
return _itemBaseClassService.ItemHasBaseClass(tpl, [baseClassTpl]);
|
|
}
|
|
|
|
// Check if item has any of the supplied base classes
|
|
// @param string tpl Item to check base classes of
|
|
// @param string[] baseClassTpls base classes to check for
|
|
// @returns true if any supplied base classes match
|
|
public bool IsOfBaseclasses(string tpl, ICollection<string> baseClassTpls)
|
|
{
|
|
return _itemBaseClassService.ItemHasBaseClass(tpl, baseClassTpls);
|
|
}
|
|
|
|
// Does the provided item have the chance to require soft armor inserts
|
|
// Only applies to helmets/vest/armors.
|
|
// Not all head gear needs them
|
|
// @param string itemTpl item to check
|
|
// @returns Does item have the possibility ot need soft inserts
|
|
public bool ArmorItemCanHoldMods(string itemTpl)
|
|
{
|
|
return IsOfBaseclasses(itemTpl, [BaseClasses.HEADWEAR, BaseClasses.VEST, BaseClasses.ARMOR]);
|
|
}
|
|
|
|
// Does the provided item tpl need soft/removable inserts to function
|
|
// @param string itemTpl Armor item
|
|
// @returns True if item needs some kind of insert
|
|
public bool ArmorItemHasRemovableOrSoftInsertSlots(string itemTpl)
|
|
{
|
|
if (!ArmorItemCanHoldMods(itemTpl))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return ArmorItemHasRemovablePlateSlots(itemTpl) || ItemRequiresSoftInserts(itemTpl);
|
|
}
|
|
|
|
// Does the pased in tpl have ability to hold removable plate items
|
|
// @param string itemTpl item tpl to check for plate support
|
|
// @returns True when armor can hold plates
|
|
public bool ArmorItemHasRemovablePlateSlots(string itemTpl)
|
|
{
|
|
var itemTemplate = GetItem(itemTpl);
|
|
var plateSlotIds = GetRemovablePlateSlotIds();
|
|
|
|
return itemTemplate.Value.Properties.Slots.Any(slot => plateSlotIds.Contains(slot.Name.ToLower()));
|
|
}
|
|
|
|
// Does the provided item tpl require soft inserts to become a valid armor item
|
|
// @param string itemTpl Item tpl to check
|
|
// @returns True if it needs armor inserts
|
|
public bool ItemRequiresSoftInserts(string itemTpl)
|
|
{
|
|
// not a slot that takes soft-inserts
|
|
if (!ArmorItemCanHoldMods(itemTpl))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Check is an item
|
|
var itemDbDetails = GetItem(itemTpl);
|
|
if (!itemDbDetails.Key)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Has no slots
|
|
if (!(itemDbDetails.Value.Properties.Slots ?? []).Any())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Check if item has slots that match soft insert name ids
|
|
if (itemDbDetails.Value.Properties.Slots.Any(slot => IsSoftInsertId(slot.Name.ToLower())))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Get all soft insert slot ids
|
|
// @returns A List of soft insert ids (e.g. soft_armor_back, helmet_top)
|
|
public static FrozenSet<string> GetSoftInsertSlotIds()
|
|
{
|
|
return _softInsertIds;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does the passed in slot id match a soft insert id
|
|
/// </summary>
|
|
/// <param name="slotId">Id to check</param>
|
|
/// <returns></returns>
|
|
public bool IsSoftInsertId(string slotId)
|
|
{
|
|
return _softInsertIds.Contains(slotId);
|
|
}
|
|
|
|
// Returns the items total price based on the handbook or as a fallback from the prices.json if the item is not
|
|
// found in the handbook. If the price can't be found at all return 0
|
|
// @param List<string> tpls item tpls to look up the price of
|
|
// @returns Total price in roubles
|
|
public double GetItemAndChildrenPrice(IEnumerable<string> tpls)
|
|
{
|
|
// Run getItemPrice for each tpl in tpls array, return sum
|
|
return tpls.Aggregate(0, (total, tpl) => total + (int) GetItemPrice(tpl).GetValueOrDefault(0));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the item price based on the handbook or as a fallback from the prices.json if the item is not
|
|
/// found in the handbook. If the price can't be found at all return 0
|
|
/// </summary>
|
|
/// <param name="tpl">Item to look price up of</param>
|
|
/// <returns>Price in roubles</returns>
|
|
public double? GetItemPrice(string tpl)
|
|
{
|
|
var handbookPrice = GetStaticItemPrice(tpl);
|
|
if (handbookPrice >= 1)
|
|
{
|
|
return handbookPrice;
|
|
}
|
|
|
|
return GetDynamicItemPrice(tpl);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the item price based on the handbook or as a fallback from the prices.json if the item is not
|
|
/// found in the handbook. If the price can't be found at all return 0
|
|
/// </summary>
|
|
/// <param name="tpl">Item to look price up of</param>
|
|
/// <returns>Price in roubles</returns>
|
|
public double GetItemMaxPrice(string tpl)
|
|
{
|
|
var staticPrice = GetStaticItemPrice(tpl);
|
|
var dynamicPrice = GetDynamicItemPrice(tpl);
|
|
|
|
return Math.Max(staticPrice, dynamicPrice ?? 0d);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the static (handbook) price in roubles for an item by tpl
|
|
/// </summary>
|
|
/// <param name="tpl">Items tpl id to look up price</param>
|
|
/// <returns>Price in roubles (0 if not found)</returns>
|
|
public double GetStaticItemPrice(string tpl)
|
|
{
|
|
var handbookPrice = _handbookHelper.GetTemplatePrice(tpl);
|
|
if (handbookPrice >= 1)
|
|
{
|
|
return handbookPrice;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the dynamic (flea) price in roubles for an item by tpl
|
|
/// </summary>
|
|
/// <param name="tpl">Items tpl id to look up price</param>
|
|
/// <returns>Price in roubles (undefined if not found)</returns>
|
|
public double? GetDynamicItemPrice(string tpl)
|
|
{
|
|
if (_databaseService.GetPrices().TryGetValue(tpl, out var price))
|
|
{
|
|
return price;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update items upd.StackObjectsCount to be 1 if its upd is missing or StackObjectsCount is undefined
|
|
/// </summary>
|
|
/// <param name="item">Item to update</param>
|
|
/// <returns>Fixed item</returns>
|
|
public Item FixItemStackCount(Item item)
|
|
{
|
|
// Ensure item has 'Upd' object
|
|
item.Upd ??= new Upd
|
|
{
|
|
StackObjectsCount = 1
|
|
};
|
|
|
|
// Ensure item has 'StackObjectsCount' property
|
|
item.Upd.StackObjectsCount ??= 1;
|
|
|
|
return item;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get cloned copy of all item data from items.json
|
|
/// </summary>
|
|
/// <returns>List of TemplateItem objects</returns>
|
|
public List<TemplateItem> GetItems()
|
|
{
|
|
return _cloner.Clone(_databaseService.GetItems().Values.ToList());
|
|
}
|
|
|
|
/**
|
|
* Gets item data from items.json
|
|
* @param itemTpl items template id to look up
|
|
* @returns bool - is valid + template item object as array
|
|
*/
|
|
public KeyValuePair<bool, TemplateItem?> GetItem(string itemTpl)
|
|
{
|
|
// -> Gets item from <input: _tpl>
|
|
if (_databaseService.GetItems().TryGetValue(itemTpl, out var item))
|
|
{
|
|
return new KeyValuePair<bool, TemplateItem?>(true, item);
|
|
}
|
|
|
|
return new KeyValuePair<bool, TemplateItem?>(false, null);
|
|
}
|
|
|
|
/**
|
|
* Checks if the item has slots
|
|
* @param itemTpl Template id of the item to check
|
|
* @returns true if the item has slots
|
|
*/
|
|
public bool ItemHasSlots(string itemTpl)
|
|
{
|
|
if (_databaseService.GetItems().TryGetValue(itemTpl, out var item))
|
|
{
|
|
return GetItem(itemTpl).Value.Properties?.Slots?.Count > 0;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Checks if the item is in the database
|
|
* @param itemTpl Template id of the item to check
|
|
* @returns true if the item is in the database
|
|
*/
|
|
public bool IsItemInDb(string itemTpl)
|
|
{
|
|
return _databaseService.GetItems().ContainsKey(itemTpl);
|
|
}
|
|
|
|
/**
|
|
* Calculate the average quality of an item and its children
|
|
* @param itemWithChildren An offers item to process
|
|
* @param skipArmorItemsWithoutDurability Skip over armor items without durability
|
|
* @returns % quality modifier between 0 and 1
|
|
*/
|
|
public double GetItemQualityModifierForItems(List<Item> itemWithChildren, bool skipArmorItemsWithoutDurability = false)
|
|
{
|
|
if (IsOfBaseclass(itemWithChildren[0].Template, BaseClasses.WEAPON))
|
|
{
|
|
return Math.Round(GetItemQualityModifier(itemWithChildren[0]), 5);
|
|
}
|
|
|
|
var qualityModifier = 0D;
|
|
var itemsWithQualityCount = 0D;
|
|
foreach (var item in itemWithChildren)
|
|
{
|
|
var result = GetItemQualityModifier(item, skipArmorItemsWithoutDurability);
|
|
if (result == -1)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
qualityModifier += result;
|
|
itemsWithQualityCount++;
|
|
}
|
|
|
|
if (itemsWithQualityCount == 0)
|
|
// Can happen when rigs without soft inserts or plates are listed
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
return Math.Min(Math.Round(qualityModifier / itemsWithQualityCount, 5), 1);
|
|
}
|
|
|
|
/**
|
|
* Get normalized value (0-1) based on item condition
|
|
* Will return -1 for base armor items with 0 durability
|
|
* @param item Item to check
|
|
* @param skipArmorItemsWithoutDurability return -1 for armor items that have max durability of 0
|
|
* @returns Number between 0 and 1
|
|
*/
|
|
public double GetItemQualityModifier(Item item, bool skipArmorItemsWithoutDurability = false)
|
|
{
|
|
// Default to 100%
|
|
var result = 1d;
|
|
|
|
// Is armor and has 0 max durability
|
|
var itemDetails = GetItem(item.Template).Value;
|
|
if (itemDetails?.Properties is null)
|
|
{
|
|
_logger.Warning($"Item: {item.Template} lacks properties, cannot ascertain quality level, assuming 100%");
|
|
|
|
return 1;
|
|
}
|
|
|
|
if (skipArmorItemsWithoutDurability && IsOfBaseclass(item.Template, BaseClasses.ARMOR) && itemDetails?.Properties?.MaxDurability == 0
|
|
)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if (item.Upd is not null)
|
|
{
|
|
if (item.Upd.MedKit is not null)
|
|
{
|
|
// Meds
|
|
result = (item.Upd.MedKit.HpResource ?? 0) / (itemDetails.Properties.MaxHpResource ?? 0);
|
|
}
|
|
else if (item.Upd.Repairable is not null)
|
|
{
|
|
result = GetRepairableItemQualityValue(itemDetails, item.Upd.Repairable, item);
|
|
}
|
|
else if (item.Upd.FoodDrink is not null)
|
|
{
|
|
result = (item.Upd.FoodDrink.HpPercent ?? 0) / (itemDetails.Properties.MaxResource ?? 0);
|
|
}
|
|
else if (item.Upd.Key?.NumberOfUsages > 0 && itemDetails.Properties.MaximumNumberOfUsage > 0)
|
|
{
|
|
// keys - keys count upwards, not down like everything else
|
|
var maxNumOfUsages = itemDetails.Properties.MaximumNumberOfUsage;
|
|
result = (maxNumOfUsages ?? 0 - item.Upd.Key.NumberOfUsages ?? 0) / maxNumOfUsages ?? 0;
|
|
}
|
|
else if (item.Upd.Resource?.UnitsConsumed > 0)
|
|
{
|
|
// E.g. fuel tank
|
|
result = (item.Upd.Resource.Value ?? 0) / (itemDetails.Properties.MaxResource ?? 0);
|
|
}
|
|
else if (item.Upd.RepairKit is not null)
|
|
{
|
|
result = (item.Upd.RepairKit.Resource ?? 0) / (itemDetails.Properties.MaxRepairResource ?? 0);
|
|
}
|
|
|
|
if (result == 0)
|
|
// make item non-zero but still very low
|
|
{
|
|
result = 0.01;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Get a quality value based on a repairable item's current state between current and max durability
|
|
* @param itemDetails Db details for item we want quality value for
|
|
* @param repairable Repairable properties
|
|
* @param item Item quality value is for
|
|
* @returns A number between 0 and 1
|
|
*/
|
|
protected double GetRepairableItemQualityValue(TemplateItem itemDetails, UpdRepairable repairable, Item item)
|
|
{
|
|
// Edge case, durability above max
|
|
if (repairable.Durability > repairable.MaxDurability)
|
|
{
|
|
_logger.Debug(
|
|
$"Max durability: {repairable.MaxDurability} for item id: {item.Id} was below durability: {repairable.Durability}, adjusting values to match"
|
|
);
|
|
repairable.MaxDurability = repairable.Durability;
|
|
}
|
|
|
|
// Attempt to get the max durability from _props. If not available, use Repairable max durability value instead.
|
|
var maxPossibleDurability = itemDetails.Properties?.MaxDurability ?? repairable.MaxDurability;
|
|
var durability = repairable.Durability / maxPossibleDurability;
|
|
|
|
if (durability == 0)
|
|
{
|
|
_logger.Error(_localisationService.GetText("item-durability_value_invalid_use_default", item.Template));
|
|
|
|
return 1;
|
|
}
|
|
|
|
return Math.Sqrt(durability ?? 0);
|
|
}
|
|
|
|
/**
|
|
* Recursive function that looks at every item from parameter and gets their children's Ids + includes parent item in results
|
|
* @param items List of items (item + possible children)
|
|
* @param baseItemId Parent item's id
|
|
* @returns a list of strings
|
|
*/
|
|
public List<string> FindAndReturnChildrenByItems(List<Item> items, string baseItemId)
|
|
{
|
|
List<string> list = [];
|
|
|
|
foreach (var childItem in items)
|
|
{
|
|
if (string.Equals(childItem.ParentId, baseItemId, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
list.AddRange(FindAndReturnChildrenByItems(items, childItem.Id));
|
|
}
|
|
}
|
|
|
|
list.Add(baseItemId); // Required, push original item id onto array
|
|
|
|
return list;
|
|
}
|
|
|
|
/**
|
|
* A variant of FindAndReturnChildren where the output is list of item objects instead of their ids.
|
|
* @param items List of items (item + possible children)
|
|
* @param baseItemId Parent item's id
|
|
* @param modsOnly Include only mod items, exclude items stored inside root item
|
|
* @returns A list of Item objects
|
|
*/
|
|
public List<Item> FindAndReturnChildrenAsItems(List<Item> items, string baseItemId, bool modsOnly = false)
|
|
{
|
|
// Use dictionary to make key lookup faster, convert to list before being returned
|
|
Dictionary<string, Item> result = [];
|
|
foreach (var childItem in items)
|
|
{
|
|
// Include itself
|
|
if (string.Equals(childItem.Id, baseItemId, StringComparison.Ordinal))
|
|
{
|
|
result.Add(childItem.Id, childItem);
|
|
continue;
|
|
}
|
|
|
|
// Is stored in parent and disallowed
|
|
if (modsOnly && childItem.Location is not null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Items parentId matches root item AND returned items doesn't contain current child
|
|
if (!result.ContainsKey(childItem.Id) && string.Equals(childItem.ParentId, baseItemId, StringComparison.Ordinal))
|
|
{
|
|
foreach (var item in FindAndReturnChildrenAsItems(items, childItem.Id))
|
|
{
|
|
result.Add(item.Id, item);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result.Values.ToList();
|
|
}
|
|
|
|
/**
|
|
* Find children of the item in a given assort (weapons parts for example, need recursive loop function)
|
|
* @param itemIdToFind Template id of item to check for
|
|
* @param assort List of items to check in
|
|
* @returns List of children of requested item
|
|
*/
|
|
public List<Item> FindAndReturnChildrenByAssort(string itemIdToFind, List<Item> assort)
|
|
{
|
|
List<Item> list = [];
|
|
foreach (var itemFromAssort in assort)
|
|
{
|
|
// Parent matches desired item + all items in list do not match
|
|
if (string.Equals(itemFromAssort.ParentId, itemIdToFind, StringComparison.OrdinalIgnoreCase)
|
|
&& list.All(item => !string.Equals(itemFromAssort.Id, item.Id, StringComparison.Ordinal)))
|
|
{
|
|
list.Add(itemFromAssort);
|
|
list = list.Concat(FindAndReturnChildrenByAssort(itemFromAssort.Id, assort)).ToList();
|
|
}
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
/**
|
|
* Check if the passed in item has buy count restrictions
|
|
* @param itemToCheck Item to check
|
|
* @returns true if it has buy restrictions
|
|
*/
|
|
public bool HasBuyRestrictions(Item itemToCheck)
|
|
{
|
|
if (itemToCheck.Upd?.BuyRestrictionCurrent is not null && itemToCheck.Upd?.BuyRestrictionMax is not null)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if the passed template id is a dog tag.
|
|
/// </summary>
|
|
/// <param name="tpl">Template id to check.</param>
|
|
/// <returns>True if it is a dogtag.</returns>
|
|
public bool IsDogtag(string tpl)
|
|
{
|
|
return _dogTagTpls.Contains(tpl);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the identifier for a child using slotId, locationX and locationY.
|
|
/// </summary>
|
|
/// <param name="item">Item.</param>
|
|
/// <returns>SlotId OR slotid, locationX, locationY.</returns>
|
|
public string GetChildId(Item item)
|
|
{
|
|
if (item.Location is null)
|
|
{
|
|
return item.SlotId;
|
|
}
|
|
|
|
var LocationTyped = (ItemLocation) item.Location;
|
|
|
|
return $"{item.SlotId},{LocationTyped.X},{LocationTyped.Y}";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if the passed item can be stacked.
|
|
/// </summary>
|
|
/// <param name="tpl">Item to check.</param>
|
|
/// <returns>True if it can be stacked.</returns>
|
|
public bool? IsItemTplStackable(string tpl)
|
|
{
|
|
if (!_databaseService.GetItems().TryGetValue(tpl, out var item))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return item.Properties.StackMaxSize > 1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Splits the item stack if it exceeds its items StackMaxSize property into child items of the passed parent.
|
|
/// </summary>
|
|
/// <param name="itemToSplit">Item to split into smaller stacks.</param>
|
|
/// <returns>List of root item + children.</returns>
|
|
public List<Item> SplitStack(Item itemToSplit)
|
|
{
|
|
if (itemToSplit?.Upd?.StackObjectsCount is null)
|
|
{
|
|
return [itemToSplit];
|
|
}
|
|
|
|
var maxStackSize = GetItem(itemToSplit.Template).Value.Properties.StackMaxSize;
|
|
var remainingCount = itemToSplit.Upd.StackObjectsCount;
|
|
List<Item> rootAndChildren = [];
|
|
|
|
// If the current count is already equal or less than the max
|
|
// return the item as is.
|
|
if (remainingCount <= maxStackSize)
|
|
{
|
|
rootAndChildren.Add(_cloner.Clone(itemToSplit));
|
|
|
|
return rootAndChildren;
|
|
}
|
|
|
|
while (remainingCount.Value != 0)
|
|
{
|
|
var amount = Math.Min(remainingCount ?? 0, maxStackSize ?? 0);
|
|
var newStackClone = _cloner.Clone(itemToSplit);
|
|
|
|
newStackClone.Id = _hashUtil.Generate();
|
|
newStackClone.Upd.StackObjectsCount = amount;
|
|
remainingCount -= amount;
|
|
rootAndChildren.Add(newStackClone);
|
|
}
|
|
|
|
return rootAndChildren;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Turns items like money into separate stacks that adhere to max stack size.
|
|
/// </summary>
|
|
/// <param name="itemToSplit">Item to split into smaller stacks.</param>
|
|
/// <returns>List of separate item stacks.</returns>
|
|
public List<List<Item>> SplitStackIntoSeparateItems(Item itemToSplit)
|
|
{
|
|
var itemTemplate = GetItem(itemToSplit.Template).Value;
|
|
var itemMaxStackSize = itemTemplate.Properties.StackMaxSize ?? 1;
|
|
|
|
// item already within bounds of stack size, return it
|
|
if (itemToSplit.Upd?.StackObjectsCount <= itemMaxStackSize)
|
|
{
|
|
return [[itemToSplit]];
|
|
}
|
|
|
|
// Split items stack into chunks
|
|
List<List<Item>> result = [];
|
|
var remainingCount = itemToSplit.Upd.StackObjectsCount;
|
|
while (remainingCount != 0)
|
|
{
|
|
var amount = Math.Min(remainingCount ?? 0, itemMaxStackSize);
|
|
var newItemClone = _cloner.Clone(itemToSplit);
|
|
|
|
newItemClone.Id = _hashUtil.Generate();
|
|
newItemClone.Upd.StackObjectsCount = amount;
|
|
remainingCount -= amount;
|
|
result.Add([newItemClone]);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Finds Barter items from a list of items.
|
|
/// </summary>
|
|
/// <param name="by">Tpl or id.</param>
|
|
/// <param name="itemsToSearch">Array of items to iterate over.</param>
|
|
/// <param name="desiredBarterItemIds">Desired barter item ids.</param>
|
|
/// <returns>List of Item objects.</returns>
|
|
public List<Item> FindBarterItems(string by, List<Item> itemsToSearch, object desiredBarterItemIds)
|
|
{
|
|
// Find required items to take after buying (handles multiple items)
|
|
var desiredBarterIds =
|
|
desiredBarterItemIds.GetType() == typeof(string) ? [(string) desiredBarterItemIds] : (List<string>) desiredBarterItemIds;
|
|
|
|
List<Item> matchingItems = [];
|
|
foreach (var barterId in desiredBarterIds)
|
|
{
|
|
var filterResult = itemsToSearch.Where(item =>
|
|
{
|
|
return by == "tpl"
|
|
? item.Template.Equals(barterId, StringComparison.OrdinalIgnoreCase)
|
|
: item.Id.Equals(barterId, StringComparison.OrdinalIgnoreCase);
|
|
}
|
|
);
|
|
|
|
matchingItems.AddRange(filterResult);
|
|
}
|
|
|
|
if (matchingItems.Count == 0)
|
|
{
|
|
_logger.Warning($"No items found for barter Id: {desiredBarterIds}");
|
|
}
|
|
|
|
return matchingItems;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Replaces the _id value for the base item + all children that are children of it.
|
|
/// REPARENTS ROOT ITEM ID, NOTHING ELSE.
|
|
/// </summary>
|
|
/// <param name="itemWithChildren">Item with mods to update.</param>
|
|
/// <param name="newId">New id to add on children of base item.</param>
|
|
public void ReplaceRootItemID(List<Item> itemWithChildren, string newId = "")
|
|
{
|
|
// original id on base item
|
|
var oldId = itemWithChildren[0].Id;
|
|
|
|
// Update base item to use new id
|
|
itemWithChildren[0].Id = newId;
|
|
|
|
// Update all parentIds of items attached to base item to use new id
|
|
foreach (var item in itemWithChildren)
|
|
{
|
|
if (string.Equals(item.ParentId, oldId, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
item.ParentId = newId;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ReplaceProfileInventoryIds(BotBaseInventory inventory, List<InsuredItem>? insuredItems = null)
|
|
{
|
|
// Blacklist
|
|
var itemIdBlacklist = new HashSet<string>();
|
|
itemIdBlacklist.UnionWith(
|
|
new List<string>
|
|
{
|
|
inventory.Equipment,
|
|
inventory.QuestRaidItems,
|
|
inventory.QuestStashItems,
|
|
inventory.SortingTable,
|
|
inventory.Stash,
|
|
inventory.HideoutCustomizationStashId
|
|
}
|
|
);
|
|
itemIdBlacklist.UnionWith(inventory.HideoutAreaStashes.Values);
|
|
|
|
// Add insured items ids to blacklist
|
|
if (insuredItems is not null)
|
|
{
|
|
itemIdBlacklist.UnionWith(insuredItems.Select(x => x.ItemId));
|
|
}
|
|
|
|
|
|
foreach (var item in inventory.Items)
|
|
{
|
|
if (itemIdBlacklist.Contains(item.Id))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Generate new id
|
|
var newId = _hashUtil.Generate();
|
|
|
|
// Keep copy of original id
|
|
var originalId = item.Id;
|
|
|
|
// Update items id to new one we generated
|
|
item.Id = newId;
|
|
|
|
// Find all children of item and update their parent ids to match
|
|
var childItems = inventory.Items.Where(x => string.Equals(x.ParentId, originalId, StringComparison.OrdinalIgnoreCase));
|
|
foreach (var childItem in childItems)
|
|
{
|
|
childItem.ParentId = newId;
|
|
}
|
|
|
|
// Also replace in quick slot if the old ID exists.
|
|
if (inventory.FastPanel is null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Update quickslot id
|
|
if (inventory.FastPanel.ContainsKey(originalId))
|
|
{
|
|
inventory.FastPanel[originalId] = newId;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Regenerate all GUIDs with new IDs, except special item types (e.g. quest, sorting table, etc.)
|
|
/// </summary>
|
|
/// <param name="items"></param>
|
|
/// <returns></returns>
|
|
public List<Item> ReplaceIDs(List<Item> items)
|
|
{
|
|
foreach (var item in items)
|
|
{
|
|
// Generate new id
|
|
var newId = _hashUtil.Generate();
|
|
|
|
// Keep copy of original id
|
|
var originalId = item.Id;
|
|
|
|
// Update items id to new one we generated
|
|
item.Id = newId;
|
|
|
|
// Find all children of item and update their parent ids to match
|
|
var childItems = items.Where(x => string.Equals(x.ParentId, originalId, StringComparison.OrdinalIgnoreCase));
|
|
foreach (var childItem in childItems)
|
|
{
|
|
childItem.ParentId = newId;
|
|
}
|
|
}
|
|
|
|
return items;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Regenerate all GUIDs with new IDs, except special item types (e.g. quest, sorting table, etc.) This
|
|
/// function will not mutate the original items list, but will return a new list with new GUIDs.
|
|
/// </summary>
|
|
/// <param name="originalItems">Items to adjust the IDs of</param>
|
|
/// <param name="pmcData">Player profile</param>
|
|
/// <param name="insuredItems">Insured items that should not have their IDs replaced</param>
|
|
/// <param name="fastPanel">Quick slot panel</param>
|
|
/// <returns>Items</returns>
|
|
public List<Item> ReplaceIDs(
|
|
List<Item> originalItems,
|
|
PmcData? pmcData,
|
|
List<InsuredItem>? insuredItems = null,
|
|
Dictionary<string, string>? fastPanel = null)
|
|
{
|
|
// Blacklist
|
|
var itemIdBlacklist = new HashSet<string>();
|
|
|
|
if (pmcData != null)
|
|
{
|
|
itemIdBlacklist.UnionWith(
|
|
new List<string>
|
|
{
|
|
pmcData.Inventory.Equipment,
|
|
pmcData.Inventory.QuestRaidItems,
|
|
pmcData.Inventory.QuestStashItems,
|
|
pmcData.Inventory.SortingTable,
|
|
pmcData.Inventory.Stash,
|
|
pmcData.Inventory.HideoutCustomizationStashId
|
|
}
|
|
);
|
|
itemIdBlacklist.UnionWith(pmcData.Inventory.HideoutAreaStashes.Keys);
|
|
}
|
|
|
|
|
|
// Add insured items ids to blacklist
|
|
if (insuredItems is not null)
|
|
{
|
|
itemIdBlacklist.UnionWith(insuredItems.Select(x => x.ItemId));
|
|
}
|
|
|
|
|
|
foreach (var item in originalItems)
|
|
{
|
|
if (itemIdBlacklist.Contains(item.Id))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Generate new id
|
|
var newId = _hashUtil.Generate();
|
|
|
|
// Keep copy of original id
|
|
var originalId = item.Id;
|
|
|
|
// Update items id to new one we generated
|
|
item.Id = newId;
|
|
|
|
// Find all children of item and update their parent ids to match
|
|
var childItems = originalItems.Where(x => string.Equals(x.ParentId, originalId, StringComparison.OrdinalIgnoreCase));
|
|
foreach (var childItem in childItems)
|
|
{
|
|
childItem.ParentId = newId;
|
|
}
|
|
|
|
// Also replace in quick slot if the old ID exists.
|
|
if (pmcData.Inventory.FastPanel is null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Update quickslot id
|
|
if (pmcData.Inventory.FastPanel.ContainsKey(originalId))
|
|
{
|
|
pmcData.Inventory.FastPanel[originalId] = newId;
|
|
}
|
|
}
|
|
|
|
return originalItems;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Mark the passed in list of items as found in raid.
|
|
/// Modifies passed in items
|
|
/// Will not flag ammo or currency as FiR
|
|
/// </summary>
|
|
/// <param name="items">The list of items to mark as FiR</param>
|
|
public void SetFoundInRaid(List<Item> items)
|
|
{
|
|
foreach (var item in items)
|
|
{
|
|
if (IsOfBaseclasses(item.Template, [BaseClasses.MONEY, BaseClasses.AMMO]))
|
|
{
|
|
if (item.Upd is not null)
|
|
{
|
|
item.Upd.SpawnedInSession = null;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
item.Upd ??= new Upd();
|
|
item.Upd.SpawnedInSession = true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Mark the passed in list of items as found in raid.
|
|
/// Modifies passed in items
|
|
/// </summary>
|
|
/// <param name="item">The list of items to mark as FiR</param>
|
|
/// <param name="excludeCurrency">Skip adding FiR status to currency items</param>
|
|
public void SetFoundInRaid(Item item, bool excludeCurrency = true)
|
|
{
|
|
if (excludeCurrency && IsOfBaseclass(item.Template, BaseClasses.MONEY))
|
|
{
|
|
return;
|
|
}
|
|
|
|
item.Upd ??= new Upd();
|
|
item.Upd.SpawnedInSession = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// WARNING, SLOW. Recursively loop down through an items hierarchy to see if any of the ids match the supplied list, return true if any do
|
|
/// </summary>
|
|
/// <param name="tpl">Items tpl to check parents of</param>
|
|
/// <param name="tplsToCheck">Tpl values to check if parents of item match</param>
|
|
/// <returns>bool Match found</returns>
|
|
public bool DoesItemOrParentsIdMatch(string tpl, List<string> tplsToCheck)
|
|
{
|
|
var itemDetails = GetItem(tpl);
|
|
var itemExists = itemDetails.Key;
|
|
var item = itemDetails.Value;
|
|
|
|
// not an item, drop out
|
|
if (!itemExists)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// no parent to check
|
|
if (item.Parent == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Does templateId match any values in tplsToCheck array
|
|
if (tplsToCheck.Contains(item.Id))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// check items parent with same method
|
|
if (tplsToCheck.Contains(item.Parent))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return DoesItemOrParentsIdMatch(item.Parent, tplsToCheck);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if item is quest item
|
|
/// </summary>
|
|
/// <param name="tpl">Items tpl to check quest status of</param>
|
|
/// <returns>true if item is flagged as quest item</returns>
|
|
public bool IsQuestItem(string tpl)
|
|
{
|
|
var itemDetails = GetItem(tpl);
|
|
if (itemDetails.Key && itemDetails.Value.Properties.QuestItem.GetValueOrDefault(false))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks to see if the item is *actually* moddable in-raid. Checks include the items existence in the database, the
|
|
/// parent items existence in the database, the existence (and value) of the items RaidModdable property, and that
|
|
/// the parents slot-required property exists, matches that of the item, and its value.
|
|
/// </summary>
|
|
/// <param name="item">The item to be checked</param>
|
|
/// <param name="parent">The parent of the item to be checked</param>
|
|
/// <returns>True if the item is actually moddable, false if it is not, and null if the check cannot be performed.</returns>
|
|
public bool? IsRaidModdable(Item item, Item parent)
|
|
{
|
|
// This check requires the item to have the slotId property populated.
|
|
if (item.SlotId == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var itemTemplate = GetItem(item.Template);
|
|
var parentTemplate = GetItem(parent.Template);
|
|
|
|
// Check for RaidModdable property on the item template.
|
|
var isNotRaidModdable = false;
|
|
if (itemTemplate.Key)
|
|
{
|
|
isNotRaidModdable = itemTemplate.Value?.Properties?.RaidModdable == false;
|
|
}
|
|
|
|
// Check to see if the slot that the item is attached to is marked as required in the parent item's template.
|
|
var isRequiredSlot = false;
|
|
if (parentTemplate.Key && parentTemplate.Value?.Properties?.Slots != null)
|
|
{
|
|
isRequiredSlot = parentTemplate.Value?.Properties?.Slots?.Any(slot =>
|
|
slot?.Name == item?.SlotId &&
|
|
(slot?.Required ?? false)
|
|
) ??
|
|
false;
|
|
}
|
|
|
|
return itemTemplate.Key && parentTemplate.Key && (isNotRaidModdable || isRequiredSlot);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieves the main parent item for a given attachment item.
|
|
/// This method traverses up the hierarchy of items starting from a given `itemId`, until it finds the main parent
|
|
/// item that is not an attached attachment itself. In other words, if you pass it an item id of a suppressor, it
|
|
/// will traverse up the muzzle brake, barrel, upper receiver, and return the gun that the suppressor is ultimately
|
|
/// attached to, even if that gun is located within multiple containers.
|
|
/// It's important to note that traversal is expensive, so this method requires that you pass it a Map of the items
|
|
/// to traverse, where the keys are the item IDs and the values are the corresponding Item objects. This alleviates
|
|
/// some of the performance concerns, as it allows for quick lookups of items by ID.
|
|
/// </summary>
|
|
/// <param name="itemId">The unique identifier of the item for which to find the main parent.</param>
|
|
/// <param name="itemsMap">A Dictionary containing item IDs mapped to their corresponding Item objects for quick lookup.</param>
|
|
/// <returns>The Item object representing the top-most parent of the given item, or null if no such parent exists.</returns>
|
|
public Item? GetAttachmentMainParent(string itemId, Dictionary<string, Item> itemsMap)
|
|
{
|
|
var currentItem = itemsMap.FirstOrDefault(x => x.Key == itemId).Value;
|
|
|
|
while (currentItem != null && IsAttachmentAttached(currentItem))
|
|
{
|
|
currentItem = itemsMap.FirstOrDefault(x => x.Key == currentItem.ParentId).Value;
|
|
if (currentItem == null)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
return currentItem;
|
|
}
|
|
|
|
/**
|
|
* Determines if an item is an attachment that is currently attached to its parent item.
|
|
*
|
|
* @param item The item to check.
|
|
* @returns true if the item is attached attachment, otherwise false.
|
|
*/
|
|
public bool IsAttachmentAttached(Item item)
|
|
{
|
|
HashSet<string> check = ["hideout", "main"];
|
|
|
|
return !(check.Contains(item.SlotId) || _slotsAsStrings.Contains(item.SlotId) || !int.TryParse(item.SlotId, out _));
|
|
}
|
|
|
|
/**
|
|
* Retrieves the equipment parent item for a given item.
|
|
*
|
|
* This method traverses up the hierarchy of items starting from a given `itemId`, until it finds the equipment
|
|
* parent item. In other words, if you pass it an item id of a suppressor, it will traverse up the muzzle brake,
|
|
* barrel, upper receiver, gun, nested backpack, and finally return the backpack Item that is equipped.
|
|
*
|
|
* It's important to note that traversal is expensive, so this method requires that you pass it a Dictionary of the items
|
|
* to traverse, where the keys are the item IDs and the values are the corresponding Item objects. This alleviates
|
|
* some of the performance concerns, as it allows for quick lookups of items by ID.
|
|
*
|
|
* @param itemId - The unique identifier of the item for which to find the equipment parent.
|
|
* @param itemsMap - A Dictionary containing item IDs mapped to their corresponding Item objects for quick lookup.
|
|
* @returns The Item object representing the equipment parent of the given item, or `null` if no such parent exists.
|
|
*/
|
|
public Item? GetEquipmentParent(string itemId, Dictionary<string, Item> itemsMap)
|
|
{
|
|
var currentItem = itemsMap.GetValueOrDefault(itemId);
|
|
|
|
while (currentItem is not null && !_slotsAsStrings.Contains(currentItem.SlotId))
|
|
{
|
|
currentItem = itemsMap.GetValueOrDefault(currentItem.ParentId);
|
|
if (currentItem is null)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
return currentItem;
|
|
}
|
|
|
|
/**
|
|
* Get the inventory size of an item
|
|
* @param items Item with children
|
|
* @param rootItemId
|
|
* @returns ItemSize object (width and height)
|
|
*/
|
|
public ItemSize GetItemSize(List<Item> items, string rootItemId)
|
|
{
|
|
var rootTemplate = GetItem(items.Where(x => x.Id.Equals(rootItemId, StringComparison.OrdinalIgnoreCase)).ToList()[0].Template).Value;
|
|
var width = rootTemplate.Properties.Width;
|
|
var height = rootTemplate.Properties.Height;
|
|
|
|
var sizeUp = 0;
|
|
var sizeDown = 0;
|
|
var sizeLeft = 0;
|
|
var sizeRight = 0;
|
|
|
|
var forcedUp = 0;
|
|
var forcedDown = 0;
|
|
var forcedLeft = 0;
|
|
var forcedRight = 0;
|
|
|
|
var children = FindAndReturnChildrenAsItems(items, rootItemId);
|
|
foreach (var ci in children)
|
|
{
|
|
var itemTemplate = GetItem(ci.Template).Value;
|
|
|
|
// Calculating child ExtraSize
|
|
if (itemTemplate.Properties.ExtraSizeForceAdd ?? false)
|
|
{
|
|
forcedUp += itemTemplate.Properties.ExtraSizeUp.Value;
|
|
forcedDown += itemTemplate.Properties.ExtraSizeDown.Value;
|
|
forcedLeft += itemTemplate.Properties.ExtraSizeLeft.Value;
|
|
forcedRight += itemTemplate.Properties.ExtraSizeRight.Value;
|
|
}
|
|
else
|
|
{
|
|
sizeUp = sizeUp < itemTemplate.Properties.ExtraSizeUp ? itemTemplate.Properties.ExtraSizeUp.Value : sizeUp;
|
|
sizeDown = sizeDown < itemTemplate.Properties.ExtraSizeDown ? itemTemplate.Properties.ExtraSizeDown.Value : sizeDown;
|
|
sizeLeft = sizeLeft < itemTemplate.Properties.ExtraSizeLeft ? itemTemplate.Properties.ExtraSizeLeft.Value : sizeLeft;
|
|
sizeRight = sizeRight < itemTemplate.Properties.ExtraSizeRight ? itemTemplate.Properties.ExtraSizeRight.Value : sizeRight;
|
|
}
|
|
}
|
|
|
|
return new ItemSize
|
|
{
|
|
Width = (width ?? 0) + sizeLeft + sizeRight + forcedLeft + forcedRight,
|
|
Height = (height ?? 0) + sizeUp + sizeDown + forcedUp + forcedDown
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get a random cartridge from an items Filter property
|
|
* @param item Db item template to look up Cartridge filter values from
|
|
* @returns Caliber of cartridge
|
|
*/
|
|
public string? GetRandomCompatibleCaliberTemplateId(TemplateItem item)
|
|
{
|
|
var cartridges = item?.Properties?.Cartridges[0]?.Props?.Filters[0]?.Filter;
|
|
|
|
if (cartridges is null)
|
|
{
|
|
_logger.Warning($"Failed to find cartridge for item: {item?.Id} {item?.Name}");
|
|
return null;
|
|
}
|
|
|
|
return _randomUtil.GetArrayValue(cartridges);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add cartridges to the ammo box with correct max stack sizes
|
|
/// </summary>
|
|
/// <param name="ammoBox">Box to add cartridges to</param>
|
|
/// <param name="ammoBoxDetails">Item template from items db</param>
|
|
public void AddCartridgesToAmmoBox(List<Item> ammoBox, TemplateItem ammoBoxDetails)
|
|
{
|
|
var ammoBoxMaxCartridgeCount = ammoBoxDetails.Properties.StackSlots[0].MaxCount;
|
|
var cartridgeTpl = ammoBoxDetails.Properties.StackSlots[0].Props.Filters[0].Filter.FirstOrDefault();
|
|
var cartridgeDetails = GetItem(cartridgeTpl);
|
|
var cartridgeMaxStackSize = cartridgeDetails.Value.Properties.StackMaxSize;
|
|
|
|
// Exit if ammo already exists in box
|
|
if (ammoBox.Any(item => item.Template.Equals(cartridgeTpl, StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Add new stack-size-correct items to ammo box
|
|
double? currentStoredCartridgeCount = 0;
|
|
var maxPerStack = Math.Min(ammoBoxMaxCartridgeCount ?? 0, cartridgeMaxStackSize ?? 0);
|
|
// Find location based on Max ammo box size
|
|
var location = Math.Ceiling(ammoBoxMaxCartridgeCount / maxPerStack ?? 0) - 1;
|
|
|
|
while (currentStoredCartridgeCount < ammoBoxMaxCartridgeCount)
|
|
{
|
|
var remainingSpace = ammoBoxMaxCartridgeCount - currentStoredCartridgeCount;
|
|
var cartridgeCountToAdd = remainingSpace < maxPerStack ? remainingSpace : maxPerStack;
|
|
|
|
// Add cartridge item into items array
|
|
var cartridgeItemToAdd = CreateCartridges(
|
|
ammoBox[0].Id,
|
|
cartridgeTpl,
|
|
(int) cartridgeCountToAdd,
|
|
location
|
|
);
|
|
|
|
// In live no ammo box has the first cartridge item with a location
|
|
if (location == 0)
|
|
{
|
|
cartridgeItemToAdd.Location = null;
|
|
}
|
|
|
|
ammoBox.Add(cartridgeItemToAdd);
|
|
|
|
currentStoredCartridgeCount += cartridgeCountToAdd;
|
|
location--;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add a single stack of cartridges to the ammo box
|
|
* @param ammoBox Box to add cartridges to
|
|
* @param ammoBoxDetails Item template from items db
|
|
*/
|
|
public void AddSingleStackCartridgesToAmmoBox(List<Item> ammoBox, TemplateItem ammoBoxDetails)
|
|
{
|
|
var ammoBoxMaxCartridgeCount = ammoBoxDetails.Properties?.StackSlots?[0].MaxCount ?? 0;
|
|
var cartridgeTpl = ammoBoxDetails.Properties?.StackSlots?[0].Props?.Filters?[0].Filter?.FirstOrDefault();
|
|
ammoBox.Add(
|
|
CreateCartridges(
|
|
ammoBox[0].Id,
|
|
cartridgeTpl,
|
|
(int) ammoBoxMaxCartridgeCount,
|
|
0
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Check if item is stored inside of a container
|
|
* @param itemToCheck Item to check is inside of container
|
|
* @param desiredContainerSlotId Name of slot to check item is in e.g. SecuredContainer/Backpack
|
|
* @param items Inventory with child parent items to check
|
|
* @returns True when item is in container
|
|
*/
|
|
public bool ItemIsInsideContainer(Item itemToCheck, string desiredContainerSlotId, List<Item> items)
|
|
{
|
|
// Get items parent
|
|
var parent = items.FirstOrDefault(item => item.Id.Equals(itemToCheck.ParentId, StringComparison.OrdinalIgnoreCase));
|
|
if (parent is null)
|
|
// No parent, end of line, not inside container
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (parent.SlotId == desiredContainerSlotId)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return ItemIsInsideContainer(parent, desiredContainerSlotId, items);
|
|
}
|
|
|
|
/**
|
|
* Add child items (cartridges) to a magazine
|
|
* @param magazine Magazine to add child items to
|
|
* @param magTemplate Db template of magazine
|
|
* @param staticAmmoDist Cartridge distribution
|
|
* @param caliber Caliber of cartridge to add to magazine
|
|
* @param minSizePercent % the magazine must be filled to
|
|
* @param defaultCartridgeTpl Cartridge to use when none found
|
|
* @param weapon Weapon the magazine will be used for (if passed in uses Chamber as whitelist)
|
|
*/
|
|
public void FillMagazineWithRandomCartridge(
|
|
List<Item> magazine,
|
|
TemplateItem magTemplate,
|
|
Dictionary<string, List<StaticAmmoDetails>> staticAmmoDist,
|
|
string? caliber = null,
|
|
double minSizePercent = 0.25,
|
|
string? defaultCartridgeTpl = null,
|
|
TemplateItem? weapon = null)
|
|
{
|
|
var chosenCaliber = caliber ?? GetRandomValidCaliber(magTemplate);
|
|
|
|
// Edge case for the Klin pp-9, it has a typo in its ammo caliber
|
|
if (chosenCaliber == "Caliber9x18PMM")
|
|
{
|
|
chosenCaliber = "Caliber9x18PM";
|
|
}
|
|
|
|
// Chose a randomly weighted cartridge that fits
|
|
var cartridgeTpl = DrawAmmoTpl(
|
|
chosenCaliber,
|
|
staticAmmoDist,
|
|
defaultCartridgeTpl,
|
|
weapon?.Properties?.Chambers?.FirstOrDefault()?.Props?.Filters?.FirstOrDefault()?.Filter ?? null
|
|
);
|
|
if (cartridgeTpl is null)
|
|
{
|
|
if (_logger.IsLogEnabled(LogLevel.Debug))
|
|
{
|
|
_logger.Debug($"Unable to fill item: {magazine.FirstOrDefault().Id} {magTemplate.Name} with cartridges, none found.");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
FillMagazineWithCartridge(magazine, magTemplate, cartridgeTpl, minSizePercent);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add child items to a magazine of a specific cartridge
|
|
/// </summary>
|
|
/// <param name="magazineWithChildCartridges">Magazine to add child items to</param>
|
|
/// <param name="magTemplate">Db template of magazine</param>
|
|
/// <param name="cartridgeTpl">Cartridge to add to magazine</param>
|
|
/// <param name="minSizeMultiplier">% the magazine must be filled to</param>
|
|
public void FillMagazineWithCartridge(
|
|
List<Item> magazineWithChildCartridges,
|
|
TemplateItem magTemplate,
|
|
string cartridgeTpl,
|
|
double minSizeMultiplier = 0.25
|
|
)
|
|
{
|
|
var isUBGL = IsOfBaseclass(magTemplate.Id, BaseClasses.UBGL);
|
|
if (isUBGL)
|
|
// UBGL don't have mags
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Get cartridge properties and max allowed stack size
|
|
var cartridgeDetails = GetItem(cartridgeTpl);
|
|
if (!cartridgeDetails.Key)
|
|
{
|
|
_logger.Error(_localisationService.GetText("item-invalid_tpl_item", cartridgeTpl));
|
|
}
|
|
|
|
var cartridgeMaxStackSize = cartridgeDetails.Value?.Properties?.StackMaxSize;
|
|
if (cartridgeMaxStackSize is null)
|
|
{
|
|
_logger.Error($"Item with tpl: {cartridgeTpl} lacks a _props or StackMaxSize property");
|
|
}
|
|
|
|
// Get max number of cartridges in magazine, choose random value between min/max
|
|
var magProps = magTemplate.Properties;
|
|
var magazineCartridgeMaxCount = IsOfBaseclass(magTemplate.Id, BaseClasses.SPRING_DRIVEN_CYLINDER)
|
|
? magProps?.Slots?.Count // Edge case for rotating grenade launcher magazine
|
|
: magProps?.Cartridges?.FirstOrDefault()?.MaxCount;
|
|
|
|
if (magazineCartridgeMaxCount is null)
|
|
{
|
|
_logger.Warning($"Magazine: {magTemplate.Id} {magTemplate.Name} lacks a Cartridges array, unable to fill magazine with ammo");
|
|
|
|
return;
|
|
}
|
|
|
|
var desiredStackCount = _randomUtil.GetInt(
|
|
(int)
|
|
Math.Round(minSizeMultiplier * magazineCartridgeMaxCount ?? 0),
|
|
(int) magazineCartridgeMaxCount
|
|
);
|
|
|
|
if (magazineWithChildCartridges.Count > 1)
|
|
{
|
|
_logger.Warning($"Magazine {magTemplate.Name} already has cartridges defined, this may cause issues");
|
|
}
|
|
|
|
// Loop over cartridge count and add stacks to magazine
|
|
var currentStoredCartridgeCount = 0;
|
|
var location = 0;
|
|
while (currentStoredCartridgeCount < desiredStackCount)
|
|
{
|
|
// Get stack size of cartridges
|
|
var cartridgeCountToAdd =
|
|
desiredStackCount <= cartridgeMaxStackSize ? desiredStackCount : cartridgeMaxStackSize;
|
|
|
|
// Ensure we don't go over the max stackCount size
|
|
var remainingSpace = desiredStackCount - currentStoredCartridgeCount;
|
|
if (cartridgeCountToAdd > remainingSpace)
|
|
{
|
|
cartridgeCountToAdd = remainingSpace;
|
|
}
|
|
|
|
// Add cartridge item object into items array
|
|
magazineWithChildCartridges.Add(
|
|
CreateCartridges(
|
|
magazineWithChildCartridges[0].Id,
|
|
cartridgeTpl,
|
|
cartridgeCountToAdd ?? 0,
|
|
location
|
|
)
|
|
);
|
|
|
|
currentStoredCartridgeCount += cartridgeCountToAdd.Value;
|
|
location++;
|
|
}
|
|
|
|
// Only one cartridge stack added, remove location property as it's only used for 2 or more stacks
|
|
if (location == 1)
|
|
{
|
|
magazineWithChildCartridges[1].Location = null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Choose a random bullet type from the list of possible a magazine has
|
|
/// </summary>
|
|
/// <param name="magTemplate">Magazine template from Db</param>
|
|
/// <returns>Tpl of cartridge</returns>
|
|
protected string? GetRandomValidCaliber(TemplateItem magTemplate)
|
|
{
|
|
var ammoTpls = magTemplate.Properties.Cartridges[0].Props.Filters[0].Filter;
|
|
var calibers = ammoTpls
|
|
.Where(x => GetItem(x).Key)
|
|
.Select(x => GetItem(x).Value.Properties.Caliber)
|
|
.ToList();
|
|
|
|
return _randomUtil.DrawRandomFromList(calibers).FirstOrDefault();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Chose a randomly weighted cartridge that fits
|
|
/// </summary>
|
|
/// <param name="caliber">Desired caliber</param>
|
|
/// <param name="staticAmmoDist">Cartridges and their weights</param>
|
|
/// <param name="fallbackCartridgeTpl">If a cartridge cannot be found in the above staticAmmoDist param, use this instead</param>
|
|
/// <param name="cartridgeWhitelist">OPTIONAL whitelist for cartridges</param>
|
|
/// <returns>Tpl of cartridge</returns>
|
|
protected string? DrawAmmoTpl(
|
|
string caliber,
|
|
Dictionary<string, List<StaticAmmoDetails>> staticAmmoDist,
|
|
string? fallbackCartridgeTpl = null,
|
|
ICollection<string>? cartridgeWhitelist = null
|
|
)
|
|
{
|
|
var ammos = staticAmmoDist.GetValueOrDefault(caliber, []);
|
|
if (ammos.Count == 0 && fallbackCartridgeTpl is not null)
|
|
{
|
|
_logger.Warning($"Unable to pick a cartridge for caliber: {caliber}, staticAmmoDist has no data. using fallback value of {fallbackCartridgeTpl}");
|
|
|
|
return fallbackCartridgeTpl;
|
|
}
|
|
|
|
if (ammos.Count == 0 && fallbackCartridgeTpl is null)
|
|
{
|
|
_logger.Warning($"Unable to pick a cartridge for caliber: {caliber}, staticAmmoDist has no data. No fallback value provided");
|
|
|
|
return null;
|
|
}
|
|
|
|
var ammoArray = new ProbabilityObjectArray<string, float?>(_mathUtil, _cloner);
|
|
foreach (var icd in ammos)
|
|
{
|
|
// Whitelist exists and tpl not inside it, skip
|
|
// Fixes 9x18mm kedr issues
|
|
if (cartridgeWhitelist is not null && !cartridgeWhitelist.Contains(icd.Tpl))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
ammoArray.Add(new ProbabilityObject<string, float?>(icd.Tpl, (double) icd.RelativeProbability, null));
|
|
}
|
|
|
|
return ammoArray.Draw().FirstOrDefault();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a basic cartridge object
|
|
/// </summary>
|
|
/// <param name="parentId">container cartridges will be placed in</param>
|
|
/// <param name="ammoTpl">Cartridge to insert</param>
|
|
/// <param name="stackCount">Count of cartridges inside parent</param>
|
|
/// <param name="location">Location inside parent (e.g. 0, 1)</param>
|
|
/// <returns>Item</returns>
|
|
public Item CreateCartridges(
|
|
string parentId,
|
|
string ammoTpl,
|
|
int stackCount,
|
|
double location
|
|
)
|
|
{
|
|
return new Item
|
|
{
|
|
Id = _hashUtil.Generate(),
|
|
Template = ammoTpl,
|
|
ParentId = parentId,
|
|
SlotId = "cartridges",
|
|
Location = location,
|
|
Upd = new Upd
|
|
{
|
|
StackObjectsCount = stackCount
|
|
}
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the size of a stack, return 1 if no stack object count property found
|
|
/// </summary>
|
|
/// <param name="item">Item to get stack size of</param>
|
|
/// <returns>size of stack</returns>
|
|
public int GetItemStackSize(Item item)
|
|
{
|
|
if (item.Upd?.StackObjectsCount is not null)
|
|
{
|
|
return (int) item.Upd.StackObjectsCount;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the name of an item from the locale file using the item tpl
|
|
/// </summary>
|
|
/// <param name="itemTpl">Tpl of item to get name of</param>
|
|
/// <returns>Full name, short name if not found</returns>
|
|
public string GetItemName(string itemTpl)
|
|
{
|
|
var localeDb = _localeService.GetLocaleDb();
|
|
var result = localeDb[$"{itemTpl} Name"];
|
|
if (result?.Length > 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
return localeDb[$"{itemTpl} ShortName"];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get all item tpls with a desired base type
|
|
/// </summary>
|
|
/// <param name="desiredBaseType">Item base type wanted</param>
|
|
/// <returns>Array of tpls</returns>
|
|
public List<string> GetItemTplsOfBaseType(string desiredBaseType)
|
|
{
|
|
return _databaseService.GetItems()
|
|
.Values
|
|
.Where(item => item.Parent == desiredBaseType)
|
|
.Select(item => item.Id)
|
|
.ToList();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add child slot items to an item, chooses random child item if multiple choices exist
|
|
/// </summary>
|
|
/// <param name="itemToAdd">array with single object (root item)</param>
|
|
/// <param name="itemToAddTemplate">Db template for root item</param>
|
|
/// <param name="modSpawnChanceDict">Optional dictionary of mod name + % chance mod will be included in item (e.g. front_plate: 100)</param>
|
|
/// <param name="requiredOnly">Only add required mods</param>
|
|
/// <returns>Item with children</returns>
|
|
public List<Item> AddChildSlotItems(
|
|
List<Item> itemToAdd,
|
|
TemplateItem itemToAddTemplate,
|
|
Dictionary<string, double?>? modSpawnChanceDict = null,
|
|
bool requiredOnly = false
|
|
)
|
|
{
|
|
var result = itemToAdd;
|
|
HashSet<string> incompatibleModTpls = [];
|
|
foreach (var slot in itemToAddTemplate.Properties.Slots)
|
|
{
|
|
// If only required mods is requested, skip non-essential
|
|
if (requiredOnly && !(slot.Required ?? false))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Roll chance for non-required slot mods
|
|
if (modSpawnChanceDict is not null && !(slot.Required ?? false))
|
|
{
|
|
// only roll chance to not include mod if dict exists and has value for this mod type (e.g. front_plate)
|
|
var modSpawnChance = modSpawnChanceDict[slot.Name.ToLower()];
|
|
if (modSpawnChance is not null)
|
|
{
|
|
if (!_randomUtil.GetChance100(modSpawnChance ?? 0))
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
var itemPool = slot.Props.Filters[0].Filter ?? [];
|
|
if (itemPool.Count == 0)
|
|
{
|
|
if (_logger.IsLogEnabled(LogLevel.Debug))
|
|
{
|
|
_logger.Debug(
|
|
$"Unable to choose a mod for slot: {slot.Name} on item: {itemToAddTemplate.Id} {itemToAddTemplate.Name}, parents' 'Filter' array is empty, skipping"
|
|
);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
var chosenTpl = GetCompatibleTplFromArray(itemPool, incompatibleModTpls);
|
|
if (chosenTpl is null)
|
|
{
|
|
if (_logger.IsLogEnabled(LogLevel.Debug))
|
|
{
|
|
_logger.Debug(
|
|
$"Unable to choose a mod for slot: {slot.Name} on item: {itemToAddTemplate.Id} {itemToAddTemplate.Name}, no compatible tpl found in pool of {itemPool.Count}, skipping"
|
|
);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
// Create basic item structure ready to add to weapon array
|
|
Item modItemToAdd = new()
|
|
{
|
|
Id = _hashUtil.Generate(),
|
|
Template = chosenTpl,
|
|
ParentId = result[0].Id,
|
|
SlotId = slot.Name
|
|
};
|
|
|
|
// Add chosen item to weapon array
|
|
result.Add(modItemToAdd);
|
|
|
|
var modItemDbDetails = GetItem(modItemToAdd.Template).Value;
|
|
|
|
// Include conflicting items of newly added mod in pool to be used for next mod choice
|
|
incompatibleModTpls.UnionWith(modItemDbDetails.Properties.ConflictingItems);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a compatible tpl from the array provided where it is not found in the provided incompatible mod tpls parameter
|
|
/// </summary>
|
|
/// <param name="possibleTpls">Tpls to randomly choose from</param>
|
|
/// <param name="incompatibleModTpls">Incompatible tpls to not allow</param>
|
|
/// <returns>Chosen tpl or undefined</returns>
|
|
public string? GetCompatibleTplFromArray(HashSet<string> possibleTpls, HashSet<string> incompatibleModTpls)
|
|
{
|
|
if (!possibleTpls.Any())
|
|
{
|
|
return null;
|
|
}
|
|
|
|
string? chosenTpl = null;
|
|
var count = 0;
|
|
while (chosenTpl is null)
|
|
{
|
|
// Loop over choosing a random tpl until one is found or count variable reaches the same size as the possible tpls array
|
|
var tpl = _randomUtil.GetArrayValue(possibleTpls);
|
|
if (incompatibleModTpls.Contains(tpl))
|
|
{
|
|
// Incompatible tpl was chosen, try again
|
|
count++;
|
|
if (count >= possibleTpls.Count)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
chosenTpl = tpl;
|
|
}
|
|
|
|
return chosenTpl;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is the provided item._props.Slots._name property a plate slot
|
|
/// </summary>
|
|
/// <param name="slotName">Name of slot (_name) of Items Slot array</param>
|
|
/// <returns>True if it is a slot that holds a removable plate</returns>
|
|
public bool IsRemovablePlateSlot(string slotName)
|
|
{
|
|
return GetRemovablePlateSlotIds().Contains(slotName.ToLower());
|
|
}
|
|
|
|
// Get a list of slot names that hold removable plates
|
|
// Returns Array of slot ids (e.g. front_plate)
|
|
public FrozenSet<string> GetRemovablePlateSlotIds()
|
|
{
|
|
return _removablePlateSlotIds;
|
|
}
|
|
|
|
// Generate new unique ids for child items while preserving hierarchy
|
|
// Base/primary item
|
|
// Primary item + children of primary item
|
|
// Returns Item array with updated IDs
|
|
public List<Item> ReparentItemAndChildren(Item rootItem, List<Item> itemWithChildren)
|
|
{
|
|
var oldRootId = itemWithChildren[0].Id;
|
|
Dictionary<string, string> idMappings = new();
|
|
|
|
idMappings[oldRootId] = rootItem.Id;
|
|
|
|
foreach (var mod in itemWithChildren)
|
|
{
|
|
if (!idMappings.ContainsKey(mod.Id))
|
|
{
|
|
idMappings[mod.Id] = _hashUtil.Generate();
|
|
}
|
|
|
|
// Has parentId + no remapping exists for its parent
|
|
if (mod.ParentId is not null && (!idMappings.ContainsKey(mod.ParentId) || idMappings?[mod.ParentId] is null))
|
|
// Make remapping for items parentId
|
|
{
|
|
idMappings[mod.ParentId] = _hashUtil.Generate();
|
|
}
|
|
|
|
mod.Id = idMappings[mod.Id];
|
|
if (mod.ParentId is not null)
|
|
{
|
|
mod.ParentId = idMappings[mod.ParentId];
|
|
}
|
|
}
|
|
|
|
// Force item's details into first location of presetItems
|
|
if (itemWithChildren[0].Template != rootItem.Template)
|
|
{
|
|
_logger.Warning($"Reassigning root item from {itemWithChildren[0].Template} to {rootItem.Template}");
|
|
}
|
|
|
|
itemWithChildren[0] = rootItem;
|
|
|
|
return itemWithChildren;
|
|
}
|
|
|
|
// Update a root items _id property value to be unique
|
|
// Item to update root items _id property
|
|
// Optional: new id to use
|
|
// Returns New root id
|
|
|
|
public string RemapRootItemId(List<Item> itemWithChildren, string? newId = null)
|
|
{
|
|
newId ??= _hashUtil.Generate();
|
|
|
|
var rootItemExistingId = itemWithChildren[0].Id;
|
|
|
|
foreach (var item in itemWithChildren)
|
|
{
|
|
// Root, update id
|
|
if (item.Id.Equals(rootItemExistingId, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
item.Id = newId;
|
|
|
|
continue;
|
|
}
|
|
|
|
// Child with parent of root, update
|
|
if (string.Equals(item.ParentId, rootItemExistingId, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
item.ParentId = newId;
|
|
}
|
|
}
|
|
|
|
return newId;
|
|
}
|
|
|
|
// Adopts orphaned items by resetting them as root "hideout" items. Helpful in situations where a parent has been
|
|
// deleted from a group of items and there are children still referencing the missing parent. This method will
|
|
// remove the reference from the children to the parent and set item properties to root values.
|
|
//
|
|
// The ID of the "root" of the container.
|
|
// Array of Items that should be adjusted.
|
|
// Returns Array of Items that have been adopted.
|
|
public List<Item> AdoptOrphanedItems(string rootId, List<Item> items)
|
|
{
|
|
foreach (var item in items)
|
|
{
|
|
// Check if the item's parent exists.
|
|
var parentExists = items.Any(parentItem => parentItem.Id.Equals(item.ParentId, StringComparison.OrdinalIgnoreCase));
|
|
|
|
// If the parent does not exist and the item is not already a 'hideout' item, adopt the orphaned item by
|
|
// setting the parent ID to the PMCs inventory equipment ID, the slot ID to 'hideout', and remove the location.
|
|
if (!parentExists && item.ParentId != rootId && item.SlotId != "hideout")
|
|
{
|
|
item.ParentId = rootId;
|
|
item.SlotId = "hideout";
|
|
item.Location = null;
|
|
}
|
|
}
|
|
|
|
return items;
|
|
}
|
|
|
|
// Populate a Map object of items for quick lookup using their ID.
|
|
//
|
|
// An array of Items that should be added to a Map.
|
|
// Returns A Map where the keys are the item IDs and the values are the corresponding Item objects.
|
|
public Dictionary<string, Item> GenerateItemsMap(List<Item> items)
|
|
{
|
|
// Convert list to dictionary, keyed by items Id
|
|
return items.ToDictionary(item => item.Id);
|
|
}
|
|
|
|
// Add a blank upd object to passed in item if it does not exist already
|
|
// item to add upd to
|
|
// text to write to log when upd object was not found
|
|
// Returns True when upd object was added
|
|
public bool AddUpdObjectToItem(Item item, string? warningMessageWhenMissing = null)
|
|
{
|
|
if (item.Upd is not null)
|
|
{
|
|
// Already exists, exit early
|
|
return false;
|
|
}
|
|
|
|
item.Upd = new Upd();
|
|
|
|
if (warningMessageWhenMissing is not null)
|
|
{
|
|
if (_logger.IsLogEnabled(LogLevel.Debug))
|
|
{
|
|
_logger.Debug(warningMessageWhenMissing);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Return all tpls from Money enum
|
|
// Returns string tpls
|
|
public List<string> GetMoneyTpls()
|
|
{
|
|
return [Money.ROUBLES, Money.DOLLARS, Money.EUROS, Money.GP];
|
|
}
|
|
|
|
// Get a randomised stack size for the passed in ammo
|
|
// Ammo to get stack size for
|
|
// Default: Limit to 60 to prevent crazy values when players use stack increase mods
|
|
// Returns number
|
|
public int GetRandomisedAmmoStackSize(TemplateItem ammoItemTemplate, int maxLimit = 60)
|
|
{
|
|
return ammoItemTemplate.Properties?.StackMaxSize == 1
|
|
? 1
|
|
: _randomUtil.GetInt(
|
|
ammoItemTemplate.Properties?.StackMinRandom ?? 1,
|
|
Math.Min(ammoItemTemplate.Properties?.StackMaxRandom ?? 1, maxLimit)
|
|
);
|
|
}
|
|
|
|
public string? GetItemBaseType(string tpl, bool rootOnly = true)
|
|
{
|
|
var result = GetItem(tpl);
|
|
if (!result.Key)
|
|
// Not an item
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var currentItem = result.Value;
|
|
while (currentItem is not null)
|
|
{
|
|
if (currentItem.Type == "Node" && !rootOnly)
|
|
// Hit first base type
|
|
{
|
|
return currentItem.Id;
|
|
}
|
|
|
|
if (currentItem.Parent is null)
|
|
// No parent, reached root
|
|
{
|
|
return currentItem.Id;
|
|
}
|
|
|
|
// Get parent item and start loop again
|
|
currentItem = GetItem(tpl).Value;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
// Remove FiR status from passed in items
|
|
// Items to update FiR status of
|
|
public void RemoveSpawnedInSessionPropertyFromItems(List<Item> items)
|
|
{
|
|
foreach (var item in items)
|
|
{
|
|
if (item.Upd is not null)
|
|
{
|
|
item.Upd.SpawnedInSession = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a 2D grid of a container's item slots
|
|
/// </summary>
|
|
/// <param name="containerTpl">Tpl id of the container</param>
|
|
public int[][] GetContainerMapping(string containerTpl)
|
|
{
|
|
// Get template from db
|
|
var containerTemplate = GetItem(containerTpl).Value;
|
|
|
|
// Get height/width
|
|
var height = containerTemplate.Properties.Grids[0].Props.CellsV;
|
|
var width = containerTemplate.Properties.Grids[0].Props.CellsH;
|
|
|
|
return GetBlankContainerMap(height.Value, width.Value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a blank two-dimensional representation of a container
|
|
/// </summary>
|
|
/// <param name="containerH">Horizontal size of container</param>
|
|
/// <param name="containerY">Vertical size of container</param>
|
|
/// <returns>Two-dimensional representation of container</returns>
|
|
public int[][] GetBlankContainerMap(int containerY, int containerX)
|
|
{
|
|
//var x = new int[containerY][];
|
|
//for (int i = 0; i < containerY; i++)
|
|
//{
|
|
// x[i] = new int[containerH];
|
|
//}
|
|
|
|
//return x;
|
|
|
|
return Enumerable.Range(0, containerY)
|
|
.Select(i => new int[containerX])
|
|
.ToArray();
|
|
}
|
|
}
|
|
|
|
public class ItemSize
|
|
{
|
|
[JsonPropertyName("width")]
|
|
public int Width
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
[JsonPropertyName("height")]
|
|
public int Height
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
}
|