Build 0.20.0.0

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/EnemyAIController.cs

@@ -442,6 +442,7 @@ namespace Barotrauma
             base.Update(deltaTime);
             UpdateTriggers(deltaTime);
             Character.ClearInputs();
+            Reverse = false;
 
             bool ignorePlatforms = Character.AnimController.TargetMovement.Y < -0.5f && (-Character.AnimController.TargetMovement.Y > Math.Abs(Character.AnimController.TargetMovement.X));
             if (steeringManager == insideSteering)
@@ -804,10 +805,6 @@ namespace Barotrauma
                                 Reverse = true;
                                 run = true;
                             }
-                            else
-                            {
-                                Reverse = false;
-                            }
                             SteeringManager.SteeringManual(deltaTime, dir * 0.2f);
                         }
                         else
@@ -1490,40 +1487,26 @@ namespace Barotrauma
                         canAttack = angle < MathHelper.ToRadians(AttackLimb.attack.RequiredAngle);
                         if (canAttack && AttackLimb.attack.AvoidFriendlyFire)
                         {
-                            float minDistance = MathUtils.Pow(ConvertUnits.ToDisplayUnits(Character.AnimController.Collider.GetMaxExtent() * 3), 2);
-                            bool IsFarEnough(Character other) => Vector2.DistanceSquared(Character.WorldPosition, other.WorldPosition) > minDistance;
-                            if (SwarmBehavior != null)
+                            canAttack = !IsBlocked(Character.GetRelativeSimPosition(SelectedAiTarget.Entity));
+                            bool IsBlocked(Vector2 targetPosition)
                             {
-                                canAttack = SwarmBehavior.Members.All(c => c == Character || IsFarEnough(c));
-                            }
-                            else
-                            {
-                                canAttack = Character.CharacterList.All(c => c == Character || !Character.IsFriendly(c) || IsFarEnough(c));
-                            }
-                            if (canAttack)
-                            {
-                                canAttack = !IsBlocked(attackSimPos) && !IsBlocked(AttackLimb.SimPosition + forward * ConvertUnits.ToSimUnits(AttackLimb.attack.Range));
-
-                                bool IsBlocked(Vector2 targetPosition)
+                                foreach (var body in Submarine.PickBodies(AttackLimb.SimPosition, targetPosition, myBodies, Physics.CollisionCharacter))
                                 {
-                                    foreach (var body in Submarine.PickBodies(AttackLimb.SimPosition, targetPosition, myBodies, Physics.CollisionCharacter))
+                                    Character hitTarget = null;
+                                    if (body.UserData is Character c)
                                     {
-                                        Character hitTarget = null;
-                                        if (body.UserData is Character c)
-                                        {
-                                            hitTarget = c;
-                                        }
-                                        else if (body.UserData is Limb limb)
-                                        {
-                                            hitTarget = limb.character;
-                                        }
-                                        if (hitTarget != null && !hitTarget.IsDead && Character.IsFriendly(hitTarget))
-                                        {
-                                            return true;
-                                        }
+                                        hitTarget = c;
+                                    }
+                                    else if (body.UserData is Limb limb)
+                                    {
+                                        hitTarget = limb.character;
+                                    }
+                                    if (hitTarget != null && !hitTarget.IsDead && Character.IsFriendly(hitTarget))
+                                    {
+                                        return true;
                                     }
-                                    return false;
                                 }
+                                return false;
                             }
                         }
                     }
@@ -1854,7 +1837,33 @@ namespace Barotrauma
                         }
                     }
 
-                    if (!canAttack || distance > Math.Min(AttackLimb.attack.Range * 0.9f, 100))
+                    if (AttackLimb is Limb attackLimb && attackLimb.attack.Ranged)
+                    {
+                        bool advance = !canAttack && Character.InWater || distance > attackLimb.attack.Range * 0.9f;
+                        bool fallBack = canAttack && distance < Math.Min(250, attackLimb.attack.Range * 0.25f);
+                        if (fallBack)
+                        {
+                            Reverse = true;
+                            UpdateFallBack(attackWorldPos, deltaTime, followThrough: false);
+                        }
+                        else if (advance)
+                        {
+                            if (pathSteering != null)
+                            {
+                                pathSteering.SteeringSeek(steerPos, weight: 10, minGapWidth: minGapSize);
+                            }
+                            else
+                            {
+                                SteeringManager.SteeringSeek(steerPos, 10);
+                            }
+                        }
+                        else if (!Character.InWater)
+                        {
+                            SteeringManager.Reset();
+                            FaceTarget(SelectedAiTarget.Entity);
+                        }
+                    }
+                    else if (!canAttack || distance > Math.Min(AttackLimb.attack.Range * 0.9f, 100))
                     {
                         if (pathSteering != null)
                         {
@@ -1865,20 +1874,30 @@ namespace Barotrauma
                             SteeringManager.SteeringSeek(steerPos, 10);
                         }
                     }
-                    else if (AttackLimb.attack.Ranged)
-                    {
-                        // Too close
-                        UpdateFallBack(attackWorldPos, deltaTime, followThrough: false);
-                    }
+
                     if (Character.CurrentHull == null && (SelectedAiTarget?.Entity is Character c && c.Submarine == null || distance == 0 || distance > ConvertUnits.ToDisplayUnits(avoidLookAheadDistance * 2)))
                     {
                         SteeringManager.SteeringAvoid(deltaTime, lookAheadDistance: avoidLookAheadDistance, weight: 30);
                     }
                 }
             }
+            IDamageable damageTarget = wallTarget != null ? wallTarget.Structure : SelectedAiTarget?.Entity as IDamageable;
+            if (AttackLimb?.attack is Attack { Ranged: true} attack)
+            {
+                Limb limb = GetLimbToRotate(attack);
+                if (limb != null)
+                {
+                    Vector2 toTarget = damageTarget.WorldPosition - limb.WorldPosition;
+                    float offset = limb.Params.GetSpriteOrientation() - MathHelper.PiOver2;
+                    limb.body.SuppressSmoothRotationCalls = false;
+                    float angle = MathUtils.VectorToAngle(toTarget);
+                    limb.body.SmoothRotate(angle + offset, attack.AimRotationTorque);
+                    limb.body.SuppressSmoothRotationCalls = true;
+                }
+            }
             if (canAttack)
             {
-                if (!UpdateLimbAttack(deltaTime, AttackLimb, attackSimPos, distance, attackTargetLimb))
+                if (!UpdateLimbAttack(deltaTime, attackSimPos, damageTarget, distance, attackTargetLimb))
                 {
                     IgnoreTarget(SelectedAiTarget);
                 }
@@ -2114,13 +2133,14 @@ namespace Barotrauma
         }
 
         // 10 dmg, 100 health -> 0.1
-        private float GetRelativeDamage(float dmg, float vitality) => dmg / Math.Max(vitality, 1.0f);
+        private static float GetRelativeDamage(float dmg, float vitality) => dmg / Math.Max(vitality, 1.0f);
 
-        private bool UpdateLimbAttack(float deltaTime, Limb attackingLimb, Vector2 attackSimPos, float distance = -1, Limb targetLimb = null)
+        private bool UpdateLimbAttack(float deltaTime, Vector2 attackSimPos, IDamageable damageTarget, float distance = -1, Limb targetLimb = null)
         {
             if (SelectedAiTarget?.Entity == null) { return false; }
-            if (attackingLimb?.attack == null) { return false; }
-            ActiveAttack = attackingLimb.attack;
+            if (AttackLimb?.attack == null) { return false; }
+            if (damageTarget == null) { return false; }
+            ActiveAttack = AttackLimb.attack;
             if (wallTarget != null)
             {
                 // If the selected target is not the wall target, make the wall target the selected target.
@@ -2131,83 +2151,94 @@ namespace Barotrauma
                     State = AIState.Attack;
                 }
             }
-            IDamageable damageTarget = wallTarget != null ? wallTarget.Structure : SelectedAiTarget.Entity as IDamageable;
-            if (damageTarget != null)
+            if (damageTarget == null) { return false; }
+            if (ActiveAttack.Ranged && ActiveAttack.RequiredAngleToShoot > 0)
             {
-                if (Character.Params.CanInteract && Character.Inventory != null)
+                Limb referenceLimb = GetLimbToRotate(ActiveAttack);
+                if (referenceLimb != null)
                 {
-                    // Use equipped items (weapons)
-                    Item item = GetEquippedItem(attackingLimb);
-                    if (item != null)
+                    Vector2 toTarget = damageTarget.WorldPosition - referenceLimb.WorldPosition;
+                    float offset = referenceLimb.Params.GetSpriteOrientation() - MathHelper.PiOver2;
+                    Vector2 forward = VectorExtensions.Forward(referenceLimb.body.TransformedRotation - offset * referenceLimb.Dir);
+                    float angle = MathHelper.ToDegrees(VectorExtensions.Angle(forward, toTarget));
+                    if (angle > ActiveAttack.RequiredAngleToShoot)
                     {
-                        if (item.RequireAimToUse)
-                        {
-                            if (!Aim(deltaTime, damageTarget as ISpatialEntity, item))
-                            {
-                                // Valid target, but can't shoot -> return true so that it will not be ignored.
-                                return true;
-                            }
-                        }
-                        Character.SetInput(item.IsShootable ? InputType.Shoot : InputType.Use, false, true);
-                        item.Use(deltaTime, Character);
+                        return true;
                     }
                 }
-                //simulate attack input to get the character to attack client-side
-                Character.SetInput(InputType.Attack, true, true);
-                if (!ActiveAttack.IsRunning)
+            }
+            if (Character.Params.CanInteract && Character.Inventory != null)
+            {
+                // Use equipped items (weapons)
+                Item item = GetEquippedItem(AttackLimb);
+                if (item != null)
                 {
+                    if (item.RequireAimToUse)
+                    {
+                        if (!Aim(deltaTime, damageTarget as ISpatialEntity, item))
+                        {
+                            // Valid target, but can't shoot -> return true so that it will not be ignored.
+                            return true;
+                        }
+                    }
+                    Character.SetInput(item.IsShootable ? InputType.Shoot : InputType.Use, false, true);
+                    item.Use(deltaTime, Character);
+                }
+            }
+            //simulate attack input to get the character to attack client-side
+            Character.SetInput(InputType.Attack, true, true);
+            if (!ActiveAttack.IsRunning)
+            {
 #if SERVER
                     GameMain.NetworkMember.CreateEntityEvent(Character, new Character.SetAttackTargetEventData(
-                        attackingLimb,
+                        AttackLimb,
                         damageTarget,
                         targetLimb,
                         SimPosition));
 #else
-                    Character.PlaySound(CharacterSound.SoundType.Attack, maxInterval: 3);
+                Character.PlaySound(CharacterSound.SoundType.Attack, maxInterval: 3);
 #endif
-                }
+            }
 
-                if (attackingLimb.UpdateAttack(deltaTime, attackSimPos, damageTarget, out AttackResult attackResult, distance, targetLimb))
+            if (AttackLimb.UpdateAttack(deltaTime, attackSimPos, damageTarget, out AttackResult attackResult, distance, targetLimb))
+            {
+                if (ActiveAttack.CoolDownTimer > 0)
                 {
-                    if (attackingLimb.attack.CoolDownTimer > 0)
+                    SetAimTimer(Math.Min(ActiveAttack.CoolDown, 1.5f));
+                    // Managed to hit a living/non-destroyed target. Increase the priority more if the target is low in health -> dies easily/soon
+                    float greed = AIParams.AggressionGreed;
+                    if (damageTarget is not Barotrauma.Character)
+                    {
+                        // Halve the greed for attacking non-characters.
+                        greed /= 2;
+                    }
+                    selectedTargetMemory.Priority += GetRelativeDamage(attackResult.Damage, damageTarget.Health) * greed;
+                }
+                if (LatchOntoAI != null && SelectedAiTarget.Entity is Character targetCharacter)
+                {
+                    LatchOntoAI.SetAttachTarget(targetCharacter);
+                }
+                if (!ActiveAttack.Ranged)
+                {
+                    if (damageTarget.Health > 0 && attackResult.Damage > 0)
                     {
-                        SetAimTimer(Math.Min(attackingLimb.attack.CoolDown, 1.5f));
                         // Managed to hit a living/non-destroyed target. Increase the priority more if the target is low in health -> dies easily/soon
                         float greed = AIParams.AggressionGreed;
-                        if (!(damageTarget is Character))
+                        if (damageTarget is not Barotrauma.Character)
                         {
                             // Halve the greed for attacking non-characters.
                             greed /= 2;
                         }
                         selectedTargetMemory.Priority += GetRelativeDamage(attackResult.Damage, damageTarget.Health) * greed;
                     }
-                    if (LatchOntoAI != null && SelectedAiTarget.Entity is Character targetCharacter)
+                    else
                     {
-                        LatchOntoAI.SetAttachTarget(targetCharacter);
-                    }
-                    if (!attackingLimb.attack.Ranged)
-                    {
-                        if (damageTarget.Health > 0 && attackResult.Damage > 0)
-                        {
-                            // Managed to hit a living/non-destroyed target. Increase the priority more if the target is low in health -> dies easily/soon
-                            float greed = AIParams.AggressionGreed;
-                            if (!(damageTarget is Character))
-                            {
-                                // Halve the greed for attacking non-characters.
-                                greed /= 2;
-                            }
-                            selectedTargetMemory.Priority += GetRelativeDamage(attackResult.Damage, damageTarget.Health) * greed;
-                        }
-                        else
-                        {
-                            selectedTargetMemory.Priority -= Math.Max(selectedTargetMemory.Priority / 2, 1);
-                            return selectedTargetMemory.Priority > 1;
-                        }
+                        selectedTargetMemory.Priority -= Math.Max(selectedTargetMemory.Priority / 2, 1);
+                        return selectedTargetMemory.Priority > 1;
                     }
                 }
-                return true;
             }
-            return false;
+            return true;
         }
 
         private float aimTimer;
@@ -2299,7 +2330,6 @@ namespace Barotrauma
         {
             if (attackVector == null)
             {
-                // TODO: test adding some random variance here?
                 attackVector = attackWorldPos - WorldPosition;
             }
             Vector2 dir = Vector2.Normalize(followThrough ? attackVector.Value : -attackVector.Value);
@@ -2319,6 +2349,16 @@ namespace Barotrauma
             return true;
         }
 
+        private Limb GetLimbToRotate(Attack attack)
+        {
+            Limb limb = AttackLimb;
+            if (attack.RotationLimbIndex > -1 && attack.RotationLimbIndex < Character.AnimController.Limbs.Length)
+            {
+                limb = Character.AnimController.Limbs[attack.RotationLimbIndex];
+            }
+            return limb;
+        }
+
         #endregion
 
         #region Eat
@@ -3429,7 +3469,7 @@ namespace Barotrauma
         private void ChangeParams(string tag, AIState state, float? priority = null, bool onlyExisting = false)
             => ChangeParams(tag.ToIdentifier(), state, priority, onlyExisting);
         
-        private void ChangeParams(Identifier tag, AIState state, float? priority = null, bool onlyExisting = false)
+        private void ChangeParams(Identifier tag, AIState state, float? priority = null, bool onlyExisting = false, bool ignoreAttacksIfNotInSameSub = false)
         {
             if (!AIParams.TryGetTarget(tag, out CharacterParams.TargetParams targetParams))
             {
@@ -3437,6 +3477,11 @@ namespace Barotrauma
                 {
                     if (AIParams.TryAddNewTarget(tag, state, priority ?? minPriority, out targetParams))
                     {
+                        if (state == AIState.Attack)
+                        {
+                            // Only applies to new temp target params. Shouldn't affect any existing definitions (handled below).
+                            targetParams.IgnoreIfNotInSameSub = ignoreAttacksIfNotInSameSub;
+                        }
                         tempParams.Add(tag, targetParams);
                     }
                 }
@@ -3470,7 +3515,7 @@ namespace Barotrauma
         {
             isStateChanged = true;
             SetStateResetTimer();
-            ChangeParams(target.SpeciesName, state, priority);
+            ChangeParams(target.SpeciesName, state, priority, ignoreAttacksIfNotInSameSub: !target.IsHuman);
             if (target.IsHuman)
             {
                 priority = GetTargetParams("human")?.Priority;

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/Objectives/AIObjectiveCombat.cs

@@ -748,6 +748,9 @@ namespace Barotrauma
             }
             if (!character.HasEquippedItem(Weapon, predicate: IsHandSlotType))
             {
+                //clear aim and shoot inputs so the bot doesn't immediately fire the weapon if it was previously e.g. using a scooter
+                character.ClearInput(InputType.Aim);
+                character.ClearInput(InputType.Shoot);
                 Weapon.TryInteract(character, forceSelectKey: true);
                 var slots = Weapon.AllowedSlots.Where(s => IsHandSlotType(s));
                 if (character.Inventory.TryPutItem(Weapon, character, slots))
@@ -764,7 +767,7 @@ namespace Barotrauma
             }
             return true;
 
-            bool IsHandSlotType(InvSlotType s) => s == InvSlotType.LeftHand || s == InvSlotType.RightHand || s == (InvSlotType.LeftHand | InvSlotType.RightHand);
+            static bool IsHandSlotType(InvSlotType s) => s == InvSlotType.LeftHand || s == InvSlotType.RightHand || s == (InvSlotType.LeftHand | InvSlotType.RightHand);
         }
 
         private float findHullTimer;

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/Objectives/AIObjectiveRepairItem.cs

@@ -186,8 +186,8 @@ namespace Barotrauma
                     {
                         if (character.SelectedItem != Item)
                         {
-                            if (Item.TryInteract(character, ignoreRequiredItems: true, forceSelectKey: true) ||
-                                Item.TryInteract(character, ignoreRequiredItems: true, forceUseKey: true))
+                            if (Item.TryInteract(character, ignoreRequiredItems: true, forceUseKey: true) ||
+                                Item.TryInteract(character, ignoreRequiredItems: true, forceSelectKey: true))
                             {
                                 character.SelectedItem = Item;
                             }

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/PetBehavior.cs

@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Xml.Linq;
+using static Barotrauma.CharacterParams;
 
 namespace Barotrauma
 {
@@ -44,7 +45,7 @@ namespace Barotrauma
         public float PlayTimer { get; set; }
         private float? unstunY { get; set; }
 
-        public EnemyAIController AiController { get; private set; } = null;
+        public EnemyAIController AIController { get; private set; } = null;
 
         public Character Owner { get; set; }
 
@@ -134,8 +135,8 @@ namespace Barotrauma
                         aggregate += Items[i].Commonness;
                         if (aggregate >= r && Items[i].Prefab != null)
                         {
-                            GameAnalyticsManager.AddDesignEvent("MicroInteraction:" + (GameMain.GameSession?.GameMode?.Preset.Identifier.Value ?? "null") + ":PetProducedItem:" + pet.AiController.Character.SpeciesName + ":" + Items[i].Prefab.Identifier);
-                            Entity.Spawner.AddItemToSpawnQueue(Items[i].Prefab, pet.AiController.Character.WorldPosition);
+                            GameAnalyticsManager.AddDesignEvent("MicroInteraction:" + (GameMain.GameSession?.GameMode?.Preset.Identifier.Value ?? "null") + ":PetProducedItem:" + pet.AIController.Character.SpeciesName + ":" + Items[i].Prefab.Identifier);
+                            Entity.Spawner.AddItemToSpawnQueue(Items[i].Prefab, pet.AIController.Character.WorldPosition);
                             break;
                         }
                     }
@@ -160,8 +161,8 @@ namespace Barotrauma
 
         public PetBehavior(XElement element, EnemyAIController aiController)
         {
-            AiController = aiController;
-            AiController.Character.CanBeDragged = true;
+            AIController = aiController;
+            AIController.Character.CanBeDragged = true;
 
             MaxHappiness = element.GetAttributeFloat("maxhappiness", 100.0f);
             MaxHunger = element.GetAttributeFloat("maxhunger", 100.0f);
@@ -218,7 +219,7 @@ namespace Barotrauma
             bool success = OnEat(item.GetTags());
             if (success)
             {
-                GameAnalyticsManager.AddDesignEvent("MicroInteraction:" + (GameMain.GameSession?.GameMode?.Preset.Identifier.Value ?? "null") + ":PetEat:" + AiController.Character.SpeciesName + ":" + item.Prefab.Identifier);
+                GameAnalyticsManager.AddDesignEvent("MicroInteraction:" + (GameMain.GameSession?.GameMode?.Preset.Identifier.Value ?? "null") + ":PetEat:" + AIController.Character.SpeciesName + ":" + item.Prefab.Identifier);
             }
             return success;
         }
@@ -229,7 +230,7 @@ namespace Barotrauma
             bool success = OnEat("dead".ToIdentifier());
             if (success)
             {
-                GameAnalyticsManager.AddDesignEvent("MicroInteraction:" + (GameMain.GameSession?.GameMode?.Preset.Identifier.Value ?? "null") + ":PetEat:" + AiController.Character.SpeciesName + ":" + character.SpeciesName);
+                GameAnalyticsManager.AddDesignEvent("MicroInteraction:" + (GameMain.GameSession?.GameMode?.Preset.Identifier.Value ?? "null") + ":PetEat:" + AIController.Character.SpeciesName + ":" + character.SpeciesName);
             }
             return success;
         }
@@ -252,7 +253,7 @@ namespace Barotrauma
                     Hunger += foods[i].Hunger;
                     Happiness += foods[i].Happiness;
 #if CLIENT
-                    AiController.Character.PlaySound(CharacterSound.SoundType.Happy, 0.5f);
+                    AIController.Character.PlaySound(CharacterSound.SoundType.Happy, 0.5f);
 #endif
                     return true;
                 }
@@ -265,20 +266,20 @@ namespace Barotrauma
             if (PlayTimer > 0.0f) { return; }
             if (Owner == null) { Owner = player; }
             PlayTimer = 5.0f;
-            AiController.Character.IsRagdolled = true;
+            AIController.Character.IsRagdolled = true;
             Happiness += 10.0f;
-            AiController.Character.AnimController.MainLimb.body.LinearVelocity += new Vector2(0, PlayForce);
-            unstunY = AiController.Character.SimPosition.Y;
+            AIController.Character.AnimController.MainLimb.body.LinearVelocity += new Vector2(0, PlayForce);
+            unstunY = AIController.Character.SimPosition.Y;
 #if CLIENT
-            AiController.Character.PlaySound(CharacterSound.SoundType.Happy, 0.9f);
+            AIController.Character.PlaySound(CharacterSound.SoundType.Happy, 0.9f);
 #endif
         }
 
         public string GetTagName()
         {
-            if (AiController.Character.Inventory != null)
+            if (AIController.Character.Inventory != null)
             {
-                foreach (Item item in AiController.Character.Inventory.AllItems)
+                foreach (Item item in AIController.Character.Inventory.AllItems)
                 {
                     var tag = item.GetComponent<NameTag>();
                     if (tag != null && !string.IsNullOrWhiteSpace(tag.WrittenName))
@@ -293,7 +294,7 @@ namespace Barotrauma
 
         public void Update(float deltaTime)
         {
-            var character = AiController.Character;
+            var character = AIController.Character;
             if (character?.Removed ?? true || character.IsDead) { return; }
 
             if (unstunY.HasValue)
@@ -332,16 +333,27 @@ namespace Barotrauma
                 Food food = foods[i];
                 if (Hunger >= food.HungerRange.X && Hunger <= food.HungerRange.Y)
                 {
-                    if (food.TargetParams == null &&
-                        AiController.AIParams.TryAddNewTarget(food.Tag, AIState.Eat, food.Priority, out CharacterParams.TargetParams targetParams))
+                    if (food.TargetParams == null)
                     {
-                        targetParams.IgnoreContained = food.IgnoreContained;
-                        food.TargetParams = targetParams;
+                        if (AIController.AIParams.TryGetTarget(food.Tag, out TargetParams target))
+                        {
+                            food.TargetParams = target;
+                        }
+                        else if (AIController.AIParams.TryAddNewTarget(food.Tag, AIState.Eat, food.Priority, out TargetParams targetParams))
+                        {
+                            food.TargetParams = targetParams;
+                        }
+                        if (food.TargetParams != null)
+                        {
+                            food.TargetParams.State = AIState.Eat;
+                            food.TargetParams.Priority = food.Priority;
+                            food.TargetParams.IgnoreContained = food.IgnoreContained;
+                        }
                     }
                 }
                 else if (food.TargetParams != null)
                 {
-                    AiController.AIParams.RemoveTarget(food.TargetParams);
+                    AIController.AIParams.RemoveTarget(food.TargetParams);
                     food.TargetParams = null;
                 }
             }

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/ShipCommand/ShipIssueWorker.cs

@@ -116,10 +116,10 @@ namespace Barotrauma
             }
 
             // accept only the highest priority order
-            if (CurrentOrder != null && OrderedCharacter.GetCurrentOrderWithTopPriority() != CurrentOrder)
+            if (CurrentOrder == null || OrderedCharacter.GetCurrentOrderWithTopPriority() != CurrentOrder)
             {
 #if DEBUG
-                ShipCommandManager.ShipCommandLog($"Order {CurrentOrder.Name} did not match current order for character {OrderedCharacter} in {this}");
+                ShipCommandManager.ShipCommandLog($"{this} is no longer the top priority of {OrderedCharacter}, considering the issue unattended.");
 #endif
                 return false;
             }

Barotrauma/BarotraumaShared/SharedSource/Characters/AI/ShipCommandManager.cs

@@ -356,7 +356,7 @@ namespace Barotrauma
                 ShipIssueWorkers.Add(new ShipIssueWorkerSteer(this, order));
             }
 
-            foreach (Item item in CommandedSubmarine.GetItems(true).FindAll(i => i.HasTag("turret")))
+            foreach (Item item in CommandedSubmarine.GetItems(true).FindAll(i => i.HasTag("turret") && !i.HasTag("hardpoint")))
             {
                 var order = new Order(OrderPrefab.Prefabs["operateweapons"], item, item.GetComponent<Turret>());
                 ShipIssueWorkers.Add(new ShipIssueWorkerOperateWeapons(this, order));

Barotrauma/BarotraumaShared/SharedSource/Characters/Animation/AnimController.cs

@@ -87,7 +87,7 @@ namespace Barotrauma
         }
 
         public bool CanWalk => RagdollParams.CanWalk;
-        public bool IsMovingBackwards => !InWater && Math.Sign(targetMovement.X) == -Math.Sign(Dir);
+        public bool IsMovingBackwards => !InWater && Math.Sign(targetMovement.X) == -Math.Sign(Dir) && CurrentAnimationParams is not FishGroundedParams { Flip: false };
 
         // TODO: define death anim duration in XML
         protected float deathAnimTimer, deathAnimDuration = 5.0f;

Barotrauma/BarotraumaShared/SharedSource/Characters/Animation/HumanoidAnimController.cs

@@ -610,15 +610,18 @@ namespace Barotrauma
                 torsoAngle -= herpesStrength / 150.0f;
                 torso.body.SmoothRotate(torsoAngle * Dir, CurrentGroundedParams.TorsoTorque);
             }
-            if (!Aiming && CurrentGroundedParams.FixedHeadAngle && HeadAngle.HasValue)
+            if (!head.Disabled)
             {
-                float headAngle = HeadAngle.Value;
-                if (Crouching && !movingHorizontally) { headAngle -= HumanCrouchParams.ExtraHeadAngleWhenStationary; }
-                head.body.SmoothRotate(headAngle * Dir, CurrentGroundedParams.HeadTorque);
-            }
-            else
-            {
-                RotateHead(head);
+                if (!Aiming && CurrentGroundedParams.FixedHeadAngle && HeadAngle.HasValue)
+                {
+                    float headAngle = HeadAngle.Value;
+                    if (Crouching && !movingHorizontally) { headAngle -= HumanCrouchParams.ExtraHeadAngleWhenStationary; }
+                    head.body.SmoothRotate(headAngle * Dir, CurrentGroundedParams.HeadTorque);
+                }
+                else
+                {
+                    RotateHead(head);
+                }
             }
 
             if (!onGround)
@@ -1389,7 +1392,7 @@ namespace Barotrauma
                 target.Oxygen += deltaTime * 0.5f; //Stabilize them        
             }
 
-            bool powerfulCPR = character.HasAbilityFlag(AbilityFlags.PowerfulCPR);
+            float cprBoost = character.GetStatValue(StatTypes.CPRBoost);
            
             int skill = (int)character.GetSkillLevel("medical");
             //pump for 15 seconds (cprAnimTimer 0-15), then do mouth-to-mouth for 2 seconds (cprAnimTimer 15-17)
@@ -1406,7 +1409,7 @@ namespace Barotrauma
                 {
                     if (target.Oxygen < -10.0f)
                     {
-                        if (powerfulCPR)
+                        if (cprBoost >= 1f)
                         {
                             //prevent the patient from suffocating no matter how fast their oxygen level is dropping
                             target.Oxygen = Math.Max(target.Oxygen, -10.0f);
@@ -1453,7 +1456,7 @@ namespace Barotrauma
                         reviveChance = (float)Math.Pow(reviveChance, CPRSettings.Active.ReviveChanceExponent);
                         reviveChance = MathHelper.Clamp(reviveChance, CPRSettings.Active.ReviveChanceMin, CPRSettings.Active.ReviveChanceMax);
 
-                        if (powerfulCPR) { reviveChance *= 2.0f; }
+                        reviveChance *= 1f + cprBoost;
 
                         if (Rand.Range(0.0f, 1.0f, Rand.RandSync.ServerAndClient) <= reviveChance)
                         {

Barotrauma/BarotraumaShared/SharedSource/Characters/Animation/Ragdoll.cs

@@ -873,7 +873,7 @@ namespace Barotrauma
 
             foreach (Limb limb in Limbs)
             {
-                if (limb == null || limb.IsSevered) { continue; }
+                if (limb == null || limb.IsSevered || !limb.DoesFlip) { continue; }
                 limb.Dir = Dir;
                 limb.MouthPos = new Vector2(-limb.MouthPos.X, limb.MouthPos.Y);
                 limb.MirrorPullJoint();
@@ -1337,7 +1337,7 @@ namespace Barotrauma
             bool limbsValid = true;
             foreach (Limb limb in limbs)
             {
-                if (limb.body == null || !limb.body.Enabled) { continue; }
+                if (limb?.body == null || !limb.body.Enabled) { continue; }
                 if (!CheckValidity(limb.body))
                 {
                     limbsValid = false;
@@ -1959,7 +1959,7 @@ namespace Barotrauma
             {
                 foreach (Limb l in Limbs)
                 {
-                    l.Remove();
+                    l?.Remove();
                 }
                 limbs = null;
             }
@@ -1968,7 +1968,7 @@ namespace Barotrauma
             {
                 foreach (PhysicsBody b in collider)
                 {
-                    b.Remove();
+                    b?.Remove();
                 }
                 collider = null;
             }
@@ -1977,7 +1977,7 @@ namespace Barotrauma
             {
                 foreach (var joint in LimbJoints)
                 {
-                    var j = joint.Joint;
+                    var j = joint?.Joint;
                     if (GameMain.World.JointList.Contains(j))
                     {
                         GameMain.World.Remove(j);

Barotrauma/BarotraumaShared/SharedSource/Characters/Attack.cs

@@ -189,6 +189,15 @@ namespace Barotrauma
         [Serialize(20f, IsPropertySaveable.Yes)]
         public float RequiredAngle { get; set; }
 
+        [Serialize(0f, IsPropertySaveable.Yes, description: "By default uses the same value as RequiredAngle. Use if you want to allow selecting the attack but not shooting until the angle is smaller. Only affects ranged attacks."), Editable]
+        public float RequiredAngleToShoot { get; set; }
+
+        [Serialize(0f, IsPropertySaveable.Yes, description: "How much the attack limb is rotated towards the target. Default 0 = no rotation. Only affects ranged attacks."), Editable]
+        public float AimRotationTorque { get; set; }
+
+        [Serialize(-1, IsPropertySaveable.Yes, description: "Reference to the limb we apply the aim rotation to. By default same as the attack limb. Only affects ranged attacks."), Editable]
+        public int RotationLimbIndex { get; set; }
+
         /// <summary>
         /// Legacy support. Use Afflictions.
         /// </summary>
@@ -529,6 +538,12 @@ namespace Barotrauma
                         effect.Apply(effectType, deltaTime, targetEntity, attacker, worldPosition);
                     }
                 }
+                if (effect.HasTargetType(StatusEffect.TargetType.Contained))
+                {
+                    targets.Clear();
+                    targets.AddRange(attacker.Inventory.AllItems);
+                    effect.Apply(effectType, deltaTime, attacker, targets);
+                }
             }
 
             return attackResult;
@@ -591,6 +606,12 @@ namespace Barotrauma
                 {
                     effect.Apply(effectType, deltaTime, targetLimb.character, attacker, worldPosition);
                 }
+                if (effect.HasTargetType(StatusEffect.TargetType.Contained))
+                {
+                    targets.Clear();
+                    targets.AddRange(attacker.Inventory.AllItems);
+                    effect.Apply(effectType, deltaTime, attacker, targets);
+                }
             }
 
             return attackResult;

Barotrauma/BarotraumaShared/SharedSource/Characters/Character.cs

@@ -129,6 +129,7 @@ namespace Barotrauma
         public bool IsCommanding => IsPlayer || (AIController is HumanAIController humanAI && humanAI.ShipCommandManager != null && humanAI.ShipCommandManager.Active);
         public bool IsBot => !IsPlayer && AIController is HumanAIController humanAI && humanAI.Enabled;
         public bool IsEscorted { get; set; }
+        public Identifier JobIdentifier => Info?.Job?.Prefab.Identifier ?? Identifier.Empty;
 
         public readonly Dictionary<Identifier, SerializableProperty> Properties;
         public Dictionary<Identifier, SerializableProperty> SerializableProperties
@@ -611,7 +612,9 @@ namespace Barotrauma
                 CharacterHealth.SetHealthBarVisibility(value == null);
 #endif
                 bool isServerOrSingleplayer = GameMain.IsSingleplayer || GameMain.NetworkMember is { IsServer: true };
-                if (IsPlayer && isServerOrSingleplayer && value is { IsDead: true, Wallet: { Balance: var balance } grabbedWallet } && balance > 0)
+                CheckTalents(AbilityEffectType.OnLootCharacter, new AbilityCharacterLoot(value));
+
+                if (IsPlayer && isServerOrSingleplayer && value is { IsDead: true, Wallet: { Balance: var balance and > 0 } grabbedWallet })
                 {
 #if SERVER
                     if (GameMain.GameSession.Campaign is MultiPlayerCampaign mpCampaign && GameMain.Server is { ServerSettings: { } settings })
@@ -999,7 +1002,7 @@ namespace Barotrauma
             }
         }
 
-        public bool InWater => AnimController?.InWater ?? false;
+        public bool InWater => AnimController is AnimController { InWater: true };
 
         public bool GodMode = false;
 
@@ -1053,6 +1056,8 @@ namespace Barotrauma
             }
         }
 
+        public HashSet<Identifier> MarkedAsLooted = new();
+
         public bool IsInFriendlySub => Submarine != null && Submarine.TeamID == TeamID;
 
         public delegate void OnDeathHandler(Character character, CauseOfDeath causeOfDeath);
@@ -1574,14 +1579,23 @@ namespace Barotrauma
                 }
                 if (createNetworkEvent && GameMain.NetworkMember is { IsServer: true })
                 {
-                    GameMain.NetworkMember.CreateEntityEvent(item, new Item.ChangePropertyEventData(item.SerializableProperties[nameof(item.Tags).ToIdentifier()]));
+                    GameMain.NetworkMember.CreateEntityEvent(item, new Item.ChangePropertyEventData(item.SerializableProperties[nameof(item.Tags).ToIdentifier()], item));
                 }
             }
         }
 
         public float GetSkillLevel(string skillIdentifier) =>
             GetSkillLevel(skillIdentifier.ToIdentifier());
-        
+
+        private static readonly ImmutableDictionary<Identifier, StatTypes> overrideStatTypes = new Dictionary<Identifier, StatTypes>
+        {
+            { new("helm"), StatTypes.HelmSkillOverride },
+            { new("medical"), StatTypes.MedicalSkillOverride },
+            { new("weapons"), StatTypes.WeaponsSkillOverride },
+            { new("electrical"), StatTypes.ElectricalSkillOverride },
+            { new("mechanical"), StatTypes.MechanicalSkillOverride }
+        }.ToImmutableDictionary();
+
         public float GetSkillLevel(Identifier skillIdentifier)
         {
             if (Info?.Job == null) { return 0.0f; }
@@ -1617,6 +1631,16 @@ namespace Barotrauma
 
             skillLevel += GetStatValue(GetSkillStatType(skillIdentifier));
 
+            if (overrideStatTypes.TryGetValue(skillIdentifier, out StatTypes statType))
+            {
+                float skillOverride = GetStatValue(statType);
+                if (skillOverride > skillLevel)
+                {
+                    skillLevel = skillOverride;
+                }
+            }
+
+
             return skillLevel;
         }
 
@@ -2058,30 +2082,42 @@ namespace Barotrauma
             {
                 foreach (Item item in HeldItems)
                 {
-                    if (IsKeyDown(InputType.Aim) || !item.RequireAimToSecondaryUse)
+                    tryUseItem(item, deltaTime);
+                }
+                foreach (Item item in Inventory.AllItems)
+                {
+                    if (item.GetComponent<Wearable>() is { AllowUseWhenWorn: true } && HasEquippedItem(item))
                     {
-                        item.SecondaryUse(deltaTime, this);
+                        tryUseItem(item, deltaTime);
                     }
-                    if (IsKeyDown(InputType.Use) && !item.IsShootable)
+                }
+            }
+
+            void tryUseItem(Item item, float deltaTime)
+            {
+                if (IsKeyDown(InputType.Aim) || !item.RequireAimToSecondaryUse)
+                {
+                    item.SecondaryUse(deltaTime, this);
+                }
+                if (IsKeyDown(InputType.Use) && !item.IsShootable)
+                {
+                    if (!item.RequireAimToUse || IsKeyDown(InputType.Aim))
                     {
-                        if (!item.RequireAimToUse || IsKeyDown(InputType.Aim))
-                        {
-                            item.Use(deltaTime, this);
-                        }
+                        item.Use(deltaTime, this);
                     }
-                    if (IsKeyDown(InputType.Shoot) && item.IsShootable)
+                }
+                if (IsKeyDown(InputType.Shoot) && item.IsShootable)
+                {
+                    if (!item.RequireAimToUse || IsKeyDown(InputType.Aim))
                     {
-                        if (!item.RequireAimToUse || IsKeyDown(InputType.Aim))
-                        {
-                            item.Use(deltaTime, this);
-                        }
+                        item.Use(deltaTime, this);
+                    }
 #if CLIENT
-                        else if (item.RequireAimToUse && !IsKeyDown(InputType.Aim))
-                        {
-                            HintManager.OnShootWithoutAiming(this, item);
-                        }
-#endif
+                    else if (item.RequireAimToUse && !IsKeyDown(InputType.Aim))
+                    {
+                        HintManager.OnShootWithoutAiming(this, item);
                     }
+#endif
                 }
             }
 
@@ -2721,6 +2757,11 @@ namespace Barotrauma
                 }
             }
 
+            bool selectInputSameAsDeselect = false;
+#if CLIENT
+            selectInputSameAsDeselect = GameSettings.CurrentConfig.KeyMap.Bindings[InputType.Select] == GameSettings.CurrentConfig.KeyMap.Bindings[InputType.Deselect];
+#endif
+
             if (SelectedCharacter != null && (IsKeyHit(InputType.Grab) || IsKeyHit(InputType.Health))) //Let people use ladders and buttons and stuff when dragging chars
             {
                 DeselectCharacter();
@@ -2760,14 +2801,16 @@ namespace Barotrauma
             {
                 FocusedCharacter.onCustomInteract(FocusedCharacter, this);
             }
-            else if (IsKeyHit(InputType.Deselect) && SelectedItem != null)
+            else if (IsKeyHit(InputType.Deselect) && SelectedItem != null && 
+                (focusedItem == null || focusedItem == SelectedItem || !selectInputSameAsDeselect))
             {
                 SelectedItem = null;
 #if CLIENT
                 CharacterHealth.OpenHealthWindow = null;
 #endif
             }
-            else if (IsKeyHit(InputType.Deselect) && SelectedSecondaryItem != null)
+            else if (IsKeyHit(InputType.Deselect) && SelectedSecondaryItem != null && SelectedSecondaryItem.GetComponent<Ladder>() == null &&
+                (focusedItem == null || focusedItem == SelectedSecondaryItem || !selectInputSameAsDeselect))
             {
                 SelectedSecondaryItem = null;
 #if CLIENT
@@ -2782,6 +2825,10 @@ namespace Barotrauma
             {
 #if CLIENT
                 if (CharacterInventory.DraggingItemToWorld) { return; }
+                if (selectInputSameAsDeselect)
+                {
+                    keys[(int)InputType.Deselect].Reset();
+                }
 #endif
                 bool canInteract = focusedItem.TryInteract(this);
 #if CLIENT
@@ -3787,7 +3834,7 @@ namespace Barotrauma
                 return;
             }
 #endif
-            if (damage < targetLimb.Params.MinSeveranceDamage) { return; }
+            if (damage > 0 && damage < targetLimb.Params.MinSeveranceDamage) { return; }
             if (!IsDead)
             {
                 if (!allowBeheading && targetLimb.type == LimbType.Head) { return; }
@@ -3805,7 +3852,7 @@ namespace Barotrauma
                 var referenceLimb = targetLimb.type == LimbType.Head && targetLimb.Params.ID == 0 ? joint.LimbA : joint.LimbB;
                 if (referenceLimb != targetLimb) { continue; }
                 float probability = severLimbsProbability;
-                if (!IsDead)
+                if (!IsDead && probability < 1)
                 {
                     probability *= joint.Params.SeveranceProbabilityModifier;
                 }
@@ -4778,6 +4825,32 @@ namespace Barotrauma
             return info.UnlockedTalents.Contains(identifier);
         }
 
+        private readonly HashSet<Hull> sameRoomHulls = new();
+
+        /// <summary>
+        /// Check if the character is in the same room
+        /// Room and hull differ in that a room can consist of multiple linked hulls
+        /// </summary>
+        public bool IsInSameRoomAs(Character character)
+        {
+            if (character == this) { return true; }
+
+            if (character.CurrentHull is null || CurrentHull is null)
+            {
+                // Outside doesn't count as a room
+                return false;
+            }
+
+            if (character.Submarine != Submarine) { return false; }
+            if (character.CurrentHull == CurrentHull) { return true; }
+
+            sameRoomHulls.Clear();
+            CurrentHull.GetLinkedEntities(sameRoomHulls);
+            sameRoomHulls.Add(CurrentHull);
+
+            return sameRoomHulls.Contains(character.CurrentHull);
+        }
+
         public bool HasUnlockedAllTalents()
         {
             if (TalentTree.JobTalentTrees.TryGet(Info.Job.Prefab.Identifier, out TalentTree talentTree))
@@ -4786,7 +4859,7 @@ namespace Barotrauma
                 {
                     foreach (TalentOption talentOption in talentSubTree.TalentOptionStages)
                     {
-                        if (talentOption.TalentIdentifiers.None(t => HasTalent(t)))
+                        if (talentOption.TalentIdentifiers.None(HasTalent))
                         {
                             return false;
                         }
@@ -4831,6 +4904,19 @@ namespace Barotrauma
             return characterTalents.Any(t => t.UnlockedRecipes.Contains(recipeIdentifier));
         }
 
+        public bool HasStoreAccessForItem(ItemPrefab prefab)
+        {
+            foreach (CharacterTalent talent in characterTalents)
+            {
+                foreach (Identifier unlockedItem in talent.UnlockedStoreItems)
+                {
+                    if (prefab.Tags.Contains(unlockedItem)) { return true; }
+                }
+            }
+
+            return false;
+        }
+
         /// <summary>
         /// Shows visual notification of money gained by the specific player. Useful for mid-mission monetary gains.
         /// </summary>
@@ -5043,6 +5129,16 @@ namespace Barotrauma
         }
     }
 
+    internal sealed class AbilityCharacterLoot : AbilityObject, IAbilityCharacter
+    {
+        public Character Character { get; set; }
+
+        public AbilityCharacterLoot(Character character)
+        {
+            Character = character;
+        }
+    }
+
     class AbilityCharacterKill : AbilityObject, IAbilityCharacter
     {
         public AbilityCharacterKill(Character character, Character killer)

Barotrauma/BarotraumaShared/SharedSource/Characters/CharacterInfo.cs

@@ -543,7 +543,7 @@ namespace Barotrauma
         
         private void GetName(Rand.RandSync randSync, out string name)
         {
-            var nameElement = CharacterConfigElement.GetChildElement("names") ?? CharacterConfigElement.GetChildElement("name");
+            ContentXElement nameElement = CharacterConfigElement.GetChildElement("names") ?? CharacterConfigElement.GetChildElement("name");
             ContentPath namesXmlFile = nameElement?.GetAttributeContentPath("path") ?? ContentPath.Empty;
             XElement namesXml = null;
             if (!namesXmlFile.IsNullOrEmpty()) //names.xml is defined 
@@ -554,8 +554,8 @@ namespace Barotrauma
             else //the legacy firstnames.txt/lastnames.txt shit is defined
             {
                 namesXml = new XElement("names", new XAttribute("format", "[firstname] [lastname]"));
-                var firstNamesPath = ReplaceVars(nameElement.GetAttributeContentPath("firstname")?.Value ?? "");
-                var lastNamesPath = ReplaceVars(nameElement.GetAttributeContentPath("lastname")?.Value ?? "");
+                string firstNamesPath = nameElement == null ? string.Empty : ReplaceVars(nameElement.GetAttributeContentPath("firstname")?.Value ?? "");
+                string lastNamesPath = nameElement == null ? string.Empty : ReplaceVars(nameElement.GetAttributeContentPath("lastname")?.Value ?? "");
                 if (File.Exists(firstNamesPath) && File.Exists(lastNamesPath))
                 {
                     var firstNames = File.ReadAllLines(firstNamesPath);
@@ -735,9 +735,7 @@ namespace Barotrauma
             Name = infoElement.GetAttributeString("name", "");
             OriginalName = infoElement.GetAttributeString("originalname", null);
             Salary = infoElement.GetAttributeInt("salary", 1000);
-
             ExperiencePoints = infoElement.GetAttributeInt("experiencepoints", 0);
-            UnlockedTalents = new HashSet<Identifier>(infoElement.GetAttributeIdentifierArray("unlockedtalents", Array.Empty<Identifier>()));
             AdditionalTalentPoints = infoElement.GetAttributeInt("additionaltalentpoints", 0);
             HashSet<Identifier> tags = infoElement.GetAttributeIdentifierArray("tags", Array.Empty<Identifier>()).ToHashSet();
             LoadTagsBackwardsCompatibility(infoElement, tags);
@@ -813,18 +811,22 @@ namespace Barotrauma
                 infoElement.GetAttributeIdentifier("npcid", Identifier.Empty));
 
             MissionsCompletedSinceDeath = infoElement.GetAttributeInt("missionscompletedsincedeath", 0);
+            UnlockedTalents = new HashSet<Identifier>();
 
             foreach (var subElement in infoElement.Elements())
             {
                 bool jobCreated = false;
-                if (subElement.Name.ToString().Equals("job", StringComparison.OrdinalIgnoreCase) && !jobCreated)
+
+                Identifier elementName = subElement.Name.ToIdentifier();
+
+                if (elementName == "job" && !jobCreated)
                 {
                     Job = new Job(subElement);
                     jobCreated = true;
                     // there used to be a break here, but it had to be removed to make room for statvalues
                     // using the jobCreated boolean to make sure that only the first job found is created
                 }
-                else if (subElement.Name.ToString().Equals("savedstatvalues", StringComparison.OrdinalIgnoreCase))
+                else if (elementName == "savedstatvalues")
                 {
                     foreach (XElement savedStat in subElement.Elements())
                     {
@@ -838,8 +840,8 @@ namespace Barotrauma
                         float value = savedStat.GetAttributeFloat("statvalue", 0f);
                         if (value == 0f) { continue; }
 
-                        string statIdentifier = savedStat.GetAttributeString("statidentifier", "").ToLowerInvariant();
-                        if (string.IsNullOrEmpty(statIdentifier))
+                        Identifier statIdentifier = savedStat.GetAttributeIdentifier("statidentifier", Identifier.Empty);
+                        if (statIdentifier.IsEmpty)
                         {
                             DebugConsole.ThrowError("Stat identifier not specified for Stat Value when loading character data in CharacterInfo!");
                             return;
@@ -849,6 +851,20 @@ namespace Barotrauma
                         ChangeSavedStatValue(statType, value, statIdentifier, removeOnDeath);
                     }
                 }
+                else if (elementName == "talents")
+                {
+                    Version version = subElement.GetAttributeVersion("version", GameMain.Version); // for future maybe
+
+                    foreach (XElement talentElement in subElement.Elements())
+                    {
+                        if (talentElement.Name.ToIdentifier() != "talent") { continue; }
+
+                        Identifier talentIdentifier = talentElement.GetAttributeIdentifier("identifier", Identifier.Empty);
+                        if (talentIdentifier == Identifier.Empty) { continue; }
+
+                        UnlockedTalents.Add(talentIdentifier);
+                    }
+                }
             }
             LoadHeadAttachments();
         }
@@ -1149,13 +1165,17 @@ namespace Barotrauma
 
             increase *= 1f + Character.GetStatValue(StatTypes.SkillGainSpeed);
 
+            increase = GetSkillSpecificGain(increase, skillIdentifier);
+
             float prevLevel = Job.GetSkillLevel(skillIdentifier);
             Job.IncreaseSkillLevel(skillIdentifier, increase, Character.HasAbilityFlag(AbilityFlags.GainSkillPastMaximum));
 
             float newLevel = Job.GetSkillLevel(skillIdentifier);
 
             if ((int)newLevel > (int)prevLevel)
-            {                
+            {
+                float extraLevel = Character.GetStatValue(StatTypes.ExtraLevelGain);
+                Job.IncreaseSkillLevel(skillIdentifier, extraLevel, Character.HasAbilityFlag(AbilityFlags.GainSkillPastMaximum));
                 // assume we are getting at least 1 point in skill, since this logic only runs in such cases
                 float increaseSinceLastSkillPoint = MathHelper.Max(increase, 1f);
                 var abilitySkillGain = new AbilitySkillGain(increaseSinceLastSkillPoint, skillIdentifier, Character, gainedFromAbility);
@@ -1169,6 +1189,25 @@ namespace Barotrauma
             OnSkillChanged(skillIdentifier, prevLevel, newLevel);
         }
 
+        private static readonly ImmutableDictionary<Identifier, StatTypes> skillGainStatValues = new Dictionary<Identifier, StatTypes>
+        {
+            { new("helm"), StatTypes.HelmSkillGainSpeed },
+            { new("medical"), StatTypes.WeaponsSkillGainSpeed },
+            { new("weapons"), StatTypes.MedicalSkillGainSpeed },
+            { new("electrical"), StatTypes.ElectricalSkillGainSpeed },
+            { new("mechanical"), StatTypes.MechanicalSkillGainSpeed }
+        }.ToImmutableDictionary();
+
+        private float GetSkillSpecificGain(float increase, Identifier skillIdentifier)
+        {
+            if (skillGainStatValues.TryGetValue(skillIdentifier, out StatTypes statType))
+            {
+                increase *= 1f + Character.GetStatValue(statType);
+            }
+
+            return increase;
+        }
+
         public void SetSkillLevel(Identifier skillIdentifier, float level)
         {
             if (Job == null) { return; }
@@ -1314,7 +1353,6 @@ namespace Barotrauma
                 new XAttribute("tags", string.Join(",", Head.Preset.TagSet)),
                 new XAttribute("salary", Salary),
                 new XAttribute("experiencepoints", ExperiencePoints),
-                new XAttribute("unlockedtalents", string.Join(",", UnlockedTalents)),
                 new XAttribute("additionaltalentpoints", AdditionalTalentPoints),
                 new XAttribute("hairindex", Head.HairIndex),
                 new XAttribute("beardindex", Head.BeardIndex),
@@ -1363,7 +1401,16 @@ namespace Barotrauma
                 }
             }
 
+            XElement talentElement = new XElement("Talents");
+            talentElement.Add(new XAttribute("version", GameMain.Version.ToString()));
+
+            foreach (Identifier talentIdentifier in UnlockedTalents)
+            {
+                talentElement.Add(new XElement("Talent", new XAttribute("identifier", talentIdentifier)));
+            }
+
             charElement.Add(savedStatElement);
+            charElement.Add(talentElement);
             parentElement?.Add(charElement);
             return charElement;
         }
@@ -1717,20 +1764,33 @@ namespace Barotrauma
             }
         }
 
-        public void ResetSavedStatValue(string statIdentifier)
+        public void ResetSavedStatValue(Identifier statIdentifier)
         {
             foreach (StatTypes statType in SavedStatValues.Keys)
             {
                 bool changed = false;
                 foreach (SavedStatValue savedStatValue in SavedStatValues[statType])
                 {
-                    if (savedStatValue.StatIdentifier != statIdentifier) { continue; }
+                    if (!MatchesIdentifier(savedStatValue.StatIdentifier, statIdentifier)) { continue; }
+
                     if (MathUtils.NearlyEqual(savedStatValue.StatValue, 0.0f)) { continue; }
                     savedStatValue.StatValue = 0.0f;
                     changed = true;
                 }
                 if (changed) { OnPermanentStatChanged(statType); }
             }
+
+            static bool MatchesIdentifier(Identifier statIdentifier, Identifier identifier)
+            {
+                if (statIdentifier == identifier) { return true; }
+
+                if (identifier.IndexOf('*') is var index and > -1)
+                {
+                    return statIdentifier.StartsWith(identifier[0..index]);
+                }
+
+                return false;
+            }
         }
 
         public float GetSavedStatValue(StatTypes statType)
@@ -1756,7 +1816,7 @@ namespace Barotrauma
             }
         }
 
-        public void ChangeSavedStatValue(StatTypes statType, float value, string statIdentifier, bool removeOnDeath, float maxValue = float.MaxValue, bool setValue = false)
+        public void ChangeSavedStatValue(StatTypes statType, float value, Identifier statIdentifier, bool removeOnDeath, float maxValue = float.MaxValue, bool setValue = false)
         {
             if (!SavedStatValues.ContainsKey(statType))
             {
@@ -1779,13 +1839,13 @@ namespace Barotrauma
         }
     }
 
-    public class SavedStatValue
+    internal sealed class SavedStatValue
     {
-        public string StatIdentifier { get; set; }
+        public Identifier StatIdentifier { get; set; }
         public float StatValue { get; set; }
         public bool RemoveOnDeath { get; set; }
 
-        public SavedStatValue(string statIdentifier, float value, bool removeOnDeath)
+        public SavedStatValue(Identifier statIdentifier, float value, bool removeOnDeath)
         {
             StatValue = value;
             RemoveOnDeath = removeOnDeath;
@@ -1793,7 +1853,7 @@ namespace Barotrauma
         }
     }
 
-    class AbilitySkillGain : AbilityObject, IAbilityValue, IAbilitySkillIdentifier, IAbilityCharacter
+    internal sealed class AbilitySkillGain : AbilityObject, IAbilityValue, IAbilitySkillIdentifier, IAbilityCharacter
     {
         public AbilitySkillGain(float skillAmount, Identifier skillIdentifier, Character character, bool gainedFromAbility)
         {

Barotrauma/BarotraumaShared/SharedSource/Characters/Health/Afflictions/AfflictionPrefab.cs

@@ -384,6 +384,8 @@ namespace Barotrauma
 
         private readonly ConstructorInfo constructor;
 
+        public readonly bool ResetBetweenRounds;
+
         public IEnumerable<KeyValuePair<Identifier, float>> TreatmentSuitability
         {
             get
@@ -465,6 +467,8 @@ namespace Barotrauma
             AfflictionOverlayAlphaIsLinear = element.GetAttributeBool("afflictionoverlayalphaislinear", false);
             AchievementOnRemoved = element.GetAttributeIdentifier("achievementonremoved", "");
 
+            ResetBetweenRounds = element.GetAttributeBool("resetbetweenrounds", false);
+
             foreach (var subElement in element.Elements())
             {
                 switch (subElement.Name.ToString().ToLowerInvariant())

Barotrauma/BarotraumaShared/SharedSource/Characters/Health/CharacterHealth.cs

@@ -140,9 +140,20 @@ namespace Barotrauma
         private float vitality;
         public float Vitality 
         {
-            get 
-            { 
-                return Character.IsDead ? minVitality : vitality; 
+            get
+            {
+                if (Character.IsDead)
+                {
+                    return minVitality;
+                }
+
+                if (Character.HasAbilityFlag(AbilityFlags.CanNotDieToAfflictions))
+                {
+                    return Math.Max(vitality, MinVitality + 1);
+                }
+
+                return vitality;
+
             }
             private set
             {
@@ -881,6 +892,9 @@ namespace Barotrauma
                 float oxygenlowResistance = GetResistance(oxygenLowAffliction.Prefab);
                 decreaseSpeed *= (1f - oxygenlowResistance);
                 increaseSpeed *= (1f + oxygenlowResistance);
+
+                float holdBreathMultiplier = 1f + GetStatValue(StatTypes.HoldBreathMultiplier);
+                decreaseSpeed *= holdBreathMultiplier;
                 OxygenAmount = MathHelper.Clamp(OxygenAmount + deltaTime * (Character.OxygenAvailable < InsufficientOxygenThreshold ? decreaseSpeed : increaseSpeed), -100.0f, 100.0f);
             }
 
@@ -1217,6 +1231,7 @@ namespace Barotrauma
                 var affliction = kvp.Key;
                 var limbHealth = kvp.Value;
                 if (affliction.Strength <= 0.0f || limbHealth != null) { continue; }
+                if (kvp.Key.Prefab.ResetBetweenRounds) { continue; }
                 healthElement.Add(new XElement("Affliction",
                     new XAttribute("identifier", affliction.Identifier),
                     new XAttribute("strength", affliction.Strength.ToString("G", CultureInfo.InvariantCulture))));

Barotrauma/BarotraumaShared/SharedSource/Characters/Limb.cs

@@ -778,6 +778,7 @@ namespace Barotrauma
                 {
                     var abilityAfflictionCharacter = new AbilityAfflictionCharacter(newAffliction, character);
                     attacker.CheckTalents(AbilityEffectType.OnAddDamageAffliction, abilityAfflictionCharacter);
+                    newAffliction = abilityAfflictionCharacter.Affliction;
                 }
                 if (applyAffliction)
                 {
@@ -896,6 +897,12 @@ namespace Barotrauma
             {
                 reEnableTimer = duration;
             }
+#if CLIENT
+            if (Hidden && LightSource != null)
+            {
+                LightSource.Enabled = false;
+            }
+#endif
         }
 
         public void ReEnable()
@@ -1194,7 +1201,25 @@ namespace Barotrauma
                 }
                 else
                 {
-                    if (statusEffect.HasTargetType(StatusEffect.TargetType.Character))
+
+                    if (statusEffect.HasTargetType(StatusEffect.TargetType.Contained) && character.Inventory is { } inventory)
+                    {
+                        foreach (Item item in inventory.AllItems)
+                        {
+                            if (statusEffect.TargetIdentifiers != null &&
+                                !statusEffect.TargetIdentifiers.Contains(item.Prefab.Identifier) &&
+                                statusEffect.TargetIdentifiers.None(id => item.HasTag(id)))
+                            {
+                                continue;
+                            }
+                            if (statusEffect.TargetSlot > -1)
+                            {
+                                if (inventory.FindIndex(item) != statusEffect.TargetSlot) { continue; }
+                            }
+                            targets.Add(item);
+                        }
+                    }
+                    else if (statusEffect.HasTargetType(StatusEffect.TargetType.Character))
                     {
                         statusEffect.Apply(actionType, deltaTime, character, character, WorldPosition);
                     }

Barotrauma/BarotraumaShared/SharedSource/Characters/Params/CharacterParams.cs

@@ -649,7 +649,7 @@ namespace Barotrauma
                 if (HasTag(tag))
                 {
                     target = null;
-                    DebugConsole.ThrowError($"Multiple targets with the same tag ('{tag}') defined! Only the first will be used!");
+                    DebugConsole.AddWarning($"Trying to add multiple targets with the same tag ('{tag}') defined! Only the first will be used!");
                     return false;
                 }
                 else

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityConditionals/AbilityCondition.cs

@@ -1,8 +1,5 @@
-using Microsoft.Xna.Framework;
-using System;
+using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Xml.Linq;
 
 namespace Barotrauma.Abilities
 {
@@ -34,6 +31,7 @@ namespace Barotrauma.Abilities
             Alive = 4,
             Monster = 5,
             InFriendlySubmarine = 6,
+            Large = 7,
         };
 
         protected List<TargetType> ParseTargetTypes(string[] targetTypeStrings)
@@ -41,8 +39,7 @@ namespace Barotrauma.Abilities
             List<TargetType> targetTypes = new List<TargetType>();
             foreach (string targetTypeString in targetTypeStrings)
             {
-                TargetType targetType = TargetType.Any;
-                if (!Enum.TryParse(targetTypeString, true, out targetType))
+                if (!Enum.TryParse(targetTypeString, true, out TargetType targetType))
                 {
                     DebugConsole.ThrowError("Invalid target type type \"" + targetTypeString + "\" in CharacterTalent (" + characterTalent.DebugIdentifier + ")");
                 }
@@ -83,6 +80,9 @@ namespace Barotrauma.Abilities
                     return !targetCharacter.IsHuman;
                 case TargetType.InFriendlySubmarine:
                     return targetCharacter.Submarine != null && targetCharacter.Submarine.TeamID == character.TeamID;
+                case TargetType.Large:
+                    // mass of mudraptor is ~48
+                    return targetCharacter.AnimController is { Mass: > 50.0f };
                 default:
                     return true;
             }

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityConditionals/AbilityConditionData/AbilityConditionCharacter.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Xml.Linq;
 
 namespace Barotrauma.Abilities
@@ -8,11 +9,13 @@ namespace Barotrauma.Abilities
     {
         private readonly List<TargetType> targetTypes;
 
-        private List<PropertyConditional> conditionals = new List<PropertyConditional>();
+        private readonly List<PropertyConditional> conditionals = new List<PropertyConditional>();
 
         public AbilityConditionCharacter(CharacterTalent characterTalent, ContentXElement conditionElement) : base(characterTalent, conditionElement)
         {
-            targetTypes = ParseTargetTypes(conditionElement.GetAttributeStringArray("targettypes", Array.Empty<string>(), convertToLowerInvariant: true));
+            targetTypes = ParseTargetTypes(
+                conditionElement.GetAttributeStringArray("targettypes", 
+                conditionElement.GetAttributeStringArray("targettype", Array.Empty<string>())));
 
             foreach (XElement subElement in conditionElement.Elements())
             {
@@ -28,13 +31,18 @@ namespace Barotrauma.Abilities
                     break;
                 }
             }
+
+            if (!targetTypes.Any() && !conditionals.Any())
+            {
+                DebugConsole.ThrowError($"Error in talent \"{characterTalent}\". No target types or conditionals defined - the condition will match any character.");
+            }
         }
 
         protected override bool MatchesConditionSpecific(AbilityObject abilityObject)
         {
             if (abilityObject is IAbilityCharacter abilityCharacter)
             {
-                if (!(abilityCharacter.Character is Character character)) { return false; }
+                if (abilityCharacter.Character is not Character character) { return false; }
                 if (!IsViableTarget(targetTypes, character)) { return false; }
                 foreach (var conditional in conditionals)
                 {

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityConditionals/AbilityConditionData/AbilityConditionCharacterNotLooted.cs

@@ -0,0 +1,19 @@
+namespace Barotrauma.Abilities
+{
+    internal sealed class AbilityConditionCharacterNotLooted : AbilityConditionData
+    {
+        private readonly Identifier identifier;
+
+        public AbilityConditionCharacterNotLooted(CharacterTalent characterTalent, ContentXElement conditionElement) : base(characterTalent, conditionElement)
+        {
+            identifier = conditionElement.GetAttributeIdentifier("identifier", Identifier.Empty);
+        }
+
+        protected override bool MatchesConditionSpecific(AbilityObject abilityObject)
+        {
+            if (abilityObject is not IAbilityCharacter ability) { return false; }
+
+            return !ability.Character.MarkedAsLooted.Contains(identifier);
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityConditionals/AbilityConditionData/AbilityConditionCharacterUnconcious.cs

@@ -0,0 +1,16 @@
+#nullable enable
+
+namespace Barotrauma.Abilities
+{
+    internal sealed class AbilityConditionCharacterUnconcious : AbilityConditionData
+    {
+        public AbilityConditionCharacterUnconcious(CharacterTalent characterTalent, ContentXElement conditionElement) : base(characterTalent, conditionElement) { }
+
+        protected override bool MatchesConditionSpecific(AbilityObject abilityObject)
+        {
+            if (abilityObject is not IAbilityCharacter targetCharacter) { return false; }
+
+            return targetCharacter.Character.IsUnconscious;
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityConditionals/AbilityConditionData/AbilityConditionItem.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Linq;
-using System.Xml.Linq;
 
 namespace Barotrauma.Abilities
 {
@@ -13,6 +12,11 @@ namespace Barotrauma.Abilities
         {
             identifiers = conditionElement.GetAttributeStringArray("identifiers", Array.Empty<string>(), convertToLowerInvariant: true);
             tags = conditionElement.GetAttributeStringArray("tags", Array.Empty<string>(), convertToLowerInvariant: true);
+
+            if (!identifiers.Any() && !tags.Any())
+            {
+                DebugConsole.ThrowError($"Error in talent \"{characterTalent}\". No identifiers or tags defined.");
+            }
         }
 
         protected override bool MatchesConditionSpecific(AbilityObject abilityObject)

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityConditionals/AbilityConditionData/AbilityConditionLocation.cs

@@ -8,6 +8,7 @@ namespace Barotrauma.Abilities
     {
         private readonly bool? hasOutpost;
         private readonly Identifier[] locationIdentifiers;
+        private readonly bool isPositiveReputation;
 
         public AbilityConditionLocation(CharacterTalent characterTalent, ContentXElement conditionElement) : base(characterTalent, conditionElement)
         {
@@ -16,12 +17,19 @@ namespace Barotrauma.Abilities
                 hasOutpost = conditionElement.GetAttributeBool("hasoutpost", false);
             }
             locationIdentifiers = conditionElement.GetAttributeIdentifierArray("locationtype", Array.Empty<Identifier>());
+
+            isPositiveReputation = conditionElement.GetAttributeBool("ispositivereputation", false);
         }
 
         protected override bool MatchesConditionSpecific(AbilityObject abilityObject)
         {
             if (abilityObject is IAbilityLocation abilityLocation)
             {
+                if (isPositiveReputation)
+                {
+                    if (abilityLocation.Location.Reputation.Faction.Reputation.Value <= 0) { return false; }
+                }
+
                 if (locationIdentifiers.Any())
                 {
                     if (!locationIdentifiers.Contains(abilityLocation.Location.Type.Identifier)) { return false; }

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityConditionals/AbilityConditionData/AbilityConditionMission.cs

@@ -1,38 +1,50 @@
 using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
-using System.Xml.Linq;
 
 namespace Barotrauma.Abilities
 {
     class AbilityConditionMission : AbilityConditionData
     {
-        private readonly MissionType missionType;
+        private readonly ImmutableHashSet<MissionType> missionType;
+        private readonly bool isAffiliated;
+
         public AbilityConditionMission(CharacterTalent characterTalent, ContentXElement conditionElement) : base(characterTalent, conditionElement)
         {
-            string missionTypeString = conditionElement.GetAttributeString("missiontype", "None");
-            if (!Enum.TryParse(missionTypeString, out missionType))
+            string[] missionTypeStrings = conditionElement.GetAttributeStringArray("missiontype", new []{ "None" })!;
+            HashSet<MissionType> missionTypes = new HashSet<MissionType>();
+            foreach (string missionTypeString in missionTypeStrings)
             {
-                DebugConsole.ThrowError("Error in AbilityConditionMission \"" + characterTalent.DebugIdentifier + "\" - \"" + missionTypeString + "\" is not a valid mission type.");
-                return;
-            }
-            if (missionType == MissionType.None)
-            {
-                DebugConsole.ThrowError("Error in AbilityConditionMission \"" + characterTalent.DebugIdentifier + "\" - mission type cannot be none.");
-                return;
+                if (!Enum.TryParse(missionTypeString, out MissionType parsedMission) || parsedMission is MissionType.None)
+                {
+                    DebugConsole.ThrowError($"Error in AbilityConditionMission \"{characterTalent.DebugIdentifier}\" - \"{missionTypeString}\" is not a valid mission type.");
+                    return;
+                }
+
+                missionTypes.Add(parsedMission);
             }
+
+            missionType = missionTypes.ToImmutableHashSet();
+            isAffiliated = conditionElement.GetAttributeBool("isaffiliated", false);
         }
 
         protected override bool MatchesConditionSpecific(AbilityObject abilityObject)
         {
-            if ((abilityObject as IAbilityMission)?.Mission is Mission mission)
+            if (abilityObject is IAbilityMission { Mission: { } mission })
             {
-                return mission.Prefab.Type == missionType;
-            }
-            else
-            {
-                LogAbilityConditionError(abilityObject, typeof(IAbilityMission));
-                return false;
+                if (isAffiliated && GameMain.GameSession?.Campaign?.Factions.MaxBy(static f => f.Reputation.Value) is { } highestFaction)
+                {
+                    if (highestFaction.Reputation.Value < 0 || !mission.ReputationRewards.ContainsKey(highestFaction.Reputation.Identifier))
+                    {
+                        return false;
+                    }
+                }
+                return missionType.Contains(mission.Prefab.Type);
             }
+
+            LogAbilityConditionError(abilityObject, typeof(IAbilityMission));
+            return false;
         }
     }
 }

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityConditionals/AbilityConditionData/AbilityConditionReduceAffliction.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Xml.Linq;
 
 namespace Barotrauma.Abilities
 {

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityConditionals/AbilityConditionDataless/AbilityConditionAllyNearby.cs

@@ -0,0 +1,47 @@
+using System;
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma.Abilities
+{
+    internal sealed class AbilityConditionAllyNearby : AbilityConditionDataless
+    {
+        private enum NearbyCharacterTruthy
+        {
+            OneCharacterMatches,
+            NoCharacterMatches
+        }
+
+        private readonly NearbyCharacterTruthy truthyWhen;
+        private readonly float distance;
+
+        public AbilityConditionAllyNearby(CharacterTalent characterTalent, ContentXElement conditionElement) : base(characterTalent, conditionElement)
+        {
+            truthyWhen = conditionElement.GetAttributeEnum("truthywhen", NearbyCharacterTruthy.OneCharacterMatches);
+            distance = conditionElement.GetAttributeFloat("distance", 10f);
+        }
+
+        protected override bool MatchesConditionSpecific()
+        {
+            bool trueCondition = truthyWhen switch
+            {
+                NearbyCharacterTruthy.OneCharacterMatches => true,
+                NearbyCharacterTruthy.NoCharacterMatches => false,
+                _ => throw new ArgumentOutOfRangeException(nameof(truthyWhen))
+            };
+
+            foreach (Character ally in Character.GetFriendlyCrew(character))
+            {
+                if (ally == character) { continue; }
+
+                float distanceToCharacter = Vector2.DistanceSquared(ally.WorldPosition, character.WorldPosition);
+
+                if (distanceToCharacter < distance * distance)
+                {
+                    return trueCondition;
+                }
+            }
+
+            return !trueCondition;
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityConditionals/AbilityConditionDataless/AbilityConditionCrewMemberUnconscious.cs

@@ -0,0 +1,22 @@
+#nullable enable
+
+namespace Barotrauma.Abilities
+{
+    internal sealed class AbilityConditionCrewMemberUnconscious : AbilityConditionDataless
+    {
+        public AbilityConditionCrewMemberUnconscious(CharacterTalent characterTalent, ContentXElement conditionElement) : base(characterTalent, conditionElement) { }
+
+        protected override bool MatchesConditionSpecific()
+        {
+            foreach (Character c in GameSession.GetSessionCrewCharacters(CharacterType.Both))
+            {
+                if (c.IsUnconscious)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityConditionals/AbilityConditionDataless/AbilityConditionHasAffliction.cs

@@ -17,7 +17,7 @@
             {
                 var affliction = character.CharacterHealth.GetAffliction(afflictionIdentifier);
                 if (affliction == null) { return false; }
-                return minimumPercentage <= affliction.Strength / affliction.Prefab.MaxStrength;
+                return affliction.Strength >= affliction.Prefab.ActivationThreshold && minimumPercentage <= affliction.Strength / affliction.Prefab.MaxStrength;
             }
             return false;
         }

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityConditionals/AbilityConditionDataless/AbilityConditionHasItem.cs

@@ -22,7 +22,7 @@ namespace Barotrauma.Abilities
         {
             if (tags.None())
             {
-                return character.GetEquippedItem(null) is Item;
+                return character.GetEquippedItem(null) != null;
             }
 
             if (requireAll)

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityConditionals/AbilityConditionDataless/AbilityConditionHasLevel.cs

@@ -0,0 +1,43 @@
+#nullable enable
+
+using System;
+
+namespace Barotrauma.Abilities
+{
+    internal sealed class AbilityConditionHasLevel : AbilityConditionDataless
+    {
+        private readonly Option<int> matchedLevel;
+        private readonly Option<int> minLevel;
+
+        public AbilityConditionHasLevel(CharacterTalent characterTalent, ContentXElement conditionElement) : base(characterTalent, conditionElement)
+        {
+            matchedLevel = conditionElement.GetAttributeInt("levelequals", 0) is var match and not 0
+                ? Option<int>.Some(match)
+                : Option<int>.None();
+
+            minLevel = conditionElement.GetAttributeInt("minlevel", 0) is var min and not 0
+                ? Option<int>.Some(min)
+                : Option<int>.None();
+
+            if (matchedLevel.IsNone() && minLevel.IsNone())
+            {
+                throw new Exception($"{nameof(AbilityConditionHasLevel)} must have either \"levelequals\" or \"minlevel\" attribute.");
+            }
+        }
+
+        protected override bool MatchesConditionSpecific()
+        {
+            if (matchedLevel.TryUnwrap(out int match))
+            {
+                return character.Info.GetCurrentLevel() == match;
+            }
+
+            if (minLevel.TryUnwrap(out int min))
+            {
+                return character.Info.GetCurrentLevel() >= min;
+            }
+
+            return false;
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityConditionals/AbilityConditionDataless/AbilityConditionHasPermanentStat.cs

@@ -1,13 +1,11 @@
-using System.Linq;
-using System.Xml.Linq;
-
-namespace Barotrauma.Abilities
+namespace Barotrauma.Abilities
 {
     class AbilityConditionHasPermanentStat : AbilityConditionDataless
     {
         private readonly Identifier statIdentifier;
         private readonly StatTypes statType;
         private readonly float min;
+        private readonly PermanentStatPlaceholder placeholder;
 
         public AbilityConditionHasPermanentStat(CharacterTalent characterTalent, ContentXElement conditionElement) : base(characterTalent, conditionElement)
         {
@@ -19,11 +17,14 @@ namespace Barotrauma.Abilities
             string statTypeName = conditionElement.GetAttributeString("stattype", string.Empty);
             statType = string.IsNullOrEmpty(statTypeName) ? StatTypes.None : CharacterAbilityGroup.ParseStatType(statTypeName, characterTalent.DebugIdentifier);
             min = conditionElement.GetAttributeFloat("min", 0f);
+            placeholder = conditionElement.GetAttributeEnum("placeholder", PermanentStatPlaceholder.None);
         }
 
         protected override bool MatchesConditionSpecific()
         {
-            return character.Info.GetSavedStatValue(statType, statIdentifier) >= min;
+            Identifier identifier = CharacterAbilityGivePermanentStat.HandlePlaceholders(placeholder, statIdentifier);
+
+            return character.Info.GetSavedStatValue(statType, identifier) >= min;
         }
     }
 }

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityConditionals/AbilityConditionDataless/AbilityConditionHasTalent.cs

@@ -0,0 +1,19 @@
+
+namespace Barotrauma.Abilities
+{
+    class AbilityConditionHasTalent : AbilityConditionDataless
+    {
+        private readonly Identifier talentIdentifier;
+
+        public AbilityConditionHasTalent(CharacterTalent characterTalent, ContentXElement conditionElement) : base(characterTalent, conditionElement)
+        {
+            talentIdentifier = conditionElement.GetAttributeIdentifier("identifier", Identifier.Empty);
+        }
+
+        protected override bool MatchesConditionSpecific()
+        {
+            bool result = character.HasTalent(talentIdentifier);
+            return result;
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityConditionals/AbilityConditionDataless/AbilityConditionHoldingItem.cs

@@ -0,0 +1,34 @@
+#nullable enable
+using System.Collections.Immutable;
+
+namespace Barotrauma.Abilities;
+
+internal sealed class AbilityConditionHoldingItem : AbilityConditionDataless
+{
+    private readonly ImmutableHashSet<Identifier> tags;
+
+    public AbilityConditionHoldingItem(CharacterTalent characterTalent, ContentXElement conditionElement) : base(characterTalent, conditionElement)
+    {
+        tags = conditionElement.GetAttributeIdentifierImmutableHashSet("tags", ImmutableHashSet<Identifier>.Empty);
+    }
+
+    protected override bool MatchesConditionSpecific()
+    {
+        if (tags.Count is 0)
+        {
+            return HasItemInHand(character, null);
+        }
+
+        foreach (Identifier tag in tags)
+        {
+            if (HasItemInHand(character, tag)) { return true; }
+        }
+
+        return false;
+
+        static bool HasItemInHand(Character character, Identifier? tagOrIdentifier) =>
+            character.GetEquippedItem(tagOrIdentifier?.Value, InvSlotType.RightHand) is not null ||
+            character.GetEquippedItem(tagOrIdentifier?.Value, InvSlotType.LeftHand) is not null;
+
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityConditionals/AbilityConditionDataless/AbilityConditionLowestLevel.cs

@@ -0,0 +1,23 @@
+#nullable enable
+
+namespace Barotrauma.Abilities
+{
+    internal sealed class AbilityConditionLowestLevel : AbilityConditionDataless
+    {
+        public AbilityConditionLowestLevel(CharacterTalent characterTalent, ContentXElement conditionElement) : base(characterTalent, conditionElement) { }
+
+        protected override bool MatchesConditionSpecific()
+        {
+            int ownLevel = character.Info.GetCurrentLevel();
+
+            foreach (Character crew in GameSession.GetSessionCrewCharacters(CharacterType.Both))
+            {
+                if (crew == character) { continue; }
+
+                if (crew.Info.GetCurrentLevel() < ownLevel) { return false; }
+            }
+
+            return true;
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityConditionals/AbilityConditionDataless/AbilityConditionNearbyCharacterCount.cs

@@ -0,0 +1,39 @@
+#nullable enable
+using System;
+using System.Collections.Immutable;
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma.Abilities;
+
+internal sealed class AbilityConditionNearbyCharacterCount : AbilityConditionDataless
+{
+    private readonly float distance;
+    private readonly int count;
+    private readonly ImmutableHashSet<TargetType> targetTypes;
+
+    public AbilityConditionNearbyCharacterCount(CharacterTalent characterTalent, ContentXElement conditionElement) : base(characterTalent, conditionElement)
+    {
+        distance = conditionElement.GetAttributeFloat("distance", 10f);
+        count = conditionElement.GetAttributeInt("count", 1);
+        targetTypes = ParseTargetTypes(conditionElement.GetAttributeStringArray("targettypes", Array.Empty<string>(), convertToLowerInvariant: true)).ToImmutableHashSet();
+    }
+
+    protected override bool MatchesConditionSpecific()
+    {
+        int amountNeeded = count;
+        foreach (Character otherCharacter in Character.CharacterList)
+        {
+            if (character.Submarine != otherCharacter.Submarine) { continue; }
+            if (!IsViableTarget(targetTypes, otherCharacter)) { return false; }
+
+            if (Vector2.DistanceSquared(character.WorldPosition, otherCharacter.WorldPosition) < distance * distance)
+            {
+                amountNeeded--;
+
+                if (amountNeeded <= 0) { return true; }
+            }
+        }
+
+        return false;
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/AbilityObjects.cs

@@ -15,5 +15,4 @@ namespace Barotrauma.Abilities
         }
         public Character Character { get; set; }
     }
-    
 }

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbility.cs

@@ -67,7 +67,7 @@ namespace Barotrauma.Abilities
             if (abilityObject is null)
             {
                 ApplyEffect();
-            } 
+            }
             else
             {
                 ApplyEffect(abilityObject);

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilityApplyStatusEffectToNonHumans.cs

@@ -0,0 +1,35 @@
+#nullable enable
+
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma.Abilities
+{
+    internal sealed class CharacterAbilityApplyStatusEffectToNonHumans : CharacterAbilityApplyStatusEffects
+    {
+        private readonly float maxDistance;
+
+        public CharacterAbilityApplyStatusEffectToNonHumans(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement)
+        {
+            maxDistance = abilityElement.GetAttributeFloat("maxdistance", float.MaxValue);
+        }
+
+        protected override void ApplyEffect()
+        {
+            foreach (Character character in Character.CharacterList)
+            {
+                if (character.IsHuman) { continue; }
+
+                if (maxDistance < float.MaxValue)
+                {
+                    if (Vector2.DistanceSquared(character.WorldPosition, Character.WorldPosition) > maxDistance * maxDistance) { continue; }
+                }
+                ApplyEffectSpecific(character);
+            }
+        }
+
+        protected override void ApplyEffect(AbilityObject abilityObject)
+        {
+            ApplyEffect();
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilityApplyStatusEffects.cs

@@ -17,6 +17,8 @@ namespace Barotrauma.Abilities
 
         readonly List<ISerializableEntity> targets = new List<ISerializableEntity>();
 
+        private bool effectBeingApplied;
+
         public CharacterAbilityApplyStatusEffects(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement)
         {
             statusEffects = CharacterAbilityGroup.ParseStatusEffects(CharacterTalent, abilityElement.GetChildElement("statuseffects"));
@@ -29,44 +31,57 @@ namespace Barotrauma.Abilities
 
         protected void ApplyEffectSpecific(Character targetCharacter)
         {
-            foreach (var statusEffect in statusEffects)
+            //prevent an infinite loop if an effect triggers itself
+            //(e.g. a talent that triggers when an affliction is applied, and applies that same affliction)
+            if (effectBeingApplied) { return; }
+
+            effectBeingApplied = true;
+
+            try
             {
-                if (statusEffect.HasTargetType(StatusEffect.TargetType.UseTarget))
+                foreach (var statusEffect in statusEffects)
                 {
-                    // currently used to spawn items on the targeted character
-                    statusEffect.SetUser(targetCharacter);
-                    statusEffect.Apply(ActionType.OnAbility, EffectDeltaTime, targetCharacter, targetCharacter);
-                }
-                else if (statusEffect.HasTargetType(StatusEffect.TargetType.NearbyCharacters))
-                {
-                    targets.Clear();
-                    targets.AddRange(statusEffect.GetNearbyTargets(targetCharacter.WorldPosition, targets));
-                    if (!nearbyCharactersAppliesToSelf)
+                    if (statusEffect.HasTargetType(StatusEffect.TargetType.UseTarget))
                     {
-                        targets.RemoveAll(c => c == Character);
+                        // currently used to spawn items on the targeted character
+                        statusEffect.SetUser(targetCharacter);
+                        statusEffect.Apply(ActionType.OnAbility, EffectDeltaTime, targetCharacter, targetCharacter);
                     }
-                    if (!nearbyCharactersAppliesToAllies)
+                    else if (statusEffect.HasTargetType(StatusEffect.TargetType.NearbyCharacters))
                     {
-                        targets.RemoveAll(c => c is Character otherCharacter && HumanAIController.IsFriendly(otherCharacter, Character));
+                        targets.Clear();
+                        targets.AddRange(statusEffect.GetNearbyTargets(targetCharacter.WorldPosition, targets));
+                        if (!nearbyCharactersAppliesToSelf)
+                        {
+                            targets.RemoveAll(c => c == Character);
+                        }
+                        if (!nearbyCharactersAppliesToAllies)
+                        {
+                            targets.RemoveAll(c => c is Character otherCharacter && HumanAIController.IsFriendly(otherCharacter, Character));
+                        }
+                        if (!nearbyCharactersAppliesToEnemies)
+                        {
+                            targets.RemoveAll(c => c is Character otherCharacter && !HumanAIController.IsFriendly(otherCharacter, Character));
+                        }
+                        statusEffect.SetUser(Character);
+                        statusEffect.Apply(ActionType.OnAbility, EffectDeltaTime, targetCharacter, targets);
                     }
-                    if (!nearbyCharactersAppliesToEnemies)
+                    else if (statusEffect.HasTargetType(StatusEffect.TargetType.Character))
                     {
-                        targets.RemoveAll(c => c is Character otherCharacter && !HumanAIController.IsFriendly(otherCharacter, Character));
+                        statusEffect.SetUser(Character);
+                        statusEffect.Apply(ActionType.OnAbility, EffectDeltaTime, Character, targetCharacter);
+                    }
+                    else
+                    {
+                        statusEffect.SetUser(Character);
+                        statusEffect.Apply(ActionType.OnAbility, EffectDeltaTime, Character, Character);
                     }
-                    statusEffect.SetUser(Character);
-                    statusEffect.Apply(ActionType.OnAbility, EffectDeltaTime, targetCharacter, targets);
-                }
-                else if (statusEffect.HasTargetType(StatusEffect.TargetType.Character))
-                {
-                    statusEffect.SetUser(Character);
-                    statusEffect.Apply(ActionType.OnAbility, EffectDeltaTime, Character, targetCharacter);
-                }
-                else
-                {
-                    statusEffect.SetUser(Character);
-                    statusEffect.Apply(ActionType.OnAbility, EffectDeltaTime, Character, Character);
                 }
             }
+            finally
+            {
+                effectBeingApplied = false;
+            }
         }
         protected override void ApplyEffect()
         {

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilityApplyStatusEffectsToAllies.cs

@@ -1,4 +1,5 @@
-using Microsoft.Xna.Framework;
+using System.Collections.Immutable;
+using Microsoft.Xna.Framework;
 
 namespace Barotrauma.Abilities
 {
@@ -6,11 +7,15 @@ namespace Barotrauma.Abilities
     {
         private readonly bool allowSelf;
         private readonly float maxDistance = float.MaxValue;
+        private readonly bool inSameRoom;
+        private readonly ImmutableHashSet<Identifier> jobIdentifiers;
 
         public CharacterAbilityApplyStatusEffectsToAllies(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement)
         {
             allowSelf = abilityElement.GetAttributeBool("allowself", true);
             maxDistance = abilityElement.GetAttributeFloat("maxdistance", float.MaxValue);
+            inSameRoom = abilityElement.GetAttributeBool("insameroom", false);
+            jobIdentifiers = abilityElement.GetAttributeIdentifierImmutableHashSet("jobs", ImmutableHashSet<Identifier>.Empty);
         }
 
 
@@ -19,6 +24,27 @@ namespace Barotrauma.Abilities
             foreach (Character character in Character.GetFriendlyCrew(Character))
             {
                 if (!allowSelf && character == Character) { continue; }
+
+                if (!jobIdentifiers.IsEmpty)
+                {
+                    bool hadJob = false;
+                    foreach (Identifier job in jobIdentifiers)
+                    {
+                        if (character.HasJob(job.Value))
+                        {
+                            hadJob = true;
+                            break;
+                        }
+                    }
+
+                    if (!hadJob) { continue;  }
+                }
+
+                if (inSameRoom && !character.IsInSameRoomAs(Character))
+                {
+                    continue;
+                }
+
                 if (maxDistance < float.MaxValue)
                 {
                     if (Vector2.DistanceSquared(character.WorldPosition, Character.WorldPosition) > maxDistance * maxDistance) { continue; }

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilityApplyStatusEffectsToApprenticeship.cs

@@ -0,0 +1,63 @@
+#nullable enable
+
+using System.Collections.Generic;
+using System.Collections.Immutable;
+
+namespace Barotrauma.Abilities
+{
+    internal sealed class CharacterAbilityApplyStatusEffectsToApprenticeship : CharacterAbilityApplyStatusEffects
+    {
+        private readonly bool invert;
+        private readonly ImmutableHashSet<JobPrefab> jobPrefabList = JobPrefab.Prefabs.ToImmutableHashSet();
+
+        public CharacterAbilityApplyStatusEffectsToApprenticeship(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement)
+        {
+            invert = abilityElement.GetAttributeBool("invert", false);
+        }
+
+        protected override void ApplyEffect()
+        {
+            ApplyEffectSpecific(Character);
+            JobPrefab? apprenticeJob = GetApprenticeJob(Character, jobPrefabList);
+            if (apprenticeJob is null)
+            {
+                DebugConsole.ThrowError($"{nameof(CharacterAbilityUnlockApprenticeshipTalentTree)}: Could not find apprentice job for character {Character.Name}");
+                return;
+            }
+
+            foreach (Character character in GameSession.GetSessionCrewCharacters(CharacterType.Both))
+            {
+                JobPrefab? characterJob = character.Info?.Job?.Prefab;
+                if (characterJob is null) { continue; }
+
+                switch (characterJob.Identifier == apprenticeJob.Identifier)
+                {
+                    case true when invert:
+                        continue;
+                    case false when !invert:
+                        continue;
+                }
+
+                ApplyEffectSpecific(character);
+            }
+        }
+
+        protected override void ApplyEffect(AbilityObject abilityObject)
+        {
+            ApplyEffect();
+        }
+
+        public static JobPrefab? GetApprenticeJob(Character character, IReadOnlyCollection<JobPrefab> jobList)
+        {
+            foreach (JobPrefab prefab in jobList)
+            {
+                if (character.Info.GetSavedStatValue(StatTypes.Apprenticeship, prefab.Identifier) > 0)
+                {
+                    return prefab;
+                }
+            }
+
+            return null;
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilityGainSimultaneousSkill.cs

@@ -6,12 +6,15 @@ namespace Barotrauma.Abilities
     class CharacterAbilityGainSimultaneousSkill : CharacterAbility
     {
         private readonly Identifier skillIdentifier;
-        private readonly bool ignoreAbilitySkillGain;
+
+        private readonly bool ignoreAbilitySkillGain,
+                              targetAllies;
 
         public CharacterAbilityGainSimultaneousSkill(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement)
         {
             skillIdentifier = abilityElement.GetAttributeIdentifier("skillidentifier", "");
             ignoreAbilitySkillGain = abilityElement.GetAttributeBool("ignoreabilityskillgain", true);
+            targetAllies = abilityElement.GetAttributeBool("targetallies", false);
         }
 
         protected override void ApplyEffect(AbilityObject abilityObject)
@@ -19,7 +22,20 @@ namespace Barotrauma.Abilities
             if (abilityObject is AbilitySkillGain abilitySkillGain)
             {
                 if (ignoreAbilitySkillGain && abilitySkillGain.GainedFromAbility) { return; }
-                Character.Info?.IncreaseSkillLevel(skillIdentifier, abilitySkillGain.Value, gainedFromAbility: true);
+                Identifier identifier = skillIdentifier == "inherit" ? abilitySkillGain.SkillIdentifier : skillIdentifier;
+
+                if (targetAllies)
+                {
+                    foreach (Character character in Character.GetFriendlyCrew(Character))
+                    {
+                        if (character == Character) { continue; }
+                        Character.Info?.IncreaseSkillLevel(identifier, abilitySkillGain.Value, gainedFromAbility: true);
+                    }
+                }
+                else
+                {
+                    Character.Info?.IncreaseSkillLevel(identifier, abilitySkillGain.Value, gainedFromAbility: true);
+                }
             }
             else
             {

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilityGiveExperience.cs

@@ -0,0 +1,35 @@
+namespace Barotrauma.Abilities;
+
+internal sealed class CharacterAbilityGiveExperience : CharacterAbility
+{
+    public override bool AppliesEffectOnIntervalUpdate => true;
+
+    private readonly int amount;
+
+    public CharacterAbilityGiveExperience(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement)
+    {
+        amount = abilityElement.GetAttributeInt("amount", 0);
+    }
+
+    private void ApplyEffectSpecific(Character targetCharacter)
+    {
+        targetCharacter.Info?.GiveExperience(amount);
+    }
+
+    protected override void ApplyEffect(AbilityObject abilityObject)
+    {
+        if ((abilityObject as IAbilityCharacter)?.Character is { } targetCharacter)
+        {
+            ApplyEffectSpecific(targetCharacter);
+        }
+        else
+        {
+            ApplyEffectSpecific(Character);
+        }
+    }
+
+    protected override void ApplyEffect()
+    {
+        ApplyEffectSpecific(Character);
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilityGiveItemStat.cs

@@ -0,0 +1,31 @@
+#nullable enable
+
+namespace Barotrauma.Abilities
+{
+    internal sealed class CharacterAbilityGiveItemStat : CharacterAbility
+    {
+        private readonly ItemTalentStats stat;
+        private readonly float value;
+
+        public CharacterAbilityGiveItemStat(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement)
+        {
+            stat = abilityElement.GetAttributeEnum("stattype", ItemTalentStats.None);
+            value = abilityElement.GetAttributeFloat("value", 0f);
+        }
+
+        protected override void VerifyState(bool conditionsMatched, float timeSinceLastUpdate)
+        {
+            if (conditionsMatched)
+            {
+                ApplyEffect();
+            }
+        }
+
+        protected override void ApplyEffect(AbilityObject abilityObject)
+        {
+            if (abilityObject is not IAbilityItem ability) { return; }
+
+            ability.Item.StatManager.ApplyStat(stat, value, CharacterTalent);
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilityGiveItemStatToTags.cs

@@ -0,0 +1,39 @@
+#nullable enable
+
+using System.Collections.Immutable;
+
+namespace Barotrauma.Abilities
+{
+    internal sealed class CharacterAbilityGiveItemStatToTags: CharacterAbility
+    {
+        private readonly ItemTalentStats stat;
+        private readonly float value;
+        private readonly ImmutableHashSet<Identifier> tags;
+
+        public CharacterAbilityGiveItemStatToTags(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement)
+        {
+            stat = abilityElement.GetAttributeEnum("stattype", ItemTalentStats.None);
+            value = abilityElement.GetAttributeFloat("value", 0f);
+            tags = abilityElement.GetAttributeIdentifierImmutableHashSet("tags", ImmutableHashSet<Identifier>.Empty);
+        }
+
+        protected override void VerifyState(bool conditionsMatched, float timeSinceLastUpdate)
+        {
+            if (conditionsMatched)
+            {
+                ApplyEffect();
+            }
+        }
+
+        protected override void ApplyEffect()
+        {
+            foreach (Item item in Character.Submarine.GetItems(true))
+            {
+                if (item.HasTag(tags) || tags.Contains(item.Prefab.Identifier))
+                {
+                    item.StatManager.ApplyStat(stat, value, CharacterTalent);
+                }
+            }
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilityGivePermanentStat.cs

@@ -1,11 +1,17 @@
-using Barotrauma.Extensions;
-using System.Xml.Linq;
+using System;
 
 namespace Barotrauma.Abilities
 {
+    public enum PermanentStatPlaceholder
+    {
+        None,
+        LocationName,
+        LocationIndex
+    }
+    
     class CharacterAbilityGivePermanentStat : CharacterAbility
     {
-        private readonly string statIdentifier;
+        private readonly Identifier statIdentifier;
         private readonly StatTypes statType;
         private readonly float value;
         private readonly float maxValue;
@@ -13,6 +19,7 @@ namespace Barotrauma.Abilities
         private readonly bool removeOnDeath;
         private readonly bool giveOnAddingFirstTime;
         private readonly bool setValue;
+        private readonly PermanentStatPlaceholder placeholder;
 
         //private readonly float maximumValue;
         public override bool AllowClientSimulation => true;
@@ -20,7 +27,7 @@ namespace Barotrauma.Abilities
 
         public CharacterAbilityGivePermanentStat(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement)
         {
-            statIdentifier = abilityElement.GetAttributeString("statidentifier", "").ToLowerInvariant();
+            statIdentifier = abilityElement.GetAttributeIdentifier("statidentifier", Identifier.Empty);
             string statTypeName = abilityElement.GetAttributeString("stattype", string.Empty);
             statType = string.IsNullOrEmpty(statTypeName) ? StatTypes.None : CharacterAbilityGroup.ParseStatType(statTypeName, CharacterTalent.DebugIdentifier);
             value = abilityElement.GetAttributeFloat("value", 0f);
@@ -29,6 +36,7 @@ namespace Barotrauma.Abilities
             removeOnDeath = abilityElement.GetAttributeBool("removeondeath", false);
             giveOnAddingFirstTime = abilityElement.GetAttributeBool("giveonaddingfirsttime", characterAbilityGroup.AbilityEffectType == AbilityEffectType.None);
             setValue = abilityElement.GetAttributeBool("setvalue", false);
+            placeholder = abilityElement.GetAttributeEnum("placeholder", PermanentStatPlaceholder.None);
         }
 
         public override void InitializeAbility(bool addingFirstTime)
@@ -51,14 +59,33 @@ namespace Barotrauma.Abilities
 
         private void ApplyEffectSpecific()
         {
+            Identifier identifier = HandlePlaceholders(placeholder, statIdentifier);
             if (targetAllies)
             {
-                Character.GetFriendlyCrew(Character).ForEach(c => c?.Info.ChangeSavedStatValue(statType, value, statIdentifier, removeOnDeath, maxValue: maxValue, setValue: setValue));
+                foreach (Character c in Character.GetFriendlyCrew(Character))
+                {
+                    c?.Info.ChangeSavedStatValue(statType, value, identifier, removeOnDeath, maxValue: maxValue, setValue: setValue);
+                }
             }
             else
             {
-                Character?.Info.ChangeSavedStatValue(statType, value, statIdentifier, removeOnDeath, maxValue: maxValue, setValue: setValue);
+                Character?.Info.ChangeSavedStatValue(statType, value, identifier, removeOnDeath, maxValue: maxValue, setValue: setValue);
             }
         }
+
+        public static Identifier HandlePlaceholders(PermanentStatPlaceholder placeholder, Identifier original)
+        {
+            if (GameMain.GameSession?.Campaign?.Map is not { } map) { return original; }
+
+            switch (placeholder)
+            {
+                case PermanentStatPlaceholder.LocationName when map.CurrentLocation is { } location:
+                    return original.Replace("[placeholder]", location.Name);
+                case PermanentStatPlaceholder.LocationIndex:
+                    return original.Replace("[placeholder]", map.CurrentLocationIndex.ToString());
+            }
+
+            return original;
+        }
     }
 }

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilityGiveReputation.cs

@@ -0,0 +1,31 @@
+#nullable enable
+
+namespace Barotrauma.Abilities
+{
+    internal sealed class CharacterAbilityGiveReputation : CharacterAbility
+    {
+        private readonly Identifier factionIdentifier;
+        private readonly float amount;
+
+        public CharacterAbilityGiveReputation(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement)
+        {
+            factionIdentifier = abilityElement.GetAttributeIdentifier("identifier", Identifier.Empty);
+            amount = abilityElement.GetAttributeFloat("amount", 0f);
+        }
+
+        protected override void ApplyEffect()
+        {
+            if (GameMain.GameSession?.Campaign is not { } campaign) { return; }
+
+            foreach (Faction faction in campaign.Factions)
+            {
+                if (faction.Prefab.Identifier != factionIdentifier) { continue; }
+
+                faction.Reputation.AddReputation(amount);
+                break;
+            }
+        }
+
+        protected override void ApplyEffect(AbilityObject abilityObject) => ApplyEffect();
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilityMarkAsLooted.cs

@@ -0,0 +1,18 @@
+namespace Barotrauma.Abilities
+{
+    internal sealed class  CharacterAbilityMarkAsLooted: CharacterAbility
+    {
+        private readonly Identifier identifier;
+        public CharacterAbilityMarkAsLooted(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement)
+        {
+            identifier = abilityElement.GetAttributeIdentifier("identifier", Identifier.Empty);
+        }
+
+        protected override void ApplyEffect(AbilityObject abilityObject)
+        {
+            if (abilityObject is not IAbilityCharacter { Character: { } character }) { return; }
+
+            character.MarkedAsLooted.Add(identifier);
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilityModifyAffliction.cs

@@ -1,30 +1,36 @@
-using System.Collections.Generic;
-using System.Xml.Linq;
-
-namespace Barotrauma.Abilities
+namespace Barotrauma.Abilities
 {
     class CharacterAbilityModifyAffliction : CharacterAbility
     {
-        private readonly string[] afflictionIdentifiers;
+        private readonly Identifier[] afflictionIdentifiers;
+
+        private readonly Identifier replaceWith;
 
         private readonly float addedMultiplier;
 
         public CharacterAbilityModifyAffliction(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement)
         {
-            afflictionIdentifiers = abilityElement.GetAttributeStringArray("afflictionidentifiers", new string[0], convertToLowerInvariant: true);
+            afflictionIdentifiers = abilityElement.GetAttributeIdentifierArray("afflictionidentifiers", System.Array.Empty<Identifier>());
+            replaceWith = abilityElement.GetAttributeIdentifier("replacewith", Identifier.Empty);
             addedMultiplier = abilityElement.GetAttributeFloat("addedmultiplier", 0f);
         }
 
         protected override void ApplyEffect(AbilityObject abilityObject)
         {
-            if ((abilityObject as IAbilityAffliction)?.Affliction is Affliction affliction)
+            var abilityAffliction = abilityObject as IAbilityAffliction;
+            if (abilityAffliction?.Affliction is Affliction affliction)
             {
-                foreach (string afflictionIdentifier in afflictionIdentifiers)
+                foreach (Identifier afflictionIdentifier in afflictionIdentifiers)
                 {
-                    if (affliction.Identifier == afflictionIdentifier)
+                    if (affliction.Identifier != afflictionIdentifier) { continue; }                    
+                    affliction.Strength *= 1 + addedMultiplier;
+                    if (!replaceWith.IsEmpty)
                     {
-                        affliction.Strength *= 1 + addedMultiplier;
-                    }
+                        if (AfflictionPrefab.Prefabs.TryGet(replaceWith, out AfflictionPrefab afflictionPrefab))
+                        {
+                            abilityAffliction.Affliction = new Affliction(afflictionPrefab, abilityAffliction.Affliction.Strength);
+                        }
+                    }                    
                 }
             }
             else

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilityReduceAffliction.cs

@@ -0,0 +1,27 @@
+#nullable enable
+
+namespace Barotrauma.Abilities
+{
+    internal sealed class CharacterAbilityReduceAffliction : CharacterAbility
+    {
+        private readonly Identifier afflictionId;
+        private readonly float amount;
+
+        public CharacterAbilityReduceAffliction(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement)
+        {
+            afflictionId = abilityElement.GetAttributeIdentifier("afflictionid", abilityElement.GetAttributeIdentifier("affliction", Identifier.Empty));
+            amount = abilityElement.GetAttributeFloat("amount", 0);
+
+            if (afflictionId.IsEmpty)
+            {
+                DebugConsole.ThrowError($"Error in {nameof(CharacterAbilityReduceAffliction)} - affliction identifier not set.");
+            }
+        }
+
+        protected override void ApplyEffect(AbilityObject abilityObject)
+        {
+            if (abilityObject is not IAbilityCharacter character) { return; }
+            character.Character.CharacterHealth.ReduceAfflictionOnAllLimbs(afflictionId, amount);
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilityRemoveRandomIngredient.cs

@@ -0,0 +1,19 @@
+#nullable enable
+
+using Barotrauma.Items.Components;
+
+namespace Barotrauma.Abilities
+{
+    internal sealed class CharacterAbilityRemoveRandomIngredient : CharacterAbility
+    {
+        public CharacterAbilityRemoveRandomIngredient(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement) { }
+
+        protected override void ApplyEffect(AbilityObject abilityObject)
+        {
+            if (abilityObject is not Fabricator.AbilityFabricationItemIngredients { Items.Count: > 0 } ingredients) { return; }
+
+            int randomIndex = Rand.Int(ingredients.Items.Count, Rand.RandSync.Unsynced);
+            ingredients.Items.RemoveAt(randomIndex);
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilityResetPermanentStat.cs

@@ -1,16 +1,15 @@
-using System.Xml.Linq;
-
+
 namespace Barotrauma.Abilities
 {
     class CharacterAbilityResetPermanentStat : CharacterAbility
     {
-        private readonly string statIdentifier;
+        private readonly Identifier statIdentifier;
         public override bool AppliesEffectOnIntervalUpdate => true;
         public override bool AllowClientSimulation => true;
 
         public CharacterAbilityResetPermanentStat(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement)
         {
-            statIdentifier = abilityElement.GetAttributeString("statidentifier", "").ToLowerInvariant();
+            statIdentifier = abilityElement.GetAttributeIdentifier("statidentifier", Identifier.Empty);
         }
         protected override void ApplyEffect(AbilityObject abilityObject)
         {

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilitySetMetadataInt.cs

@@ -0,0 +1,29 @@
+#nullable enable
+
+namespace Barotrauma.Abilities
+{
+    internal sealed class CharacterAbilitySetMetadataInt : CharacterAbility
+    {
+        private readonly Identifier identifier;
+        private readonly int value;
+
+        public CharacterAbilitySetMetadataInt(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement)
+        {
+            identifier = abilityElement.GetAttributeIdentifier("identifier", Identifier.Empty);
+            value = abilityElement.GetAttributeInt("value", 0);
+        }
+
+        protected override void ApplyEffect()
+        {
+            if (identifier == Identifier.Empty) { return; }
+            if (GameMain.GameSession?.Campaign?.CampaignMetadata is not { } metadata) { return; }
+
+            metadata.SetValue(identifier, value);
+        }
+
+        protected override void ApplyEffect(AbilityObject abilityObject)
+        {
+            ApplyEffect();
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CharacterAbilityUnlockTree.cs

@@ -1,29 +0,0 @@
-namespace Barotrauma.Abilities
-{
-    class CharacterAbilityUnlockTree : CharacterAbility
-    {
-        public CharacterAbilityUnlockTree(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement)
-        {
-        }
-
-        public override void InitializeAbility(bool addingFirstTime)
-        {
-            if (!TalentTree.JobTalentTrees.TryGet(Character.Info.Job.Prefab.Identifier, out TalentTree talentTree)) { return; }
-
-            var subTree = talentTree.TalentSubTrees.Find(t => t.AllTalentIdentifiers.Contains(CharacterTalent.Prefab.Identifier));
-            if (subTree == null) { return; }
-            
-            subTree.ForceUnlock = true;
-            if (!addingFirstTime) { return; }
-
-            foreach (var talentId in subTree.AllTalentIdentifiers)
-            {
-                if (talentId == CharacterTalent.Prefab.Identifier) { continue; }
-                if (Character.GiveTalent(talentId))
-                {
-                    Character.Info.AdditionalTalentPoints++;
-                }                
-            }            
-        }
-    }
-}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/Abilities/CustomAbilities/CharacterAbilityTandemFire.cs

@@ -13,21 +13,23 @@ namespace Barotrauma.Abilities
 
         protected override void ApplyEffect()
         {
-            if (!SelectedItemHasTag(Character)) { return; }
+            if (!SelectedItemHasTag(Character, tag)) { return; }
 
             Character closestCharacter = null;
             float closestDistance = squaredMaxDistance;
 
             foreach (Character crewCharacter in Character.GetFriendlyCrew(Character))
             {
-                if (crewCharacter != Character && Vector2.DistanceSquared(Character.SimPosition, Character.GetRelativeSimPosition(crewCharacter)) is float tempDistance && tempDistance < closestDistance)
+                if (crewCharacter != Character && 
+                    Vector2.DistanceSquared(Character.WorldPosition, crewCharacter.WorldPosition) is float tempDistance && tempDistance < closestDistance &&
+                    SelectedItemHasTag(crewCharacter, tag))
                 {
                     closestCharacter = crewCharacter;
                     closestDistance = tempDistance;
                 }
             }
 
-            if (closestCharacter == null || !SelectedItemHasTag(closestCharacter)) { return; }
+            if (closestCharacter == null) { return; }
 
             if (closestDistance < squaredMaxDistance)
             {
@@ -35,7 +37,7 @@ namespace Barotrauma.Abilities
                 ApplyEffectSpecific(closestCharacter);
             }
 
-            bool SelectedItemHasTag(Character character) =>
+            static bool SelectedItemHasTag(Character character, string tag) =>
                 (character.SelectedItem != null && character.SelectedItem.HasTag(tag)) ||
                 (character.SelectedSecondaryItem != null && character.SelectedSecondaryItem.HasTag(tag));
         }

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

@@ -0,0 +1,48 @@
+#nullable enable
+
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using Barotrauma.Extensions;
+
+namespace Barotrauma.Abilities
+{
+    internal sealed class CharacterAbilityUnlockApprenticeshipTalentTree : CharacterAbility
+    {
+        public CharacterAbilityUnlockApprenticeshipTalentTree(CharacterAbilityGroup characterAbilityGroup, ContentXElement abilityElement) : base(characterAbilityGroup, abilityElement) { }
+
+        public override void InitializeAbility(bool addingFirstTime)
+        {
+            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}");
+                return;
+            }
+
+            if (!TalentTree.JobTalentTrees.TryGet(apprentice.Identifier, out TalentTree? talentTree)) { return; }
+
+            HashSet<ImmutableHashSet<Identifier>> talentsTrees = new HashSet<ImmutableHashSet<Identifier>>();
+            foreach (TalentSubTree subTree in talentTree.TalentSubTrees)
+            {
+                if (subTree.Type != TalentTreeType.Specialization) { continue; }
+                talentsTrees.Add(subTree.AllTalentIdentifiers);
+            }
+
+            ImmutableHashSet<Identifier> selectedTalentTree = talentsTrees.GetRandomUnsynced();
+
+            foreach (Identifier identifier in selectedTalentTree)
+            {
+                if (Character.HasTalent(identifier)) { continue; }
+                if (Character.GiveTalent(identifier))
+                {
+                    Character.Info.AdditionalTalentPoints++;
+                }
+            }
+        }
+
+        protected override void ApplyEffect(AbilityObject abilityObject)
+        {
+            ApplyEffect();
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/AbilityGroups/CharacterAbilityGroup.cs

@@ -18,12 +18,15 @@ namespace Barotrauma.Abilities
         protected readonly int maxTriggerCount;
         protected int timesTriggered = 0;
 
-
-        // add support for OR conditions? 
+        // add support for OR conditions?
         protected readonly List<AbilityCondition> abilityConditions = new List<AbilityCondition>();
 
-        // separate dictionaries for each type of characterability?
-        protected readonly List<CharacterAbility> characterAbilities = new List<CharacterAbility>();
+        /// <summary>
+        /// List of abilities that are triggered by this group.
+        /// Fallback abilities are triggered if the conditional fails
+        /// </summary>
+        protected readonly List<CharacterAbility> characterAbilities = new List<CharacterAbility>(),
+                                                  fallbackAbilities = new List<CharacterAbility>();
 
         public CharacterAbilityGroup(AbilityEffectType abilityEffectType, CharacterTalent characterTalent, ContentXElement abilityElementGroup)
         {
@@ -38,6 +41,9 @@ namespace Barotrauma.Abilities
                     case "abilities":
                         LoadAbilities(subElement);
                         break;
+                    case "fallbackabilities":
+                        LoadFallbackAbilities(subElement);
+                        break;
                     case "conditions":
                         LoadConditions(subElement);
                         break;
@@ -47,10 +53,23 @@ namespace Barotrauma.Abilities
 
         public void ActivateAbilityGroup(bool addingFirstTime)
         {
+            if (!CheckActivatingCondition()) { return; }
+
             foreach (var characterAbility in characterAbilities)
             {
                 characterAbility.InitializeAbility(addingFirstTime);
             }
+
+            foreach (var characterAbility in fallbackAbilities)
+            {
+                characterAbility.InitializeAbility(addingFirstTime);
+            }
+        }
+
+        private bool CheckActivatingCondition()
+        {
+            if (AbilityEffectType is not AbilityEffectType.None) { return true; }
+            return !abilityConditions.Any(static abilityCondition => !abilityCondition.MatchesCondition());
         }
 
         public void LoadConditions(ContentXElement conditionElements)
@@ -85,6 +104,17 @@ namespace Barotrauma.Abilities
             characterAbilities.Add(characterAbility);
         }
 
+        public void AddFallbackAbility(CharacterAbility characterAbility)
+        {
+            if (characterAbility == null)
+            {
+                DebugConsole.ThrowError($"Trying to add null ability for talent {CharacterTalent.DebugIdentifier}!");
+                return;
+            }
+
+            fallbackAbilities.Add(characterAbility);
+        }
+
         // XML
         private AbilityCondition ConstructCondition(CharacterTalent characterTalent, ContentXElement conditionElement, bool errorMessages = true)
         {
@@ -135,6 +165,14 @@ namespace Barotrauma.Abilities
             }
         }
 
+        private void LoadFallbackAbilities(ContentXElement abilityElements)
+        {
+            foreach (var abilityElementGroup in abilityElements.Elements())
+            {
+                AddFallbackAbility(ConstructAbility(abilityElementGroup, CharacterTalent));
+            }
+        }
+
         private CharacterAbility ConstructAbility(ContentXElement abilityElement, CharacterTalent characterTalent)
         {
             CharacterAbility newAbility = CharacterAbility.Load(abilityElement, this);

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/AbilityGroups/CharacterAbilityGroupEffect.cs

@@ -1,29 +1,38 @@
-namespace Barotrauma.Abilities
+using System.Collections.Generic;
+
+namespace Barotrauma.Abilities
 {
     class CharacterAbilityGroupEffect : CharacterAbilityGroup
     {
-        public CharacterAbilityGroupEffect(AbilityEffectType abilityEffectType, CharacterTalent characterTalent, ContentXElement abilityElementGroup) : 
+        public CharacterAbilityGroupEffect(AbilityEffectType abilityEffectType, CharacterTalent characterTalent, ContentXElement abilityElementGroup) :
             base(abilityEffectType, characterTalent, abilityElementGroup) { }
 
         public void CheckAbilityGroup(AbilityObject abilityObject)
         {
             if (!IsActive) { return; }
-            if (IsApplicable(abilityObject))
+
+            if (IsOverTriggerCount) { return; }
+
+            List<CharacterAbility> abilities = IsApplicable(abilityObject) ? characterAbilities : fallbackAbilities;
+
+            foreach (CharacterAbility characterAbility in abilities)
             {
-                foreach (var characterAbility in characterAbilities)
+                if (characterAbility.IsViable())
                 {
-                    if (characterAbility.IsViable())
-                    {
-                        characterAbility.ApplyAbilityEffect(abilityObject);
-                    }
+                    characterAbility.ApplyAbilityEffect(abilityObject);
                 }
+            }
+
+            if (abilities.Count > 0)
+            {
                 timesTriggered++;
             }
         }
 
+        private bool IsOverTriggerCount => timesTriggered >= maxTriggerCount;
+
         private bool IsApplicable(AbilityObject abilityObject)
         {
-            if (timesTriggered >= maxTriggerCount) { return false; }
             foreach (var abilityCondition in abilityConditions)
             {
                 if (!abilityCondition.MatchesCondition(abilityObject))
@@ -31,7 +40,8 @@
                     return false;
                 }
             }
+
             return true;
         }
     }
-}
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/AbilityGroups/CharacterAbilityGroupInterval.cs

@@ -1,4 +1,7 @@
-namespace Barotrauma.Abilities
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma.Abilities
 {
     class CharacterAbilityGroupInterval : CharacterAbilityGroup
     {
@@ -9,48 +12,71 @@
         private float effectDelayTimer;
 
 
-        public CharacterAbilityGroupInterval(AbilityEffectType abilityEffectType, CharacterTalent characterTalent, ContentXElement abilityElementGroup) : 
+        public CharacterAbilityGroupInterval(AbilityEffectType abilityEffectType, CharacterTalent characterTalent, ContentXElement abilityElementGroup) :
             base(abilityEffectType, characterTalent, abilityElementGroup)
-        {            
+        {
             // too many overlapping intervals could cause hitching? maybe randomize a little
             interval = abilityElementGroup.GetAttributeFloat("interval", 0f);
             effectDelay = abilityElementGroup.GetAttributeFloat("effectdelay", 0f);
         }
+
         public void UpdateAbilityGroup(float deltaTime)
         {
             if (!IsActive) { return; }
-            TimeSinceLastUpdate += deltaTime;
-            if (TimeSinceLastUpdate >= interval)
-            {
-                bool conditionsMatched = IsApplicable();
-                effectDelayTimer = conditionsMatched ? effectDelayTimer + TimeSinceLastUpdate : 0f;
-                conditionsMatched &= effectDelayTimer >= effectDelay;
 
-                foreach (var characterAbility in characterAbilities)
-                {
-                    if (characterAbility.IsViable())
-                    {
-                        characterAbility.UpdateCharacterAbility(conditionsMatched, TimeSinceLastUpdate);
-                    }
-                }
-                if (conditionsMatched)
-                {
-                    timesTriggered++;
-                }
-                TimeSinceLastUpdate = 0;
+            TimeSinceLastUpdate += deltaTime;
+            if (TimeSinceLastUpdate < interval) { return; }
+
+            bool shouldApplyDelayedEffect;
+            bool conditionsDidntMatch;
+
+            if (AllConditionsMatched())
+            {
+                effectDelayTimer += TimeSinceLastUpdate;
+                shouldApplyDelayedEffect = effectDelayTimer >= effectDelay;
+                conditionsDidntMatch = false;
             }
+            else
+            {
+                effectDelayTimer = 0f;
+                shouldApplyDelayedEffect = false;
+                conditionsDidntMatch = true;
+            }
+
+            bool hasFallbacks = fallbackAbilities.Count > 0;
+
+            List<CharacterAbility> abilitiesToRun =
+                conditionsDidntMatch && hasFallbacks
+                    ? fallbackAbilities
+                    : characterAbilities;
+
+            foreach (var characterAbility in abilitiesToRun)
+            {
+                if (!characterAbility.IsViable()) { continue; }
+
+                characterAbility.UpdateCharacterAbility(
+                    shouldApplyDelayedEffect || conditionsDidntMatch,
+                    TimeSinceLastUpdate);
+            }
+
+            if (shouldApplyDelayedEffect || (conditionsDidntMatch && hasFallbacks))
+            {
+                timesTriggered++;
+            }
+
+            TimeSinceLastUpdate = 0;
         }
-        private bool IsApplicable()
+
+        private bool AllConditionsMatched()
         {
             if (timesTriggered >= maxTriggerCount) { return false; }
+
             foreach (var abilityCondition in abilityConditions)
             {
-                if (!abilityCondition.MatchesCondition())
-                {
-                    return false;
-                }
+                if (!abilityCondition.MatchesCondition()) { return false; }
             }
+
             return true;
         }
     }
-}
+}

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/CharacterTalent.cs

@@ -19,6 +19,7 @@ namespace Barotrauma
 
         // works functionally but a missing recipe is not represented on GUI side. this might be better placed in the character class itself, though it might be fine here as well
         public List<Identifier> UnlockedRecipes { get; } = new List<Identifier>();
+        public List<Identifier> UnlockedStoreItems { get; } = new List<Identifier>();
 
         public CharacterTalent(TalentPrefab talentPrefab, Character character)
         {
@@ -45,7 +46,17 @@ namespace Barotrauma
                         }
                         else
                         {
-                            DebugConsole.ThrowError("No recipe identifier defined for talent " + DebugIdentifier);
+                            DebugConsole.ThrowError($"No recipe identifier defined for talent {DebugIdentifier}");
+                        }
+                        break;
+                    case "addedstoreitem":
+                        if (subElement.GetAttributeIdentifier("itemtag", Identifier.Empty) is { IsEmpty: false } storeItemTag)
+                        {
+                            UnlockedStoreItems.Add(storeItemTag);
+                        }
+                        else
+                        {
+                            DebugConsole.ThrowError($"No store item identifier defined for talent {DebugIdentifier}");
                         }
                         break;
                 }

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/TalentPrefab.cs

@@ -1,6 +1,6 @@
-using System;
-using System.Collections.Generic;
-using System.Xml.Linq;
+#if CLIENT
+using Microsoft.Xna.Framework;
+#endif
 
 namespace Barotrauma
 {
@@ -14,6 +14,10 @@ namespace Barotrauma
 
         public readonly Sprite Icon;
 
+#if CLIENT
+        public readonly Option<Color> ColorOverride;
+#endif
+
         public static readonly PrefabCollection<TalentPrefab> TalentPrefabs = new PrefabCollection<TalentPrefab>();
 
         public ContentXElement ConfigElement
@@ -28,8 +32,22 @@ namespace Barotrauma
 
             DisplayName = TextManager.Get($"talentname.{Identifier}").Fallback(Identifier.Value);
 
-            Description = "";
-            
+            Identifier nameIdentifier = element.GetAttributeIdentifier("nameidentifier", Identifier.Empty);
+            if (!nameIdentifier.IsEmpty)
+            {
+                DisplayName = TextManager.Get(nameIdentifier).Fallback(Identifier.Value);
+            }
+
+            Description = string.Empty;
+
+#if CLIENT
+            Color colorOverride = element.GetAttributeColor("coloroverride", Color.TransparentBlack);
+
+            ColorOverride = colorOverride != Color.TransparentBlack
+                ? Option<Color>.Some(colorOverride)
+                : Option<Color>.None();
+#endif
+
             foreach (var subElement in element.Elements())
             {
                 switch (subElement.Name.ToString().ToLowerInvariant())

Barotrauma/BarotraumaShared/SharedSource/Characters/Talents/TalentTree.cs

@@ -5,7 +5,7 @@ using System.Linq;
 
 namespace Barotrauma
 {
-    class TalentTree : Prefab
+    internal sealed class TalentTree : Prefab
     {
         public enum TalentTreeStageState
         {
@@ -40,16 +40,17 @@ namespace Barotrauma
                 DebugConsole.ThrowError($"No job defined for talent tree in \"{file.Path}\"!");
                 return;
             }
-            
+
             List<TalentSubTree> subTrees = new List<TalentSubTree>();
             foreach (var subTreeElement in element.GetChildElements("subtree"))
             {
                 subTrees.Add(new TalentSubTree(subTreeElement));
             }
+
             TalentSubTrees = subTrees.ToImmutableArray();
             AllTalentIdentifiers = TalentSubTrees.SelectMany(t => t.AllTalentIdentifiers).ToImmutableHashSet();
         }
-        
+
         public bool TalentIsInTree(Identifier talentIdentifier)
         {
             return AllTalentIdentifiers.Contains(talentIdentifier);
@@ -57,29 +58,42 @@ namespace Barotrauma
 
         public static bool IsViableTalentForCharacter(Character character, Identifier talentIdentifier)
         {
-            return IsViableTalentForCharacter(character, talentIdentifier, character?.Info?.UnlockedTalents ?? (ICollection<Identifier>)Array.Empty<Identifier>());
+            return IsViableTalentForCharacter(character, talentIdentifier, character?.Info?.UnlockedTalents ?? (IReadOnlyCollection<Identifier>)Array.Empty<Identifier>());
+        }
+
+        public static bool TalentTreeMeetsRequirements(TalentTree tree, TalentSubTree targetTree, IReadOnlyCollection<Identifier> selectedTalents)
+        {
+            IEnumerable<TalentSubTree> blockingSubTrees = tree.TalentSubTrees.Where(tst => tst.BlockedTrees.Contains(targetTree.Identifier)),
+                                       requiredSubTrees = tree.TalentSubTrees.Where(tst => targetTree.RequiredTrees.Contains(tst.Identifier));
+
+            return requiredSubTrees.All(tst => tst.IsCompleted(selectedTalents)) &&  // check if we meet requirements
+                   !blockingSubTrees.Any(tst => tst.HasAnyTalent(selectedTalents)); // check if any other talent trees are blocking this one
         }
 
         // i hate this function - markus
         // me too - joonas
-        public static TalentTreeStageState GetTalentOptionStageState(Character character, Identifier subTreeIdentifier, int index, List<Identifier> selectedTalents)
+        public static TalentTreeStageState GetTalentOptionStageState(Character character, Identifier subTreeIdentifier, int index, IReadOnlyCollection<Identifier> selectedTalents)
         {
             if (character?.Info?.Job.Prefab is null) { return TalentTreeStageState.Invalid; }
 
             if (!JobTalentTrees.TryGet(character.Info.Job.Prefab.Identifier, out TalentTree talentTree)) { return TalentTreeStageState.Invalid; }
 
-            TalentSubTree subTree = talentTree.TalentSubTrees.FirstOrDefault(tst => tst.Identifier == subTreeIdentifier);
+            TalentSubTree subTree = talentTree!.TalentSubTrees.FirstOrDefault(tst => tst.Identifier == subTreeIdentifier);
+            if (subTree is null) { return TalentTreeStageState.Invalid; }
 
-            if (subTree == null) { return TalentTreeStageState.Invalid; }
+            if (!TalentTreeMeetsRequirements(talentTree, subTree, selectedTalents))
+            {
+                return TalentTreeStageState.Locked;
+            }
 
             TalentOption targetTalentOption = subTree.TalentOptionStages[index];
 
-            if (targetTalentOption.TalentIdentifiers.Any(t => character.HasTalent(t)))
+            if (targetTalentOption.HasEnoughTalents(character.Info))
             {
                 return TalentTreeStageState.Unlocked;
             }
 
-            if (targetTalentOption.TalentIdentifiers.Any(t => selectedTalents.Contains(t)))
+            if (targetTalentOption.HasSelectedTalent(selectedTalents))
             {
                 return TalentTreeStageState.Highlighted;
             }
@@ -91,8 +105,8 @@ namespace Barotrauma
             if (lastindex >= 0)
             {
                 TalentOption lastLatentOption = subTree.TalentOptionStages[lastindex];
-                hasTalentInLastTier = lastLatentOption.TalentIdentifiers.Any(HasTalent);
-                isLastTalentPurchased = lastLatentOption.TalentIdentifiers.Any(t => character.HasTalent(t));
+                hasTalentInLastTier = lastLatentOption.HasEnoughTalents(selectedTalents);
+                isLastTalentPurchased = lastLatentOption.HasEnoughTalents(character.Info);
             }
 
             if (!hasTalentInLastTier)
@@ -108,38 +122,29 @@ namespace Barotrauma
             }
 
             return TalentTreeStageState.Locked;
-
-            bool HasTalent(Identifier talentId)
-            {
-                return selectedTalents.Contains(talentId);
-            }
         }
 
 
-        public static bool IsViableTalentForCharacter(Character character, Identifier talentIdentifier, ICollection<Identifier> selectedTalents)
+        public static bool IsViableTalentForCharacter(Character character, Identifier talentIdentifier, IReadOnlyCollection<Identifier> selectedTalents)
         {
             if (character?.Info?.Job.Prefab == null) { return false; }
-            if (character.Info.GetTotalTalentPoints() - selectedTalents.Count() <= 0) { return false; }
+
+            if (character.Info.GetTotalTalentPoints() - selectedTalents.Count <= 0) { return false; }
 
             if (!JobTalentTrees.TryGet(character.Info.Job.Prefab.Identifier, out TalentTree talentTree)) { return false; }
 
-            foreach (var subTree in talentTree.TalentSubTrees)
+            foreach (var subTree in talentTree!.TalentSubTrees)
             {
-                if (subTree.ForceUnlock && subTree.TalentOptionStages.Any(option => option.TalentIdentifiers.Contains(talentIdentifier))) { return true; }
-
                 foreach (var talentOptionStage in subTree.TalentOptionStages)
                 {
-                    bool hasTalentInThisTier = talentOptionStage.TalentIdentifiers.Any(t => selectedTalents.Contains(t));
+                    bool hasTalentInThisTier = talentOptionStage.HasEnoughTalents(selectedTalents);
                     if (!hasTalentInThisTier)
                     {
                         if (talentOptionStage.TalentIdentifiers.Contains(talentIdentifier))
                         {
-                            return true;
-                        }
-                        else
-                        {
-                            break;
+                            return TalentTreeMeetsRequirements(talentTree, subTree, selectedTalents);
                         }
+                        break;
                     }
                 }
             }
@@ -164,60 +169,119 @@ namespace Barotrauma
                     }
                 }
             }
+
             return viableTalents;
         }
 
         public override void Dispose() { }
     }
 
-    class TalentSubTree
+    internal enum TalentTreeType
+    {
+        Specialization,
+        Primary
+    }
+
+    internal sealed class TalentSubTree
     {
         public Identifier Identifier { get; }
 
         public LocalizedString DisplayName { get; }
 
-        public bool ForceUnlock;
-
         public readonly ImmutableArray<TalentOption> TalentOptionStages;
 
         public readonly ImmutableHashSet<Identifier> AllTalentIdentifiers;
 
+        public readonly TalentTreeType Type;
+        public readonly ImmutableHashSet<Identifier> RequiredTrees;
+        public readonly ImmutableHashSet<Identifier> BlockedTrees;
+
+        public bool IsCompleted(IReadOnlyCollection<Identifier> talents) => TalentOptionStages.All(option => option.HasEnoughTalents(talents));
+        public bool HasAnyTalent(IReadOnlyCollection<Identifier> talents) => TalentOptionStages.Any(option => option.HasSelectedTalent(talents));
+
         public TalentSubTree(ContentXElement subTreeElement)
         {
             Identifier = subTreeElement.GetAttributeIdentifier("identifier", "");
-            DisplayName = TextManager.Get("talenttree." + Identifier).Fallback(Identifier.Value);
+            string nameIdentifier = subTreeElement.GetAttributeString("nameidentifier", string.Empty);
+            if (string.IsNullOrWhiteSpace(nameIdentifier))
+            {
+                nameIdentifier = $"talenttree.{Identifier}";
+            }
+            DisplayName = TextManager.Get($"talenttree.{nameIdentifier}").Fallback(Identifier.Value);
+            Type = subTreeElement.GetAttributeEnum("type", TalentTreeType.Specialization);
+            RequiredTrees = subTreeElement.GetAttributeIdentifierImmutableHashSet("requires", ImmutableHashSet<Identifier>.Empty);
+            BlockedTrees = subTreeElement.GetAttributeIdentifierImmutableHashSet("blocks", ImmutableHashSet<Identifier>.Empty);
             List<TalentOption> talentOptionStages = new List<TalentOption>();
             foreach (var talentOptionsElement in subTreeElement.GetChildElements("talentoptions"))
             {
                 talentOptionStages.Add(new TalentOption(talentOptionsElement, Identifier));
             }
+
             TalentOptionStages = talentOptionStages.ToImmutableArray();
             AllTalentIdentifiers = TalentOptionStages.SelectMany(t => t.TalentIdentifiers).ToImmutableHashSet();
         }
-
     }
 
-    class TalentOption
+    internal readonly struct TalentOption
     {
         private readonly ImmutableHashSet<Identifier> talentIdentifiers;
 
         public IEnumerable<Identifier> TalentIdentifiers => talentIdentifiers;
 
-        public bool HasTalent(Identifier talentIdentifier)
+        public readonly int MaxChosenTalents;
+
+        /// <summary>
+        /// When specified the talent option will show talent with this identifier
+        /// and clicking on it will expand the talent option to show the talents
+        /// </summary>
+        public readonly Option<Identifier> ShowcaseTalent;
+
+        public bool HasEnoughTalents(CharacterInfo character) => CountMatchingTalents(character.UnlockedTalents) >= MaxChosenTalents;
+        public bool HasEnoughTalents(IReadOnlyCollection<Identifier> selectedTalents) => CountMatchingTalents(selectedTalents) >= MaxChosenTalents;
+
+        // No LINQ
+        public bool HasSelectedTalent(IReadOnlyCollection<Identifier> selectedTalents)
         {
-            return talentIdentifiers.Contains(talentIdentifier);
+            foreach (Identifier talent in selectedTalents)
+            {
+                if (talentIdentifiers.Contains(talent))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public int CountMatchingTalents(IReadOnlyCollection<Identifier> talents)
+        {
+            int i = 0;
+            foreach (Identifier talent in talents)
+            {
+                if (talentIdentifiers.Contains(talent))
+                {
+                    i++;
+                }
+            }
+            return i;
         }
 
         public TalentOption(ContentXElement talentOptionsElement, Identifier debugIdentifier)
         {
+            MaxChosenTalents = talentOptionsElement.GetAttributeInt("maxchosentalents", 1);
+
+            Identifier showcaseTalent = talentOptionsElement.GetAttributeIdentifier("showcasetalent", Identifier.Empty);
+            ShowcaseTalent = !showcaseTalent.IsEmpty
+                ? Option<Identifier>.Some(showcaseTalent)
+                : Option<Identifier>.None();
+
             var talentIdentifiers = new HashSet<Identifier>();
             foreach (var talentOptionElement in talentOptionsElement.GetChildElements("talentoption"))
             {
                 Identifier identifier = talentOptionElement.GetAttributeIdentifier("identifier", Identifier.Empty);
                 talentIdentifiers.Add(identifier);
             }
+
             this.talentIdentifiers = talentIdentifiers.ToImmutableHashSet();
         }
     }
-
-}
+}