LuaCsForBarotraumaEP/Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CustomAbilities/CharacterAbilityUnlockApprenticeshipTalentTree.cs

#nullable enable

using System;
using Barotrauma.Extensions;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;

namespace Barotrauma.Abilities
{
    internal sealed class CharacterAbilityUnlockApprenticeshipTalentTree : CharacterAbility
    {
        public override bool AllowClientSimulation => false;

        public CharacterAbilityUnlockApprenticeshipTalentTree(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement) { }

        public override void InitializeAbility(bool addingFirstTime)
        {
            if (!addingFirstTime) { return; }

            // do not run client-side in multiplayer
            if (GameMain.NetworkMember is { IsClient: true }) { return; }

            JobPrefab? apprentice = CharacterAbilityApplyStatusEffectsToApprenticeship.GetApprenticeJob(Character, JobPrefab.Prefabs.ToImmutableHashSet());
            if (apprentice is null)
            {
                DebugConsole.ThrowError($"{nameof(CharacterAbilityUnlockApprenticeshipTalentTree)}: Could not find apprentice job for character {Character.Name}",
                    contentPackage: CharacterTalent.Prefab.ContentPackage);
                return;
            }

            if (!TalentTree.JobTalentTrees.TryGet(apprentice.Identifier, out TalentTree? talentTree)) { return; }

            var characters = Character.GetFriendlyCrew(Character);

            HashSet<ImmutableHashSet<Identifier>> talentsTrees = new HashSet<ImmutableHashSet<Identifier>>();
            foreach (TalentSubTree subTree in talentTree.TalentSubTrees)
            {
                if (subTree.Type != TalentTreeType.Specialization) { continue; }

                HashSet<Identifier> identifiers = new HashSet<Identifier>();
                foreach (TalentOption option in subTree.TalentOptionStages)
                {
                    foreach (Identifier identifier in option.TalentIdentifiers)
                    {
                        if (IsShowCaseTalent(identifier, option) || TalentTree.IsTalentLocked(identifier, characters)) { continue; }

                        identifiers.Add(identifier);
                    }

                    foreach (var (_, value) in option.ShowCaseTalents)
                    {
                        var ids = value.Where(i => !TalentTree.IsTalentLocked(i, characters)).ToImmutableHashSet();
                        if (ids.Count is 0) { continue; }

                        identifiers.Add(value.GetRandomUnsynced());
                    }
                }

                talentsTrees.Add(identifiers.ToImmutableHashSet());
            }

            ImmutableHashSet<Identifier>? selectedTalentTree = talentsTrees.GetRandomUnsynced();
            if (selectedTalentTree != null)
            {
                foreach (Identifier identifier in selectedTalentTree)
                {
                    if (Character.HasTalent(identifier)) { continue; }
                    Character.GiveTalent(identifier);
                    Character.Info.ResettableExtraTalents.Add(identifier);
                }
            }

            static bool IsShowCaseTalent(Identifier identifier, TalentOption option)
            {
                foreach (var (_, value) in option.ShowCaseTalents)
                {
                    if (value.Contains(identifier)) { return true; }
                }

                return false;
            }
        }

        protected override void ApplyEffect(AbilityObject abilityObject)
        {
            ApplyEffect();
        }
    }
}