diff --git a/Core/Generators/BotEquipmentModGenerator.cs b/Core/Generators/BotEquipmentModGenerator.cs new file mode 100644 index 00000000..44add471 --- /dev/null +++ b/Core/Generators/BotEquipmentModGenerator.cs @@ -0,0 +1,391 @@ +using Core.Models.Eft.Common; +using Core.Models.Eft.Common.Tables; +using Core.Models.Enums; +using Core.Models.Spt.Bots; +using Core.Models.Spt.Config; + +namespace Core.Generators; + +public class BotEquipmentModGenerator +{ + private BotConfig _botConfig; + + public BotEquipmentModGenerator() + { + } + + /// + /// Check mods are compatible and add to array + /// + /// Equipment item to add mods to + /// Mod list to choose from + /// parentid of item to add mod to + /// Template object of item to add mods to + /// The relevant blacklist from bot.json equipment dictionary + /// should this mod be forced to spawn + /// Item + compatible mods as an array + public Item GenerateModsForEquipment(List equipment, string parentId, TemplateItem parentTemplate, GenerateEquipmentProperties settings, + EquipmentFilterDetails specificBlacklist, bool shouldForceSpawn = false) + { + throw new NotImplementedException(); + } + + /// + /// Filter a bots plate pool based on its current level + /// + /// Bot equipment generation settings + /// Armor slot being filtered + /// Plates tpls to choose from + /// The armor items db template + /// Array of plate tpls to choose from + public FilterPlateModsForSlotByLevelResult FilterPlateModsForSlotByLevel(GenerateEquipmentProperties settings, string modSlot, + List existingPlateTplPool, TemplateItem armorItem) + { + throw new NotImplementedException(); + } + + /// + /// Add mods to a weapon using the provided mod pool + /// + /// Session id + /// Data used to generate the weapon + /// Weapon + mods array + public List GenerateModsForWeapon(string sessionId, GenerateWeaponRequest request) + { + throw new NotImplementedException(); + } + + /// + /// Should the provided bot have its stock chance values altered to 100% + /// + /// Slot to check + /// Bots equipment config/chance values + /// Mod being added to bots weapon + /// True if it should + public bool ShouldForceSubStockSlots(string modSlot, EquipmentFilters botEquipConfig, TemplateItem modToAddTemplate) + { + throw new NotImplementedException(); + } + + /// + /// Is this modslot a front or rear sight + /// + /// Slot to check + /// + /// true if it's a front/rear sight + public bool ModIsFrontOrRearSight(string modSlot, string tpl) + { + throw new NotImplementedException(); + } + + /// + /// Does the provided mod details show the mod can hold a scope + /// + /// e.g. mod_scope, mod_mount + /// Parent id of mod item + /// true if it can hold a scope + public bool ModSlotCanHoldScope(string modSlot, string ModsParentId) + { + throw new NotImplementedException(); + } + + /// + /// Set mod spawn chances to defined amount + /// + /// Chance dictionary to update + /// + /// + public void AdjustSlotSpawnChances(ModsChances modSpawnChances, List modSlotsToAdjust, double newChancePercent) + { + throw new NotImplementedException(); + } + + /// + /// Does the provided modSlot allow muzzle-related items + /// + /// Slot id to check + /// OPTIONAL: parent id of modslot being checked + /// True if modSlot can have muzzle-related items + public bool AodSlotCanHoldMuzzleDevices(string modSlot, string? modsParentId) + { + throw new NotImplementedException(); + } + + /// + /// Sort mod slots into an ordering that maximises chance of a successful weapon generation + /// + /// Array of mod slot strings to sort + /// The Tpl of the item with mod keys being sorted + /// Sorted array + public List SortModKeys(List unsortedSlotKeys, string itemTplWithKeysToSort) + { + throw new NotImplementedException(); + } + + /// + /// Get a Slot property for an item (chamber/cartridge/slot) + /// + /// e.g patron_in_weapon + /// item template + /// Slot item + public Slot GetModItemSlotFromDb(string modSlot, TemplateItem parentTemplate) + { + throw new NotImplementedException(); + } + + /// + /// Randomly choose if a mod should be spawned, 100% for required mods OR mod is ammo slot + /// + /// slot the item sits in from db + /// Name of slot the mod sits in + /// Chances for various mod spawns + /// Various config settings for generating this type of bot + /// ModSpawn.SPAWN when mod should be spawned, ModSpawn.DEFAULT_MOD when default mod should spawn, ModSpawn.SKIP when mod is skipped + public ModSpawn ShouldModBeSpawned(Slot itemSlot, string modSlotName, ModsChances modSpawnChances, EquipmentFilters botEquipConfig) + { + throw new NotImplementedException(); + } + + /// + /// Choose a mod to fit into the desired slot + /// + /// Data used to choose an appropriate mod with + /// itemHelper.getItem() result + public object? ChooseModToPutIntoSlot(ModToSpawnRequest request) // TODO: type fuckery: [boolean, ITemplateItem] | undefined + { + throw new NotImplementedException(); + } + + /// + /// Given the passed in array of magaizne tpls, look up the min size set in config and return only those that have that size or larger + /// + /// Request data + /// Pool of magazine tpls to filter + /// Filtered pool of magazine tpls + /// + public List GetFilterdMagazinePoolByCapacity(ModToSpawnRequest modSpawnRequest, List modPool) + { + throw new NotImplementedException(); + } + + /// + /// Choose a weapon mod tpl for a given slot from a pool of choices + /// Checks chosen tpl is compatible with all existing weapon items + /// + /// + /// Pool of mods that can be picked from + /// Slot the picked mod will have as a parent + /// How should chosen tpl be treated: DEFAULT_MOD/SPAWN/SKIP + /// Array of weapon items chosen item will be added to + /// Name of slot picked mod will be placed into + /// Chosen weapon details + public ChooseRandomCompatibleModResult GetCompatibleWeaponModTplForSlotFromPool(ModToSpawnRequest request, List modPool, Slot parentSlot, + ModSpawn choiceTypeEnum, List weapon, string modSlotName) + { + throw new NotImplementedException(); + } + + /// + /// + /// + /// Pool of item Tpls to choose from + /// How should the slot choice be handled - forced/normal etc + /// Weapon mods at current time + /// IChooseRandomCompatibleModResult + public ChooseRandomCompatibleModResult GetCompatibleModFromPool(List modPool, ModSpawn modSpawnType, List weapon) + { + throw new NotImplementedException(); + } + + public object CreateExhaustableArray(T itemsToAddToArray) // TODO: this wont likely be needed, reimplement for C# + { + throw new NotImplementedException(); + } + + /// + /// Get a list of mod tpls that are compatible with the current weapon + /// + /// + /// Tpls that are incompatible and should not be used + /// string array of compatible mod tpls with weapon + public List GetFilteredModPool(List modPool, List tplBlacklist) // TODO: tplBlacklist was Set + { + throw new NotImplementedException(); + } + + /// + /// Filter mod pool down based on various criteria: + /// Is slot flagged as randomisable + /// Is slot required + /// Is slot flagged as default mod only + /// + /// + /// Mods root parent (weapon/equipment) + /// Array of mod tpls + public List GetModPoolForSlot(ModToSpawnRequest request, TemplateItem weaponTemplate) + { + throw new NotImplementedException(); + } + + public List GetModPoolForDefaultSlot(ModToSpawnRequest request, TemplateItem weaponTemplate) + { + throw new NotImplementedException(); + } + + public object GetMatchingModFromPreset(ModToSpawnRequest request, TemplateItem weaponTemplate) // TODO: no return type given in node server + { + throw new NotImplementedException(); + } + + /// + /// Get default preset for weapon OR get specific weapon presets for edge cases (mp5/silenced dvl) + /// + /// Weapons db template + /// Tpl of the parent item + /// Default preset found + public Preset? GetMatchingPreset(TemplateItem weaponTemplate, string parentItemTpl) + { + throw new NotImplementedException(); + } + + /// + /// Temp fix to prevent certain combinations of weapons with mods that are known to be incompatible + /// + /// Array of items that make up a weapon + /// Mod to check compatibility with weapon + /// True if incompatible + public bool WeaponModComboIsIncompatible(List weapon, string modTpl) + { + throw new NotImplementedException(); + } + + /// + /// Create a mod item with provided parameters as properties + add upd property + /// + /// _id + /// _tpl + /// parentId + /// slotId + /// Used to add additional properties in the upd object + /// The bots role mod is being created for + /// Item object + public Item CreateModItem(string modId, string modTpl, string parentId, string modSlot, TemplateItem modTemplate, string botRole) + { + throw new NotImplementedException(); + } + + /// + /// Get a list of containers that hold ammo + /// e.g. mod_magazine / patron_in_weapon_000 + /// + /// string array + public List GetAmmoContainers() + { + throw new NotImplementedException(); + } + + /// + /// Get a random mod from an items compatible mods Filter array + /// + /// Default value to return if parentSlot Filter is empty + /// Item mod will go into, used to get compatible items + /// Slot to get mod to fill + /// Items to ensure picked mod is compatible with + /// Item tpl + public string? GetRandomModTplFromItemDb(string fallbackModTpl, Slot parentSlot, string modSlot, List items) + { + throw new NotImplementedException(); + } + + /// + /// Check if mod exists in db + is for a required slot + /// TODO: modToAdd type was [boolean, ITemplateItem] in node + /// + /// Db template of mod to check + /// Slot object the item will be placed as child into + /// Slot the mod will fill + /// Db template of the mods being added + /// Bots wildspawntype (assault/pmcBot/exUsec etc) + /// True if valid for slot + public bool IsModValidForSlot(object modToAdd, Slot slotAddedToTemplate, string modSlot, TemplateItem parentTemplate, string botRole) + { + throw new NotImplementedException(); + } + + /// + /// Find mod tpls of a provided type and add to modPool + /// + /// Slot to look up and add we are adding tpls for (e.g mod_scope) + /// db object for modItem we get compatible mods from + /// Pool of mods we are adding to + /// A blacklist of items that cannot be picked + public void AddCompatibleModsForProvidedMod(string desiredSlotName, TemplateItem modTemplate, Dictionary>> modPool, + EquipmentFilterDetails botEquipBlacklist) + { + throw new NotImplementedException(); + } + + /// + /// Get the possible items that fit a slot + /// + /// item tpl to get compatible items for + /// Slot item should fit in + /// Equipment that should not be picked + /// Array of compatible items for that slot + public List GetDynamicModPool(string parentItemId, string modSlot, EquipmentFilterDetails botEquipBlacklist) + { + throw new NotImplementedException(); + } + + /// + /// Take a list of tpls and filter out blacklisted values using itemFilterService + botEquipmentBlacklist + /// + /// Base mods to filter + /// Equipment blacklist + /// Slot mods belong to + /// Filtered array of mod tpls + public List FilterModsByBlacklist(List allowedMods, EquipmentFilterDetails botEquipBlacklist, string modSlot) + { + throw new NotImplementedException(); + } + + /// + /// With the shotgun revolver (60db29ce99594040e04c4a27) 12.12 introduced CylinderMagazines. + /// Those magazines (e.g. 60dc519adf4c47305f6d410d) have a "Cartridges" entry with a _max_count=0. + /// Ammo is not put into the magazine directly but assigned to the magazine's slots: The "camora_xxx" slots. + /// This function is a helper called by generateModsForItem for mods with parent type "CylinderMagazine" + /// + /// The items where the CylinderMagazine's camora are appended to + /// ModPool which should include available cartridges + /// The CylinderMagazine's UID + /// The CylinderMagazine's template + public void FillCamora(List items, Dictionary>> modPool, string cylinderMagParentId, + TemplateItem cylinderMagTemplate) + { + throw new NotImplementedException(); + } + + /// + /// Take a record of camoras and merge the compatible shells into one array + /// + /// Dictionary of camoras we want to merge into one array + /// String array of shells for multiple camora sources + public List MergeCamoraPools(Dictionary> camorasWithShells) + { + throw new NotImplementedException(); + } + + /// + /// Filter out non-whitelisted weapon scopes + /// Controlled by bot.json weaponSightWhitelist + /// e.g. filter out rifle scopes from SMGs + /// + /// Weapon scopes will be added to + /// Full scope pool + /// Whitelist of scope types by weapon base type + /// Array of scope tpls that have been filtered to just ones allowed for that weapon type + public List FilterSightsByWeaponType(Item weapon, List scopes, Dictionary> botWeaponSightWhitelist) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Generators/BotLevelGenerator.cs b/Core/Generators/BotLevelGenerator.cs new file mode 100644 index 00000000..1741311d --- /dev/null +++ b/Core/Generators/BotLevelGenerator.cs @@ -0,0 +1,43 @@ +using Core.Models.Common; +using Core.Models.Eft.Bot; +using Core.Models.Eft.Common.Tables; +using Core.Models.Spt.Bots; + +namespace Core.Generators; + +public class BotLevelGenerator +{ + public BotLevelGenerator() + { + + } + + /// + /// Return a randomised bot level and exp value + /// + /// Min and max of level for bot + /// Details to help generate a bot + /// Bot the level is being generated for + /// IRandomisedBotLevelResult object + public RandomisedBotLevelResult GenerateBotLevel(MinMax levelDetails, BotGenerationDetails botGenerationDetails, BotBase bot) + { + throw new NotImplementedException(); + } + + public int ChooseBotLevel(int min, int max, int shift, int number) + { + throw new NotImplementedException(); + } + + /// + /// Return the min and max bot level based on a relative delta from the PMC level + /// + /// Details to help generate a bot + /// + /// Max level allowed + /// A MinMax of the lowest and highest level to generate the bots + public MinMax GetRelativeBotLevelRange(BotGenerationDetails botGenerationDetails, MinMax levelDetails, int maxAvailableLevel) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Generators/BotLootGenerator.cs b/Core/Generators/BotLootGenerator.cs new file mode 100644 index 00000000..074a18fd --- /dev/null +++ b/Core/Generators/BotLootGenerator.cs @@ -0,0 +1,202 @@ +using Core.Models.Eft.Common.Tables; +using Core.Models.Enums; +using Core.Models.Spt.Bots; +using Core.Models.Spt.Config; + +namespace Core.Generators; + +public class BotLootGenerator +{ + private BotConfig _botConfig; + private PmcConfig _pmcConfig; + + public BotLootGenerator() + { + + } + + /// + /// + /// + /// + /// + /// + public ItemSpawnLimitSettings GetItemSpawnLimitsForBot(string botRole) + { + throw new NotImplementedException(); + } + + /// + /// Add loot to bots containers + /// + /// Session id + /// Base json db file for the bot having its loot generated + /// Will bot be a pmc + /// Role of bot, e.g. asssult + /// Inventory to add loot to + /// Level of bot + public void GenerateLoot(string sessionId, BotType botJsonTemplate, bool isPmc, string botRole, BotBaseInventory botInventory, int botLevel) + { + throw new NotImplementedException(); + } + + /// + /// Gets the rouble cost total for loot in a bots backpack by the bots levl + /// Will return 0 for non PMCs + /// + /// Bots level + /// Is the bot a PMC + /// int + public int GetBackpackRoubleTotalByLevel(int botLevel, bool isPmc) + { + throw new NotImplementedException(); + } + + /// + /// + /// + /// + /// + /// + public List GetAvailableContainersBotCanStoreItemsIn(BotBaseInventory botInventory) + { + throw new NotImplementedException(); + } + + /// + /// Force healing items onto bot to ensure they can heal in-raid + /// + /// Inventory to add items to + /// Role of bot (pmcBEAR/pmcUSEC) + public void AddForcedMedicalItemsToPmcSecure(BotBaseInventory botInventory, string botRole) + { + throw new NotImplementedException(); + } + + /// + /// Take random items from a pool and add to an inventory until totalItemCount or totalValueLimit or space limit is reached + /// + /// Pool of items to pick from with weight + /// What equipment slot will the loot items be added to + /// Max count of items to add + /// Bot inventory loot will be added to + /// Role of the bot loot is being generated for (assault/pmcbot) + /// Item spawn limits the bot must adhere to + /// + /// Total value of loot allowed in roubles + /// Is bot being generated for a pmc + /// + public void AddLootFromPool(Dictionary pool, List equipmentSlots, int totalItemCount, BotBaseInventory inventoryToAddItemsTo, // TODO: type for containersIdFull was Set + string botRole, ItemSpawnLimitSettings? itemSpawnLimits, List containersIdFull, int totalValueLimitRub = 0, bool isPmc = false) + { + throw new NotImplementedException(); + } + + /// + /// + /// + /// + /// + /// + public List> CrateWalletLoot(string walletId) + { + throw new NotImplementedException(); + } + + /// + /// Some items need child items to function, add them to the itemToAddChildrenTo array + /// + /// Db template of item to check + /// Item to add children to + /// Is the item being generated for a pmc (affects money/ammo stack sizes) + /// role bot has that owns item + public void AddRequiredChildItemsToParent(TemplateItem itemToAddTemplate, List itemToAddChildrenTo, bool isPmc, string botRole) + { + throw new NotImplementedException(); + } + + /// + /// Add generated weapons to inventory as loot + /// + /// + /// inventory to add preset to + /// slot to place the preset in (backpack) + /// bots template, assault.json + /// chances for mods to spawn on weapon + /// bots role .e.g. pmcBot + /// are we generating for a pmc + /// + /// + public void AddLooseWeaponsToInventorySlot(string sessionId, BotBaseInventory botInventory, string equipmentSlot, BotBaseInventory templateInventory, // TODO: type for containersIdFull was Set + ModsChances modsChances, string botRole, bool isPmc, int botLevel, List? containersIdFull) + { + throw new NotImplementedException(); + } + + /// + /// Hydrate item limit array to contain items that have a limit for a specific bot type + /// All values are set to 0 + /// + /// Role the bot has + /// + public void InitItemLimitArray(string botRole, Dictionary limitCount) + { + throw new NotImplementedException(); + } + + /// + /// Check if an item has reached its bot-specific spawn limit + /// + /// Item we check to see if its reached spawn limit + /// Bot type + /// + /// true if item has reached spawn limit + public bool ItemHasReachedSpawnLimit(TemplateItem itemTemplate, string botRole, ItemSpawnLimitSettings itemSpawnLimits) + { + throw new NotImplementedException(); + } + + /// + /// Randomise the stack size of a money object, uses different values for pmc or scavs + /// + /// Role bot has that has money stack + /// item details from db + /// Money item to randomise + public void RandomiseMoneyStackSize(string botRole, TemplateItem itemTemplate, Item moneyItem) + { + throw new NotImplementedException(); + } + + /// + /// Randomise the size of an ammo stack + /// + /// Is ammo on a PMC bot + /// item details from db + /// Ammo item to randomise + public void RandomiseAmmoStackSize(bool isPmc, TemplateItem itemTemplate, Item ammoItem) + { + throw new NotImplementedException(); + } + + /// + /// Get spawn limits for a specific bot type from bot.json config + /// If no limit found for a non pmc bot, fall back to defaults + /// + /// what role does the bot have + /// Dictionary of tplIds and limit + public Dictionary GetItemSpawnLimitsForBotType(string botRole) + { + throw new NotImplementedException(); + } + + /// + /// Get the parentId or tplId of item inside spawnLimits object if it exists + /// + /// item we want to look for in spawn limits + /// Limits to check for item + /// id as string, otherwise undefined + public string? GetMatchingIdFromSpawnLimits(TemplateItem itemTemplate, Dictionary spawnLimits) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Generators/WeaponGen/BotInventoryGenerator.cs b/Core/Generators/WeaponGen/BotInventoryGenerator.cs new file mode 100644 index 00000000..7884a6de --- /dev/null +++ b/Core/Generators/WeaponGen/BotInventoryGenerator.cs @@ -0,0 +1,145 @@ +using Core.Models.Eft.Common.Tables; +using Core.Models.Eft.Match; +using Core.Models.Spt.Bots; +using Core.Models.Spt.Config; +using Equipment = Core.Models.Eft.Common.Tables.Equipment; + +namespace Core.Generators.WeaponGen; + +public class BotInventoryGenerator +{ + private BotConfig _botConfig; + + public BotInventoryGenerator() + { + + } + + /// + /// Add equipment/weapons/loot to bot + /// + /// Session id + /// Base json db file for the bot having its loot generated + /// Role bot has (assault/pmcBot) + /// Is bot being converted into a pmc + /// Level of bot being generated + /// Game version for bot, only really applies for PMCs + /// PmcInventory object with equipment/weapons/loot + public BotBaseInventory generateInventory(string sessionId, BotType botJsonTemplate, string botRole, bool isPmc, int botLevel, string chosenGameVersion) + { + throw new NotImplementedException(); + } + + /// + /// Create a pmcInventory object with all the base/generic items needed + /// + /// PmcInventory object + public BotBaseInventory GenerateInventoryBase() + { + throw new NotImplementedException(); + } + + /// + /// Add equipment to a bot + /// + /// Session id + /// bot/x.json data from db + /// Chances items will be added to bot + /// Role bot has (assault/pmcBot) + /// Inventory to add equipment to + /// Level of bot + /// Game version for bot, only really applies for PMCs + /// RadiConfig + public void GenerateAndAddEquipmentToBot(string sessionId, BotBaseInventory templateInventory, Chances wornItemChances, string botRole, + BotBaseInventory botInventory, int botLevel, string chosenGameVersion, GetRaidConfigurationRequestData raidConfig) + { + throw new NotImplementedException(); + } + + /// + /// Remove non-armored rigs from parameter data + /// + /// Equpiment to filter TacticalVest of + /// Role of bot vests are being filtered for + public void FilterRigsToThoseWithProtection(Equipment templateEquipment, string botRole) + { + throw new NotImplementedException(); + } + + /// + /// Remove armored rigs from parameter data + /// + /// Equpiment to filter TacticalVest of + /// Role of bot vests are being filtered for + /// Should the function return all rigs when 0 unarmored are found + public void FilterRigsTothoseWithoutProtection(Equipment templateEquipment, string botRole, bool allowEmptyRequest = false) + { + throw new NotImplementedException(); + } + + /// + /// Add a piece of equipment with mods to inventory from the provided pools + /// + /// Values to adjust how item is chosen and added to bot + /// true when item added + public bool GenerateEquipment(GenerateEquipmentProperties settings) + { + throw new NotImplementedException(); + } + + /// + /// Get all possible mods for item and filter down based on equipment blacklist from bot.json config + /// + /// Item mod pool is being retrieved and filtered + /// Blacklist to filter mod pool with + /// Filtered pool of mods + public Dictionary> GetFilteredDynamicModsForItem(string itemTpl, Dictionary> equipmentBlacklist) + { + throw new NotImplementedException(); + } + + /// + /// Work out what weapons bot should have equipped and add them to bot inventory + /// + /// bot/x.json data from db + /// Chances bot can have equipment equipped + /// Session id + /// Inventory to add weapons to + /// assault/pmcBot/bossTagilla etc + /// Is the bot being generated as a pmc + /// Limits for items the bot can have + /// level of bot having weapon generated + public void GenerateAndAddWeaponsToBot(BotBaseInventory templateInventory, Chances equipmentChances, string sessionId, BotBaseInventory botInventory, string botRole, + bool isPmc, Generation itemGenerationLimitsMinMax, int botLevel) + { + throw new NotImplementedException(); + } + + /// + /// Calculate if the bot should have weapons in Primary/Secondary/Holster slots + /// + /// Chances bot has certain equipment + /// What slots bot should have weapons generated for + public object GetDesiredWeaponsForBot(Chances equipmentChances) // TODO: Type fuckery { slot: EquipmentSlots; shouldSpawn: boolean }[] + { + throw new NotImplementedException(); + } + + /// + /// Add weapon + spare mags/ammo to bots inventory + /// + /// Session id + /// Weapon slot being generated + /// bot/x.json data from db + /// Inventory to add weapon+mags/ammo to + /// Chances bot can have equipment equipped + /// assault/pmcBot/bossTagilla etc + /// Is the bot being generated as a pmc + /// + /// + public void AddWeaponAndMagazineToInventory(string sessionId, object weaponSlot, BotBaseInventory templateInventory, BotBaseInventory botInventory, Chances equipmentChances, string botRole, + bool isPmc, Generation itemGenerationWeights, int botLevel) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Generators/WeaponGen/Implementations/InventoryMagGen.cs b/Core/Generators/WeaponGen/Implementations/InventoryMagGen.cs new file mode 100644 index 00000000..5866e62b --- /dev/null +++ b/Core/Generators/WeaponGen/Implementations/InventoryMagGen.cs @@ -0,0 +1,42 @@ +using Core.Models.Eft.Common.Tables; + +namespace Core.Generators.WeaponGen.Implementations; + +public class InventoryMagGen +{ + private GenerationData _magCounts; + private TemplateItem _magazineTemplate; + private TemplateItem _weaponTemplate; + private TemplateItem _ammoTemplate; + private BotBaseInventory _pmcInventory; + + public InventoryMagGen() + { + + } + + public GenerationData GetMagCount() + { + return _magCounts; + } + + public TemplateItem GetMagazineTemplate() + { + return _magazineTemplate; + } + + public TemplateItem GetWeaponTemplate() + { + return _weaponTemplate; + } + + public TemplateItem GetAmmoTemplate() + { + return _ammoTemplate; + } + + public BotBaseInventory GetPmcInventory() + { + return _pmcInventory; + } +} \ No newline at end of file diff --git a/Core/Models/Eft/Bot/RandomisedBotLevelResult.cs b/Core/Models/Eft/Bot/RandomisedBotLevelResult.cs new file mode 100644 index 00000000..b10697b0 --- /dev/null +++ b/Core/Models/Eft/Bot/RandomisedBotLevelResult.cs @@ -0,0 +1,12 @@ +using System.Text.Json.Serialization; + +namespace Core.Models.Eft.Bot; + +public class RandomisedBotLevelResult +{ + [JsonPropertyName("level")] + public int Level { get; set; } + + [JsonPropertyName("exp")] + public int Exp { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Enums/EquipmentSlots.cs b/Core/Models/Enums/EquipmentSlots.cs new file mode 100644 index 00000000..8d736c11 --- /dev/null +++ b/Core/Models/Enums/EquipmentSlots.cs @@ -0,0 +1,19 @@ +namespace Core.Models.Enums; + +public enum EquipmentSlots +{ + HEADWEAR, + EARPIECE, + FACE_COVER, + ARMOR_VEST, + EYEWEAR, + ARM_BAND, + TACTICAL_VEST, + POCKETS, + BACKPACK, + SECURED_CONTAINER, + FIRST_PRIMARY_WEAPON, + SECOND_PRIMARY_WEAPON, + HOLSTER, + SCABBARD +} \ No newline at end of file