OBT1.1.0 Merge branch 'dev_pte' into dev

.github/workflows/publish-release.yml

@@ -23,13 +23,16 @@ on:
 env:
   CI_DIR: 2049ef39-42a2-46d2-b513-ee6d2e3a7b15
   RELEASES: |
-    windows:client:Windows/Client
     windows:server:Windows/Server
-    linux:client:Linux/Client
     linux:server:Linux/Server
-    mac:client:Mac/Client/Barotrauma.app/Contents/MacOS
     mac:server:Mac/Server
-  ARCHIVE_BASE_NAME: luacsforbarotrauma
+  ARCHIVE_BASE_NAME: luacsforbarotraumaEP
+
+  # windows:client:Windows/Client
+  # linux:client:Linux/Client
+  # mac:client:Mac/Client/Barotrauma.app/Contents/MacOS
+  # we do not currently provide a CL
+  
   # XXX: these file names are subject to shell expansion.
   # Be careful when using special characters.
   ARCHIVE_FILES_SERVER: |

.gitignore

@@ -60,3 +60,5 @@ Deploy/DeployAll/PrivateKey.*
 #Rider
 *.DotSettings.user
 .vscode/settings.json
+.vscode/launch.json
+.vscode/tasks.json

Barotrauma/BarotraumaClient/ClientSource/Characters/Health/CharacterHealth.cs

@@ -2143,7 +2143,7 @@ namespace Barotrauma
                 if (existingAffliction == null)
                 {
                     existingAffliction = afflictionPrefab.Instantiate(strength);
-                    afflictions.Add(existingAffliction, limb);
+                    afflictions.TryAdd(existingAffliction, limb);
                     newAdded = true;
                 }
                 existingAffliction.SetStrength(strength);

Barotrauma/BarotraumaClient/ClientSource/GameSession/CrewManager.cs

@@ -867,7 +867,7 @@ namespace Barotrauma
                         {
                             foreach (var stackedItem in item.GetStackedItems())
                             {
-                                Item.DeconstructItems.Add(stackedItem);
+                                Item.MarkForDeconstruction(stackedItem);
                             }
                             HintManager.OnItemMarkedForDeconstruction(order.OrderGiver);
                         }
@@ -875,7 +875,7 @@ namespace Barotrauma
                         {
                             foreach (var stackedItem in item.GetStackedItems())
                             {
-                                Item.DeconstructItems.Remove(stackedItem);
+                                Item.UnmarkForDeconstruction(stackedItem);
                             }
                         }
                     }

Barotrauma/BarotraumaClient/ClientSource/Items/Inventory.cs

@@ -1891,7 +1891,7 @@ namespace Barotrauma
                        
                     }
                 }
-                else if (Item.DeconstructItems.Contains(item) &&
+                else if (Item.IsMarkedForDeconstruction(item) &&
                     OrderPrefab.Prefabs.TryGet(Tags.DeconstructThis, out OrderPrefab deconstructOrder))
                 {
                     DrawSideIcon(deconstructOrder.SymbolSprite, Direction.Right, TextManager.Get("tooltip.markedfordeconstruction"), GUIStyle.Red, out bool mouseOn);

Barotrauma/BarotraumaClient/ClientSource/Map/MapEntity.cs

@@ -471,11 +471,11 @@ namespace Barotrauma
 
                         if (item0 == null && item1 != null)
                         {
-                            item0 = Item.ItemList.Find(it => it.GetComponent<ConnectionPanel>()?.DisconnectedWires.Contains(wire) ?? false);
+                            item0 = Item.ItemList.FirstOrDefault(it => it.GetComponent<ConnectionPanel>()?.DisconnectedWires.Contains(wire) ?? false);
                         }
                         else if (item0 != null && item1 == null)
                         {
-                            item1 = Item.ItemList.Find(it => it.GetComponent<ConnectionPanel>()?.DisconnectedWires.Contains(wire) ?? false);
+                            item1 = Item.ItemList.FirstOrDefault(it => it.GetComponent<ConnectionPanel>()?.DisconnectedWires.Contains(wire) ?? false);
                         }
                         if (item0 != null && item1 != null && SelectedList.Contains(item0) && SelectedList.Contains(item1))
                         {

Barotrauma/BarotraumaClient/ClientSource/Sounds/SoundChannel.cs

@@ -503,14 +503,24 @@ namespace Barotrauma.Sounds
                 mutex = new object();
             }
 
+            // Use the playingChannels lock to protect both channel assignment AND OpenAL operations.
+            // This prevents race conditions when multiple threads try to play sounds simultaneously
+            // (e.g., during Parallel.ForEach in MapEntity.UpdateAll).
+            int poolIndex = (int)sound.SourcePoolIndex;
+            object channelsLock = sound.Owner.GetPlayingChannelsLock(sound.SourcePoolIndex);
+
 #if !DEBUG
             try
             {
 #endif
-                if (mutex != null) { Monitor.Enter(mutex); }
-                if (sound.Owner.CountPlayingInstances(sound) < sound.MaxSimultaneousInstances)
+                lock (channelsLock)
                 {
-                    ALSourceIndex = sound.Owner.AssignFreeSourceToChannel(this);
+                    if (mutex != null) { Monitor.Enter(mutex); }
+                    try
+                    {
+                        if (sound.Owner.CountPlayingInstancesUnsafe(sound, poolIndex) < sound.MaxSimultaneousInstances)
+                        {
+                            ALSourceIndex = sound.Owner.AssignFreeSourceToChannelUnsafe(this, poolIndex);
                         }
 
                         if (ALSourceIndex >= 0)
@@ -585,18 +595,18 @@ namespace Barotrauma.Sounds
                                 SetProperties();
                             }
                         }
+                    }
+                    finally
+                    {
+                        if (mutex != null) { Monitor.Exit(mutex); }
+                    }
+                }
 #if !DEBUG
             }
             catch
             {
                 throw;
             }
-            finally
-            {
-#endif
-                if (mutex != null) { Monitor.Exit(mutex); }
-#if !DEBUG
-            }
 #endif
 
             void SetProperties()

Barotrauma/BarotraumaClient/ClientSource/Sounds/SoundManager.cs

@@ -417,6 +417,15 @@ namespace Barotrauma.Sounds
             return sourcePools[(int)poolIndex].ALSources[srcInd];
         }
 
+        /// <summary>
+        /// Gets the lock object for the playing channels array for a specific pool.
+        /// Used to protect OpenAL operations that need to be atomic with channel assignment.
+        /// </summary>
+        public object GetPlayingChannelsLock(SourcePoolIndex poolIndex)
+        {
+            return playingChannels[(int)poolIndex];
+        }
+
         public int AssignFreeSourceToChannel(SoundChannel newChannel)
         {
             if (Disabled) { return -1; }
@@ -427,6 +436,18 @@ namespace Barotrauma.Sounds
 
             lock (playingChannels[poolIndex])
             {
+                return AssignFreeSourceToChannelUnsafe(newChannel, poolIndex);
+            }
+        }
+
+        /// <summary>
+        /// Assigns a free source to a channel without locking. 
+        /// Caller MUST hold the playingChannels[poolIndex] lock before calling this method.
+        /// </summary>
+        public int AssignFreeSourceToChannelUnsafe(SoundChannel newChannel, int poolIndex)
+        {
+            if (Disabled) { return -1; }
+
             for (int i = 0; i < playingChannels[poolIndex].Length; i++)
             {
                 if (playingChannels[poolIndex][i] == null || !playingChannels[poolIndex][i].IsPlaying)
@@ -436,7 +457,6 @@ namespace Barotrauma.Sounds
                     return i;
                 }
             }
-            }
 
             //we couldn't get a free source to assign to this channel!
             return -1;
@@ -476,13 +496,25 @@ namespace Barotrauma.Sounds
             int count = 0;
             lock (playingChannels[(int)sound.SourcePoolIndex])
             {
-                for (int i = 0; i < playingChannels[(int)sound.SourcePoolIndex].Length; i++)
-                {
-                    if (playingChannels[(int)sound.SourcePoolIndex][i] != null && 
-                        playingChannels[(int)sound.SourcePoolIndex][i].Sound.Filename == sound.Filename)
-                    {
-                        if (playingChannels[(int)sound.SourcePoolIndex][i].IsPlaying) { count++; };
+                count = CountPlayingInstancesUnsafe(sound, (int)sound.SourcePoolIndex);
             }
+            return count;
+        }
+
+        /// <summary>
+        /// Counts playing instances without locking.
+        /// Caller MUST hold the playingChannels[poolIndex] lock before calling this method.
+        /// </summary>
+        public int CountPlayingInstancesUnsafe(Sound sound, int poolIndex)
+        {
+            if (Disabled) { return 0; }
+            int count = 0;
+            for (int i = 0; i < playingChannels[poolIndex].Length; i++)
+            {
+                if (playingChannels[poolIndex][i] != null && 
+                    playingChannels[poolIndex][i].Sound.Filename == sound.Filename)
+                {
+                    if (playingChannels[poolIndex][i].IsPlaying) { count++; };
                 }
             }
             return count;

Barotrauma/BarotraumaServer/ServerSource/Networking/Client.cs

@@ -126,7 +126,7 @@ namespace Barotrauma.Networking
                 if (!MathUtils.NearlyEqual(karma, syncedKarma, 10.0f))
                 {
                     syncedKarma = karma;
-                    GameMain.NetworkMember.LastClientListUpdateID++;
+                    GameMain.NetworkMember.IncrementLastClientListUpdateID();
                 }
             }
         }

Barotrauma/BarotraumaServer/ServerSource/Networking/FileTransfer/FileSender.cs

@@ -174,7 +174,7 @@ namespace Barotrauma.Networking
             StartTime = DateTime.Now;
 
             OnStarted(transfer);
-            GameMain.Server.LastClientListUpdateID++;
+            GameMain.Server.IncrementLastClientListUpdateID();
 
             return transfer;
         }
@@ -204,7 +204,7 @@ namespace Barotrauma.Networking
 
             if (numRemoved > 0 || endedTransfers.Count > 0)
             {
-                GameMain.Server.LastClientListUpdateID++;
+                GameMain.Server.IncrementLastClientListUpdateID();
             }
         }
 

Barotrauma/BarotraumaServer/ServerSource/Networking/GameServer.cs

@@ -327,7 +327,7 @@ namespace Barotrauma.Networking
                 }
             }
 
-            LastClientListUpdateID++;
+            IncrementLastClientListUpdateID();
 
             if (newClient.Connection == OwnerConnection && OwnerConnection != null)
             {
@@ -3222,7 +3222,7 @@ namespace Barotrauma.Networking
             initiatedStartGame = false;
             GameMain.ResetFrameTime();
 
-            LastClientListUpdateID++;
+            IncrementLastClientListUpdateID();
 
             roundStartTime = DateTime.Now;
 
@@ -3532,7 +3532,7 @@ namespace Barotrauma.Networking
                 {
                     var coolDownRemaining = Client.NameChangeCoolDown - timeSinceNameChange;
                     SendDirectChatMessage($"ServerMessage.NameChangeFailedCooldownActive~[seconds]={(int)coolDownRemaining.TotalSeconds}", c);
-                    LastClientListUpdateID++;
+                    IncrementLastClientListUpdateID();
                     //increment the ID to make sure the current server-side name is treated as the "latest",
                     //and the client correctly reverts back to the old name
                     c.NameId++;
@@ -3545,7 +3545,7 @@ namespace Barotrauma.Networking
 
             if (result != null)
             {
-                LastClientListUpdateID++;
+                IncrementLastClientListUpdateID();
                 return result.Value;
             }
 
@@ -3562,14 +3562,14 @@ namespace Barotrauma.Networking
                 c.Name = newName;
                 c.RejectedName = string.Empty;
                 SendChatMessage($"ServerMessage.NameChangeSuccessful~[oldname]={oldName}~[newname]={newName}", ChatMessageType.Server);
-                LastClientListUpdateID++;
+                IncrementLastClientListUpdateID();
                 return true;
             }
             else
             {
                 //update client list even if the name cannot be changed to the one sent by the client,
                 //so the client will be informed what their actual name is
-                LastClientListUpdateID++;
+                IncrementLastClientListUpdateID();
                 return false;
             }
         }
@@ -4857,7 +4857,7 @@ namespace Barotrauma.Networking
         private void UpdateClientLobbies()
         {
             // Triggers a call to WriteClientList(), which causes clients to call GameClient.ReadClientList()
-            LastClientListUpdateID++;
+            IncrementLastClientListUpdateID();
         }
 
         private List<Client> GetPlayingClients()

Barotrauma/BarotraumaServer/ServerSource/Networking/KarmaManager.cs

@@ -163,7 +163,7 @@ namespace Barotrauma
                 {
                     client.Character.CharacterHealth.ApplyAffliction(null, new Affliction(herpesAffliction, herpesStrength));
                     GameServer.Log($"{GameServer.ClientLogName(client)} has contracted space herpes due to low karma.", ServerLog.MessageType.Karma);
-                    GameMain.NetworkMember.LastClientListUpdateID++;
+                    GameMain.NetworkMember.IncrementLastClientListUpdateID();
                 }
                 else if (existingAffliction != null)
                 {

Barotrauma/BarotraumaServer/ServerSource/Networking/RespawnManager.cs

@@ -279,7 +279,7 @@ namespace Barotrauma.Networking
             var shuttleGaps = Gap.GapList.FindAll(g => RespawnShuttles.Contains(g.Submarine) && g.ConnectedWall != null);
             shuttleGaps.ForEach(g => Spawner.AddEntityToRemoveQueue(g));
 
-            var dockingPorts = Item.ItemList.FindAll(i => RespawnShuttles.Contains(i.Submarine) && i.GetComponent<DockingPort>() != null);
+            var dockingPorts = Item.ItemList.Where(i => RespawnShuttles.Contains(i.Submarine) && i.GetComponent<DockingPort>() != null).ToList();
             dockingPorts.ForEach(d => d.GetComponent<DockingPort>().Undock());
 
             if (!IsShuttleInsideLevel || DateTime.Now > teamSpecificState.DespawnTime)

Barotrauma/BarotraumaShared/SharedSource/AchievementManager.cs

@@ -156,7 +156,8 @@ namespace Barotrauma
                 Reactor reactor = item.GetComponent<Reactor>();
                 if (reactor != null && reactor.Item.Condition > 0.0f) { roundData.Reactors.Add(reactor); }
             }
-            pathFinder = new PathFinder(WayPoint.WayPointList, false);
+
+            pathFinder = new PathFinder(WayPoint.WayPointList.ToList(), false);
             cachedDistances.Clear();
             
 #if CLIENT
@@ -323,7 +324,7 @@ namespace Barotrauma
 
                 static CachedDistance CalculateNewCachedDistance(Character c)
                 {
-                    pathFinder ??= new PathFinder(WayPoint.WayPointList, false);
+                    pathFinder ??= new PathFinder(WayPoint.WayPointList.ToList(), false);
                     var path = pathFinder.FindPath(ConvertUnits.ToSimUnits(c.WorldPosition), ConvertUnits.ToSimUnits(Submarine.MainSub.WorldPosition));
                     if (path.Unreachable) { return null; }
                     return new CachedDistance(c.WorldPosition, Submarine.MainSub.WorldPosition, path.TotalLength, Timing.TotalTime + Rand.Range(1.0f, 5.0f));

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

@@ -1,13 +1,67 @@
 using Microsoft.Xna.Framework;
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
 using System.Xml.Linq;
 
 namespace Barotrauma
 {
+    /// <summary>
+    /// Thread-safe wrapper for AITarget list operations.
+    /// Uses copy-on-write pattern for lock-free reads.
+    /// </summary>
+    class ThreadSafeAITargetList : IEnumerable<AITarget>
+    {
+        private volatile List<AITarget> _list = new List<AITarget>();
+        private readonly object _writeLock = new object();
+
+        public int Count => _list.Count;
+
+        public void Add(AITarget target)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<AITarget>(_list) { target };
+                Interlocked.Exchange(ref _list, newList);
+            }
+        }
+
+        public bool Remove(AITarget target)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<AITarget>(_list);
+                bool removed = newList.Remove(target);
+                if (removed)
+                {
+                    Interlocked.Exchange(ref _list, newList);
+                }
+                return removed;
+            }
+        }
+
+        public void Clear()
+        {
+            Interlocked.Exchange(ref _list, new List<AITarget>());
+        }
+
+        public bool Contains(AITarget target) => _list.Contains(target);
+
+        public AITarget this[int index] => _list[index];
+
+        public IEnumerator<AITarget> GetEnumerator() => _list.GetEnumerator();
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
+
+        public List<AITarget> ToList() => new List<AITarget>(_list);
+        public AITarget FirstOrDefault(Func<AITarget, bool> predicate) => _list.FirstOrDefault(predicate);
+        public IEnumerable<AITarget> Where(Func<AITarget, bool> predicate) => _list.Where(predicate);
+        public bool Any(Func<AITarget, bool> predicate) => _list.Any(predicate);
+    }
+
     partial class AITarget
     {
-        public static List<AITarget> List = new List<AITarget>();
+        public static ThreadSafeAITargetList List = new ThreadSafeAITargetList();
 
         private Entity entity;
         public Entity Entity

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

@@ -5,6 +5,7 @@ using Microsoft.Xna.Framework;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 
 namespace Barotrauma
 {
@@ -1817,7 +1818,9 @@ namespace Barotrauma
         public static bool HasDivingMask(Character character, float conditionPercentage = 0, bool requireOxygenTank = true) 
             => HasItem(character, Tags.LightDivingGear, out _, requireOxygenTank ? Tags.OxygenSource : Identifier.Empty, conditionPercentage, requireEquipped: true);
 
-        private static List<Item> matchingItems = new List<Item>();
+        // ThreadLocal to ensure thread safety - each thread gets its own list instance
+        private static readonly ThreadLocal<List<Item>> matchingItemsLocal = new ThreadLocal<List<Item>>(() => new List<Item>());
+        private static List<Item> matchingItems => matchingItemsLocal.Value;
 
         /// <summary>
         /// Note: uses a single list for matching items. The item is reused each time when the method is called. So if you use the method twice, and then refer to the first items, you'll actually get the second. 
@@ -1825,15 +1828,16 @@ namespace Barotrauma
         /// </summary>
         public static bool HasItem(Character character, Identifier tagOrIdentifier, out IEnumerable<Item> items, Identifier containedTag = default, float conditionPercentage = 0, bool requireEquipped = false, bool recursive = true, Func<Item, bool> predicate = null)
         {
-            matchingItems.Clear();
-            items = matchingItems;
+            var localMatchingItems = matchingItems;
+            localMatchingItems.Clear();
+            items = localMatchingItems;
             if (character?.Inventory == null) { return false; }
-            matchingItems = character.Inventory.FindAllItems(i => (i.Prefab.Identifier == tagOrIdentifier || i.HasTag(tagOrIdentifier)) &&
+            character.Inventory.FindAllItems(i => (i.Prefab.Identifier == tagOrIdentifier || i.HasTag(tagOrIdentifier)) &&
                 i.ConditionPercentage >= conditionPercentage &&
                 (!requireEquipped || character.HasEquippedItem(i)) &&
-                (predicate == null || predicate(i)), recursive, matchingItems);
-            items = matchingItems;
-            foreach (var item in matchingItems)
+                (predicate == null || predicate(i)), recursive, localMatchingItems);
+            items = localMatchingItems;
+            foreach (var item in localMatchingItems)
             {
                 if (item == null) { continue; }
 

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

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using Barotrauma.IO;
 using System.Linq;
@@ -9,7 +10,8 @@ namespace Barotrauma
 {
     class NPCConversationCollection : Prefab
     {
-        public static readonly Dictionary<LanguageIdentifier, PrefabCollection<NPCConversationCollection>> Collections = new Dictionary<LanguageIdentifier, PrefabCollection<NPCConversationCollection>>();
+        // Thread-safe dictionary for language-based collections
+        public static readonly ConcurrentDictionary<LanguageIdentifier, PrefabCollection<NPCConversationCollection>> Collections = new ConcurrentDictionary<LanguageIdentifier, PrefabCollection<NPCConversationCollection>>();
 
         public readonly LanguageIdentifier Language;
 
@@ -160,7 +162,24 @@ namespace Barotrauma
             return currentFlags;
         }
 
-        private static readonly List<NPCConversation> previousConversations = new List<NPCConversation>();
+        // Thread-safe previous conversations tracking using copy-on-write pattern
+        private static volatile List<NPCConversation> _previousConversations = new List<NPCConversation>();
+        private static readonly object _previousConversationsLock = new object();
+        private static List<NPCConversation> previousConversations => _previousConversations;
+        
+        private static void AddToPreviousConversations(NPCConversation conversation)
+        {
+            lock (_previousConversationsLock)
+            {
+                var newList = new List<NPCConversation>(_previousConversations);
+                newList.Insert(0, conversation);
+                if (newList.Count > MaxPreviousConversations)
+                {
+                    newList.RemoveAt(MaxPreviousConversations);
+                }
+                _previousConversations = newList;
+            }
+        }
         
         public static List<(Character speaker, string line)> CreateRandom(List<Character> availableSpeakers)
         {
@@ -281,8 +300,7 @@ namespace Barotrauma
 
             if (baseConversation == null)
             {
-                previousConversations.Insert(0, selectedConversation);
-                if (previousConversations.Count > MaxPreviousConversations) previousConversations.RemoveAt(MaxPreviousConversations);
+                AddToPreviousConversations(selectedConversation);
             }
             lineList.Add((speaker, selectedConversation.Line));
             CreateConversation(availableSpeakers, assignedSpeakers, selectedConversation, lineList, availableConversations);

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

@@ -119,7 +119,7 @@ namespace Barotrauma
 
         protected override bool CheckObjectiveState()
         {
-            if (item.IgnoreByAI(character) || Item.DeconstructItems.Contains(item))
+            if (item.IgnoreByAI(character) || Item.IsMarkedForDeconstruction(item))
             {
                 Abandon = true;
             }

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

@@ -114,7 +114,7 @@ namespace Barotrauma
                 if (!allowUnloading) { return false; }
                 if (requireValidContainer && !IsValidContainer(item.Container, character)) { return false; }
             }
-            if (ignoreItemsMarkedForDeconstruction && Item.DeconstructItems.Contains(item)) { return false; }
+            if (ignoreItemsMarkedForDeconstruction && Item.IsMarkedForDeconstruction(item)) { return false; }
             if (!item.HasAccess(character)) { return false; }
             if (character != null && !IsItemInsideValidSubmarine(item, character)) { return false; }
             if (item.HasBallastFloraInHull) { return false; }

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

@@ -1,5 +1,6 @@
 #nullable enable
 using Microsoft.Xna.Framework;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using Barotrauma.Items.Components;
@@ -68,8 +69,9 @@ namespace Barotrauma
 
         /// <summary>
         /// When did the character last inspect whether some other character has stolen items on them?
+        /// Thread-safe dictionary for concurrent access.
         /// </summary>
-        private static readonly Dictionary<Character, double> lastInspectionTimes = new Dictionary<Character, double>();
+        private static readonly ConcurrentDictionary<Character, double> lastInspectionTimes = new ConcurrentDictionary<Character, double>();
         
         private const float NormalInspectionInterval = 120.0f;
         private const float CriminalInspectionInterval = 30.0f;

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

@@ -440,7 +440,7 @@ namespace Barotrauma
 
             if (Identifier == Tags.DeconstructThis && item.AllowDeconstruct)
             {
-                if (item.AllowDeconstruct && !Item.DeconstructItems.Contains(item) &&
+                if (item.AllowDeconstruct && !Item.IsMarkedForDeconstruction(item) &&
                     //only allow deconstructing if there are no deconstruction recipes (= deconstructing yields nothing), or deconstruction recipes that
                     (item.Prefab.DeconstructItems.None() ||
                     item.Prefab.DeconstructItems.Any(deconstructItem =>
@@ -454,7 +454,7 @@ namespace Barotrauma
             }
             else if (Identifier == Tags.DontDeconstructThis)
             {
-                if (Item.DeconstructItems.Contains(item)) { return true; }
+                if (Item.IsMarkedForDeconstruction(item)) { return true; }
             }
 
             ImmutableArray<Identifier> targetItems = GetTargetItems(option);

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

@@ -5,8 +5,10 @@ using FarseerPhysics.Dynamics.Contacts;
 using FarseerPhysics.Dynamics.Joints;
 using Microsoft.Xna.Framework;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Xml.Linq;
 using Barotrauma.Extensions;
 using LimbParams = Barotrauma.RagdollParams.LimbParams;
@@ -25,7 +27,33 @@ namespace Barotrauma
         /// </summary>
         const float MaxImpactDamage = 0.1f;
 
-        private static readonly List<Ragdoll> list = new List<Ragdoll>();
+        // Thread-safe list using copy-on-write pattern (ConcurrentBag doesn't support indexer/Remove)
+        private static volatile List<Ragdoll> _list = new List<Ragdoll>();
+        private static readonly object _listLock = new object();
+        private static List<Ragdoll> list => _list;
+        
+        private static void ListAdd(Ragdoll ragdoll)
+        {
+            lock (_listLock)
+            {
+                var newList = new List<Ragdoll>(_list) { ragdoll };
+                Interlocked.Exchange(ref _list, newList);
+            }
+        }
+        
+        private static bool ListRemove(Ragdoll ragdoll)
+        {
+            lock (_listLock)
+            {
+                var newList = new List<Ragdoll>(_list);
+                bool removed = newList.Remove(ragdoll);
+                if (removed)
+                {
+                    Interlocked.Exchange(ref _list, newList);
+                }
+                return removed;
+            }
+        }
 
         struct Impact
         {
@@ -45,7 +73,8 @@ namespace Barotrauma
             }
         }
 
-        private readonly Queue<Impact> impactQueue = new Queue<Impact>();
+        // Thread-safe queue for physics collision callbacks
+        private readonly ConcurrentQueue<Impact> impactQueue = new ConcurrentQueue<Impact>();
 
         protected Hull currentHull;
 
@@ -467,7 +496,7 @@ namespace Barotrauma
 
         public Ragdoll(Character character, string seed, RagdollParams ragdollParams = null)
         {
-            list.Add(this);
+            ListAdd(this);
             this.character = character;
             Recreate(ragdollParams ?? RagdollParams);
         }
@@ -743,12 +772,9 @@ namespace Barotrauma
             if (f2.Body.UserData is not Structure structure)
             {
                 if (!f2.IsSensor)
-                {
-                    lock (impactQueue)
                 {
                     impactQueue.Enqueue(new Impact(f1, f2, contact, velocity));
                 }
-                }
                 return true;
             }
             else if (character.Submarine != null && structure.Submarine != null && character.Submarine != structure.Submarine)
@@ -819,10 +845,7 @@ namespace Barotrauma
                 }
             }
 
-            lock (impactQueue)
-            {
             impactQueue.Enqueue(new Impact(f1, f2, contact, velocity));
-            }
 
             return true;
         }
@@ -1274,9 +1297,8 @@ namespace Barotrauma
         {
             if (!character.Enabled || character.Removed || Frozen || Invalid || Collider == null || Collider.Removed) { return; }
 
-            while (impactQueue.Count > 0)
+            while (impactQueue.TryDequeue(out var impact))
             {
-                var impact = impactQueue.Dequeue();
                 ApplyImpact(impact.F1, impact.F2, impact.LocalNormal, impact.ImpactPos, impact.Velocity);
             }
 
@@ -2325,7 +2347,7 @@ namespace Barotrauma
                 LimbJoints = null;
             }
 
-            list.Remove(this);
+            ListRemove(this);
         }
 
         public static void RemoveAll()

Barotrauma/BarotraumaShared/SharedSource/Characters/Character.cs

@@ -7,10 +7,12 @@ using FarseerPhysics;
 using FarseerPhysics.Dynamics;
 using Microsoft.Xna.Framework;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading;
 using System.Xml.Linq;
 #if SERVER
 using System.Text;
@@ -28,12 +30,70 @@ namespace Barotrauma
 
     public readonly record struct TalentResistanceIdentifier(Identifier ResistanceIdentifier, Identifier TalentIdentifier);
 
+    /// <summary>
+    /// Thread-safe wrapper for character list operations.
+    /// Provides lock-free read operations and synchronized write operations.
+    /// </summary>
+    class ThreadSafeCharacterList : IEnumerable<Character>
+    {
+        private volatile List<Character> _list = new List<Character>();
+        private readonly object _writeLock = new object();
+
+        public int Count => _list.Count;
+
+        public void Add(Character character)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<Character>(_list) { character };
+                Interlocked.Exchange(ref _list, newList);
+            }
+        }
+
+        public bool Remove(Character character)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<Character>(_list);
+                bool removed = newList.Remove(character);
+                if (removed)
+                {
+                    Interlocked.Exchange(ref _list, newList);
+                }
+                return removed;
+            }
+        }
+
+        public void Clear()
+        {
+            Interlocked.Exchange(ref _list, new List<Character>());
+        }
+
+        public bool Contains(Character character) => _list.Contains(character);
+
+        public Character this[int index] => _list[index];
+
+        public IEnumerator<Character> GetEnumerator() => _list.GetEnumerator();
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
+
+        // LINQ-friendly snapshot for complex queries
+        public List<Character> ToList() => new List<Character>(_list);
+        
+        public Character FirstOrDefault(Func<Character, bool> predicate) => _list.FirstOrDefault(predicate);
+        public Character Find(Predicate<Character> predicate) => _list.Find(predicate);
+        public List<Character> FindAll(Predicate<Character> predicate) => _list.FindAll(predicate);
+        public IEnumerable<Character> Where(Func<Character, bool> predicate) => _list.Where(predicate);
+        public bool Any(Func<Character, bool> predicate) => _list.Any(predicate);
+        public bool None(Func<Character, bool> predicate) => !_list.Any(predicate);
+        public int CountWhere(Func<Character, bool> predicate) => _list.Count(predicate);
+    }
+
     partial class Character : Entity, IDamageable, ISerializableEntity, IClientSerializable, IServerPositionSync
     {
-        public static readonly List<Character> CharacterList = new List<Character>();
+        public static readonly ThreadSafeCharacterList CharacterList = new ThreadSafeCharacterList();
 
         public static int CharacterUpdateInterval = 1;
-        private static int characterUpdateTick = 1;
+        private static volatile int characterUpdateTick = 1;
         
         public const float MaxHighlightDistance = 150.0f;
         public const float MaxDragDistance = 200.0f;
@@ -2761,10 +2821,11 @@ namespace Barotrauma
             }
             int itemsPerFrame = IsOnPlayerTeam ? 100 : 10;
             int checkedItemCount = 0;
-            for (int i = 0; i < itemsPerFrame && itemIndex < Item.ItemList.Count; i++, itemIndex++)
+            var cachedItems = Item.GetCachedItemList();
+            for (int i = 0; i < itemsPerFrame && itemIndex < cachedItems.Count; i++, itemIndex++)
             {
                 checkedItemCount++;
-                var item = Item.ItemList[itemIndex];
+                var item = cachedItems[itemIndex];
                 if (!item.IsInteractable(this)) { continue; }
                 if (ignoredItems != null && ignoredItems.Contains(item)) { continue; }
                 if (item.Submarine == null) { continue; }
@@ -2800,10 +2861,10 @@ namespace Barotrauma
                 }
             }
             targetItem = _foundItem;
-            bool completed = itemIndex >= Item.ItemList.Count - 1;
+            bool completed = itemIndex >= cachedItems.Count - 1;
             if (HumanAIController.DebugAI && checkedItemCount > 0 && targetItem != null && StopWatch.ElapsedMilliseconds > 1)
             {
-                var msg = $"Went through {checkedItemCount} of total {Item.ItemList.Count} items. Found item {targetItem.Name} in {StopWatch.ElapsedMilliseconds} ms. Completed: {completed}";
+                var msg = $"Went through {checkedItemCount} of total {cachedItems.Count} items. Found item {targetItem.Name} in {StopWatch.ElapsedMilliseconds} ms. Completed: {completed}";
                 if (StopWatch.ElapsedMilliseconds > 5)
                 {
                     DebugConsole.ThrowError(msg);
@@ -4819,7 +4880,11 @@ namespace Barotrauma
             HealthUpdateInterval = 0.0f;
         }
 
-        private readonly List<ISerializableEntity> targets = new List<ISerializableEntity>();
+        // Thread-static to avoid concurrent modification in parallel item updates
+        [ThreadStatic]
+        private static List<ISerializableEntity> t_statusEffectTargets;
+        private static List<ISerializableEntity> StatusEffectTargets => t_statusEffectTargets ??= new List<ISerializableEntity>();
+
         public void ApplyStatusEffects(ActionType actionType, float deltaTime)
         {
             if (actionType == ActionType.OnEating)
@@ -4848,6 +4913,7 @@ namespace Barotrauma
                     if (statusEffect.HasTargetType(StatusEffect.TargetType.NearbyItems) ||
                         statusEffect.HasTargetType(StatusEffect.TargetType.NearbyCharacters))
                     {
+                        var targets = StatusEffectTargets;
                         targets.Clear();
                         statusEffect.AddNearbyTargets(WorldPosition, targets);
                         statusEffect.Apply(actionType, deltaTime, this, targets);

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

@@ -3,15 +3,13 @@ using Barotrauma.Extensions;
 using Barotrauma.Networking;
 using Microsoft.Xna.Framework;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using System.Threading;
 using System.Xml.Linq;
-using Barotrauma.Networking;
-using Barotrauma.Extensions;
-using System.Globalization;
 using MoonSharp.Interpreter;
-using Barotrauma.Abilities;
 
 namespace Barotrauma
 {
@@ -132,8 +130,9 @@ namespace Barotrauma
 
         private readonly List<LimbHealth> limbHealths = new List<LimbHealth>();
 
-        private readonly Dictionary<Affliction, LimbHealth> afflictions = new Dictionary<Affliction, LimbHealth>();
-        private readonly HashSet<Affliction> irremovableAfflictions = new HashSet<Affliction>();
+        // Thread-safe afflictions dictionary for concurrent access
+        private readonly ConcurrentDictionary<Affliction, LimbHealth> afflictions = new ConcurrentDictionary<Affliction, LimbHealth>();
+        private readonly ConcurrentDictionary<Affliction, byte> irremovableAfflictions = new ConcurrentDictionary<Affliction, byte>();
         private Affliction bloodlossAffliction;
         private Affliction oxygenLowAffliction;
         private Affliction pressureAffliction;
@@ -324,13 +323,13 @@ namespace Barotrauma
 
         private void InitIrremovableAfflictions()
         {
-            irremovableAfflictions.Add(bloodlossAffliction = new Affliction(AfflictionPrefab.Bloodloss, 0.0f));
-            irremovableAfflictions.Add(stunAffliction = new Affliction(AfflictionPrefab.Stun, 0.0f));
-            irremovableAfflictions.Add(pressureAffliction = new Affliction(AfflictionPrefab.Pressure, 0.0f));
-            irremovableAfflictions.Add(oxygenLowAffliction = new Affliction(AfflictionPrefab.OxygenLow, 0.0f));
-            foreach (Affliction affliction in irremovableAfflictions)
+            irremovableAfflictions.TryAdd(bloodlossAffliction = new Affliction(AfflictionPrefab.Bloodloss, 0.0f), 0);
+            irremovableAfflictions.TryAdd(stunAffliction = new Affliction(AfflictionPrefab.Stun, 0.0f), 0);
+            irremovableAfflictions.TryAdd(pressureAffliction = new Affliction(AfflictionPrefab.Pressure, 0.0f), 0);
+            irremovableAfflictions.TryAdd(oxygenLowAffliction = new Affliction(AfflictionPrefab.OxygenLow, 0.0f), 0);
+            foreach (Affliction affliction in irremovableAfflictions.Keys)
             {
-                afflictions.Add(affliction, null);
+                afflictions.TryAdd(affliction, null);
             }
         }
 
@@ -338,7 +337,7 @@ namespace Barotrauma
 
         public IReadOnlyCollection<Affliction> GetAllAfflictions()
         {
-            return afflictions.Keys;
+            return afflictions.Keys.ToList();
         }
 
         public IEnumerable<Affliction> GetAllAfflictions(Func<Affliction, bool> limbHealthFilter)
@@ -503,7 +502,7 @@ namespace Barotrauma
         /// </summary>
         public float GetResistance(AfflictionPrefab afflictionPrefab, LimbType limbType)
         {
-            lock (afflictions) {
+            // ConcurrentDictionary is thread-safe, no lock needed
             // This is a % resistance (0 to 1.0)
             float resistance = 0.0f;
             foreach (KeyValuePair<Affliction, LimbHealth> kvp in afflictions)
@@ -516,7 +515,6 @@ namespace Barotrauma
             // The returned value is calculated to be a % resistance again
             return 1 - ((1 - resistance) * abilityResistanceMultiplier);
         }
-        }
 
         public float GetStatValue(StatTypes statType)
         {
@@ -539,20 +537,25 @@ namespace Barotrauma
             return false;
         }
 
-        private readonly List<Affliction> matchingAfflictions = new List<Affliction>();
+        // Thread-static to avoid concurrent modification in parallel item updates
+        [ThreadStatic]
+        private static List<Affliction> t_matchingAfflictions;
+        private static List<Affliction> MatchingAfflictions => t_matchingAfflictions ??= new List<Affliction>();
 
         public void ReduceAllAfflictionsOnAllLimbs(float amount, ActionType? treatmentAction = null)
         {
+            var matchingAfflictions = MatchingAfflictions;
             matchingAfflictions.Clear();
             matchingAfflictions.AddRange(afflictions.Keys);
 
-            ReduceMatchingAfflictions(amount, treatmentAction);
+            ReduceMatchingAfflictions(matchingAfflictions, amount, treatmentAction);
         }
         
         public void ReduceAfflictionOnAllLimbs(Identifier afflictionIdOrType, float amount, ActionType? treatmentAction = null, Character attacker = null)
         {
             if (afflictionIdOrType.IsEmpty) { throw new ArgumentException($"{nameof(afflictionIdOrType)} is empty"); }
 
+            var matchingAfflictions = MatchingAfflictions;
             matchingAfflictions.Clear();
             foreach (var affliction in afflictions)
             {
@@ -562,7 +565,7 @@ namespace Barotrauma
                 }
             }
 
-            ReduceMatchingAfflictions(amount, treatmentAction, attacker);
+            ReduceMatchingAfflictions(matchingAfflictions, amount, treatmentAction, attacker);
         }
 
         private IEnumerable<Affliction> GetAfflictionsForLimb(Limb targetLimb)
@@ -572,10 +575,11 @@ namespace Barotrauma
         {
             if (targetLimb is null) { throw new ArgumentNullException(nameof(targetLimb)); }
 
+            var matchingAfflictions = MatchingAfflictions;
             matchingAfflictions.Clear();
             matchingAfflictions.AddRange(GetAfflictionsForLimb(targetLimb));
 
-            ReduceMatchingAfflictions(amount, treatmentAction);
+            ReduceMatchingAfflictions(matchingAfflictions, amount, treatmentAction);
         }
 
         public void ReduceAfflictionOnLimb(Limb targetLimb, Identifier afflictionIdOrType, float amount, ActionType? treatmentAction = null, Character attacker = null)
@@ -583,6 +587,7 @@ namespace Barotrauma
             if (afflictionIdOrType.IsEmpty) { throw new ArgumentException($"{nameof(afflictionIdOrType)} is empty"); }
             if (targetLimb is null) { throw new ArgumentNullException(nameof(targetLimb)); }
 
+            var matchingAfflictions = MatchingAfflictions;
             matchingAfflictions.Clear();
             var targetLimbHealth = limbHealths[targetLimb.HealthIndex];
             foreach (var affliction in afflictions)
@@ -593,10 +598,10 @@ namespace Barotrauma
                     matchingAfflictions.Add(affliction.Key);
                 }
             }
-            ReduceMatchingAfflictions(amount, treatmentAction, attacker);
+            ReduceMatchingAfflictions(matchingAfflictions, amount, treatmentAction, attacker);
         }
 
-        private void ReduceMatchingAfflictions(float amount, ActionType? treatmentAction, Character attacker = null)
+        private void ReduceMatchingAfflictions(List<Affliction> matchingAfflictions, float amount, ActionType? treatmentAction, Character attacker = null)
         {
             if (matchingAfflictions.Count == 0) { return; }
 
@@ -683,12 +688,19 @@ namespace Barotrauma
             }
         }
 
-        private readonly static List<Affliction> afflictionsToRemove = new List<Affliction>();
-        private readonly static List<KeyValuePair<Affliction, LimbHealth>> afflictionsToUpdate = new List<KeyValuePair<Affliction, LimbHealth>>();
+        // Thread-static to avoid concurrent modification when multiple characters are updated in parallel
+        [ThreadStatic]
+        private static List<Affliction> t_afflictionsToRemove;
+        [ThreadStatic]
+        private static List<KeyValuePair<Affliction, LimbHealth>> t_afflictionsToUpdate;
+        private static List<Affliction> AfflictionsToRemove => t_afflictionsToRemove ??= new List<Affliction>();
+        private static List<KeyValuePair<Affliction, LimbHealth>> AfflictionsToUpdate => t_afflictionsToUpdate ??= new List<KeyValuePair<Affliction, LimbHealth>>();
+
         public void SetAllDamage(float damageAmount, float bleedingDamageAmount, float burnDamageAmount)
         {
             if (Unkillable || Character.GodMode) { return; }
 
+            var afflictionsToRemove = AfflictionsToRemove;
             afflictionsToRemove.Clear();
             afflictionsToRemove.AddRange(afflictions.Keys.Where(a =>
                     a.Prefab.AfflictionType == AfflictionPrefab.InternalDamage.AfflictionType ||
@@ -696,14 +708,14 @@ namespace Barotrauma
                     a.Prefab.AfflictionType == AfflictionPrefab.Bleeding.AfflictionType));
             foreach (var affliction in afflictionsToRemove)
             {
-                afflictions.Remove(affliction);
+                afflictions.TryRemove(affliction, out _);
             }
 
             foreach (LimbHealth limbHealth in limbHealths)
             {
-                if (damageAmount > 0.0f) { afflictions.Add(AfflictionPrefab.InternalDamage.Instantiate(damageAmount), limbHealth); }
-                if (bleedingDamageAmount > 0.0f && DoesBleed) { afflictions.Add(AfflictionPrefab.Bleeding.Instantiate(bleedingDamageAmount), limbHealth); }
-                if (burnDamageAmount > 0.0f) { afflictions.Add(AfflictionPrefab.Burn.Instantiate(burnDamageAmount), limbHealth); }
+                if (damageAmount > 0.0f) { afflictions.TryAdd(AfflictionPrefab.InternalDamage.Instantiate(damageAmount), limbHealth); }
+                if (bleedingDamageAmount > 0.0f && DoesBleed) { afflictions.TryAdd(AfflictionPrefab.Bleeding.Instantiate(bleedingDamageAmount), limbHealth); }
+                if (burnDamageAmount > 0.0f) { afflictions.TryAdd(AfflictionPrefab.Burn.Instantiate(burnDamageAmount), limbHealth); }
             }
             
             RecalculateVitality();
@@ -739,26 +751,28 @@ namespace Barotrauma
 
         public void RemoveAfflictions(Func<Affliction, bool> predicate)
         {
+            var afflictionsToRemove = AfflictionsToRemove;
             afflictionsToRemove.Clear();
             afflictionsToRemove.AddRange(afflictions.Keys.Where(affliction => predicate(affliction)));
             foreach (var affliction in afflictionsToRemove)
             {
-                afflictions.Remove(affliction);
+                afflictions.TryRemove(affliction, out _);
             }
             CalculateVitality();
         }
 
         public void RemoveAllAfflictions()
         {
+            var afflictionsToRemove = AfflictionsToRemove;
             afflictionsToRemove.Clear();
-            afflictionsToRemove.AddRange(afflictions.Keys.Where(a => !irremovableAfflictions.Contains(a))); 
+            afflictionsToRemove.AddRange(afflictions.Keys.Where(a => !irremovableAfflictions.ContainsKey(a))); 
             foreach (var affliction in afflictionsToRemove)
             {
                 //set strength to 0 in case the affliction needs to react to becoming inactive
                 affliction.Strength = 0.0f;
-                afflictions.Remove(affliction);
+                afflictions.TryRemove(affliction, out _);
             }
-            foreach (Affliction affliction in irremovableAfflictions)
+            foreach (Affliction affliction in irremovableAfflictions.Keys)
             {
                 affliction.Strength = 0.0f;
             }
@@ -767,17 +781,18 @@ namespace Barotrauma
 
         public void RemoveNegativeAfflictions()
         {
+            var afflictionsToRemove = AfflictionsToRemove;
             afflictionsToRemove.Clear();
             afflictionsToRemove.AddRange(afflictions.Keys.Where(a => 
-                !irremovableAfflictions.Contains(a) && 
+                !irremovableAfflictions.ContainsKey(a) && 
                 !a.Prefab.IsBuff && 
                 a.Prefab.AfflictionType != "geneticmaterialbuff" && 
                 a.Prefab.AfflictionType != "geneticmaterialdebuff"));
             foreach (var affliction in afflictionsToRemove)
             {
-                afflictions.Remove(affliction);
+                afflictions.TryRemove(affliction, out _);
             }
-            foreach (Affliction affliction in irremovableAfflictions)
+            foreach (Affliction affliction in irremovableAfflictions.Keys)
             {
                 affliction.Strength = 0.0f;
             }
@@ -869,7 +884,7 @@ namespace Barotrauma
             var copyAffliction = newAffliction.Prefab.Instantiate(
                 Math.Min(newAffliction.Prefab.MaxStrength, newAffliction.Strength * (100.0f / MaxVitality) * (1f - GetResistance(newAffliction.Prefab, limbType))),
                 newAffliction.Source);
-            afflictions.Add(copyAffliction, limbHealth);
+            afflictions.TryAdd(copyAffliction, limbHealth);
             AchievementManager.OnAfflictionReceived(copyAffliction, Character);
             MedicalClinic.OnAfflictionCountChanged(Character);
 
@@ -906,6 +921,8 @@ namespace Barotrauma
 
             if (!Character.GodMode) 
             {
+                var afflictionsToRemove = AfflictionsToRemove;
+                var afflictionsToUpdate = AfflictionsToUpdate;
                 afflictionsToRemove.Clear();
                 afflictionsToUpdate.Clear();
                 foreach (KeyValuePair<Affliction, LimbHealth> kvp in afflictions)
@@ -914,7 +931,7 @@ namespace Barotrauma
                     if (affliction.Strength <= 0.0f)
                     {
                         AchievementManager.OnAfflictionRemoved(affliction, Character);
-                        if (!irremovableAfflictions.Contains(affliction)) { afflictionsToRemove.Add(affliction); }
+                        if (!irremovableAfflictions.ContainsKey(affliction)) { afflictionsToRemove.Add(affliction); }
                         continue;
                     }
                     if (affliction.Prefab.Duration > 0.0f)
@@ -952,7 +969,7 @@ namespace Barotrauma
 
                 foreach (var affliction in afflictionsToRemove)
                 {
-                    afflictions.Remove(affliction);
+                    afflictions.TryRemove(affliction, out _);
                 }
 
                 if (afflictionsToRemove.Count is not 0)
@@ -1200,9 +1217,14 @@ namespace Barotrauma
             return (causeOfDeath, strongestAffliction);
         }
 
-        private readonly List<Affliction> allAfflictions = new List<Affliction>();
+        // Thread-static to avoid concurrent modification in parallel item updates
+        [ThreadStatic]
+        private static List<Affliction> t_allAfflictions;
+        private static List<Affliction> AllAfflictionsList => t_allAfflictions ??= new List<Affliction>();
+
         private IEnumerable<Affliction> GetAllAfflictions(bool mergeSameAfflictions, Func<Affliction, bool> predicate = null)
         {
+            var allAfflictions = AllAfflictionsList;
             allAfflictions.Clear();
             if (!mergeSameAfflictions)
             {
@@ -1385,10 +1407,17 @@ namespace Barotrauma
             return MathHelper.Clamp(strength, 0.0f, affliction.Prefab.MaxStrength);
         }
 
-        private readonly List<Affliction> activeAfflictions = new List<Affliction>();
-        private readonly List<(LimbHealth limbHealth, Affliction affliction)> limbAfflictions = new List<(LimbHealth limbHealth, Affliction affliction)>();
+        // Thread-static to avoid concurrent modification in parallel updates
+        [ThreadStatic]
+        private static List<Affliction> t_activeAfflictions;
+        [ThreadStatic]
+        private static List<(LimbHealth limbHealth, Affliction affliction)> t_limbAfflictions;
+        private static List<Affliction> ActiveAfflictionsList => t_activeAfflictions ??= new List<Affliction>();
+        private static List<(LimbHealth limbHealth, Affliction affliction)> LimbAfflictionsList => t_limbAfflictions ??= new List<(LimbHealth limbHealth, Affliction affliction)>();
+
         public void ServerWrite(IWriteMessage msg)
         {
+            var activeAfflictions = ActiveAfflictionsList;
             activeAfflictions.Clear();
             foreach (KeyValuePair<Affliction, LimbHealth> kvp in afflictions)
             {
@@ -1414,6 +1443,7 @@ namespace Barotrauma
                 }
             }
 
+            var limbAfflictions = LimbAfflictionsList;
             limbAfflictions.Clear();
             foreach (KeyValuePair<Affliction, LimbHealth> kvp in afflictions)
             {
@@ -1443,8 +1473,9 @@ namespace Barotrauma
         public void Remove()
         {
             RemoveProjSpecific();
-            afflictionsToRemove.Clear();
-            afflictionsToUpdate.Clear();
+            // Clear thread-static lists to help with garbage collection
+            AfflictionsToRemove.Clear();
+            AfflictionsToUpdate.Clear();
         }
 
         partial void RemoveProjSpecific();
@@ -1519,14 +1550,14 @@ namespace Barotrauma
                 }
                 if (afflictionPredicate != null && !afflictionPredicate.Invoke(afflictionPrefab)) { return; }
                 float strength = afflictionElement.GetAttributeFloat("strength", 0.0f);
-                var irremovableAffliction = irremovableAfflictions.FirstOrDefault(a => a.Prefab == afflictionPrefab);
+                var irremovableAffliction = irremovableAfflictions.Keys.FirstOrDefault(a => a.Prefab == afflictionPrefab);
                 if (irremovableAffliction != null)
                 {
                     irremovableAffliction.Strength = strength;
                 }
                 else
                 {
-                    afflictions.Add(afflictionPrefab.Instantiate(strength), limbHealth);
+                    afflictions.TryAdd(afflictionPrefab.Instantiate(strength), limbHealth);
                 }
             }
         }

Barotrauma/BarotraumaShared/SharedSource/Characters/Limb.cs

@@ -797,16 +797,14 @@ namespace Barotrauma
             return AddDamage(simPosition, afflictions, playSound);
         }
 
-        private readonly List<DamageModifier> appliedDamageModifiers = new List<DamageModifier>();
-        private readonly List<DamageModifier> tempModifiers = new List<DamageModifier>();
-        private readonly List<Affliction> afflictionsCopy = new List<Affliction>();
+        // Thread-safe: using local variables instead of instance fields to avoid concurrent modification
         public AttackResult AddDamage(Vector2 simPosition, IEnumerable<Affliction> afflictions, bool playSound, float damageMultiplier = 1, float penetration = 0f, Character attacker = null)
         {
-            appliedDamageModifiers.Clear();
-            afflictionsCopy.Clear();
+            var appliedDamageModifiers = new List<DamageModifier>();
+            var afflictionsCopy = new List<Affliction>();
             foreach (var affliction in afflictions)
             {
-                tempModifiers.Clear();
+                var tempModifiers = new List<DamageModifier>();
                 var newAffliction = affliction;
                 float random = Rand.Value(Rand.RandSync.Unsynced);
                 bool foundMatchingModifier = false;
@@ -1022,13 +1020,18 @@ namespace Barotrauma
 
         partial void UpdateProjSpecific(float deltaTime);
 
-        private readonly List<Body> contactBodies = new List<Body>();
+        // Thread-static to avoid concurrent modification in parallel item updates
+        [ThreadStatic]
+        private static List<Body> t_contactBodies;
+        private static List<Body> ContactBodies => t_contactBodies ??= new List<Body>();
+
         /// <summary>
         /// Returns true if the attack successfully hit something. If the distance is not given, it will be calculated.
         /// </summary>
         public bool UpdateAttack(float deltaTime, Vector2 attackSimPos, IDamageable damageTarget, out AttackResult attackResult, float distance = -1, Limb targetLimb = null)
         {
             attackResult = default;
+            var contactBodies = ContactBodies;
             Vector2 simPos = ragdoll.SimplePhysicsEnabled ? character.SimPosition : SimPosition;
             float dist = distance > -1 ? distance : ConvertUnits.ToDisplayUnits(Vector2.Distance(simPos, attackSimPos));
             bool wasRunning = attack.IsRunning;
@@ -1287,7 +1290,11 @@ namespace Barotrauma
             }
         }
 
-        private readonly List<ISerializableEntity> targets = new List<ISerializableEntity>();
+        // Thread-static to avoid concurrent modification in parallel item updates
+        [ThreadStatic]
+        private static List<ISerializableEntity> t_statusEffectTargets;
+        private static List<ISerializableEntity> StatusEffectTargets => t_statusEffectTargets ??= new List<ISerializableEntity>();
+
         public void ApplyStatusEffects(ActionType actionType, float deltaTime)
         {
             if (!statusEffects.TryGetValue(actionType, out var statusEffectList)) { return; }
@@ -1310,6 +1317,7 @@ namespace Barotrauma
                 if (statusEffect.HasTargetType(StatusEffect.TargetType.NearbyItems) ||
                     statusEffect.HasTargetType(StatusEffect.TargetType.NearbyCharacters))
                 {
+                    var targets = StatusEffectTargets;
                     targets.Clear();
                     statusEffect.AddNearbyTargets(WorldPosition, targets);
                     statusEffect.Apply(actionType, deltaTime, character, targets);

Barotrauma/BarotraumaShared/SharedSource/Characters/Params/Animation/AnimationParams.cs

@@ -1,10 +1,12 @@
 using Microsoft.Xna.Framework;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Globalization;
 using Barotrauma.IO;
 using System;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading;
 using System.Xml.Linq;
 using Barotrauma.Extensions;
 
@@ -117,8 +119,9 @@ namespace Barotrauma
         public virtual AnimationType AnimationType { get; protected set; }
         /// <summary>
         /// The cached animations of all the characters that have been loaded.
+        /// Thread-safe cache using ConcurrentDictionary.
         /// </summary>
-        private static readonly Dictionary<Identifier, Dictionary<string, AnimationParams>> allAnimations = new Dictionary<Identifier, Dictionary<string, AnimationParams>>();
+        private static readonly ConcurrentDictionary<Identifier, ConcurrentDictionary<string, AnimationParams>> allAnimations = new ConcurrentDictionary<Identifier, ConcurrentDictionary<string, AnimationParams>>();
 
         [Header("Movement")]
         [Serialize(1.0f, IsPropertySaveable.Yes), Editable(DecimalCount = 2, MinValueFloat = 0, MaxValueFloat = Ragdoll.MAX_SPEED, ValueStep = 0.1f)]
@@ -244,7 +247,9 @@ namespace Barotrauma
             return GetAnimParams<T>(speciesName, animSpecies, fallbackSpecies: character.Prefab.GetBaseCharacterSpeciesName(speciesName), animType, file, throwErrors);
         }
         
-        private static readonly List<string> errorMessages = new List<string>();
+        // ThreadLocal for thread-safe error message collection during animation loading
+        private static readonly ThreadLocal<List<string>> errorMessagesLocal = new ThreadLocal<List<string>>(() => new List<string>());
+        private static List<string> errorMessages => errorMessagesLocal.Value;
 
         private static T GetAnimParams<T>(Identifier speciesName, Identifier animSpecies, Identifier fallbackSpecies, AnimationType animType, Either<string, ContentPath> file, bool throwErrors = true) where T : AnimationParams, new()
         {
@@ -262,11 +267,7 @@ namespace Barotrauma
             }
             ContentPackage contentPackage = contentPath?.ContentPackage ?? CharacterPrefab.FindBySpeciesName(speciesName)?.ContentPackage;
             Debug.Assert(contentPackage != null);
-            if (!allAnimations.TryGetValue(speciesName, out Dictionary<string, AnimationParams> animations))
-            {
-                animations = new Dictionary<string, AnimationParams>();
-                allAnimations.Add(speciesName, animations);
-            }
+            var animations = allAnimations.GetOrAdd(speciesName, _ => new ConcurrentDictionary<string, AnimationParams>());
             string key = fileName ?? contentPath?.Value ?? GetDefaultFileName(animSpecies, animType);
             if (animations.TryGetValue(key, out AnimationParams anim) && anim.AnimationType == animType)
             {
@@ -418,16 +419,12 @@ namespace Barotrauma
             {
                 throw new Exception("Cannot create an animation file of type " + animationType);
             }
-            if (!allAnimations.TryGetValue(speciesName, out Dictionary<string, AnimationParams> anims))
-            {
-                anims = new Dictionary<string, AnimationParams>();
-                allAnimations.Add(speciesName, anims);
-            }
+            var anims = allAnimations.GetOrAdd(speciesName, _ => new ConcurrentDictionary<string, AnimationParams>());
             string fileName = IO.Path.GetFileNameWithoutExtension(fullPath);
             if (anims.ContainsKey(fileName))
             {
                 DebugConsole.NewMessage($"[AnimationParams] Removing the old animation of type {animationType}.", Color.Red);
-                anims.Remove(fileName);
+                anims.TryRemove(fileName, out _);
             }
             var instance = new T();
             XElement animationElement = new XElement(GetDefaultFileName(speciesName, animationType), new XAttribute("animationtype", animationType.ToString()));
@@ -439,7 +436,7 @@ namespace Barotrauma
             instance.IsLoaded = instance.Deserialize(animationElement);
             instance.Save();
             instance.Load(contentPath, speciesName);
-            anims.Add(fileName, instance);
+            anims.TryAdd(fileName, instance);
             DebugConsole.NewMessage($"[AnimationParams] New animation file of type {animationType} created.", Color.GhostWhite);
             return instance;
         }
@@ -467,17 +464,14 @@ namespace Barotrauma
             {
                 // Update the key by removing and re-adding the animation.
                 string fileName = FileNameWithoutExtension;
-                if (allAnimations.TryGetValue(SpeciesName, out Dictionary<string, AnimationParams> animations))
+                if (allAnimations.TryGetValue(SpeciesName, out ConcurrentDictionary<string, AnimationParams> animations))
                 {
-                    animations.Remove(fileName);
+                    animations.TryRemove(fileName, out _);
                 }
                 base.UpdatePath(newPath);
                 if (animations != null)
                 {
-                    if (!animations.ContainsKey(fileName))
-                    {
-                        animations.Add(fileName, this);
-                    }
+                    animations.TryAdd(fileName, this);
                 }
             }
         }

Barotrauma/BarotraumaShared/SharedSource/Characters/Params/Ragdoll/RagdollParams.cs

@@ -1,5 +1,6 @@
 using Microsoft.Xna.Framework;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Xml.Linq;
@@ -124,8 +125,9 @@ namespace Barotrauma
         /// key1: Species name
         /// key2: File path
         /// value: Ragdoll parameters
+        /// Thread-safe cache using ConcurrentDictionary.
         /// </summary>
-        private static readonly Dictionary<Identifier, Dictionary<string, RagdollParams>> allRagdolls = new Dictionary<Identifier, Dictionary<string, RagdollParams>>();
+        private static readonly ConcurrentDictionary<Identifier, ConcurrentDictionary<string, RagdollParams>> allRagdolls = new ConcurrentDictionary<Identifier, ConcurrentDictionary<string, RagdollParams>>();
 
         public List<ColliderParams> Colliders { get; private set; } = new List<ColliderParams>();
         public List<LimbParams> Limbs { get; private set; } = new List<LimbParams>();
@@ -222,11 +224,7 @@ namespace Barotrauma
                 Debug.Assert(!fileName.IsNullOrWhiteSpace() || !contentPath.IsNullOrWhiteSpace());
             }
             Debug.Assert(contentPackage != null);
-            if (!allRagdolls.TryGetValue(speciesName, out Dictionary<string, RagdollParams> ragdolls))
-            {
-                ragdolls = new Dictionary<string, RagdollParams>();
-                allRagdolls.Add(speciesName, ragdolls);
-            }
+            var ragdolls = allRagdolls.GetOrAdd(speciesName, _ => new ConcurrentDictionary<string, RagdollParams>());
             string key = fileName ?? contentPath?.Value ?? GetDefaultFileName(ragdollSpecies);
             if (ragdolls.TryGetValue(key, out RagdollParams ragdoll))
             {
@@ -331,10 +329,10 @@ namespace Barotrauma
             if (allRagdolls.ContainsKey(speciesName))
             {
                 DebugConsole.NewMessage($"[RagdollParams] Removing the old ragdolls from {speciesName}.", Color.Red);
-                allRagdolls.Remove(speciesName);
+                allRagdolls.TryRemove(speciesName, out _);
             }
-            var ragdolls = new Dictionary<string, RagdollParams>();
-            allRagdolls.Add(speciesName, ragdolls);
+            var ragdolls = new ConcurrentDictionary<string, RagdollParams>();
+            allRagdolls.TryAdd(speciesName, ragdolls);
             var instance = new T
             {
                 doc = new XDocument(mainElement)
@@ -345,7 +343,7 @@ namespace Barotrauma
             instance.IsLoaded = instance.Deserialize(mainElement);
             instance.Save();
             instance.Load(contentPath, speciesName);
-            ragdolls.Add(instance.FileNameWithoutExtension, instance);
+            ragdolls.TryAdd(instance.FileNameWithoutExtension, instance);
             DebugConsole.NewMessage("[RagdollParams] New default ragdoll params successfully created at " + fullPath, Color.NavajoWhite);
             return instance;
         }
@@ -362,17 +360,14 @@ namespace Barotrauma
             {
                 // Update the key by removing and re-adding the ragdoll.
                 string fileName = FileNameWithoutExtension;
-                if (allRagdolls.TryGetValue(SpeciesName, out Dictionary<string, RagdollParams> ragdolls))
+                if (allRagdolls.TryGetValue(SpeciesName, out ConcurrentDictionary<string, RagdollParams> ragdolls))
                 {
-                    ragdolls.Remove(fileName);
+                    ragdolls.TryRemove(fileName, out _);
                 }
                 base.UpdatePath(fullPath);
                 if (ragdolls != null)
                 {
-                    if (!ragdolls.ContainsKey(fileName))
-                    {
-                        ragdolls.Add(fileName, this);
-                    }
+                    ragdolls.TryAdd(fileName, this);
                 }
             }
         }

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

@@ -1,6 +1,8 @@
 using Barotrauma.Abilities;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Threading;
 
 namespace Barotrauma
 {
@@ -72,7 +74,9 @@ namespace Barotrauma
             }
         }
 
-        private static readonly HashSet<Identifier> checkedNonStackableTalents = new();
+        // ThreadLocal for thread-safe talent checking
+        private static readonly ThreadLocal<HashSet<Identifier>> checkedNonStackableTalentsLocal = new ThreadLocal<HashSet<Identifier>>(() => new HashSet<Identifier>());
+        private static HashSet<Identifier> checkedNonStackableTalents => checkedNonStackableTalentsLocal.Value;
 
         /// <summary>
         /// Checks talents for a given AbilityObject taking into account non-stackable talents.

Barotrauma/BarotraumaShared/SharedSource/ContentManagement/ContentFile/NPCConversationsFile.cs

@@ -1,4 +1,4 @@
-using System.Xml.Linq;
+using System.Xml.Linq;
 
 namespace Barotrauma
 {
@@ -21,7 +21,7 @@ namespace Barotrauma
             var npcConversationCollection = new NPCConversationCollection(this, mainElement);
             if (!NPCConversationCollection.Collections.ContainsKey(npcConversationCollection.Language))
             {
-                NPCConversationCollection.Collections.Add(npcConversationCollection.Language, new PrefabCollection<NPCConversationCollection>());
+                NPCConversationCollection.Collections.TryAdd(npcConversationCollection.Language, new PrefabCollection<NPCConversationCollection>());
             }
             NPCConversationCollection.Collections[npcConversationCollection.Language].Add(npcConversationCollection, allowOverriding);
         }

Barotrauma/BarotraumaShared/SharedSource/DebugConsole.cs

@@ -1478,7 +1478,7 @@ namespace Barotrauma
                     newItemName = args[2];
                 }
 
-                var oldItem = Item.ItemList.FindAll(it => it.Name == args[0]).ElementAtOrDefault(itemIndex);
+                var oldItem = Item.ItemList.Where(it => it.Name == args[0]).ElementAtOrDefault(itemIndex);
                 if (oldItem == null)
                 {
                     ThrowError($"Could not find an item with the name {args[0]} (index {itemIndex}).");
@@ -1852,7 +1852,7 @@ namespace Barotrauma
 
             commands.Add(new Command("power", "power: Immediately powers up the submarine's nuclear reactor.", (string[] args) =>
             {
-                Item reactorItem = Item.ItemList.Find(i => i.GetComponent<Reactor>() != null);
+                Item reactorItem = Item.ItemList.FirstOrDefault(i => i.GetComponent<Reactor>() != null);
                 if (reactorItem == null) { return; }
 
                 var reactor = reactorItem.GetComponent<Reactor>();
@@ -3225,7 +3225,7 @@ namespace Barotrauma
                 if (args.Length > spawnLocationIndex + 1)
                 {
                     if (!int.TryParse(args[spawnLocationIndex + 1], NumberStyles.Any, CultureInfo.InvariantCulture, out amount)) { amount = 1; }
-                    amount = Math.Min(amount, 100);
+                    amount = Math.Min(amount, 100000);
                 }
                 
                 if (args.Length > spawnLocationIndex + 2)

Barotrauma/BarotraumaShared/SharedSource/Events/EventManager.cs

@@ -160,7 +160,7 @@ namespace Barotrauma
             MissionAction.ResetMissionsUnlockedThisRound();
             UnlockPathAction.ResetPathsUnlockedThisRound();
 #endif
-            pathFinder = new PathFinder(WayPoint.WayPointList, false);
+            pathFinder = new PathFinder(WayPoint.WayPointList.ToList(), false);
             totalPathLength = 0.0f;
             if (level != null)
             {

Barotrauma/BarotraumaShared/SharedSource/Events/MalfunctionEvent.cs

@@ -41,7 +41,7 @@ namespace Barotrauma
 
         protected override void InitEventSpecific(EventSet parentSet)
         {
-            var matchingItems = Item.ItemList.FindAll(i => i.Condition > 0.0f && targetItemIdentifiers.Contains(i.Prefab.Identifier));
+            var matchingItems = Item.ItemList.Where(i => i.Condition > 0.0f && targetItemIdentifiers.Contains(i.Prefab.Identifier)).ToList();
             int itemAmount = Rand.Range(minItemAmount, maxItemAmount, Rand.RandSync.ServerAndClient);
             for (int i = 0; i < itemAmount; i++)
             {

Barotrauma/BarotraumaShared/SharedSource/Events/Missions/AbandonedOutpostMission.cs

@@ -111,7 +111,7 @@ namespace Barotrauma
         {
             if (!itemTag.IsEmpty)
             {
-                var itemsToDestroy = Item.ItemList.FindAll(it => it.Submarine?.Info.Type != SubmarineType.Player && it.HasTag(itemTag));
+                var itemsToDestroy = Item.ItemList.Where(it => it.Submarine?.Info.Type != SubmarineType.Player && it.HasTag(itemTag)).ToList();
                 if (!itemsToDestroy.Any())
                 {
                     DebugConsole.ThrowError($"Error in mission \"{Prefab.Identifier}\". Could not find an item with the tag \"{itemTag}\".",

Barotrauma/BarotraumaShared/SharedSource/Events/Missions/EndMission.cs

@@ -181,7 +181,7 @@ namespace Barotrauma
                 return;
             }
             destructibleItems.Clear();
-            destructibleItems.AddRange(Item.ItemList.FindAll(it => it.HasTag(destructibleItemTag)));
+            destructibleItems.AddRange(Item.ItemList.Where(it => it.HasTag(destructibleItemTag)));
             if (destructibleItems.None())
             {
                 DebugConsole.ThrowError($"Error in end mission \"{Prefab.Identifier}\". Could not find any destructible items with the tag \"{spawnPointTag}\".",

Barotrauma/BarotraumaShared/SharedSource/Events/Missions/PirateMission.cs

@@ -283,7 +283,7 @@ namespace Barotrauma
 
             if (!IsClient)
             {
-                PathFinder pathFinder = new PathFinder(WayPoint.WayPointList, false);
+                PathFinder pathFinder = new PathFinder(WayPoint.WayPointList.ToList(), false);
                 var path = pathFinder.FindPath(ConvertUnits.ToSimUnits(patrolPos), ConvertUnits.ToSimUnits(preferredSpawnPos));
                 if (!path.Unreachable)
                 {

Barotrauma/BarotraumaShared/SharedSource/GameSession/CrewManager.cs

@@ -128,7 +128,7 @@ namespace Barotrauma
                         {
                             foreach (var stackedItem in item.GetStackedItems())
                             {
-                                Item.DeconstructItems.Add(stackedItem);
+                                Item.MarkForDeconstruction(stackedItem);
                             }
 #if CLIENT
                             HintManager.OnItemMarkedForDeconstruction(order.OrderGiver);
@@ -138,7 +138,7 @@ namespace Barotrauma
                         {
                             foreach (var stackedItem in item.GetStackedItems())
                             {
-                                Item.DeconstructItems.Remove(stackedItem);
+                                Item.UnmarkForDeconstruction(stackedItem);
                             }
                         }
                     }

Barotrauma/BarotraumaShared/SharedSource/GameSession/GameSession.cs

@@ -1094,7 +1094,7 @@ namespace Barotrauma
 #endif
             //Clear the grids to allow for garbage collection
             Powered.Grids.Clear();
-            Powered.ChangedConnections.Clear();
+            Powered.ClearChangedConnections();
 
             try
             {
@@ -1153,6 +1153,7 @@ namespace Barotrauma
                 EventManager?.EndRound();
                 StatusEffect.StopAll();
                 AfflictionPrefab.ClearAllEffects();
+                PhysicsBodyQueue.Clear();
                 IsRunning = false;
 
 #if CLIENT

Barotrauma/BarotraumaShared/SharedSource/Items/Components/DockingPort.cs

@@ -5,6 +5,7 @@ using FarseerPhysics.Dynamics;
 using FarseerPhysics.Dynamics.Joints;
 using Microsoft.Xna.Framework;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 #if CLIENT
@@ -24,11 +25,8 @@ namespace Barotrauma.Items.Components
             Right
         }
 
-        private static readonly List<DockingPort> list = new List<DockingPort>();
-        public static IEnumerable<DockingPort> List
-        {
-            get { return list; }
-        }
+        private static readonly ConcurrentDictionary<DockingPort, byte> _dockingPortDict = new ConcurrentDictionary<DockingPort, byte>();
+        public static IEnumerable<DockingPort> List => _dockingPortDict.Keys;
 
         private Sprite overlaySprite;
         private float dockingState;
@@ -168,7 +166,7 @@ namespace Barotrauma.Items.Components
             
             IsActive = true;
             
-            list.Add(this);
+            _dockingPortDict.TryAdd(this, 0);
         }
 
         public override void FlipX(bool relativeToSub)
@@ -200,7 +198,7 @@ namespace Barotrauma.Items.Components
         {
             float closestDist = float.MaxValue;
             DockingPort closestPort = null;
-            foreach (DockingPort port in list)
+            foreach (DockingPort port in List)
             {
                 if (port == this || port.item.Submarine == item.Submarine || port.IsHorizontal != IsHorizontal) { continue; }
                 float xDist = Math.Abs(port.item.WorldPosition.X - item.WorldPosition.X);
@@ -532,8 +530,8 @@ namespace Barotrauma.Items.Components
             wire.TryConnect(recipient, addNode: false);
 
             //Flag connections to be updated
-            Powered.ChangedConnections.Add(powerConnection);
-            Powered.ChangedConnections.Add(recipient);
+            Powered.MarkConnectionChanged(powerConnection);
+            Powered.MarkConnectionChanged(recipient);
         }
 
         private void CreateDoorBody()
@@ -1007,7 +1005,7 @@ namespace Barotrauma.Items.Components
             Connection powerConnection = Item.Connections.Find(c => c.IsPower);
             if (powerConnection != null)
             {
-                Powered.ChangedConnections.Add(powerConnection);
+                Powered.MarkConnectionChanged(powerConnection);
             }
 
             if (doorBody != null)
@@ -1151,7 +1149,7 @@ namespace Barotrauma.Items.Components
         protected override void RemoveComponentSpecific()
         {
             base.RemoveComponentSpecific();
-            list.Remove(this);
+            _dockingPortDict.TryRemove(this, out _);
             hulls[0]?.Remove(); hulls[0] = null;
             hulls[1]?.Remove(); hulls[1] = null;
             gap?.Remove(); gap = null;

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Door.cs

@@ -2,6 +2,7 @@
 using FarseerPhysics;
 using Microsoft.Xna.Framework;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using FarseerPhysics.Dynamics;
@@ -14,9 +15,9 @@ namespace Barotrauma.Items.Components
 {
     partial class Door : Pickable, IDrawableComponent, IServerSerializable
     {
-        private static readonly HashSet<Door> doorList = new HashSet<Door>();
+        private static readonly ConcurrentDictionary<Door, byte> _doorDict = new ConcurrentDictionary<Door, byte>();
 
-        public static IReadOnlyCollection<Door> DoorList { get { return doorList; } }
+        public static ICollection<Door> DoorList => _doorDict.Keys;
 
         private Gap linkedGap;
         private bool isOpen;
@@ -277,7 +278,7 @@ namespace Barotrauma.Items.Components
             }
                         
             IsActive = true;
-            doorList.Add(this);
+            _doorDict.TryAdd(this, 0);
         }
 
         public override void OnItemLoaded()
@@ -313,13 +314,21 @@ namespace Barotrauma.Items.Components
 
         public override void Move(Vector2 amount, bool ignoreContacts = false)
         {
+            // Defer physics operation if in parallel context (Farseer is not thread-safe)
+            if (Body != null)
+            {
+                var capturedBody = Body;
+                var capturedNewPos = Body.SimPosition + ConvertUnits.ToSimUnits(amount);
                 if (ignoreContacts)
                 {
-                Body?.SetTransformIgnoreContacts(Body.SimPosition + ConvertUnits.ToSimUnits(amount), 0.0f);
+                    PhysicsBodyQueue.ExecuteOrDefer(() => 
+                        capturedBody.SetTransformIgnoreContacts(capturedNewPos, 0.0f));
                 }
                 else
                 {
-                Body?.SetTransform(Body.SimPosition + ConvertUnits.ToSimUnits(amount), 0.0f);
+                    PhysicsBodyQueue.ExecuteOrDefer(() => 
+                        capturedBody.SetTransform(capturedNewPos, 0.0f));
+                }
             }
 #if CLIENT
             UpdateConvexHulls();
@@ -669,7 +678,7 @@ namespace Barotrauma.Items.Components
             convexHull2?.Remove();
 #endif
 
-            doorList.Remove(this);
+            _doorDict.TryRemove(this, out _);
         }
 
         private bool CheckSubmarinesInDoorWay()
@@ -785,13 +794,19 @@ namespace Barotrauma.Items.Components
             //immediately teleport it to the correct side
             if (Math.Sign(diff) != dir)
             {
+                // Defer physics operation if in parallel context (Farseer is not thread-safe)
+                var capturedBody = body;
                 if (IsHorizontal)
                 {
-                    body.SetTransformIgnoreContacts(new Vector2(body.SimPosition.X, item.SimPosition.Y + dir * doorRectSimSize.Y * 2.0f), body.Rotation);
+                    Vector2 newPos = new Vector2(body.SimPosition.X, item.SimPosition.Y + dir * doorRectSimSize.Y * 2.0f);
+                    float rotation = body.Rotation;
+                    PhysicsBodyQueue.ExecuteOrDefer(() => capturedBody.SetTransformIgnoreContacts(newPos, rotation));
                 }
                 else
                 {
-                    body.SetTransformIgnoreContacts(new Vector2(item.SimPosition.X + dir * doorRectSimSize.X * 1.2f, body.SimPosition.Y), body.Rotation);
+                    Vector2 newPos = new Vector2(item.SimPosition.X + dir * doorRectSimSize.X * 1.2f, body.SimPosition.Y);
+                    float rotation = body.Rotation;
+                    PhysicsBodyQueue.ExecuteOrDefer(() => capturedBody.SetTransformIgnoreContacts(newPos, rotation));
                 }
             }
 

Barotrauma/BarotraumaShared/SharedSource/Items/Components/ElectricalDischarger.cs

@@ -3,6 +3,7 @@ using Barotrauma.Networking;
 using FarseerPhysics;
 using Microsoft.Xna.Framework;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -10,11 +11,8 @@ namespace Barotrauma.Items.Components
 {
     partial class ElectricalDischarger : Powered, IServerSerializable
     {
-        private static readonly List<ElectricalDischarger> list = new List<ElectricalDischarger>();
-        public static IEnumerable<ElectricalDischarger> List
-        {
-            get { return list; }
-        }
+        private static readonly ConcurrentDictionary<ElectricalDischarger, byte> _dischargerDict = new ConcurrentDictionary<ElectricalDischarger, byte>();
+        public static IEnumerable<ElectricalDischarger> List => _dischargerDict.Keys;
 
         const int MaxNodes = 100;
         const float MaxNodeDistance = 150.0f;
@@ -115,7 +113,7 @@ namespace Barotrauma.Items.Components
         public ElectricalDischarger(Item item, ContentXElement element) : 
             base(item, element)
         {
-            list.Add(this);
+            _dischargerDict.TryAdd(this, 0);
 
             foreach (var subElement in element.Elements())
             {
@@ -604,7 +602,7 @@ namespace Barotrauma.Items.Components
         protected override void RemoveComponentSpecific()
         {
             base.RemoveComponentSpecific();
-            list.Remove(this);
+            _dischargerDict.TryRemove(this, out _);
         }
 
         public void ServerEventWrite(IWriteMessage msg, Client c, NetEntityEvent.IData extraData = null)

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Holdable/Holdable.cs

@@ -9,6 +9,7 @@ using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
+using System.Threading;
 using System.Xml.Linq;
 
 namespace Barotrauma.Items.Components
@@ -485,7 +486,10 @@ namespace Barotrauma.Items.Components
                 }
                 else
                 {
-                    item.body.ResetDynamics();
+                    // Calculate target position
+                    Vector2 targetPos;
+                    Submarine forceSubmarine = picker.Submarine;
+                    
                     Limb heldHand, arm;
                     if (picker.Inventory.IsInLimbSlot(item, InvSlotType.LeftHand))
                     {
@@ -503,17 +507,42 @@ namespace Barotrauma.Items.Components
                         Vector2 diff = new Vector2(
                             (heldHand.SimPosition.X - arm.SimPosition.X) / 2f,
                             (heldHand.SimPosition.Y - arm.SimPosition.Y) / 2.5f);
+                        targetPos = heldHand.SimPosition + diff;
+                    }
+                    else
+                    {
+                        targetPos = picker.SimPosition;
+                    }
 
+                    // Defer physics operations if in parallel context
+                    if (PhysicsBodyQueue.IsInParallelContext)
+                    {
+                        var capturedBody = item.body;
+                        var capturedItem = item;
+                        var capturedTargetPos = targetPos;
+                        var capturedForceSubmarine = forceSubmarine;
+                        
+                        PhysicsBodyQueue.Enqueue(() =>
+                        {
+                            if (capturedBody.Removed || capturedItem.Removed) { return; }
+                            capturedBody.ResetDynamics();
                             //we have forced the item to be in the same sub as the dropper above,
                             //and are placing it to the position of the hands in "local" coordinates
                             //which may be outside the sub if the character is e.g. standing half-way through the airlock
                             // -> let's use the forceSubmarine argument ensure the item is still considered to be in the sub's coordinate space,
                             //    or it will end up in a weird state and seemingly disappear
-                        item.SetTransform(heldHand.SimPosition + diff, 0.0f, forceSubmarine: picker.Submarine);
+                            capturedItem.SetTransform(capturedTargetPos, 0.0f, forceSubmarine: capturedForceSubmarine);
+                        });
                     }
                     else
                     {
-                        item.SetTransform(picker.SimPosition, 0.0f, forceSubmarine: picker.Submarine);
+                        item.body.ResetDynamics();
+                        //we have forced the item to be in the same sub as the dropper above,
+                        //and are placing it to the position of the hands in "local" coordinates
+                        //which may be outside the sub if the character is e.g. standing half-way through the airlock
+                        // -> let's use the forceSubmarine argument ensure the item is still considered to be in the sub's coordinate space,
+                        //    or it will end up in a weird state and seemingly disappear
+                        item.SetTransform(targetPos, 0.0f, forceSubmarine: forceSubmarine);
                     }
                 }
             }
@@ -616,12 +645,13 @@ namespace Barotrauma.Items.Components
             return CanBeAttached(user, out _);
         }
 
-        private static List<Item> tempOverlappingItems = new List<Item>();
+        private static readonly ThreadLocal<List<Item>> tempOverlappingItems = new ThreadLocal<List<Item>>(() => new List<Item>());
 
         private bool CanBeAttached(Character user, out IEnumerable<Item> overlappingItems)
         {
-            tempOverlappingItems.Clear();
-            overlappingItems = tempOverlappingItems;
+            var overlapping = tempOverlappingItems.Value;
+            overlapping.Clear();
+            overlappingItems = overlapping;
             if (!attachable || !Reattachable) { return false; }
 
             //can be attached anywhere in sub editor
@@ -664,9 +694,9 @@ namespace Barotrauma.Items.Components
                     }                        
                     if (attachPos.X + size.X < worldRect.X || attachPos.X - size.X > worldRect.Right) { continue; }
                     if (attachPos.Y - size.Y > worldRect.Y || attachPos.Y + size.Y < worldRect.Y - worldRect.Height) { continue; }
-                    tempOverlappingItems.Add(otherItem);
+                    overlapping.Add(otherItem);
                 }
-                if (tempOverlappingItems.Any()) { return false; }
+                if (overlapping.Any()) { return false; }
             }
 
             //can be attached anywhere inside hulls

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Holdable/LevelResource.cs

@@ -14,6 +14,12 @@ namespace Barotrauma.Items.Components
 
         private float deattachTimer;
         
+        /// <summary>
+        /// Flag to prevent multiple queued creation requests.
+        /// Uses volatile to ensure visibility across threads.
+        /// </summary>
+        private volatile bool triggerBodyCreationQueued;
+
         [Serialize(1.0f, IsPropertySaveable.No, description: "How long it takes to deattach the item from the level walls (in seconds).")]
         public float DeattachDuration
         {
@@ -86,13 +92,16 @@ namespace Barotrauma.Items.Components
         {
             if (trigger != null && amount.LengthSquared() > 0.00001f)
             {
+                // Defer physics operation if in parallel context (Farseer is not thread-safe)
+                var capturedTrigger = trigger;
+                var capturedPos = item.SimPosition;
                 if (ignoreContacts)
                 {
-                    trigger.SetTransformIgnoreContacts(item.SimPosition, 0.0f);
+                    PhysicsBodyQueue.ExecuteOrDefer(() => capturedTrigger.SetTransformIgnoreContacts(capturedPos, 0.0f));
                 }
                 else
                 {
-                    trigger.SetTransform(item.SimPosition, 0.0f);
+                    PhysicsBodyQueue.ExecuteOrDefer(() => capturedTrigger.SetTransform(capturedPos, 0.0f));
                 }
             }
         }
@@ -109,13 +118,29 @@ namespace Barotrauma.Items.Components
             }
             else
             {
-                if (trigger == null) 
+                if (trigger == null && !triggerBodyCreationQueued) 
+                { 
+                    // Queue the physics body creation to be processed on the main thread.
+                    // This is necessary because physics body creation is not thread-safe
+                    // and Update() may be called from a parallel loop.
+                    triggerBodyCreationQueued = true;
+                    PhysicsBodyQueue.EnqueueCreation(() =>
+                    {
+                        // Double-check that trigger hasn't been created yet
+                        // (in case this was called multiple times before queue processing)
+                        if (trigger == null && !item.Removed)
                         {
                             CreateTriggerBody();
                         }
+                        triggerBodyCreationQueued = false;
+                    });
+                }
                 if (trigger != null && Vector2.DistanceSquared(item.SimPosition, trigger.SimPosition) > 0.01f)
                 {
-                    trigger.SetTransform(item.SimPosition, 0.0f);
+                    // Defer physics operation if in parallel context (Farseer is not thread-safe)
+                    var capturedTrigger = trigger;
+                    var capturedPos = item.SimPosition;
+                    PhysicsBodyQueue.ExecuteOrDefer(() => capturedTrigger.SetTransform(capturedPos, 0.0f));
                 }
                 IsActive = false;
             }

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Holdable/MeleeWeapon.cs

@@ -3,6 +3,7 @@ using FarseerPhysics.Dynamics;
 using FarseerPhysics.Dynamics.Contacts;
 using Microsoft.Xna.Framework;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
@@ -24,7 +25,7 @@ namespace Barotrauma.Items.Components
 
         private readonly HashSet<Entity> hitTargets = new HashSet<Entity>();
 
-        private readonly Queue<Fixture> impactQueue = new Queue<Fixture>();
+        private readonly ConcurrentQueue<Fixture> impactQueue = new ConcurrentQueue<Fixture>();
 
         public Character User { get; private set; }
 
@@ -190,17 +191,16 @@ namespace Barotrauma.Items.Components
         {
             if (!item.body.Enabled)
             {
-                impactQueue.Clear();
+                while (impactQueue.TryDequeue(out _)) { } // Clear queue
                 return;
             }
             if (picker == null || !picker.HeldItems.Contains(item))
             {
-                impactQueue.Clear();
+                while (impactQueue.TryDequeue(out _)) { } // Clear queue
                 IsActive = false;
             }
-            while (impactQueue.Count > 0)
+            while (impactQueue.TryDequeue(out var impact))
             {
-                var impact = impactQueue.Dequeue();
                 HandleImpact(impact);
             }
             //in case handling the impact does something to the picker
@@ -300,7 +300,7 @@ namespace Barotrauma.Items.Components
 
         private void RestoreCollision()
         {
-            impactQueue.Clear();
+            while (impactQueue.TryDequeue(out _)) { } // Clear queue
             item.body.FarseerBody.OnCollision -= OnCollision;
             item.body.CollisionCategories = Physics.CollisionItem;
             item.body.CollidesWith = Physics.DefaultItemCollidesWith;

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Holdable/RepairTool.cs

@@ -4,6 +4,7 @@ using Microsoft.Xna.Framework;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using Barotrauma.Extensions;
 using Barotrauma.MapCreatures.Behavior;
 
@@ -315,7 +316,7 @@ namespace Barotrauma.Items.Components
 
         partial void UseProjSpecific(float deltaTime, Vector2 raystart);
 
-        private static readonly List<Body> hitBodies = new List<Body>();
+        private static readonly ThreadLocal<List<Body>> hitBodies = new ThreadLocal<List<Body>>(() => new List<Body>());
         private readonly HashSet<Character> hitCharacters = new HashSet<Character>();
         private readonly List<FireSource> fireSourcesInRange = new List<FireSource>();
         private void Repair(Vector2 rayStart, Vector2 rayEnd, float deltaTime, Character user, float degreeOfSuccess, List<Body> ignoredBodies)
@@ -373,13 +374,13 @@ namespace Barotrauma.Items.Components
                     },
                     allowInsideFixture: true);
 
-                hitBodies.Clear();
-                hitBodies.AddRange(bodies.Distinct());
+                hitBodies.Value.Clear();
+                hitBodies.Value.AddRange(bodies.Distinct());
 
                 lastPickedFraction = Submarine.LastPickedFraction;
                 Type lastHitType = null;
                 hitCharacters.Clear();
-                foreach (Body body in hitBodies)
+                foreach (Body body in hitBodies.Value)
                 {
                     Type bodyType = body.UserData?.GetType();
                     if (!RepairThroughWalls && bodyType != null && bodyType != lastHitType)
@@ -897,48 +898,49 @@ namespace Barotrauma.Items.Components
             }
         }
 
-        private static List<ISerializableEntity> currentTargets = new List<ISerializableEntity>();
+        private static readonly ThreadLocal<List<ISerializableEntity>> currentTargets = new ThreadLocal<List<ISerializableEntity>>(() => new List<ISerializableEntity>());
         private void ApplyStatusEffectsOnTarget(Character user, float deltaTime, ActionType actionType, Item targetItem = null, Character character = null, Limb limb = null, Structure structure = null)
         {
             if (statusEffectLists == null) { return; }
             if (!statusEffectLists.TryGetValue(actionType, out List<StatusEffect> statusEffects)) { return; }
 
+            var targets = currentTargets.Value;
             foreach (StatusEffect effect in statusEffects)
             {
-                currentTargets.Clear();
+                targets.Clear();
                 effect.SetUser(user);
                 if (effect.HasTargetType(StatusEffect.TargetType.UseTarget))
                 {
                     if (targetItem != null)
                     {
-                        currentTargets.AddRange(targetItem.AllPropertyObjects);
+                        targets.AddRange(targetItem.AllPropertyObjects);
                     }
                     if (structure != null)
                     {
-                        currentTargets.Add(structure);
+                        targets.Add(structure);
                     }
                     if (character != null)
                     {
-                        currentTargets.Add(character);
+                        targets.Add(character);
                     }
-                    effect.Apply(actionType, deltaTime, item, currentTargets);
+                    effect.Apply(actionType, deltaTime, item, targets);
                 }
                 else if (effect.HasTargetType(StatusEffect.TargetType.Character))
                 {
-                    currentTargets.Add(user);
-                    effect.Apply(actionType, deltaTime, item, currentTargets);
+                    targets.Add(user);
+                    effect.Apply(actionType, deltaTime, item, targets);
                 }
                 else if (effect.HasTargetType(StatusEffect.TargetType.Limb))
                 {
-                    currentTargets.Add(limb);
-                    effect.Apply(actionType, deltaTime, item, currentTargets);
+                    targets.Add(limb);
+                    effect.Apply(actionType, deltaTime, item, targets);
                 }
 
 #if CLIENT
                 if (user == null) { return; }
                 // Hard-coded progress bars for welding doors stuck.
                 // A general purpose system could be better, but it would most likely require changes in the way we define the status effects in xml.
-                foreach (ISerializableEntity target in currentTargets)
+                foreach (ISerializableEntity target in targets)
                 {
                     if (target is not Door door) { continue; }
                     if (!door.CanBeWelded || !door.Item.IsInteractable(user)) { continue; }

Barotrauma/BarotraumaShared/SharedSource/Items/Components/ItemComponent.cs

@@ -949,7 +949,8 @@ namespace Barotrauma.Items.Components
             //if any of the effects reduce the item's condition, set the user for OnBroken effects as well
             if (reducesCondition && user != null && type != ActionType.OnBroken)
             {
-                foreach (ItemComponent ic in item.Components)
+                // Use ToArray() snapshot for thread-safe iteration
+                foreach (ItemComponent ic in item.Components.ToArray())
                 {
                     if (ic.statusEffectLists == null || !ic.statusEffectLists.TryGetValue(ActionType.OnBroken, out List<StatusEffect> brokenEffects)) { continue; }
                     foreach (var brokenEffect in brokenEffects)

Barotrauma/BarotraumaShared/SharedSource/Items/Components/ItemContainer.cs

@@ -884,7 +884,8 @@ namespace Barotrauma.Items.Components
                 RelatedItem containableItem = FindContainableItem(containedItem);
                 if (containableItem != null && containableItem.SetActive)
                 {
-                    foreach (var ic in containedItem.Components)
+                    // Use ToArray() snapshot for thread-safe iteration
+                    foreach (var ic in containedItem.Components.ToArray())
                     {
                         ic.IsActive = active;
                     }
@@ -1010,7 +1011,11 @@ namespace Barotrauma.Items.Components
                             if (flippedX ^ flippedY) { rotation = -rotation; }
                             rotation += -item.RotationRad;
                         }
-                        contained.Item.body.FarseerBody.SetTransformIgnoreContacts(ref simPos, rotation);
+                        // Defer physics operation if in parallel context (Farseer is not thread-safe)
+                        var capturedBody = contained.Item.body.FarseerBody;
+                        var capturedSimPos = simPos;
+                        var capturedRotation = rotation;
+                        PhysicsBodyQueue.ExecuteOrDefer(() => capturedBody.SetTransformIgnoreContacts(ref capturedSimPos, capturedRotation));
                         contained.Item.body.UpdateDrawPosition(interpolate: false);
                     }
                     catch (Exception e)

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Ladder.cs

@@ -1,17 +1,19 @@
-using System.Collections.Generic;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Xml.Linq;
 
 namespace Barotrauma.Items.Components
 {
     partial class Ladder : ItemComponent
     {
-        public static List<Ladder> List { get; } = new List<Ladder>();
+        private static readonly ConcurrentDictionary<Ladder, byte> _ladderDict = new ConcurrentDictionary<Ladder, byte>();
+        public static IEnumerable<Ladder> List => _ladderDict.Keys;
 
         public Ladder(Item item, ContentXElement element)
             : base(item, element)
         {
             InitProjSpecific(element);
-            List.Add(this);
+            _ladderDict.TryAdd(this, 0);
         }
 
         partial void InitProjSpecific(ContentXElement element);
@@ -28,7 +30,7 @@ namespace Barotrauma.Items.Components
         {
             base.RemoveComponentSpecific();
             RemoveProjSpecific();
-            List.Remove(this);
+            _ladderDict.TryRemove(this, out _);
         }
 
         partial void RemoveProjSpecific();

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Machines/Controller.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Xml.Linq;
+using System.Linq;
 
 namespace Barotrauma.Items.Components
 {
@@ -497,12 +498,14 @@ namespace Barotrauma.Items.Components
 
             item.SendSignal(new Signal(MathHelper.ToDegrees(targetRotation).ToString("G", CultureInfo.InvariantCulture), sender: user), positionOut);
 
-            for (int i = item.LastSentSignalRecipients.Count - 1; i >= 0; i--)
+            // Use ToList() snapshot for thread-safe iteration
+            var signalRecipients = item.LastSentSignalRecipients.ToList();
+            for (int i = signalRecipients.Count - 1; i >= 0; i--)
             {
-                if (item.LastSentSignalRecipients[i].Item.Condition <= 0.0f || item.LastSentSignalRecipients[i].IsPower) { continue; }
-                if (item.LastSentSignalRecipients[i].Item.Prefab.FocusOnSelected)
+                if (signalRecipients[i].Item.Condition <= 0.0f || signalRecipients[i].IsPower) { continue; }
+                if (signalRecipients[i].Item.Prefab.FocusOnSelected)
                 {
-                    return item.LastSentSignalRecipients[i].Item;
+                    return signalRecipients[i].Item;
                 }
             }
 

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Machines/Sonar.cs

@@ -1,14 +1,17 @@
 using Barotrauma.Networking;
 using Microsoft.Xna.Framework;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 
 namespace Barotrauma.Items.Components
 {
     partial class Sonar : Powered, IServerSerializable, IClientSerializable
     {
-        public static List<Sonar> SonarList = new List<Sonar>();
+        private static readonly ConcurrentDictionary<Sonar, byte> _sonarDict = new ConcurrentDictionary<Sonar, byte>();
+        public static IEnumerable<Sonar> SonarList => _sonarDict.Keys;
 
         public enum Mode
         {
@@ -169,7 +172,7 @@ namespace Barotrauma.Items.Components
             IsActive = true;
             InitProjSpecific(element);
             CurrentMode = Mode.Passive;
-            SonarList.Add(this);
+            _sonarDict.TryAdd(this, 0);
         }
 
         partial void InitProjSpecific(ContentXElement element);
@@ -291,13 +294,15 @@ namespace Barotrauma.Items.Components
             return currentPingIndex != -1 && (character == null || characterUsable);
         }
 
-        private static readonly Dictionary<string, List<Character>> targetGroups = new Dictionary<string, List<Character>>();
+        private static readonly ThreadLocal<Dictionary<string, List<Character>>> targetGroups = 
+            new ThreadLocal<Dictionary<string, List<Character>>>(() => new Dictionary<string, List<Character>>());
 
         public override bool CrewAIOperate(float deltaTime, Character character, AIObjectiveOperateItem objective)
         {
             if (currentMode == Mode.Passive || !aiPingCheckPending) { return false; }
 
-            foreach (List<Character> targetGroup in targetGroups.Values)
+            var groups = targetGroups.Value;
+            foreach (List<Character> targetGroup in groups.Values)
             {
                 targetGroup.Clear();
             }
@@ -310,14 +315,14 @@ namespace Barotrauma.Items.Components
 
                 #warning This is not the best key for a dictionary.
                 string directionName = GetDirectionName(c.WorldPosition - item.WorldPosition).Value;
-                if (!targetGroups.ContainsKey(directionName))
+                if (!groups.ContainsKey(directionName))
                 {
-                    targetGroups.Add(directionName, new List<Character>());
+                    groups.Add(directionName, new List<Character>());
                 }
-                targetGroups[directionName].Add(c);
+                groups[directionName].Add(c);
             }
 
-            foreach (KeyValuePair<string, List<Character>> targetGroup in targetGroups)
+            foreach (KeyValuePair<string, List<Character>> targetGroup in groups)
             {
                 if (!targetGroup.Value.Any()) { continue; }
                 string dialogTag = "DialogSonarTarget";
@@ -401,7 +406,7 @@ namespace Barotrauma.Items.Components
 
             MineralClusters = null;
 #endif
-            SonarList.Remove(this);
+            _sonarDict.TryRemove(this, out _);
         }
 
 

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Machines/Steering.cs

@@ -637,7 +637,7 @@ namespace Barotrauma.Items.Components
 
             if (pathFinder == null)
             {
-                pathFinder = new PathFinder(WayPoint.WayPointList, false)
+                pathFinder = new PathFinder(WayPoint.WayPointList.ToList(), false)
                 {
                     GetNodePenalty = GetNodePenalty
                 };

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Power/PowerTransfer.cs

@@ -1,6 +1,7 @@
 using Barotrauma.Extensions;
 using Microsoft.Xna.Framework;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Xml.Linq;
@@ -13,10 +14,12 @@ namespace Barotrauma.Items.Components
 
         private readonly HashSet<Connection> signalConnections = new HashSet<Connection>();
 
-        private readonly Dictionary<Connection, bool> connectionDirty = new Dictionary<Connection, bool>();
+        private readonly ConcurrentDictionary<Connection, bool> connectionDirty = new ConcurrentDictionary<Connection, bool>();
 
         //a list of connections a given connection is connected to, either directly or via other power transfer components
-        private readonly Dictionary<Connection, HashSet<Connection>> connectedRecipients = new Dictionary<Connection, HashSet<Connection>>();
+        //Uses ConcurrentDictionary<Connection, byte> as a thread-safe HashSet replacement
+        private readonly ConcurrentDictionary<Connection, ConcurrentDictionary<Connection, byte>> connectedRecipients = 
+            new ConcurrentDictionary<Connection, ConcurrentDictionary<Connection, byte>>();
 
         private float overloadCooldownTimer;
         private const float OverloadCooldown = 5.0f;
@@ -132,7 +135,7 @@ namespace Barotrauma.Items.Components
         
         partial void InitProjectSpecific(XElement element);
 
-        private static readonly HashSet<PowerTransfer> recipientsToRefresh = new HashSet<PowerTransfer>();
+        private static readonly System.Collections.Concurrent.ConcurrentDictionary<PowerTransfer, byte> _recipientsToRefresh = new System.Collections.Concurrent.ConcurrentDictionary<PowerTransfer, byte>();
         public override void UpdateBroken(float deltaTime, Camera cam)
         {
             base.UpdateBroken(deltaTime, cam);
@@ -144,20 +147,21 @@ namespace Barotrauma.Items.Components
                 powerLoad = 0.0f;
                 currPowerConsumption = 0.0f;
                 SetAllConnectionsDirty();
-                recipientsToRefresh.Clear();
-                foreach (HashSet<Connection> recipientList in connectedRecipients.Values)
+                _recipientsToRefresh.Clear();
+                // Take snapshot for thread-safe iteration (no locks needed with ConcurrentDictionary)
+                foreach (var recipientDict in connectedRecipients.Values)
                 {
-                    foreach (Connection c in recipientList)
+                    foreach (Connection c in recipientDict.Keys)
                     {
                         if (c.Item == item) { continue; }
                         var recipientPowerTransfer = c.Item.GetComponent<PowerTransfer>();
                         if (recipientPowerTransfer != null)
                         {
-                            recipientsToRefresh.Add(recipientPowerTransfer);
+                            _recipientsToRefresh.TryAdd(recipientPowerTransfer, 0);
                         }
                     }
                 }
-                foreach (PowerTransfer recipientPowerTransfer in recipientsToRefresh)
+                foreach (PowerTransfer recipientPowerTransfer in _recipientsToRefresh.Keys)
                 {
                     recipientPowerTransfer.SetAllConnectionsDirty();
                     recipientPowerTransfer.RefreshConnections();
@@ -304,58 +308,56 @@ namespace Barotrauma.Items.Components
         protected void RefreshConnections()
         {
             var connections = item.Connections;
-            foreach (Connection c in connections)
+            if (connections == null) { return; }
+            
+            // Take a snapshot of connections for thread-safe iteration
+            var connectionSnapshot = connections.ToList();
+            foreach (Connection c in connectionSnapshot)
             {
-                if (!connectionDirty.ContainsKey(c))
+                if (!connectionDirty.TryGetValue(c, out bool isDirty))
                 {
                     connectionDirty[c] = true;
+                    isDirty = true;
                 }
-                else if (!connectionDirty[c])
+                
+                if (!isDirty)
                 {
                     continue;
                 }
 
                 //find all connections that are connected to this one (directly or via another PowerTransfer)
-                HashSet<Connection> tempConnected;
-                if (!connectedRecipients.ContainsKey(c))
-                {
-                    tempConnected = new HashSet<Connection>();
-                    connectedRecipients.Add(c, tempConnected);
-                }
-                else
-                {
-                    tempConnected = connectedRecipients[c];
+                var tempConnected = connectedRecipients.GetOrAdd(c, _ => new ConcurrentDictionary<Connection, byte>());
+                
+                // Get previous recipients and clear
+                var previousRecipients = tempConnected.Keys.ToList();
                 tempConnected.Clear();
+                
                 //mark all previous recipients as dirty
-                    foreach (Connection recipient in tempConnected)
+                foreach (Connection recipient in previousRecipients)
                 {
                     var pt = recipient.Item.GetComponent<PowerTransfer>();
                     if (pt != null) { pt.connectionDirty[recipient] = true; }
                 }
-                }
 
-                tempConnected.Add(c);
+                tempConnected.TryAdd(c, 0);
                 if (item.Condition > 0.0f)
                 {
                     GetConnected(c, tempConnected);
                     //go through all the PowerTransfers that we're connected to and set their connections to match the ones we just calculated
                     //(no need to go through the recursive GetConnected method again)
-                    foreach (Connection recipient in tempConnected)
+                    // Take snapshot for thread-safe iteration (no locks needed)
+                    var tempConnectedSnapshot = tempConnected.Keys.ToList();
+                    foreach (Connection recipient in tempConnectedSnapshot)
                     {
                         if (recipient == c) { continue; }
                         var recipientPowerTransfer = recipient.Item.GetComponent<PowerTransfer>();
                         if (recipientPowerTransfer == null) { continue; }
-                        if (!recipientPowerTransfer.connectedRecipients.ContainsKey(recipient))
+                        
+                        var recipientSet = recipientPowerTransfer.connectedRecipients.GetOrAdd(recipient, _ => new ConcurrentDictionary<Connection, byte>());
+                        recipientSet.Clear();
+                        foreach (var connection in tempConnectedSnapshot)
                         {
-                            recipientPowerTransfer.connectedRecipients.Add(recipient, new HashSet<Connection>());
-                        }
-                        else
-                        {
-                            recipientPowerTransfer.connectedRecipients[recipient].Clear();
-                        }
-                        foreach (var connection in tempConnected)
-                        {
-                            recipientPowerTransfer.connectedRecipients[recipient].Add(connection);
+                            recipientSet.TryAdd(connection, 0);
                         }
                         recipientPowerTransfer.connectionDirty[recipient] = false;
                     }
@@ -364,19 +366,20 @@ namespace Barotrauma.Items.Components
             }
         }
 
-        //Finds all the connections that can receive a signal sent into the given connection and stores them in the hashset.
-        private void GetConnected(Connection c, HashSet<Connection> connected)
+        //Finds all the connections that can receive a signal sent into the given connection and stores them in the concurrent dictionary.
+        private void GetConnected(Connection c, ConcurrentDictionary<Connection, byte> connected)
         {
-            var recipients = c.Recipients;
+            // Take snapshot for thread-safe iteration
+            var recipients = c.Recipients.ToList();
 
             foreach (Connection recipient in recipients)
             {
-                if (recipient == null || connected.Contains(recipient)) { continue; }
+                if (recipient == null || connected.ContainsKey(recipient)) { continue; }
 
                 Item it = recipient.Item;
                 if (it == null || it.Condition <= 0.0f) { continue; }
 
-                connected.Add(recipient);
+                connected.TryAdd(recipient, 0);
 
                 var powerTransfer = it.GetComponent<PowerTransfer>();
                 if (powerTransfer != null && powerTransfer.CanTransfer && powerTransfer.IsActive)
@@ -394,10 +397,14 @@ namespace Barotrauma.Items.Components
                 connectionDirty[c] = true;
                 if (c.IsPower)
                 {
-                    ChangedConnections.Add(c);
+                    MarkConnectionChanged(c);
                     if (connectedRecipients.TryGetValue(c, out var recipients))
                     {
-                        recipients.Where(c => c.IsPower).ForEach(c => ChangedConnections.Add(c));
+                        // No lock needed - ConcurrentDictionary.Keys is thread-safe
+                        foreach (var conn in recipients.Keys.Where(conn => conn.IsPower))
+                        {
+                            MarkConnectionChanged(conn);
+                        }
                     }
                 }
             }
@@ -410,10 +417,14 @@ namespace Barotrauma.Items.Components
             connectionDirty[connection] = true;
             if (connection.IsPower)
             {
-                ChangedConnections.Add(connection);
+                MarkConnectionChanged(connection);
                 if (connectedRecipients.TryGetValue(connection, out var recipients))
                 {
-                    recipients.Where(c => c.IsPower).ForEach(c => ChangedConnections.Add(c));
+                    // No lock needed - ConcurrentDictionary.Keys is thread-safe
+                    foreach (var conn in recipients.Keys.Where(conn => conn.IsPower))
+                    {
+                        MarkConnectionChanged(conn);
+                    }
                 }
             }
         }
@@ -452,16 +463,19 @@ namespace Barotrauma.Items.Components
         public override void ReceiveSignal(Signal signal, Connection connection)
         {
             if (item.Condition <= 0.0f || connection.IsPower) { return; }
-            if (!connectedRecipients.ContainsKey(connection)) { return; }
+            if (!connectedRecipients.TryGetValue(connection, out var recipients)) { return; }
             if (!signalConnections.Contains(connection)) { return; }
 
-            foreach (Connection recipient in connectedRecipients[connection])
+            // No lock needed - ConcurrentDictionary.Keys is thread-safe
+            // Use ToList() snapshot for thread-safe iteration
+            foreach (Connection recipient in recipients.Keys.ToList())
             {
                 if (recipient.Item == item || recipient.Item == signal.source) { continue; }
 
                 signal.source?.LastSentSignalRecipients.Add(recipient);
 
-                foreach (ItemComponent ic in recipient.Item.Components)
+                // Use ToArray() snapshot for thread-safe iteration
+                foreach (ItemComponent ic in recipient.Item.Components.ToArray())
                 {
                     //other junction boxes don't need to receive the signal in the pass-through signal connections
                     //because we relay it straight to the connected items without going through the whole chain of junction boxes
@@ -471,7 +485,8 @@ namespace Barotrauma.Items.Components
 
                 if (recipient.Effects != null && signal.value != "0" && !string.IsNullOrEmpty(signal.value))
                 {
-                    foreach (StatusEffect effect in recipient.Effects)
+                    // Use ToArray() snapshot for thread-safe iteration
+                    foreach (StatusEffect effect in recipient.Effects.ToArray())
                     {
                         recipient.Item.ApplyStatusEffect(effect, ActionType.OnUse, 1.0f);
                     }
@@ -484,7 +499,7 @@ namespace Barotrauma.Items.Components
             base.RemoveComponentSpecific();
             connectedRecipients?.Clear();
             connectionDirty?.Clear();
-            recipientsToRefresh.Clear();
+            _recipientsToRefresh.Clear();
         }
     }
 }

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Power/Powered.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Concurrent;
+using System.Threading;
 using Microsoft.Xna.Framework;
 using System.Collections.Generic;
 using System.Linq;
@@ -62,17 +64,77 @@ namespace Barotrauma.Items.Components
         protected const float UpdateInterval = (float)Timing.Step;
 
         /// <summary>
-        /// List of all powered ItemComponents
+        /// List of all powered ItemComponents (thread-safe)
         /// </summary>
-        private static readonly List<Powered> poweredList = new List<Powered>();
+        private static readonly ConcurrentDictionary<Powered, byte> _poweredDict = new ConcurrentDictionary<Powered, byte>();
+        
+        /// <summary>
+        /// Cached list for iteration - updated when collection changes
+        /// </summary>
+        private static volatile List<Powered> _cachedPoweredList;
+        private static int _poweredListVersion;
+        
         public static IEnumerable<Powered> PoweredList
         {
-            get { return poweredList; }
+            get 
+            { 
+                var cached = _cachedPoweredList;
+                if (cached != null) return cached;
+                return GetCachedPoweredList();
+            }
         }
         
-        public static readonly HashSet<Connection> ChangedConnections = new HashSet<Connection>();
+        private static List<Powered> GetCachedPoweredList()
+        {
+            var newList = _poweredDict.Keys.ToList();
+            _cachedPoweredList = newList;
+            return newList;
+        }
         
-        public readonly static Dictionary<int, GridInfo> Grids = new Dictionary<int, GridInfo>();
+        private static void InvalidatePoweredListCache()
+        {
+            _cachedPoweredList = null;
+            Interlocked.Increment(ref _poweredListVersion);
+        }
+
+        /// <summary>
+        /// Thread-safe set of changed connections
+        /// </summary>
+        private static readonly ConcurrentDictionary<Connection, byte> _changedConnections = new ConcurrentDictionary<Connection, byte>();
+        
+        /// <summary>
+        /// Gets all changed connections (snapshot)
+        /// </summary>
+        public static ICollection<Connection> ChangedConnections => _changedConnections.Keys;
+        
+        /// <summary>
+        /// Add a connection to the changed set
+        /// </summary>
+        public static void MarkConnectionChanged(Connection c)
+        {
+            _changedConnections.TryAdd(c, 0);
+        }
+        
+        /// <summary>
+        /// Clear all changed connections
+        /// </summary>
+        public static void ClearChangedConnections()
+        {
+            _changedConnections.Clear();
+        }
+        
+        /// <summary>
+        /// Remove a connection from the changed set
+        /// </summary>
+        public static void UnmarkConnectionChanged(Connection c)
+        {
+            _changedConnections.TryRemove(c, out _);
+        }
+
+        /// <summary>
+        /// Thread-safe grid dictionary
+        /// </summary>
+        public readonly static ConcurrentDictionary<int, GridInfo> Grids = new ConcurrentDictionary<int, GridInfo>();
 
         /// <summary>
         /// The amount of power currently consumed by the item. Negative values mean that the item is providing power to connected items
@@ -209,7 +271,8 @@ namespace Barotrauma.Items.Components
         public Powered(Item item, ContentXElement element)
             : base(item, element)
         {
-            poweredList.Add(this);
+            _poweredDict.TryAdd(this, 0);
+            InvalidatePoweredListCache();
             InitProjectSpecific(element);
         }
 
@@ -322,17 +385,20 @@ namespace Barotrauma.Items.Components
             //don't use cache if there are no existing grids
             if (Grids.Count > 0 && useCache)
             {
+                // Take a snapshot of changed connections for iteration
+                var changedSnapshot = ChangedConnections.ToList();
+                
                 //delete all grids that were affected
-                foreach (Connection c in ChangedConnections)
+                foreach (Connection c in changedSnapshot)
                 {
                     if (c.Grid != null)
                     {
-                        Grids.Remove(c.Grid.ID);
+                        Grids.TryRemove(c.Grid.ID, out _);
                         c.Grid = null;
                     }
                 }
 
-                foreach (Connection c in ChangedConnections)
+                foreach (Connection c in changedSnapshot)
                 {
                     //Make sure the connection grid hasn't been resolved by another connection update
                     //Ensure the connection has other connections
@@ -346,7 +412,7 @@ namespace Barotrauma.Items.Components
             else
             {
                 //Clear all grid IDs from connections
-                foreach (Powered powered in poweredList)
+                foreach (Powered powered in PoweredList)
                 {
                     //Only check devices with connectors
                     if (powered.powerIn != null)
@@ -361,7 +427,7 @@ namespace Barotrauma.Items.Components
 
                 Grids.Clear();
 
-                foreach (Powered powered in poweredList)
+                foreach (Powered powered in PoweredList)
                 {
                     if (powered.Item.Condition <= 0f) { continue; }
 
@@ -392,7 +458,7 @@ namespace Barotrauma.Items.Components
             }
 
             //Clear changed connections after each update
-            ChangedConnections.Clear();
+            ClearChangedConnections();
         }
 
         private static GridInfo PropagateGrid(Connection conn)
@@ -422,8 +488,8 @@ namespace Barotrauma.Items.Components
                 c.Grid = grid;
                 grid.AddConnection(c);
 
-                //Add on recipients 
-                foreach (Connection otherC in c.Recipients)
+                //Add on recipients - use ToList() snapshot for thread-safe iteration
+                foreach (Connection otherC in c.Recipients.ToList())
                 {
                     //Only add valid connections
                     if (otherC.Grid != grid && (otherC.Grid == null || !Grids.ContainsKey(otherC.Grid.ID)) && ValidPowerConnection(c, otherC))
@@ -494,7 +560,7 @@ namespace Barotrauma.Items.Components
             }
 
             //Determine if devices are adding a load or providing power, also resolve solo nodes
-            foreach (Powered powered in poweredList)
+            foreach (Powered powered in PoweredList)
             {
                 //Make voltage decay to ensure the device powers down.
                 //This only effects devices with no power input (whose voltage is set by other means, e.g. status effects from a contained battery)
@@ -730,7 +796,8 @@ namespace Barotrauma.Items.Components
         {
             if (item.Connections != null && powerIn != null)
             {
-                foreach (Connection recipient in powerIn.Recipients)
+                // Use ToList() snapshot for thread-safe iteration
+                foreach (Connection recipient in powerIn.Recipients.ToList())
                 {
                     if (!recipient.IsPower || !recipient.IsOutput) { continue; }
                     if (recipient.Item?.GetComponent<PowerContainer>() is PowerContainer battery)
@@ -750,13 +817,14 @@ namespace Barotrauma.Items.Components
                 {
                     if (c.IsPower && c.Grid != null)
                     {
-                        ChangedConnections.Add(c);
+                        MarkConnectionChanged(c);
                     }
                 }
             }
 
             base.RemoveComponentSpecific();
-            poweredList.Remove(this);
+            _poweredDict.TryRemove(this, out _);
+            InvalidatePoweredListCache();
         }
     }
 
@@ -780,9 +848,9 @@ namespace Barotrauma.Items.Components
             Connections.Remove(c);
 
             //Remove the grid if it has no devices
-            if (Connections.Count == 0 && Powered.Grids.ContainsKey(ID))
+            if (Connections.Count == 0)
             {
-                Powered.Grids.Remove(ID);
+                Powered.Grids.TryRemove(ID, out _);
             }
         }
 

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Projectile.cs

@@ -5,6 +5,7 @@ using FarseerPhysics.Dynamics.Contacts;
 using FarseerPhysics.Dynamics.Joints;
 using Microsoft.Xna.Framework;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
@@ -72,7 +73,7 @@ namespace Barotrauma.Items.Components
 
         public const float WaterDragCoefficient = 0.1f;
 
-        private readonly Queue<Impact> impactQueue = new Queue<Impact>();
+        private readonly ConcurrentQueue<Impact> impactQueue = new ConcurrentQueue<Impact>();
 
         private bool removePending;
 
@@ -840,9 +841,8 @@ namespace Barotrauma.Items.Components
                     DisableProjectileCollisions();
                 }
             }
-            while (impactQueue.Count > 0)
+            while (impactQueue.TryDequeue(out var impact))
             {
-                var impact = impactQueue.Dequeue();
                 HandleProjectileCollision(impact.Fixture, impact.Normal, impact.LinearVelocity);
             }
 

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Repairable.cs

@@ -456,7 +456,8 @@ namespace Barotrauma.Items.Components
 
             item.SendSignal(conditionSignal, "condition_out");
 
-            foreach (var component in item.Components)
+            // Use ToArray() snapshot for thread-safe iteration
+            foreach (var component in item.Components.ToArray())
             {
                 if (component is IDeteriorateUnderStress deteriorateUnderStress)
                 {
@@ -713,7 +714,8 @@ namespace Barotrauma.Items.Components
 #endif
 
             if (LastActiveTime > Timing.TotalTime) { return true; }
-            foreach (ItemComponent ic in item.Components)
+            // Use ToArray() snapshot for thread-safe iteration
+            foreach (ItemComponent ic in item.Components.ToArray())
             {
                 if (ic is Fabricator || ic is Deconstructor)
                 {
@@ -761,7 +763,8 @@ namespace Barotrauma.Items.Components
 
         private float GetDeteriorationDelayMultiplier()
         {
-            foreach (ItemComponent ic in item.Components)
+            // Use ToArray() snapshot for thread-safe iteration
+            foreach (ItemComponent ic in item.Components.ToArray())
             {
                 if (ic is Engine engine)
                 {

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Signal/Connection.cs

@@ -222,13 +222,14 @@ namespace Barotrauma.Items.Components
         public void SetRecipientsDirty()
         {
             recipientsDirty = true;
-            if (IsPower) { Powered.ChangedConnections.Add(this); }
+            if (IsPower) { Powered.MarkConnectionChanged(this); }
         }
 
         private void RefreshRecipients()
         {
             recipients.Clear();
-            foreach (var wire in wires)
+            // Use ToArray() snapshot for thread-safe iteration
+            foreach (var wire in wires.ToArray())
             {
                 Connection recipient = wire.OtherConnection(this);
                 if (recipient != null) { recipients.Add(recipient); }
@@ -267,8 +268,8 @@ namespace Barotrauma.Items.Components
                     //Check if both connections belong to a larger grid
                     if (prevOtherConnection.recipients.Count > 1 && recipients.Count > 1)
                     {
-                        Powered.ChangedConnections.Add(prevOtherConnection);
-                        Powered.ChangedConnections.Add(this);
+                        Powered.MarkConnectionChanged(prevOtherConnection);
+                        Powered.MarkConnectionChanged(this);
                     }
                     else if (recipients.Count > 1)
                     {
@@ -284,7 +285,7 @@ namespace Barotrauma.Items.Components
                     else if (Grid.Connections.Count == 2)
                     {
                         //Delete the grid as these were the only 2 devices
-                        Powered.Grids.Remove(Grid.ID);
+                        Powered.Grids.TryRemove(Grid.ID, out _);
                         Grid = null;
                         prevOtherConnection.Grid = null;
                     }
@@ -325,8 +326,8 @@ namespace Barotrauma.Items.Components
                     else
                     {
                         //Flag change so that proper grids can be formed
-                        Powered.ChangedConnections.Add(this);
-                        Powered.ChangedConnections.Add(otherConnection);
+                        Powered.MarkConnectionChanged(this);
+                        Powered.MarkConnectionChanged(otherConnection);
                     }
                 }
 
@@ -339,7 +340,8 @@ namespace Barotrauma.Items.Components
         {
             LastSentSignal = signal;
             enumeratingWires = true;
-            foreach (var wire in wires)
+            // Use ToArray() snapshot for thread-safe iteration
+            foreach (var wire in wires.ToArray())
             {
                 Connection recipient = wire.OtherConnection(this);
                 if (recipient == null) { continue; }
@@ -354,14 +356,14 @@ namespace Barotrauma.Items.Components
                 GameMain.LuaCs.Hook.Call("signalReceived." + recipient.item.Prefab.Identifier, signal, recipient);
             }
 
-            foreach (CircuitBoxConnection connection in CircuitBoxConnections)
+            foreach (CircuitBoxConnection connection in CircuitBoxConnections.ToArray())
             {
                 connection.ReceiveSignal(signal);
                 GameMain.LuaCs.Hook.Call("signalReceived", signal, connection.Connection);
                 GameMain.LuaCs.Hook.Call("signalReceived." + connection.Connection.Item.Prefab.Identifier, signal, connection);
             }
             enumeratingWires = false;
-            foreach (var removedWire in removedWires)
+            foreach (var removedWire in removedWires.ToArray())
             {
                 wires.Remove(removedWire);
             }
@@ -372,14 +374,16 @@ namespace Barotrauma.Items.Components
         {
             conn.LastReceivedSignal = signal;
 
-            foreach (ItemComponent ic in conn.item.Components)
+            // Use ToArray() snapshot for thread-safe iteration
+            foreach (ItemComponent ic in conn.item.Components.ToArray())
             {
                 ic.ReceiveSignal(signal, conn);
             }
 
             if (conn.Effects == null || signal.value == "0") { return; }
 
-            foreach (StatusEffect effect in conn.Effects)
+            // Use ToArray() snapshot for thread-safe iteration
+            foreach (StatusEffect effect in conn.Effects.ToArray())
             {
                 conn.Item.ApplyStatusEffect(effect, ActionType.OnUse, (float)Timing.Step);
             }
@@ -389,13 +393,15 @@ namespace Barotrauma.Items.Components
         {
             if (IsPower && Grid != null)
             {
-                Powered.ChangedConnections.Add(this);
-                foreach (Connection c in recipients)
+                Powered.MarkConnectionChanged(this);
+                // Use ToArray() snapshot for thread-safe iteration
+                foreach (Connection c in recipients.ToArray())
                 {
-                    Powered.ChangedConnections.Add(c);
+                    Powered.MarkConnectionChanged(c);
                 }
             }
-            foreach (var wire in wires)
+            // Use ToArray() snapshot for thread-safe iteration
+            foreach (var wire in wires.ToArray())
             {
                 wire.RemoveConnection(this);
                 recipientsDirty = true;
@@ -403,7 +409,7 @@ namespace Barotrauma.Items.Components
 
             if (enumeratingWires)
             {
-                foreach (var wire in wires)
+                foreach (var wire in wires.ToArray())
                 {
                     removedWires.Add(wire);
                 }
@@ -446,7 +452,8 @@ namespace Barotrauma.Items.Components
         {
             XElement newElement = new XElement(IsOutput ? "output" : "input", new XAttribute("name", Name));
 
-            foreach (var wire in wires.OrderBy(w => w.Item.ID))
+            // Use ToArray() snapshot before OrderBy for thread-safe iteration
+            foreach (var wire in wires.ToArray().OrderBy(w => w.Item.ID))
             {
                 newElement.Add(new XElement("link",
                     new XAttribute("w", wire.Item.ID.ToString()),

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Signal/ConnectionPanel.cs

@@ -148,14 +148,16 @@ namespace Barotrauma.Items.Components
             Vector2 wireNodeOffset = item.Submarine == null ? Vector2.Zero : item.Submarine.HiddenSubPosition + amount;
             foreach (Connection c in Connections)
             {
-                foreach (Wire wire in c.Wires)
+                // Use ToArray() snapshot for thread-safe iteration
+                foreach (Wire wire in c.Wires.ToArray())
                 {
                     if (wire == null) { continue; }
                     TryMoveWire(wire);
                 }
             }
 
-            foreach (var wire in DisconnectedWires)
+            // Use ToList() snapshot for thread-safe iteration
+            foreach (var wire in DisconnectedWires.ToList())
             {
                 TryMoveWire(wire);
             }
@@ -387,7 +389,7 @@ namespace Barotrauma.Items.Components
             }
             foreach (var connection in Connections)
             {
-                Powered.ChangedConnections.Remove(connection);
+                Powered.UnmarkConnectionChanged(connection);
                 connection.Recipients.Clear();
             }
             Connections.Clear();
@@ -412,15 +414,19 @@ namespace Barotrauma.Items.Components
             msg.WriteByte((byte)Connections.Count);
             foreach (Connection connection in Connections)
             {
-                msg.WriteVariableUInt32((uint)connection.Wires.Count);
-                foreach (Wire wire in connection.Wires)
+                // Use ToArray() snapshot for thread-safe iteration
+                var wiresSnapshot = connection.Wires.ToArray();
+                msg.WriteVariableUInt32((uint)wiresSnapshot.Length);
+                foreach (Wire wire in wiresSnapshot)
                 {
                     msg.WriteUInt16(wire?.Item == null ? (ushort)0 : wire.Item.ID);
                 }
             }
 
-            msg.WriteUInt16((ushort)DisconnectedWires.Count);
-            foreach (Wire disconnectedWire in DisconnectedWires)
+            // Use ToList() snapshot for thread-safe iteration
+            var disconnectedSnapshot = DisconnectedWires.ToList();
+            msg.WriteUInt16((ushort)disconnectedSnapshot.Count);
+            foreach (Wire disconnectedWire in disconnectedSnapshot)
             {
                 msg.WriteUInt16(disconnectedWire.Item.ID);
             }

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Signal/DelayComponent.cs

@@ -1,6 +1,8 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Globalization;
+using System.Linq;
 using System.Xml.Linq;
 using Microsoft.Xna.Framework;
 namespace Barotrauma.Items.Components
@@ -25,7 +27,8 @@ namespace Barotrauma.Items.Components
         private int signalQueueSize;
         private int delayTicks;
 
-        private readonly Queue<DelayedSignal> signalQueue = new Queue<DelayedSignal>();
+        // Thread-safe queue for concurrent access
+        private readonly ConcurrentQueue<DelayedSignal> signalQueue = new ConcurrentQueue<DelayedSignal>();
 
         private DelayedSignal prevQueuedSignal;
         
@@ -40,7 +43,8 @@ namespace Barotrauma.Items.Components
                 delay = value;
                 delayTicks = (int)(delay / Timing.Step);
                 signalQueueSize = Math.Max(delayTicks, 1) * 2;
-                signalQueue.Clear();
+                // ConcurrentQueue doesn't have Clear(), drain it instead
+                while (signalQueue.TryDequeue(out _)) { }
             }
         }
 
@@ -66,19 +70,19 @@ namespace Barotrauma.Items.Components
 
         public override void Update(float deltaTime, Camera cam)
         {
-            if (signalQueue.Count == 0)
+            if (signalQueue.IsEmpty)
             {
                 IsActive = false;
                 return;
             }
 
-            foreach (var val in signalQueue)
+            // Use ToArray() snapshot for thread-safe iteration
+            foreach (var val in signalQueue.ToArray())
             {
                 val.SendTimer -= 1;
             }
-            while (signalQueue.Count > 0 && signalQueue.Peek().SendTimer <= 0)
+            while (signalQueue.TryPeek(out var signalOut) && signalOut.SendTimer <= 0)
             {
-                var signalOut = signalQueue.Peek();
                 signalOut.SendDuration -= 1;
                 item.SendSignal(new Signal(signalOut.Signal.value, sender: signalOut.Signal.sender, strength: signalOut.Signal.strength), "signal_out");
                 if (signalOut.SendDuration <= 0) 
@@ -100,11 +104,15 @@ namespace Barotrauma.Items.Components
             {
                 case "signal_in":
                     if (signalQueue.Count >= signalQueueSize) { return; }
-                    if (ResetWhenSignalReceived) { prevQueuedSignal = null; signalQueue.Clear(); }
-                    if (ResetWhenDifferentSignalReceived && signalQueue.Count > 0 && signalQueue.Peek().Signal.value != signal.value)
+                    if (ResetWhenSignalReceived) 
                     { 
                         prevQueuedSignal = null; 
-                        signalQueue.Clear();
+                        while (signalQueue.TryDequeue(out _)) { } 
+                    }
+                    if (ResetWhenDifferentSignalReceived && signalQueue.TryPeek(out var peekSignal) && peekSignal.Signal.value != signal.value)
+                    {
+                        prevQueuedSignal = null;
+                        while (signalQueue.TryDequeue(out _)) { }
                     }
 
                     if (prevQueuedSignal != null && 
@@ -127,10 +135,10 @@ namespace Barotrauma.Items.Components
                     if (float.TryParse(signal.value, NumberStyles.Any, CultureInfo.InvariantCulture, out float newDelay))
                     {
 						newDelay = MathHelper.Clamp(newDelay, 0, 60);
-                        if (signalQueue.Count > 0 && newDelay != Delay)
+                        if (!signalQueue.IsEmpty && newDelay != Delay)
                         {
                             prevQueuedSignal = null;
-                            signalQueue.Clear();
+                            while (signalQueue.TryDequeue(out _)) { }
                         }
                         Delay = newDelay;
                     }

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Signal/RelayComponent.cs

@@ -2,6 +2,7 @@
 using Microsoft.Xna.Framework;
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Xml.Linq;
 
@@ -31,7 +32,8 @@ namespace Barotrauma.Items.Components
 
         private float thirdInverseMax = 0, loadEqnConstant = 0;
 
-        private static readonly Dictionary<string, string> connectionPairs = new Dictionary<string, string>
+        // Thread-safe immutable dictionary for connection pairs (read-only after initialization)
+        private static readonly ImmutableDictionary<string, string> connectionPairs = new Dictionary<string, string>
         {
             { "power_in", "power_out"},
             { "signal_in", "signal_out" },
@@ -40,7 +42,7 @@ namespace Barotrauma.Items.Components
             { "signal_in3", "signal_out3" },
             { "signal_in4", "signal_out4" },
             { "signal_in5", "signal_out5" }
-        };
+        }.ToImmutableDictionary();
 
         protected override PowerPriority Priority { get { return PowerPriority.Relay; } }
 

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Signal/WifiComponent.cs

@@ -1,6 +1,7 @@
 using Barotrauma.Networking;
 using Microsoft.Xna.Framework;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
@@ -10,7 +11,8 @@ namespace Barotrauma.Items.Components
 {
     partial class WifiComponent : ItemComponent, IServerSerializable, IClientSerializable
     {
-        private static readonly List<WifiComponent> list = new List<WifiComponent>();
+        private static readonly ConcurrentDictionary<WifiComponent, byte> _wifiDict = new ConcurrentDictionary<WifiComponent, byte>();
+        private static IEnumerable<WifiComponent> AllWifiComponents => _wifiDict.Keys;
 
         const int ChannelMemorySize = 10;
 
@@ -111,7 +113,7 @@ namespace Barotrauma.Items.Components
         public WifiComponent(Item item, ContentXElement element)
             : base (item, element)
         {
-            list.Add(this);
+            _wifiDict.TryAdd(this, 0);
             IsActive = true;
         }
 
@@ -156,7 +158,7 @@ namespace Barotrauma.Items.Components
         /// </summary>
         public IEnumerable<WifiComponent> GetReceiversInRange()
         {
-            return list.Where(w => w != this && w.CanReceive(this));
+            return AllWifiComponents.Where(w => w != this && w.CanReceive(this));
         }
 
         public bool CanReceive(WifiComponent sender)
@@ -185,7 +187,7 @@ namespace Barotrauma.Items.Components
         /// </summary>
         public IEnumerable<WifiComponent> GetTransmittersInRange()
         {
-            return list.Where(w => w != this && w.CanTransmit(this));
+            return AllWifiComponents.Where(w => w != this && w.CanTransmit(this));
         }
 
         public bool CanTransmit(WifiComponent sender)
@@ -275,7 +277,8 @@ namespace Barotrauma.Items.Components
 
                 if (signal.source != null)
                 {
-                    foreach (Connection receiver in wifiComp.item.LastSentSignalRecipients)
+                    // Use ToList() snapshot for thread-safe iteration
+                    foreach (Connection receiver in wifiComp.item.LastSentSignalRecipients.ToList())
                     {
                         if (!signal.source.LastSentSignalRecipients.Contains(receiver))
                         {
@@ -366,7 +369,7 @@ namespace Barotrauma.Items.Components
         protected override void RemoveComponentSpecific()
         {
             base.RemoveComponentSpecific();
-            list.Remove(this);
+            _wifiDict.TryRemove(this, out _);
         }
 
         public override XElement Save(XElement parentElement)

Barotrauma/BarotraumaShared/SharedSource/Items/Components/Signal/Wire.cs

@@ -250,7 +250,8 @@ namespace Barotrauma.Items.Components
             {
                 if (connections[0] != null && connections[1] != null)
                 {
-                    foreach (ItemComponent ic in item.Components)
+                    // Use ToArray() snapshot for thread-safe iteration
+                    foreach (ItemComponent ic in item.Components.ToArray())
                     {
                         if (ic == this) { continue; }
 
@@ -723,11 +724,11 @@ namespace Barotrauma.Items.Components
 
             if (item0 == null && item1 != null)
             {
-                item0 = Item.ItemList.Find(it => it.GetComponent<ConnectionPanel>()?.DisconnectedWires.Contains(this) ?? false);
+                item0 = Item.ItemList.FirstOrDefault(it => it.GetComponent<ConnectionPanel>()?.DisconnectedWires.Contains(this) ?? false);
             }
             else if (item0 != null && item1 == null)
             {
-                item1 = Item.ItemList.Find(it => it.GetComponent<ConnectionPanel>()?.DisconnectedWires.Contains(this) ?? false);
+                item1 = Item.ItemList.FirstOrDefault(it => it.GetComponent<ConnectionPanel>()?.DisconnectedWires.Contains(this) ?? false);
             }
 
             if (item0 == null || item1 == null || nodes.Count == 0) { return; }

Barotrauma/BarotraumaShared/SharedSource/Items/Components/TriggerComponent.cs

@@ -73,6 +73,11 @@ namespace Barotrauma.Items.Components
 
         public PhysicsBody PhysicsBody { get; private set; }
 
+        /// <summary>
+        /// Flag to prevent multiple queued refresh requests.
+        /// </summary>
+        private volatile bool physicsBodyRefreshQueued;
+
         private float radius;
         [Editable, Serialize(0.0f, IsPropertySaveable.Yes)]
         public float Radius
@@ -83,7 +88,7 @@ namespace Barotrauma.Items.Components
             {
                 if (radius == value) { return; }
                 radius = value;
-                if (PhysicsBody != null) { RefreshPhysicsBodySize(); }
+                if (PhysicsBody != null) { QueuePhysicsBodyRefresh(); }
             }
         }
 
@@ -97,7 +102,7 @@ namespace Barotrauma.Items.Components
             {
                 if (width == value) { return; }
                 width = value;
-                if (PhysicsBody != null) { RefreshPhysicsBodySize(); }
+                if (PhysicsBody != null) { QueuePhysicsBodyRefresh(); }
             }
         }
 
@@ -111,10 +116,28 @@ namespace Barotrauma.Items.Components
             {
                 if (height == value) { return; }
                 height = value;
-                if (PhysicsBody != null) { RefreshPhysicsBodySize(); }
+                if (PhysicsBody != null) { QueuePhysicsBodyRefresh(); }
             }
         }
 
+        /// <summary>
+        /// Queue the physics body refresh to be executed on the main thread.
+        /// This is necessary because physics body operations are not thread-safe.
+        /// </summary>
+        private void QueuePhysicsBodyRefresh()
+        {
+            if (physicsBodyRefreshQueued) { return; }
+            physicsBodyRefreshQueued = true;
+            PhysicsBodyQueue.EnqueueCreation(() =>
+            {
+                if (!item.Removed)
+                {
+                    RefreshPhysicsBodySize();
+                }
+                physicsBodyRefreshQueued = false;
+            });
+        }
+
         private float currentRadius, currentWidth, currentHeight;
 
         private Vector2 bodyOffset;
@@ -289,13 +312,18 @@ namespace Barotrauma.Items.Components
                 Matrix transform = Matrix.CreateRotationZ(-item.RotationRad);
                 offset = Vector2.Transform(offset, transform);
             }
+            
+            // Defer physics operations if in parallel context (Farseer is not thread-safe)
+            var capturedBody = PhysicsBody;
+            var capturedPos = item.SimPosition + offset;
+            var capturedRot = -item.RotationRad;
             if (ignoreContacts)
             {
-                PhysicsBody.SetTransformIgnoreContacts(item.SimPosition + offset, -item.RotationRad);
+                PhysicsBodyQueue.ExecuteOrDefer(() => capturedBody.SetTransformIgnoreContacts(capturedPos, capturedRot));
             }
             else
             {
-                PhysicsBody.SetTransform(item.SimPosition + offset, -item.RotationRad);
+                PhysicsBodyQueue.ExecuteOrDefer(() => capturedBody.SetTransform(capturedPos, capturedRot));
             }
             PhysicsBody.UpdateDrawPosition();
         }

Barotrauma/BarotraumaShared/SharedSource/Items/Inventory.cs

@@ -381,7 +381,8 @@ namespace Barotrauma
 
             if (Owner is not Item it) { return; }
 
-            foreach (var c in it.Components)
+            // Use ToArray() snapshot for thread-safe iteration
+            foreach (var c in it.Components.ToArray())
             {
                 c.OnInventoryChanged();
             }

Barotrauma/BarotraumaShared/SharedSource/Items/Item.cs

@@ -14,7 +14,9 @@ using Barotrauma.Extensions;
 using Barotrauma.MapCreatures.Behavior;
 using MoonSharp.Interpreter;
 using System.Collections.Immutable;
+using System.Threading;
 using Barotrauma.Abilities;
+using HarmonyLib;
 
 #if CLIENT
 using Microsoft.Xna.Framework.Graphics;
@@ -27,57 +29,172 @@ namespace Barotrauma
         #region Lists
 
         /// <summary>
-        /// A list of every item that exists somewhere in the world. Note that there can be a huge number of items in the list, 
-        /// and you probably shouldn't be enumerating it to find some that match some specific criteria (unless that's done very, very sparsely or during initialization).
+        /// Thread-safe dictionary of all items by ID.
         /// </summary>
-        public static readonly List<Item> ItemList = new List<Item>();
+        private static readonly ConcurrentDictionary<ushort, Item> _itemDictionary = new ConcurrentDictionary<ushort, Item>();
 
-        private static readonly HashSet<Item> _dangerousItems = new HashSet<Item>();
+        /// <summary>
+        /// Provides thread-safe enumeration over all items.
+        /// </summary>
+        public static ICollection<Item> ItemList => _itemDictionary.Values;
+
+        /// <summary>
+        /// Thread-safe item lookup by ID.
+        /// </summary>
+        public static Item GetItemById(ushort id)
+        {
+            _itemDictionary.TryGetValue(id, out var item);
+            return item;
+        }
+
+        // Thread-safe optimized item collections using Immutable + atomic swap pattern
+        private static volatile ImmutableHashSet<Item> _dangerousItems = ImmutableHashSet<Item>.Empty;
+        private static volatile ImmutableHashSet<Item> _repairableItems = ImmutableHashSet<Item>.Empty;
+        private static volatile ImmutableHashSet<Item> _cleanableItems = ImmutableHashSet<Item>.Empty;
+        private static volatile ImmutableHashSet<Item> _sonarVisibleItems = ImmutableHashSet<Item>.Empty;
+        private static volatile ImmutableHashSet<Item> _turretTargetItems = ImmutableHashSet<Item>.Empty;
+        private static volatile ImmutableHashSet<Item> _chairItems = ImmutableHashSet<Item>.Empty;
+
+        // DeconstructItems uses ConcurrentDictionary to simulate a thread-safe HashSet
+        private static readonly ConcurrentDictionary<Item, byte> _deconstructItems = new ConcurrentDictionary<Item, byte>();
 
         public static IReadOnlyCollection<Item> DangerousItems => _dangerousItems;
 
-        private static readonly List<Item> _repairableItems = new List<Item>();
-
         /// <summary>
         /// Items that have one more more Repairable component
         /// </summary>
         public static IReadOnlyCollection<Item> RepairableItems => _repairableItems;
 
-        private static readonly List<Item> _cleanableItems = new List<Item>();
-
         /// <summary>
         /// Items that may potentially need to be cleaned up (pickable, not attached to a wall, and not inside a valid container)
         /// </summary>
         public static IReadOnlyCollection<Item> CleanableItems => _cleanableItems;
 
-        private static readonly HashSet<Item> _deconstructItems = new HashSet<Item>();
-
         /// <summary>
-        /// Items that have been marked for deconstruction
+        /// Items that have been marked for deconstruction. Thread-safe collection.
         /// </summary>
-        public static HashSet<Item> DeconstructItems => _deconstructItems;
-
-        private static readonly List<Item> _sonarVisibleItems = new List<Item>();
+        public static ICollection<Item> DeconstructItems => _deconstructItems.Keys;
 
         /// <summary>
         /// Items whose <see cref="ItemPrefab.SonarSize"/> is larger than 0
         /// </summary>
         public static IReadOnlyCollection<Item> SonarVisibleItems => _sonarVisibleItems;
 
-        private static readonly List<Item> _turretTargetItems = new List<Item>();
-
         /// <summary>
         /// Items whose <see cref="ItemPrefab.IsAITurretTarget"/> is true.
         /// </summary>
         public static IReadOnlyCollection<Item> TurretTargetItems => _turretTargetItems;
 
-        private static readonly List<Item> _chairItems = new List<Item>();
-
         /// <summary>
         /// Items that have the tag <see cref="Tags.ChairItem"/>. Which is an oddly specific thing, but useful as an optimization for NPC AI.
         /// </summary>
         public static IReadOnlyCollection<Item> ChairItems => _chairItems;
 
+        #region Thread-safe collection helpers
+
+        /// <summary>
+        /// Atomically adds an item to an immutable set using compare-and-swap.
+        /// </summary>
+        private static void AddToImmutableSet(ref ImmutableHashSet<Item> location, Item item)
+        {
+            ImmutableHashSet<Item> original, updated;
+            do
+            {
+                original = location;
+                updated = original.Add(item);
+                if (ReferenceEquals(original, updated)) return; // Already exists
+            }
+            while (Interlocked.CompareExchange(ref location, updated, original) != original);
+        }
+
+        /// <summary>
+        /// Atomically removes an item from an immutable set using compare-and-swap.
+        /// </summary>
+        private static void RemoveFromImmutableSet(ref ImmutableHashSet<Item> location, Item item)
+        {
+            ImmutableHashSet<Item> original, updated;
+            do
+            {
+                original = location;
+                updated = original.Remove(item);
+                if (ReferenceEquals(original, updated)) return; // Doesn't exist
+            }
+            while (Interlocked.CompareExchange(ref location, updated, original) != original);
+        }
+
+        /// <summary>
+        /// Marks an item for deconstruction (thread-safe).
+        /// </summary>
+        public static void MarkForDeconstruction(Item item)
+        {
+            _deconstructItems.TryAdd(item, 0);
+        }
+
+        /// <summary>
+        /// Unmarks an item for deconstruction (thread-safe).
+        /// </summary>
+        public static void UnmarkForDeconstruction(Item item)
+        {
+            _deconstructItems.TryRemove(item, out _);
+        }
+
+        /// <summary>
+        /// Checks if an item is marked for deconstruction (thread-safe).
+        /// </summary>
+        public static bool IsMarkedForDeconstruction(Item item)
+        {
+            return _deconstructItems.ContainsKey(item);
+        }
+
+        /// <summary>
+        /// Clears all item collections (thread-safe). Used during unloading.
+        /// </summary>
+        public static void ClearAllItemCollections()
+        {
+            _itemDictionary.Clear();
+            _dangerousItems = ImmutableHashSet<Item>.Empty;
+            _repairableItems = ImmutableHashSet<Item>.Empty;
+            _cleanableItems = ImmutableHashSet<Item>.Empty;
+            _sonarVisibleItems = ImmutableHashSet<Item>.Empty;
+            _turretTargetItems = ImmutableHashSet<Item>.Empty;
+            _chairItems = ImmutableHashSet<Item>.Empty;
+            _deconstructItems.Clear();
+            while (_pendingConditionUpdates.TryDequeue(out _)) { }
+            _cachedItemList = null;
+            _cachedItemListVersion = -1;
+        }
+
+        // Cached item list for indexed access (used by AI systems)
+        private static volatile List<Item> _cachedItemList;
+        private static volatile int _cachedItemListVersion = -1;
+        private static volatile int _itemListVersion;
+
+        /// <summary>
+        /// Gets a cached list snapshot of all items for indexed access.
+        /// The list is refreshed when items are added or removed.
+        /// Thread-safe but may return slightly stale data.
+        /// </summary>
+        public static List<Item> GetCachedItemList()
+        {
+            int currentVersion = _itemListVersion;
+            if (_cachedItemList == null || _cachedItemListVersion != currentVersion)
+            {
+                _cachedItemList = _itemDictionary.Values.ToList();
+                _cachedItemListVersion = currentVersion;
+            }
+            return _cachedItemList;
+        }
+
+        /// <summary>
+        /// Called when items are added or removed to invalidate the cached list.
+        /// </summary>
+        private static void InvalidateCachedItemList()
+        {
+            Interlocked.Increment(ref _itemListVersion);
+        }
+
+        #endregion
+
         #endregion
 
         public new ItemPrefab Prefab => base.Prefab as ItemPrefab;
@@ -179,7 +296,12 @@ namespace Barotrauma
 
         private bool transformDirty = true;
 
-        private static readonly List<Item> itemsWithPendingConditionUpdates = new List<Item>();
+        private static readonly ConcurrentQueue<Item> _pendingConditionUpdates = new ConcurrentQueue<Item>();
+
+        /// <summary>
+        /// Flag to avoid duplicate enqueue for pending condition updates.
+        /// </summary>
+        private volatile bool _hasPendingConditionUpdate;
 
         private float lastSentCondition;
         private float sendConditionUpdateTimer;
@@ -845,11 +967,11 @@ namespace Barotrauma
                 isDangerous = value; 
                 if (!value)
                 {
-                    _dangerousItems.Remove(this);
+                    RemoveFromImmutableSet(ref _dangerousItems, this);
                 }
                 else
                 {
-                    _dangerousItems.Add(this);
+                    AddToImmutableSet(ref _dangerousItems, this);
                 }
             }
         }
@@ -1398,12 +1520,13 @@ namespace Barotrauma
             }
 
             InsertToList();
-            ItemList.Add(this);
-            if (Prefab.IsDangerous) { _dangerousItems.Add(this); }
-            if (Repairables.Any()) { _repairableItems.Add(this); }
-            if (Prefab.SonarSize > 0.0f) { _sonarVisibleItems.Add(this); }
-            if (Prefab.IsAITurretTarget) { _turretTargetItems.Add(this); }
-            if (Prefab.Tags.Contains(Barotrauma.Tags.ChairItem)) { _chairItems.Add(this); }
+            _itemDictionary.TryAdd(ID, this);
+            InvalidateCachedItemList();
+            if (Prefab.IsDangerous) { AddToImmutableSet(ref _dangerousItems, this); }
+            if (Repairables.Any()) { AddToImmutableSet(ref _repairableItems, this); }
+            if (Prefab.SonarSize > 0.0f) { AddToImmutableSet(ref _sonarVisibleItems, this); }
+            if (Prefab.IsAITurretTarget) { AddToImmutableSet(ref _turretTargetItems, this); }
+            if (Prefab.Tags.Contains(Barotrauma.Tags.ChairItem)) { AddToImmutableSet(ref _chairItems, this); }
             CheckCleanable();
 
             DebugConsole.Log("Created " + Name + " (" + ID + ")");
@@ -1699,7 +1822,13 @@ namespace Barotrauma
                 try
                 {
 #endif
-                    body.SetTransformIgnoreContacts(simPosition, rotation, setPrevTransform);
+                    // Defer physics operation if in parallel context (Farseer is not thread-safe)
+                    var capturedBody = body;
+                    var capturedSimPos = simPosition;
+                    var capturedRotation = rotation;
+                    var capturedSetPrevTransform = setPrevTransform;
+                    PhysicsBodyQueue.ExecuteOrDefer(() => 
+                        capturedBody.SetTransformIgnoreContacts(capturedSimPos, capturedRotation, capturedSetPrevTransform));
 #if DEBUG
                 }
                 catch (Exception e)
@@ -1756,14 +1885,11 @@ namespace Barotrauma
                 Prefab.PreferredContainers.Any() &&
                 (container == null || container.HasTag(Barotrauma.Tags.AllowCleanup)))
             {
-                if (!_cleanableItems.Contains(this))
-                {
-                    _cleanableItems.Add(this);
-                }
+                AddToImmutableSet(ref _cleanableItems, this);
             }
             else
             {
-                _cleanableItems.Remove(this);
+                RemoveFromImmutableSet(ref _cleanableItems, this);
             }
         }
 
@@ -1779,13 +1905,19 @@ namespace Barotrauma
 
             if (ItemList != null && body != null)
             {
+                // Defer physics operation if in parallel context (Farseer is not thread-safe)
+                var capturedBody = body;
+                var capturedNewPos = body.SimPosition + ConvertUnits.ToSimUnits(amount);
+                var capturedRotation = body.Rotation;
                 if (ignoreContacts)
                 {
-                    body.SetTransformIgnoreContacts(body.SimPosition + ConvertUnits.ToSimUnits(amount), body.Rotation);
+                    PhysicsBodyQueue.ExecuteOrDefer(() => 
+                        capturedBody.SetTransformIgnoreContacts(capturedNewPos, capturedRotation));
                 }
                 else
                 {
-                    body.SetTransform(body.SimPosition + ConvertUnits.ToSimUnits(amount), body.Rotation);
+                    PhysicsBodyQueue.ExecuteOrDefer(() => 
+                        capturedBody.SetTransform(capturedNewPos, capturedRotation));
                 }
             }
             foreach (ItemComponent ic in components)
@@ -2294,9 +2426,10 @@ namespace Barotrauma
                 {
                     needsConditionUpdate = true;
                 }
-                if (needsConditionUpdate && !itemsWithPendingConditionUpdates.Contains(this))
+                if (needsConditionUpdate && !_hasPendingConditionUpdate)
                 {
-                    itemsWithPendingConditionUpdates.Add(this);
+                    _hasPendingConditionUpdate = true;
+                    _pendingConditionUpdates.Enqueue(this);
                 }
             }
 
@@ -2320,10 +2453,11 @@ namespace Barotrauma
                 {
                     if (c.IsPower)
                     {
-                        Powered.ChangedConnections.Add(c);
-                        foreach (Connection conn in c.Recipients)
+                        Powered.MarkConnectionChanged(c);
+                        // Use ToList() snapshot for thread-safe iteration
+                        foreach (Connection conn in c.Recipients.ToList())
                         {
-                            Powered.ChangedConnections.Add(conn);
+                            Powered.MarkConnectionChanged(conn);
                         }
                     }
                 }
@@ -2352,9 +2486,9 @@ namespace Barotrauma
         public void SendPendingNetworkUpdates()
         {
             if (!(GameMain.NetworkMember is { IsServer: true })) { return; }
-            if (!itemsWithPendingConditionUpdates.Contains(this)) { return; }
+            if (!_hasPendingConditionUpdate) { return; }
             SendPendingNetworkUpdatesInternal();
-            itemsWithPendingConditionUpdates.Remove(this);
+            _hasPendingConditionUpdate = false;
         }
 
         private void SendPendingNetworkUpdatesInternal()
@@ -2383,21 +2517,35 @@ namespace Barotrauma
         public static void UpdatePendingConditionUpdates(float deltaTime)
         {
             if (GameMain.NetworkMember is not { IsServer: true }) { return; }
-            for (int i = 0; i < itemsWithPendingConditionUpdates.Count; i++)
+            
+            int count = _pendingConditionUpdates.Count;
+            for (int i = 0; i < count; i++)
             {
-                var item = itemsWithPendingConditionUpdates[i];
+                if (!_pendingConditionUpdates.TryDequeue(out var item)) { break; }
+                
                 if (item == null || item.Removed)
                 {
-                    itemsWithPendingConditionUpdates.RemoveAt(i--);
+                    item._hasPendingConditionUpdate = false;
+                    continue;
+                }
+                
+                if (item.Submarine is { Loading: true })
+                {
+                    // Re-enqueue, still loading
+                    _pendingConditionUpdates.Enqueue(item);
                     continue;
                 }
-                if (item.Submarine is { Loading: true }) { continue; }
 
                 item.sendConditionUpdateTimer -= deltaTime;
                 if (item.sendConditionUpdateTimer <= 0.0f)
                 {
                     item.SendPendingNetworkUpdatesInternal();
-                    itemsWithPendingConditionUpdates.RemoveAt(i--);
+                    item._hasPendingConditionUpdate = false;
+                }
+                else
+                {
+                    // Not ready yet, re-enqueue
+                    _pendingConditionUpdates.Enqueue(item);
                 }
             }
         }
@@ -2427,7 +2575,12 @@ namespace Barotrauma
                     if (item != this) 
                     {
                         item.body.Enabled = false;
-                        item.body.SetTransformIgnoreContacts(this.SimPosition, body.Rotation); 
+                        // Defer physics operation if in parallel context (Farseer is not thread-safe)
+                        var capturedItemBody = item.body;
+                        var capturedSimPos = this.SimPosition;
+                        var capturedRotation = body.Rotation;
+                        PhysicsBodyQueue.ExecuteOrDefer(() => 
+                            capturedItemBody.SetTransformIgnoreContacts(capturedSimPos, capturedRotation));
                     }
                 }
             }
@@ -2619,17 +2772,25 @@ namespace Barotrauma
                 FindHull();
             }
 
+            // Defer physics transform operations if in parallel context.
+            // Farseer's DynamicTree is not thread-safe.
             if (Submarine == null && prevSub != null)
             {
-                body.SetTransformIgnoreContacts(body.SimPosition + prevSub.SimPosition, body.Rotation);
+                Vector2 newPos = body.SimPosition + prevSub.SimPosition;
+                float rotation = body.Rotation;
+                PhysicsBodyQueue.ExecuteOrDefer(() => body.SetTransformIgnoreContacts(newPos, rotation));
             }
             else if (Submarine != null && prevSub == null)
             {
-                body.SetTransformIgnoreContacts(body.SimPosition - Submarine.SimPosition, body.Rotation);
+                Vector2 newPos = body.SimPosition - Submarine.SimPosition;
+                float rotation = body.Rotation;
+                PhysicsBodyQueue.ExecuteOrDefer(() => body.SetTransformIgnoreContacts(newPos, rotation));
             }
             else if (Submarine != null && prevSub != null && Submarine != prevSub)
             {
-                body.SetTransformIgnoreContacts(body.SimPosition + prevSub.SimPosition - Submarine.SimPosition, body.Rotation);
+                Vector2 newPos = body.SimPosition + prevSub.SimPosition - Submarine.SimPosition;
+                float rotation = body.Rotation;
+                PhysicsBodyQueue.ExecuteOrDefer(() => body.SetTransformIgnoreContacts(newPos, rotation));
             }
 
             if (Submarine != prevSub)
@@ -2845,7 +3006,8 @@ namespace Barotrauma
             foreach (Connection c in connectionPanel.Connections)
             {
                 if (connectionFilter != null && !connectionFilter(c)) { continue; }
-                foreach (Connection recipient in c.Recipients)
+                // Use ToList() snapshot for thread-safe iteration
+                foreach (Connection recipient in c.Recipients.ToList())
                 {
                     var component = recipient.Item.GetComponent<T>();
                     if (component != null)
@@ -2878,7 +3040,8 @@ namespace Barotrauma
             foreach (Connection c in connectionPanel.Connections)
             {
                 if (connectionFilter != null && !connectionFilter(c)) { continue; }
-                foreach (Connection recipient in c.Recipients)
+                // Use ToList() snapshot for thread-safe iteration
+                foreach (Connection recipient in c.Recipients.ToList())
                 {
                     var component = recipient.Item.GetComponent<T>();
                     if (component != null && !connectedComponents.Contains(component))
@@ -2932,12 +3095,13 @@ namespace Barotrauma
             alreadySearched.Add(c);
             static IEnumerable<Connection> GetRecipients(Connection c)
             {
-                foreach (Connection recipient in c.Recipients)
+                // Use ToList() snapshot for thread-safe iteration
+                foreach (Connection recipient in c.Recipients.ToList())
                 {
                     yield return recipient;
                 }
                 //check circuit box inputs/outputs this connection is connected to
-                foreach (var circuitBoxConnection in c.CircuitBoxConnections)
+                foreach (var circuitBoxConnection in c.CircuitBoxConnections.ToArray())
                 {
                     yield return circuitBoxConnection.Connection;
                 }
@@ -3077,7 +3241,8 @@ namespace Barotrauma
             if (signal.stepsTaken > 5 && signal.source != null)
             {
                 int duplicateRecipients = 0;
-                foreach (var recipient in signal.source.LastSentSignalRecipients)
+                // Use ToList() snapshot for thread-safe iteration
+                foreach (var recipient in signal.source.LastSentSignalRecipients.ToList())
                 {
                     if (recipient == connection)
                     {
@@ -3529,6 +3694,30 @@ namespace Barotrauma
             if (body != null)
             {
                 IsActive = true;
+                
+                // Physics body operations must be deferred if we're in a parallel update context,
+                // because Farseer Physics is not thread-safe.
+                if (PhysicsBodyQueue.IsInParallelContext)
+                {
+                    // Capture the values we need for the deferred operation
+                    var capturedBody = body;
+                    var capturedDropperSimPos = dropper?.SimPosition ?? Microsoft.Xna.Framework.Vector2.Zero;
+                    var capturedSetTransform = setTransform && dropper != null;
+                    
+                    PhysicsBodyQueue.Enqueue(() =>
+                    {
+                        if (capturedBody.Removed || Removed) { return; }
+                        capturedBody.Enabled = true;
+                        capturedBody.PhysEnabled = true;
+                        capturedBody.ResetDynamics();
+                        if (capturedSetTransform)
+                        {
+                            capturedBody.SetTransformIgnoreContacts(capturedDropperSimPos, 0.0f);
+                        }
+                    });
+                }
+                else
+                {
                     body.Enabled = true;
                     body.PhysEnabled = true;
                     body.ResetDynamics();
@@ -3546,15 +3735,31 @@ namespace Barotrauma
                         }
                     }
                 }
+            }
 
             foreach (ItemComponent ic in components) { ic.Drop(dropper, setTransform); }
             
             if (Container != null)
             {
                 if (setTransform)
+                {
+                    // Defer SetTransform if in parallel context
+                    if (PhysicsBodyQueue.IsInParallelContext)
+                    {
+                        var capturedContainerSimPos = Container.SimPosition;
+                        PhysicsBodyQueue.Enqueue(() =>
+                        {
+                            if (!Removed)
+                            {
+                                SetTransform(capturedContainerSimPos, 0.0f);
+                            }
+                        });
+                    }
+                    else
                     {
                         SetTransform(Container.SimPosition, 0.0f);
                     }
+                }
                 Container.RemoveContained(this);
                 Container = null;
             }
@@ -4217,7 +4422,7 @@ namespace Barotrauma
                 }
             }
 
-            if (element.GetAttributeBool("markedfordeconstruction", false)) { _deconstructItems.Add(item); }
+            if (element.GetAttributeBool("markedfordeconstruction", false)) { _deconstructItems.TryAdd(item, 0); }
 
             float prevRotation = item.Rotation;
             if (element.GetAttributeBool("flippedx", false)) { item.FlipX(relativeToSub: false, force: true); }
@@ -4510,7 +4715,7 @@ namespace Barotrauma
                 new XAttribute("name", Prefab.OriginalName),
                 new XAttribute("identifier", Prefab.Identifier),
                 new XAttribute("ID", ID),
-                new XAttribute("markedfordeconstruction", _deconstructItems.Contains(this)));
+                new XAttribute("markedfordeconstruction", _deconstructItems.ContainsKey(this)));
 
             if (PendingItemSwap != null)
             {
@@ -4713,14 +4918,16 @@ namespace Barotrauma
 
         private void RemoveFromLists()
         {
-            ItemList.Remove(this);
-            _dangerousItems.Remove(this);
-            _repairableItems.Remove(this);
-            _sonarVisibleItems.Remove(this);
-            _cleanableItems.Remove(this);
-            _deconstructItems.Remove(this);
-            _turretTargetItems.Remove(this);
-            _chairItems.Remove(this);
+            _itemDictionary.TryRemove(ID, out _);
+            InvalidateCachedItemList();
+            RemoveFromImmutableSet(ref _dangerousItems, this);
+            RemoveFromImmutableSet(ref _repairableItems, this);
+            RemoveFromImmutableSet(ref _sonarVisibleItems, this);
+            RemoveFromImmutableSet(ref _cleanableItems, this);
+            _deconstructItems.TryRemove(this, out _);
+            RemoveFromImmutableSet(ref _turretTargetItems, this);
+            RemoveFromImmutableSet(ref _chairItems, this);
+            _hasPendingConditionUpdate = false;
             RemoveFromDroppedStack(allowClientExecute: true);
         }
 

Barotrauma/BarotraumaShared/SharedSource/Map/Creatures/BallastFloraBehavior.cs

@@ -4,6 +4,7 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
 using System.Linq;
+using System.Threading;
 using System.Xml.Linq;
 using Barotrauma.Extensions;
 using Barotrauma.Items.Components;
@@ -14,6 +15,55 @@ using Microsoft.Xna.Framework;
 
 namespace Barotrauma.MapCreatures.Behavior
 {
+    /// <summary>
+    /// Thread-safe wrapper for BallastFloraBehavior list operations.
+    /// Uses copy-on-write pattern for lock-free reads.
+    /// </summary>
+    internal class ThreadSafeBallastFloraList : IEnumerable<BallastFloraBehavior>
+    {
+        private volatile List<BallastFloraBehavior> _list = new List<BallastFloraBehavior>();
+        private readonly object _writeLock = new object();
+
+        public int Count => _list.Count;
+
+        public void Add(BallastFloraBehavior entity)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<BallastFloraBehavior>(_list) { entity };
+                Interlocked.Exchange(ref _list, newList);
+            }
+        }
+
+        public bool Remove(BallastFloraBehavior entity)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<BallastFloraBehavior>(_list);
+                bool removed = newList.Remove(entity);
+                if (removed)
+                {
+                    Interlocked.Exchange(ref _list, newList);
+                }
+                return removed;
+            }
+        }
+
+        public void Clear()
+        {
+            Interlocked.Exchange(ref _list, new List<BallastFloraBehavior>());
+        }
+
+        public IEnumerator<BallastFloraBehavior> GetEnumerator() => _list.GetEnumerator();
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
+
+        // LINQ-friendly methods
+        public List<BallastFloraBehavior> ToList() => new List<BallastFloraBehavior>(_list);
+        public bool Any() => _list.Any();
+        public bool Any(Func<BallastFloraBehavior, bool> predicate) => _list.Any(predicate);
+        public IEnumerable<BallastFloraBehavior> Where(Func<BallastFloraBehavior, bool> predicate) => _list.Where(predicate);
+    }
+
     class BallastFloraBranch : VineTile
     {
         public readonly BallastFloraBehavior? ParentBallastFlora;
@@ -132,7 +182,7 @@ namespace Barotrauma.MapCreatures.Behavior
         public List<Tuple<Vector2, Vector2>> debugSearchLines = new List<Tuple<Vector2, Vector2>>();
 #endif
 
-        private readonly static List<BallastFloraBehavior> _entityList = new List<BallastFloraBehavior>();
+        private readonly static ThreadSafeBallastFloraList _entityList = new ThreadSafeBallastFloraList();
         public static IEnumerable<BallastFloraBehavior> EntityList => _entityList;
 
         public enum NetworkHeader
@@ -308,6 +358,12 @@ namespace Barotrauma.MapCreatures.Behavior
         private BallastFloraBranch? root;
         private readonly List<Body> bodies = new List<Body>();
         
+        /// <summary>
+        /// Branches that need physics bodies created on the main thread.
+        /// </summary>
+        private readonly List<BallastFloraBranch> pendingBodyCreations = new List<BallastFloraBranch>();
+        private readonly object pendingBodyCreationsLock = new object();
+
         private bool isDead;
 
         public readonly BallastFloraStateMachine StateMachine;
@@ -347,7 +403,8 @@ namespace Barotrauma.MapCreatures.Behavior
                     }
                 }
                 UpdateConnections(branch);
-                CreateBody(branch);
+                // OnMapLoaded runs on the main thread, so we can create bodies immediately
+                CreateBody(branch, immediate: true);
             }
         }
 
@@ -998,10 +1055,52 @@ namespace Barotrauma.MapCreatures.Behavior
         }
 
         /// <summary>
-        /// Create a body for a branch which works as the hitbox for flamer
+        /// Queue a physics body creation for a branch.
+        /// The actual body will be created on the main thread to ensure thread safety.
         /// </summary>
-        /// <param name="branch"></param>
-        private void CreateBody(BallastFloraBranch branch)
+        /// <param name="branch">The branch to create a body for</param>
+        /// <param name="immediate">If true, create the body immediately (only safe when called from main thread)</param>
+        private void CreateBody(BallastFloraBranch branch, bool immediate = false)
+        {
+            if (immediate)
+            {
+                CreateBodyImmediate(branch);
+                return;
+            }
+            
+            lock (pendingBodyCreationsLock)
+            {
+                pendingBodyCreations.Add(branch);
+            }
+            PhysicsBodyQueue.EnqueueCreation(() => ProcessPendingBodyCreations());
+        }
+
+        /// <summary>
+        /// Process all pending body creations on the main thread.
+        /// This ensures Farseer Physics operations are thread-safe.
+        /// </summary>
+        private void ProcessPendingBodyCreations()
+        {
+            List<BallastFloraBranch> branchesToProcess;
+            lock (pendingBodyCreationsLock)
+            {
+                if (pendingBodyCreations.Count == 0) { return; }
+                branchesToProcess = new List<BallastFloraBranch>(pendingBodyCreations);
+                pendingBodyCreations.Clear();
+            }
+
+            foreach (var branch in branchesToProcess)
+            {
+                if (branch.Removed) { continue; }
+                CreateBodyImmediate(branch);
+            }
+        }
+
+        /// <summary>
+        /// Actually create the physics body for a branch.
+        /// Must be called on the main thread.
+        /// </summary>
+        private void CreateBodyImmediate(BallastFloraBranch branch)
         {
             Rectangle rect = branch.Rect;
             Vector2 pos = Parent.Position + Offset + branch.Position;

Barotrauma/BarotraumaShared/SharedSource/Map/Entity.cs

@@ -1,5 +1,6 @@
 using Microsoft.Xna.Framework;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using Barotrauma.IO;
@@ -20,10 +21,10 @@ namespace Barotrauma
 
         public const ushort MaxEntityCount = ushort.MaxValue - 4; //ushort.MaxValue - 4 because the 4 values above are reserved values
 
-        private static readonly Dictionary<ushort, Entity> dictionary = new Dictionary<ushort, Entity>();
+        private static readonly ConcurrentDictionary<ushort, Entity> dictionary = new ConcurrentDictionary<ushort, Entity>();
         public static IReadOnlyCollection<Entity> GetEntities()
         {
-            return dictionary.Values;
+            return (IReadOnlyCollection<Entity>)dictionary.Values;
         }
 
         public static int EntityCount => dictionary.Count;
@@ -122,13 +123,11 @@ namespace Barotrauma
             //give a unique ID
             ID = DetermineID(id, submarine);
 
-            if (dictionary.ContainsKey(ID))
+            if (!dictionary.TryAdd(ID, this))
             {
                 throw new Exception($"ID {ID} is taken by {dictionary[ID]}");
             }
 
-            dictionary.Add(ID, this);
-
             CreationStackTrace = "";
 #if DEBUG
             var st = new StackTrace(skipFrames: 2, fNeedFileInfo: true);
@@ -147,7 +146,6 @@ namespace Barotrauma
                 CreationStackTrace += $"{fileName}@{fileLineNumber}; ";
             }
 #endif
-            #warning TODO: consider removing this mutex, entity creation probably shouldn't be multithreaded
             lock (creationCounterMutex)
             {
                 CreationIndex = creationCounter;
@@ -261,7 +259,7 @@ namespace Barotrauma
                         DebugConsole.ThrowError($"Error while removing item \"{item}\"", exception);
                     }
                 }
-                Item.ItemList.Clear();
+                Item.ClearAllItemCollections();
             }
             if (Character.CharacterList.Count > 0)
             {
@@ -325,7 +323,7 @@ namespace Barotrauma
             }
             else
             {
-                dictionary.Remove(ID);
+                dictionary.TryRemove(ID, out _);
             }
             IdFreed = true;
         }

Barotrauma/BarotraumaShared/SharedSource/Map/Explosion.cs

@@ -7,6 +7,7 @@ using Microsoft.Xna.Framework;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 
 namespace Barotrauma
 {
@@ -648,7 +649,11 @@ namespace Barotrauma
             }
         }
 
-        private static readonly Dictionary<Structure, float> damagedStructures = new Dictionary<Structure, float>();
+        // ThreadLocal for thread-safe structure damage tracking
+        private static readonly ThreadLocal<Dictionary<Structure, float>> damagedStructuresLocal = 
+            new ThreadLocal<Dictionary<Structure, float>>(() => new Dictionary<Structure, float>());
+        private static Dictionary<Structure, float> damagedStructures => damagedStructuresLocal.Value;
+        
         /// <summary>
         /// Returns a dictionary where the keys are the structures that took damage and the values are the amount of damage taken
         /// </summary>

Barotrauma/BarotraumaShared/SharedSource/Map/Gap.cs

@@ -8,13 +8,71 @@ using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Xml.Linq;
 
 namespace Barotrauma
 {
+    /// <summary>
+    /// Thread-safe wrapper for Gap list operations.
+    /// Uses copy-on-write pattern for lock-free reads.
+    /// </summary>
+    internal class ThreadSafeGapList : IEnumerable<Gap>
+    {
+        private volatile List<Gap> _list = new List<Gap>();
+        private readonly object _writeLock = new object();
+
+        public int Count => _list.Count;
+
+        public void Add(Gap gap)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<Gap>(_list) { gap };
+                Interlocked.Exchange(ref _list, newList);
+            }
+        }
+
+        public bool Remove(Gap gap)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<Gap>(_list);
+                bool removed = newList.Remove(gap);
+                if (removed)
+                {
+                    Interlocked.Exchange(ref _list, newList);
+                }
+                return removed;
+            }
+        }
+
+        public void Clear()
+        {
+            Interlocked.Exchange(ref _list, new List<Gap>());
+        }
+
+        public bool Contains(Gap gap) => _list.Contains(gap);
+
+        public Gap this[int index] => _list[index];
+
+        public IEnumerator<Gap> GetEnumerator() => _list.GetEnumerator();
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
+
+        // LINQ-friendly methods
+        public List<Gap> ToList() => new List<Gap>(_list);
+        public Gap FirstOrDefault(Func<Gap, bool> predicate) => _list.FirstOrDefault(predicate);
+        public Gap Find(Predicate<Gap> predicate) => _list.Find(predicate);
+        public List<Gap> FindAll(Predicate<Gap> predicate) => _list.FindAll(predicate);
+        public IEnumerable<Gap> Where(Func<Gap, bool> predicate) => _list.Where(predicate);
+        public bool Any() => _list.Any();
+        public bool Any(Func<Gap, bool> predicate) => _list.Any(predicate);
+        public IOrderedEnumerable<Gap> OrderBy<TKey>(Func<Gap, TKey> keySelector) => _list.OrderBy(keySelector);
+    }
+
     partial class Gap : MapEntity, ISerializableEntity
     {
-        public static List<Gap> GapList = new List<Gap>();
+        public static ThreadSafeGapList GapList = new ThreadSafeGapList();
 
         const float MaxFlowForce = 500.0f;
 

Barotrauma/BarotraumaShared/SharedSource/Map/Hull.cs

@@ -6,6 +6,7 @@ using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using System.Threading;
 using System.Xml.Linq;
 using Barotrauma.MapCreatures.Behavior;
 using Barotrauma.Items.Components;
@@ -13,6 +14,116 @@ using Barotrauma.Extensions;
 
 namespace Barotrauma
 {
+    /// <summary>
+    /// Thread-safe wrapper for Hull list operations.
+    /// Uses copy-on-write pattern for lock-free reads.
+    /// </summary>
+    internal class ThreadSafeHullList : IEnumerable<Hull>
+    {
+        private volatile List<Hull> _list = new List<Hull>();
+        private readonly object _writeLock = new object();
+
+        public int Count => _list.Count;
+
+        public void Add(Hull hull)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<Hull>(_list) { hull };
+                Interlocked.Exchange(ref _list, newList);
+            }
+        }
+
+        public bool Remove(Hull hull)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<Hull>(_list);
+                bool removed = newList.Remove(hull);
+                if (removed)
+                {
+                    Interlocked.Exchange(ref _list, newList);
+                }
+                return removed;
+            }
+        }
+
+        public void Clear()
+        {
+            Interlocked.Exchange(ref _list, new List<Hull>());
+        }
+
+        public bool Contains(Hull hull) => _list.Contains(hull);
+
+        public Hull this[int index] => _list[index];
+
+        public IEnumerator<Hull> GetEnumerator() => _list.GetEnumerator();
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
+
+        // LINQ-friendly methods
+        public List<Hull> ToList() => new List<Hull>(_list);
+        public Hull FirstOrDefault(Func<Hull, bool> predicate) => _list.FirstOrDefault(predicate);
+        public Hull Find(Predicate<Hull> predicate) => _list.Find(predicate);
+        public List<Hull> FindAll(Predicate<Hull> predicate) => _list.FindAll(predicate);
+        public IEnumerable<Hull> Where(Func<Hull, bool> predicate) => _list.Where(predicate);
+        public bool Any() => _list.Any();
+        public bool Any(Func<Hull, bool> predicate) => _list.Any(predicate);
+        public bool Exists(Predicate<Hull> predicate) => _list.Exists(predicate);
+        public void ForEach(Action<Hull> action) => _list.ForEach(action);
+    }
+
+    /// <summary>
+    /// Thread-safe wrapper for EntityGrid list operations.
+    /// Uses copy-on-write pattern for lock-free reads.
+    /// </summary>
+    internal class ThreadSafeEntityGridList : IEnumerable<EntityGrid>
+    {
+        private volatile List<EntityGrid> _list = new List<EntityGrid>();
+        private readonly object _writeLock = new object();
+
+        public int Count => _list.Count;
+
+        public void Add(EntityGrid grid)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<EntityGrid>(_list) { grid };
+                Interlocked.Exchange(ref _list, newList);
+            }
+        }
+
+        public bool Remove(EntityGrid grid)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<EntityGrid>(_list);
+                bool removed = newList.Remove(grid);
+                if (removed)
+                {
+                    Interlocked.Exchange(ref _list, newList);
+                }
+                return removed;
+            }
+        }
+
+        public void Clear()
+        {
+            Interlocked.Exchange(ref _list, new List<EntityGrid>());
+        }
+
+        public EntityGrid this[int index] => _list[index];
+
+        public IEnumerator<EntityGrid> GetEnumerator() => _list.GetEnumerator();
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
+
+        // LINQ-friendly methods
+        public List<EntityGrid> ToList() => new List<EntityGrid>(_list);
+        public EntityGrid FirstOrDefault(Func<EntityGrid, bool> predicate) => _list.FirstOrDefault(predicate);
+        public EntityGrid Find(Predicate<EntityGrid> predicate) => _list.Find(predicate);
+        public IEnumerable<EntityGrid> Where(Func<EntityGrid, bool> predicate) => _list.Where(predicate);
+        public bool Any() => _list.Any();
+    }
+
     partial class BackgroundSection
     {
         public Rectangle Rect;
@@ -113,8 +224,8 @@ namespace Barotrauma
 
     partial class Hull : MapEntity, ISerializableEntity, IServerSerializable
     {
-        public readonly static List<Hull> HullList = new List<Hull>();
-        public readonly static List<EntityGrid> EntityGrids = new List<EntityGrid>();
+        public readonly static ThreadSafeHullList HullList = new ThreadSafeHullList();
+        public readonly static ThreadSafeEntityGridList EntityGrids = new ThreadSafeEntityGridList();
 
         public static bool ShowHulls = true;
 
@@ -1133,13 +1244,18 @@ namespace Barotrauma
         }
 
         /// <summary>
-        /// Used in <see cref="GetApproximateDistance"/>
+        /// Used in <see cref="GetApproximateDistance"/> - ThreadLocal for thread safety
         /// </summary>
-        private static readonly Dictionary<Hull, float> cachedDistances = [];
+        private static readonly ThreadLocal<Dictionary<Hull, float>> cachedDistancesLocal = 
+            new ThreadLocal<Dictionary<Hull, float>>(() => new Dictionary<Hull, float>());
         /// <summary>
-        /// Used in <see cref="GetApproximateDistance"/>
+        /// Used in <see cref="GetApproximateDistance"/> - ThreadLocal for thread safety
         /// </summary>
-        private static readonly PriorityQueue<(Hull hull, Vector2 pos), float> priorityQueue = new PriorityQueue<(Hull hull, Vector2 pos), float>();
+        private static readonly ThreadLocal<PriorityQueue<(Hull hull, Vector2 pos), float>> priorityQueueLocal = 
+            new ThreadLocal<PriorityQueue<(Hull hull, Vector2 pos), float>>(() => new PriorityQueue<(Hull hull, Vector2 pos), float>());
+        
+        private static Dictionary<Hull, float> cachedDistances => cachedDistancesLocal.Value;
+        private static PriorityQueue<(Hull hull, Vector2 pos), float> priorityQueue => priorityQueueLocal.Value;
 
         /// <summary>
         /// Approximate distance from this hull to the target hull, moving through open gaps without passing through walls.

Barotrauma/BarotraumaShared/SharedSource/Map/Levels/Level.cs

@@ -4775,7 +4775,7 @@ namespace Barotrauma
             //     BeaconStation.FlipX();
             // }
 
-            Item sonarItem = Item.ItemList.Find(it => it.Submarine == BeaconStation && it.GetComponent<Sonar>() != null);
+            Item sonarItem = Item.ItemList.FirstOrDefault(it => it.Submarine == BeaconStation && it.GetComponent<Sonar>() != null);
             if (sonarItem == null)
             {
                 DebugConsole.ThrowError($"No sonar found in the beacon station \"{beaconStationName}\"!");
@@ -4794,7 +4794,7 @@ namespace Barotrauma
                 throw new InvalidOperationException("Failed to prepare beacon station (no beacon station in the level).");
             }
 
-            List<Item> beaconItems = Item.ItemList.FindAll(it => it.Submarine == BeaconStation);
+            List<Item> beaconItems = Item.ItemList.Where(it => it.Submarine == BeaconStation).ToList();
 
             Item reactorItem = beaconItems.Find(it => it.GetComponent<Reactor>() != null);
             Reactor reactorComponent = null;
@@ -4840,7 +4840,7 @@ namespace Barotrauma
             if (BeaconStation?.Info?.BeaconStationInfo is { AllowDisconnectedWires: false }) { return; }
 
             if (disconnectWireProbability <= 0.0f) { return; }
-            List<Item> beaconItems = Item.ItemList.FindAll(it => it.Submarine == BeaconStation);
+            List<Item> beaconItems = Item.ItemList.Where(it => it.Submarine == BeaconStation).ToList();
             foreach (Item item in beaconItems.Where(it => it.GetComponent<Wire>() != null).ToList())
             {
                 if (item.NonInteractable || item.InvulnerableToDamage) { continue; }
@@ -4878,7 +4878,7 @@ namespace Barotrauma
 
             if (breakDeviceProbability <= 0.0f) { return; }
             //break powered items
-            List<Item> beaconItems = Item.ItemList.FindAll(it => it.Submarine == BeaconStation);
+            List<Item> beaconItems = Item.ItemList.Where(it => it.Submarine == BeaconStation).ToList();
             foreach (Item item in beaconItems.Where(it => it.Components.Any(c => c is Powered) && it.Components.Any(c => c is Repairable)))
             {
                 if (item.NonInteractable || item.InvulnerableToDamage) { continue; }

Barotrauma/BarotraumaShared/SharedSource/Map/Map/Location.cs

@@ -1371,7 +1371,7 @@ namespace Barotrauma
         {
             foreach (TakenItem takenItem in takenItems)
             {
-                Item item = Item.ItemList.Find(it => takenItem.Matches(it));
+                Item item = Item.ItemList.FirstOrDefault(it => takenItem.Matches(it));
                 item?.Remove();
             }
         }

Barotrauma/BarotraumaShared/SharedSource/Map/MapEntity.cs

@@ -6,14 +6,111 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
+using System.Threading;
 using System.Threading.Tasks;
 using System.Xml.Linq;
 
 namespace Barotrauma
 {
+    /// <summary>
+    /// Thread-safe wrapper for MapEntity list operations.
+    /// Uses copy-on-write pattern for lock-free reads.
+    /// </summary>
+    internal class ThreadSafeMapEntityList : IEnumerable<MapEntity>
+    {
+        private volatile List<MapEntity> _list = new List<MapEntity>();
+        private readonly object _writeLock = new object();
+
+        public int Count => _list.Count;
+
+        public void Add(MapEntity entity)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<MapEntity>(_list) { entity };
+                Interlocked.Exchange(ref _list, newList);
+            }
+        }
+
+        public void Insert(int index, MapEntity entity)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<MapEntity>(_list);
+                newList.Insert(index, entity);
+                Interlocked.Exchange(ref _list, newList);
+            }
+        }
+
+        /// <summary>
+        /// Atomically inserts an entity at a position determined by the insertAction.
+        /// The insertAction is executed within the lock to ensure thread-safety.
+        /// </summary>
+        public void InsertWithAction(MapEntity entity, Action<List<MapEntity>, MapEntity> insertAction)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<MapEntity>(_list);
+                insertAction(newList, entity);
+                Interlocked.Exchange(ref _list, newList);
+            }
+        }
+
+        public bool Remove(MapEntity entity)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<MapEntity>(_list);
+                bool removed = newList.Remove(entity);
+                if (removed)
+                {
+                    Interlocked.Exchange(ref _list, newList);
+                }
+                return removed;
+            }
+        }
+
+        public int RemoveAll(Predicate<MapEntity> match)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<MapEntity>(_list);
+                int count = newList.RemoveAll(match);
+                if (count > 0)
+                {
+                    Interlocked.Exchange(ref _list, newList);
+                }
+                return count;
+            }
+        }
+
+        public void Clear()
+        {
+            Interlocked.Exchange(ref _list, new List<MapEntity>());
+        }
+
+        public bool Contains(MapEntity entity) => _list.Contains(entity);
+
+        public MapEntity this[int index] => _list[index];
+
+        public IEnumerator<MapEntity> GetEnumerator() => _list.GetEnumerator();
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
+
+        // LINQ-friendly methods that work on a snapshot
+        public List<MapEntity> ToList() => new List<MapEntity>(_list);
+        public MapEntity FirstOrDefault(Func<MapEntity, bool> predicate) => _list.FirstOrDefault(predicate);
+        public MapEntity Find(Predicate<MapEntity> predicate) => _list.Find(predicate);
+        public List<MapEntity> FindAll(Predicate<MapEntity> predicate) => _list.FindAll(predicate);
+        public IEnumerable<MapEntity> Where(Func<MapEntity, bool> predicate) => _list.Where(predicate);
+        public bool Any(Func<MapEntity, bool> predicate) => _list.Any(predicate);
+        public bool Exists(Predicate<MapEntity> predicate) => _list.Exists(predicate);
+        public IOrderedEnumerable<MapEntity> OrderBy<TKey>(Func<MapEntity, TKey> keySelector) => _list.OrderBy(keySelector);
+        public void ForEach(Action<MapEntity> action) => _list.ForEach(action);
+    }
+
     abstract partial class MapEntity : Entity, ISpatialEntity
     {
-        public readonly static List<MapEntity> MapEntityList = new List<MapEntity>();
+        public readonly static ThreadSafeMapEntityList MapEntityList = new ThreadSafeMapEntityList();
 
         public readonly MapEntityPrefab Prefab;
 
@@ -559,45 +656,51 @@ namespace Barotrauma
                 return;
             }
 
+            // Use atomic insertion to ensure thread-safety
+            MapEntityList.InsertWithAction(this, (list, entity) =>
+            {
+                int i = 0;
+                
                 //sort damageable walls by sprite depth:
                 //necessary because rendering the damage effect starts a new sprite batch and breaks the order otherwise
-            int i = 0;
-            if (this is Structure { DrawDamageEffect: true } structure)
+                if (entity is Structure { DrawDamageEffect: true } structure)
                 {
                     //insertion sort according to draw depth
                     float drawDepth = structure.SpriteDepth;
-                while (i < MapEntityList.Count)
+                    while (i < list.Count)
                     {
-                    float otherDrawDepth = (MapEntityList[i] as Structure)?.SpriteDepth ?? 1.0f;
+                        float otherDrawDepth = (list[i] as Structure)?.SpriteDepth ?? 1.0f;
                         if (otherDrawDepth < drawDepth) { break; }
                         i++;
                     }
-                MapEntityList.Insert(i, this);
+                    list.Insert(i, entity);
                     return;
                 }
 
                 i = 0;
-            while (i < MapEntityList.Count)
+                var mapEntity = (MapEntity)entity;
+                while (i < list.Count)
                 {
                     i++;
-                if (MapEntityList[i - 1]?.Prefab == Prefab)
+                    if (list[i - 1]?.Prefab == mapEntity.Prefab)
                     {
-                    MapEntityList.Insert(i, this);
+                        list.Insert(i, entity);
                         return;
                     }
                 }
 
 #if CLIENT
                 i = 0;
-            while (i < MapEntityList.Count)
+                while (i < list.Count)
                 {
                     i++;
-                Sprite existingSprite = MapEntityList[i - 1].Sprite;
+                    Sprite existingSprite = list[i - 1].Sprite;
                     if (existingSprite == null) { continue; }
-                if (existingSprite.Texture == this.Sprite.Texture) { break; }
+                    if (existingSprite.Texture == mapEntity.Sprite?.Texture) { break; }
                 }
 #endif
-            MapEntityList.Insert(i, this);
+                list.Insert(i, entity);
+            });
         }
 
         /// <summary>
@@ -659,16 +762,32 @@ namespace Barotrauma
                 {
                     // basically nothing here is thread-safe so
                     foreach(var hull in hullList)
+                    {
+                        PhysicsBodyQueue.IsInParallelContext = true;
+                        try
                         {
                             hull.Update(deltaTime, cam);
                         }
+                        finally
+                        {
+                            PhysicsBodyQueue.IsInParallelContext = false;
+                        }
+                    });
                 },
                 // Structure parallel update
                 () =>
                 {
                     Parallel.ForEach(structureList, parallelOptions, structure =>
+                    {
+                        PhysicsBodyQueue.IsInParallelContext = true;
+                        try
                         {
                             structure.Update(deltaTime, cam);
+                        }
+                        finally
+                        {
+                            PhysicsBodyQueue.IsInParallelContext = false;
+                        }
                     });
                 },
                 // Gap reset (must be done before update)
@@ -686,6 +805,10 @@ namespace Barotrauma
                 }
             );
 
+            // Process any physics operations queued during Hull/Structure updates.
+            // BallastFlora growth (from Hull.Update) may queue physics body creations/transforms.
+            PhysicsBodyQueue.ProcessPendingOperations();
+
 #if CLIENT
             // Hull Cheats need to be executed after Hull update
             Hull.UpdateCheats(deltaTime, cam);
@@ -694,10 +817,21 @@ namespace Barotrauma
             // Gap update (has order dependencies, keep random order but execute sequentially)
             var shuffledGaps = gapList.OrderBy(g => Rand.Int(int.MaxValue)).ToList();
             Parallel.ForEach(gapList, parallelOptions, gap =>
+            {
+                PhysicsBodyQueue.IsInParallelContext = true;
+                try
                 {
                     gap.Update(deltaTime, cam);
+                }
+                finally
+                {
+                    PhysicsBodyQueue.IsInParallelContext = false;
+                }
             });
             
+            // Process any physics operations queued during Gap updates.
+            PhysicsBodyQueue.ProcessPendingOperations();
+
 #if CLIENT
             sw.Stop();
             GameMain.PerformanceCounter.AddElapsedTicks("Update:MapEntity:Misc", sw.ElapsedTicks);
@@ -712,11 +846,19 @@ namespace Barotrauma
 
             try
             {
-                foreach (Item item in itemList)
+                Parallel.ForEach(itemList, parallelOptions, item =>
+                {
+                    PhysicsBodyQueue.IsInParallelContext = true;
+                    try
                     {
                         lastUpdatedItem = item;
                         item.Update(scaledDeltaTime, cam);
                     }
+                    finally
+                    {
+                        PhysicsBodyQueue.IsInParallelContext = false;
+                    }
+                });
             }
             catch (InvalidOperationException e)
             {
@@ -727,6 +869,10 @@ namespace Barotrauma
                 throw new InvalidOperationException($"Error while updating item {lastUpdatedItem?.Name ?? "null"}", innerException: e);
             }
 
+            // Process any physics operations that were queued during the parallel update.
+            // This must be done on the main thread because Farseer Physics is not thread-safe.
+            PhysicsBodyQueue.ProcessPendingOperations();
+
             UpdateAllProjSpecific(scaledDeltaTime);
             Spawner?.Update();
 

Barotrauma/BarotraumaShared/SharedSource/Map/Structure.cs

@@ -7,6 +7,7 @@ using Microsoft.Xna.Framework;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Xml.Linq;
 using System.Collections.Immutable;
 using Barotrauma.Abilities;
@@ -18,6 +19,63 @@ using Barotrauma.Lights;
 
 namespace Barotrauma
 {
+    /// <summary>
+    /// Thread-safe wrapper for Structure list operations.
+    /// Uses copy-on-write pattern for lock-free reads.
+    /// </summary>
+    internal class ThreadSafeStructureList : IEnumerable<Structure>
+    {
+        private volatile List<Structure> _list = new List<Structure>();
+        private readonly object _writeLock = new object();
+
+        public int Count => _list.Count;
+
+        public void Add(Structure structure)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<Structure>(_list) { structure };
+                Interlocked.Exchange(ref _list, newList);
+            }
+        }
+
+        public bool Remove(Structure structure)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<Structure>(_list);
+                bool removed = newList.Remove(structure);
+                if (removed)
+                {
+                    Interlocked.Exchange(ref _list, newList);
+                }
+                return removed;
+            }
+        }
+
+        public void Clear()
+        {
+            Interlocked.Exchange(ref _list, new List<Structure>());
+        }
+
+        public bool Contains(Structure structure) => _list.Contains(structure);
+
+        public Structure this[int index] => _list[index];
+
+        public IEnumerator<Structure> GetEnumerator() => _list.GetEnumerator();
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
+
+        // LINQ-friendly methods
+        public List<Structure> ToList() => new List<Structure>(_list);
+        public Structure FirstOrDefault(Func<Structure, bool> predicate) => _list.FirstOrDefault(predicate);
+        public Structure Find(Predicate<Structure> predicate) => _list.Find(predicate);
+        public List<Structure> FindAll(Predicate<Structure> predicate) => _list.FindAll(predicate);
+        public IEnumerable<Structure> Where(Func<Structure, bool> predicate) => _list.Where(predicate);
+        public bool Any() => _list.Any();
+        public bool Any(Func<Structure, bool> predicate) => _list.Any(predicate);
+        public void ForEach(Action<Structure> action) => _list.ForEach(action);
+    }
+
     partial class WallSection : IIgnorable
     {
         public Rectangle rect;
@@ -48,7 +106,7 @@ namespace Barotrauma
     partial class Structure : MapEntity, IDamageable, IServerSerializable, ISerializableEntity
     {
         public const int WallSectionSize = 96;
-        public static List<Structure> WallList = new List<Structure>();
+        public static ThreadSafeStructureList WallList = new ThreadSafeStructureList();
 
         const float LeakThreshold = 0.1f;
         const float BigGapThreshold = 0.7f;

Barotrauma/BarotraumaShared/SharedSource/Map/Submarine.cs

@@ -12,11 +12,70 @@ using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading;
 using System.Xml.Linq;
 using Voronoi2;
 
 namespace Barotrauma
 {
+    /// <summary>
+    /// Thread-safe wrapper for Submarine list operations.
+    /// Uses copy-on-write pattern for lock-free reads.
+    /// </summary>
+    internal class ThreadSafeSubmarineList : IEnumerable<Submarine>
+    {
+        private volatile List<Submarine> _list = new List<Submarine>();
+        private readonly object _writeLock = new object();
+
+        public int Count => _list.Count;
+
+        public void Add(Submarine submarine)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<Submarine>(_list) { submarine };
+                Interlocked.Exchange(ref _list, newList);
+            }
+        }
+
+        public bool Remove(Submarine submarine)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<Submarine>(_list);
+                bool removed = newList.Remove(submarine);
+                if (removed)
+                {
+                    Interlocked.Exchange(ref _list, newList);
+                }
+                return removed;
+            }
+        }
+
+        public void Clear()
+        {
+            Interlocked.Exchange(ref _list, new List<Submarine>());
+        }
+
+        public bool Contains(Submarine submarine) => _list.Contains(submarine);
+
+        public Submarine this[int index] => _list[index];
+
+        public IEnumerator<Submarine> GetEnumerator() => _list.GetEnumerator();
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
+
+        // LINQ-friendly methods
+        public List<Submarine> ToList() => new List<Submarine>(_list);
+        public Submarine FirstOrDefault(Func<Submarine, bool> predicate) => _list.FirstOrDefault(predicate);
+        public Submarine Find(Predicate<Submarine> predicate) => _list.Find(predicate);
+        public List<Submarine> FindAll(Predicate<Submarine> predicate) => _list.FindAll(predicate);
+        public IEnumerable<Submarine> Where(Func<Submarine, bool> predicate) => _list.Where(predicate);
+        public bool Any() => _list.Any();
+        public bool Any(Func<Submarine, bool> predicate) => _list.Any(predicate);
+        public float Sum(Func<Submarine, float> selector) => _list.Sum(selector);
+        public IEnumerable<TResult> Select<TResult>(Func<Submarine, TResult> selector) => _list.Select(selector);
+    }
+
     public enum Direction : byte
     {
         None = 0, Left = 1, Right = 2
@@ -72,7 +131,7 @@ namespace Barotrauma
             get { return MainSubs[0]; }
             set { MainSubs[0] = value; }
         }
-        private static readonly List<Submarine> loaded = new List<Submarine>();
+        private static readonly ThreadSafeSubmarineList loaded = new ThreadSafeSubmarineList();
 
         private readonly Identifier upgradeEventIdentifier;
 
@@ -97,10 +156,11 @@ namespace Barotrauma
             }
         }
 
-        private static Vector2 lastPickedPosition;
-        private static float lastPickedFraction;
-        private static Fixture lastPickedFixture;
-        private static Vector2 lastPickedNormal;
+        // ThreadLocal for thread-safe ray casting results
+        private static readonly ThreadLocal<Vector2> lastPickedPositionLocal = new ThreadLocal<Vector2>();
+        private static readonly ThreadLocal<float> lastPickedFractionLocal = new ThreadLocal<float>();
+        private static readonly ThreadLocal<Fixture> lastPickedFixtureLocal = new ThreadLocal<Fixture>();
+        private static readonly ThreadLocal<Vector2> lastPickedNormalLocal = new ThreadLocal<Vector2>();
 
         private Vector2 prevPosition;
 
@@ -114,22 +174,22 @@ namespace Barotrauma
 
         public static Vector2 LastPickedPosition
         {
-            get { return lastPickedPosition; }
+            get { return lastPickedPositionLocal.Value; }
         }
 
         public static float LastPickedFraction
         {
-            get { return lastPickedFraction; }
+            get { return lastPickedFractionLocal.Value; }
         }
 
         public static Fixture LastPickedFixture
         {
-            get { return lastPickedFixture; }
+            get { return lastPickedFixtureLocal.Value; }
         }
 
         public static Vector2 LastPickedNormal
         {
-            get { return lastPickedNormal; }
+            get { return lastPickedNormalLocal.Value; }
         }
 
         public bool Loading
@@ -146,7 +206,7 @@ namespace Barotrauma
 
         public List<WayPoint> ForcedOutpostModuleWayPoints = new List<WayPoint>();
 
-        public static List<Submarine> Loaded
+        public static ThreadSafeSubmarineList Loaded
         {
             get { return loaded; }
         }
@@ -854,10 +914,10 @@ namespace Barotrauma
                 }, ref aabb);
                 if (closestFraction <= 0.0f)
                 {
-                    lastPickedPosition = rayStart;
-                    lastPickedFraction = closestFraction;
-                    lastPickedFixture = closestFixture;
-                    lastPickedNormal = closestNormal;
+                    lastPickedPositionLocal.Value = rayStart;
+                    lastPickedFractionLocal.Value = closestFraction;
+                    lastPickedFixtureLocal.Value = closestFixture;
+                    lastPickedNormalLocal.Value = closestNormal;
                     return closestBody;
                 }
             }
@@ -876,16 +936,22 @@ namespace Barotrauma
                 return fraction;
             }, rayStart, rayEnd, collisionCategory ?? Category.All);
 
-            lastPickedPosition = rayStart + (rayEnd - rayStart) * closestFraction;
-            lastPickedFraction = closestFraction;
-            lastPickedFixture = closestFixture;
-            lastPickedNormal = closestNormal;
+            lastPickedPositionLocal.Value = rayStart + (rayEnd - rayStart) * closestFraction;
+            lastPickedFractionLocal.Value = closestFraction;
+            lastPickedFixtureLocal.Value = closestFixture;
+            lastPickedNormalLocal.Value = closestNormal;
 
             return closestBody;
         }
 
-        private static readonly Dictionary<Body, float> bodyDist = new Dictionary<Body, float>();
-        private static readonly List<Body> bodies = new List<Body>();
+        // ThreadLocal for thread-safe body picking
+        private static readonly ThreadLocal<Dictionary<Body, float>> bodyDistLocal = 
+            new ThreadLocal<Dictionary<Body, float>>(() => new Dictionary<Body, float>());
+        private static readonly ThreadLocal<List<Body>> bodiesLocal = 
+            new ThreadLocal<List<Body>>(() => new List<Body>());
+        
+        private static Dictionary<Body, float> bodyDist => bodyDistLocal.Value;
+        private static List<Body> bodies => bodiesLocal.Value;
 
         public static float LastPickedBodyDist(Body body)
         {
@@ -919,10 +985,10 @@ namespace Barotrauma
                 }
                 if (fraction < closestFraction)
                 {
-                    lastPickedPosition = rayStart + (rayEnd - rayStart) * fraction;
-                    lastPickedFraction = fraction;
-                    lastPickedNormal = normal;
-                    lastPickedFixture = fixture;
+                    lastPickedPositionLocal.Value = rayStart + (rayEnd - rayStart) * fraction;
+                    lastPickedFractionLocal.Value = fraction;
+                    lastPickedNormalLocal.Value = normal;
+                    lastPickedFixtureLocal.Value = fixture;
                 }
                 //continue
                 return -1;
@@ -940,10 +1006,10 @@ namespace Barotrauma
                     if (!fixture.Shape.TestPoint(ref transform, ref rayStart)) { return true; }
 
                     closestFraction = 0.0f;
-                    lastPickedPosition = rayStart;
-                    lastPickedFraction = 0.0f;
-                    lastPickedNormal = Vector2.Normalize(rayEnd - rayStart);
-                    lastPickedFixture = fixture;
+                    lastPickedPositionLocal.Value = rayStart;
+                    lastPickedFractionLocal.Value = 0.0f;
+                    lastPickedNormalLocal.Value = Vector2.Normalize(rayEnd - rayStart);
+                    lastPickedFixtureLocal.Value = fixture;
                     bodies.Add(fixture.Body);
                     bodyDist[fixture.Body] = 0.0f;
                     return false;
@@ -1011,7 +1077,7 @@ namespace Barotrauma
 
             if (Vector2.DistanceSquared(rayStart, rayEnd) < 0.01f)
             {
-                lastPickedPosition = rayEnd;
+                lastPickedPositionLocal.Value = rayEnd;
                 return null;
             }
 
@@ -1053,10 +1119,10 @@ namespace Barotrauma
             , rayStart, rayEnd);
 
 
-            lastPickedPosition = rayStart + (rayEnd - rayStart) * closestFraction;
-            lastPickedFraction = closestFraction;
-            lastPickedFixture = closestFixture;
-            lastPickedNormal = closestNormal;
+            lastPickedPositionLocal.Value = rayStart + (rayEnd - rayStart) * closestFraction;
+            lastPickedFractionLocal.Value = closestFraction;
+            lastPickedFixtureLocal.Value = closestFixture;
+            lastPickedNormalLocal.Value = closestNormal;
             return closestBody;
         }
 
@@ -1077,7 +1143,7 @@ namespace Barotrauma
 
             Item.UpdateHulls();
 
-            List<Item> bodyItems = Item.ItemList.FindAll(it => it.Submarine == this && it.body != null);
+            List<Item> bodyItems = Item.ItemList.Where(it => it.Submarine == this && it.body != null).ToList();
             List<MapEntity> subEntities = MapEntity.MapEntityList.FindAll(me => me.Submarine == this);
 
             foreach (MapEntity e in subEntities)
@@ -1511,9 +1577,9 @@ namespace Barotrauma
         public List<WayPoint> GetWaypoints(bool alsoFromConnectedSubs) => GetEntities(alsoFromConnectedSubs, WayPoint.WayPointList);
         public List<Structure> GetWalls(bool alsoFromConnectedSubs) => GetEntities(alsoFromConnectedSubs, Structure.WallList);
 
-        public List<T> GetEntities<T>(bool includingConnectedSubs, List<T> list) where T : MapEntity
+        public List<T> GetEntities<T>(bool includingConnectedSubs, IEnumerable<T> list) where T : MapEntity
         {
-            return list.FindAll(e => IsEntityFoundOnThisSub(e, includingConnectedSubs));
+            return list.Where(e => IsEntityFoundOnThisSub(e, includingConnectedSubs)).ToList();
         }
 
         public List<(ItemContainer container, int freeSlots)> GetCargoContainers()
@@ -1538,11 +1604,6 @@ namespace Barotrauma
             return containers;
         }
 
-        public IEnumerable<T> GetEntities<T>(bool includingConnectedSubs, IEnumerable<T> list) where T : MapEntity
-        {
-            return list.Where(e => IsEntityFoundOnThisSub(e, includingConnectedSubs));
-        }
-
         public bool IsEntityFoundOnThisSub(MapEntity entity, bool includingConnectedSubs, bool allowDifferentTeam = false, bool allowDifferentType = false)
         {
             if (entity == null) { return false; }
@@ -1666,9 +1727,8 @@ namespace Barotrauma
                     HiddenSubPosition += Vector2.UnitY * GameMain.GameSession.LevelData.Size.Y;
                 }
 
-                for (int i = 0; i < loaded.Count; i++)
+                foreach (Submarine sub in loaded)
                 {
-                    Submarine sub = loaded[i];
                     HiddenSubPosition =
                         new Vector2(
                             //1st sub on the left side, 2nd on the right, etc
@@ -1800,10 +1860,9 @@ namespace Barotrauma
                 }
                 entityGrid = Hull.GenerateEntityGrid(this);
 
-                for (int i = 0; i < MapEntity.MapEntityList.Count; i++)
+                foreach (MapEntity me in MapEntity.MapEntityList.Where(e => e.Submarine == this))
                 {
-                    if (MapEntity.MapEntityList[i].Submarine != this) { continue; }
-                    MapEntity.MapEntityList[i].Move(HiddenSubPosition, ignoreContacts: true);
+                    me.Move(HiddenSubPosition, ignoreContacts: true);
                 }
 
                 Loading = false;
@@ -2148,7 +2207,7 @@ namespace Barotrauma
                             DebugConsole.ThrowError("Error while removing \"" + item.Name + "\"!", e);
                         }
                     }
-                    Item.ItemList.Clear();
+                    Item.ClearAllItemCollections();
                 }
 
                 Ragdoll.RemoveAll();
@@ -2157,7 +2216,7 @@ namespace Barotrauma
                 GameMain.World = null;
 
                 Powered.Grids.Clear();
-                Powered.ChangedConnections.Clear();
+                Powered.ClearChangedConnections();
 
                 GC.Collect();
 
@@ -2197,7 +2256,7 @@ namespace Barotrauma
 
             ConnectedDockingPorts?.Clear();
 
-            Powered.ChangedConnections.Clear();
+            Powered.ClearChangedConnections();
             Powered.Grids.Clear();
 
             loaded.Remove(this);

Barotrauma/BarotraumaShared/SharedSource/Map/WayPoint.cs

@@ -5,17 +5,75 @@ using Microsoft.Xna.Framework;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Xml.Linq;
 using Barotrauma.Extensions;
 
 namespace Barotrauma
 {
+    /// <summary>
+    /// Thread-safe wrapper for WayPoint list operations.
+    /// Uses copy-on-write pattern for lock-free reads.
+    /// </summary>
+    internal class ThreadSafeWayPointList : IEnumerable<WayPoint>
+    {
+        private volatile List<WayPoint> _list = new List<WayPoint>();
+        private readonly object _writeLock = new object();
+
+        public int Count => _list.Count;
+
+        public void Add(WayPoint waypoint)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<WayPoint>(_list) { waypoint };
+                Interlocked.Exchange(ref _list, newList);
+            }
+        }
+
+        public bool Remove(WayPoint waypoint)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<WayPoint>(_list);
+                bool removed = newList.Remove(waypoint);
+                if (removed)
+                {
+                    Interlocked.Exchange(ref _list, newList);
+                }
+                return removed;
+            }
+        }
+
+        public void Clear()
+        {
+            Interlocked.Exchange(ref _list, new List<WayPoint>());
+        }
+
+        public bool Contains(WayPoint waypoint) => _list.Contains(waypoint);
+
+        public WayPoint this[int index] => _list[index];
+
+        public IEnumerator<WayPoint> GetEnumerator() => _list.GetEnumerator();
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
+
+        // LINQ-friendly methods
+        public List<WayPoint> ToList() => new List<WayPoint>(_list);
+        public WayPoint FirstOrDefault(Func<WayPoint, bool> predicate) => _list.FirstOrDefault(predicate);
+        public WayPoint Find(Predicate<WayPoint> predicate) => _list.Find(predicate);
+        public List<WayPoint> FindAll(Predicate<WayPoint> predicate) => _list.FindAll(predicate);
+        public IEnumerable<WayPoint> Where(Func<WayPoint, bool> predicate) => _list.Where(predicate);
+        public bool Any() => _list.Any();
+        public bool Any(Func<WayPoint, bool> predicate) => _list.Any(predicate);
+        public bool Exists(Predicate<WayPoint> predicate) => _list.Exists(predicate);
+    }
+
     [Flags]
     public enum SpawnType { Path = 0, Human = 1, Enemy = 2, Cargo = 4, Corpse = 8, Submarine = 16, ExitPoint = 32, Disabled = 64 };
 
     partial class WayPoint : MapEntity
     {
-        public static List<WayPoint> WayPointList = new List<WayPoint>();
+        public static ThreadSafeWayPointList WayPointList = new ThreadSafeWayPointList();
 
         public static bool ShowWayPoints = true, ShowSpawnPoints = true;
 
@@ -932,7 +990,7 @@ namespace Barotrauma
 
         public static WayPoint GetRandom(SpawnType spawnType = SpawnType.Human, JobPrefab assignedJob = null, Submarine sub = null, bool useSyncedRand = false, string spawnPointTag = null, bool ignoreSubmarine = false)
         {
-            return WayPointList.GetRandom(wp =>
+            return WayPointList.ToList().GetRandom(wp =>
                 (ignoreSubmarine || wp.Submarine == sub) && 
                 //checking for the disabled flag is not strictly necessary because we check for equality of the spawn type,
                 //but lets do that anyway in case we change the handling of the spawn type at some point

Barotrauma/BarotraumaShared/SharedSource/Networking/Client.cs

@@ -62,7 +62,7 @@ namespace Barotrauma.Networking
                     DebugConsole.Log($"Changed client {Name}'s team to {teamID}.");
                     if (GameMain.NetworkMember != null && GameMain.NetworkMember.IsServer)
                     {
-                        GameMain.NetworkMember.LastClientListUpdateID++;
+                        GameMain.NetworkMember.IncrementLastClientListUpdateID();
                     }
                     teamID = value;
                 }
@@ -86,7 +86,7 @@ namespace Barotrauma.Networking
             {
                 if (GameMain.NetworkMember != null && GameMain.NetworkMember.IsServer)
                 {
-                    GameMain.NetworkMember.LastClientListUpdateID++;
+                    GameMain.NetworkMember.IncrementLastClientListUpdateID();
                     if (value != null)
                     {
                         CharacterID = value.ID;
@@ -154,7 +154,7 @@ namespace Barotrauma.Networking
 #endif
                 if (GameMain.NetworkMember != null && GameMain.NetworkMember.IsServer)
                 {
-                    GameMain.NetworkMember.LastClientListUpdateID++;
+                    GameMain.NetworkMember.IncrementLastClientListUpdateID();
                 }
             }
         }
@@ -178,7 +178,7 @@ namespace Barotrauma.Networking
             {
                 if (GameMain.NetworkMember != null && GameMain.NetworkMember.IsServer)
                 {
-                    GameMain.NetworkMember.LastClientListUpdateID++;
+                    GameMain.NetworkMember.IncrementLastClientListUpdateID();
                 }
                 inGame = value;
             }

Barotrauma/BarotraumaShared/SharedSource/Networking/EntitySpawner.cs

@@ -434,7 +434,7 @@ namespace Barotrauma
             if (GameMain.NetworkMember is { IsClient: true }) { return; }
             while (spawnOrRemoveQueue.Count > 0)
             {
-                var spawnOrRemove = spawnOrRemoveQueue.Dequeue();
+                if (!spawnOrRemoveQueue.TryDequeue(out var spawnOrRemove)) { break; }
                 if (spawnOrRemove.TryGet(out Entity entityToRemove))
                 {
                     if (entityToRemove is Item item)

Barotrauma/BarotraumaShared/SharedSource/Networking/INetSerializableStruct.cs

@@ -1,5 +1,6 @@
 #nullable enable
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
@@ -146,10 +147,10 @@ namespace Barotrauma
             }
         }
 
-        private static readonly Dictionary<Type, ImmutableArray<CachedReflectedVariable>> CachedVariables = new Dictionary<Type, ImmutableArray<CachedReflectedVariable>>();
+        private static readonly ConcurrentDictionary<Type, ImmutableArray<CachedReflectedVariable>> CachedVariables = new ConcurrentDictionary<Type, ImmutableArray<CachedReflectedVariable>>();
 
-        private static readonly Dictionary<Type, IReadWriteBehavior> TypeBehaviors
-            = new Dictionary<Type, IReadWriteBehavior>
+        private static readonly ConcurrentDictionary<Type, IReadWriteBehavior> TypeBehaviors
+            = new ConcurrentDictionary<Type, IReadWriteBehavior>(new Dictionary<Type, IReadWriteBehavior>
             {
                 { typeof(Boolean), new ReadWriteBehavior<Boolean>(ReadBoolean, WriteBoolean) },
                 { typeof(Byte), new ReadWriteBehavior<Byte>(ReadByte, WriteByte) },
@@ -168,7 +169,7 @@ namespace Barotrauma
                 { typeof(Vector2), new ReadWriteBehavior<Vector2>(ReadVector2, WriteVector2) },
                 { typeof(SerializableDateTime), new ReadWriteBehavior<SerializableDateTime>(ReadSerializableDateTime, WriteSerializableDateTime) },
                 { typeof(NetLimitedString), new ReadWriteBehavior<NetLimitedString>(ReadNetLString, WriteNetLString) }
-            };
+            });
 
         private static readonly ImmutableDictionary<Predicate<Type>, Func<Type, IReadWriteBehavior>> BehaviorFactories = new Dictionary<Predicate<Type>, Func<Type, IReadWriteBehavior>>
         {
@@ -584,7 +585,11 @@ namespace Barotrauma
                 if (!predicate(type)) { continue; }
 
                 behavior = factory(type);
-                TypeBehaviors.Add(type, behavior);
+                // Use TryAdd for thread-safety; if another thread already added, use that value
+                if (!TypeBehaviors.TryAdd(type, behavior))
+                {
+                    behavior = TypeBehaviors[type];
+                }
                 return true;
             }
 
@@ -594,8 +599,11 @@ namespace Barotrauma
 
         public static ImmutableArray<CachedReflectedVariable> GetPropertiesAndFields(Type type)
         {
-            if (CachedVariables.TryGetValue(type, out var cached)) { return cached; }
+            return CachedVariables.GetOrAdd(type, static t => CreateCachedVariables(t));
+        }
 
+        private static ImmutableArray<CachedReflectedVariable> CreateCachedVariables(Type type)
+        {
             List<CachedReflectedVariable> variables = new List<CachedReflectedVariable>();
 
             IEnumerable<PropertyInfo> propertyInfos = type.GetProperties().Where(HasAttribute).Where(NotStatic);
@@ -633,7 +641,6 @@ namespace Barotrauma
             }
 
             ImmutableArray<CachedReflectedVariable> array = variables.All(v => v.HasOwnAttribute) ? variables.OrderBy(v => v.Attribute.OrderKey).ToImmutableArray() : variables.ToImmutableArray();
-            CachedVariables.Add(type, array);
             return array;
 
             bool HasAttribute(MemberInfo info) => (info.GetCustomAttribute<NetworkSerialize>() ?? type.GetCustomAttribute<NetworkSerialize>()) != null;

Barotrauma/BarotraumaShared/SharedSource/Networking/NetworkMember.cs

@@ -1,6 +1,7 @@
 using Microsoft.Xna.Framework;
 using System;
 using System.Collections.Generic;
+using System.Threading;
 
 namespace Barotrauma.Networking
 {
@@ -186,10 +187,19 @@ namespace Barotrauma.Networking
     {
         protected const int MaxSubNameLengthInErrorMessages = 16;
 
+        private int lastClientListUpdateID;
         public UInt16 LastClientListUpdateID
         {
-            get;
-            set;
+            get => (UInt16)Interlocked.CompareExchange(ref lastClientListUpdateID, 0, 0);
+            set => Interlocked.Exchange(ref lastClientListUpdateID, value);
+        }
+
+        /// <summary>
+        /// Thread-safe increment of LastClientListUpdateID
+        /// </summary>
+        public void IncrementLastClientListUpdateID()
+        {
+            Interlocked.Increment(ref lastClientListUpdateID);
         }
 
         public abstract bool IsServer { get; }

Barotrauma/BarotraumaShared/SharedSource/Physics/PhysicsBody.cs

@@ -4,12 +4,69 @@ using FarseerPhysics.Dynamics;
 using Microsoft.Xna.Framework;
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
 using System.Xml.Linq;
 using LimbParams = Barotrauma.RagdollParams.LimbParams;
 using ColliderParams = Barotrauma.RagdollParams.ColliderParams;
 
 namespace Barotrauma
 {
+    /// <summary>
+    /// Thread-safe wrapper for PhysicsBody list operations.
+    /// Uses copy-on-write pattern for lock-free reads.
+    /// </summary>
+    internal class ThreadSafePhysicsBodyList : IEnumerable<PhysicsBody>
+    {
+        private volatile List<PhysicsBody> _list = new List<PhysicsBody>();
+        private readonly object _writeLock = new object();
+
+        public int Count => _list.Count;
+
+        public void Add(PhysicsBody body)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<PhysicsBody>(_list) { body };
+                Interlocked.Exchange(ref _list, newList);
+            }
+        }
+
+        public bool Remove(PhysicsBody body)
+        {
+            lock (_writeLock)
+            {
+                var newList = new List<PhysicsBody>(_list);
+                bool removed = newList.Remove(body);
+                if (removed)
+                {
+                    Interlocked.Exchange(ref _list, newList);
+                }
+                return removed;
+            }
+        }
+
+        public void Clear()
+        {
+            Interlocked.Exchange(ref _list, new List<PhysicsBody>());
+        }
+
+        public bool Contains(PhysicsBody body) => _list.Contains(body);
+
+        public PhysicsBody this[int index] => _list[index];
+
+        public IEnumerator<PhysicsBody> GetEnumerator() => _list.GetEnumerator();
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
+
+        // LINQ-friendly methods
+        public List<PhysicsBody> ToList() => new List<PhysicsBody>(_list);
+        public PhysicsBody FirstOrDefault(Func<PhysicsBody, bool> predicate) => _list.FirstOrDefault(predicate);
+        public PhysicsBody Find(Predicate<PhysicsBody> predicate) => _list.Find(predicate);
+        public IEnumerable<PhysicsBody> Where(Func<PhysicsBody, bool> predicate) => _list.Where(predicate);
+        public bool Any() => _list.Any();
+        public bool Any(Func<PhysicsBody, bool> predicate) => _list.Any(predicate);
+    }
+
     class PosInfo
     {
         public Vector2 Position
@@ -92,8 +149,8 @@ namespace Barotrauma
         public const float MinDensity = 0.01f;
         public const float DefaultAngularDamping = 5.0f;
 
-        private static readonly List<PhysicsBody> list = new List<PhysicsBody>();
-        public static List<PhysicsBody> List
+        private static readonly ThreadSafePhysicsBodyList list = new ThreadSafePhysicsBodyList();
+        public static ThreadSafePhysicsBodyList List
         {
             get { return list; }
         }

Barotrauma/BarotraumaShared/SharedSource/Physics/PhysicsBodyQueue.cs

@@ -0,0 +1,155 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Barotrauma
+{
+    /// <summary>
+    /// Thread-safe queue for deferring physics operations to the main thread.
+    /// This is necessary because Farseer Physics' DynamicTree is not thread-safe,
+    /// and physics operations cannot be safely performed during parallel updates.
+    /// 
+    /// Supported operations include:
+    /// - Physics body creation
+    /// - Physics body transform updates (SetTransform, SetTransformIgnoreContacts)
+    /// - Any other operation that modifies the Farseer physics world
+    /// </summary>
+/// <start>
+///  ├─> PhysicsBodyQueue.IsInParallelContext = true (ThreadStatic)
+///  ├─> Item.Update()
+///  │     └─> StatusEffect.Apply()
+///  │           └─> Character.Kill()
+///  │                 └─> Item.Drop()
+///  │                       └─> Check if IsInParallelContext == true
+///  │                             └─> PhysicsBodyQueue.Enqueue(Physics operation)
+///  ├──> PhysicsBodyQueue.IsInParallelContext = false
+///  └──> PhysicsBodyQueue.ProcessPendingOperations() ← Main thread executes
+///        └─> body.SetTransformIgnoreContacts()
+    static class PhysicsBodyQueue
+    {
+        private static readonly object _lock = new object();
+        private static readonly Queue<Action> _pendingOperations = new Queue<Action>();
+
+        /// <summary>
+        /// Thread-local flag indicating whether the current thread is in a parallel physics update context.
+        /// When true, physics operations should be deferred using this queue instead of executing immediately.
+        /// </summary>
+        [ThreadStatic]
+        private static bool _isInParallelContext;
+
+        /// <summary>
+        /// Gets or sets whether the current thread is in a parallel update context.
+        /// When true, physics operations should be queued instead of executed immediately.
+        /// </summary>
+        public static bool IsInParallelContext
+        {
+            get => _isInParallelContext;
+            set => _isInParallelContext = value;
+        }
+
+        /// <summary>
+        /// Enqueues a physics operation to be executed on the main thread.
+        /// This method is thread-safe and can be called from parallel update loops.
+        /// </summary>
+        /// <param name="operation">The physics operation to defer</param>
+        public static void Enqueue(Action operation)
+        {
+            if (operation == null) { return; }
+            lock (_lock)
+            {
+                _pendingOperations.Enqueue(operation);
+            }
+        }
+
+        /// <summary>
+        /// Enqueues a physics body creation action to be executed on the main thread.
+        /// This method is thread-safe and can be called from parallel update loops.
+        /// </summary>
+        /// <param name="createAction">The action that creates the physics body</param>
+        public static void EnqueueCreation(Action createAction)
+        {
+            Enqueue(createAction);
+        }
+
+        /// <summary>
+        /// Executes a physics operation, either immediately or deferred depending on context.
+        /// If called from a parallel context, the operation will be queued for later execution.
+        /// If called from the main thread (outside parallel loops), the operation executes immediately.
+        /// </summary>
+        /// <param name="operation">The physics operation to execute</param>
+        public static void ExecuteOrDefer(Action operation)
+        {
+            if (operation == null) { return; }
+            
+            if (_isInParallelContext)
+            {
+                Enqueue(operation);
+            }
+            else
+            {
+                operation();
+            }
+        }
+
+        /// <summary>
+        /// Gets the number of pending physics operations.
+        /// </summary>
+        public static int PendingCount
+        {
+            get
+            {
+                lock (_lock)
+                {
+                    return _pendingOperations.Count;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Processes all pending physics operations.
+        /// Must be called on the main thread, outside of any parallel loops.
+        /// </summary>
+        public static void ProcessPendingOperations()
+        {
+            while (true)
+            {
+                Action action;
+                lock (_lock)
+                {
+                    if (_pendingOperations.Count == 0) { break; }
+                    action = _pendingOperations.Dequeue();
+                }
+                try
+                {
+                    action?.Invoke();
+                }
+                catch (Exception e)
+                {
+                    DebugConsole.ThrowError($"Error processing deferred physics operation: {e.Message}", e);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Legacy method for backwards compatibility.
+        /// Calls ProcessPendingOperations().
+        /// </summary>
+        public static void ProcessPendingCreations()
+        {
+            ProcessPendingOperations();
+        }
+
+        /// <summary>
+        /// Clears all pending physics operations.
+        /// Should be called when ending a round or cleaning up.
+        /// </summary>
+        public static void Clear()
+        {
+            lock (_lock)
+            {
+                _pendingOperations.Clear();
+            }
+        }
+    }
+}
+

Barotrauma/BarotraumaShared/SharedSource/Screens/GameScreen.cs

@@ -178,9 +178,23 @@ namespace Barotrauma
 
             Parallel.Invoke(parallelOptions,
                 () => GameMain.ParticleManager.Update((float)deltaTime),
-                () => { if (Level.Loaded != null) Level.Loaded.Update((float)deltaTime, cam); }
+                () => 
+                { 
+                    PhysicsBodyQueue.IsInParallelContext = true;
+                    try
+                    {
+                        if (Level.Loaded != null) Level.Loaded.Update((float)deltaTime, cam);
+                    }
+                    finally
+                    {
+                        PhysicsBodyQueue.IsInParallelContext = false;
+                    }
+                }
             );
             
+            // Process any physics operations queued during Level update
+            PhysicsBodyQueue.ProcessPendingOperations();
+            
             sw.Stop();
             GameMain.PerformanceCounter.AddElapsedTicks("Update:Particles+Level", sw.ElapsedTicks);
 
@@ -246,12 +260,33 @@ namespace Barotrauma
 
 #elif SERVER
             Parallel.Invoke(parallelOptions,
-                () => { if (Level.Loaded != null) Level.Loaded.Update((float)deltaTime, Camera.Instance); },
-                () => Character.UpdateAll((float)deltaTime, Camera.Instance)
+                () => 
+                { 
+                    PhysicsBodyQueue.IsInParallelContext = true;
+                    try
+                    {
+                        if (Level.Loaded != null) Level.Loaded.Update((float)deltaTime, Camera.Instance);
+                    }
+                    finally
+                    {
+                        PhysicsBodyQueue.IsInParallelContext = false;
+                    }
+                },
+                () => 
+                {
+                    PhysicsBodyQueue.IsInParallelContext = true;
+                    try
+                    {
+                        Character.UpdateAll((float)deltaTime, Camera.Instance);
+                    }
+                    finally
+                    {
+                        PhysicsBodyQueue.IsInParallelContext = false;
+                    }
+                }
             );
             
-            //StatusEffect.UpdateAll is not thread-safe and must be executed on the main thread
-            StatusEffect.UpdateAll((float)deltaTime);
+            PhysicsBodyQueue.ProcessPendingOperations();
 #endif
 
             var submarines = Submarine.Loaded.ToList();
@@ -275,6 +310,8 @@ namespace Barotrauma
 
             MapEntity.UpdateAll((float)deltaTime, Camera.Instance, parallelOptions);
 
+            StatusEffect.UpdateAll((float)deltaTime);
+
 #endif
 
 #if CLIENT

Barotrauma/BarotraumaShared/SharedSource/StatusEffects/DelayedEffect.cs

@@ -1,26 +1,56 @@
 using Barotrauma.Items.Components;
 using Microsoft.Xna.Framework;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 
 namespace Barotrauma
 {
     class DelayedListElement
     {
+        public readonly long Id;
         public readonly DelayedEffect Parent;
         public readonly Entity Entity;
-        public Vector2? WorldPosition;
+
+        private Vector2? _worldPosition;
+        private readonly object _worldPositionLock = new object();
+        public Vector2? WorldPosition
+        {
+            get
+            {
+                lock (_worldPositionLock)
+                {
+                    return _worldPosition;
+                }
+            }
+            set
+            {
+                lock (_worldPositionLock)
+                {
+                    _worldPosition = value;
+                }
+            }
+        }
+
         /// <summary>
         /// Should the delayed effect attempt to determine the position of the effect based on the targets, or just use the position that was passed to the constructor.
         /// </summary>
         public bool GetPositionBasedOnTargets;
         public readonly Vector2? StartPosition;
         public readonly List<ISerializableEntity> Targets;
-        public float Delay;
+        
+        private volatile float _delay;
+        public float Delay
+        {
+            get => _delay;
+            set => _delay = value;
+        }
 
         public DelayedListElement(DelayedEffect parentEffect, Entity parentEntity, IEnumerable<ISerializableEntity> targets, float delay, Vector2? worldPosition, Vector2? startPosition)
         {
+            Id = Interlocked.Increment(ref DelayedEffect._delayElementIdCounter);
             Parent = parentEffect;
             Entity = parentEntity;
             Targets = new List<ISerializableEntity>(targets);
@@ -29,9 +59,19 @@ namespace Barotrauma
             StartPosition = startPosition;
         }
     }
+    
     class DelayedEffect : StatusEffect
     {
-        public static readonly List<DelayedListElement> DelayList = new List<DelayedListElement>();
+        // Thread-safe counter for generating unique IDs for DelayedListElement
+        internal static long _delayElementIdCounter;
+        
+        // Thread-safe dictionary for delayed effects
+        public static readonly ConcurrentDictionary<long, DelayedListElement> DelayListDict = new ConcurrentDictionary<long, DelayedListElement>();
+        
+        /// <summary>
+        /// Provides a thread-safe enumerable view of the delay list for iteration.
+        /// </summary>
+        public static IEnumerable<DelayedListElement> DelayList => DelayListDict.Values;
 
         private enum DelayTypes 
         { 
@@ -62,9 +102,10 @@ namespace Barotrauma
             if (this.type != type || !HasRequiredItems(entity)) { return; }
             if (!Stackable)
             {
-                foreach (var existingEffect in DelayList)
+                // Thread-safe iteration over ConcurrentDictionary
+                foreach (var kvp in DelayListDict)
                 {
-                    if (existingEffect.Parent == this && existingEffect.Targets.FirstOrDefault() == target) 
+                    if (kvp.Value.Parent == this && kvp.Value.Targets.FirstOrDefault() == target) 
                     {
                         return; 
                     }
@@ -72,18 +113,19 @@ namespace Barotrauma
             }
             if (!IsValidTarget(target)) { return; }
 
-            currentTargets.Clear();
-            currentTargets.Add(target);
-            if (!HasRequiredConditions(currentTargets)) { return; }
+            var targets = CurrentTargets;
+            targets.Clear();
+            targets.Add(target);
+            if (!HasRequiredConditions(targets)) { return; }
 
             switch (delayType)
             {
                 case DelayTypes.Timer:
-                    var newDelayListElement = new DelayedListElement(this, entity, currentTargets, delay, worldPosition ?? GetPosition(entity, currentTargets, worldPosition), startPosition: null)
+                    var newDelayListElement = new DelayedListElement(this, entity, targets, delay, worldPosition ?? GetPosition(entity, targets, worldPosition), startPosition: null)
                     {
                         GetPositionBasedOnTargets = worldPosition == null
                     };
-                    DelayList.Add(newDelayListElement);
+                    DelayListDict.TryAdd(newDelayListElement.Id, newDelayListElement);
                     break;
                 case DelayTypes.ReachCursor:
                     Projectile projectile = (entity as Item)?.GetComponent<Projectile>();
@@ -105,7 +147,8 @@ namespace Barotrauma
                         return;
                     }
 
-                    DelayList.Add(new DelayedListElement(this, entity, currentTargets, Vector2.Distance(entity.WorldPosition, projectile.User.CursorWorldPosition), worldPosition, entity.WorldPosition));
+                    var reachCursorElement = new DelayedListElement(this, entity, targets, Vector2.Distance(entity.WorldPosition, projectile.User.CursorWorldPosition), worldPosition, entity.WorldPosition);
+                    DelayListDict.TryAdd(reachCursorElement.Id, reachCursorElement);
                     break;
             }
         }
@@ -119,25 +162,28 @@ namespace Barotrauma
             if (delayType == DelayTypes.ReachCursor && Character.Controlled == null) { return; }
             if (!Stackable) 
             { 
-                foreach (var existingEffect in DelayList)
+                // Thread-safe iteration over ConcurrentDictionary
+                foreach (var kvp in DelayListDict)
                 {
-                    if (existingEffect.Parent == this && existingEffect.Targets.SequenceEqual(targets)) { return; }
+                    if (kvp.Value.Parent == this && kvp.Value.Targets.SequenceEqual(targets)) { return; }
                 }
             }
 
-            currentTargets.Clear();
+            var localTargets = CurrentTargets;
+            localTargets.Clear();
             foreach (ISerializableEntity target in targets)
             {
                 if (!IsValidTarget(target)) { continue; }
-                currentTargets.Add(target);
+                localTargets.Add(target);
             }
 
-            if (!HasRequiredConditions(currentTargets)) { return; }
+            if (!HasRequiredConditions(localTargets)) { return; }
 
             switch (delayType)
             {
                 case DelayTypes.Timer:
-                    DelayList.Add(new DelayedListElement(this, entity, currentTargets, delay, worldPosition, null));
+                    var timerElement = new DelayedListElement(this, entity, localTargets, delay, worldPosition, null);
+                    DelayListDict.TryAdd(timerElement.Id, timerElement);
                     break;
                 case DelayTypes.ReachCursor:
                     Projectile projectile = (entity as Item)?.GetComponent<Projectile>();
@@ -161,19 +207,21 @@ namespace Barotrauma
                         return;
                     }
 
-                    DelayList.Add(new DelayedListElement(this, entity, currentTargets, Vector2.Distance(entity.WorldPosition, user.CursorWorldPosition), worldPosition, entity.WorldPosition));
+                    var reachCursorElement = new DelayedListElement(this, entity, localTargets, Vector2.Distance(entity.WorldPosition, user.CursorWorldPosition), worldPosition, entity.WorldPosition);
+                    DelayListDict.TryAdd(reachCursorElement.Id, reachCursorElement);
                     break;
             }
         }
 
         public static void Update(float deltaTime)
         {
-            for (int i = DelayList.Count - 1; i >= 0; i--)
+            // Thread-safe iteration over ConcurrentDictionary
+            foreach (var kvp in DelayListDict)
             {
-                DelayedListElement element = DelayList[i];
+                DelayedListElement element = kvp.Value;
                 if (element.Parent.CheckConditionalAlways && !element.Parent.HasRequiredConditions(element.Targets))
                 {
-                    DelayList.Remove(element);
+                    DelayListDict.TryRemove(element.Id, out _);
                     continue;
                 }
 
@@ -187,7 +235,7 @@ namespace Barotrauma
                             //keep refreshing the position until the effect runs (so e.g. a delayed effect runs at the last known position of a monster before it despawned)
                             if (element.GetPositionBasedOnTargets && element.Entity is { Removed: false })
                             {
-                                element.WorldPosition = element.Parent.GetPosition(element.Entity, element.Parent.currentTargets);
+                                element.WorldPosition = element.Parent.GetPosition(element.Entity, element.Parent.CurrentTargets);
                             }
                             continue; 
                         }
@@ -198,7 +246,7 @@ namespace Barotrauma
                 }
 
                 element.Parent.Apply(deltaTime, element.Entity, element.Targets, element.WorldPosition);
-                DelayList.Remove(element);
+                DelayListDict.TryRemove(element.Id, out _);
             }
         }
     }

Barotrauma/BarotraumaShared/SharedSource/StatusEffects/StatusEffect.cs

@@ -7,15 +7,18 @@ using FarseerPhysics.Dynamics;
 using Microsoft.Xna.Framework;
 using Steamworks;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
+using System.Threading;
 using System.Xml.Linq;
 
 namespace Barotrauma
 {
     class DurationListElement
     {
+        public readonly long Id;
         public readonly StatusEffect Parent;
         public readonly Entity Entity;
         public float Duration
@@ -24,12 +27,24 @@ namespace Barotrauma
             private set;
         }
         public readonly List<ISerializableEntity> Targets;
-        public Character User { get; private set; }
         
-        public float Timer;
+        private volatile Character _user;
+        public Character User 
+        { 
+            get => _user; 
+            private set => _user = value; 
+        }
+
+        private volatile float _timer;
+        public float Timer
+        {
+            get => _timer;
+            set => _timer = value;
+        }
 
         public DurationListElement(StatusEffect parentEffect, Entity parentEntity, IEnumerable<ISerializableEntity> targets, float duration, Character user)
         {
+            Id = Interlocked.Increment(ref StatusEffect._durationElementIdCounter);
             Parent = parentEffect;
             Entity = parentEntity;
             Targets = new List<ISerializableEntity>(targets);
@@ -39,8 +54,9 @@ namespace Barotrauma
 
         public void Reset(float duration, Character newUser)
         {
-            Timer = Duration = duration;
-            User = newUser;
+            Duration = duration;
+            Volatile.Write(ref _timer, duration);
+            _user = newUser;
         }
     }
 
@@ -601,14 +617,23 @@ namespace Barotrauma
         private readonly float lifeTime;
         private float lifeTimer;
 
-        private Dictionary<Entity, float> intervalTimers;
+        private ConcurrentDictionary<Entity, float> intervalTimers;
 
         /// <summary>
         /// Makes the effect only execute once. After it has executed, it'll never execute again (during the same round).
         /// </summary>
         private readonly bool oneShot;
 
-        public static readonly List<DurationListElement> DurationList = new List<DurationListElement>();
+        // Thread-safe counter for generating unique IDs for DurationListElement
+        internal static long _durationElementIdCounter;
+        
+        // Thread-safe dictionary for duration effects
+        public static readonly ConcurrentDictionary<long, DurationListElement> DurationListDict = new ConcurrentDictionary<long, DurationListElement>();
+        
+        /// <summary>
+        /// Provides a thread-safe enumerable view of the duration list for iteration.
+        /// </summary>
+        public static IEnumerable<DurationListElement> DurationList => DurationListDict.Values;
 
         /// <summary>
         /// Only applicable for StatusEffects with a duration or delay. Should the conditional checks only be done when the effect triggers, 
@@ -1624,22 +1649,52 @@ namespace Barotrauma
             }
         }
 
-        private static readonly List<Entity> intervalsToRemove = new List<Entity>();
+        // Thread-local list to avoid contention when cleaning up removed entities
+        [ThreadStatic]
+        private static List<Entity> _threadLocalIntervalsToRemove;
+        
+        private static List<Entity> IntervalsToRemove
+        {
+            get
+            {
+                _threadLocalIntervalsToRemove ??= new List<Entity>();
+                return _threadLocalIntervalsToRemove;
+            }
+        }
 
         public bool ShouldWaitForInterval(Entity entity, float deltaTime)
         {
-            if (Interval > 0.0f && entity != null && intervalTimers != null)
+            if (Interval > 0.0f && entity != null)
             {
-                if (intervalTimers.ContainsKey(entity))
+                // Thread-safe lazy initialization
+                if (intervalTimers == null)
                 {
-                    intervalTimers[entity] -= deltaTime;
-                    if (intervalTimers[entity] > 0.0f) { return true; }
+                    Interlocked.CompareExchange(ref intervalTimers, new ConcurrentDictionary<Entity, float>(), null);
                 }
-                intervalsToRemove.Clear();
-                intervalsToRemove.AddRange(intervalTimers.Keys.Where(e => e.Removed));
-                foreach (var toRemove in intervalsToRemove)
+                
+                if (intervalTimers.TryGetValue(entity, out float currentTimer))
                 {
-                    intervalTimers.Remove(toRemove);
+                    float newTimer = currentTimer - deltaTime;
+                    if (newTimer > 0.0f)
+                    {
+                        intervalTimers.AddOrUpdate(entity, newTimer, (_, __) => newTimer);
+                        return true;
+                    }
+                }
+                
+                // Clean up removed entities using thread-local list
+                var toRemove = IntervalsToRemove;
+                toRemove.Clear();
+                foreach (var key in intervalTimers.Keys)
+                {
+                    if (key.Removed)
+                    {
+                        toRemove.Add(key);
+                    }
+                }
+                foreach (var key in toRemove)
+                {
+                    intervalTimers.TryRemove(key, out _);
                 }
             }
             return false;
@@ -1655,7 +1710,7 @@ namespace Barotrauma
             if (Duration > 0.0f && !Stackable)
             {
                 //ignore if not stackable and there's already an identical statuseffect
-                DurationListElement existingEffect = DurationList.Find(d => d.Parent == this && d.Targets.FirstOrDefault() == target);
+                DurationListElement existingEffect = FindExistingDurationEffect(target);
                 if (existingEffect != null)
                 {
                     if (ResetDurationWhenReapplied)
@@ -1666,30 +1721,74 @@ namespace Barotrauma
                 }
             }
 
-            currentTargets.Clear();
-            currentTargets.Add(target);
-            if (!HasRequiredConditions(currentTargets)) { return; }
-            Apply(deltaTime, entity, currentTargets, worldPosition);
+            var targets = CurrentTargets;
+            targets.Clear();
+            targets.Add(target);
+            if (!HasRequiredConditions(targets)) { return; }
+            Apply(deltaTime, entity, targets, worldPosition);
+        }
+
+        // Thread-local list to avoid contention when collecting targets
+        [ThreadStatic]
+        private static List<ISerializableEntity> _threadLocalCurrentTargets;
+        
+        protected List<ISerializableEntity> CurrentTargets
+        {
+            get
+            {
+                _threadLocalCurrentTargets ??= new List<ISerializableEntity>();
+                return _threadLocalCurrentTargets;
+            }
+        }
+        
+        /// <summary>
+        /// Thread-safe method to find an existing duration effect for a single target.
+        /// </summary>
+        private DurationListElement FindExistingDurationEffect(ISerializableEntity target)
+        {
+            foreach (var element in DurationListDict.Values)
+            {
+                if (element.Parent == this && element.Targets.FirstOrDefault() == target)
+                {
+                    return element;
+                }
+            }
+            return null;
+        }
+        
+        /// <summary>
+        /// Thread-safe method to find an existing duration effect for multiple targets.
+        /// </summary>
+        private DurationListElement FindExistingDurationEffect(IReadOnlyList<ISerializableEntity> targets)
+        {
+            foreach (var element in DurationListDict.Values)
+            {
+                if (element.Parent == this && element.Targets.SequenceEqual(targets))
+                {
+                    return element;
+                }
+            }
+            return null;
         }
         
-        protected readonly List<ISerializableEntity> currentTargets = new List<ISerializableEntity>();
         public virtual void Apply(ActionType type, float deltaTime, Entity entity, IReadOnlyList<ISerializableEntity> targets, Vector2? worldPosition = null)
         {
             if (Disabled) { return; }
             if (this.type != type) { return; }
             if (ShouldWaitForInterval(entity, deltaTime)) { return; }
 
-            currentTargets.Clear();
+            var localTargets = CurrentTargets;
+            localTargets.Clear();
             foreach (ISerializableEntity target in targets)
             {
                 if (!IsValidTarget(target)) { continue; }
-                currentTargets.Add(target);
+                localTargets.Add(target);
             }
 
-            if (TargetIdentifiers != null && currentTargets.Count == 0) { return; }
+            if (TargetIdentifiers != null && localTargets.Count == 0) { return; }
 
             bool hasRequiredItems = HasRequiredItems(entity);
-            if (!hasRequiredItems || !HasRequiredConditions(currentTargets))
+            if (!hasRequiredItems || !HasRequiredConditions(localTargets))
             {
 #if CLIENT
                 if (!hasRequiredItems && playSoundOnRequiredItemFailure)
@@ -1703,15 +1802,15 @@ namespace Barotrauma
             if (Duration > 0.0f && !Stackable)
             {
                 //ignore if not stackable and there's already an identical statuseffect
-                DurationListElement existingEffect = DurationList.Find(d => d.Parent == this && d.Targets.SequenceEqual(currentTargets));
+                DurationListElement existingEffect = FindExistingDurationEffect(localTargets);
                 if (existingEffect != null)
                 {
-                    existingEffect?.Reset(Math.Max(existingEffect.Timer, Duration), user);
+                    existingEffect.Reset(Math.Max(existingEffect.Timer, Duration), user);
                     return;
                 }
             }
 
-            Apply(deltaTime, entity, currentTargets, worldPosition);
+            Apply(deltaTime, entity, localTargets, worldPosition);
         }
 
         private Hull GetHull(Entity entity)
@@ -1924,7 +2023,8 @@ namespace Barotrauma
 
             if (Duration > 0.0f)
             {
-                DurationList.Add(new DurationListElement(this, entity, targets, Duration, user));
+                var element = new DurationListElement(this, entity, targets, Duration, user);
+                DurationListDict.TryAdd(element.Id, element);
             }
             else
             {
@@ -2452,7 +2552,7 @@ namespace Barotrauma
             }
             if (Interval > 0.0f && entity != null)
             {
-                intervalTimers ??= new Dictionary<Entity, float>();
+                intervalTimers ??= new ConcurrentDictionary<Entity, float>();
                 intervalTimers[entity] = Interval;
             }
         }
@@ -2849,13 +2949,15 @@ namespace Barotrauma
             UpdateAllProjSpecific(deltaTime);
 
             DelayedEffect.Update(deltaTime);
-            for (int i = DurationList.Count - 1; i >= 0; i--)
+            
+            // Thread-safe iteration over ConcurrentDictionary
+            foreach (var kvp in DurationListDict)
             {
-                DurationListElement element = DurationList[i];
+                DurationListElement element = kvp.Value;
 
                 if (element.Parent.CheckConditionalAlways && !element.Parent.HasRequiredConditions(element.Targets))
                 {
-                    DurationList.RemoveAt(i);
+                    DurationListDict.TryRemove(element.Id, out _);
                     continue;
                 }
 
@@ -2864,7 +2966,7 @@ namespace Barotrauma
                     (t is Limb limb && (limb.character == null || limb.character.Removed)));
                 if (element.Targets.Count == 0)
                 {
-                    DurationList.RemoveAt(i);
+                    DurationListDict.TryRemove(element.Id, out _);
                     continue;
                 }
 
@@ -2959,7 +3061,7 @@ namespace Barotrauma
                 element.Timer -= deltaTime;
 
                 if (element.Timer > 0.0f) { continue; }
-                DurationList.Remove(element);
+                DurationListDict.TryRemove(element.Id, out _);
             }
         }
 
@@ -3059,8 +3161,8 @@ namespace Barotrauma
         public static void StopAll()
         {
             CoroutineManager.StopCoroutines("statuseffect");
-            DelayedEffect.DelayList.Clear();
-            DurationList.Clear();
+            DelayedEffect.DelayListDict.Clear();
+            DurationListDict.Clear();
         }
 
         public void AddTag(Identifier tag)

Barotrauma/BarotraumaShared/SharedSource/Utils/ToolBox.cs

@@ -2,6 +2,7 @@
 using Barotrauma.Networking;
 using Microsoft.Xna.Framework;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
@@ -75,7 +76,7 @@ namespace Barotrauma
             return !corrected;
         }
 
-        private static readonly Dictionary<string, string> cachedFileNames = new Dictionary<string, string>();
+        private static readonly ConcurrentDictionary<string, string> cachedFileNames = new ConcurrentDictionary<string, string>();
 
         public static string CorrectFilenameCase(string filename, out bool corrected, string directory = "")
         {
@@ -153,7 +154,7 @@ namespace Barotrauma
                 if (i < subDirs.Length - 1) { filename += "/"; }
             }
 
-            cachedFileNames.Add(originalFilename, filename);
+            cachedFileNames.TryAdd(originalFilename, filename);
             return filename;
         }
 
@@ -355,32 +356,26 @@ namespace Barotrauma
             return text;
         }
 
-        private static Dictionary<string, List<string>> cachedLines = new Dictionary<string, List<string>>();
+        private static readonly ConcurrentDictionary<string, List<string>> cachedLines = new ConcurrentDictionary<string, List<string>>();
         public static string GetRandomLine(string filePath, Rand.RandSync randSync = Rand.RandSync.ServerAndClient)
         {
-            List<string> lines;
-            if (cachedLines.ContainsKey(filePath))
-            {
-                lines = cachedLines[filePath];
-            }
-            else
+            List<string> lines = cachedLines.GetOrAdd(filePath, path =>
             {
                 try
                 {
-                    lines = File.ReadAllLines(filePath, catchUnauthorizedAccessExceptions: false).ToList();
-                    cachedLines.Add(filePath, lines);
-                    if (lines.Count == 0)
+                    var fileLines = File.ReadAllLines(path, catchUnauthorizedAccessExceptions: false).ToList();
+                    if (fileLines.Count == 0)
                     {
-                        DebugConsole.ThrowError("File \"" + filePath + "\" is empty!");
-                        return "";
+                        DebugConsole.ThrowError("File \"" + path + "\" is empty!");
                     }
+                    return fileLines;
                 }
                 catch (Exception e)
                 {
-                    DebugConsole.ThrowError("Couldn't open file \"" + filePath + "\"!", e);
-                    return "";
-                }
+                    DebugConsole.ThrowError("Couldn't open file \"" + path + "\"!", e);
+                    return new List<string>();
                 }
+            });
 
             if (lines.Count == 0) return "";
             return lines[Rand.Range(0, lines.Count, randSync)];

Libraries/Farseer Physics Engine 3.5/Collision/DynamicTree.cs

@@ -30,6 +30,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Threading;
 using FarseerPhysics.Common;
 using FarseerPhysics.Dynamics;
 using Microsoft.Xna.Framework;
@@ -74,8 +75,15 @@ namespace FarseerPhysics.Collision
     /// </summary>
     public class DynamicTree<T>
     {
-        private Stack<int> _raycastStack = new Stack<int>(256);
-        private Stack<int> _queryStack = new Stack<int>(256);
+        // Thread-local stacks to ensure thread safety during parallel queries/raycasts
+        [ThreadStatic]
+        private static Stack<int> _raycastStack;
+        [ThreadStatic]
+        private static Stack<int> _queryStack;
+        
+        private static Stack<int> RaycastStack => _raycastStack ??= new Stack<int>(256);
+        private static Stack<int> QueryStack => _queryStack ??= new Stack<int>(256);
+        
         private int _freeList;
         private int _nodeCapacity;
         private int _nodeCount;
@@ -346,12 +354,12 @@ namespace FarseerPhysics.Collision
         /// <param name="aabb">The aabb.</param>
         public void Query(Func<int, bool> callback, ref AABB aabb, ref Body body)
         {
-            _queryStack.Clear();
-            _queryStack.Push(_root);
+            QueryStack.Clear();
+            QueryStack.Push(_root);
 
-            while (_queryStack.Count > 0)
+            while (QueryStack.Count > 0)
             {
-                int nodeId = _queryStack.Pop();
+                int nodeId = QueryStack.Pop();
                 if (nodeId == NullNode)
                 {
                     continue;
@@ -386,8 +394,8 @@ namespace FarseerPhysics.Collision
                     }
                     else
                     {
-                        _queryStack.Push(node.Child1);
-                        _queryStack.Push(node.Child2);
+                        QueryStack.Push(node.Child1);
+                        QueryStack.Push(node.Child2);
                     }                    
                 }
             }
@@ -395,12 +403,12 @@ namespace FarseerPhysics.Collision
 
         public void Query(Func<int, bool> callback, ref AABB aabb)
         {
-            _queryStack.Clear();
-            _queryStack.Push(_root);
+            QueryStack.Clear();
+            QueryStack.Push(_root);
 
-            while (_queryStack.Count > 0)
+            while (QueryStack.Count > 0)
             {
-                int nodeId = _queryStack.Pop();
+                int nodeId = QueryStack.Pop();
                 if (nodeId == NullNode)
                 {
                     continue;
@@ -419,8 +427,8 @@ namespace FarseerPhysics.Collision
                     }
                     else
                     {
-                        _queryStack.Push(_nodes[nodeId].Child1);
-                        _queryStack.Push(_nodes[nodeId].Child2);
+                        QueryStack.Push(_nodes[nodeId].Child1);
+                        QueryStack.Push(_nodes[nodeId].Child2);
                     }
                 }
             }
@@ -460,12 +468,12 @@ namespace FarseerPhysics.Collision
                 Vector2.Max(ref p1, ref t, out segmentAABB.UpperBound);
             }
 
-            _raycastStack.Clear();
-            _raycastStack.Push(_root);
+            RaycastStack.Clear();
+            RaycastStack.Push(_root);
 
-            while (_raycastStack.Count > 0)
+            while (RaycastStack.Count > 0)
             {
-                int nodeId = _raycastStack.Pop();
+                int nodeId = RaycastStack.Pop();
                 if (nodeId == NullNode)
                 {
                     continue;
@@ -522,8 +530,8 @@ namespace FarseerPhysics.Collision
                 }
                 else
                 {
-                    _raycastStack.Push(_nodes[nodeId].Child1);
-                    _raycastStack.Push(_nodes[nodeId].Child2);
+                    RaycastStack.Push(_nodes[nodeId].Child1);
+                    RaycastStack.Push(_nodes[nodeId].Child2);
                 }
             }
         }

README.md

@@ -1,4 +1,4 @@
-# LuaCsForBarotrauma Enhanced Performence Project
+# LuaCsForBarotrauma Enhanced Performance Project
 
 > ⚠ **Warning：** This release is only available for server-side use and is not recommended to run on the client. Make sure that compatibility is adequately tested before deployment.