v0.14.6.0

Barotrauma/BarotraumaShared/SharedSource/Events/EventActions/CheckDataAction.cs

@@ -23,7 +23,17 @@ namespace Barotrauma
 
         protected PropertyConditional.OperatorType Operator { get; set; }
 
-        public CheckDataAction(ScriptedEvent parentEvent, XElement element) : base(parentEvent, element) { }
+        public CheckDataAction(ScriptedEvent parentEvent, XElement element) : base(parentEvent, element) 
+        {
+            if (string.IsNullOrEmpty(Condition))
+            {
+                Condition = element.GetAttributeString("value", string.Empty);
+                if (string.IsNullOrEmpty(Condition))
+                {
+                    DebugConsole.ThrowError($"Error in scripted event \"{parentEvent.Prefab.Identifier}\". CheckDataAction with no condition set ({element}).");
+                }
+            }
+        }
 
         protected override bool? DetermineSuccess()
         {

Barotrauma/BarotraumaShared/SharedSource/Events/EventActions/ConversationAction.cs

@@ -179,7 +179,7 @@ namespace Barotrauma
         {
             if (speaker == null) { return; }
             speaker.CampaignInteractionType = CampaignMode.InteractionType.None;
-            speaker.ActiveConversation = this;
+            speaker.ActiveConversation = null;
             speaker.SetCustomInteract(null, null);
 #if SERVER
             GameMain.NetworkMember.CreateEntityEvent(speaker, new object[] { NetEntityEvent.Type.AssignCampaignInteraction });
@@ -213,7 +213,14 @@ namespace Barotrauma
                 if (dialogOpened)
                 {
 #if CLIENT
-                    Character.DisableControls = true;
+                    if (GUIMessageBox.MessageBoxes.Any(mb => mb.UserData as string == "ConversationAction"))
+                    {
+                        Character.DisableControls = true;
+                    }
+                    else
+                    {
+                        Reset();
+                    }
 #endif
                     if (ShouldInterrupt())
                     {
@@ -240,7 +247,7 @@ namespace Barotrauma
                     {
                         TryStartConversation(speaker);
                     }
-                    else
+                    else if (speaker.ActiveConversation != this)
                     {
                         speaker.CampaignInteractionType = CampaignMode.InteractionType.Talk;
                         speaker.ActiveConversation = this;
@@ -303,9 +310,15 @@ namespace Barotrauma
 
         private bool IsValidTarget(Entity e)
         {
-            return 
-                e is Character character && !character.Removed && !character.IsDead && !character.IsIncapacitated &&
+            bool isValid = e is Character character && !character.Removed && !character.IsDead && !character.IsIncapacitated &&
                 (e == Character.Controlled || character.IsRemotePlayer);
+#if SERVER
+            UpdateIgnoredClients();
+            isValid &= !ignoredClients.Keys.Any(c => c.Character == e);
+#elif CLIENT
+            isValid &= (e != Character.Controlled || !GUI.InputBlockingMenuOpen);
+#endif
+            return isValid;
         }
 
         private void TryStartConversation(Character speaker, Character targetCharacter = null)
@@ -348,10 +361,18 @@ namespace Barotrauma
             {
                 ParentEvent.AddTarget(InvokerTag, targetCharacter);
             }
-            
+
             ShowDialog(speaker, targetCharacter);
 
             dialogOpened = true;
+            if (speaker != null)
+            {
+                speaker.CampaignInteractionType = CampaignMode.InteractionType.None;
+                speaker.SetCustomInteract(null, null);
+#if SERVER
+                GameMain.NetworkMember.CreateEntityEvent(speaker, new object[] { NetEntityEvent.Type.AssignCampaignInteraction });
+#endif
+            }
         }
 
         partial void ShowDialog(Character speaker, Character targetCharacter);

Barotrauma/BarotraumaShared/SharedSource/Events/EventActions/MissionAction.cs

@@ -14,6 +14,18 @@ namespace Barotrauma
         [Serialize("", true)]
         public string MissionTag { get; set; }
 
+        [Serialize("", true, description: "The type of the location the mission will be unlocked in (if empty, any location can be selected).")]
+        public string LocationType { get; set; }
+
+        [Serialize(0, true, description: "Minimum distance to the location the mission is unlocked in (1 = one path between locations).")]
+        public int MinLocationDistance { get; set; }
+
+        [Serialize(true, true, description: "If true, the mission has to be unlocked in a location further on the campaign map.")]
+        public bool UnlockFurtherOnMap { get; set; }
+
+        [Serialize(false, true, description: "If true, a suitable location is forced on the map if one isn't found.")]
+        public bool CreateLocationIfNotFound { get; set; }
+
         private bool isFinished;
 
         public MissionAction(ScriptedEvent parentEvent, XElement element) : base(parentEvent, element)
@@ -44,33 +56,82 @@ namespace Barotrauma
             if (GameMain.GameSession.GameMode is CampaignMode campaign)
             {
                 MissionPrefab prefab = null;
-                if (!string.IsNullOrEmpty(MissionIdentifier))
+                var unlockLocation = FindUnlockLocation();
+                if (unlockLocation == null && CreateLocationIfNotFound)
                 {
-                    prefab = campaign.Map.CurrentLocation.UnlockMissionByIdentifier(MissionIdentifier);                    
-                }
-                else if (!string.IsNullOrEmpty(MissionTag))
-                {
-                    prefab = campaign.Map.CurrentLocation.UnlockMissionByTag(MissionTag);
-                }
-                if (campaign is MultiPlayerCampaign mpCampaign)
-                {
-                    mpCampaign.LastUpdateID++;
+                    //find an empty location at least 3 steps away, further on the map
+                    var emptyLocation = FindUnlockLocationRecursive(campaign.Map.CurrentLocation, Math.Max(MinLocationDistance, 3), "none", true, new HashSet<Location>());
+                    if (emptyLocation != null)
+                    {
+                        emptyLocation.ChangeType(Barotrauma.LocationType.List.Find(lt => lt.Identifier.Equals(LocationType, StringComparison.OrdinalIgnoreCase)));
+                        unlockLocation = emptyLocation;
+                    }
                 }
 
-                if (prefab != null)
+                if (unlockLocation != null)
                 {
-#if CLIENT
-                    new GUIMessageBox(string.Empty, TextManager.GetWithVariable("missionunlocked", "[missionname]", prefab.Name), 
-                        new string[0], type: GUIMessageBox.Type.InGame, icon: prefab.Icon, relativeSize: new Vector2(0.3f, 0.15f), minSize: new Point(512, 128))
+                    if (!string.IsNullOrEmpty(MissionIdentifier))
                     {
-                        IconColor = prefab.IconColor
-                    };
-#else
-                    NotifyMissionUnlock(prefab);
-#endif
+                        prefab = unlockLocation.UnlockMissionByIdentifier(MissionIdentifier);                    
+                    }
+                    else if (!string.IsNullOrEmpty(MissionTag))
+                    {
+                        prefab = unlockLocation.UnlockMissionByTag(MissionTag);
+                    }
+                    if (campaign is MultiPlayerCampaign mpCampaign)
+                    {
+                        mpCampaign.LastUpdateID++;
+                    }
+                    if (prefab != null)
+                    {
+                        DebugConsole.NewMessage($"Unlocked mission \"{prefab.Name}\" in the location \"{unlockLocation.Name}\".");
+    #if CLIENT
+                        new GUIMessageBox(string.Empty, TextManager.GetWithVariable("missionunlocked", "[missionname]", prefab.Name), 
+                            new string[0], type: GUIMessageBox.Type.InGame, icon: prefab.Icon, relativeSize: new Vector2(0.3f, 0.15f), minSize: new Point(512, 128))
+                        {
+                            IconColor = prefab.IconColor
+                        };
+    #else
+                        NotifyMissionUnlock(prefab);
+    #endif
+                    }
+                }
+                else
+                {
+                    DebugConsole.AddWarning($"Failed to find a suitable location to unlock a mission in (LocationType: {LocationType}, MinLocationDistance: {MinLocationDistance}, UnlockFurtherOnMap: {UnlockFurtherOnMap})");
                 }
             }
-            isFinished = true;            
+            isFinished = true;
+        }
+
+        private Location FindUnlockLocation()
+        {
+            var campaign = GameMain.GameSession.GameMode as CampaignMode;
+            if (string.IsNullOrEmpty(LocationType) && MinLocationDistance <= 1)
+            {
+                return campaign.Map.CurrentLocation;
+            }
+
+            return FindUnlockLocationRecursive(campaign.Map.CurrentLocation, 0, LocationType, UnlockFurtherOnMap, new HashSet<Location>());
+        }
+
+        private Location FindUnlockLocationRecursive(Location currLocation, int currDistance, string locationType, bool unlockFurtherOnMap, HashSet<Location> checkedLocations)
+        {
+            var campaign = GameMain.GameSession.GameMode as CampaignMode;
+            if (currLocation.Type.Identifier.Equals(locationType, StringComparison.OrdinalIgnoreCase) && currDistance >= MinLocationDistance &&
+                (!unlockFurtherOnMap || currLocation.MapPosition.X > campaign.Map.CurrentLocation.MapPosition.X))
+            {
+                return currLocation;
+            }
+            checkedLocations.Add(currLocation);
+            foreach (LocationConnection connection in currLocation.Connections)
+            {
+                var otherLocation = connection.OtherLocation(currLocation);
+                if (checkedLocations.Contains(otherLocation)) { continue; }
+                var unlockLocation = FindUnlockLocationRecursive(otherLocation, ++currDistance, locationType, unlockFurtherOnMap, checkedLocations);
+                if (unlockLocation != null) { return unlockLocation; }
+            }
+            return null;
         }
 
         public override string ToDebugString()
@@ -84,8 +145,8 @@ namespace Barotrauma
             foreach (Client client in GameMain.Server.ConnectedClients)
             {
                 IWriteMessage outmsg = new WriteOnlyMessage();
-                outmsg.Write((byte) ServerPacketHeader.EVENTACTION);
-                outmsg.Write((byte) EventManager.NetworkEventType.MISSION);
+                outmsg.Write((byte)ServerPacketHeader.EVENTACTION);
+                outmsg.Write((byte)EventManager.NetworkEventType.MISSION);
                 outmsg.Write(prefab.Identifier);
                 GameMain.Server.ServerPeer.Send(outmsg, client.Connection, DeliveryMethod.Reliable);
             }

Barotrauma/BarotraumaShared/SharedSource/Events/EventActions/NPCChangeTeamAction.cs

@@ -0,0 +1,73 @@
+using Barotrauma.Networking;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class NPCChangeTeamAction : EventAction
+    {
+        [Serialize("", true)]
+        public string NPCTag { get; set; }
+
+        [Serialize(0, true)]
+        public int TeamTag { get; set; }
+
+        [Serialize(false, true)]
+        public bool AddToCrew { get; set; }
+
+        private bool isFinished = false;
+
+        public NPCChangeTeamAction(ScriptedEvent parentEvent, XElement element) : base(parentEvent, element) { }
+
+        private List<Character> affectedNpcs = null;
+
+        public override void Update(float deltaTime)
+        {
+            if (isFinished) { return; }
+
+            affectedNpcs = ParentEvent.GetTargets(NPCTag).Where(c => c is Character).Select(c => c as Character).ToList();
+            foreach (var npc in affectedNpcs)
+            {
+                CharacterTeamType newTeam = (CharacterTeamType)TeamTag;
+                // characters will still remain on friendlyNPC team for rest of the tick
+                npc.SetOriginalTeam(newTeam);
+
+                if (AddToCrew && (newTeam == CharacterTeamType.Team1 || newTeam == CharacterTeamType.Team2))
+                {
+                    npc.Info.StartItemsGiven = true;
+
+                    GameMain.GameSession.CrewManager.AddCharacter(npc);
+                    foreach (Item item in npc.Inventory.AllItems)
+                    {
+                        item.AllowStealing = true;
+                        var wifiComponent = item.GetComponent<Items.Components.WifiComponent>();
+                        if (wifiComponent != null)
+                        {
+                            wifiComponent.TeamID = newTeam;
+                        }
+                    }
+#if SERVER
+                    GameMain.NetworkMember.CreateEntityEvent(npc, new object[] { NetEntityEvent.Type.AddToCrew, newTeam, npc.Inventory.AllItems.Select(it => it.ID).ToArray() });
+#endif
+                }
+            }
+            isFinished = true;
+        }
+
+        public override bool IsFinished(ref string goTo)
+        {
+            return isFinished;
+        }
+
+        public override void Reset()
+        {
+            isFinished = false;
+        }
+
+        public override string ToDebugString()
+        {
+            return $"{ToolBox.GetDebugSymbol(isFinished)} {nameof(NPCChangeTeamAction)} -> (NPCTag: {NPCTag.ColorizeObject()})";
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Events/EventActions/NPCFollowAction.cs

@@ -48,9 +48,9 @@ namespace Barotrauma
                 }
                 else
                 {
-                    foreach (var goToObjective in humanAiController.ObjectiveManager.GetActiveObjectives<AIObjectiveGoTo>())
+                    foreach (var objective in humanAiController.ObjectiveManager.Objectives)
                     {
-                        if (goToObjective.Target == target)
+                        if (objective is AIObjectiveGoTo goToObjective && goToObjective.Target == target)
                         {
                             goToObjective.Abandon = true;
                         }

Barotrauma/BarotraumaShared/SharedSource/Events/EventActions/RemoveItemAction.cs

@@ -20,11 +20,7 @@ namespace Barotrauma
         { 
             if (string.IsNullOrWhiteSpace(ItemIdentifier))
             {
-                ItemIdentifier = element.GetAttributeString("itemidentifiers", "");
-            }
-            if (string.IsNullOrWhiteSpace(ItemIdentifier))
-            {
-                DebugConsole.ThrowError($"Error in event \"{parentEvent.Prefab.Identifier}\" - RemoveItemAction without an item identifier.");
+                ItemIdentifier = element.GetAttributeString("itemidentifiers", null) ?? element.GetAttributeString("identifier", "");
             }
         }
 
@@ -47,7 +43,7 @@ namespace Barotrauma
             bool hasValidTargets = false;
             foreach (Entity target in targets)
             {
-                if (target is Character character && character.Inventory != null) 
+                if (target is Character character && character.Inventory != null || target is Item) 
                 {
                     hasValidTargets = true;
                     break;
@@ -55,20 +51,31 @@ namespace Barotrauma
             }
             if (!hasValidTargets) { return; }
 
-            List<Item> usedItems = new List<Item>();
+            HashSet<Item> removedItems = new HashSet<Item>();
             foreach (Entity target in targets)
             {
                 Inventory inventory = (target as Character)?.Inventory;
-                if (inventory == null) { continue; }
-                while (usedItems.Count < Amount)
+                if (inventory != null) 
                 {
-                    var item = inventory.FindItem(it => 
-                        it != null && 
-                        !usedItems.Contains(it) &&
-                        it.Prefab.Identifier.Equals(ItemIdentifier, StringComparison.InvariantCultureIgnoreCase), recursive: true);
-                    if (item == null) { break; }
-                    Entity.Spawner.AddToRemoveQueue(item);
-                    usedItems.Add(item);
+                    while (removedItems.Count < Amount)
+                    {
+                        var item = inventory.FindItem(it => 
+                            it != null && 
+                            !removedItems.Contains(it) &&
+                            (string.IsNullOrEmpty(ItemIdentifier) || it.Prefab.Identifier.Equals(ItemIdentifier, StringComparison.InvariantCultureIgnoreCase)), recursive: true);
+                        if (item == null) { break; }
+                        Entity.Spawner.AddToRemoveQueue(item);
+                        removedItems.Add(item);
+                    }                    
+                }
+                else if (target is Item item)
+                {
+                    if (string.IsNullOrEmpty(ItemIdentifier) || item.Prefab.Identifier.Equals(ItemIdentifier, StringComparison.InvariantCultureIgnoreCase))
+                    {
+                        Entity.Spawner.AddToRemoveQueue(item);
+                        removedItems.Add(item);
+                        if (removedItems.Count >= Amount) { break; }
+                    }
                 }
             }
             isFinished = true;

Barotrauma/BarotraumaShared/SharedSource/Events/EventActions/SpawnAction.cs

@@ -15,7 +15,8 @@ namespace Barotrauma
             Outpost,
             MainPath,
             Ruin,
-            Wreck
+            Wreck,
+            BeaconStation
         }
 
         [Serialize("", true, description: "Species name of the character to spawn.")]
@@ -102,31 +103,36 @@ namespace Barotrauma
         public override void Update(float deltaTime)
         {
             if (spawned) { return; }
-            
+
             if (!string.IsNullOrEmpty(NPCSetIdentifier) && !string.IsNullOrEmpty(NPCIdentifier))
             {
                 HumanPrefab humanPrefab = NPCSet.Get(NPCSetIdentifier, NPCIdentifier);
-                ISpatialEntity spawnPos = GetSpawnPos();
-                Entity.Spawner.AddToSpawnQueue(CharacterPrefab.HumanSpeciesName, OffsetSpawnPos(spawnPos?.WorldPosition ?? Vector2.Zero, 100.0f), onSpawn: newCharacter =>
+                if (humanPrefab != null)
                 {
-                    newCharacter.TeamID = CharacterTeamType.FriendlyNPC;
-                    newCharacter.EnableDespawn = false;
-                    humanPrefab.GiveItems(newCharacter, newCharacter.Submarine);
-                    if (LootingIsStealing)
+                    ISpatialEntity spawnPos = GetSpawnPos();
+                    Entity.Spawner.AddToSpawnQueue(CharacterPrefab.HumanSpeciesName, OffsetSpawnPos(spawnPos?.WorldPosition ?? Vector2.Zero, 100.0f), humanPrefab.GetCharacterInfo(), onSpawn: newCharacter =>
                     {
-                        foreach (Item item in newCharacter.Inventory.AllItems)
+                        if (newCharacter == null) { return; }
+                        newCharacter.Prefab = humanPrefab;
+                        newCharacter.TeamID = CharacterTeamType.FriendlyNPC;
+                        newCharacter.EnableDespawn = false;
+                        humanPrefab.GiveItems(newCharacter, newCharacter.Submarine);
+                        if (LootingIsStealing)
                         {
-                            item.SpawnedInOutpost = true;
-                            item.AllowStealing = false;
+                            foreach (Item item in newCharacter.Inventory.AllItems)
+                            {
+                                item.SpawnedInOutpost = true;
+                                item.AllowStealing = false;
+                            }
                         }
-                    }
-                    humanPrefab.InitializeCharacter(newCharacter, spawnPos);
-                    if (!string.IsNullOrEmpty(TargetTag) && newCharacter != null)
-                    {
-                        ParentEvent.AddTarget(TargetTag, newCharacter);
-                    }
-                    spawnedEntity = newCharacter;
-                });
+                        humanPrefab.InitializeCharacter(newCharacter, spawnPos);
+                        if (!string.IsNullOrEmpty(TargetTag) && newCharacter != null)
+                        {
+                            ParentEvent.AddTarget(TargetTag, newCharacter);
+                        }
+                        spawnedEntity = newCharacter;
+                    });
+                }
             }
             else if (!string.IsNullOrEmpty(SpeciesName))
             {
@@ -196,8 +202,7 @@ namespace Barotrauma
                 }
             }
 
-            spawned = true;
-            
+            spawned = true;            
         }
 
         public static Vector2 OffsetSpawnPos(Vector2 pos, float offsetAmount)
@@ -225,6 +230,7 @@ namespace Barotrauma
                     SpawnLocationType.Outpost => Item.ItemList.FindAll(it => it.Submarine != null && it.Submarine.Info.IsOutpost),
                     SpawnLocationType.Wreck => Item.ItemList.FindAll(it => it.Submarine != null && it.Submarine.Info.IsWreck),
                     SpawnLocationType.Ruin => Item.ItemList.FindAll(it => it.ParentRuin != null),
+                    SpawnLocationType.BeaconStation => Item.ItemList.FindAll(it => it.Submarine != null && it.Submarine.Info.IsBeacon),
                     _ => throw new NotImplementedException()
                 };
 
@@ -250,15 +256,15 @@ namespace Barotrauma
                 SpawnLocationType.Outpost => WayPoint.WayPointList.FindAll(wp => wp.Submarine != null && wp.CurrentHull != null && wp.Submarine.Info.IsOutpost),
                 SpawnLocationType.Wreck => WayPoint.WayPointList.FindAll(wp => wp.Submarine != null && wp.Submarine.Info.IsWreck),
                 SpawnLocationType.Ruin => WayPoint.WayPointList.FindAll(wp => wp.ParentRuin != null),
+                SpawnLocationType.BeaconStation => WayPoint.WayPointList.FindAll(wp => wp.Submarine != null && wp.Submarine.Info.IsBeacon),
                 _ => throw new NotImplementedException()
             };
 
             potentialSpawnPoints = potentialSpawnPoints.FindAll(wp => wp.ConnectedDoor == null && wp.Ladders == null && !wp.isObstructed);
 
-            var airlockSpawnPoints = potentialSpawnPoints.Where(wp => wp.CurrentHull?.OutpostModuleTags?.Contains("airlock") ?? false).ToList();
             if (moduleFlags != null && moduleFlags.Any())
             {
-                List<WayPoint> spawnPoints = potentialSpawnPoints.Where(wp => wp.CurrentHull?.OutpostModuleTags?.Any(moduleFlags.Contains) ?? false).ToList();
+                List<WayPoint> spawnPoints = potentialSpawnPoints.Where(wp => wp.CurrentHull?.OutpostModuleTags.Any(moduleFlags.Contains) ?? false).ToList();
                 if (spawnPoints.Any())
                 {
                     potentialSpawnPoints = spawnPoints;
@@ -267,8 +273,10 @@ namespace Barotrauma
 
             if (spawnpointTags != null && spawnpointTags.Any())
             {
-                var spawnPoints = potentialSpawnPoints.Where(wp => spawnpointTags.Any(tag => wp.Tags.Contains(tag)))
-                                                                 .Where(wp => wp.ConnectedDoor == null && !wp.isObstructed);
+                var spawnPoints = potentialSpawnPoints
+                    .Where(wp => spawnpointTags.Any(tag => wp.Tags.Contains(tag)))
+                    .Where(wp => wp.ConnectedDoor == null && !wp.isObstructed);
+
                 if (spawnPoints.Any())
                 {
                     potentialSpawnPoints = spawnPoints.ToList();
@@ -293,6 +301,7 @@ namespace Barotrauma
             }
 
             //don't spawn in an airlock module if there are other options
+            var airlockSpawnPoints = potentialSpawnPoints.Where(wp => wp.CurrentHull?.OutpostModuleTags.Contains("airlock") ?? false);
             if (airlockSpawnPoints.Count() < validSpawnPoints.Count())
             {
                 validSpawnPoints = validSpawnPoints.Except(airlockSpawnPoints);

Barotrauma/BarotraumaShared/SharedSource/Events/EventActions/StatusEffectAction.cs

@@ -51,7 +51,14 @@ namespace Barotrauma
             {
                 foreach (var target in targets)
                 {
-                    effect.Apply(effect.type, deltaTime, target, target as ISerializableEntity);
+                    if (target is Item targetItem)
+                    {
+                        effect.Apply(effect.type, deltaTime, target, targetItem.AllPropertyObjects);
+                    }
+                    else
+                    {
+                        effect.Apply(effect.type, deltaTime, target, target as ISerializableEntity);
+                    }
                 }
             }
 #if SERVER

Barotrauma/BarotraumaShared/SharedSource/Events/EventActions/TagAction.cs

@@ -6,7 +6,7 @@ namespace Barotrauma
 {
     class TagAction : EventAction
     {
-        public enum SubType { Any= 0, Player = 1, Outpost = 2, Wreck = 4, BeaconStation = 8 }
+        public enum SubType { Any = 0, Player = 1, Outpost = 2, Wreck = 4, BeaconStation = 8 }
 
         [Serialize("", true)]
         public string Criteria { get; set; }
@@ -67,6 +67,16 @@ namespace Barotrauma
 #endif
         }
 
+        private void TagHumansByIdentifier(string identifier)
+        {
+            foreach (Character c in Character.CharacterList)
+            {
+                if (c.Prefab?.Identifier.Equals(identifier, StringComparison.OrdinalIgnoreCase) ?? false)
+                {
+                    ParentEvent.AddTarget(Tag, c);
+                }
+            }
+        }
         private void TagStructuresByIdentifier(string identifier)
         {
             ParentEvent.AddTargetPredicate(Tag, e => e is Structure s && SubmarineTypeMatches(s.Submarine) && s.Prefab.Identifier.Equals(identifier, StringComparison.InvariantCultureIgnoreCase));
@@ -122,6 +132,9 @@ namespace Barotrauma
                     case "crew":
                         TagCrew();
                         break;
+                    case "humanprefabidentifier":
+                        if (kvp.Length > 1) { TagHumansByIdentifier(kvp[1].Trim()); }
+                        break;
                     case "structureidentifier":
                         if (kvp.Length > 1) { TagStructuresByIdentifier(kvp[1].Trim()); }
                         break;

Barotrauma/BarotraumaShared/SharedSource/Events/EventActions/TriggerAction.cs

@@ -1,3 +1,4 @@
+using Barotrauma.Networking;
 using Microsoft.Xna.Framework;
 using System.Linq;
 using System.Xml.Linq;
@@ -30,6 +31,9 @@ namespace Barotrauma
         [Serialize(true, true, description: "If true, dead/unconscious characters cannot trigger the action.")]
         public bool DisableIfTargetIncapacitated { get; set; }
 
+        [Serialize(false, true, description: "If true, one target must interact with the other to trigger the action.")]
+        public bool WaitForInteraction { get; set; }
+
         private float distance;
         
         public TriggerAction(ScriptedEvent parentEvent, XElement element) : base(parentEvent, element) 
@@ -44,12 +48,15 @@ namespace Barotrauma
         }
         public override void Reset()
         {
+            ResetTargetIcons();
             isRunning = false;
             isFinished = false;
         }
 
         public bool isRunning = false;
 
+        private Either<Character, Item> npcOrItem = null;
+
         public override void Update(float deltaTime)
         {
             if (isFinished) { return; }
@@ -81,20 +88,104 @@ namespace Barotrauma
                     if (DisableInCombat && IsInCombat(e2)) { continue; }
                     if (DisableIfTargetIncapacitated && e2 is Character character2 && (character2.IsDead || character2.IsIncapacitated)) { continue; }
 
-                    Vector2 pos1 = e1.WorldPosition;
-                    Vector2 pos2 = e2.WorldPosition;
-                    distance = Vector2.Distance(pos1, pos2);
-                    if (((e1 is MapEntity m1) && Submarine.RectContains(m1.WorldRect, pos2)) ||
-                        ((e2 is MapEntity m2) && Submarine.RectContains(m2.WorldRect, pos1)) ||
-                        Vector2.DistanceSquared(pos1, pos2) < Radius * Radius)
+                    if (WaitForInteraction)
                     {
-                        Trigger(e1, e2);
-                        return;
+                        Character player = null;
+                        Character npc = null;
+                        Item item = null;
+                        npcOrItem?.TryGet(out npc);
+                        npcOrItem?.TryGet(out item);
+                        if (e1 is Character char1)
+                        {
+                            if (char1.IsBot) { npc ??= char1; }
+                            else { player = char1; }
+                        }
+                        else
+                        {
+                            item ??= e1 as Item;
+                        }
+                        if (e2 is Character char2)
+                        {
+                            if (char2.IsBot) { npc ??= char2; }
+                            else { player = char2; }
+                        }
+                        else
+                        {
+                            item ??= e2 as Item;
+                        }
+
+                        if (player != null)
+                        {
+                            if (npc != null)
+                            {
+                                if (npc.CampaignInteractionType != CampaignMode.InteractionType.Examine)
+                                {
+                                    npcOrItem = npc;
+                                    npc.CampaignInteractionType = CampaignMode.InteractionType.Examine;
+                                    npc.RequireConsciousnessForCustomInteract = false;
+#if CLIENT
+                                    npc.SetCustomInteract(
+                                        (speaker, player) => { if (e1 == speaker) { Trigger(speaker, player); } else { Trigger(player, speaker); } },
+                                        TextManager.GetWithVariable("CampaignInteraction.Examine", "[key]", GameMain.Config.KeyBindText(InputType.Use)));
+#else
+                                    npc.SetCustomInteract(
+                                        (speaker, player) => { if (e1 == speaker) { Trigger(speaker, player); } else { Trigger(player, speaker); } }, 
+                                        TextManager.Get("CampaignInteraction.Talk"));
+                                    GameMain.NetworkMember.CreateEntityEvent(npc, new object[] { NetEntityEvent.Type.AssignCampaignInteraction });
+#endif
+                                }
+
+                                return;
+                            }
+                            else if (item != null)
+                            {
+                                npcOrItem = item;
+                                item.CampaignInteractionType = CampaignMode.InteractionType.Examine;
+                                if (player.SelectedConstruction == item ||
+                                    player.Inventory.Contains(item) ||
+                                    (player.FocusedItem == item && player.IsKeyHit(InputType.Use)))
+                                {
+                                    Trigger(e1, e2);
+                                    return;
+                                }
+                            }
+                        }
+                    }
+                    else
+                    {
+                        Vector2 pos1 = e1.WorldPosition;
+                        Vector2 pos2 = e2.WorldPosition;
+                        distance = Vector2.Distance(pos1, pos2);
+                        if (((e1 is MapEntity m1) && Submarine.RectContains(m1.WorldRect, pos2)) ||
+                            ((e2 is MapEntity m2) && Submarine.RectContains(m2.WorldRect, pos1)) ||
+                            Vector2.DistanceSquared(pos1, pos2) < Radius * Radius)
+                        {
+                            Trigger(e1, e2);
+                            return;
+                        }
                     }
                 }
             }            
         }
 
+        private void ResetTargetIcons()
+        {
+            if (npcOrItem == null) { return; }
+            if (npcOrItem.TryGet(out Character npc))
+            {
+                npc.CampaignInteractionType = CampaignMode.InteractionType.None;
+                npc.SetCustomInteract(null, null);
+                npc.RequireConsciousnessForCustomInteract = true;
+#if SERVER
+                GameMain.NetworkMember.CreateEntityEvent(npc, new object[] { NetEntityEvent.Type.AssignCampaignInteraction });
+#endif
+            }
+            else if (npcOrItem.TryGet(out Item item))
+            {
+                item.CampaignInteractionType = CampaignMode.InteractionType.None;
+            }
+        }
+
         private bool IsCloseEnoughToHull(Entity e, out Hull hull)
         {
             hull = null;
@@ -157,6 +248,7 @@ namespace Barotrauma
 
         private void Trigger(Entity entity1, Entity entity2)
         {
+            ResetTargetIcons();
             if (!string.IsNullOrEmpty(ApplyToTarget1))
             {
                 ParentEvent.AddTarget(ApplyToTarget1, entity1);
@@ -174,7 +266,14 @@ namespace Barotrauma
         {
             if (string.IsNullOrEmpty(TargetModuleType))
             {
-                return $"{ToolBox.GetDebugSymbol(isFinished, isRunning)} {nameof(TriggerAction)} -> (Distance: {((int)distance).ColorizeObject()}, Radius: {Radius.ColorizeObject()}, TargetTags: {Target1Tag.ColorizeObject()}, {Target2Tag.ColorizeObject()})";
+                return
+                    $"{ToolBox.GetDebugSymbol(isFinished, isRunning)} {nameof(TriggerAction)} -> (" +
+                    (WaitForInteraction ?
+                        $"Selected non-player target: {(npcOrItem?.ToString() ?? "<null>").ColorizeObject()}, " :
+                        $"Distance: {((int)distance).ColorizeObject()}, ") +
+                    $"Radius: {Radius.ColorizeObject()}, " +
+                    $"TargetTags: {Target1Tag.ColorizeObject()}, " +
+                    $"{Target2Tag.ColorizeObject()})";
             }
             else
             {

Barotrauma/BarotraumaShared/SharedSource/Events/EventManager.cs

@@ -50,7 +50,7 @@ namespace Barotrauma
         private float calculateDistanceTraveledTimer;
         private float distanceTraveled;
 
-        private float avgCrewHealth, avgHullIntegrity, floodingAmount, fireAmount, enemyDanger;
+        private float avgCrewHealth, avgHullIntegrity, floodingAmount, fireAmount, enemyDanger, monsterTotalStrength;
 
         private float roundDuration;
 
@@ -107,7 +107,7 @@ namespace Barotrauma
             totalPathLength = 0.0f;
             if (level != null)
             {
-                var steeringPath = pathFinder.FindPath(ConvertUnits.ToSimUnits(Level.Loaded.StartPosition), ConvertUnits.ToSimUnits(Level.Loaded.EndPosition));
+                var steeringPath = pathFinder.FindPath(ConvertUnits.ToSimUnits(level.StartPosition), ConvertUnits.ToSimUnits(level.EndPosition));
                 totalPathLength = steeringPath.TotalLength;
             }
 
@@ -124,7 +124,7 @@ namespace Barotrauma
             }
             MTRandom rand = new MTRandom(seed);
 
-            var initialEventSet = SelectRandomEvents(EventSet.List);
+            var initialEventSet = SelectRandomEvents(EventSet.List, rand);
             if (initialEventSet != null)
             {
                 pendingEventSets.Add(initialEventSet);
@@ -168,7 +168,7 @@ namespace Barotrauma
                     if (eventSet == null) { return; }
                     if (eventSet.OncePerOutpost)
                     {
-                        foreach (EventPrefab ep in eventSet.EventPrefabs.Select(e => e.First))
+                        foreach (EventPrefab ep in eventSet.EventPrefabs.Select(e => e.prefab))
                         {
                             if (!level.LevelData.NonRepeatableEvents.Contains(ep)) 
                             {
@@ -374,11 +374,11 @@ namespace Barotrauma
             preloadedSprites.Clear();
         }
 
-        private float CalculateCommonness(Pair<EventPrefab, float> eventPrefab)
+        private float CalculateCommonness(EventPrefab eventPrefab, float baseCommonness)
         {
-            if (level.LevelData.NonRepeatableEvents.Contains(eventPrefab.First)) { return 0.0f; }
-            float retVal = eventPrefab.Second;
-            if (level.LevelData.EventHistory.Contains(eventPrefab.First)) { retVal *= 0.1f; }
+            if (level.LevelData.NonRepeatableEvents.Contains(eventPrefab)) { return 0.0f; }
+            float retVal = baseCommonness;
+            if (level.LevelData.EventHistory.Contains(eventPrefab)) { retVal *= 0.1f; }
             return retVal;
         }
 
@@ -386,21 +386,25 @@ namespace Barotrauma
         {
             if (level == null) { return; }
             if (level.LevelData.HasHuntingGrounds && eventSet.DisableInHuntingGrounds) { return; }
-
+#if DEBUG
+            DebugConsole.NewMessage($"Loading event set {eventSet.DebugIdentifier}", Color.LightBlue);
+#else
+            DebugConsole.Log($"Loading event set {eventSet.DebugIdentifier}");
+#endif
             int applyCount = 1;
             List<Func<Level.InterestingPosition, bool>> spawnPosFilter = new List<Func<Level.InterestingPosition, bool>>();
             if (eventSet.PerRuin)
             {
-                applyCount = Level.Loaded.Ruins.Count();
-                foreach (var ruin in Level.Loaded.Ruins)
+                applyCount = level.Ruins.Count();
+                foreach (var ruin in level.Ruins)
                 {
                     spawnPosFilter.Add((Level.InterestingPosition pos) => { return pos.Ruin == ruin; });
                 }
             }
             else if (eventSet.PerCave)
             {
-                applyCount = Level.Loaded.Caves.Count();
-                foreach (var cave in Level.Loaded.Caves)
+                applyCount = level.Caves.Count();
+                foreach (var cave in level.Caves)
                 {
                     spawnPosFilter.Add((Level.InterestingPosition pos) => { return pos.Cave == cave; });
                 }
@@ -416,49 +420,62 @@ namespace Barotrauma
             }
 
             var suitablePrefabs = eventSet.EventPrefabs.FindAll(e =>
-                string.IsNullOrEmpty(e.First.BiomeIdentifier) ||
-                e.First.BiomeIdentifier.Equals(Level.Loaded.LevelData?.Biome?.Identifier, StringComparison.OrdinalIgnoreCase));
+                string.IsNullOrEmpty(e.prefab.BiomeIdentifier) ||
+                e.prefab.BiomeIdentifier.Equals(level.LevelData?.Biome?.Identifier, StringComparison.OrdinalIgnoreCase));
+
             for (int i = 0; i < applyCount; i++)
             {
                 if (eventSet.ChooseRandom)
                 {
                     if (suitablePrefabs.Count > 0)
                     {
-                        List<Pair<EventPrefab, float>> unusedEvents = new List<Pair<EventPrefab, float>>(suitablePrefabs);
+                        var unusedEvents = new List<(EventPrefab prefab, float commonness, float probability)>(suitablePrefabs);
                         for (int j = 0; j < eventSet.EventCount; j++)
                         {
-                            if (unusedEvents.All(e => CalculateCommonness(e) <= 0.0f)) { break; }
-                            var eventPrefab = ToolBox.SelectWeightedRandom(unusedEvents, unusedEvents.Select(e => CalculateCommonness(e)).ToList(), rand);
-                            if (eventPrefab != null)
+                            if (unusedEvents.All(e => CalculateCommonness(e.prefab, e.commonness) <= 0.0f)) { break; }
+                            (EventPrefab eventPrefab, float commonness, float probability) = ToolBox.SelectWeightedRandom(unusedEvents, unusedEvents.Select(e => CalculateCommonness(e.prefab, e.commonness)).ToList(), rand);
+                            if (eventPrefab != null && rand.NextDouble() <= probability)
                             {
-                                var newEvent = eventPrefab.First.CreateInstance();
+                                var newEvent = eventPrefab.CreateInstance();
                                 if (newEvent == null) { continue; }
                                 newEvent.Init(true);
                                 if (i < spawnPosFilter.Count) { newEvent.SpawnPosFilter = spawnPosFilter[i]; }
-                                DebugConsole.Log("Initialized event " + newEvent.ToString());
+#if DEBUG
+                                DebugConsole.NewMessage($"Initialized event {newEvent}");
+#else
+                                DebugConsole.Log($"Initialized event {newEvent}");
+#endif
                                 if (!selectedEvents.ContainsKey(eventSet))
                                 {
                                     selectedEvents.Add(eventSet, new List<Event>());
                                 }
                                 selectedEvents[eventSet].Add(newEvent);
-                                unusedEvents.Remove(eventPrefab);
+                                unusedEvents.Remove((eventPrefab, commonness, probability));
                             }
                         }
                     }
                     if (eventSet.ChildSets.Count > 0)
                     {
-                        var newEventSet = SelectRandomEvents(eventSet.ChildSets);
-                        if (newEventSet != null) { CreateEvents(newEventSet, rand); }
+                        var newEventSet = SelectRandomEvents(eventSet.ChildSets, rand);
+                        if (newEventSet != null)
+                        {
+                            CreateEvents(newEventSet, rand);
+                        }
                     }
                 }
                 else
                 {
-                    foreach (Pair<EventPrefab, float> eventPrefab in suitablePrefabs)
+                    foreach ((EventPrefab eventPrefab, float commonness, float probability) in suitablePrefabs)
                     {
-                        var newEvent = eventPrefab.First.CreateInstance();
+                        if (rand.NextDouble() > probability) { continue; }
+                        var newEvent = eventPrefab.CreateInstance();
                         if (newEvent == null) { continue; }
                         newEvent.Init(true);
-                        DebugConsole.Log("Initialized event " + newEvent.ToString());
+#if DEBUG
+                        DebugConsole.NewMessage($"Initialized event {newEvent}");
+#else
+                        DebugConsole.Log($"Initialized event {newEvent}");
+#endif
                         if (!selectedEvents.ContainsKey(eventSet))
                         {
                             selectedEvents.Add(eventSet, new List<Event>());
@@ -474,10 +491,10 @@ namespace Barotrauma
             }
         }
 
-        private EventSet SelectRandomEvents(List<EventSet> eventSets)
+        private EventSet SelectRandomEvents(List<EventSet> eventSets, Random random = null)
         {
             if (level == null) { return null; }
-            MTRandom rand = new MTRandom(ToolBox.StringToInt(level.Seed));
+            Random rand = random ?? new MTRandom(ToolBox.StringToInt(level.Seed));
 
             var allowedEventSets = 
                 eventSets.Where(es => 
@@ -496,7 +513,8 @@ namespace Barotrauma
             }
 
             float totalCommonness = allowedEventSets.Sum(e => e.GetCommonness(level));
-            float randomNumber = (float)rand.NextDouble() * totalCommonness;
+            float randomNumber = (float)rand.NextDouble();
+            randomNumber *= totalCommonness;
             foreach (EventSet eventSet in allowedEventSets)
             {
                 float commonness = eventSet.GetCommonness(level);
@@ -694,47 +712,103 @@ namespace Barotrauma
             // enemy amount --------------------------------------------------------
 
             enemyDanger = 0.0f;
+            monsterTotalStrength = 0;
             foreach (Character character in Character.CharacterList)
             {
-                if (character.IsDead || character.IsIncapacitated || !character.Enabled || character.IsPet || character.Params.CompareGroup("human")) { continue; }
+                if (character.IsIncapacitated || !character.Enabled || character.IsPet || character.Params.CompareGroup("human")) { continue; }
 
                 if (!(character.AIController is EnemyAIController enemyAI)) { continue; }
 
+                if (!enemyAI.AIParams.StayInAbyss)
+                {
+                    // Ignore abyss monsters because they can stay active for quite great distances. They'll be taken into account when they target the sub.
+                    monsterTotalStrength += enemyAI.CombatStrength;
+                }
+
+                // Example combat strengths:
+                // Hammerheadspawn 1
+                // Moloch Pupa 1
+                // Terminal cell 20
+                // Leucocyte 40
+                // Husk 90
+                // Crawler 100
+                // Unarmored Mudraptor 140
+                // Spineling 150
+                // Tigerthresher 200
+                // Armored Mudraptor 210
+                // Watcher 400
+                // Golden Hammerhead 400
+                // Hammerhead 500
+                // Hammerhead Matriarch 550
+                // Bonethresher 600
+                // Moloch 1250
+                // Black Moloch 1500
+                // Endworm 10000
                 if (character.CurrentHull?.Submarine != null && 
                     (character.CurrentHull.Submarine == Submarine.MainSub || Submarine.MainSub.DockedTo.Contains(character.CurrentHull.Submarine)))
                 {
-                    //crawler inside the sub adds 0.1f to enemy danger, mantis 0.25f
-                    enemyDanger += enemyAI.CombatStrength / 100.0f;
+                    // Enemy onboard -> Crawler inside the sub adds 0.2 to enemy danger, Mudraptor 0.42
+                    enemyDanger += enemyAI.CombatStrength / 500.0f;
                 }
                 else if (enemyAI.SelectedAiTarget?.Entity?.Submarine != null)
                 {
-                    //enemy outside and targeting the sub or something in it
-                    //moloch adds 0.24 to enemy danger, a crawler 0.02
-                    enemyDanger += enemyAI.CombatStrength / 1000.0f;
+                    // Enemy outside targeting the sub or something in it
+                    // -> One Crawler adds 0.02, a Mudraptor 0.042, a Hammerhead 0.1, and a Moloch 0.25.
+                    enemyDanger += enemyAI.CombatStrength / 5000.0f;
                 }
             }
+            // Add a portion of the total strength of active monsters to the enemy danger so that we don't spawn too many monsters around the sub.
+            // On top of the existing value, so if 10 crawlers are targeting the sub simultaneously from outside, the final value would be: 0.02 x 10 + 0.2 = 0.4.
+            // And if they get inside, we add 0.1 per crawler on that.
+            // So, in practice the danger per enemy that is attacking the sub is half of what it would be when the enemy is not targeting the sub.
+            // 10 Crawlers -> +0.2 (0.4 in total if all target the sub from outside).
+            // 5 Mudraptors -> +0.21 (0.42 in total, before they get inside).
+            // 3 Hammerheads -> +0.3 (0.6 in total, if they all target the sub).
+            // 2 Molochs -> +0.5 (1.0 in total, if both target the sub).
+            enemyDanger += monsterTotalStrength / 5000f;
             enemyDanger = MathHelper.Clamp(enemyDanger, 0.0f, 1.0f);
 
+            // The definitions above aim for that we never spawn more monsters that the player (and the performance) can handle.
+            // Some examples that result in the max intensity even when the creatures would just idle around.
+            // The values are theoretical, because in practice many of the monsters are targeting the sub, which will double the danger of those monster and effectively halve the max monster count.
+            // In practice we don't use the max intensity. For example on level 50 we use max intensity 50, which would mean that we'd halve the numbers below.
+            // There's no hard cap for the monster count, but if the amount of monsters is higher than this, we don't spawn more monsters from the events:
+            // 50 Crawlers (We shouldn't actually ever spawn that many. 12 is the max per event, but theoretically 25 crawlers would result in max intensity).
+            // 25 Tigerthreshers (Max 9 per event. 12 targeting the sub at the same time results in max intensity).
+            // 10 Hammerheads (Max 3 per event. 5 targeting the sub at the same time results in max intensity).
+            // 4 Molochs (Max 2 per event and 2 targeting the sub at the same time results in max intensity).
+
             // hull status (gaps, flooding, fire) --------------------------------------------------------
 
             float holeCount = 0.0f;
             float waterAmount = 0.0f;
-            float totalHullVolume = 0.0f;
+            float dryHullVolume = 0.0f;
             foreach (Hull hull in Hull.hullList)
             {
-                if (hull.Submarine == null || hull.Submarine.Info.Type != SubmarineType.Player) { continue; }
-                if (hull.RoomName != null && hull.RoomName.Contains("ballast", StringComparison.OrdinalIgnoreCase)) { continue; }
+                if (hull.Submarine == null || hull.Submarine.Info.Type != SubmarineType.Player) { continue; } 
+                if (GameMain.GameSession?.GameMode is PvPMode)
+                {
+                    if (hull.Submarine.TeamID != CharacterTeamType.Team1 && hull.Submarine.TeamID != CharacterTeamType.Team2) { continue; }
+                }
+                else
+                {
+                    if (hull.Submarine.TeamID != CharacterTeamType.Team1) { continue; }
+                }
+                fireAmount += hull.FireSources.Sum(fs => fs.Size.X);
+                if (hull.IsWetRoom) { continue; }
                 foreach (Gap gap in hull.ConnectedGaps)
                 {
-                    if (!gap.IsRoomToRoom) holeCount += gap.Open;
+                    if (!gap.IsRoomToRoom)
+                    {
+                        holeCount += gap.Open;
+                    }
                 }
                 waterAmount += hull.WaterVolume;
-                totalHullVolume += hull.Volume;
-                fireAmount += hull.FireSources.Sum(fs => fs.Size.X);
+                dryHullVolume += hull.Volume;
             }
-            if (totalHullVolume > 0)
+            if (dryHullVolume > 0)
             {
-                floodingAmount = waterAmount / totalHullVolume;
+                floodingAmount = waterAmount / dryHullVolume;
             }
 
             //hull integrity at 0.0 if there are 10 or more wide-open holes
@@ -779,7 +853,7 @@ namespace Barotrauma
         {
             if (level == null) { return 0.0f; }
             var refEntity = GetRefEntity();
-            Vector2 target = ConvertUnits.ToSimUnits(Level.Loaded.EndPosition);
+            Vector2 target = ConvertUnits.ToSimUnits(level.EndPosition);
             var steeringPath = pathFinder.FindPath(ConvertUnits.ToSimUnits(refEntity.WorldPosition), target);
             if (steeringPath.Unreachable || float.IsPositiveInfinity(totalPathLength))
             {
@@ -897,15 +971,15 @@ namespace Barotrauma
 
             const int maxDist = 1000;
 
-            if (Level.Loaded != null)
+            if (level != null)
             {
-                foreach (var ruin in Level.Loaded.Ruins)
+                foreach (var ruin in level.Ruins)
                 {
                     Rectangle area = ruin.Area;
                     area.Inflate(maxDist, maxDist);
                     if (area.Contains(character.WorldPosition)) { return true; }
                 }
-                foreach (var cave in Level.Loaded.Caves)
+                foreach (var cave in level.Caves)
                 {
                     Rectangle area = cave.Area;
                     area.Inflate(maxDist, maxDist);

Barotrauma/BarotraumaShared/SharedSource/Events/EventPrefab.cs

@@ -8,7 +8,7 @@ namespace Barotrauma
     {
         public readonly XElement ConfigElement;    
         public readonly Type EventType;
-        public readonly float SpawnProbability;
+        public readonly float Probability;
         public readonly bool TriggerEventCooldown;
         public float Commonness;
         public string Identifier;
@@ -39,7 +39,7 @@ namespace Barotrauma
             Identifier = ConfigElement.GetAttributeString("identifier", string.Empty);
             BiomeIdentifier = ConfigElement.GetAttributeString("biome", string.Empty);
             Commonness = element.GetAttributeFloat("commonness", 1.0f);
-            SpawnProbability = Math.Clamp(element.GetAttributeFloat("spawnprobability", 1.0f), 0, 1);
+            Probability = Math.Clamp(element.GetAttributeFloat(1.0f, "probability", "spawnprobability"), 0, 1);
             TriggerEventCooldown = element.GetAttributeBool("triggereventcooldown", true);
 
             UnlockPathEvent = element.GetAttributeBool("unlockpathevent", false);

Barotrauma/BarotraumaShared/SharedSource/Events/EventSet.cs

@@ -48,10 +48,10 @@ namespace Barotrauma
             List<EventPrefab> eventPrefabs = new List<EventPrefab>(PrefabList);
             foreach (var eventSet in List)
             {
-                eventPrefabs.AddRange(eventSet.EventPrefabs.Select(ep => ep.First));
+                eventPrefabs.AddRange(eventSet.EventPrefabs.Select(ep => ep.prefab));
                 foreach (var childSet in eventSet.ChildSets)
                 {
-                    eventPrefabs.AddRange(childSet.EventPrefabs.Select(ep => ep.First));
+                    eventPrefabs.AddRange(childSet.EventPrefabs.Select(ep => ep.prefab));
                 }
             }
             return eventPrefabs;
@@ -96,8 +96,7 @@ namespace Barotrauma
 
         public readonly Dictionary<string, float> Commonness;
 
-        //Pair.First: event prefab, Pair.Second: commonness
-        public readonly List<Pair<EventPrefab, float>> EventPrefabs;
+        public readonly List<(EventPrefab prefab, float commonness, float probability)> EventPrefabs;
 
         public readonly List<EventSet> ChildSets;
 
@@ -111,7 +110,7 @@ namespace Barotrauma
         {
             DebugIdentifier = element.GetAttributeString("identifier", null) ?? debugIdentifier;
             Commonness = new Dictionary<string, float>();
-            EventPrefabs = new List<Pair<EventPrefab, float>>();
+            EventPrefabs =  new List<(EventPrefab prefab, float commonness, float probability)>();
             ChildSets = new List<EventSet>();
 
             BiomeIdentifier = element.GetAttributeString("biome", string.Empty);
@@ -149,7 +148,7 @@ namespace Barotrauma
             OncePerOutpost = element.GetAttributeBool("onceperoutpost", false);
             TriggerEventCooldown = element.GetAttributeBool("triggereventcooldown", true);
 
-            Commonness[""] = 1.0f;
+            Commonness[""] = element.GetAttributeFloat("commonness", 1.0f);
             foreach (XElement subElement in element.Elements())
             {
                 switch (subElement.Name.ToString().ToLowerInvariant())
@@ -184,13 +183,14 @@ namespace Barotrauma
                             else
                             {
                                 float commonness = subElement.GetAttributeFloat("commonness", prefab.Commonness);
-                                EventPrefabs.Add(new Pair<EventPrefab, float>( prefab, commonness));
+                                float probability = subElement.GetAttributeFloat("probability", prefab.Probability);
+                                EventPrefabs.Add((prefab, commonness, probability));
                             }
                         }
                         else
                         {
                             var prefab = new EventPrefab(subElement);
-                            EventPrefabs.Add(new Pair<EventPrefab, float>(prefab, prefab.Commonness));
+                            EventPrefabs.Add((prefab, prefab.Commonness, prefab.Probability));
                         }
                         break;
                 }
@@ -342,13 +342,13 @@ namespace Barotrauma
             {
                 if (thisSet.ChooseRandom)
                 {
-                    List<Pair<EventPrefab, float>> unusedEvents = new List<Pair<EventPrefab, float>>(thisSet.EventPrefabs);
+                    var unusedEvents = new List<(EventPrefab prefab, float commonness, float probability)>(thisSet.EventPrefabs);
                     for (int i = 0; i < thisSet.EventCount; i++)
                     {
-                        var eventPrefab = ToolBox.SelectWeightedRandom(unusedEvents, unusedEvents.Select(e => e.Second).ToList(), Rand.RandSync.Unsynced);
-                        if (eventPrefab != null)
+                        var eventPrefab = ToolBox.SelectWeightedRandom(unusedEvents, unusedEvents.Select(e => e.commonness).ToList(), Rand.RandSync.Unsynced);
+                        if (eventPrefab.prefab != null)
                         {
-                            AddEvent(stats, eventPrefab.First);
+                            AddEvent(stats, eventPrefab.prefab);
                             unusedEvents.Remove(eventPrefab);
                         }
                     }
@@ -357,7 +357,7 @@ namespace Barotrauma
                 {
                     foreach (var eventPrefab in thisSet.EventPrefabs)
                     {
-                        AddEvent(stats, eventPrefab.First);
+                        AddEvent(stats, eventPrefab.prefab);
                     }
                 }
                 foreach (var childSet in thisSet.ChildSets)

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

@@ -1,4 +1,5 @@
 using Barotrauma.Extensions;
+using Microsoft.Xna.Framework;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -15,6 +16,10 @@ namespace Barotrauma
         protected readonly HashSet<Character> requireKill = new HashSet<Character>();
         protected readonly HashSet<Character> requireRescue = new HashSet<Character>();
 
+        private readonly string itemTag;
+        private readonly XElement itemConfig;
+        private readonly List<Item> items = new List<Item>();
+
         protected const int HostagesKilledState = 5;
 
         private readonly string hostagesKilledMessage;
@@ -33,15 +38,55 @@ namespace Barotrauma
             }
         }
 
+        public override IEnumerable<Vector2> SonarPositions
+        {
+            get
+            {
+                if (State > 0)
+                {
+                    return Enumerable.Empty<Vector2>();
+                }
+                else
+                {
+                    return Targets.Select(t => t.WorldPosition);
+                }
+            }
+        }
+
+        private IEnumerable<Entity> Targets
+        {
+            get
+            {
+                if (State > 0)
+                {
+                    return Enumerable.Empty<Entity>();
+                }
+                else
+                {
+                    if (items.Any())
+                    {
+                        return items.Where(it => !it.Removed && it.Condition > 0.0f).Cast<Entity>().Concat(requireKill.Where(c => !c.Removed && !c.IsDead)).Concat(requireRescue);
+                    }
+                    else
+                    {
+                        return requireKill.Concat(requireRescue);
+                    }
+                }
+            }
+        }
+
         protected bool wasDocked;
 
-        public AbandonedOutpostMission(MissionPrefab prefab, Location[] locations) : 
-            base(prefab, locations)
+        public AbandonedOutpostMission(MissionPrefab prefab, Location[] locations, Submarine sub) : 
+            base(prefab, locations, sub)
         {
             characterConfig = prefab.ConfigElement.Element("Characters");
 
             string msgTag = prefab.ConfigElement.GetAttributeString("hostageskilledmessage", "");
             hostagesKilledMessage = TextManager.Get(msgTag, returnNull: true) ?? msgTag;
+
+            itemConfig = prefab.ConfigElement.Element("Items");
+            itemTag = prefab.ConfigElement.GetAttributeString("targetitem", "");
         }
 
         protected override void StartMissionSpecific(Level level)
@@ -52,8 +97,13 @@ namespace Barotrauma
             characterItems.Clear();
             requireKill.Clear();
             requireRescue.Clear();
+            items.Clear();
+#if SERVER
+            spawnedItems.Clear();
+#endif
 
             var submarine = Submarine.Loaded.Find(s => s.Info.Type == SubmarineType.Outpost) ?? Submarine.MainSub;
+            InitItems(submarine);
             if (!IsClient)
             {
                 InitCharacters(submarine);
@@ -62,56 +112,101 @@ namespace Barotrauma
             wasDocked = Submarine.MainSub.DockedTo.Contains(Level.Loaded.StartOutpost);
         }
 
+        private void InitItems(Submarine submarine)
+        {
+            if (!string.IsNullOrEmpty(itemTag))
+            {
+                var itemsToDestroy = Item.ItemList.FindAll(it => it.Submarine?.Info.Type != SubmarineType.Player && it.HasTag(itemTag));
+                if (!itemsToDestroy.Any())
+                {
+                    DebugConsole.ThrowError($"Error in mission \"{Prefab.Identifier}\". Could not find an item with the tag \"{itemTag}\".");
+                }
+                else
+                {
+                    items.AddRange(itemsToDestroy);
+                }
+            }
+
+            if (itemConfig != null && !IsClient)
+            {
+                foreach (XElement element in itemConfig.Elements())
+                {
+                    string itemIdentifier = element.GetAttributeString("identifier", "");
+                    if (!(MapEntityPrefab.Find(null, itemIdentifier) is ItemPrefab itemPrefab))
+                    {
+                        DebugConsole.ThrowError("Couldn't spawn item for outpost destroy mission: item prefab \"" + itemIdentifier + "\" not found");
+                        continue;
+                    }
+
+                    string[] moduleFlags = element.GetAttributeStringArray("moduleflags", null);
+                    string[] spawnPointTags = element.GetAttributeStringArray("spawnpointtags", null);
+                    ISpatialEntity spawnPoint = SpawnAction.GetSpawnPos(
+                         SpawnAction.SpawnLocationType.Outpost, SpawnType.Human | SpawnType.Enemy,
+                         moduleFlags, spawnPointTags, element.GetAttributeBool("asfaraspossible", false));
+                    if (spawnPoint == null)
+                    {
+                        spawnPoint = submarine.GetHulls(alsoFromConnectedSubs: false).GetRandom();
+                    }
+                    Vector2 spawnPos = spawnPoint.WorldPosition;
+                    if (spawnPoint is WayPoint wp && wp.CurrentHull != null && wp.CurrentHull.Rect.Width > 100)
+                    {
+                        spawnPos = new Vector2(
+                            MathHelper.Clamp(wp.WorldPosition.X + Rand.Range(-200, 200), wp.CurrentHull.WorldRect.X + 50, wp.CurrentHull.WorldRect.Right - 50),
+                            wp.CurrentHull.WorldRect.Y - wp.CurrentHull.Rect.Height + 16.0f);
+                    }
+                    var item = new Item(itemPrefab, spawnPos, null);
+                    items.Add(item);
+#if SERVER
+                    spawnedItems.Add(item);
+#endif
+                }
+            }
+        }
+
         private void InitCharacters(Submarine submarine)
         {
             characters.Clear();
             characterItems.Clear();
 
-            if (characterConfig == null) { return; }
-
-            foreach (XElement element in characterConfig.Elements())
-            {
-                if (GameMain.NetworkMember == null && element.GetAttributeBool("multiplayeronly", false)) { continue; }
-
-                int defaultCount = element.GetAttributeInt("count", -1);
-                if (defaultCount < 0)
+            if (characterConfig != null) 
+            { 
+                foreach (XElement element in characterConfig.Elements())
                 {
-                    defaultCount = element.GetAttributeInt("amount", 1);
-                }
-                int min = Math.Min(element.GetAttributeInt("min", defaultCount), 255);
-                int max = Math.Min(Math.Max(min, element.GetAttributeInt("max", defaultCount)), 255);
-                int count = Rand.Range(min, max + 1);
+                    if (GameMain.NetworkMember == null && element.GetAttributeBool("multiplayeronly", false)) { continue; }
 
-                if (element.Attribute("identifier") != null && element.Attribute("from") != null)
-                {
-                    string characterIdentifier = element.GetAttributeString("identifier", "");
-                    string characterFrom = element.GetAttributeString("from", "");
-                    HumanPrefab humanPrefab = NPCSet.Get(characterFrom, characterIdentifier);
-                    if (humanPrefab == null)
+                    int defaultCount = element.GetAttributeInt("count", -1);
+                    if (defaultCount < 0)
                     {
-                        DebugConsole.ThrowError("Couldn't spawn a character for abandoned outpost mission: character prefab \"" + characterIdentifier + "\" not found");
-                        continue;
+                        defaultCount = element.GetAttributeInt("amount", 1);
                     }
-                    for (int i = 0; i < count; i++)
+                    int min = Math.Min(element.GetAttributeInt("min", defaultCount), 255);
+                    int max = Math.Min(Math.Max(min, element.GetAttributeInt("max", defaultCount)), 255);
+                    int count = Rand.Range(min, max + 1);
+
+                    if (element.Attribute("identifier") != null && element.Attribute("from") != null)
                     {
-                        LoadHuman(humanPrefab, element, submarine);
+                        HumanPrefab humanPrefab = GetHumanPrefabFromElement(element);
+                        for (int i = 0; i < count; i++)
+                        {
+                            LoadHuman(humanPrefab, element, submarine);
+                        }
+                    }
+                    else
+                    {
+                        string speciesName = element.GetAttributeString("character", element.GetAttributeString("identifier", ""));
+                        var characterPrefab = CharacterPrefab.FindBySpeciesName(speciesName);
+                        if (characterPrefab == null)
+                        {
+                            DebugConsole.ThrowError("Couldn't spawn a character for abandoned outpost mission: character prefab \"" + speciesName + "\" not found");
+                            continue;
+                        }
+                        for (int i = 0; i < count; i++)
+                        {
+                            LoadMonster(characterPrefab, element, submarine);
+                        }
                     }
                 }
-                else
-                {
-                    string speciesName = element.GetAttributeString("character", element.GetAttributeString("identifier", ""));
-                    var characterPrefab = CharacterPrefab.FindBySpeciesName(speciesName);
-                    if (characterPrefab == null)
-                    {
-                        DebugConsole.ThrowError("Couldn't spawn a character for abandoned outpost mission: character prefab \"" + speciesName + "\" not found");
-                        continue;
-                    }
-                    for (int i = 0; i < count; i++)
-                    {
-                        LoadMonster(characterPrefab, element, submarine);
-                    }
-                }
-            }
+            }            
         }
 
         private void LoadHuman(HumanPrefab humanPrefab, XElement element, Submarine submarine)
@@ -128,32 +223,27 @@ namespace Barotrauma
                 spawnPos = submarine.GetHulls(alsoFromConnectedSubs: false).GetRandom();
             }
 
-            var characterInfo = new CharacterInfo(CharacterPrefab.HumanSpeciesName, jobPrefab: humanPrefab.GetJobPrefab(Rand.RandSync.Server), randSync: Rand.RandSync.Server);
-            Character spawnedCharacter = Character.Create(characterInfo.SpeciesName, spawnPos.WorldPosition, ToolBox.RandomSeed(8), characterInfo, createNetworkEvent: false);
-            if (element.GetAttributeBool("requirerescue", false))
-            {
-                requireRescue.Add(spawnedCharacter);
-                spawnedCharacter.TeamID = CharacterTeamType.FriendlyNPC;
-#if CLIENT
-                GameMain.GameSession.CrewManager.AddCharacterToCrewList(spawnedCharacter);
-#endif
-            }
-            else
-            {
-                spawnedCharacter.TeamID = CharacterTeamType.None;
-            }
-            humanPrefab.InitializeCharacter(spawnedCharacter, spawnPos);
-            humanPrefab.GiveItems(spawnedCharacter, Submarine.MainSub, Rand.RandSync.Server, createNetworkEvents: false);
+            bool requiresRescue = element.GetAttributeBool("requirerescue", false);
+
+            Character spawnedCharacter = CreateHuman(humanPrefab, characters, characterItems, submarine, requiresRescue ? CharacterTeamType.FriendlyNPC : CharacterTeamType.None, spawnPos, giveTags: true);
+
             if (spawnPos is WayPoint wp)
             {
                 spawnedCharacter.GiveIdCardTags(wp);
             }
+
+            if (requiresRescue)
+            {
+                requireRescue.Add(spawnedCharacter);
+#if CLIENT
+                GameMain.GameSession.CrewManager.AddCharacterToCrewList(spawnedCharacter);
+#endif
+            }
+
             if (element.GetAttributeBool("requirekill", false))
             {
                 requireKill.Add(spawnedCharacter);
             }
-            characters.Add(spawnedCharacter);
-            characterItems.Add(spawnedCharacter, spawnedCharacter.Inventory.FindAllItems(recursive: true));
         }
 
         private void LoadMonster(CharacterPrefab monsterPrefab, XElement element, Submarine submarine)
@@ -187,7 +277,7 @@ namespace Barotrauma
         }
 
 
-        public override void Update(float deltaTime)
+        protected override void UpdateMissionSpecific(float deltaTime)
         {
             if (State != HostagesKilledState)
             {
@@ -215,7 +305,8 @@ namespace Barotrauma
             {
                 case 0:
 
-                    if (requireKill.All(c => c.Removed || c.IsDead) &&
+                    if (items.All(it => it.Removed || it.Condition <= 0.0f) &&
+                        requireKill.All(c => c.Removed || c.IsDead) &&
                         requireRescue.All(c => c.Submarine?.Info.Type == SubmarineType.Player))
                     {
                         State = 1;

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

@@ -13,7 +13,7 @@ namespace Barotrauma
         private Point monsterCountRange;
         private readonly string sonarLabel;
 
-        public BeaconMission(MissionPrefab prefab, Location[] locations) : base(prefab, locations)
+        public BeaconMission(MissionPrefab prefab, Location[] locations, Submarine sub) : base(prefab, locations, sub)
         {
             swarmSpawned = false;
 
@@ -53,7 +53,7 @@ namespace Barotrauma
             }
         }
 
-        public override void Update(float deltaTime)
+        protected override void UpdateMissionSpecific(float deltaTime)
         {
             if (IsClient) { return; }
             if (!swarmSpawned && level.CheckBeaconActive())

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

@@ -15,17 +15,112 @@ namespace Barotrauma
         private readonly Dictionary<Item, UInt16> parentInventoryIDs = new Dictionary<Item, UInt16>();
         private readonly Dictionary<Item, byte> parentItemContainerIndices = new Dictionary<Item, byte>();
 
-        private int requiredDeliveryAmount;
+        private float requiredDeliveryAmount;
 
-        public CargoMission(MissionPrefab prefab, Location[] locations)
-            : base(prefab, locations)
+        private readonly List<(XElement element, ItemContainer container)> itemsToSpawn = new List<(XElement element, ItemContainer container)>();
+        private int? rewardPerCrate;
+        private int calculatedReward;
+        private int maxItemCount;
+
+        private Submarine sub;
+
+        public override string Description
         {
+            get
+            {
+                if (Submarine.MainSub != sub)
+                {
+                    string rewardText = $"‖color:gui.orange‖{string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0:N0}", GetReward(Submarine.MainSub))}‖end‖";
+                    if (descriptionWithoutReward != null) { description = descriptionWithoutReward.Replace("[reward]", rewardText); }
+                }
+                return description;
+            }
+        }
+
+        public CargoMission(MissionPrefab prefab, Location[] locations, Submarine sub)
+            : base(prefab, locations, sub)
+        {
+            this.sub = sub;
             itemConfig = prefab.ConfigElement.Element("Items");
-            requiredDeliveryAmount = prefab.ConfigElement.GetAttributeInt("requireddeliveryamount", 0);
+            requiredDeliveryAmount = Math.Min(prefab.ConfigElement.GetAttributeFloat("requireddeliveryamount", 0.98f), 1.0f);            
+            DetermineCargo();
+        }
+
+        private void DetermineCargo()
+        {
+            if (this.sub == null || itemConfig == null)
+            {
+                calculatedReward = Prefab.Reward;
+                return;
+            }
+
+            itemsToSpawn.Clear();
+            List<(ItemContainer container, int freeSlots)> containers = sub.GetCargoContainers();
+            containers.Sort((c1, c2) => { return c2.container.Capacity.CompareTo(c1.container.Capacity); });
+
+            maxItemCount = 0;
+            foreach (XElement subElement in itemConfig.Elements())
+            {
+                int maxCount = subElement.GetAttributeInt("maxcount", 10);
+                maxItemCount += maxCount;
+            }
+
+            for (int i = 0; i < containers.Count; i++)
+            {
+                foreach (XElement subElement in itemConfig.Elements())
+                {
+                    int maxCount = subElement.GetAttributeInt("maxcount", 10);
+                    if (itemsToSpawn.Count(it => it.element == subElement) >= maxCount) { continue; }
+                    ItemPrefab itemPrefab = FindItemPrefab(subElement);
+                    while (containers[i].freeSlots > 0 && containers[i].container.Inventory.CanBePut(itemPrefab))
+                    {
+                        containers[i] = (containers[i].container, containers[i].freeSlots - 1);
+                        itemsToSpawn.Add((subElement, containers[i].container));
+                        if (itemsToSpawn.Count(it => it.element == subElement) >= maxCount) { break; }
+                    }
+                }
+            }
+
+            if (!itemsToSpawn.Any())
+            {
+                itemsToSpawn.Add((itemConfig.Elements().First(), null));
+            }
+
+            calculatedReward = 0;
+            foreach (var itemToSpawn in itemsToSpawn)
+            {
+                int price = itemToSpawn.element.GetAttributeInt("reward", Prefab.Reward / itemsToSpawn.Count);
+                if (rewardPerCrate.HasValue)
+                {
+                    if (price != rewardPerCrate.Value) { rewardPerCrate = -1; }
+                }
+                else
+                {
+                    rewardPerCrate = price;
+                }
+                calculatedReward += price;
+            }
+            if (rewardPerCrate.HasValue && rewardPerCrate < 0) { rewardPerCrate = null; }
+
+            string rewardText = $"‖color:gui.orange‖{string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0:N0}", GetReward(sub))}‖end‖";
+            if (descriptionWithoutReward != null) { description = descriptionWithoutReward.Replace("[reward]", rewardText); }
+        }
+
+        public override int GetReward(Submarine sub)
+        {
+            if (sub != this.sub)
+            {
+                this.sub = sub;
+                DetermineCargo();
+            }
+            return calculatedReward;
         }
 
         private void InitItems()
         {
+            this.sub = Submarine.MainSub;
+            DetermineCargo();
+
             items.Clear();
             parentInventoryIDs.Clear();
             parentItemContainerIndices.Clear();
@@ -36,20 +131,15 @@ namespace Barotrauma
                 return;
             }
 
-            foreach (XElement subElement in itemConfig.Elements())
+            foreach (var (element, container) in itemsToSpawn)
             {
-                LoadItemAsChild(subElement, null);
+                LoadItemAsChild(element, container?.Item);
             }
 
-            if (requiredDeliveryAmount == 0) { requiredDeliveryAmount = items.Count; }
-            if (requiredDeliveryAmount > items.Count)
-            {
-                DebugConsole.AddWarning($"Error in mission \"{Prefab.Identifier}\". Required delivery amount is {requiredDeliveryAmount} but there's only {items.Count} items to deliver.");
-                requiredDeliveryAmount = items.Count;
-            }
+            if (requiredDeliveryAmount <= 0.0f) { requiredDeliveryAmount = 1.0f; }
         }
 
-        private void LoadItemAsChild(XElement element, Item parent)
+        private ItemPrefab FindItemPrefab(XElement element)
         {
             ItemPrefab itemPrefab;
             if (element.Attribute("name") != null)
@@ -60,7 +150,6 @@ namespace Barotrauma
                 if (itemPrefab == null)
                 {
                     DebugConsole.ThrowError("Couldn't spawn item for cargo mission: item prefab \"" + itemName + "\" not found");
-                    return;
                 }
             }
             else
@@ -70,15 +159,15 @@ namespace Barotrauma
                 if (itemPrefab == null)
                 {
                     DebugConsole.ThrowError("Couldn't spawn item for cargo mission: item prefab \"" + itemIdentifier + "\" not found");
-                    return;
                 }
             }
+            return itemPrefab;
+        }
 
-            if (itemPrefab == null)
-            {
-                DebugConsole.ThrowError("Couldn't spawn item for cargo mission: item prefab \"" + element.Name.ToString() + "\" not found");
-                return;
-            }
+
+        private void LoadItemAsChild(XElement element, Item parent)
+        {
+            ItemPrefab itemPrefab = FindItemPrefab(element);
 
             WayPoint cargoSpawnPos = WayPoint.GetRandom(SpawnType.Cargo, null, Submarine.MainSub, useSyncedRand: true);
             if (cargoSpawnPos == null)
@@ -88,7 +177,6 @@ namespace Barotrauma
             }
 
             var cargoRoom = cargoSpawnPos.CurrentHull;
-
             if (cargoRoom == null)
             {
                 DebugConsole.ThrowError("A waypoint marked as Cargo must be placed inside a room!");
@@ -140,7 +228,7 @@ namespace Barotrauma
             if (Submarine.MainSub != null && Submarine.MainSub.AtEndExit)
             {
                 int deliveredItemCount = items.Count(i => i.CurrentHull != null && !i.Removed && i.Condition > 0.0f);
-                if (deliveredItemCount >= requiredDeliveryAmount)
+                if (deliveredItemCount / (float)items.Count >= requiredDeliveryAmount)
                 {
                     GiveReward();
                     completed = true;

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

@@ -1,5 +1,4 @@
-using Barotrauma.Extensions;
-using Barotrauma.Items.Components;
+using Barotrauma.Extensions;
 using System.Collections.Generic;
 
 namespace Barotrauma
@@ -7,6 +6,7 @@ namespace Barotrauma
     partial class CombatMission : Mission
     {
         private Submarine[] subs;
+        // TODO: not used
         private List<Character>[] crews;
 
         private readonly string[] descriptions;
@@ -45,8 +45,8 @@ namespace Barotrauma
             }
         }
 
-        public CombatMission(MissionPrefab prefab, Location[] locations)
-            : base(prefab, locations)
+        public CombatMission(MissionPrefab prefab, Location[] locations, Submarine sub)
+            : base(prefab, locations, sub)
         {
             descriptions = new string[]
             {

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

@@ -0,0 +1,344 @@
+using Barotrauma.Items.Components;
+using Barotrauma.Extensions;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    partial class EscortMission : Mission
+    {
+        private readonly XElement characterConfig;
+        private readonly XElement itemConfig;
+
+        private readonly List<Character> characters = new List<Character>();
+        private readonly Dictionary<Character, List<Item>> characterItems = new Dictionary<Character, List<Item>>();
+
+        private readonly int baseEscortedCharacters;
+        private readonly float scalingEscortedCharacters;
+        private readonly float terroristChance;
+
+        private int calculatedReward;
+        private Submarine missionSub;
+
+        private Character vipCharacter;
+
+        private readonly List<Character> terroristCharacters = new List<Character>();
+        private bool terroristsShouldAct = false;
+        private float terroristDistanceSquared;
+        private const string TerroristTeamChangeIdentifier = "terrorist"; 
+
+        public EscortMission(MissionPrefab prefab, Location[] locations, Submarine sub)
+            : base(prefab, locations, sub)
+        {
+            missionSub = sub;
+            characterConfig = prefab.ConfigElement.Element("Characters");
+            baseEscortedCharacters = prefab.ConfigElement.GetAttributeInt("baseescortedcharacters", 1);
+            scalingEscortedCharacters = prefab.ConfigElement.GetAttributeFloat("scalingescortedcharacters", 0);
+            terroristChance = prefab.ConfigElement.GetAttributeFloat("terroristchance", 0);
+            itemConfig = prefab.ConfigElement.Element("TerroristItems");
+            CalculateReward();
+        }
+
+        private void CalculateReward()
+        {
+            if (missionSub == null)
+            {
+                calculatedReward = Prefab.Reward;
+                return;
+            }
+
+            int multiplier = CalculateScalingEscortedCharacterCount();
+            calculatedReward = Prefab.Reward * multiplier;
+
+            string rewardText = $"‖color:gui.orange‖{string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0:N0}", GetReward(missionSub))}‖end‖";
+            if (descriptionWithoutReward != null) { description = descriptionWithoutReward.Replace("[reward]", rewardText); }
+        }
+
+        public override int GetReward(Submarine sub)
+        {
+            if (sub != missionSub)
+            {
+                missionSub = sub;
+                CalculateReward();
+            }
+            return calculatedReward;
+        }
+
+        int CalculateScalingEscortedCharacterCount(bool inMission = false)
+        {
+            if (missionSub == null || missionSub.Info == null) // UI logic failing to get the correct value is not important, but the mission logic must succeed
+            {
+                if (inMission)
+                {
+                    DebugConsole.ThrowError("MainSub was null when trying to retrieve submarine size for determining escorted character count!");
+                }
+                return 1;
+            }
+            return (int)Math.Round(baseEscortedCharacters + scalingEscortedCharacters * (missionSub.Info.RecommendedCrewSizeMin + missionSub.Info.RecommendedCrewSizeMax) / 2);
+        }
+
+        private void InitEscort()
+        {
+            characters.Clear();
+            characterItems.Clear();
+
+            WayPoint explicitStayInHullPos = WayPoint.GetRandom(SpawnType.Human, null, Submarine.MainSub);
+            Rand.RandSync randSync = Rand.RandSync.Server;
+
+            if (terroristChance > 0f)
+            {
+                // in terrorist missions, reroll characters each retry to avoid confusion as to who the terrorists are
+                randSync = Rand.RandSync.Unsynced; 
+            }
+
+            //if any of the escortees have a job defined, try to use a spawnpoint designated for that job
+            foreach (XElement element in characterConfig.Elements())
+            {
+                var humanPrefab = GetHumanPrefabFromElement(element);
+                if (humanPrefab == null || string.IsNullOrEmpty(humanPrefab.Job) || humanPrefab.Job.Equals("any", StringComparison.OrdinalIgnoreCase)) { continue; }
+
+                var jobPrefab = humanPrefab.GetJobPrefab();
+                if (jobPrefab != null)
+                {
+                    var jobSpecificSpawnPos = WayPoint.GetRandom(SpawnType.Human, jobPrefab, Submarine.MainSub);
+                    if (jobSpecificSpawnPos != null) 
+                    {
+                        explicitStayInHullPos = jobSpecificSpawnPos;
+                        break;
+                    }
+                }
+            }
+
+            foreach (XElement element in characterConfig.Elements())
+            {
+                int count = CalculateScalingEscortedCharacterCount(inMission: true);
+                for (int i = 0; i < count; i++)
+                {
+                    Character spawnedCharacter = CreateHuman(GetHumanPrefabFromElement(element), characters, characterItems, Submarine.MainSub, CharacterTeamType.FriendlyNPC, explicitStayInHullPos, humanPrefabRandSync: randSync);
+                    if (spawnedCharacter.AIController is HumanAIController humanAI)
+                    {
+                        humanAI.InitMentalStateManager();
+                    }
+                }
+            }
+
+            if (terroristChance > 0f)
+            {
+                int terroristCount = (int)Math.Ceiling(terroristChance * Rand.Range(0.8f, 1.2f) * characters.Count);
+                terroristCount = Math.Clamp(terroristCount, 1, characters.Count);
+
+                terroristCharacters.Clear();
+                characters.GetRange(0, terroristCount).ForEach(c => terroristCharacters.Add(c));
+
+                terroristDistanceSquared = Vector2.DistanceSquared(Level.Loaded.StartPosition, Level.Loaded.EndPosition) * Rand.Range(0.35f, 0.65f);
+
+#if DEBUG
+                DebugConsole.AddWarning("Terrorists will trigger at range  " + Math.Sqrt(terroristDistanceSquared));
+                foreach (Character character in terroristCharacters)
+                {
+                    DebugConsole.AddWarning(character.Name + " is a terrorist.");
+                }
+#endif
+            }
+        }
+
+        private void InitCharacters()
+        {
+            int scalingCharacterCount = CalculateScalingEscortedCharacterCount(inMission: true);
+
+            if (scalingCharacterCount * characterConfig.Elements().Count() != characters.Count)
+            {
+                DebugConsole.AddWarning("Character count did not match expected character count in InitCharacters of EscortMission");
+                return;
+            }
+            int i = 0;
+
+            foreach (XElement element in characterConfig.Elements())
+            {
+                string escortIdentifier = element.GetAttributeString("escortidentifier", string.Empty);
+                string colorIdentifier = element.GetAttributeString("color", string.Empty);
+                for (int k = 0; k < scalingCharacterCount; k++)
+                {
+                    // for each element defined, we need to initialize that type of character equal to the scaling escorted character count
+                    characters[k + i].IsEscorted = true;
+                    if (escortIdentifier != string.Empty)
+                    {
+                        if (escortIdentifier == "vip")
+                        {
+                            vipCharacter = characters[k + i];
+                        }
+                    }
+                    characters[k + i].UniqueNameColor = element.GetAttributeColor("color", Color.LightGreen);
+                }
+                i++;
+            }
+        }
+
+        protected override void StartMissionSpecific(Level level)
+        {
+            if (characters.Count > 0)
+            {
+#if DEBUG
+                throw new Exception($"characters.Count > 0 ({characters.Count})");
+#else
+                DebugConsole.AddWarning("Character list was not empty at the start of a escort mission. The mission instance may not have been ended correctly on previous rounds.");
+                characters.Clear();            
+#endif
+            }
+
+            if (characterConfig == null)
+            {
+                DebugConsole.ThrowError("Failed to initialize characters for escort mission (characterConfig == null)");
+                return;
+            }
+
+            // to ensure single missions run without issues, default to mainsub
+            if (missionSub == null)
+            {
+                missionSub = Submarine.MainSub;
+                CalculateReward();
+            }
+
+            if (!IsClient)
+            {
+                InitEscort();
+                InitCharacters();
+            }
+        }
+
+        void TryToTriggerTerrorists()
+        {
+            if (terroristsShouldAct)
+            {
+                // decoupled from range check to prevent from weirdness if players handcuff a terrorist and move backwards
+                foreach (Character character in terroristCharacters)
+                {
+                    if (character.HasTeamChange(TerroristTeamChangeIdentifier))
+                    {
+                        // already triggered
+                        continue;
+                    }
+
+                    if (IsAlive(character) && !character.IsIncapacitated && !character.LockHands)
+                    {
+                        character.TryAddNewTeamChange(TerroristTeamChangeIdentifier, new ActiveTeamChange(CharacterTeamType.None, ActiveTeamChange.TeamChangePriorities.Willful, aggressiveBehavior: true));
+                        character.Speak(TextManager.Get("dialogterroristannounce"), null, Rand.Range(0.5f, 3f));
+                        XElement randomElement = itemConfig.Elements().GetRandom(e => e.GetAttributeFloat(0f, "mindifficulty") <= Level.Loaded.Difficulty);
+                        if (randomElement != null)
+                        {
+                            HumanPrefab.InitializeItem(character, randomElement, character.Submarine, humanPrefab: null, createNetworkEvents: true);
+                        }
+                    }
+                }
+            }
+            else if (Vector2.DistanceSquared(Submarine.MainSub.WorldPosition, Level.Loaded.EndPosition) < terroristDistanceSquared)
+            {
+                foreach (Character character in terroristCharacters)
+                {
+                    if (character.AIController is HumanAIController humanAI)
+                    {
+                        humanAI.ObjectiveManager.AddObjective(new AIObjectiveEscapeHandcuffs(character, humanAI.ObjectiveManager, shouldSwitchTeams: false, beginInstantly: true));
+                    }
+                }
+                terroristsShouldAct = true;
+            }
+        }
+
+        bool NonTerroristsStillAlive(IEnumerable<Character> characterList)
+        {
+            return characterList.All(c => terroristCharacters.Contains(c) || IsAlive(c));
+        }
+
+        protected override void UpdateMissionSpecific(float deltaTime)
+        {
+            if (!IsClient)
+            {
+                int newState = State;
+                TryToTriggerTerrorists();
+                switch (State)
+                {
+                    case 0: // base
+                        if (!NonTerroristsStillAlive(characters))
+                        {
+                            newState = 1;
+                        }
+                        if (terroristCharacters.Any() && terroristCharacters.All(c => !IsAlive(c)))
+                        {
+                            newState = 2;
+                        }
+                        break;
+                    case 1: // failure
+                        break;
+                    case 2: // terrorists killed
+                        if (!NonTerroristsStillAlive(characters))
+                        {
+                            newState = 1;
+                        }
+                        break;
+                }
+                State = newState;
+            }
+        }
+
+        private bool Survived(Character character)
+        {
+            return IsAlive(character) && character.CurrentHull != null && character.CurrentHull.Submarine == Submarine.MainSub;
+        }
+
+        private bool IsAlive(Character character)
+        {
+            return character != null && !character.Removed && !character.IsDead;
+        }
+
+        private bool IsCaptured(Character character)
+        {
+            return character.LockHands && character.HasTeamChange(TerroristTeamChangeIdentifier);
+        }
+
+        public override void End()
+        {
+            if (Submarine.MainSub != null && Submarine.MainSub.AtEndExit)
+            {
+                bool terroristsSurvived = terroristCharacters.Any(c => Survived(c) && !IsCaptured(c));
+                bool friendliesSurvived = characters.Except(terroristCharacters).All(c => Survived(c));
+                bool vipDied = false;
+
+                // this logic is currently irrelevant, as the mission is failed regardless of who dies 
+                if (vipCharacter != null)
+                {
+                    vipDied = !Survived(vipCharacter);
+                }
+
+                if (friendliesSurvived && !terroristsSurvived && !vipDied)
+                {
+                    GiveReward();
+                    completed = true;
+                }
+            }
+
+            // characters that survived will take their items with them, in case players tried to be crafty and steal them
+            // this needs to run here in case players abort the mission by going back home
+            // TODO: I think this might feel like a bug.
+            foreach (var characterItem in characterItems)
+            {
+                if (Survived(characterItem.Key) || !completed)
+                {
+                    foreach (Item item in characterItem.Value)
+                    {
+                        if (!item.Removed)
+                        {
+                            item.Remove();
+                        }
+                    }
+                }
+            }
+
+            characters.Clear();
+            characterItems.Clear();
+            failed = !completed;
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+using Barotrauma.Networking;
+
+namespace Barotrauma
+{
+    partial class GoToMission : Mission
+    {
+        public GoToMission(MissionPrefab prefab, Location[] locations, Submarine sub)
+            : base(prefab, locations, sub)
+        {
+        }
+
+        protected override void UpdateMissionSpecific(float deltaTime)
+        {
+            State = 1;
+        }
+
+#if CLIENT
+        public override void ClientReadInitial(IReadMessage msg)
+        {
+        }
+#elif SERVER
+
+        public override void ServerWriteInitial(IWriteMessage msg, Client c)
+        {
+        }
+#endif
+    }
+}

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

@@ -26,7 +26,7 @@ namespace Barotrauma
             }
         }
 
-        public MineralMission(MissionPrefab prefab, Location[] locations) : base(prefab, locations)
+        public MineralMission(MissionPrefab prefab, Location[] locations, Submarine sub) : base(prefab, locations, sub)
         {
             var configElement = prefab.ConfigElement.Element("Items");
             foreach (var c in configElement.GetChildElements("Item"))
@@ -115,7 +115,7 @@ namespace Barotrauma
             FindRelevantLevelResources();
         }
 
-        public override void Update(float deltaTime)
+        protected override void UpdateMissionSpecific(float deltaTime)
         {
             if (IsClient) { return; }
             switch (State)

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

@@ -3,6 +3,7 @@ using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using System.Xml.Linq;
 
 namespace Barotrauma
 {
@@ -22,6 +23,7 @@ namespace Barotrauma
                 if (state != value)
                 {
                     state = value;
+                    TryTriggerEvents(state);
 #if SERVER
                     GameMain.Server?.UpdateMissionState(this, state);
 #endif
@@ -61,14 +63,19 @@ namespace Barotrauma
             //private set { description = value; }
         }
 
+        protected string descriptionWithoutReward;
+
         public virtual bool AllowUndocking
         {
             get { return true; }
         }
 
-        public int Reward
+        public virtual int Reward
         {
-            get { return Prefab.Reward; }
+            get 
+            {
+                return Prefab.Reward;
+            }
         }
 
         public Dictionary<string, float> ReputationRewards
@@ -92,6 +99,16 @@ namespace Barotrauma
             get { return true; }
         }
 
+        public virtual int TeamCount
+        {
+            get { return 1; }
+        }
+
+        public virtual SubmarineInfo EnemySubmarineInfo
+        {
+            get { return null; }
+        }
+
         public virtual IEnumerable<Vector2> SonarPositions
         {
             get { return Enumerable.Empty<Vector2>(); }
@@ -112,8 +129,22 @@ namespace Barotrauma
         {
             get { return Prefab.Difficulty; }
         }
+
+        private class DelayedTriggerEvent
+        {
+            public readonly MissionPrefab.TriggerEvent TriggerEvent;
+            public float Delay;
+
+            public DelayedTriggerEvent(MissionPrefab.TriggerEvent triggerEvent, float delay)
+            {
+                TriggerEvent = triggerEvent;
+                Delay = delay;
+            }
+        }
+
+        private List<DelayedTriggerEvent> delayedTriggerEvents = new List<DelayedTriggerEvent>();
            
-        public Mission(MissionPrefab prefab, Location[] locations)
+        public Mission(MissionPrefab prefab, Location[] locations, Submarine sub)
         {
             System.Diagnostics.Debug.Assert(locations.Length == 2);
 
@@ -138,8 +169,12 @@ namespace Barotrauma
                     Messages[m] = Messages[m].Replace("[location" + (n + 1) + "]", locationName);
                 }
             }
-            string rewardText = $"‖color:gui.orange‖{string.Format(CultureInfo.InvariantCulture, "{0:N0}", Reward)}‖end‖";
-            if (description != null) { description = description.Replace("[reward]", rewardText); }
+            string rewardText = $"‖color:gui.orange‖{string.Format(CultureInfo.InvariantCulture, "{0:N0}", GetReward(sub))}‖end‖";
+            if (description != null) 
+            {
+                descriptionWithoutReward = description;
+                description = description.Replace("[reward]", rewardText); 
+            }
             if (successMessage != null) { successMessage = successMessage.Replace("[reward]", rewardText); }
             if (failureMessage != null) { failureMessage = failureMessage.Replace("[reward]", rewardText); }
             for (int m = 0; m < Messages.Count; m++)
@@ -147,6 +182,9 @@ namespace Barotrauma
                 Messages[m] = Messages[m].Replace("[reward]", rewardText);
             }
         }
+
+        public virtual void SetDifficulty(float difficulty) { }
+
         public static Mission LoadRandom(Location[] locations, string seed, bool requireCorrectLocationType, MissionType missionType, bool isSinglePlayer = false)
         {
             return LoadRandom(locations, new MTRandom(ToolBox.StringToInt(seed)), requireCorrectLocationType, missionType, isSinglePlayer);
@@ -181,7 +219,7 @@ namespace Barotrauma
             {
                 if (randomNumber <= missionPrefab.Commonness)
                 {
-                    return missionPrefab.Instantiate(locations);
+                    return missionPrefab.Instantiate(locations, Submarine.MainSub);
                 }
                 randomNumber -= missionPrefab.Commonness;
             }
@@ -189,11 +227,18 @@ namespace Barotrauma
             return null;
         }
 
+        public virtual int GetReward(Submarine sub)
+        {
+            return Prefab.Reward;
+        }
+
         public void Start(Level level)
         {
+            state = 0;
 #if CLIENT
             shownMessages.Clear();
 #endif
+            delayedTriggerEvents.Clear();
             foreach (string categoryToShow in Prefab.UnhideEntitySubCategories)
             {
                 foreach (MapEntity entityToShow in MapEntity.mapEntityList.Where(me => me.prefab?.HasSubCategory(categoryToShow) ?? false))
@@ -202,12 +247,27 @@ namespace Barotrauma
                 }
             }
             this.level = level;
+            TryTriggerEvents(0);
             StartMissionSpecific(level);
         }
 
         protected virtual void StartMissionSpecific(Level level) { }
 
-        public virtual void Update(float deltaTime) { }
+        public void Update(float deltaTime)
+        {
+            for (int i = delayedTriggerEvents.Count - 1; i>=0;i--)
+            {
+                delayedTriggerEvents[i].Delay -= deltaTime;
+                if (delayedTriggerEvents[i].Delay <= 0.0f)
+                {
+                    TriggerEvent(delayedTriggerEvents[i].TriggerEvent);
+                    delayedTriggerEvents.RemoveAt(i);
+                }
+            }
+            UpdateMissionSpecific(deltaTime);
+        }
+
+        protected virtual void UpdateMissionSpecific(float deltaTime) { }
 
         protected void ShowMessage(int missionState)
         {
@@ -216,6 +276,57 @@ namespace Barotrauma
 
         partial void ShowMessageProjSpecific(int missionState);
 
+
+        private void TryTriggerEvents(int state)
+        {
+            foreach (var triggerEvent in Prefab.TriggerEvents)
+            {
+                if (triggerEvent.State == state)
+                {
+                    TryTriggerEvent(triggerEvent);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Triggers the event or adds it to the delayedTriggerEvents it if it has a delay
+        /// </summary>
+        private void TryTriggerEvent(MissionPrefab.TriggerEvent trigger)
+        {
+            if (trigger.CampaignOnly && GameMain.GameSession?.Campaign == null) { return; }
+            if (trigger.Delay > 0)
+            {
+                if (!delayedTriggerEvents.Any(t => t.TriggerEvent == trigger))
+                {
+                    delayedTriggerEvents.Add(new DelayedTriggerEvent(trigger, trigger.Delay));
+                }
+            }
+            else
+            {
+                TriggerEvent(trigger);
+            }
+        }
+
+        /// <summary>
+        /// Triggers the event immediately, ignoring any delays
+        /// </summary>
+        private void TriggerEvent(MissionPrefab.TriggerEvent trigger)
+        {
+            if (trigger.CampaignOnly && GameMain.GameSession?.Campaign == null) { return; }
+            var eventPrefab = EventSet.GetAllEventPrefabs().Find(p => p.Identifier.Equals(trigger.EventIdentifier, StringComparison.OrdinalIgnoreCase));
+            if (eventPrefab == null)
+            {
+                DebugConsole.ThrowError($"Mission \"{Name}\" failed to trigger an event (couldn't find an event with the identifier \"{trigger.EventIdentifier}\").");
+                return;
+            }
+            if (GameMain.GameSession?.EventManager != null)
+            {
+                var newEvent = eventPrefab.CreateInstance();
+                GameMain.GameSession.EventManager.ActiveEvents.Add(newEvent);
+                newEvent.Init(true);
+            }
+        }
+
         /// <summary>
         /// End the mission and give a reward if it was completed successfully
         /// </summary>
@@ -232,7 +343,7 @@ namespace Barotrauma
         public void GiveReward()
         {
             if (!(GameMain.GameSession.GameMode is CampaignMode campaign)) { return; }
-            campaign.Money += Reward;
+            campaign.Money += GetReward(Submarine.MainSub);
 
             foreach (KeyValuePair<string, float> reputationReward in ReputationRewards)
             {
@@ -287,5 +398,47 @@ namespace Barotrauma
         }
 
         public virtual void AdjustLevelData(LevelData levelData) { }
+
+        // putting these here since both escort and pirate missions need them. could be tucked away into another class that they can inherit from (or use composition)
+        protected HumanPrefab GetHumanPrefabFromElement(XElement element)
+        {
+            if (element.Attribute("name") != null)
+            {
+                DebugConsole.ThrowError("Error in mission \"" + Name + "\" - use character identifiers instead of names to configure the characters.");
+
+                return null;
+            }
+
+            string characterIdentifier = element.GetAttributeString("identifier", "");
+            string characterFrom = element.GetAttributeString("from", "");
+            HumanPrefab humanPrefab = NPCSet.Get(characterFrom, characterIdentifier);
+            if (humanPrefab == null)
+            {
+                DebugConsole.ThrowError("Couldn't spawn character for mission: character prefab \"" + characterIdentifier + "\" not found");
+                return null;
+            }
+
+            return humanPrefab;
+        }
+
+        protected Character CreateHuman(HumanPrefab humanPrefab, List<Character> characters, Dictionary<Character, List<Item>> characterItems, Submarine submarine, CharacterTeamType teamType, ISpatialEntity positionToStayIn = null, Rand.RandSync humanPrefabRandSync = Rand.RandSync.Server, bool giveTags = true)
+        {
+            if (positionToStayIn == null) 
+            {
+                positionToStayIn = WayPoint.GetRandom(SpawnType.Human, null, submarine);
+            }
+
+            var characterInfo = humanPrefab.GetCharacterInfo(Rand.RandSync.Server) ?? new CharacterInfo(CharacterPrefab.HumanSpeciesName, npcIdentifier: humanPrefab.Identifier, jobPrefab: humanPrefab.GetJobPrefab(humanPrefabRandSync), randSync: humanPrefabRandSync);
+            characterInfo.TeamID = teamType;
+            Character spawnedCharacter = Character.Create(characterInfo.SpeciesName, positionToStayIn.WorldPosition, ToolBox.RandomSeed(8), characterInfo, createNetworkEvent: false);
+            spawnedCharacter.Prefab = humanPrefab;
+            humanPrefab.InitializeCharacter(spawnedCharacter, positionToStayIn);
+            humanPrefab.GiveItems(spawnedCharacter, submarine, Rand.RandSync.Server, createNetworkEvents: false);
+
+            characters.Add(spawnedCharacter);
+            characterItems.Add(spawnedCharacter, spawnedCharacter.Inventory.FindAllItems(recursive: true));
+
+            return spawnedCharacter;
+        }
     }
 }

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

@@ -18,10 +18,11 @@ namespace Barotrauma
         Nest = 0x10,
         Mineral = 0x20,
         Combat = 0x40,
-        OutpostDestroy = 0x80,
-        OutpostRescue = 0x100,
-
-        All = Salvage | Monster | Cargo | Beacon | Nest | Mineral | Combat | OutpostDestroy | OutpostRescue
+        AbandonedOutpost = 0x80,
+        Escort = 0x100,
+        Pirate = 0x200,
+        GoTo = 0x400,
+        All = Salvage | Monster | Cargo | Beacon | Nest | Mineral | Combat | AbandonedOutpost | Escort | Pirate | GoTo
     }
 
     partial class MissionPrefab
@@ -36,13 +37,17 @@ namespace Barotrauma
             { MissionType.Beacon, typeof(BeaconMission) },
             { MissionType.Nest, typeof(NestMission) },
             { MissionType.Mineral, typeof(MineralMission) },
-            { MissionType.OutpostDestroy, typeof(OutpostDestroyMission) },
-            { MissionType.OutpostRescue, typeof(AbandonedOutpostMission) },
+            { MissionType.AbandonedOutpost, typeof(AbandonedOutpostMission) },
+            { MissionType.Escort, typeof(EscortMission) },
+            { MissionType.Pirate, typeof(PirateMission) },
+            { MissionType.GoTo, typeof(GoToMission) }
         };
         public static readonly Dictionary<MissionType, Type> PvPMissionClasses = new Dictionary<MissionType, Type>()
         {
             { MissionType.Combat, typeof(CombatMission) }
         };
+
+        public static readonly HashSet<MissionType> HiddenMissionClasses = new HashSet<MissionType>() { MissionType.GoTo };
         
         private readonly ConstructorInfo constructor;
 
@@ -84,6 +89,8 @@ namespace Barotrauma
 
         public readonly bool IsSideObjective;
 
+        public readonly bool RequireWreck;
+
         /// <summary>
         /// The mission can only be received when travelling from Pair.First to Pair.Second
         /// </summary>
@@ -99,6 +106,28 @@ namespace Barotrauma
         /// </summary>
         public readonly List<string> UnhideEntitySubCategories = new List<string>();
 
+        public class TriggerEvent
+        {
+            [Serialize("", true)]
+            public string EventIdentifier { get; private set; }
+
+            [Serialize(0, true)]
+            public int State { get; private set; }
+
+            [Serialize(0.0f, true)]
+            public float Delay { get; private set; }
+
+            [Serialize(false, true)]
+            public bool CampaignOnly { get; private set; }
+
+            public TriggerEvent(XElement element)
+            {
+                SerializableProperty.DeserializeProperties(this, element);
+            }
+        }
+
+        public readonly List<TriggerEvent> TriggerEvents = new List<TriggerEvent>();
+
         public LocationTypeChange LocationTypeChangeOnCompleted;
 
         public readonly XElement ConfigElement;
@@ -157,6 +186,7 @@ namespace Barotrauma
             Reward      = element.GetAttributeInt("reward", 1);
             AllowRetry  = element.GetAttributeBool("allowretry", false);
             IsSideObjective = element.GetAttributeBool("sideobjective", false);
+            RequireWreck = element.GetAttributeBool("requirewreck", false);
             Commonness  = element.GetAttributeInt("commonness", 1);
             if (element.GetAttribute("difficulty") != null)
             {
@@ -269,10 +299,19 @@ namespace Barotrauma
                             DataRewards.Add(Tuple.Create(identifier, value, operation));
                         }
                         break;
+                    case "triggerevent":
+                        TriggerEvents.Add(new TriggerEvent(subElement));
+                        break;
                 }
             }
 
             string missionTypeName = element.GetAttributeString("type", "");
+            //backwards compatibility
+            if (missionTypeName.Equals("outpostdestroy", StringComparison.OrdinalIgnoreCase) || missionTypeName.Equals("outpostrescue", StringComparison.OrdinalIgnoreCase)) 
+            {
+                missionTypeName = "AbandonedOutpost";
+            }
+
             if (!Enum.TryParse(missionTypeName, out Type))
             {
                 DebugConsole.ThrowError("Error in mission prefab \"" + Name + "\" - \"" + missionTypeName + "\" is not a valid mission type.");
@@ -286,16 +325,20 @@ namespace Barotrauma
 
             if (CoOpMissionClasses.ContainsKey(Type))
             {
-                constructor = CoOpMissionClasses[Type].GetConstructor(new[] { typeof(MissionPrefab), typeof(Location[]) });
+                constructor = CoOpMissionClasses[Type].GetConstructor(new[] { typeof(MissionPrefab), typeof(Location[]), typeof(Submarine) });
             }
             else if (PvPMissionClasses.ContainsKey(Type))
             {
-                constructor = PvPMissionClasses[Type].GetConstructor(new[] { typeof(MissionPrefab), typeof(Location[]) });
+                constructor = PvPMissionClasses[Type].GetConstructor(new[] { typeof(MissionPrefab), typeof(Location[]), typeof(Submarine) });
             }
             else
             {
                 DebugConsole.ThrowError("Error in mission prefab \"" + Name + "\" - unsupported mission type \"" + Type.ToString() + "\"");
             }
+            if (constructor == null)
+            {
+                DebugConsole.ThrowError($"Failed to find a constructor for the mission type \"{Type}\"!");
+            }
 
             InitProjSpecific(element);
         }
@@ -333,9 +376,9 @@ namespace Barotrauma
             return false;
         }
 
-        public Mission Instantiate(Location[] locations)
+        public Mission Instantiate(Location[] locations, Submarine sub)
         {
-            return constructor?.Invoke(new object[] { this, locations }) as Mission;
+            return constructor?.Invoke(new object[] { this, locations, sub }) as Mission;
         }
     }
 }

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

@@ -33,8 +33,8 @@ namespace Barotrauma
             }
         }
 
-        public MonsterMission(MissionPrefab prefab, Location[] locations)
-            : base(prefab, locations)
+        public MonsterMission(MissionPrefab prefab, Location[] locations, Submarine sub)
+            : base(prefab, locations, sub)
         {
             string speciesName = prefab.ConfigElement.GetAttributeString("monsterfile", null);
             if (!string.IsNullOrEmpty(speciesName))
@@ -160,7 +160,7 @@ namespace Barotrauma
             }
         }
 
-        public override void Update(float deltaTime)
+        protected override void UpdateMissionSpecific(float deltaTime)
         {
             switch (State)
             {

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

@@ -46,8 +46,8 @@ namespace Barotrauma
             }
         }
 
-        public NestMission(MissionPrefab prefab, Location[] locations)
-            : base(prefab, locations)
+        public NestMission(MissionPrefab prefab, Location[] locations, Submarine sub)
+            : base(prefab, locations, sub)
         {
             itemConfig = prefab.ConfigElement.Element("Items");
 
@@ -216,7 +216,7 @@ namespace Barotrauma
             level.LevelObjectManager.PlaceNestObjects(level, cave, nestPosition, nestObjectRadius, nestObjectAmount);
         }
 
-        public override void Update(float deltaTime)
+        protected override void UpdateMissionSpecific(float deltaTime)
         {
             if (IsClient)
             {

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

@@ -1,165 +0,0 @@
-using Barotrauma.Extensions;
-using Microsoft.Xna.Framework;
-using System.Collections.Generic;
-using System.Linq;
-using System.Xml.Linq;
-
-namespace Barotrauma
-{
-    partial class OutpostDestroyMission : AbandonedOutpostMission
-    {
-        private readonly string itemTag;
-        private readonly XElement itemConfig;
-        private readonly List<Item> items = new List<Item>();
-
-        public override IEnumerable<Vector2> SonarPositions
-        {
-            get
-            {
-                if (State > 0)
-                {
-                    return Enumerable.Empty<Vector2>();
-                }
-                else
-                {
-                    return Targets.Select(t => t.WorldPosition);
-                }
-            }
-        }
-
-        private IEnumerable<Entity> Targets
-        {
-            get
-            {
-                if (State > 0)
-                {
-                    return Enumerable.Empty<Entity>();
-                }
-                else
-                {
-                    if (items.Any())
-                    {
-                        return items.Where(it => !it.Removed && it.Condition > 0.0f).Cast<Entity>().Concat(requireKill.Where(c => !c.Removed && !c.IsDead)).Concat(requireRescue);
-                    }
-                    else
-                    {
-                        return requireKill.Concat(requireRescue);
-                    }
-                }
-            }
-        }
-
-        public OutpostDestroyMission(MissionPrefab prefab, Location[] locations) : 
-            base(prefab, locations)
-        {
-            itemConfig = prefab.ConfigElement.Element("Items");
-            itemTag = prefab.ConfigElement.GetAttributeString("targetitem", "");
-        }
-
-        protected override void StartMissionSpecific(Level level)
-        {
-            items.Clear();
-#if SERVER
-            spawnedItems.Clear();
-#endif
-            if (!string.IsNullOrEmpty(itemTag))
-            {
-                var itemsToDestroy = Item.ItemList.FindAll(it => it.Submarine?.Info.Type != SubmarineType.Player && it.HasTag(itemTag));
-                if (!itemsToDestroy.Any())
-                {
-                    DebugConsole.ThrowError($"Error in mission \"{Prefab.Identifier}\". Could not find an item with the tag \"{itemTag}\".");
-                }
-                else
-                {
-                    items.AddRange(itemsToDestroy);
-                }
-            }
-            if (itemConfig != null && !IsClient)
-            {
-                foreach (XElement element in itemConfig.Elements())
-                {
-                    string itemIdentifier = element.GetAttributeString("identifier", "");
-                    if (!(MapEntityPrefab.Find(null, itemIdentifier) is ItemPrefab itemPrefab))
-                    {
-                        DebugConsole.ThrowError("Couldn't spawn item for outpost destroy mission: item prefab \"" + itemIdentifier + "\" not found");
-                        continue;
-                    }
-
-                    string[] moduleFlags = element.GetAttributeStringArray("moduleflags", null);
-                    string[] spawnPointTags = element.GetAttributeStringArray("spawnpointtags", null); 
-                    ISpatialEntity spawnPoint = SpawnAction.GetSpawnPos(
-                         SpawnAction.SpawnLocationType.Outpost, SpawnType.Human | SpawnType.Enemy,
-                         moduleFlags, spawnPointTags, element.GetAttributeBool("asfaraspossible", false));
-                    if (spawnPoint == null)
-                    {
-                        var submarine = Submarine.Loaded.Find(s => s.Info.Type == SubmarineType.Outpost) ?? Submarine.MainSub;
-                        spawnPoint = submarine.GetHulls(alsoFromConnectedSubs: false).GetRandom();
-                    }
-                    Vector2 spawnPos = spawnPoint.WorldPosition;
-                    if (spawnPoint is WayPoint wp && wp.CurrentHull != null)
-                    {
-                        spawnPos = new Vector2(
-                            MathHelper.Clamp(wp.WorldPosition.X + Rand.Range(-200, 200), wp.CurrentHull.WorldRect.X, wp.CurrentHull.WorldRect.Right),
-                            wp.CurrentHull.WorldRect.Y - wp.CurrentHull.Rect.Height + 16.0f);
-                    }
-                    var item = new Item(itemPrefab, spawnPos, null);
-                    items.Add(item);
-#if SERVER
-                    spawnedItems.Add(item);
-#endif
-                }
-            }
-
-            base.StartMissionSpecific(level);
-        }
-
-        public override void Update(float deltaTime)
-        {
-            if (requireRescue.Any(r => r.Removed || r.IsDead))
-            {
-#if SERVER
-                if (!(GameMain.GameSession.GameMode is CampaignMode) && GameMain.Server != null)
-                {
-                    GameMain.Server.EndGame();                        
-                }
-#endif
-                return;
-            }
-
-            switch (state)
-            {
-                case 0:
-                    if (items.Any())
-                    {
-                        if (items.All(it => it.Removed || it.Condition <= 0.0f) &&
-                            requireKill.All(c => c.Removed || c.IsDead) && 
-                            requireRescue.All(c => c.Submarine?.Info.Type == SubmarineType.Player))
-                        {
-                            State = 1;
-                        }
-                    }
-                    else
-                    {
-                        if (requireKill.All(c => c.Removed || c.IsDead) &&
-                            requireRescue.All(c => c.Submarine?.Info.Type == SubmarineType.Player))
-                        {
-                            State = 1;
-                        }
-                    }
-                    break;
-#if SERVER
-                case 1:
-                    if (!(GameMain.GameSession.GameMode is CampaignMode) && GameMain.Server != null)
-                    {
-                        if (!Submarine.MainSub.AtStartExit || (wasDocked && !Submarine.MainSub.DockedTo.Contains(Level.Loaded.StartOutpost)))
-                        {
-                            GameMain.Server.EndGame();
-                            State = 2;
-                        }
-                    }
-                    break;
-#endif
-            }
-        }
-    }
-}

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

@@ -0,0 +1,395 @@
+using Barotrauma.Extensions;
+using Barotrauma.Items.Components;
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    partial class PirateMission : Mission
+    {
+        private readonly XElement submarineTypeConfig;
+        private readonly XElement characterConfig;
+        private readonly XElement characterTypeConfig;
+        private readonly float addedMissionDifficultyPerPlayer;
+
+        private float missionDifficulty;
+        private int alternateReward;
+
+        private Submarine enemySub;
+        private readonly List<Character> characters = new List<Character>();
+        private readonly Dictionary<Character, List<Item>> characterItems = new Dictionary<Character, List<Item>>();
+
+        // Update the last sighting periodically so that the players can find the pirate sub even if they have lost the track of it.
+        private readonly float pirateSightingUpdateFrequency = 30;
+        private float pirateSightingUpdateTimer;
+        private Vector2? lastSighting;
+
+        public override int TeamCount => 2;
+
+        private bool outsideOfSonarRange;
+
+        private readonly List<Vector2> patrolPositions = new List<Vector2>();
+
+        public override IEnumerable<Vector2> SonarPositions
+        {
+            get
+            {
+                var empty = Enumerable.Empty<Vector2>();
+                if (outsideOfSonarRange)
+                {
+                    return State switch
+                    {
+                        0 => patrolPositions,
+                        1 => lastSighting.HasValue ? lastSighting.Value.ToEnumerable() : empty,
+                        _ => empty,
+                    };
+                }
+                else
+                {
+                    return empty;
+                }
+            }
+        }
+
+        public override int GetReward(Submarine sub)
+        {
+            return alternateReward;
+        }
+
+        private SubmarineInfo submarineInfo;
+
+        public override SubmarineInfo EnemySubmarineInfo
+        {
+            get
+            {
+                return submarineInfo;
+            }
+        }
+
+        // these values could also be defined within the mission XML
+        private const float RandomnessModifier = 25;
+        private const float ShipRandomnessModifier = 15;
+
+        private const float MaxDifficulty = 100;
+
+        public PirateMission(MissionPrefab prefab, Location[] locations, Submarine sub) : base(prefab, locations, sub)
+        {
+            submarineTypeConfig = prefab.ConfigElement.Element("SubmarineTypes");
+            characterConfig = prefab.ConfigElement.Element("Characters");
+            characterTypeConfig = prefab.ConfigElement.Element("CharacterTypes");
+            addedMissionDifficultyPerPlayer = prefab.ConfigElement.GetAttributeFloat("addedmissiondifficultyperplayer", 0);
+
+            // for campaign missions, set difficulty at construction
+            LevelData levelData = locations[0].Connections.Where(c => c.Locations.Contains(locations[1])).FirstOrDefault()?.LevelData ?? locations[0]?.LevelData;
+            
+            SetDifficulty(levelData?.Difficulty ?? Level.Loaded?.Difficulty ?? 0f);
+        }
+
+        public override void SetDifficulty(float difficulty)
+        {
+            if (missionDifficulty > 0f)
+            {
+                // difficulty already set
+                return;
+            }
+
+            missionDifficulty = difficulty;
+
+            XElement submarineConfig = GetRandomDifficultyModifiedElement(submarineTypeConfig, missionDifficulty, ShipRandomnessModifier);
+
+            alternateReward = submarineConfig.GetAttributeInt("alternatereward", Reward);
+
+            string rewardText = $"‖color:gui.orange‖{string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0:N0}", alternateReward)}‖end‖";
+            if (descriptionWithoutReward != null) { description = descriptionWithoutReward.Replace("[reward]", rewardText); }
+
+            string submarinePath = submarineConfig.GetAttributeString("path", string.Empty);
+            if (submarinePath == string.Empty)
+            {
+                DebugConsole.ThrowError($"No path used for submarine for the pirate mission \"{Prefab.Identifier}\"!");
+                return;
+            }
+            // maybe a little redundant
+            var contentFile = ContentPackage.GetFilesOfType(GameMain.Config.AllEnabledPackages, ContentType.EnemySubmarine).FirstOrDefault(x => x.Path == submarinePath);
+            if (contentFile == null)
+            {
+                DebugConsole.ThrowError($"No submarine file found from the path {submarinePath}!");
+                return;
+            }
+
+            submarineInfo = new SubmarineInfo(contentFile.Path);
+        }
+
+        private float GetDifficultyModifiedValue(float preferredDifficulty, float levelDifficulty, float randomnessModifier)
+        {
+            return Math.Abs(levelDifficulty - preferredDifficulty + (Rand.Range(-randomnessModifier, randomnessModifier, Rand.RandSync.Server)));
+        }
+        private int GetDifficultyModifiedAmount(int minAmount, int maxAmount, float levelDifficulty)
+        {
+            return Math.Max((int)Math.Round(minAmount + (maxAmount - minAmount) * ((levelDifficulty + Rand.Range(-RandomnessModifier, RandomnessModifier, Rand.RandSync.Server)) / MaxDifficulty)), minAmount);
+        }
+
+        private XElement GetRandomDifficultyModifiedElement(XElement parentElement, float levelDifficulty, float randomnessModifier)
+        {
+            // look for the element that is closest to our difficulty, with some randomness
+            XElement bestElement = null;
+            float bestValue = float.MaxValue;
+            foreach (XElement element in parentElement.Elements())
+            {
+                float applicabilityValue = GetDifficultyModifiedValue(element.GetAttributeFloat(0f, "preferreddifficulty"), levelDifficulty, randomnessModifier);
+                if (applicabilityValue < bestValue)
+                {
+                    bestElement = element;
+                    bestValue = applicabilityValue;
+                }
+            }
+            return bestElement;
+        }
+
+        private void CreateMissionPositions(out Vector2 preferredSpawnPos)
+        {
+            Vector2 patrolPos = enemySub.WorldPosition;
+            Point subSize = enemySub.GetDockedBorders().Size;
+
+            if (!Level.Loaded.TryGetInterestingPosition(true, Level.PositionType.MainPath | Level.PositionType.SidePath, Level.Loaded.Size.X * 0.3f, out preferredSpawnPos))
+            {
+                DebugConsole.ThrowError("Could not spawn pirate submarine in an interesting location! " + this);
+            }
+            if (!Level.Loaded.TryGetInterestingPositionAwayFromPoint(true, Level.PositionType.MainPath | Level.PositionType.SidePath, Level.Loaded.Size.X * 0.3f, out patrolPos, preferredSpawnPos, minDistFromPoint: 10000f))
+            {
+                DebugConsole.ThrowError("Could not give pirate submarine an interesting location to patrol to! " + this);
+            }
+
+            patrolPos = enemySub.FindSpawnPos(patrolPos, subSize);
+
+            patrolPositions.Add(patrolPos);
+            patrolPositions.Add(preferredSpawnPos);
+
+            if (!IsClient)
+            {
+                PathFinder pathFinder = new PathFinder(WayPoint.WayPointList, false);
+                var path = pathFinder.FindPath(ConvertUnits.ToSimUnits(patrolPos), ConvertUnits.ToSimUnits(preferredSpawnPos));
+                if (!path.Unreachable)
+                {
+                    preferredSpawnPos = path.Nodes[Rand.Range(0, path.Nodes.Count - 1)].WorldPosition; // spawn the sub in a random point in the path if possible
+                }
+
+                int graceDistance = 500; // the sub still spawns awkwardly close to walls, so this helps. could also be given as a parameter instead
+                preferredSpawnPos = enemySub.FindSpawnPos(preferredSpawnPos, new Point(subSize.X + graceDistance, subSize.Y + graceDistance));
+            }
+        }
+
+        private void InitPirateShip(Vector2 spawnPos)
+        {
+            enemySub.NeutralizeBallast();
+            if (enemySub.GetItems(alsoFromConnectedSubs: false).Find(i => i.HasTag("reactor") && !i.NonInteractable)?.GetComponent<Reactor>() is Reactor reactor)
+            {
+                reactor.PowerUpImmediately();
+            }
+            enemySub.EnableMaintainPosition();
+            enemySub.TeamID = CharacterTeamType.None;
+            //make the enemy sub withstand atleast the same depth as the player sub
+            enemySub.RealWorldCrushDepth = Math.Max(enemySub.RealWorldCrushDepth, Submarine.MainSub.RealWorldCrushDepth);
+        }
+
+        private void InitPirates()
+        {
+            characters.Clear();
+            characterItems.Clear();
+
+            if (characterConfig == null)
+            {
+                DebugConsole.ThrowError("Failed to initialize characters for escort mission (characterConfig == null)");
+                return;
+            }
+
+            int playerCount = 1;
+
+#if SERVER
+            playerCount = GameMain.Server.ConnectedClients.Where(c => !c.SpectateOnly || !GameMain.Server.ServerSettings.AllowSpectating).Count();
+#endif
+
+            float enemyCreationDifficulty = missionDifficulty + playerCount * addedMissionDifficultyPerPlayer;
+
+            bool commanderAssigned = false;
+            foreach (XElement element in characterConfig.Elements())
+            {
+                // it is possible to get more than the "max" amount of characters if the modified difficulty is high enough; this is intentional
+                // if necessary, another "hard max" value could be used to clamp the value for performance/gameplay concerns
+                int amountCreated = GetDifficultyModifiedAmount(element.GetAttributeInt("minamount", 0), element.GetAttributeInt("maxamount", 0), enemyCreationDifficulty);
+                for (int i = 0; i < amountCreated; i++)
+                {
+                    XElement characterType = characterTypeConfig.Elements().Where(e => e.GetAttributeString("typeidentifier", string.Empty) == element.GetAttributeString("typeidentifier", string.Empty)).FirstOrDefault();
+
+                    if (characterType == null)
+                    {
+                        DebugConsole.ThrowError($"No character types defined in CharacterTypes for a declared type identifier in mission \"{Prefab.Identifier}\".");
+                        return;
+                    }
+
+                    XElement variantElement = GetRandomDifficultyModifiedElement(characterType, enemyCreationDifficulty, RandomnessModifier);
+
+                    Character spawnedCharacter = CreateHuman(GetHumanPrefabFromElement(variantElement), characters, characterItems, enemySub, CharacterTeamType.None, null);
+                    if (!commanderAssigned)
+                    {
+                        bool isCommander = variantElement.GetAttributeBool("iscommander", false);
+                        if (isCommander && spawnedCharacter.AIController is HumanAIController humanAIController)
+                        {
+                            humanAIController.InitShipCommandManager();
+                            foreach (var patrolPos in patrolPositions)
+                            {
+                                humanAIController.ShipCommandManager.patrolPositions.Add(patrolPos);
+                            }
+                            commanderAssigned = true;
+                        }
+                    }
+
+                    foreach (Item item in spawnedCharacter.Inventory.AllItems)
+                    {
+                        if (item?.Prefab.Identifier == "idcard")
+                        {
+                            item.AddTag("id_pirate");
+                        }
+                    }
+                }
+            }
+        }
+
+        protected override void StartMissionSpecific(Level level)
+        {
+            if (characters.Count > 0)
+            {
+#if DEBUG
+                throw new Exception($"characters.Count > 0 ({characters.Count})");
+#else
+                DebugConsole.AddWarning("Character list was not empty at the start of a pirate mission. The mission instance may not have been ended correctly on previous rounds.");
+                characters.Clear();            
+#endif
+            }
+
+            if (patrolPositions.Count > 0)
+            {
+#if DEBUG
+                throw new Exception($"patrolPositions.Count > 0 ({patrolPositions.Count})");
+#else
+                DebugConsole.AddWarning("Patrol point list was not empty at the start of a pirate mission. The mission instance may not have been ended correctly on previous rounds.");
+                patrolPositions.Clear();            
+#endif
+            }
+
+            enemySub = Submarine.MainSubs[1];
+
+            if (enemySub == null)
+            {
+                DebugConsole.ThrowError($"Enemy Submarine was not created. SubmarineInfo is likely not defined.");
+                // TODO: should we set the state to something here?
+                return;
+            }
+
+            Vector2 spawnPos = Level.Loaded.EndPosition; // in case TryGetInterestingPosition fails, though this should not happen
+            CreateMissionPositions(out spawnPos); // patrol positions are not explicitly replicated, instead they are acquired the same way the server acquires them
+#if DEBUG
+            if (IsClient)
+            {
+                DebugConsole.NewMessage("The patrol positions set by client were: ");
+            }
+            else
+            {
+                DebugConsole.NewMessage("The patrol positions set by server were: ");
+            }
+            foreach (var patrolPos in patrolPositions)
+            {
+                DebugConsole.NewMessage("Patrol pos: " + patrolPos);
+            }
+#endif
+            if (!IsClient)
+            {
+                InitPirateShip(spawnPos);
+            }
+            enemySub.SetPosition(spawnPos);
+
+            // flipping the sub on the frame it is moved into place must be done after it's been moved, or it breaks item connections in the submarine
+            // creating the pirates has to be done after the sub has been flipped, or it seems to break the AI pathing
+            enemySub.FlipX();
+            enemySub.ShowSonarMarker = false;
+
+            if (!IsClient)
+            {
+                InitPirates();
+            }
+        }
+
+        protected override void UpdateMissionSpecific(float deltaTime)
+        {
+            int newState = State;
+            float sqrSonarRange = MathUtils.Pow2(Sonar.DefaultSonarRange);
+            outsideOfSonarRange = Vector2.DistanceSquared(enemySub.WorldPosition, Submarine.MainSub.WorldPosition) > sqrSonarRange;
+            if (State < 2 && CheckWinState())
+            {
+                newState = 2;
+            }
+            else
+            {
+                switch (State)
+                {
+                    case 0:
+                        for (int i = patrolPositions.Count - 1; i >= 0; i--)
+                        {
+                            if (Vector2.DistanceSquared(patrolPositions[i], Submarine.MainSub.WorldPosition) < sqrSonarRange)
+                            {
+                                patrolPositions.RemoveAt(i);
+                            }
+                        }
+                        if (!outsideOfSonarRange || patrolPositions.None())
+                        {
+                            newState = 1;
+                        }
+                        break;
+                    case 1:
+                        if (outsideOfSonarRange)
+                        {
+                            if (lastSighting.HasValue && Vector2.DistanceSquared(lastSighting.Value, Submarine.MainSub.WorldPosition) < sqrSonarRange)
+                            {
+                                lastSighting = null;
+                            }
+                            pirateSightingUpdateTimer -= deltaTime;
+                            if (pirateSightingUpdateTimer < 0)
+                            {
+                                pirateSightingUpdateTimer = pirateSightingUpdateFrequency;
+                                lastSighting = enemySub.WorldPosition;
+                            }
+                        }
+                        else
+                        {
+                            lastSighting = enemySub.WorldPosition;
+                            pirateSightingUpdateTimer = 0;
+                        }
+                        break;
+                }
+            }
+            State = newState;
+        }
+
+        private bool CheckWinState() => !IsClient && (characters.All(m => !Survived(m)));
+
+        private bool Survived(Character character)
+        {
+            return character != null && !character.Removed && !character.IsDead;
+        }
+
+        public override void End()
+        {
+            if (state == 2)
+            {
+                GiveReward();
+                completed = true;
+            }
+            characters.Clear();
+            characterItems.Clear();
+            failed = !completed;
+        }
+    }
+}

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

@@ -43,8 +43,8 @@ namespace Barotrauma
             }
         }
 
-        public SalvageMission(MissionPrefab prefab, Location[] locations)
-            : base(prefab, locations)
+        public SalvageMission(MissionPrefab prefab, Location[] locations, Submarine sub)
+            : base(prefab, locations, sub)
         {
             containerTag = prefab.ConfigElement.GetAttributeString("containertag", "");
 
@@ -205,7 +205,7 @@ namespace Barotrauma
             }
         }
 
-        public override void Update(float deltaTime)
+        protected override void UpdateMissionSpecific(float deltaTime)
         {
             if (item == null)
             {

Barotrauma/BarotraumaShared/SharedSource/Events/MonsterEvent.cs

@@ -88,7 +88,7 @@ namespace Barotrauma
             }
 
             offset = prefab.ConfigElement.GetAttributeFloat("offset", 0);
-            scatter = Math.Clamp(prefab.ConfigElement.GetAttributeFloat("scatter", 1000), 0, 3000);
+            scatter = Math.Clamp(prefab.ConfigElement.GetAttributeFloat("scatter", 500), 0, 3000);
 
             if (GameMain.NetworkMember != null)
             {
@@ -182,18 +182,11 @@ namespace Barotrauma
         {
             if (disallowed) { return; }
 
-            if (Rand.Value(Rand.RandSync.Server) > prefab.SpawnProbability)
-            {
-                spawnPos = null;
-                Finished();
-                return;
-            }
-
             spawnPos = Vector2.Zero;
             var availablePositions = GetAvailableSpawnPositions();
             var chosenPosition = new Level.InterestingPosition(Point.Zero, Level.PositionType.MainPath, isValid: false);
-            bool isSubOrWreck = spawnPosType == Level.PositionType.Ruin || spawnPosType == Level.PositionType.Wreck;
-            if (affectSubImmediately && !isSubOrWreck && spawnPosType != Level.PositionType.Abyss)
+            bool isRuinOrWreck = spawnPosType.HasFlag(Level.PositionType.Ruin) || spawnPosType.HasFlag(Level.PositionType.Wreck);
+            if (affectSubImmediately && !isRuinOrWreck && !spawnPosType.HasFlag(Level.PositionType.Abyss))
             {
                 if (availablePositions.None())
                 {
@@ -264,7 +257,7 @@ namespace Barotrauma
             }
             else
             {
-                if (!isSubOrWreck)
+                if (!isRuinOrWreck)
                 {
                     float minDistance = 20000;
                     var refSub = GetReferenceSub();
@@ -375,7 +368,7 @@ namespace Barotrauma
             if (spawnPending)
             {
                 //wait until there are no submarines at the spawnpos
-                if (spawnPosType == Level.PositionType.MainPath || spawnPosType == Level.PositionType.SidePath || spawnPosType == Level.PositionType.Abyss)
+                if (spawnPosType.HasFlag(Level.PositionType.MainPath) || spawnPosType.HasFlag(Level.PositionType.SidePath) || spawnPosType.HasFlag(Level.PositionType.Abyss))
                 {
                     foreach (Submarine submarine in Submarine.Loaded)
                     {
@@ -387,7 +380,7 @@ namespace Barotrauma
 
                 //if spawning in a ruin/cave, wait for someone to be close to it to spawning 
                 //unnecessary monsters in places the players might never visit during the round
-                if (spawnPosType == Level.PositionType.Ruin || spawnPosType == Level.PositionType.Cave || spawnPosType == Level.PositionType.Wreck)
+                if (spawnPosType.HasFlag(Level.PositionType.Ruin) || spawnPosType.HasFlag(Level.PositionType.Cave) || spawnPosType.HasFlag(Level.PositionType.Wreck))
                 {
                     bool someoneNearby = false;
                     float minDist = Sonar.DefaultSonarRange * 0.8f;
@@ -415,16 +408,19 @@ namespace Barotrauma
                 }
 
 
-                if (spawnPosType == Level.PositionType.Abyss || spawnPosType == Level.PositionType.AbyssCave)
+                if (spawnPosType.HasFlag(Level.PositionType.Abyss) || spawnPosType.HasFlag(Level.PositionType.AbyssCave))
                 {
+                    bool anyInAbyss = false;
                     foreach (Submarine submarine in Submarine.Loaded)
                     {
-                        if (submarine.Info.Type != SubmarineType.Player) { continue; }
-                        if (submarine.WorldPosition.Y > 0)
+                        if (submarine.Info.Type != SubmarineType.Player || submarine == GameMain.NetworkMember?.RespawnManager?.RespawnShuttle) { continue; }
+                        if (submarine.WorldPosition.Y < 0)
                         {
-                            return;
+                            anyInAbyss = true;
+                            break;
                         }
                     }
+                    if (!anyInAbyss) { return; }
                 }
 
                 spawnPending = false;
@@ -432,7 +428,23 @@ namespace Barotrauma
                 //+1 because Range returns an integer less than the max value
                 int amount = Rand.Range(minAmount, maxAmount + 1);
                 monsters = new List<Character>();
-                float offsetAmount = spawnPosType == Level.PositionType.MainPath || spawnPosType == Level.PositionType.SidePath ? scatter : 100;
+                float scatterAmount = scatter;
+                if (spawnPosType.HasFlag(Level.PositionType.SidePath))
+                {
+                    var sidePaths = Level.Loaded.Tunnels.Where(t => t.Type == Level.TunnelType.SidePath);
+                    if (sidePaths.Any())
+                    {
+                        scatterAmount = Math.Min(scatter, sidePaths.Min(t => t.MinWidth) / 2);
+                    }
+                    else
+                    {
+                        scatterAmount = scatter;
+                    }
+                }
+                else if (!spawnPosType.HasFlag(Level.PositionType.MainPath))
+                {
+                    scatterAmount = 0;
+                }
                 for (int i = 0; i < amount; i++)
                 {
                     string seed = Level.Loaded.Seed + i.ToString();
@@ -443,8 +455,8 @@ namespace Barotrauma
 						
                         System.Diagnostics.Debug.Assert(GameMain.NetworkMember == null || GameMain.NetworkMember.IsServer, "Clients should not create monster events.");
 
-                        Vector2 pos = spawnPos.Value + Rand.Vector(offsetAmount);
-                        if (spawnPosType == Level.PositionType.MainPath || spawnPosType == Level.PositionType.SidePath)
+                        Vector2 pos = spawnPos.Value + Rand.Vector(scatterAmount);
+                        if (scatterAmount > 0)
                         {
                             if (Submarine.Loaded.Any(s => ToolBox.GetWorldBounds(s.Borders.Center, s.Borders.Size).ContainsWorld(pos)))
                             {