1651 lines
74 KiB
C#
1651 lines
74 KiB
C#
using Barotrauma.Extensions;
|
|
using Barotrauma.IO;
|
|
using Barotrauma.Networking;
|
|
using Microsoft.Xna.Framework;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Xml.Linq;
|
|
|
|
namespace Barotrauma
|
|
{
|
|
partial class MultiPlayerCampaign : CampaignMode
|
|
{
|
|
private readonly List<CharacterCampaignData> characterData = new List<CharacterCampaignData>();
|
|
private readonly Dictionary<ushort, Wallet> walletsToCheck = new Dictionary<ushort, Wallet>();
|
|
private readonly HashSet<NetWalletTransaction> transactions = new HashSet<NetWalletTransaction>();
|
|
private const float clientCheckInterval = 10;
|
|
private float clientCheckTimer = clientCheckInterval;
|
|
|
|
/// <summary>
|
|
/// Temporary backup storage for characters that have been overwritten by SaveSingleCharacter, this will be gone
|
|
/// once the round ends or the server closes. Currently needed to enable the console command "revive" in ironman mode.
|
|
/// </summary>
|
|
public List<CharacterCampaignData> replacedCharacterDataBackup = new List<CharacterCampaignData>();
|
|
|
|
public override Wallet GetWallet(Client client = null)
|
|
{
|
|
if (client is null) { throw new ArgumentNullException(nameof(client), "Client should not be null in multiplayer"); }
|
|
|
|
if (client.Character is { } character)
|
|
{
|
|
return character.Wallet;
|
|
}
|
|
|
|
return Wallet.Invalid;
|
|
}
|
|
|
|
private bool forceMapUI;
|
|
public bool ForceMapUI
|
|
{
|
|
get { return forceMapUI; }
|
|
set
|
|
{
|
|
if (forceMapUI == value) { return; }
|
|
forceMapUI = value;
|
|
IncrementLastUpdateIdForFlag(NetFlags.MapAndMissions);
|
|
}
|
|
}
|
|
|
|
public bool GameOver { get; private set; }
|
|
|
|
class SavedExperiencePoints
|
|
{
|
|
public readonly Option<AccountId> AccountId;
|
|
public readonly Address Address;
|
|
public readonly int ExperiencePoints;
|
|
|
|
public SavedExperiencePoints(Client client)
|
|
{
|
|
AccountId = client.AccountId;
|
|
Address = client.Connection.Endpoint.Address;
|
|
ExperiencePoints = client.Character?.Info?.ExperiencePoints ?? 0;
|
|
}
|
|
|
|
public SavedExperiencePoints(XElement element)
|
|
{
|
|
AccountId = Networking.AccountId.Parse(
|
|
element.GetAttributeString("accountid", null)
|
|
?? element.GetAttributeString("steamid", ""));
|
|
Address = Address.Parse(
|
|
element.GetAttributeString("address", null)
|
|
?? element.GetAttributeString("endpoint", ""))
|
|
.Fallback(new UnknownAddress());
|
|
ExperiencePoints = element.GetAttributeInt("points", 0);
|
|
}
|
|
}
|
|
|
|
private readonly List<SavedExperiencePoints> savedExperiencePoints = new List<SavedExperiencePoints>();
|
|
|
|
public override bool Paused
|
|
{
|
|
get { return ForceMapUI || CoroutineManager.IsCoroutineRunning("LevelTransition"); }
|
|
}
|
|
|
|
private bool purchasedHullRepairs, purchasedLostShuttles, purchasedItemRepairs;
|
|
public override bool PurchasedHullRepairs
|
|
{
|
|
get { return purchasedHullRepairs; }
|
|
set
|
|
{
|
|
if (purchasedHullRepairs == value) { return; }
|
|
purchasedHullRepairs = value;
|
|
PurchasedHullRepairsInLatestSave |= value;
|
|
IncrementLastUpdateIdForFlag(NetFlags.Misc);
|
|
DebugConsole.NewMessage("Set PurchasedHullRepairs to " + PurchasedHullRepairs, Color.Cyan);
|
|
}
|
|
}
|
|
public override bool PurchasedLostShuttles
|
|
{
|
|
get { return purchasedLostShuttles; }
|
|
set
|
|
{
|
|
if (purchasedLostShuttles == value) { return; }
|
|
purchasedLostShuttles = value;
|
|
PurchasedLostShuttlesInLatestSave |= value;
|
|
IncrementLastUpdateIdForFlag(NetFlags.Misc);
|
|
}
|
|
}
|
|
public override bool PurchasedItemRepairs
|
|
{
|
|
get { return purchasedItemRepairs; }
|
|
set
|
|
{
|
|
if (purchasedItemRepairs == value) { return; }
|
|
purchasedItemRepairs = value;
|
|
PurchasedItemRepairsInLatestSave |= value;
|
|
IncrementLastUpdateIdForFlag(NetFlags.Misc);
|
|
}
|
|
}
|
|
|
|
public static void StartNewCampaign(string savePath, string subPath, string seed, CampaignSettings startingSettings)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(savePath)) { return; }
|
|
|
|
GameMain.GameSession = new GameSession(new SubmarineInfo(subPath), Option.None, CampaignDataPath.CreateRegular(savePath), GameModePreset.MultiPlayerCampaign, startingSettings, seed);
|
|
GameMain.NetLobbyScreen.ToggleCampaignMode(true);
|
|
SaveUtil.SaveGame(GameMain.GameSession.DataPath);
|
|
|
|
DebugConsole.NewMessage("Campaign started!", Color.Cyan);
|
|
DebugConsole.NewMessage("Current location: " + GameMain.GameSession.Map.CurrentLocation.DisplayName, Color.Cyan);
|
|
((MultiPlayerCampaign)GameMain.GameSession.GameMode).LoadInitialLevel();
|
|
}
|
|
|
|
public static void LoadCampaign(CampaignDataPath path, Client client)
|
|
{
|
|
GameMain.NetLobbyScreen.ToggleCampaignMode(true);
|
|
try
|
|
{
|
|
SaveUtil.LoadGame(path);
|
|
if (GameMain.GameSession.GameMode is MultiPlayerCampaign mpCampaign)
|
|
{
|
|
mpCampaign.LastSaveID++;
|
|
}
|
|
else
|
|
{
|
|
DebugConsole.ThrowError("Failed to load a campaign. Unexpected game mode: " + GameMain.GameSession.GameMode ?? "none");
|
|
return;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
string errorMsg = $"Error while loading the save {path.LoadPath}";
|
|
if (client != null)
|
|
{
|
|
GameMain.Server?.SendDirectChatMessage($"{errorMsg}: {e.Message}\n{e.StackTrace}", client, ChatMessageType.Error);
|
|
}
|
|
DebugConsole.ThrowError(errorMsg, e);
|
|
return;
|
|
}
|
|
DebugConsole.NewMessage("Campaign loaded!", Color.Cyan);
|
|
DebugConsole.NewMessage(
|
|
GameMain.GameSession.Map.SelectedLocation == null ?
|
|
GameMain.GameSession.Map.CurrentLocation.DisplayName :
|
|
GameMain.GameSession.Map.CurrentLocation.DisplayName + " -> " + GameMain.GameSession.Map.SelectedLocation.DisplayName, Color.Cyan);
|
|
}
|
|
|
|
protected override void LoadInitialLevel()
|
|
{
|
|
NextLevel = map.SelectedConnection?.LevelData ?? map.CurrentLocation.LevelData;
|
|
MirrorLevel = false;
|
|
GameMain.Server.TryStartGame();
|
|
}
|
|
|
|
public static void StartCampaignSetup()
|
|
{
|
|
DebugConsole.NewMessage("********* CAMPAIGN SETUP *********", Color.White);
|
|
DebugConsole.ShowQuestionPrompt("Do you want to start a new campaign? Y/N", (string arg) =>
|
|
{
|
|
if (arg.Equals("y", StringComparison.OrdinalIgnoreCase) || arg.Equals("yes", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
DebugConsole.ShowQuestionPrompt("Enter a save name for the campaign:", (string saveName) =>
|
|
{
|
|
string savePath = SaveUtil.CreateSavePath(SaveUtil.SaveType.Multiplayer, saveName);
|
|
StartNewCampaign(savePath, GameMain.NetLobbyScreen.SelectedSub.FilePath, GameMain.NetLobbyScreen.LevelSeed, CampaignSettings.Empty);
|
|
});
|
|
}
|
|
else
|
|
{
|
|
var saveFiles = SaveUtil.GetSaveFiles(SaveUtil.SaveType.Multiplayer, includeInCompatible: false).ToArray();
|
|
if (saveFiles.Length == 0)
|
|
{
|
|
DebugConsole.ThrowError("No save files found.");
|
|
return;
|
|
}
|
|
DebugConsole.NewMessage("Saved campaigns:", Color.White);
|
|
for (int i = 0; i < saveFiles.Length; i++)
|
|
{
|
|
DebugConsole.NewMessage(" " + i + ". " + saveFiles[i].FilePath, Color.White);
|
|
}
|
|
DebugConsole.ShowQuestionPrompt("Select a save file to load (0 - " + (saveFiles.Length - 1) + "):", (string selectedSave) =>
|
|
{
|
|
int saveIndex = -1;
|
|
if (!int.TryParse(selectedSave, out saveIndex)) { return; }
|
|
|
|
if (saveIndex < 0 || saveIndex >= saveFiles.Length)
|
|
{
|
|
DebugConsole.ThrowError("Invalid save file index.");
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
LoadCampaign(CampaignDataPath.CreateRegular(saveFiles[saveIndex].FilePath), client: null);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
DebugConsole.ThrowError("Failed to load the campaign.", ex);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
public override void Start()
|
|
{
|
|
base.Start();
|
|
IncrementAllLastUpdateIds();
|
|
}
|
|
|
|
private static bool IsOwner(Client client) => client != null && client.Connection == GameMain.Server.OwnerConnection;
|
|
|
|
public void SaveExperiencePoints(Client client)
|
|
{
|
|
ClearSavedExperiencePoints(client);
|
|
savedExperiencePoints.Add(new SavedExperiencePoints(client));
|
|
}
|
|
public int GetSavedExperiencePoints(Client client)
|
|
{
|
|
return savedExperiencePoints.Find(s => client.AccountId == s.AccountId || client.Connection.Endpoint.Address == s.Address)?.ExperiencePoints ?? 0;
|
|
}
|
|
public void ClearSavedExperiencePoints(Client client)
|
|
{
|
|
savedExperiencePoints.RemoveAll(s => client.AccountId == s.AccountId || client.Connection.Endpoint.Address == s.Address);
|
|
}
|
|
|
|
public void RefreshCharacterCampaignData(Character character, bool refreshHealthData)
|
|
{
|
|
var matchingData = characterData.FirstOrDefault(c => c.CharacterInfo == character.Info);
|
|
matchingData?.Refresh(character, refreshHealthData: refreshHealthData);
|
|
}
|
|
|
|
public void SavePlayers()
|
|
{
|
|
//refresh the character data of clients who are still in the server
|
|
foreach (Client c in GameMain.Server.ConnectedClients)
|
|
{
|
|
//ignore if the character is controlling a monster
|
|
//(we'll just use the previously saved campaign data if there's any)
|
|
if (c.Character != null && c.Character.Info == null)
|
|
{
|
|
c.Character = null;
|
|
}
|
|
//use the info of the character the client is currently controlling
|
|
// or the previously saved info if not (e.g. if the client has been spectating or died)
|
|
var characterInfo = c.Character?.Info;
|
|
var matchingCharacterData = characterData.Find(d => d.MatchesClient(c));
|
|
if (matchingCharacterData != null)
|
|
{
|
|
//hasn't spawned this round -> don't touch the data
|
|
if (!matchingCharacterData.HasSpawned) { continue; }
|
|
characterInfo ??= matchingCharacterData.CharacterInfo;
|
|
}
|
|
if (characterInfo == null || characterInfo.Discarded) { continue; }
|
|
//reduce skills if the character has died
|
|
if (characterInfo.CauseOfDeath != null && characterInfo.CauseOfDeath.Type != CauseOfDeathType.Disconnected)
|
|
{
|
|
characterInfo.ApplyDeathEffects();
|
|
}
|
|
c.CharacterInfo = characterInfo;
|
|
SetClientCharacterData(c);
|
|
}
|
|
|
|
//refresh the character data of clients who aren't in the server anymore
|
|
List<CharacterCampaignData> prevCharacterData = new List<CharacterCampaignData>(characterData);
|
|
foreach (CharacterCampaignData data in prevCharacterData)
|
|
{
|
|
if (data.HasSpawned && !GameMain.Server.ConnectedClients.Any(c => data.MatchesClient(c)))
|
|
{
|
|
var character = Character.CharacterList.Find(c => c.Info == data.CharacterInfo && !c.IsHusk);
|
|
if (character != null &&
|
|
(!character.IsDead || character.CauseOfDeath?.Type == CauseOfDeathType.Disconnected))
|
|
{
|
|
//character still alive (or killed by Disconnect) -> save it as-is
|
|
characterData.RemoveAll(cd => cd.IsDuplicate(data));
|
|
data.Refresh(character, refreshHealthData: character.CauseOfDeath?.Type != CauseOfDeathType.Disconnected);
|
|
characterData.Add(data);
|
|
}
|
|
//check the cause of death in the CharacterInfo too (the character instance may have despawned, so we can't just rely on that)
|
|
else if (data.CharacterInfo.CauseOfDeath is not { Type: CauseOfDeathType.Disconnected })
|
|
{
|
|
//character dead or removed -> reduce skills, remove items, health data, etc
|
|
data.CharacterInfo.ApplyDeathEffects();
|
|
data.Reset();
|
|
}
|
|
}
|
|
}
|
|
|
|
MoveDiscardedCharacterBalancesToBank();
|
|
|
|
characterData.ForEach(cd => cd.HasSpawned = false);
|
|
foreach (var cd in characterData)
|
|
{
|
|
//remove from crewmanager - we don't need to save the data there if it's been saved as CharacterCampaignData
|
|
//(e.g. if a client has taken over a bot, we need to do this to prevent it being saved twice)
|
|
CrewManager.RemoveCharacterInfo(cd.CharacterInfo);
|
|
}
|
|
|
|
SavePets();
|
|
|
|
//remove all items that are in someone's inventory
|
|
foreach (Character c in Character.CharacterList)
|
|
{
|
|
if (c.Inventory == null) { continue; }
|
|
if (Level.Loaded.Type == LevelData.LevelType.Outpost && c.Submarine != Level.Loaded.StartOutpost)
|
|
{
|
|
Map.CurrentLocation.RegisterTakenItems(c.Inventory.AllItems.Where(it => it.SpawnedInCurrentOutpost && it.OriginalModuleIndex > 0));
|
|
}
|
|
|
|
if (c.Info != null && c.IsBot)
|
|
{
|
|
if (c.IsDead && c.CauseOfDeath?.Type != CauseOfDeathType.Disconnected) { CrewManager.RemoveCharacterInfo(c.Info); }
|
|
c.Info.HealthData = new XElement("health");
|
|
c.CharacterHealth.Save(c.Info.HealthData);
|
|
c.Info.InventoryData = new XElement("inventory");
|
|
c.SaveInventory();
|
|
c.Info.SaveOrderData();
|
|
}
|
|
|
|
c.Inventory.DeleteAllItems();
|
|
}
|
|
|
|
SaveActiveOrders();
|
|
}
|
|
|
|
public void MoveDiscardedCharacterBalancesToBank()
|
|
{
|
|
foreach (var discardedCharacter in discardedCharacters)
|
|
{
|
|
if (discardedCharacter.WalletData != null)
|
|
{
|
|
var wallet =
|
|
Character.CharacterList.Find(c => c.Info == discardedCharacter.CharacterInfo)?.Wallet ??
|
|
new Wallet(Option<Character>.None(), discardedCharacter.WalletData);
|
|
Bank.Give(wallet.Balance);
|
|
}
|
|
}
|
|
discardedCharacters.Clear();
|
|
}
|
|
|
|
protected override IEnumerable<CoroutineStatus> DoLevelTransition(TransitionType transitionType, LevelData newLevel, Submarine leavingSub, bool mirror)
|
|
{
|
|
IncrementAllLastUpdateIds();
|
|
|
|
switch (transitionType)
|
|
{
|
|
case TransitionType.None:
|
|
throw new InvalidOperationException("Level transition failed (no transitions available).");
|
|
case TransitionType.ReturnToPreviousLocation:
|
|
//deselect destination on map
|
|
map.SelectLocation(-1);
|
|
break;
|
|
case TransitionType.ProgressToNextLocation:
|
|
Map.MoveToNextLocation();
|
|
TotalPassedLevels++;
|
|
break;
|
|
case TransitionType.End:
|
|
EndCampaign();
|
|
IsFirstRound = true;
|
|
break;
|
|
case TransitionType.ProgressToNextEmptyLocation:
|
|
Map.Visit(Map.CurrentLocation);
|
|
TotalPassedLevels++;
|
|
break;
|
|
}
|
|
|
|
Map.ProgressWorld(this, transitionType, GameMain.GameSession.RoundDuration);
|
|
|
|
bool success = GameMain.Server.ConnectedClients.Any(c => c.InGame && c.Character != null && !c.Character.IsDead);
|
|
if (success)
|
|
{
|
|
foreach (Client c in GameMain.Server.ConnectedClients)
|
|
{
|
|
if (c.Character?.HasAbilityFlag(AbilityFlags.RetainExperienceForNewCharacter) ?? false)
|
|
{
|
|
(GameMain.GameSession?.GameMode as MultiPlayerCampaign)?.SaveExperiencePoints(c);
|
|
}
|
|
}
|
|
// Event history must be registered before ending the round or it will be cleared
|
|
GameMain.GameSession.EventManager.StoreEventDataAtRoundEnd();
|
|
}
|
|
|
|
//store the currently active missions at this point so we can communicate their states to clients, they're cleared in EndRound
|
|
List<Mission> missions = GameMain.GameSession.Missions.ToList();
|
|
|
|
GameMain.GameSession.EndRound("", transitionType);
|
|
|
|
//--------------------------------------
|
|
|
|
if (success)
|
|
{
|
|
SavePlayers();
|
|
yield return CoroutineStatus.Running;
|
|
LeaveUnconnectedSubs(leavingSub);
|
|
NextLevel = newLevel;
|
|
GameMain.GameSession.SubmarineInfo = new SubmarineInfo(GameMain.GameSession.Submarine);
|
|
SaveUtil.SaveGame(GameMain.GameSession.DataPath);
|
|
}
|
|
else
|
|
{
|
|
PendingSubmarineSwitch = null;
|
|
GameMain.Server.EndGame(TransitionType.None, wasSaved: false);
|
|
LoadCampaign(GameMain.GameSession.DataPath, client: null);
|
|
LastSaveID++;
|
|
IncrementAllLastUpdateIds();
|
|
yield return CoroutineStatus.Success;
|
|
}
|
|
|
|
CrewManager?.ClearCurrentOrders();
|
|
|
|
//--------------------------------------
|
|
|
|
GameMain.Server.EndGame(transitionType, wasSaved: true, missions);
|
|
|
|
ForceMapUI = false;
|
|
|
|
NextLevel = newLevel;
|
|
MirrorLevel = mirror;
|
|
|
|
|
|
yield return new WaitForSeconds(EndTransitionDuration * 0.5f);
|
|
|
|
//don't start the next round automatically if we just finished the campaign
|
|
if (transitionType != TransitionType.End)
|
|
{
|
|
GameMain.Server.TryStartGame();
|
|
}
|
|
|
|
yield return CoroutineStatus.Success;
|
|
}
|
|
|
|
partial void InitProjSpecific()
|
|
{
|
|
Identifier eventId = nameof(MultiPlayerCampaign).ToIdentifier();
|
|
CargoManager.OnItemsInBuyCrateChanged.RegisterOverwriteExisting(eventId, _ => IncrementLastUpdateIdForFlag(NetFlags.ItemsInBuyCrate));
|
|
CargoManager.OnPurchasedItemsChanged.RegisterOverwriteExisting(eventId, _ => IncrementLastUpdateIdForFlag(NetFlags.PurchasedItems));
|
|
CargoManager.OnSoldItemsChanged.RegisterOverwriteExisting(eventId, _ => IncrementLastUpdateIdForFlag(NetFlags.SoldItems));
|
|
UpgradeManager.OnUpgradesChanged.RegisterOverwriteExisting(eventId, _ => IncrementLastUpdateIdForFlag(NetFlags.UpgradeManager));
|
|
|
|
Reputation.OnAnyReputationValueChanged.RegisterOverwriteExisting(eventId, _ => IncrementLastUpdateIdForFlag(NetFlags.Reputation));
|
|
|
|
Map.OnLocationSelected = (loc, connection) => IncrementLastUpdateIdForFlag(NetFlags.MapAndMissions);
|
|
Map.OnMissionsSelected = (loc, mission) => IncrementLastUpdateIdForFlag(NetFlags.MapAndMissions);
|
|
|
|
//increment save ID so clients know they're lacking the most up-to-date save file
|
|
LastSaveID++;
|
|
}
|
|
|
|
public bool CanPurchaseSub(SubmarineInfo info, Client client)
|
|
=> CanAfford(info.GetPrice(), client) && GetCampaignSubs().Contains(info);
|
|
|
|
private readonly List<CharacterCampaignData> discardedCharacters = new List<CharacterCampaignData>();
|
|
public void DiscardClientCharacterData(Client client)
|
|
{
|
|
foreach (var data in characterData.ToList())
|
|
{
|
|
if (data.MatchesClient(client))
|
|
{
|
|
if (!discardedCharacters.Any(d => d.MatchesClient(client)))
|
|
{
|
|
discardedCharacters.Add(data);
|
|
}
|
|
DebugConsole.Log($"Client \"{client}\" discarded the character ({data.Name})");
|
|
data.CharacterInfo.Discarded = true;
|
|
characterData.Remove(data);
|
|
IncrementLastUpdateIdForFlag(NetFlags.CharacterInfo);
|
|
}
|
|
}
|
|
}
|
|
|
|
public CharacterCampaignData GetClientCharacterData(Client client)
|
|
{
|
|
return characterData.Find(cd => cd.MatchesClient(client));
|
|
}
|
|
|
|
public CharacterCampaignData GetCharacterData(CharacterInfo characterInfo)
|
|
{
|
|
return characterData.Find(cd => cd.CharacterInfo == characterInfo);
|
|
}
|
|
|
|
public CharacterCampaignData SetClientCharacterData(Client client)
|
|
{
|
|
characterData.RemoveAll(cd => cd.MatchesClient(client));
|
|
var data = new CharacterCampaignData(client);
|
|
characterData.Add(data);
|
|
IncrementLastUpdateIdForFlag(NetFlags.CharacterInfo);
|
|
return data;
|
|
}
|
|
|
|
public void AssignClientCharacterInfos(IEnumerable<Client> connectedClients)
|
|
{
|
|
foreach (Client client in connectedClients)
|
|
{
|
|
if (client.SpectateOnly && GameMain.Server.ServerSettings.AllowSpectating) { continue; }
|
|
var matchingData = GetClientCharacterData(client);
|
|
if (matchingData != null) { client.CharacterInfo = matchingData.CharacterInfo; }
|
|
}
|
|
IncrementLastUpdateIdForFlag(NetFlags.CharacterInfo);
|
|
}
|
|
|
|
public Dictionary<Client, Job> GetAssignedJobs(IEnumerable<Client> connectedClients)
|
|
{
|
|
var assignedJobs = new Dictionary<Client, Job>();
|
|
foreach (Client client in connectedClients)
|
|
{
|
|
var matchingData = GetClientCharacterData(client);
|
|
if (matchingData != null) assignedJobs.Add(client, matchingData.CharacterInfo.Job);
|
|
}
|
|
return assignedJobs;
|
|
}
|
|
|
|
public override void Update(float deltaTime)
|
|
{
|
|
if (CoroutineManager.IsCoroutineRunning("LevelTransition")) { return; }
|
|
|
|
Map?.Radiation?.UpdateRadiation(deltaTime);
|
|
|
|
base.Update(deltaTime);
|
|
|
|
MedicalClinic?.Update(deltaTime);
|
|
|
|
if (Level.Loaded != null)
|
|
{
|
|
if (Level.Loaded.Type == LevelData.LevelType.LocationConnection)
|
|
{
|
|
var transitionType = GetAvailableTransition(out _, out Submarine leavingSub);
|
|
if (transitionType == TransitionType.End ||
|
|
(Level.Loaded.IsEndBiome && transitionType == TransitionType.ProgressToNextLocation))
|
|
{
|
|
LoadNewLevel();
|
|
}
|
|
else if (GameMain.Server.ConnectedClients.Count == 0 || GameMain.Server.ConnectedClients.Any(c => c.InGame && c.Character != null && !c.Character.IsDead))
|
|
{
|
|
if (transitionType == TransitionType.ProgressToNextLocation && Level.Loaded.EndOutpost != null && Level.Loaded.EndOutpost.DockedTo.Contains(leavingSub))
|
|
{
|
|
LoadNewLevel();
|
|
}
|
|
else if (transitionType == TransitionType.ReturnToPreviousLocation && Level.Loaded.StartOutpost != null && Level.Loaded.StartOutpost.DockedTo.Contains(leavingSub))
|
|
{
|
|
LoadNewLevel();
|
|
}
|
|
}
|
|
}
|
|
else if (Level.Loaded.IsEndBiome)
|
|
{
|
|
var transitionType = GetAvailableTransition(out _, out Submarine leavingSub);
|
|
if (transitionType == TransitionType.ProgressToNextLocation)
|
|
{
|
|
LoadNewLevel();
|
|
}
|
|
}
|
|
else if (Level.Loaded.Type == LevelData.LevelType.Outpost)
|
|
{
|
|
KeepCharactersCloseToOutpost(deltaTime);
|
|
}
|
|
}
|
|
|
|
UpdateClientsToCheck(deltaTime);
|
|
UpdateWallets();
|
|
}
|
|
|
|
private void UpdateClientsToCheck(float deltaTime)
|
|
{
|
|
if (clientCheckTimer < clientCheckInterval)
|
|
{
|
|
clientCheckTimer += deltaTime;
|
|
return;
|
|
}
|
|
|
|
clientCheckTimer = 0;
|
|
walletsToCheck.Clear();
|
|
walletsToCheck.Add(0, Bank);
|
|
|
|
foreach (Character character in GameSession.GetSessionCrewCharacters(CharacterType.Player))
|
|
{
|
|
walletsToCheck.Add(character.ID, character.Wallet);
|
|
}
|
|
}
|
|
|
|
private void UpdateWallets()
|
|
{
|
|
foreach (var (id, wallet) in walletsToCheck)
|
|
{
|
|
if (wallet.HasTransactions())
|
|
{
|
|
NetWalletTransaction transaction = wallet.DequeueAndMergeTransactions(id);
|
|
if (!wallet.ShouldForceUpdate && transaction.ChangedData.BalanceChanged.IsNone() && transaction.ChangedData.RewardDistributionChanged.IsNone()) { continue; }
|
|
transactions.Add(transaction);
|
|
wallet.ShouldForceUpdate = false;
|
|
}
|
|
}
|
|
|
|
if (transactions.Count == 0) { return; }
|
|
|
|
NetWalletUpdate walletUpdate = new NetWalletUpdate
|
|
{
|
|
Transactions = transactions.ToArray()
|
|
};
|
|
|
|
transactions.Clear();
|
|
|
|
foreach (Client client in GameMain.Server.ConnectedClients)
|
|
{
|
|
IWriteMessage msg = new WriteOnlyMessage().WithHeader(ServerPacketHeader.MONEY);
|
|
((INetSerializableStruct)walletUpdate).Write(msg);
|
|
GameMain.Server?.ServerPeer?.Send(msg, client.Connection, DeliveryMethod.Reliable);
|
|
}
|
|
}
|
|
|
|
public override void End(TransitionType transitionType = TransitionType.None)
|
|
{
|
|
GameOver = !GameMain.Server.ConnectedClients.Any(c => c.InGame && c.Character != null && !c.Character.IsDead);
|
|
base.End(transitionType);
|
|
}
|
|
|
|
private bool IsFlagRequired(Client c, NetFlags flag)
|
|
=> !c.LastRecvCampaignUpdate.TryGetValue(flag, out var id) || NetIdUtils.IdMoreRecent(GetLastUpdateIdForFlag(flag), id);
|
|
|
|
public void ServerWrite(IWriteMessage msg, Client c)
|
|
{
|
|
System.Diagnostics.Debug.Assert(map.Locations.Count < UInt16.MaxValue);
|
|
|
|
NetFlags requiredFlags = lastUpdateID.Keys.Where(k => IsFlagRequired(c, k)).Aggregate((NetFlags)0, (f1, f2) => f1 | f2);
|
|
|
|
msg.WriteUInt16((UInt16)requiredFlags);
|
|
|
|
msg.WriteBoolean(IsFirstRound);
|
|
msg.WriteByte(CampaignID);
|
|
msg.WriteByte(RoundID);
|
|
msg.WriteUInt16(lastSaveID);
|
|
msg.WriteString(map.Seed);
|
|
|
|
if (requiredFlags.HasFlag(NetFlags.Misc))
|
|
{
|
|
msg.WriteUInt16(GetLastUpdateIdForFlag(NetFlags.Misc));
|
|
msg.WriteBoolean(PurchasedHullRepairs);
|
|
msg.WriteBoolean(PurchasedItemRepairs);
|
|
msg.WriteBoolean(PurchasedLostShuttles);
|
|
}
|
|
|
|
if (requiredFlags.HasFlag(NetFlags.MapAndMissions))
|
|
{
|
|
msg.WriteUInt16(GetLastUpdateIdForFlag(NetFlags.MapAndMissions));
|
|
msg.WriteBoolean(ForceMapUI);
|
|
msg.WriteBoolean(map.AllowDebugTeleport);
|
|
msg.WriteUInt16(map.CurrentLocationIndex == -1 ? UInt16.MaxValue : (UInt16)map.CurrentLocationIndex);
|
|
msg.WriteUInt16(map.SelectedLocationIndex == -1 ? UInt16.MaxValue : (UInt16)map.SelectedLocationIndex);
|
|
|
|
if (map.CurrentLocation != null)
|
|
{
|
|
msg.WriteByte((byte)map.CurrentLocation.AvailableMissions.Count());
|
|
foreach (Mission mission in map.CurrentLocation.AvailableMissions)
|
|
{
|
|
msg.WriteIdentifier(mission.Prefab.Identifier);
|
|
if (mission.Locations[0] == mission.Locations[1])
|
|
{
|
|
msg.WriteByte((byte)255);
|
|
}
|
|
else
|
|
{
|
|
Location missionDestination = mission.Locations[0] == map.CurrentLocation ? mission.Locations[1] : mission.Locations[0];
|
|
LocationConnection connection = map.CurrentLocation.Connections.Find(c => c.OtherLocation(map.CurrentLocation) == missionDestination);
|
|
msg.WriteByte((byte)map.CurrentLocation.Connections.IndexOf(connection));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
msg.WriteByte((byte)0);
|
|
}
|
|
|
|
var selectedMissionIndices = map.GetSelectedMissionIndices();
|
|
msg.WriteByte((byte)selectedMissionIndices.Count());
|
|
foreach (int selectedMissionIndex in selectedMissionIndices)
|
|
{
|
|
msg.WriteByte((byte)selectedMissionIndex);
|
|
}
|
|
|
|
WriteStores(msg);
|
|
}
|
|
|
|
if (requiredFlags.HasFlag(NetFlags.SubList))
|
|
{
|
|
msg.WriteUInt16(GetLastUpdateIdForFlag(NetFlags.SubList));
|
|
var subList = GameMain.NetLobbyScreen.GetSubList();
|
|
List<int> ownedSubmarineIndices = new List<int>();
|
|
for (int i = 0; i < subList.Count; i++)
|
|
{
|
|
if (GameMain.GameSession.OwnedSubmarines.Any(s => s.Name == subList[i].Name))
|
|
{
|
|
ownedSubmarineIndices.Add(i);
|
|
}
|
|
}
|
|
msg.WriteUInt16((ushort)ownedSubmarineIndices.Count);
|
|
foreach (int index in ownedSubmarineIndices)
|
|
{
|
|
msg.WriteUInt16((ushort)index);
|
|
}
|
|
}
|
|
if (requiredFlags.HasFlag(NetFlags.UpgradeManager))
|
|
{
|
|
msg.WriteUInt16(GetLastUpdateIdForFlag(NetFlags.UpgradeManager));
|
|
msg.WriteUInt16((ushort)UpgradeManager.PendingUpgrades.Count);
|
|
foreach (var (prefab, category, level) in UpgradeManager.PendingUpgrades)
|
|
{
|
|
msg.WriteIdentifier(prefab.Identifier);
|
|
msg.WriteIdentifier(category.Identifier);
|
|
msg.WriteByte((byte)level);
|
|
}
|
|
msg.WriteUInt16((ushort)UpgradeManager.PurchasedItemSwaps.Count);
|
|
foreach (var itemSwap in UpgradeManager.PurchasedItemSwaps)
|
|
{
|
|
msg.WriteUInt16(itemSwap.ItemToRemove.ID);
|
|
msg.WriteIdentifier(itemSwap.ItemToInstall?.Identifier ?? Identifier.Empty);
|
|
}
|
|
}
|
|
|
|
if (requiredFlags.HasFlag(NetFlags.ItemsInBuyCrate))
|
|
{
|
|
msg.WriteUInt16(GetLastUpdateIdForFlag(NetFlags.ItemsInBuyCrate));
|
|
WriteItems(msg, CargoManager.ItemsInBuyCrate);
|
|
WriteStores(msg);
|
|
}
|
|
|
|
if (requiredFlags.HasFlag(NetFlags.ItemsInSellFromSubCrate))
|
|
{
|
|
msg.WriteUInt16(GetLastUpdateIdForFlag(NetFlags.ItemsInSellFromSubCrate));
|
|
WriteItems(msg, CargoManager.ItemsInSellFromSubCrate);
|
|
WriteStores(msg);
|
|
}
|
|
|
|
if (requiredFlags.HasFlag(NetFlags.PurchasedItems))
|
|
{
|
|
msg.WriteUInt16(GetLastUpdateIdForFlag(NetFlags.PurchasedItems));
|
|
WriteItems(msg, CargoManager.PurchasedItems);
|
|
WriteStores(msg);
|
|
|
|
}
|
|
if (requiredFlags.HasFlag(NetFlags.SoldItems))
|
|
{
|
|
msg.WriteUInt16(GetLastUpdateIdForFlag(NetFlags.SoldItems));
|
|
WriteItems(msg, CargoManager.SoldItems);
|
|
WriteStores(msg);
|
|
}
|
|
if (requiredFlags.HasFlag(NetFlags.Reputation))
|
|
{
|
|
msg.WriteUInt16(GetLastUpdateIdForFlag(NetFlags.Reputation));
|
|
// hopefully we'll never have more than 128 factions
|
|
msg.WriteByte((byte)Factions.Count);
|
|
foreach (Faction faction in Factions)
|
|
{
|
|
msg.WriteIdentifier(faction.Prefab.Identifier);
|
|
msg.WriteSingle(faction.Reputation.Value);
|
|
}
|
|
}
|
|
if (requiredFlags.HasFlag(NetFlags.CharacterInfo))
|
|
{
|
|
msg.WriteUInt16(GetLastUpdateIdForFlag(NetFlags.CharacterInfo));
|
|
var characterData = GetClientCharacterData(c);
|
|
if (characterData?.CharacterInfo == null)
|
|
{
|
|
msg.WriteBoolean(false);
|
|
}
|
|
else
|
|
{
|
|
msg.WriteBoolean(true);
|
|
characterData.CharacterInfo.ServerWrite(msg);
|
|
}
|
|
}
|
|
|
|
void WriteStores(IWriteMessage msg)
|
|
{
|
|
if (map.CurrentLocation != null)
|
|
{
|
|
// Store balance
|
|
bool hasStores = map.CurrentLocation.Stores != null && map.CurrentLocation.Stores.Any();
|
|
msg.WriteBoolean(hasStores);
|
|
if (hasStores)
|
|
{
|
|
msg.WriteByte((byte)map.CurrentLocation.Stores.Count);
|
|
foreach (var store in map.CurrentLocation.Stores.Values)
|
|
{
|
|
msg.WriteIdentifier(store.Identifier);
|
|
msg.WriteUInt16((UInt16)store.Balance);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
msg.WriteByte((byte)0);
|
|
// Store balance
|
|
msg.WriteBoolean(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ServerRead(IReadMessage msg, Client sender)
|
|
{
|
|
UInt16 currentLocIndex = msg.ReadUInt16();
|
|
UInt16 selectedLocIndex = msg.ReadUInt16();
|
|
|
|
byte selectedMissionCount = msg.ReadByte();
|
|
List<int> selectedMissionIndices = new List<int>();
|
|
for (int i = 0; i < selectedMissionCount; i++)
|
|
{
|
|
selectedMissionIndices.Add(msg.ReadByte());
|
|
}
|
|
|
|
bool purchasedHullRepairs = msg.ReadBoolean();
|
|
bool purchasedItemRepairs = msg.ReadBoolean();
|
|
bool purchasedLostShuttles = msg.ReadBoolean();
|
|
|
|
var buyCrateItems = ReadPurchasedItems(msg, sender);
|
|
var subSellCrateItems = ReadPurchasedItems(msg, sender);
|
|
var purchasedItems = ReadPurchasedItems(msg, sender);
|
|
var soldItems = ReadSoldItems(msg);
|
|
|
|
ushort purchasedUpgradeCount = msg.ReadUInt16();
|
|
List<PurchasedUpgrade> purchasedUpgrades = new List<PurchasedUpgrade>();
|
|
for (int i = 0; i < purchasedUpgradeCount; i++)
|
|
{
|
|
Identifier upgradeIdentifier = msg.ReadIdentifier();
|
|
UpgradePrefab prefab = UpgradePrefab.Find(upgradeIdentifier);
|
|
|
|
Identifier categoryIdentifier = msg.ReadIdentifier();
|
|
UpgradeCategory category = UpgradeCategory.Find(categoryIdentifier);
|
|
|
|
int upgradeLevel = msg.ReadByte();
|
|
|
|
if (category == null || prefab == null) { continue; }
|
|
purchasedUpgrades.Add(new PurchasedUpgrade(prefab, category, upgradeLevel));
|
|
}
|
|
|
|
ushort purchasedItemSwapCount = msg.ReadUInt16();
|
|
List<PurchasedItemSwap> purchasedItemSwaps = new List<PurchasedItemSwap>();
|
|
for (int i = 0; i < purchasedItemSwapCount; i++)
|
|
{
|
|
UInt16 itemToRemoveID = msg.ReadUInt16();
|
|
Identifier itemToInstallIdentifier = msg.ReadIdentifier();
|
|
ItemPrefab itemToInstall = itemToInstallIdentifier.IsEmpty ? null : ItemPrefab.Find(string.Empty, itemToInstallIdentifier);
|
|
if (Entity.FindEntityByID(itemToRemoveID) is not Item itemToRemove) { continue; }
|
|
purchasedItemSwaps.Add(new PurchasedItemSwap(itemToRemove, itemToInstall));
|
|
}
|
|
|
|
if (purchasedUpgradeCount > 0 || purchasedItemSwapCount > 0)
|
|
{
|
|
//if the client attempted to purchase something, increment flag regardless of whether the upgrades were actually purchased or not
|
|
//so we can sync the correct state in case the client incorrectly assumed they can buy something (e.g. lost permissions just as they were purchasing)
|
|
IncrementLastUpdateIdForFlag(NetFlags.UpgradeManager);
|
|
}
|
|
|
|
int hullRepairCost = GetHullRepairCost();
|
|
int itemRepairCost = GetItemRepairCost();
|
|
int shuttleRetrieveCost = CampaignMode.ShuttleReplaceCost;
|
|
Location location = Map.CurrentLocation;
|
|
if (location != null)
|
|
{
|
|
hullRepairCost = location.GetAdjustedMechanicalCost(hullRepairCost);
|
|
itemRepairCost = location.GetAdjustedMechanicalCost(itemRepairCost);
|
|
shuttleRetrieveCost = location.GetAdjustedMechanicalCost(shuttleRetrieveCost);
|
|
}
|
|
|
|
Wallet personalWallet = GetWallet(sender);
|
|
personalWallet?.ForceUpdate();
|
|
if (AllowedToManageWallets(sender))
|
|
{
|
|
Bank.ForceUpdate();
|
|
}
|
|
|
|
if (purchasedHullRepairs && !PurchasedHullRepairs)
|
|
{
|
|
if (GetBalance(sender) >= hullRepairCost)
|
|
{
|
|
TryPurchase(sender, hullRepairCost);
|
|
PurchasedHullRepairs = true;
|
|
GameAnalyticsManager.AddMoneySpentEvent(hullRepairCost, GameAnalyticsManager.MoneySink.Service, "hullrepairs");
|
|
}
|
|
}
|
|
|
|
if (purchasedItemRepairs && !PurchasedItemRepairs)
|
|
{
|
|
if (GetBalance(sender) >= itemRepairCost)
|
|
{
|
|
TryPurchase(sender, itemRepairCost);
|
|
PurchasedItemRepairs = true;
|
|
GameAnalyticsManager.AddMoneySpentEvent(itemRepairCost, GameAnalyticsManager.MoneySink.Service, "devicerepairs");
|
|
}
|
|
}
|
|
|
|
if (purchasedLostShuttles && !PurchasedLostShuttles)
|
|
{
|
|
if (GameMain.GameSession?.SubmarineInfo != null && GameMain.GameSession.SubmarineInfo.LeftBehindSubDockingPortOccupied)
|
|
{
|
|
GameMain.Server.SendDirectChatMessage(TextManager.FormatServerMessage("ReplaceShuttleDockingPortOccupied"), sender, ChatMessageType.MessageBox);
|
|
}
|
|
else if (TryPurchase(sender, shuttleRetrieveCost))
|
|
{
|
|
PurchasedLostShuttles = true;
|
|
GameAnalyticsManager.AddMoneySpentEvent(shuttleRetrieveCost, GameAnalyticsManager.MoneySink.Service, "retrieveshuttle");
|
|
}
|
|
}
|
|
|
|
if (currentLocIndex < Map.Locations.Count && Map.AllowDebugTeleport)
|
|
{
|
|
Map.SetLocation(currentLocIndex);
|
|
}
|
|
|
|
if (AllowedToManageCampaign(sender, ClientPermissions.ManageMap))
|
|
{
|
|
Map.SelectLocation(selectedLocIndex == UInt16.MaxValue ? -1 : selectedLocIndex);
|
|
if (Map.SelectedLocation == null) { Map.SelectRandomLocation(preferUndiscovered: true); }
|
|
if (Map.SelectedConnection != null) { Map.SelectMission(selectedMissionIndices); }
|
|
CheckTooManyMissions(Map.CurrentLocation, sender);
|
|
}
|
|
|
|
var prevBuyCrateItems = new Dictionary<Identifier, List<PurchasedItem>>();
|
|
foreach (var kvp in CargoManager.ItemsInBuyCrate)
|
|
{
|
|
prevBuyCrateItems.Add(kvp.Key, new List<PurchasedItem>(kvp.Value));
|
|
}
|
|
foreach (var store in prevBuyCrateItems)
|
|
{
|
|
foreach (var item in store.Value.ToList())
|
|
{
|
|
CargoManager.ModifyItemQuantityInBuyCrate(store.Key, item.ItemPrefab, -item.Quantity, sender);
|
|
}
|
|
}
|
|
foreach (var store in buyCrateItems)
|
|
{
|
|
foreach (var item in store.Value.ToList())
|
|
{
|
|
if (map?.CurrentLocation?.Stores == null || !map.CurrentLocation.Stores.ContainsKey(store.Key)) { continue; }
|
|
int availableQuantity = map.CurrentLocation.Stores[store.Key].Stock.Find(s => s.ItemPrefab == item.ItemPrefab)?.Quantity ?? 0;
|
|
int alreadyPurchasedQuantity =
|
|
CargoManager.GetBuyCrateItem(store.Key, item.ItemPrefab)?.Quantity ?? 0 +
|
|
CargoManager.GetPurchasedItemCount(store.Key, item.ItemPrefab);
|
|
item.Quantity = MathHelper.Clamp(item.Quantity, 0, availableQuantity - alreadyPurchasedQuantity);
|
|
CargoManager.ModifyItemQuantityInBuyCrate(store.Key, item.ItemPrefab, item.Quantity, sender);
|
|
}
|
|
}
|
|
|
|
var prevPurchasedItems = new Dictionary<Identifier, List<PurchasedItem>>();
|
|
foreach (var kvp in CargoManager.PurchasedItems)
|
|
{
|
|
prevPurchasedItems.Add(kvp.Key, new List<PurchasedItem>(kvp.Value));
|
|
}
|
|
|
|
foreach (var storeId in purchasedItems.Keys)
|
|
{
|
|
DebugConsole.Log($"Purchased items ({storeId}):\n");
|
|
if (prevPurchasedItems.TryGetValue(storeId, out var alreadyPurchased))
|
|
{
|
|
var delivered = alreadyPurchased.Where(it => it.Delivered);
|
|
var notDelivered = alreadyPurchased.Where(it => !it.Delivered);
|
|
if (delivered.Any())
|
|
{
|
|
DebugConsole.Log($" Already delivered:\n" + string.Concat(delivered.Select(it => $" - {it.ItemPrefab.Name} (x{it.Quantity})")));
|
|
}
|
|
if (notDelivered.Any())
|
|
{
|
|
DebugConsole.Log($" Already purchased:\n" + string.Concat(notDelivered.Where(it => !it.Delivered).Select(it => $" - {it.ItemPrefab.Name} (x{it.Quantity})")));
|
|
}
|
|
}
|
|
DebugConsole.Log($" New purchases:");
|
|
foreach (var purchasedItem in purchasedItems[storeId])
|
|
{
|
|
if (purchasedItem.Delivered) { continue; }
|
|
int quantity = purchasedItem.Quantity;
|
|
if (alreadyPurchased != null)
|
|
{
|
|
quantity -= alreadyPurchased.Where(it => it.DeliverImmediately == purchasedItem.DeliverImmediately && it.ItemPrefab == purchasedItem.ItemPrefab).Sum(it => it.Quantity);
|
|
}
|
|
if (quantity > 0)
|
|
{
|
|
DebugConsole.Log($" - {purchasedItem.ItemPrefab.Name} (x{quantity})");
|
|
}
|
|
}
|
|
}
|
|
foreach (var storeId in soldItems.Keys)
|
|
{
|
|
DebugConsole.Log($"Sold items:\n" + string.Concat(soldItems[storeId].Select(it => $" - {it.ItemPrefab.Name}")));
|
|
}
|
|
|
|
foreach (var kvp in purchasedItems)
|
|
{
|
|
var storeId = kvp.Key;
|
|
var purchasedItemList = kvp.Value;
|
|
foreach (var purchasedItem in purchasedItemList)
|
|
{
|
|
int desiredQuantity = purchasedItem.Quantity;
|
|
if (prevPurchasedItems.TryGetValue(storeId, out var alreadyPurchasedList) &&
|
|
alreadyPurchasedList.FirstOrDefault(p => p.ItemPrefab == purchasedItem.ItemPrefab && p.DeliverImmediately == purchasedItem.DeliverImmediately) is { } alreadyPurchased)
|
|
{
|
|
desiredQuantity -= alreadyPurchased.Quantity;
|
|
}
|
|
int availableQuantity = map.CurrentLocation.Stores[storeId].Stock.Find(s => s.ItemPrefab == purchasedItem.ItemPrefab)?.Quantity ?? 0;
|
|
purchasedItem.Quantity = Math.Min(desiredQuantity, availableQuantity);
|
|
}
|
|
CargoManager.PurchaseItems(storeId, purchasedItemList, removeFromCrate: false, client: sender);
|
|
}
|
|
|
|
foreach (var (storeIdentifier, items) in CargoManager.PurchasedItems)
|
|
{
|
|
if (!prevPurchasedItems.ContainsKey(storeIdentifier))
|
|
{
|
|
CargoManager.LogNewItemPurchases(storeIdentifier, items, sender);
|
|
continue;
|
|
}
|
|
|
|
List<PurchasedItem> newItems = new List<PurchasedItem>();
|
|
List<PurchasedItem> prevItems = prevPurchasedItems[storeIdentifier];
|
|
|
|
foreach (PurchasedItem item in items)
|
|
{
|
|
PurchasedItem matching = prevItems.FirstOrDefault(ppi => ppi.ItemPrefab == item.ItemPrefab);
|
|
if (matching is null)
|
|
{
|
|
newItems.Add(item);
|
|
continue;
|
|
}
|
|
if (matching.Quantity < item.Quantity)
|
|
{
|
|
newItems.Add(new PurchasedItem(item.ItemPrefab, item.Quantity - matching.Quantity, sender));
|
|
}
|
|
}
|
|
|
|
if (newItems.Any())
|
|
{
|
|
CargoManager.LogNewItemPurchases(storeIdentifier, newItems, sender);
|
|
}
|
|
}
|
|
|
|
|
|
bool allowedToSellSubItems = AllowedToManageCampaign(sender, ClientPermissions.SellSubItems);
|
|
if (allowedToSellSubItems)
|
|
{
|
|
var prevSubSellCrateItems = new Dictionary<Identifier, List<PurchasedItem>>(CargoManager.ItemsInSellFromSubCrate);
|
|
foreach (var store in prevSubSellCrateItems)
|
|
{
|
|
foreach (var item in store.Value.ToList())
|
|
{
|
|
CargoManager.ModifyItemQuantityInSubSellCrate(store.Key, item.ItemPrefab, -item.Quantity, sender);
|
|
}
|
|
}
|
|
foreach (var store in subSellCrateItems)
|
|
{
|
|
foreach (var item in store.Value.ToList())
|
|
{
|
|
CargoManager.ModifyItemQuantityInSubSellCrate(store.Key, item.ItemPrefab, item.Quantity, sender);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool allowedToSellInventoryItems = AllowedToManageCampaign(sender, ClientPermissions.SellInventoryItems);
|
|
if (allowedToSellInventoryItems && allowedToSellSubItems)
|
|
{
|
|
// for some reason CargoManager.SoldItem is never cleared by the server, I've added a check to SellItems that ignores all
|
|
// sold items that are removed so they should be discarded on the next message
|
|
var prevSoldItems = new Dictionary<Identifier, List<SoldItem>>(CargoManager.SoldItems);
|
|
foreach (var store in prevSoldItems)
|
|
{
|
|
CargoManager.BuyBackSoldItems(store.Key, store.Value.ToList(), sender);
|
|
}
|
|
foreach (var store in soldItems)
|
|
{
|
|
CargoManager.SellItems(store.Key, store.Value.ToList(), sender);
|
|
}
|
|
}
|
|
else if (allowedToSellInventoryItems || allowedToSellSubItems)
|
|
{
|
|
var prevSoldItems = new Dictionary<Identifier, List<SoldItem>>(CargoManager.SoldItems);
|
|
foreach (var store in prevSoldItems)
|
|
{
|
|
store.Value.RemoveAll(predicate);
|
|
CargoManager.BuyBackSoldItems(store.Key, store.Value.ToList(), sender);
|
|
}
|
|
foreach (var store in soldItems)
|
|
{
|
|
store.Value.RemoveAll(predicate);
|
|
}
|
|
foreach (var store in soldItems)
|
|
{
|
|
CargoManager.SellItems(store.Key, store.Value.ToList(), sender);
|
|
}
|
|
bool predicate(SoldItem i) => allowedToSellInventoryItems != (i.Origin == SoldItem.SellOrigin.Character);
|
|
}
|
|
|
|
var characterList = GameSession.GetSessionCrewCharacters(CharacterType.Both);
|
|
foreach (var (prefab, category, _) in purchasedUpgrades)
|
|
{
|
|
UpgradeManager.TryPurchaseUpgrade(prefab, category, client: sender);
|
|
|
|
// unstable logging
|
|
int price = prefab.Price.GetBuyPrice(prefab, UpgradeManager.GetUpgradeLevel(prefab, category), Map?.CurrentLocation, characterList);
|
|
int level = UpgradeManager.GetUpgradeLevel(prefab, category);
|
|
GameServer.Log($"SERVER: Purchased level {level} {category.Identifier}.{prefab.Identifier} for {price}", ServerLog.MessageType.ServerMessage);
|
|
}
|
|
foreach (var purchasedItemSwap in purchasedItemSwaps)
|
|
{
|
|
if (purchasedItemSwap.ItemToInstall == null)
|
|
{
|
|
UpgradeManager.CancelItemSwap(purchasedItemSwap.ItemToRemove, client: sender);
|
|
}
|
|
else
|
|
{
|
|
UpgradeManager.PurchaseItemSwap(purchasedItemSwap.ItemToRemove, purchasedItemSwap.ItemToInstall, client: sender);
|
|
}
|
|
}
|
|
foreach (Item item in Item.ItemList)
|
|
{
|
|
if (item.PendingItemSwap != null && !purchasedItemSwaps.Any(it => it.ItemToRemove == item))
|
|
{
|
|
UpgradeManager.CancelItemSwap(item);
|
|
item.PendingItemSwap = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ServerReadMoney(IReadMessage msg, Client sender)
|
|
{
|
|
NetWalletTransfer transfer = INetSerializableStruct.Read<NetWalletTransfer>(msg);
|
|
|
|
if (GameMain.Server is null) { return; }
|
|
|
|
if (transfer.Sender.TryUnwrap(out var id))
|
|
{
|
|
if (id != sender.CharacterID && !AllowedToManageWallets(sender)) { return; }
|
|
|
|
Wallet wallet = GetWalletByID(id);
|
|
if (wallet is InvalidWallet) { return; }
|
|
|
|
TransferMoney(wallet);
|
|
}
|
|
else
|
|
{
|
|
if (!AllowedToManageWallets(sender))
|
|
{
|
|
if (transfer.Receiver.TryUnwrap(out var receiverId) && receiverId == sender.CharacterID)
|
|
{
|
|
if (transfer.Amount > GameMain.Server.ServerSettings.MaximumMoneyTransferRequest) { return; }
|
|
GameMain.Server.Voting.StartTransferVote(sender, null, transfer.Amount, sender);
|
|
GameServer.Log($"{sender.Name} started a vote to transfer {transfer.Amount} mk from the bank.", ServerLog.MessageType.Money);
|
|
}
|
|
return;
|
|
}
|
|
|
|
TransferMoney(Bank);
|
|
}
|
|
|
|
void TransferMoney(Wallet from)
|
|
{
|
|
if (!from.TryDeduct(transfer.Amount)) { return; }
|
|
|
|
if (transfer.Receiver.TryUnwrap(out var id))
|
|
{
|
|
Wallet wallet = GetWalletByID(id);
|
|
if (wallet is InvalidWallet) { return; }
|
|
|
|
wallet.Give(transfer.Amount);
|
|
GameServer.Log($"{sender.Name} transferred {transfer.Amount} mk to {wallet.GetOwnerLogName()} from {from.GetOwnerLogName()}.", ServerLog.MessageType.Money);
|
|
}
|
|
else
|
|
{
|
|
Bank.Give(transfer.Amount);
|
|
GameServer.Log($"{sender.Name} transferred {transfer.Amount} mk to {Bank.GetOwnerLogName()} from {from.GetOwnerLogName()}.", ServerLog.MessageType.Money);
|
|
}
|
|
}
|
|
|
|
Wallet GetWalletByID(ushort id)
|
|
{
|
|
Character targetCharacter = Character.CharacterList.FirstOrDefault(c => c.ID == id);
|
|
return targetCharacter is null ? Wallet.Invalid : targetCharacter.Wallet;
|
|
}
|
|
}
|
|
|
|
public void ServerReadRewardDistribution(IReadMessage msg, Client sender)
|
|
{
|
|
NetWalletSetSalaryUpdate update = INetSerializableStruct.Read<NetWalletSetSalaryUpdate>(msg);
|
|
|
|
if (!AllowedToManageWallets(sender)) { return; }
|
|
|
|
if (update.Target.TryUnwrap(out ushort id))
|
|
{
|
|
Character targetCharacter = Character.CharacterList.FirstOrDefault(c => c.ID == id);
|
|
targetCharacter?.Wallet.SetRewardDistribution(update.NewRewardDistribution);
|
|
GameServer.Log($"{sender.Name} changed the salary of {targetCharacter?.Name} to {update.NewRewardDistribution}%.", ServerLog.MessageType.Money);
|
|
return;
|
|
}
|
|
|
|
Bank.SetRewardDistribution(update.NewRewardDistribution);
|
|
GameServer.Log($"{sender.Name} changed the default salary to {update.NewRewardDistribution}%.", ServerLog.MessageType.Money);
|
|
}
|
|
|
|
public void ResetSalaries(Client sender)
|
|
{
|
|
if (!AllowedToManageWallets(sender)) { return; }
|
|
|
|
foreach (Character character in GameSession.GetSessionCrewCharacters(CharacterType.Player))
|
|
{
|
|
character.Wallet.SetRewardDistribution(Bank.RewardDistribution);
|
|
}
|
|
}
|
|
|
|
public void ServerReadCrew(IReadMessage msg, Client sender)
|
|
{
|
|
UInt16[] pendingHires = null;
|
|
bool[] pendingToReserveBench = null;
|
|
Dictionary<int, BotStatus> existingBotsClient = null;
|
|
|
|
bool updatePending = msg.ReadBoolean();
|
|
if (updatePending)
|
|
{
|
|
ushort pendingHireLength = msg.ReadUInt16();
|
|
pendingHires = new UInt16[pendingHireLength];
|
|
pendingToReserveBench = new bool[pendingHireLength];
|
|
for (int i = 0; i < pendingHireLength; i++)
|
|
{
|
|
pendingHires[i] = msg.ReadUInt16();
|
|
pendingToReserveBench[i] = msg.ReadBoolean();
|
|
}
|
|
}
|
|
|
|
bool validateHires = msg.ReadBoolean();
|
|
|
|
bool renameCharacter = msg.ReadBoolean();
|
|
UInt16 renamedIdentifier = 0;
|
|
string newName = null;
|
|
bool existingCrewMember = false;
|
|
if (renameCharacter)
|
|
{
|
|
renamedIdentifier = msg.ReadUInt16();
|
|
newName = Client.SanitizeName(msg.ReadString());
|
|
existingCrewMember = msg.ReadBoolean();
|
|
if (!GameMain.Server.IsNameValid(sender, newName, clientRenamingSelf: renamedIdentifier == sender.CharacterInfo?.ID))
|
|
{
|
|
renameCharacter = false;
|
|
}
|
|
}
|
|
|
|
bool fireCharacter = msg.ReadBoolean();
|
|
int firedIdentifier = -1;
|
|
if (fireCharacter) { firedIdentifier = msg.ReadUInt16(); }
|
|
|
|
Location location = map?.CurrentLocation;
|
|
CharacterInfo firedCharacter = null;
|
|
(ushort id, string newName) appliedRename = (Entity.NullEntityID, string.Empty);
|
|
|
|
if (location != null)
|
|
{
|
|
if (fireCharacter && AllowedToManageCampaign(sender, ClientPermissions.ManageHires))
|
|
{
|
|
firedCharacter = CrewManager.GetCharacterInfos(includeReserveBench: true).FirstOrDefault(info => info.ID == firedIdentifier);
|
|
if (firedCharacter != null && (firedCharacter.Character?.IsBot ?? true))
|
|
{
|
|
CrewManager.FireCharacter(firedCharacter);
|
|
}
|
|
else
|
|
{
|
|
DebugConsole.ThrowError($"Tried to fire an invalid character ({firedIdentifier})");
|
|
}
|
|
}
|
|
|
|
if (renameCharacter)
|
|
{
|
|
CharacterInfo characterInfo = null;
|
|
if (AllowedToManageCampaign(sender, ClientPermissions.ManageHires))
|
|
{
|
|
if (existingCrewMember && CrewManager != null)
|
|
{
|
|
characterInfo = CrewManager.GetCharacterInfos(includeReserveBench: true).FirstOrDefault(info => info.ID == renamedIdentifier);
|
|
}
|
|
else if (!existingCrewMember && location.HireManager != null)
|
|
{
|
|
characterInfo = location.HireManager.AvailableCharacters.FirstOrDefault(info => info.ID == renamedIdentifier);
|
|
}
|
|
}
|
|
if (characterInfo == null && renamedIdentifier == sender.CharacterInfo?.ID)
|
|
{
|
|
characterInfo = sender.CharacterInfo;
|
|
}
|
|
if (characterInfo != null &&
|
|
(characterInfo.Character == null || characterInfo.Character is { IsBot: true } || (characterInfo.RenamingEnabled && characterInfo == sender.CharacterInfo)))
|
|
{
|
|
GameServer.Log($"{sender.Name} renamed the character \"{characterInfo.Name}\" as \"{newName}\".", ServerLog.MessageType.ServerMessage);
|
|
if (existingCrewMember)
|
|
{
|
|
CrewManager.RenameCharacter(characterInfo, newName);
|
|
if (characterInfo == sender.CharacterInfo)
|
|
{
|
|
//renaming is only allowed once
|
|
characterInfo.RenamingEnabled = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
location.HireManager.RenameCharacter(characterInfo, newName);
|
|
}
|
|
appliedRename = (characterInfo.ID, newName);
|
|
}
|
|
else
|
|
{
|
|
string errorMsg = $"Tried to rename an invalid character ({renamedIdentifier}, {characterInfo?.Name ?? "null"})";
|
|
DebugConsole.ThrowError(errorMsg);
|
|
GameMain.Server?.SendConsoleMessage(errorMsg, sender, Color.Red);
|
|
}
|
|
}
|
|
|
|
if (location.HireManager != null)
|
|
{
|
|
if (validateHires)
|
|
{
|
|
foreach (CharacterInfo hireInfo in location.HireManager.PendingHires)
|
|
{
|
|
TryHireCharacter(location, hireInfo, client: sender);
|
|
}
|
|
}
|
|
|
|
if (updatePending)
|
|
{
|
|
List<CharacterInfo> pendingHireInfos = new List<CharacterInfo>();
|
|
int i = 0;
|
|
foreach (UInt16 identifier in pendingHires)
|
|
{
|
|
CharacterInfo match = location.GetHireableCharacters().FirstOrDefault(info => info.ID == identifier);
|
|
if (match == null)
|
|
{
|
|
DebugConsole.ThrowError($"Tried to add a character that doesn't exist ({identifier}) to pending hires");
|
|
continue;
|
|
}
|
|
|
|
match.BotStatus = pendingToReserveBench[i++] ? BotStatus.PendingHireToReserveBench : BotStatus.PendingHireToActiveService;
|
|
if (match.BotStatus == BotStatus.PendingHireToActiveService)
|
|
{
|
|
//can't add more bots to active service is max has been reached
|
|
if (pendingHireInfos.Count(ci => ci.BotStatus == BotStatus.PendingHireToActiveService) + CrewManager.GetCharacterInfos().Count() >= CrewManager.MaxCrewSize) { continue; }
|
|
}
|
|
|
|
pendingHireInfos.Add(match);
|
|
}
|
|
location.HireManager.PendingHires = pendingHireInfos;
|
|
}
|
|
|
|
location.HireManager.AvailableCharacters.ForEachMod(info =>
|
|
{
|
|
if (!location.HireManager.PendingHires.Contains(info))
|
|
{
|
|
location.HireManager.RenameCharacter(info, info.OriginalName);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
// bounce back
|
|
if (renameCharacter && existingCrewMember)
|
|
{
|
|
SendCrewState(appliedRename, firedCharacter);
|
|
}
|
|
else
|
|
{
|
|
SendCrewState(firedCharacter: firedCharacter);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Notifies the clients of the current bot situation like syncing pending and available hires
|
|
/// </summary>
|
|
/// <param name="hiredCharacters">Inform the clients that these characters have been hired.</param>
|
|
/// <param name="firedCharacter">Inform the clients that this character has been fired.</param>
|
|
/// <remarks>
|
|
/// It might be obsolete to sync available hires. I found that the available hires are always the same between
|
|
/// the client and the server when there's only one person on the server but when a second person joins both of
|
|
/// their available hires are different from the server.
|
|
/// </remarks>
|
|
public void SendCrewState((ushort id, string newName) renamedCrewMember = default, CharacterInfo firedCharacter = null, bool createNotification = true)
|
|
{
|
|
List<CharacterInfo> availableHires = new List<CharacterInfo>();
|
|
List<CharacterInfo> pendingHires = new List<CharacterInfo>();
|
|
|
|
if (map.CurrentLocation != null && map.CurrentLocation.Type.HasHireableCharacters)
|
|
{
|
|
availableHires = map.CurrentLocation.GetHireableCharacters().ToList();
|
|
pendingHires = map.CurrentLocation?.HireManager.PendingHires;
|
|
}
|
|
|
|
foreach (Client client in GameMain.Server.ConnectedClients)
|
|
{
|
|
IWriteMessage msg = new WriteOnlyMessage();
|
|
msg.WriteByte((byte)ServerPacketHeader.CREW);
|
|
|
|
msg.WriteBoolean(createNotification);
|
|
|
|
msg.WriteUInt16((ushort)availableHires.Count);
|
|
foreach (CharacterInfo hire in availableHires)
|
|
{
|
|
hire.ServerWrite(msg);
|
|
msg.WriteInt32(hire.Salary);
|
|
}
|
|
|
|
msg.WriteUInt16((ushort)pendingHires.Count);
|
|
foreach (CharacterInfo pendingHire in pendingHires)
|
|
{
|
|
msg.WriteUInt16(pendingHire.ID);
|
|
msg.WriteBoolean(pendingHire.BotStatus == BotStatus.PendingHireToReserveBench);
|
|
}
|
|
|
|
var crewManager = CrewManager.GetCharacterInfos();
|
|
msg.WriteUInt16((ushort)crewManager.Count());
|
|
foreach (CharacterInfo info in crewManager)
|
|
{
|
|
info.ServerWrite(msg);
|
|
}
|
|
|
|
var reserveBench = CrewManager.GetReserveBenchInfos();
|
|
msg.WriteUInt16((ushort)reserveBench.Count());
|
|
foreach (CharacterInfo info in reserveBench)
|
|
{
|
|
info.ServerWrite(msg);
|
|
}
|
|
|
|
bool validRenaming = renamedCrewMember.id > 0 && !string.IsNullOrEmpty(renamedCrewMember.newName);
|
|
msg.WriteBoolean(validRenaming);
|
|
if (validRenaming)
|
|
{
|
|
msg.WriteUInt16(renamedCrewMember.id);
|
|
msg.WriteString(renamedCrewMember.newName);
|
|
}
|
|
|
|
msg.WriteBoolean(firedCharacter != null);
|
|
if (firedCharacter != null) { msg.WriteUInt16(firedCharacter.ID); }
|
|
|
|
GameMain.Server.ServerPeer.Send(msg, client.Connection, DeliveryMethod.Reliable);
|
|
}
|
|
}
|
|
|
|
public override bool TryPurchase(Client client, int price)
|
|
{
|
|
//disconnected clients can never purchase anything
|
|
//(can happen e.g. if someone starts a vote to buy something and then disconnects)
|
|
if (client != null && !GameMain.Server.ConnectedClients.Contains(client)) { return false; }
|
|
|
|
if (price == 0) { return true; }
|
|
|
|
Wallet wallet = GetWallet(client);
|
|
if (!AllowedToManageWallets(client))
|
|
{
|
|
return wallet.TryDeduct(price);
|
|
}
|
|
|
|
int balance = wallet.Balance;
|
|
|
|
if (balance >= price)
|
|
{
|
|
return wallet.TryDeduct(price);
|
|
}
|
|
|
|
if (balance + Bank.Balance >= price)
|
|
{
|
|
int remainder = price - balance;
|
|
if (balance > 0) { wallet.Deduct(balance); }
|
|
Bank.Deduct(remainder);
|
|
return true ;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public override int GetBalance(Client client = null)
|
|
{
|
|
if (client is null) { return 0; }
|
|
|
|
Wallet wallet = GetWallet(client);
|
|
if (!AllowedToManageWallets(client))
|
|
{
|
|
return wallet.Balance;
|
|
}
|
|
|
|
return wallet.Balance + Bank.Balance;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Serializes the campaign and character data to XML.
|
|
/// </summary>
|
|
/// <param name="element">Game session element to save the campaign data to.</param>
|
|
/// <param name="isSavingOnLoading">
|
|
/// Whether the save is being done during loading to ensure the campaign ID matches the one in the save file.
|
|
/// Used to work around some quirks with the backup save system.
|
|
/// See: <see cref="SaveUtil.SaveGame(CampaignDataPath,bool)"/>
|
|
/// </param>
|
|
public override void Save(XElement element, bool isSavingOnLoading)
|
|
{
|
|
element.Add(new XAttribute("campaignid", CampaignID));
|
|
XElement modeElement = new XElement("MultiPlayerCampaign",
|
|
new XAttribute("purchasedlostshuttles", PurchasedLostShuttlesInLatestSave),
|
|
new XAttribute("purchasedhullrepairs", PurchasedHullRepairsInLatestSave),
|
|
new XAttribute("purchaseditemrepairs", PurchasedItemRepairsInLatestSave),
|
|
new XAttribute("cheatsenabled", CheatsEnabled));
|
|
|
|
DebugConsole.NewMessage("Saved PurchasedHullRepairs: "+ PurchasedHullRepairs+" (in last save "+PurchasedHullRepairsInLatestSave+")", Color.Magenta);
|
|
|
|
modeElement.Add(Settings.Save());
|
|
modeElement.Add(SaveStats());
|
|
if (GameMain.Server?.TraitorManager is TraitorManager traitorManager)
|
|
{
|
|
modeElement.Add(traitorManager.Save());
|
|
}
|
|
modeElement.Add(Bank.Save());
|
|
|
|
if (GameMain.GameSession?.EventManager != null)
|
|
{
|
|
modeElement.Add(GameMain.GameSession?.EventManager.Save());
|
|
}
|
|
|
|
foreach ((CharacterTeamType team, Identifier unlockedRecipe) in GameMain.GameSession.UnlockedRecipes)
|
|
{
|
|
modeElement.Add(
|
|
new XElement("unlockedrecipe",
|
|
new XAttribute("identifier", unlockedRecipe),
|
|
new XAttribute("team", team)));
|
|
}
|
|
|
|
CampaignMetadata?.Save(modeElement);
|
|
Map.Save(modeElement);
|
|
CargoManager?.SavePurchasedItems(modeElement);
|
|
UpgradeManager?.Save(modeElement);
|
|
|
|
if (petsElement != null)
|
|
{
|
|
modeElement.Add(petsElement);
|
|
}
|
|
|
|
// save bots
|
|
var crewManagerElement = CrewManager.SaveMultiplayer(modeElement);
|
|
if (ActiveOrdersElement != null)
|
|
{
|
|
crewManagerElement.Add(ActiveOrdersElement);
|
|
}
|
|
|
|
XElement savedExperiencePointsElement = new XElement("SavedExperiencePoints");
|
|
foreach (var savedExperiencePoint in savedExperiencePoints)
|
|
{
|
|
savedExperiencePointsElement.Add(new XElement("Point",
|
|
new XAttribute("accountid", savedExperiencePoint.AccountId.TryUnwrap(out var accountId) ? accountId.StringRepresentation : ""),
|
|
new XAttribute("address", savedExperiencePoint.Address.StringRepresentation),
|
|
new XAttribute("points", savedExperiencePoint.ExperiencePoints)));
|
|
}
|
|
|
|
element.Add(modeElement);
|
|
|
|
// save character data to a separate file
|
|
|
|
// When loading a campaign in multiplayer, we save the campaign to ensure the campaign ID that gets assigned
|
|
// matches the one in the save file, this is a problem with the backup save system since this causes the
|
|
// character data to save too, and we don't want to overwrite the main save file's character data.
|
|
// So we instead save over the load path in this case, which in backup saves is the backup file
|
|
// which we don't mind getting overriden since the data should be the same
|
|
string characterDataPath = isSavingOnLoading
|
|
? GetCharacterDataPathForLoading()
|
|
: GetCharacterDataPathForSaving();
|
|
XDocument characterDataDoc = new XDocument(new XElement("CharacterData"));
|
|
foreach (CharacterCampaignData cd in characterData)
|
|
{
|
|
characterDataDoc.Root.Add(cd.Save());
|
|
}
|
|
try
|
|
{
|
|
SaveUtil.DeleteIfExists(characterDataPath);
|
|
characterDataDoc.SaveSafe(characterDataPath);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
DebugConsole.ThrowError("Saving multiplayer campaign characters to \"" + characterDataPath + "\" failed!", e);
|
|
}
|
|
|
|
lastSaveID++;
|
|
DebugConsole.Log("Campaign saved, save ID " + lastSaveID);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Load the current character save file and add/replace a single character's data with a new version immediately.
|
|
/// </summary>
|
|
/// <param name="newData">New character to insert. If it matches one existing in the save, that will get replaced.</param>
|
|
/// <param name="skipBackup">By default, replaced characters will be temporarily backed up, but that might be unwanted
|
|
/// eg. when using this method to save a character itself restored from the backup.</param>
|
|
public void SaveSingleCharacter(CharacterCampaignData newData, bool skipBackup = false)
|
|
{
|
|
string characterDataPath = GetCharacterDataPathForSaving();
|
|
if (!File.Exists(characterDataPath))
|
|
{
|
|
DebugConsole.ThrowError($"Failed to load the character data for the campaign. Could not find the file \"{characterDataPath}\".");
|
|
}
|
|
else
|
|
{
|
|
var loadedCharacterData = XMLExtensions.TryLoadXml(characterDataPath);
|
|
if (loadedCharacterData?.Root == null) { return; }
|
|
var oldData = loadedCharacterData.Root.Elements()
|
|
.FirstOrDefault(subElement => new CharacterCampaignData(subElement).IsDuplicate(newData));
|
|
|
|
if (oldData != null)
|
|
{
|
|
if (!skipBackup)
|
|
{
|
|
replacedCharacterDataBackup.Add(new CharacterCampaignData(oldData));
|
|
}
|
|
oldData.Remove();
|
|
}
|
|
loadedCharacterData.Root.Add(newData.Save());
|
|
|
|
try
|
|
{
|
|
loadedCharacterData.SaveSafe(characterDataPath);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
DebugConsole.ThrowError("Saving multiplayer campaign characters to \"" + characterDataPath + "\" failed!", e);
|
|
}
|
|
}
|
|
}
|
|
|
|
public CharacterCampaignData RestoreSingleCharacterFromBackup(Client client)
|
|
{
|
|
if (replacedCharacterDataBackup.Find(cd => cd.MatchesClient(client)) is CharacterCampaignData characterToRestore)
|
|
{
|
|
replacedCharacterDataBackup.Remove(characterToRestore);
|
|
return characterToRestore;
|
|
}
|
|
|
|
return default;
|
|
}
|
|
}
|
|
}
|