Unstable 0.1400.0.0

2021-05-11 15:47:47 +03:00
parent 3f324b14e8
commit 92f0264af2
247 changed files with 8238 additions and 1911 deletions
@@ -35,8 +35,8 @@ namespace Barotrauma

        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");

@@ -84,14 +84,7 @@ namespace Barotrauma

                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)
-                    {
-                        DebugConsole.ThrowError("Couldn't spawn a character for abandoned outpost mission: character prefab \"" + characterIdentifier + "\" not found");
-                        continue;
-                    }
+                    HumanPrefab humanPrefab = CreateHumanPrefabFromElement(element);
                    for (int i = 0; i < count; i++)
                    {
                        LoadHuman(humanPrefab, element, submarine);
@@ -128,32 +121,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)
@@ -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;

@@ -17,15 +17,97 @@ namespace Barotrauma

        private int 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 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);
+            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,9 +118,9 @@ 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; }
@@ -49,7 +131,7 @@ namespace Barotrauma
            }
        }

-        private void LoadItemAsChild(XElement element, Item parent)
+        private ItemPrefab FindItemPrefab(XElement element)
        {
            ItemPrefab itemPrefab;
            if (element.Attribute("name") != null)
@@ -60,7 +142,6 @@ namespace Barotrauma
                if (itemPrefab == null)
                {
                    DebugConsole.ThrowError("Couldn't spawn item for cargo mission: item prefab \"" + itemName + "\" not found");
-                    return;
                }
            }
            else
@@ -70,15 +151,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 +169,6 @@ namespace Barotrauma
            }

            var cargoRoom = cargoSpawnPos.CurrentHull;
-
            if (cargoRoom == null)
            {
                DebugConsole.ThrowError("A waypoint marked as Cargo must be placed inside a room!");
@@ -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[]
            {
@@ -0,0 +1,301 @@
+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>> characterDictionary = new Dictionary<Character, List<Item>>();
+
+        private readonly int baseEscortedCharacters;
+        private readonly float scalingEscortedCharacters;
+        private readonly float terroristChance;
+
+        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)
+        {
+            characterConfig = prefab.ConfigElement.Element("Characters");
+            // Should reflect different escortables, prisoners, VIPs, passengers (where does this comment refer to?)
+
+            baseEscortedCharacters = prefab.ConfigElement.GetAttributeInt("baseescortedcharacters", 1);
+            scalingEscortedCharacters = prefab.ConfigElement.GetAttributeFloat("scalingescortedcharacters", 0);
+            terroristChance = prefab.ConfigElement.GetAttributeFloat("terroristchance", 0);
+            itemConfig = prefab.ConfigElement.Element("TerroristItems");
+        }
+
+        public override int Reward
+        {
+            get
+            { 
+                int multiplier = CalculateScalingEscortedCharacterCount();
+                return Prefab.Reward * multiplier;
+            }
+        }
+
+        int CalculateScalingEscortedCharacterCount(bool inMission = false)
+        {
+            if (Submarine.MainSub == null || Submarine.MainSub.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 * Submarine.MainSub.Info.RecommendedCrewSizeMin);
+        }
+
+        private void InitEscort()
+        {
+            characters.Clear();
+            characterDictionary.Clear();
+            // VIP transport mission characters stay in the same location; other characters roam at will
+            // could be replaced with a designated waypoint for VIPs, such as cargo or crew
+            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; 
+            }
+
+            foreach (XElement element in characterConfig.Elements())
+            {
+                int count = CalculateScalingEscortedCharacterCount(inMission: true);
+                for (int i = 0; i < count; i++)
+                {
+                    Character spawnedCharacter = CreateHuman(CreateHumanPrefabFromElement(element), characters, characterDictionary, Submarine.MainSub, CharacterTeamType.FriendlyNPC, explicitStayInHullPos, humanPrefabRandSync: randSync);
+                    if (spawnedCharacter.AIController is HumanAIController humanAI)
+                    {
+                        humanAI.InitMentalStateManager();
+                    }
+                }
+            }
+        }
+
+        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++;
+            }
+
+            if (!IsClient && 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.Shuffle();
+                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
+            }
+        }
+
+        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;
+            }
+
+            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.Any(c => !terroristCharacters.Contains(c) && IsAlive(c));
+        }
+
+        public override void Update(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).Any(c => Survived(c));
+                bool vipDied = false;
+
+                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 characterDictionary)
+            {
+                if (Survived(characterItem.Key) || !completed)
+                {
+                    foreach (Item item in characterItem.Value)
+                    {
+                        if (!item.Removed)
+                        {
+                            item.Remove();
+                        }
+                    }
+                }
+            }
+
+            characters.Clear();
+            characterDictionary.Clear();
+            failed = !completed;
+        }
+    }
+}
@@ -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"))
@@ -3,6 +3,7 @@ using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using System.Xml.Linq;

 namespace Barotrauma
 {
@@ -61,14 +62,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 +98,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>(); }
@@ -113,7 +129,7 @@ namespace Barotrauma
            get { return Prefab.Difficulty; }
        }
           
-        public Mission(MissionPrefab prefab, Location[] locations)
+        public Mission(MissionPrefab prefab, Location[] locations, Submarine sub)
        {
            System.Diagnostics.Debug.Assert(locations.Length == 2);

@@ -138,8 +154,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++)
@@ -181,7 +201,7 @@ namespace Barotrauma
            {
                if (randomNumber <= missionPrefab.Commonness)
                {
-                    return missionPrefab.Instantiate(locations);
+                    return missionPrefab.Instantiate(locations, Submarine.MainSub);
                }
                randomNumber -= missionPrefab.Commonness;
            }
@@ -189,6 +209,11 @@ namespace Barotrauma
            return null;
        }

+        public virtual int GetReward(Submarine sub)
+        {
+            return Prefab.Reward;
+        }
+
        public void Start(Level level)
        {
 #if CLIENT
@@ -232,7 +257,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 +312,48 @@ 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 CreateHumanPrefabFromElement(XElement element)
+        {
+            HumanPrefab humanPrefab = null;
+
+            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 = 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 = new CharacterInfo(CharacterPrefab.HumanSpeciesName, jobPrefab: humanPrefab.GetJobPrefab(humanPrefabRandSync), randSync: humanPrefabRandSync);
+            characterInfo.TeamID = teamType;
+            Character spawnedCharacter = Character.Create(characterInfo.SpeciesName, positionToStayIn.WorldPosition, ToolBox.RandomSeed(8), characterInfo, createNetworkEvent: false);
+            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;
+        }
    }
 }
@@ -20,8 +20,9 @@ namespace Barotrauma
        Combat = 0x40,
        OutpostDestroy = 0x80,
        OutpostRescue = 0x100,
-
-        All = Salvage | Monster | Cargo | Beacon | Nest | Mineral | Combat | OutpostDestroy | OutpostRescue
+        Escort = 0x200,
+        Pirate = 0x400,
+        All = Salvage | Monster | Cargo | Beacon | Nest | Mineral | Combat | OutpostDestroy | OutpostRescue | Escort | Pirate
    }

    partial class MissionPrefab
@@ -38,6 +39,8 @@ namespace Barotrauma
            { MissionType.Mineral, typeof(MineralMission) },
            { MissionType.OutpostDestroy, typeof(OutpostDestroyMission) },
            { MissionType.OutpostRescue, typeof(AbandonedOutpostMission) },
+            { MissionType.Escort, typeof(EscortMission) },
+            { MissionType.Pirate, typeof(PirateMission) }
        };
        public static readonly Dictionary<MissionType, Type> PvPMissionClasses = new Dictionary<MissionType, Type>()
        {
@@ -286,16 +289,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 +340,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;
        }
    }
 }
@@ -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))
@@ -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");

@@ -49,8 +49,8 @@ namespace Barotrauma
            }
        }

-        public OutpostDestroyMission(MissionPrefab prefab, Location[] locations) : 
-            base(prefab, locations)
+        public OutpostDestroyMission(MissionPrefab prefab, Location[] locations, Submarine sub) : 
+            base(prefab, locations, sub)
        {
            itemConfig = prefab.ConfigElement.Element("Items");
            itemTag = prefab.ConfigElement.GetAttributeString("targetitem", "");
@@ -96,10 +96,10 @@ namespace Barotrauma
                        spawnPoint = submarine.GetHulls(alsoFromConnectedSubs: false).GetRandom();
                    }
                    Vector2 spawnPos = spawnPoint.WorldPosition;
-                    if (spawnPoint is WayPoint wp && wp.CurrentHull != null)
+                    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, wp.CurrentHull.WorldRect.Right),
+                            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);
@@ -0,0 +1,290 @@
+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 characterConfig;
+        private readonly XElement submarineConfig;
+
+        private Submarine enemySub;
+        private Item reactorItem;
+        private readonly List<Character> characters = new List<Character>();
+        private readonly Dictionary<Character, List<Item>> characterDictionary = 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;
+                }
+            }
+        }
+
+        private SubmarineInfo submarineInfo;
+
+        public override SubmarineInfo EnemySubmarineInfo => submarineInfo;
+
+        public PirateMission(MissionPrefab prefab, Location[] locations, Submarine sub) : base(prefab, locations, sub)
+        {
+            submarineConfig = prefab.ConfigElement.Element("Submarine");
+            characterConfig = prefab.ConfigElement.Element("Characters");
+
+            string submarineIdentifier = submarineConfig.GetAttributeString("identifier", string.Empty);
+
+            if (submarineIdentifier == string.Empty)
+            {
+                DebugConsole.ThrowError("No identifier used for submarine for pirate mission!");
+                return;
+            }
+            // maybe a little redundant
+            var contentFile = ContentPackage.GetFilesOfType(GameMain.Config.AllEnabledPackages, ContentType.EnemySubmarine).FirstOrDefault(x => x.Path == submarineIdentifier);
+            if (contentFile == null)
+            {
+                DebugConsole.ThrowError("No submarine file found with the identifier!");
+                return;
+            }
+            submarineInfo = new SubmarineInfo(contentFile.Path);
+        }
+
+        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();
+                reactorItem = reactor.Item;
+            }
+            enemySub.EnableMaintainPosition();
+            enemySub.SetPosition(spawnPos);
+            enemySub.TeamID = CharacterTeamType.None;
+        }
+
+        private void InitPirates()
+        {
+            characters.Clear();
+            characterDictionary.Clear();
+
+            if (characterConfig == null)
+            {
+                DebugConsole.ThrowError("Failed to initialize characters for escort mission (characterConfig == null)");
+                return;
+            }
+
+            bool commanderAssigned = false;
+            foreach (XElement element in characterConfig.Elements())
+            {
+                Character spawnedCharacter = CreateHuman(CreateHumanPrefabFromElement(element), characters, characterDictionary, enemySub, CharacterTeamType.None, null);
+                if (!commanderAssigned)
+                {
+                    bool isCommander = element.GetAttributeBool("iscommander", false);
+                    if (isCommander && spawnedCharacter.AIController is HumanAIController humanAIController)
+                    {
+                        humanAIController.InitShipCommandManager();
+                        foreach (var patrolPos in patrolPositions)
+                        {
+                            humanAIController.ShipCommandManager.patrolPositions.Add(patrolPos);
+                        }
+                        commanderAssigned = true;
+                    }
+                }
+            }
+        }
+
+        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);
+            }
+
+            // flipping the sub on the frame it is moved into place must be done after it's been moved, or it breaks item connections to the submarine
+            // creating the pirates have 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();
+            }
+        }
+
+        public override void Update(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)) || reactorItem.Condition <= 0f);
+
+        private bool Survived(Character character)
+        {
+            return character != null && !character.Removed && !character.IsDead;
+        }
+
+        public override void End()
+        {
+            if (state == 2)
+            {
+                GiveReward();
+                completed = true;
+            }
+            characters.Clear();
+            characterDictionary.Clear();
+            failed = !completed;
+        }
+    }
+}
@@ -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", "");