AutoItemPlacer.cs

using Barotrauma.Extensions;
using Barotrauma.Items.Components;
using System;
using System.Collections.Generic;
using System.Linq;

namespace Barotrauma
{
    static class AutoItemPlacer
    {
        public static bool OutputDebugInfo = false;

        public static void SpawnItems(Identifier? startItemSet = null)
        {
            if (GameMain.NetworkMember != null && !GameMain.NetworkMember.IsServer) { return; }

            //player has more than one sub = we must have given the start items already
            bool startItemsGiven = GameMain.GameSession?.OwnedSubmarines != null && GameMain.GameSession.OwnedSubmarines.Count > 1;
            if (!startItemsGiven)
            {
                for (int i = 0; i < Submarine.MainSubs.Length; i++)
                {
                    var sub = Submarine.MainSubs[i];
                    if (sub == null || sub.Info.InitialSuppliesSpawned || sub.Info.IsManuallyOutfitted || !sub.Info.IsPlayer) { continue; }
                    //1st pass: items defined in the start item set, only spawned in the main sub (not drones/shuttles or other linked subs)
                    SpawnStartItems(sub, startItemSet);
                    //2nd pass: items defined using preferred containers, spawned in the main sub and all the linked subs (drones, shuttles etc)
                    var subs = sub.GetConnectedSubs().Where(s => s.TeamID == sub.TeamID);
                    CreateAndPlace(subs);
                    subs.ForEach(s => s.Info.InitialSuppliesSpawned = true);
                    sub.CheckFuel();
                }
            }

            //spawn items in wrecks, beacon stations and pirate subs
            foreach (var sub in Submarine.Loaded)
            {
                if (sub.Info.Type is SubmarineType.Player or SubmarineType.Outpost or SubmarineType.OutpostModule) { continue; }
                if (sub.Info.InitialSuppliesSpawned) { continue; }
                CreateAndPlace(sub.ToEnumerable());
                sub.Info.InitialSuppliesSpawned = true;
            }

            if (Level.Loaded?.StartOutpost != null && Level.Loaded.Type == LevelData.LevelType.Outpost)
            {
                var sub = Level.Loaded.StartOutpost;
                if (!sub.Info.InitialSuppliesSpawned)
                {
                    Rand.SetSyncedSeed(ToolBox.StringToInt(sub.Info.Name));
                    CreateAndPlace(sub.ToEnumerable());
                    sub.Info.InitialSuppliesSpawned = true;
                }
            }
        }

        /// <summary>
        /// Spawns loot in the specified container. 
        /// </summary>
        /// <param name="skipItemProbability">Probability for an individual loot item to be skipped. I.e. a value of 1.0 means nothing spawns, 0.5 means there's about 50% of the normal amount of loot.</param>
        public static void RegenerateLoot(Submarine sub, ItemContainer regeneratedContainer, float skipItemProbability = 0.0f)
        {
            CreateAndPlace(sub.ToEnumerable(), regeneratedContainer: regeneratedContainer, skipItemProbability);
        }

        public static Identifier DefaultStartItemSet = new Identifier("normal");

        /// <summary>
        /// Spawns the items defined in the start item set in the specified sub.
        /// </summary>
        private static void SpawnStartItems(Submarine sub, Identifier? startItemSet)
        {
            Identifier setIdentifier = startItemSet ?? DefaultStartItemSet;
            if (!StartItemSet.Sets.TryGet(setIdentifier, out StartItemSet itemSet))
            {
                DebugConsole.AddWarning($"Couldn't find a start item set matching the identifier \"{setIdentifier}\"!");
                if (!StartItemSet.Sets.TryGet(DefaultStartItemSet, out StartItemSet defaultSet))
                {
                    DebugConsole.ThrowError($"Couldn't find the default start item set \"{DefaultStartItemSet}\"!");
                    return;
                }
                itemSet = defaultSet;
            }
            WayPoint wp = WayPoint.GetRandom(SpawnType.Cargo, null, sub);
            ISpatialEntity initialSpawnPos;
            if (wp?.CurrentHull == null)
            {
                var spawnHull = Hull.HullList.Where(h => h.Submarine == sub && !h.IsWetRoom).GetRandomUnsynced();
                if (spawnHull == null)
                {
                    DebugConsole.AddWarning($"Failed to spawn start items in the sub. No cargo waypoint or dry hulls found to spawn the items in.");
                    return;
                }
                initialSpawnPos = spawnHull;
            }
            else
            {
                initialSpawnPos = wp;
            }
            var newItems = new List<Item>();
            foreach (var startItem in itemSet.Items)
            {
                if (!ItemPrefab.Prefabs.TryGet(startItem.Item, out ItemPrefab itemPrefab))
                {
                    DebugConsole.AddWarning($"Cannot find a start item with with the identifier \"{startItem.Item}\"");
                    continue;
                }
                if (startItem.MultiPlayerOnly && GameMain.GameSession?.GameMode is { IsSinglePlayer: true }) { continue; }
                for (int i = 0; i < startItem.Amount; i++)
                {
                    var item = new Item(itemPrefab, initialSpawnPos.Position, sub, callOnItemLoaded: false);
                    // Is this necessary?
                    foreach (WifiComponent wifiComponent in item.GetComponents<WifiComponent>())
                    {
                        wifiComponent.TeamID = sub.TeamID;
                    }
                    newItems.Add(item);
                }
            }
            var cargoContainers = new List<ItemContainer>();
            foreach (var item in newItems)
            {
#if SERVER
                Entity.Spawner.CreateNetworkEvent(new EntitySpawner.SpawnEntity(item));
#endif
                foreach (ItemComponent ic in item.Components)
                {
                    ic.OnItemLoaded();
                }
                var container = sub.FindContainerFor(item, onlyPrimary: true);
                if (container == null)
                {
                    var cargoContainer = CargoManager.GetOrCreateCargoContainerFor(item.Prefab, initialSpawnPos, ref cargoContainers);
                    container = cargoContainer?.Item;
                }
                container?.OwnInventory.TryPutItem(item, user: null);
            }
        }

        private static void CreateAndPlace(IEnumerable<Submarine> subs, ItemContainer regeneratedContainer = null, float skipItemProbability = 0.0f)
        {
            if (GameMain.NetworkMember != null && GameMain.NetworkMember.IsClient)
            {
                DebugConsole.ThrowError("Clients are not allowed to use AutoItemPlacer.\n" + Environment.StackTrace.CleanupStackTrace());
                return;
            }

            List<Item> itemsToSpawn = new List<Item>(100);

            int itemCountApprox = MapEntityPrefab.List.Count() / 3;
            var containers = new List<ItemContainer>(70 + 30 * subs.Count());
            var prefabsItemsCanSpawnIn = new List<ItemPrefab>(itemCountApprox / 3);
            var singlePrefabs = new List<ItemPrefab>(itemCountApprox);
            var removals = new List<ItemPrefab>();

            // generate loot only for a specific container if defined
            if (regeneratedContainer != null)
            {
                containers.Add(regeneratedContainer);
            }
            else
            {
                foreach (Item item in Item.ItemList)
                {
                    if (!subs.Contains(item.Submarine)) { continue; }
                    if (item.GetRootInventoryOwner() is Character) { continue; }
                    if (item.NonInteractable) { continue; }
                    containers.AddRange(item.GetComponents<ItemContainer>());
                }
                containers.Shuffle(Rand.RandSync.ServerAndClient);
            }

            var itemPrefabs = ItemPrefab.Prefabs.OrderBy(p => p.UintIdentifier);
            foreach (ItemPrefab ip in itemPrefabs)
            {
                if (ip.PreferredContainers.None()) { continue; }
                if (ip.ConfigElement.Elements().Any(e => string.Equals(e.Name.ToString(), typeof(ItemContainer).Name.ToString(), StringComparison.OrdinalIgnoreCase)) && itemPrefabs.Any(ip2 => CanSpawnIn(ip2, ip)))
                {
                    prefabsItemsCanSpawnIn.Add(ip);
                }
                else
                {
                    singlePrefabs.Add(ip);
                }
            }

            bool CanSpawnIn(ItemPrefab item, ItemPrefab container)
            {
                foreach (var preferredContainer in item.PreferredContainers)
                {
                    if (ItemPrefab.IsContainerPreferred(preferredContainer.Primary, container.Identifier.ToEnumerable().Union(container.Tags))) { return true; }
                }
                return false;
            }

            var validContainers = new Dictionary<ItemContainer, PreferredContainer>();
            prefabsItemsCanSpawnIn.Shuffle(Rand.RandSync.ServerAndClient);
            // Spawn items that other items can spawn in first so we can fill them up with items if needed (oxygen tanks inside the spawned diving masks, etc)
            for (int i = 0; i < prefabsItemsCanSpawnIn.Count; i++)
            {
                var itemPrefab = prefabsItemsCanSpawnIn[i];
                if (itemPrefab == null) { continue; }
                SpawnItems(itemPrefab);
            }

            // Spawn items that nothing can spawn in last
            singlePrefabs.Shuffle(Rand.RandSync.ServerAndClient);
            singlePrefabs.ForEach(i => SpawnItems(i));

            if (OutputDebugInfo)
            {
                var subNames = subs.Select(s => s.Info.Name).ToList();
                DebugConsole.NewMessage($"Automatically placed items in { string.Join(", ", subNames) }:");
                foreach (string itemName in itemsToSpawn.Select(it => it.Name).Distinct())
                {
                    DebugConsole.NewMessage(" - " + itemName + " x" + itemsToSpawn.Count(it => it.Name == itemName));
                }
            }

            if (GameMain.GameSession?.Level != null &&
                GameMain.GameSession.Level.Type == LevelData.LevelType.Outpost &&
                GameMain.GameSession.StartLocation?.TakenItems != null)
            {
                foreach (Location.TakenItem takenItem in GameMain.GameSession.StartLocation.TakenItems)
                {
                    var matchingItem = itemsToSpawn.Find(it => takenItem.Matches(it));
                    if (matchingItem == null) { continue; }
                    if (OutputDebugInfo)
                    {
                        DebugConsole.NewMessage($"Removing the stolen item: {matchingItem.Prefab.Identifier} ({matchingItem.ID})");
                    }
                    var containedItems = itemsToSpawn.FindAll(it => it.ParentInventory?.Owner == matchingItem);
                    matchingItem.Remove();
                    itemsToSpawn.Remove(matchingItem);
                    foreach (Item containedItem in containedItems)
                    {
                        containedItem.Remove();
                        itemsToSpawn.Remove(containedItem);
                    }
                }
            }
            foreach (Item item in itemsToSpawn)
            {
#if SERVER
                Entity.Spawner.CreateNetworkEvent(new EntitySpawner.SpawnEntity(item));
#endif
                foreach (ItemComponent ic in item.Components)
                {
                    ic.OnItemLoaded();
                }
            }

            void SpawnItems(ItemPrefab itemPrefab, float skipItemProbability = 0.0f)
            {
                if (Rand.Range(0.0f, 1.0f, Rand.RandSync.ServerAndClient) < skipItemProbability) { return; }
                if (itemPrefab == null)
                {
                    string errorMsg = "Error in AutoItemPlacer.SpawnItems - itemPrefab was null.\n" + Environment.StackTrace.CleanupStackTrace();
                    DebugConsole.ThrowError(errorMsg);
                    GameAnalyticsManager.AddErrorEventOnce("AutoItemPlacer.SpawnItems:ItemNull", GameAnalyticsManager.ErrorSeverity.Error, errorMsg);
                    return;
                }
                bool isCampaign = GameMain.GameSession?.GameMode is CampaignMode;
                float levelDifficulty = Level.Loaded?.Difficulty ?? 0.0f;
                foreach (PreferredContainer preferredContainer in itemPrefab.PreferredContainers)
                {
                    if (preferredContainer.CampaignOnly && !isCampaign) { continue; }
                    if (preferredContainer.NotCampaign && isCampaign) { continue; }
                    if (levelDifficulty < preferredContainer.MinLevelDifficulty || levelDifficulty > preferredContainer.MaxLevelDifficulty) { continue; }
                    if (preferredContainer.SpawnProbability <= 0.0f || preferredContainer.MaxAmount <= 0 && preferredContainer.Amount <= 0) { continue; }
                    validContainers = GetValidContainers(preferredContainer, containers, validContainers, primary: true);
                    if (validContainers.None())
                    {
                        validContainers = GetValidContainers(preferredContainer, containers, validContainers, primary: false);
                    }
                    foreach (var validContainer in validContainers)
                    {
                        var newItems = CreateItems(itemPrefab, containers, validContainer);
                        if (newItems.Any())
                        {
                            itemsToSpawn.AddRange(newItems);
                        }
                    }
                }
            }
        }

        private static Dictionary<ItemContainer, PreferredContainer> GetValidContainers(PreferredContainer preferredContainer, IEnumerable<ItemContainer> allContainers, Dictionary<ItemContainer, PreferredContainer> validContainers, bool primary)
        {
            validContainers.Clear();
            foreach (ItemContainer container in allContainers)
            {
                if (!container.AutoFill) { continue; }
                if (primary)
                {
                    if (!ItemPrefab.IsContainerPreferred(preferredContainer.Primary, container)) { continue; }
                }
                else
                {
                    if (!ItemPrefab.IsContainerPreferred(preferredContainer.Secondary, container)) { continue; }
                }
                if (!validContainers.ContainsKey(container))
                {
                    validContainers.Add(container, preferredContainer);
                }
            }
            return validContainers;
        }

        private static List<Item> CreateItems(ItemPrefab itemPrefab, List<ItemContainer> containers, KeyValuePair<ItemContainer, PreferredContainer> validContainer)
        {
            List<Item> newItems = new List<Item>();
            if (Rand.Value(Rand.RandSync.ServerAndClient) > validContainer.Value.SpawnProbability) { return newItems; }
            // Don't add dangerously reactive materials in thalamus wrecks 
            if (validContainer.Key.Item.Submarine.WreckAI != null && itemPrefab.Tags.Contains("explodesinwater"))
            {
                return newItems;
            }
            int amount = validContainer.Value.Amount;
            if (amount == 0)
            {
                amount = Rand.Range(validContainer.Value.MinAmount, validContainer.Value.MaxAmount + 1, Rand.RandSync.ServerAndClient);
            }
            for (int i = 0; i < amount; i++)
            {
                if (validContainer.Key.Inventory.IsFull(takeStacksIntoAccount: true))
                {
                    containers.Remove(validContainer.Key);
                    break;
                }
                var existingItem = validContainer.Key.Inventory.AllItems.FirstOrDefault(it => it.Prefab == itemPrefab);
                int quality = existingItem?.Quality ?? Quality.GetSpawnedItemQuality(validContainer.Key.Item.Submarine, Level.Loaded, Rand.RandSync.ServerAndClient);
                if (!validContainer.Key.Inventory.CanBePut(itemPrefab, quality: quality)) { break; }
                var item = new Item(itemPrefab, validContainer.Key.Item.Position, validContainer.Key.Item.Submarine, callOnItemLoaded: false)
                {
                    SpawnedInCurrentOutpost = validContainer.Key.Item.SpawnedInCurrentOutpost,
                    AllowStealing = validContainer.Key.Item.AllowStealing || validContainer.Key.Item.Prefab.AllowStealingContainedItems,
                    Quality = quality,
                    OriginalModuleIndex = validContainer.Key.Item.OriginalModuleIndex,
                    OriginalContainerIndex = 
                        Item.ItemList.Where(it => it.Submarine == validContainer.Key.Item.Submarine && it.OriginalModuleIndex == validContainer.Key.Item.OriginalModuleIndex).ToList().IndexOf(validContainer.Key.Item)
                };
                foreach (WifiComponent wifiComponent in item.GetComponents<WifiComponent>())
                {
                    wifiComponent.TeamID = validContainer.Key.Item.Submarine.TeamID;
                }
                newItems.Add(item);
                validContainer.Key.Inventory.TryPutItem(item, null, createNetworkEvent: false);
                containers.AddRange(item.GetComponents<ItemContainer>());
            }
            return newItems;
        }
    }
}