public static Vector2 CalcSize(MyObjectBuilder_Checkpoint checkpoint)
{
float width = checkpoint == null ? 0.9f : 0.65f;
float height = checkpoint == null ? 0.97f : 0.95f;
return(new Vector2(width, height));
}
private void PrepareComponents(MyObjectBuilder_Checkpoint checkpoint)
{
ScriptManager.Init(checkpoint.ScriptManagerData);
MyDefinitionManager.Static.LoadData(checkpoint.Mods);
LoadGameDefinition(checkpoint);
if (!MyDefinitionManager.Static.TryGetDefinition <MyScenarioDefinition>(checkpoint.Scenario, out Static.Scenario))
{
Static.Scenario = MyDefinitionManager.Static.GetScenarioDefinitions().FirstOrDefault();
}
FixIncorrectSettings(Static.Settings);
Static.WorldBoundaries = checkpoint.WorldBoundaries;
// Use whatever setting is in scenario if there was nothing in the file (0 min and max).
// SE scenarios have nothing while ME scenarios have size defined.
if (Static.WorldBoundaries.Min == Vector3D.Zero &&
Static.WorldBoundaries.Max == Vector3D.Zero)
{
Static.WorldBoundaries = Static.Scenario.WorldBoundaries;
}
LoadDataComponents();
LoadObjectBuildersComponents(checkpoint.SessionComponents);
}
public virtual void FixSessionComponentObjectBuilders(MyObjectBuilder_Checkpoint checkpoint, MyObjectBuilder_Sector sector)
{
if (checkpoint.ScriptManagerData == null)
{
checkpoint.ScriptManagerData = (MyObjectBuilder_ScriptManager)checkpoint.SessionComponents.FirstOrDefault(x => x is MyObjectBuilder_ScriptManager);
}
}
#pragma warning restore 649
private void DoLoadSession(string sessionPath)
{
if (!Path.IsPathRooted(sessionPath))
{
sessionPath = Path.Combine(MyFileSystem.SavesPath, sessionPath);
}
if (!Sandbox.Engine.Platform.Game.IsDedicated)
{
MySessionLoader.LoadSingleplayerSession(sessionPath);
return;
}
ulong checkpointSize;
MyObjectBuilder_Checkpoint checkpoint = MyLocalCache.LoadCheckpoint(sessionPath, out checkpointSize);
if (MySession.IsCompatibleVersion(checkpoint))
{
if (MySteamWorkshop.DownloadWorldModsBlocking(checkpoint.Mods).Success)
{
// MySpaceAnalytics.Instance.SetEntry(MyGameEntryEnum.Load);
MySession.Load(sessionPath, checkpoint, checkpointSize);
_hostServerForSession(MySession.Static, MyMultiplayer.Static);
}
else
{
MyLog.Default.WriteLineAndConsole("Unable to download mods");
}
}
else
{
MyLog.Default.WriteLineAndConsole(MyTexts.Get(MyCommonTexts.DialogTextIncompatibleWorldVersion)
.ToString());
}
}
private void saveConfigButton_Click(object sender, EventArgs e)
{
SaveConfiguration();
if (!string.IsNullOrEmpty(MySandboxGame.ConfigDedicated.LoadWorld) && !MySandboxGame.ConfigDedicated.SessionSettings.Battle)
{
ulong sizeInBytes;
var path = MySandboxGame.ConfigDedicated.LoadWorld;
MyObjectBuilder_Checkpoint checkpoint = MyLocalCache.LoadCheckpoint(path, out sizeInBytes);
if (!string.IsNullOrWhiteSpace(MySandboxGame.ConfigDedicated.WorldName))
{
checkpoint.SessionName = MySandboxGame.ConfigDedicated.WorldName;
}
checkpoint.Settings = m_selectedSessionSettings;
checkpoint.Mods.Clear();
foreach (ulong publishedFileId in MySandboxGame.ConfigDedicated.Mods)
{
checkpoint.Mods.Add(new MyObjectBuilder_Checkpoint.ModItem(publishedFileId));
}
MyLocalCache.SaveCheckpoint(checkpoint, path);
}
}
private void gamesListBox_SelectedIndexChanged(object sender, EventArgs e)
{
if (gamesListBox.SelectedIndex != -1)
{
ulong sizeInBytes;
WorldItem worldItem = (WorldItem)gamesListBox.Items[gamesListBox.SelectedIndex];
((MyConfigDedicated <MyObjectBuilder_SessionSettings>)MySandboxGame.ConfigDedicated).LoadWorld = worldItem.SessionPath;
var loadPath = worldItem.SessionPath;
MyObjectBuilder_Checkpoint checkpoint = MyLocalCache.LoadCheckpoint(loadPath, out sizeInBytes);
m_selectedSessionSettings = checkpoint.Settings;
MySandboxGame.ConfigDedicated.Mods.Clear();
foreach (var mod in checkpoint.Mods)
{
if (mod.PublishedFileId != 0)
{
MySandboxGame.ConfigDedicated.Mods.Add(mod.PublishedFileId);
}
}
modIdsTextBox.Text = string.Join(Environment.NewLine, MySandboxGame.ConfigDedicated.Mods.ToArray());
FillSessionSettingsItems();
}
}
// Edit game constructor
public MyGuiScreenWorldSettings(MyObjectBuilder_Checkpoint checkpoint, string path)
: base(new Vector2(0.5f, 0.5f), MyGuiConstants.SCREEN_BACKGROUND_COLOR, CalcSize(checkpoint))
{
MySandboxGame.Log.WriteLine("MyGuiScreenWorldSettings.ctor START");
EnabledBackgroundFade = true;
Static = this;
m_checkpoint = checkpoint;
if (checkpoint == null || checkpoint.Mods == null)
{
m_mods = new List <MyObjectBuilder_Checkpoint.ModItem>();
}
else
{
m_mods = checkpoint.Mods;
}
m_sessionPath = path;
m_isNewGame = (checkpoint == null);
RecreateControls(true);
// If this screen is loaded from "Saved Games" it should not use the EnvironmentHostility logic
m_isHostilityChanged = !m_isNewGame;
MySandboxGame.Log.WriteLine("MyGuiScreenWorldSettings.ctor END");
}
public void InitFromCheckpoint(MyObjectBuilder_Checkpoint checkpoint)
{
var cooldowns = checkpoint.RespawnCooldowns;
m_lastUpdate = MySandboxGame.TotalGamePlayTimeInMilliseconds;
m_globalRespawnTimesMs.Clear();
if (cooldowns == null)
{
return;
}
foreach (var item in cooldowns)
{
var controllerId = new MyPlayer.PlayerId()
{
SteamId = item.PlayerSteamId, SerialId = item.PlayerSerialId
};
var key = new RespawnKey()
{
ControllerId = controllerId, RespawnShipId = item.RespawnShipId
};
m_globalRespawnTimesMs.Add(key, item.Cooldown + m_lastUpdate, immediate: true);
}
}
private void PrepareBaseSession(MyObjectBuilder_Checkpoint checkpoint, MyObjectBuilder_Sector sector)
{
ScriptManager.Init(checkpoint.ScriptManagerData);
MyDefinitionManager.Static.LoadData(checkpoint.Mods);
LoadGameDefinition(checkpoint);
MyDefinitionManager.Static.TryGetDefinition <MyScenarioDefinition>(checkpoint.Scenario, out Scenario);
WorldBoundaries = checkpoint.WorldBoundaries;
FixIncorrectSettings(Settings);
// Use whatever setting is in scenario if there was nothing in the file (0 min and max).
// SE scenarios have nothing while ME scenarios have size defined.
if (!WorldBoundaries.HasValue && Scenario != null)
{
WorldBoundaries = Scenario.WorldBoundaries;
}
MySector.InitEnvironmentSettings(sector.Environment);
LoadDataComponents();
LoadObjectBuildersComponents(checkpoint.SessionComponents);
}
public void SaveGpss(MyObjectBuilder_Checkpoint checkpoint)
{
if (MyFakes.ENABLE_GPS)
{
DiscardOld();
if (checkpoint.Gps == null)
{
checkpoint.Gps = new SerializableDictionary <long, MyObjectBuilder_Gps>();
}
foreach (var item in m_playerGpss)
{
MyObjectBuilder_Gps bGps;
if (!checkpoint.Gps.Dictionary.TryGetValue(item.Key, out bGps))
{
bGps = MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_Gps>();
}
if (bGps.Entries == null)
{
bGps.Entries = new List <MyObjectBuilder_Gps.Entry>();
}
foreach (var gps in item.Value)
{
bGps.Entries.Add(GetObjectBuilderEntry(gps.Value));
}
checkpoint.Gps.Dictionary.Add(item.Key, bGps);
}
}
}
public void LoadGpss(MyObjectBuilder_Checkpoint checkpoint)
{
if (MyFakes.ENABLE_GPS && checkpoint.Gps != null)
{
foreach (var entry in checkpoint.Gps.Dictionary)//identity
{
foreach (var gpsEntry in entry.Value.Entries)
{
MyGps gps = new MyGps(gpsEntry);
Dictionary <int, MyGps> playersGpss;
if (!m_playerGpss.TryGetValue(entry.Key, out playersGpss))
{
playersGpss = new Dictionary <int, MyGps>();
m_playerGpss.Add(entry.Key, playersGpss);
}
if (!playersGpss.ContainsKey(gps.GetHashCode()))
{
playersGpss.Add(gps.GetHashCode(), gps);
if (gps.ShowOnHud && entry.Key == MySession.Static.LocalPlayerId && MySession.Static.LocalPlayerId != 0)// LocalPlayerId=0 => loading MP game and not yet initialized. Or server, which does not matter
{
MyHud.GpsMarkers.RegisterMarker(gps);
}
}
}
}
}
}
private void SetupWorldGeneratorSettings(MyObjectBuilder_Checkpoint checkpoint)
{
switch ((MyGuiScreenWorldGeneratorSettings.AsteroidAmountEnum)AsteroidAmount)
{
case MyGuiScreenWorldGeneratorSettings.AsteroidAmountEnum.ProceduralLow:
checkpoint.Settings.ProceduralDensity = 0.25f;
break;
case MyGuiScreenWorldGeneratorSettings.AsteroidAmountEnum.ProceduralNormal:
checkpoint.Settings.ProceduralDensity = 0.35f;
break;
case MyGuiScreenWorldGeneratorSettings.AsteroidAmountEnum.ProceduralHigh:
checkpoint.Settings.ProceduralDensity = 0.50f;
break;
case MyGuiScreenWorldGeneratorSettings.AsteroidAmountEnum.ProceduralNone:
checkpoint.Settings.ProceduralDensity = 0.0f;
break;
default:
throw new InvalidBranchException();
break;
}
}
public static void LoadMission(string sessionPath, bool multiplayer, MyOnlineModeEnum onlineMode, short maxPlayers,
MyGameModeEnum gameMode, MyObjectBuilder_Checkpoint checkpoint, ulong checkpointSizeInBytes)
{
var persistentEditMode = checkpoint.Settings.ScenarioEditMode;
checkpoint.Settings.OnlineMode = onlineMode;
checkpoint.Settings.MaxPlayers = maxPlayers;
checkpoint.Settings.Scenario = true;
checkpoint.Settings.GameMode = gameMode;
checkpoint.Settings.ScenarioEditMode = false;
if (!MySession.IsCompatibleVersion(checkpoint))
{
MyLog.Default.WriteLine(MyTexts.Get(MyCommonTexts.DialogTextIncompatibleWorldVersion).ToString());
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox(
messageCaption: MyTexts.Get(MyCommonTexts.MessageBoxCaptionError),
messageText: MyTexts.Get(MyCommonTexts.DialogTextIncompatibleWorldVersion),
buttonType: MyMessageBoxButtonsType.OK));
MyLog.Default.WriteLine("LoadSession() - End");
return;
}
if (!MySteamWorkshop.CheckLocalModsAllowed(checkpoint.Mods, checkpoint.Settings.OnlineMode == MyOnlineModeEnum.OFFLINE))
{
MyLog.Default.WriteLine(MyTexts.Get(MyCommonTexts.DialogTextLocalModsDisabledInMultiplayer).ToString());
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox(
messageCaption: MyTexts.Get(MyCommonTexts.MessageBoxCaptionError),
messageText: MyTexts.Get(MyCommonTexts.DialogTextLocalModsDisabledInMultiplayer),
buttonType: MyMessageBoxButtonsType.OK));
MyLog.Default.WriteLine("LoadSession() - End");
return;
}
m_checkpointData = new CheckpointData()
{
Checkpoint = checkpoint,
CheckpointSize = checkpointSizeInBytes,
PersistentEditMode = persistentEditMode,
SessionPath = sessionPath,
};
if (checkpoint.BriefingVideo != null && checkpoint.BriefingVideo.Length > 0 && !MyFakes.XBOX_PREVIEW)
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox(
messageCaption: MyTexts.Get(MySpaceTexts.MessageBoxCaptionVideo),
messageText: MyTexts.Get(MySpaceTexts.MessageBoxTextWatchVideo),
buttonType: MyMessageBoxButtonsType.YES_NO,
callback: OnVideoMessageBox));
}
else
{
var checkpointData = m_checkpointData.Value;
m_checkpointData = null;
LoadMission(checkpointData);
}
}
private static Vector2 CalcSize(MyObjectBuilder_Checkpoint checkpoint)//TODO optimize
{
float width = checkpoint == null ? 0.9f : 0.65f;
float height = checkpoint == null ? 1.24f : 0.97f;
if (checkpoint != null)
height -= 0.05f;
height -= 0.27f;
return new Vector2(width, height);
}
public override void FixSessionObjectBuilders(MyObjectBuilder_Checkpoint checkpoint, MyObjectBuilder_Sector sector)
{
base.FixSessionObjectBuilders(checkpoint, sector);
if (sector.AppVersion == 0)
{
HashSet <String> previouslyColored = new HashSet <String>();
previouslyColored.Add("LargeBlockArmorBlock");
previouslyColored.Add("LargeBlockArmorSlope");
previouslyColored.Add("LargeBlockArmorCorner");
previouslyColored.Add("LargeBlockArmorCornerInv");
previouslyColored.Add("LargeRoundArmor_Slope");
previouslyColored.Add("LargeRoundArmor_Corner");
previouslyColored.Add("LargeRoundArmor_CornerInv");
previouslyColored.Add("LargeHeavyBlockArmorBlock");
previouslyColored.Add("LargeHeavyBlockArmorSlope");
previouslyColored.Add("LargeHeavyBlockArmorCorner");
previouslyColored.Add("LargeHeavyBlockArmorCornerInv");
previouslyColored.Add("SmallBlockArmorBlock");
previouslyColored.Add("SmallBlockArmorSlope");
previouslyColored.Add("SmallBlockArmorCorner");
previouslyColored.Add("SmallBlockArmorCornerInv");
previouslyColored.Add("SmallHeavyBlockArmorBlock");
previouslyColored.Add("SmallHeavyBlockArmorSlope");
previouslyColored.Add("SmallHeavyBlockArmorCorner");
previouslyColored.Add("SmallHeavyBlockArmorCornerInv");
previouslyColored.Add("LargeBlockInteriorWall");
foreach (var obj in sector.SectorObjects)
{
var grid = obj as MyObjectBuilder_CubeGrid;
if (grid == null)
{
continue;
}
foreach (var block in grid.CubeBlocks)
{
if (block.TypeId != typeof(MyObjectBuilder_CubeBlock) || !previouslyColored.Contains(block.SubtypeName))
{
block.ColorMaskHSV = MyRenderComponentBase.OldGrayToHSV;
}
}
}
}
if (sector.AppVersion <= 01100001)
{
CheckOxygenContainers(sector);
}
// TODO: this is disabled now because replication of MyEntity with components is not resolved, when you enable it make sure that corresponding
// definitions are also changed (InventoryBagDefinition/.... to EntityBase/...)
//CheckInventoryBagEntity(sector);
}
private static Vector2 CalcSize(MyObjectBuilder_Checkpoint checkpoint)//TODO optimize
{
float width = checkpoint == null ? 0.9f : 0.65f;
float height = checkpoint == null ? 1.24f : 0.97f;
if (checkpoint != null)
height -= 0.05f;
if (MyFakes.OCTOBER_RELEASE_HIDE_WORLD_PARAMS)
height -= 0.27f;
return new Vector2(width, height);
}
public void SaveCameraCollection(MyObjectBuilder_Checkpoint checkpoint)
{
MyDebug.AssertDebug(checkpoint.AllPlayersData != null, "Players data not initialized!");
if (checkpoint.AllPlayersData == null)
{
return;
}
foreach (var playerData in checkpoint.AllPlayersData.Dictionary)
{
PlayerId pid = new PlayerId(playerData.Key.ClientId, playerData.Key.SerialId);
playerData.Value.EntityCameraData = new List <CameraControllerSettings>();
if (!m_entityCameraSettings.ContainsKey(pid))
{
continue;
}
m_entitiesToRemove.Clear();
foreach (var cameraSetting in m_entityCameraSettings[pid])
{
if (MyEntities.EntityExists(cameraSetting.Key))
{
CameraControllerSettings settings = new CameraControllerSettings()
{
Distance = cameraSetting.Value.Distance,
IsFirstPerson = cameraSetting.Value.IsFirstPerson,
HeadAngle = cameraSetting.Value.HeadAngle,
EntityId = cameraSetting.Key,
};
playerData.Value.EntityCameraData.Add(settings);
}
else
{
m_entitiesToRemove.Add(cameraSetting.Key);
}
}
foreach (long entityId in m_entitiesToRemove)
{
m_entityCameraSettings[pid].Remove(entityId);
}
if (m_characterCameraSettings != null)
{
playerData.Value.CharacterCameraData = new CameraControllerSettings()
{
Distance = m_characterCameraSettings.Distance,
IsFirstPerson = m_characterCameraSettings.IsFirstPerson,
HeadAngle = m_characterCameraSettings.HeadAngle,
};
}
}
}
public override void FixSessionObjectBuilders(MyObjectBuilder_Checkpoint checkpoint, MyObjectBuilder_Sector sector)
{
base.FixSessionObjectBuilders(checkpoint, sector);
if (sector.AppVersion == 0)
{
HashSet<String> previouslyColored = new HashSet<String>();
previouslyColored.Add("LargeBlockArmorBlock");
previouslyColored.Add("LargeBlockArmorSlope");
previouslyColored.Add("LargeBlockArmorCorner");
previouslyColored.Add("LargeBlockArmorCornerInv");
previouslyColored.Add("LargeRoundArmor_Slope");
previouslyColored.Add("LargeRoundArmor_Corner");
previouslyColored.Add("LargeRoundArmor_CornerInv");
previouslyColored.Add("LargeHeavyBlockArmorBlock");
previouslyColored.Add("LargeHeavyBlockArmorSlope");
previouslyColored.Add("LargeHeavyBlockArmorCorner");
previouslyColored.Add("LargeHeavyBlockArmorCornerInv");
previouslyColored.Add("SmallBlockArmorBlock");
previouslyColored.Add("SmallBlockArmorSlope");
previouslyColored.Add("SmallBlockArmorCorner");
previouslyColored.Add("SmallBlockArmorCornerInv");
previouslyColored.Add("SmallHeavyBlockArmorBlock");
previouslyColored.Add("SmallHeavyBlockArmorSlope");
previouslyColored.Add("SmallHeavyBlockArmorCorner");
previouslyColored.Add("SmallHeavyBlockArmorCornerInv");
previouslyColored.Add("LargeBlockInteriorWall");
foreach (var obj in sector.SectorObjects)
{
var grid = obj as MyObjectBuilder_CubeGrid;
if (grid == null)
continue;
foreach (var block in grid.CubeBlocks)
{
if (block.TypeId != typeof(MyObjectBuilder_CubeBlock) || !previouslyColored.Contains(block.SubtypeName))
{
block.ColorMaskHSV = MyRenderComponentBase.OldGrayToHSV;
}
}
}
}
if (sector.AppVersion <= 01100001)
{
CheckOxygenContainers(sector);
}
// TODO: this is disabled now because replication of MyEntity with components is not resolved, when you enable it make sure that corresponding
// definitions are also changed (InventoryBagDefinition/.... to EntityBase/...)
//CheckInventoryBagEntity(sector);
}
public static Vector2 CalcSize(MyObjectBuilder_Checkpoint checkpoint)
{
float width = checkpoint == null ? 0.9f : 0.65f;
float height = checkpoint == null ? 1.24f : 1.00f;
if (checkpoint != null)
{
height -= 0.05f;
}
height -= 0.27f;
return(new Vector2(width, height));
}
public void LoadToolbars(MyObjectBuilder_Checkpoint checkpoint)
{
if (checkpoint.AllPlayersData != null)
{
foreach (var item in checkpoint.AllPlayersData.Dictionary)
{
var playerId = new PlayerId(item.Key.ClientId, item.Key.SerialId);
var toolbar = new MyToolbar(MyToolbarType.Character);
toolbar.Init(item.Value.Toolbar, null, true);
AddPlayerToolbar(playerId, toolbar);
}
}
}
private static void CheckDx11AndLoad(MyObjectBuilder_Checkpoint checkpoint, string sessionPath, ulong checkpointSizeInBytes)
{
bool needsDx11 = checkpoint.RequiresDX >= 11;
if (!needsDx11 || MySandboxGame.IsDirectX11)
{
LoadSingleplayerSession(checkpoint, sessionPath, checkpointSizeInBytes);
}
else
{
MyJoinGameHelper.HandleDx11Needed();
}
}
private static void CheckDx11AndLoad(string sessionPath, bool multiplayer, MyOnlineModeEnum onlineMode, short maxPlayers,
MyGameModeEnum gameMode, MyObjectBuilder_Checkpoint checkpoint, ulong checkpointSizeInBytes)
{
bool needsDx11 = checkpoint.RequiresDX>=11;
if (!needsDx11 || MySandboxGame.IsDirectX11)
{
LoadMission(sessionPath, multiplayer, onlineMode, maxPlayers, gameMode, checkpoint, checkpointSizeInBytes);
}
else
{
MyJoinGameHelper.HandleDx11Needed();
}
}
public static Vector2 CalcSize(MyObjectBuilder_Checkpoint checkpoint)
{
float width = checkpoint == null ? 0.9f : 0.65f;
float height = checkpoint == null ? 1.24f : 0.95f;
if (MyFakes.ENABLE_NEW_SOUNDS)
{
height += 0.05f;
}
height -= 0.27f;
return(new Vector2(width, height));
}
private static Vector2 CalcSize(MyObjectBuilder_Checkpoint checkpoint)//TODO optimize
{
float width = checkpoint == null ? 0.9f : 0.65f;
float height = checkpoint == null ? 1.24f : 0.97f;
if (checkpoint != null)
{
height -= 0.05f;
}
height -= 0.27f;
return(new Vector2(width, height));
}
//public SerializableDictionary<MyObjectBuilder_Checkpoint.PlayerId, MyObjectBuilder_Toolbar> GetSerDictionary()
//{
// var ret = new SerializableDictionary<MyObjectBuilder_Checkpoint.PlayerId, MyObjectBuilder_Toolbar>();
// foreach (var item in m_playerToolbars)
// {
// var pid = new MyObjectBuilder_Checkpoint.PlayerId(item.Key.SteamId);
// pid.SerialId = item.Key.SerialId;
// var ob = item.Value.GetObjectBuilder();
// ret.Dictionary.Add(pid, ob);
// }
// return ret;
//}
public void SaveToolbars(MyObjectBuilder_Checkpoint checkpoint)
{
Dictionary <MyObjectBuilder_Checkpoint.PlayerId, MyObjectBuilder_Player> checkpointData = checkpoint.AllPlayersData.Dictionary;
foreach (var toolbar in m_playerToolbars)
{
var pid = new MyObjectBuilder_Checkpoint.PlayerId(toolbar.Key.SteamId);
pid.SerialId = toolbar.Key.SerialId;
if (checkpointData.ContainsKey(pid))
{
checkpointData[pid].Toolbar = toolbar.Value.GetObjectBuilder();
}
}
}
public override void FixSessionObjectBuilders(MyObjectBuilder_Checkpoint checkpoint, MyObjectBuilder_Sector sector)
{
if (sector.AppVersion == 0)
{
HashSet <String> previouslyColored = new HashSet <String>();
previouslyColored.Add("LargeBlockArmorBlock");
previouslyColored.Add("LargeBlockArmorSlope");
previouslyColored.Add("LargeBlockArmorCorner");
previouslyColored.Add("LargeBlockArmorCornerInv");
previouslyColored.Add("LargeRoundArmor_Slope");
previouslyColored.Add("LargeRoundArmor_Corner");
previouslyColored.Add("LargeRoundArmor_CornerInv");
previouslyColored.Add("LargeHeavyBlockArmorBlock");
previouslyColored.Add("LargeHeavyBlockArmorSlope");
previouslyColored.Add("LargeHeavyBlockArmorCorner");
previouslyColored.Add("LargeHeavyBlockArmorCornerInv");
previouslyColored.Add("SmallBlockArmorBlock");
previouslyColored.Add("SmallBlockArmorSlope");
previouslyColored.Add("SmallBlockArmorCorner");
previouslyColored.Add("SmallBlockArmorCornerInv");
previouslyColored.Add("SmallHeavyBlockArmorBlock");
previouslyColored.Add("SmallHeavyBlockArmorSlope");
previouslyColored.Add("SmallHeavyBlockArmorCorner");
previouslyColored.Add("SmallHeavyBlockArmorCornerInv");
previouslyColored.Add("LargeBlockInteriorWall");
foreach (var obj in sector.SectorObjects)
{
var grid = obj as MyObjectBuilder_CubeGrid;
if (grid == null)
{
continue;
}
foreach (var block in grid.CubeBlocks)
{
if (block.TypeId != typeof(MyObjectBuilder_CubeBlock) || !previouslyColored.Contains(block.SubtypeName))
{
block.ColorMaskHSV = MyRenderComponentBase.OldGrayToHSV;
}
}
}
}
if (sector.AppVersion <= 01100001)
{
CheckOxygenContainers(sector);
}
}
private void QuickstartScenario(string scenarioName)
{
string path = "CustomWorlds";
string sessionPath = Path.Combine(MyFileSystem.ContentPath, path, scenarioName);
ulong sizeInBytes;
MyObjectBuilder_Checkpoint checkpoint = MyLocalCache.LoadCheckpoint(sessionPath, out sizeInBytes);
if (checkpoint != null)
{
MySessionLoader.LoadSingleplayerSession(checkpoint, sessionPath, sizeInBytes, delegate
{
MyAsyncSaving.Start(null, Path.Combine(MyFileSystem.SavesPath, checkpoint.SessionName.Replace(':', '-')));
});
}
}
public static Vector2 CalcSize(MyObjectBuilder_Checkpoint checkpoint)
{
float width = checkpoint == null ? 0.9f : 0.65f;
float height = checkpoint == null ? 1.24f : 0.97f;
if (checkpoint != null)
{
height -= 0.05f;
}
if (MyFakes.OCTOBER_RELEASE_HIDE_WORLD_PARAMS)
{
height -= 0.27f;
}
return(new Vector2(width, height));
}
public override void FixSessionObjectBuilders(MyObjectBuilder_Checkpoint checkpoint, MyObjectBuilder_Sector sector)
{
if (sector.AppVersion == 0)
{
HashSet<String> previouslyColored = new HashSet<String>();
previouslyColored.Add("LargeBlockArmorBlock");
previouslyColored.Add("LargeBlockArmorSlope");
previouslyColored.Add("LargeBlockArmorCorner");
previouslyColored.Add("LargeBlockArmorCornerInv");
previouslyColored.Add("LargeRoundArmor_Slope");
previouslyColored.Add("LargeRoundArmor_Corner");
previouslyColored.Add("LargeRoundArmor_CornerInv");
previouslyColored.Add("LargeHeavyBlockArmorBlock");
previouslyColored.Add("LargeHeavyBlockArmorSlope");
previouslyColored.Add("LargeHeavyBlockArmorCorner");
previouslyColored.Add("LargeHeavyBlockArmorCornerInv");
previouslyColored.Add("SmallBlockArmorBlock");
previouslyColored.Add("SmallBlockArmorSlope");
previouslyColored.Add("SmallBlockArmorCorner");
previouslyColored.Add("SmallBlockArmorCornerInv");
previouslyColored.Add("SmallHeavyBlockArmorBlock");
previouslyColored.Add("SmallHeavyBlockArmorSlope");
previouslyColored.Add("SmallHeavyBlockArmorCorner");
previouslyColored.Add("SmallHeavyBlockArmorCornerInv");
previouslyColored.Add("LargeBlockInteriorWall");
foreach (var obj in sector.SectorObjects)
{
var grid = obj as MyObjectBuilder_CubeGrid;
if (grid == null)
continue;
foreach (var block in grid.CubeBlocks)
{
if (block.TypeId != typeof(MyObjectBuilder_CubeBlock) || !previouslyColored.Contains(block.SubtypeName))
{
block.ColorMaskHSV = MyRenderComponentBase.OldGrayToHSV;
}
}
}
}
if (sector.AppVersion <= 01100001)
{
CheckOxygenContainers(sector);
}
}
private static void LoadOnlinePlayers(MyObjectBuilder_Checkpoint checkpoint)
{
//Get This players ID
MyPlayer.PlayerId?savingPlayerId = new MyPlayer.PlayerId(Sync.MyId);
if (!savingPlayerId.HasValue)
{
SeamlessClient.TryShow("SavingPlayerID is null! Creating Default!");
savingPlayerId = new MyPlayer.PlayerId(Sync.MyId);
}
SeamlessClient.TryShow("Saving PlayerID: " + savingPlayerId.ToString());
SeamlessClient.TryShow("Checkpoint.AllPlayers: " + checkpoint.AllPlayers.Count);
//These both are null/empty. Server doesnt need to send them to the client
//SeamlessClient.TryShow("Checkpoint.ConnectedPlayers: " + checkpoint.ConnectedPlayers.Dictionary.Count);
//SeamlessClient.TryShow("Checkpoint.DisconnectedPlayers: " + checkpoint.DisconnectedPlayers.Dictionary.Count);
SeamlessClient.TryShow("Checkpoint.AllPlayersData: " + checkpoint.AllPlayersData.Dictionary.Count);
foreach (KeyValuePair <MyObjectBuilder_Checkpoint.PlayerId, MyObjectBuilder_Player> item3 in checkpoint.AllPlayersData.Dictionary)
{
MyPlayer.PlayerId playerId5 = new MyPlayer.PlayerId(item3.Key.GetClientId(), item3.Key.SerialId);
if (savingPlayerId.HasValue && playerId5.SteamId == savingPlayerId.Value.SteamId)
{
playerId5 = new MyPlayer.PlayerId(Sync.MyId, playerId5.SerialId);
}
LoadPlayerInternal.Invoke(MySession.Static.Players, new object[] { playerId5, item3.Value, false });
ConcurrentDictionary <MyPlayer.PlayerId, MyPlayer> Players = (ConcurrentDictionary <MyPlayer.PlayerId, MyPlayer>)MPlayerGPSCollection.GetValue(MySession.Static.Players);
//LoadPlayerInternal(ref playerId5, item3.Value);
if (Players.TryGetValue(playerId5, out MyPlayer myPlayer))
{
List <Vector3> value2 = null;
if (checkpoint.AllPlayersColors != null && checkpoint.AllPlayersColors.Dictionary.TryGetValue(item3.Key, out value2))
{
myPlayer.SetBuildColorSlots(value2);
}
else if (checkpoint.CharacterToolbar != null && checkpoint.CharacterToolbar.ColorMaskHSVList != null && checkpoint.CharacterToolbar.ColorMaskHSVList.Count > 0)
{
myPlayer.SetBuildColorSlots(checkpoint.CharacterToolbar.ColorMaskHSVList);
}
}
}
}
public void UpdateSessionSettings( )
{
MyConfigDedicatedData <MyObjectBuilder_SessionSettings> config = Server.Instance.LoadServerConfig( );
ApplicationLog.BaseLog.Info("Loading Session Settings");
try
{
string worldPath = config.LoadWorld;
ulong fileSize;
m_checkPoint = LoadSandbox(worldPath, out fileSize);
if (m_checkPoint == null)
{
return;
}
m_checkPoint.Settings = config.SessionSettings;
m_checkPoint.Scenario = config.Scenario;
m_checkPoint.Mods.Clear( );
foreach (ulong modid in config.Mods)
{
m_checkPoint.Mods.Add(new MyObjectBuilder_Checkpoint.ModItem(modid));
}
File.Copy(Path.Combine(worldPath, "Sandbox.sbc"), Path.Combine(worldPath, "Sandbox.sbc.bak"), true);
SaveSandbox(m_checkPoint, worldPath, out fileSize);
ApplicationLog.BaseLog.Info("{0}Max Players: {1}", Environment.NewLine, m_checkPoint.Settings.MaxPlayers);
ApplicationLog.BaseLog.Info("OnlineMode: {0}", m_checkPoint.Settings.OnlineMode);
ApplicationLog.BaseLog.Info("GameMode: {0}", m_checkPoint.Settings.GameMode);
ApplicationLog.BaseLog.Info("Scenario: {0}", m_checkPoint.Scenario.SubtypeId);
ApplicationLog.BaseLog.Info("World Size: {0}{1}", m_checkPoint.Settings.WorldSizeKm, Environment.NewLine);
}
catch (Exception ex)
{
if (ExtenderOptions.IsDebugging)
{
ApplicationLog.BaseLog.Error(ex, "Session Manager Exception: {0}");
}
}
}
public void UpdateSessionSettings()
{
ulong fileSize = 0UL;
MyConfigDedicatedData config = Server.Instance.LoadServerConfig();
Console.WriteLine("Loading Session Settings");
try
{
var worldPath = config.LoadWorld;
m_checkPoint = LoadSandbox(worldPath, out fileSize);
if (m_checkPoint == null)
{
return;
}
m_checkPoint.Settings = config.SessionSettings;
m_checkPoint.Scenario = config.Scenario;
m_checkPoint.Mods.Clear();
foreach (ulong modid in config.Mods)
{
m_checkPoint.Mods.Add(new MyObjectBuilder_Checkpoint.ModItem(modid));
}
File.Copy(worldPath + "\\Sandbox.sbc", worldPath + "\\Sandbox.sbc.bak", true);
SaveSandbox(m_checkPoint, worldPath, out fileSize);
Console.WriteLine(Environment.NewLine + "Max Players: " + m_checkPoint.Settings.MaxPlayers);
Console.WriteLine("OnlineMode: " + m_checkPoint.Settings.OnlineMode);
Console.WriteLine("GameMode: " + m_checkPoint.Settings.GameMode);
Console.WriteLine("Scenario: " + m_checkPoint.Scenario.SubtypeId);
Console.WriteLine("World Size: " + m_checkPoint.Settings.WorldSizeKm + Environment.NewLine);
}
catch (Exception ex)
{
LogManager.ErrorLog.WriteLineAndConsole("Session Manager Exception: " + ex.ToString());
return;
}
}
public static MyObjectBuilder_Checkpoint LoadCheckpoint(string sessionPath, out ulong sizeInBytes)
{
sizeInBytes = 0;
var checkpointFile = Path.Combine(sessionPath, CHECKPOINT_FILE);
if (!File.Exists(checkpointFile))
{
return(null);
}
MyObjectBuilder_Checkpoint result = null;
Sandbox.Common.ObjectBuilders.Serializer.MyObjectBuilderSerializer.DeserializeXML(checkpointFile, out result, out sizeInBytes);
if (result != null && string.IsNullOrEmpty(result.SessionName))
{
result.SessionName = Path.GetFileNameWithoutExtension(checkpointFile);
}
return(result);
}
public void SaveToCheckpoint(MyObjectBuilder_Checkpoint checkpoint)
{
var cooldowns = checkpoint.RespawnCooldowns;
foreach (var pair in m_globalRespawnTimesMs)
{
int cooldown = pair.Value - m_lastUpdate;
if (cooldown <= 0)
{
continue;
}
var item = new Sandbox.Common.ObjectBuilders.MyObjectBuilder_Checkpoint.RespawnCooldownItem();
item.PlayerSteamId = pair.Key.ControllerId.SteamId;
item.PlayerSerialId = pair.Key.ControllerId.SerialId;
item.RespawnShipId = pair.Key.RespawnShipId;
item.Cooldown = cooldown;
cooldowns.Add(item);
}
}
public void UpdateSessionSettings( )
{
MyConfigDedicatedData<MyObjectBuilder_SessionSettings> config = Server.Instance.LoadServerConfig( );
ApplicationLog.BaseLog.Info( "Loading Session Settings" );
try
{
string worldPath = config.LoadWorld;
ulong fileSize;
m_checkPoint = LoadSandbox(worldPath, out fileSize);
if (m_checkPoint == null)
return;
m_checkPoint.Settings = config.SessionSettings;
m_checkPoint.Scenario = config.Scenario;
m_checkPoint.Mods.Clear( );
foreach ( ulong modid in config.Mods )
m_checkPoint.Mods.Add( new MyObjectBuilder_Checkpoint.ModItem( modid ) );
File.Copy( Path.Combine( worldPath, "Sandbox.sbc" ), Path.Combine( worldPath, "Sandbox.sbc.bak" ), true );
SaveSandbox(m_checkPoint, worldPath, out fileSize);
ApplicationLog.BaseLog.Info( "{0}Max Players: {1}", Environment.NewLine, m_checkPoint.Settings.MaxPlayers );
ApplicationLog.BaseLog.Info( "OnlineMode: {0}", m_checkPoint.Settings.OnlineMode );
ApplicationLog.BaseLog.Info( "GameMode: {0}", m_checkPoint.Settings.GameMode );
ApplicationLog.BaseLog.Info( "Scenario: {0}", m_checkPoint.Scenario.SubtypeId );
ApplicationLog.BaseLog.Info( "World Size: {0}{1}", m_checkPoint.Settings.WorldSizeKm, Environment.NewLine );
}
catch (Exception ex)
{
if ( ExtenderOptions.IsDebugging )
ApplicationLog.BaseLog.Error( ex, "Session Manager Exception: {0}" );
}
}
public void SavePlayers(MyObjectBuilder_Checkpoint checkpoint)
{
checkpoint.ConnectedPlayers = new SerializableDictionary<MyObjectBuilder_Checkpoint.PlayerId, MyObjectBuilder_Player>();
checkpoint.DisconnectedPlayers = new SerializableDictionary<MyObjectBuilder_Checkpoint.PlayerId, long>();
checkpoint.AllPlayersData = new SerializableDictionary<MyObjectBuilder_Checkpoint.PlayerId, MyObjectBuilder_Player>();
foreach (var player in m_players.Values)
{
var id = new MyObjectBuilder_Checkpoint.PlayerId() { ClientId = player.Id.SteamId, SerialId = player.Id.SerialId };
MyObjectBuilder_Player playerOb = new MyObjectBuilder_Player();
playerOb.DisplayName = player.DisplayName;
playerOb.IdentityId = player.Identity.IdentityId;
playerOb.Connected = true;
checkpoint.AllPlayersData.Dictionary.Add(id, playerOb);
}
foreach (var entry in m_playerIdentityIds)
{
if (m_players.ContainsKey(entry.Key) || entry.Key.SerialId != 0) continue;
var id = new MyObjectBuilder_Checkpoint.PlayerId() { ClientId = entry.Key.SteamId, SerialId = entry.Key.SerialId };
MyObjectBuilder_Player playerOb = new MyObjectBuilder_Player();
playerOb.Connected = false;
playerOb.IdentityId = entry.Value;
var identity = TryGetIdentity(entry.Value);
playerOb.DisplayName = identity != null ? identity.DisplayName : null;
checkpoint.AllPlayersData.Dictionary.Add(id, playerOb);
}
//foreach (var entry in m_playerIdentityIds)
//{
// // Skip connected players
// if (m_players.ContainsKey(entry.Key)) continue;
// var id = new MyObjectBuilder_Checkpoint.PlayerId() { ClientId = entry.Key.SteamId, SerialId = entry.Key.SerialId };
// checkpoint.DisconnectedPlayers.Dictionary.Add(id, entry.Value);
//}
}
public void LoadCameraCollection(MyObjectBuilder_Checkpoint checkpoint)
{
m_entityCameraSettings = new Dictionary<PlayerId, Dictionary<long, MyEntityCameraSettings>>();
var allPlayers = checkpoint.AllPlayersData;
if (allPlayers != null)
{
foreach (var playerData in allPlayers.Dictionary)
{
PlayerId pid = new PlayerId(playerData.Key.ClientId, playerData.Key.SerialId);
m_entityCameraSettings[pid] = new Dictionary<long, MyEntityCameraSettings>();
foreach (var cameraSettings in playerData.Value.EntityCameraData)
{
MyEntityCameraSettings data = new MyEntityCameraSettings()
{
Distance = cameraSettings.Distance,
HeadAngle = (Vector2?)cameraSettings.HeadAngle,
IsFirstPerson = cameraSettings.IsFirstPerson
};
m_entityCameraSettings[pid][cameraSettings.EntityId] = data;
}
if (playerData.Value.CharacterCameraData != null)
{
m_characterCameraSettings = new MyEntityCameraSettings()
{
Distance = playerData.Value.CharacterCameraData.Distance,
HeadAngle = playerData.Value.CharacterCameraData.HeadAngle,
IsFirstPerson = playerData.Value.CharacterCameraData.IsFirstPerson
};
}
}
}
}
private void LoadWorld(MyObjectBuilder_Checkpoint checkpoint, MyObjectBuilder_Sector sector)
{
// Run compatibility helper.
MySandboxGame.Static.SessionCompatHelper.FixSessionObjectBuilders(checkpoint, sector);
//MyAudio.Static.Mute = true
MyEntities.MemoryLimitAddFailureReset();
ElapsedGameTime = new TimeSpan(checkpoint.ElapsedGameTime);
InGameTime = checkpoint.InGameTime;
Name = checkpoint.SessionName;
Description = checkpoint.Description;
PromotedUsers = new HashSet<ulong>(checkpoint.PromotedUsers ?? Enumerable.Empty<ulong>());
Briefing = checkpoint.Briefing;
BriefingVideo = checkpoint.BriefingVideo;
WorkshopId = checkpoint.WorkshopId;
Password = checkpoint.Password;
PreviousEnvironmentHostility = checkpoint.PreviousEnvironmentHostility;
RequiresDX = checkpoint.RequiresDX;
FixIncorrectSettings(Settings);
AppVersionFromSave = checkpoint.AppVersion;
if (MyFakes.ENABLE_BATTLE_SYSTEM)
{
VoxelHandVolumeChanged = sector.VoxelHandVolumeChanged;
}
MyToolbarComponent.InitCharacterToolbar(checkpoint.CharacterToolbar);
LoadCameraControllerSettings(checkpoint);;
Sync.Players.RespawnComponent.InitFromCheckpoint(checkpoint);
MyPlayer.PlayerId savingPlayer = new MyPlayer.PlayerId();
MyPlayer.PlayerId? savingPlayerNullable = null;
bool reuseSavingPlayerIdentity = TryFindSavingPlayerId(checkpoint.ControlledEntities, checkpoint.ControlledObject, out savingPlayer);
if (reuseSavingPlayerIdentity && !(IsScenario && Static.OnlineMode != MyOnlineModeEnum.OFFLINE))
savingPlayerNullable = savingPlayer;
// Identities have to be loaded before entities (because of ownership)
if (Sync.IsServer || (!Battle && MyPerGameSettings.Game == GameEnum.ME_GAME) || (!IsScenario && MyPerGameSettings.Game == GameEnum.SE_GAME)
|| (!IsScenario && MyPerGameSettings.Game == GameEnum.VRS_GAME))
Sync.Players.LoadIdentities(checkpoint, savingPlayerNullable);
Toolbars.LoadToolbars(checkpoint);
if (!MyEntities.Load(sector.SectorObjects))
{
ShowLoadingError();
}
MySandboxGame.Static.SessionCompatHelper.AfterEntitiesLoad(sector.AppVersion);
if (checkpoint.Factions != null && (Sync.IsServer || (!Battle && MyPerGameSettings.Game == GameEnum.ME_GAME) || (!IsScenario && MyPerGameSettings.Game == GameEnum.SE_GAME)))
{
Static.Factions.Init(checkpoint.Factions);
}
MyGlobalEvents.LoadEvents(sector.SectorEvents);
// Regenerate default events if they are empty (i.e. we are loading an old save)
// Initialize Spectator light
MySpectatorCameraController.Static.InitLight(checkpoint.SpectatorIsLightOn);
// MySpectator.Static.SpectatorCameraMovement = checkpoint.SpectatorCameraMovement;
MySpectatorCameraController.Static.SetViewMatrix(MatrixD.Invert(checkpoint.SpectatorPosition.GetMatrix()));
if (MyPerGameSettings.Game == GameEnum.UNKNOWN_GAME || ((!Battle && MyPerGameSettings.Game == GameEnum.ME_GAME) || ((!IsScenario || Static.OnlineMode == MyOnlineModeEnum.OFFLINE) && MyPerGameSettings.Game == GameEnum.SE_GAME)
|| ((!IsScenario || Static.OnlineMode == MyOnlineModeEnum.OFFLINE) && MyPerGameSettings.Game == GameEnum.VRS_GAME)))
{
if (!(Static.IsScenario && Static.Settings.StartInRespawnScreen))
{
Sync.Players.LoadConnectedPlayers(checkpoint, savingPlayerNullable);
Sync.Players.LoadControlledEntities(checkpoint.ControlledEntities, checkpoint.ControlledObject, savingPlayerNullable);
}
}
LoadCamera(checkpoint);
//fix: saved in survival with dead player, changed to creative, loaded game, no character with no way to respawn
if (CreativeMode && !Engine.Platform.Game.IsDedicated && LocalHumanPlayer != null && LocalHumanPlayer.Character != null && LocalHumanPlayer.Character.IsDead)
MyPlayerCollection.RequestLocalRespawn();
if (MyMultiplayer.Static != null && !Sync.IsServer)
{
Sync.Layer.TransportLayer.SendMessage(MyMessageId.CLIENT_READY, null, true, new EndpointId(Sync.ServerId));
((MyReplicationClient)MyMultiplayer.Static.ReplicationLayer).OnLocalClientReady();
}
// Create the player if he/she does not exist (on clients and server)
if (!Engine.Platform.Game.IsDedicated && LocalHumanPlayer == null)
{
Sync.Players.RequestNewPlayer(0, MySteam.UserName, null);
}
// Fix missing controlled entity. This should be needed only on the server.
// On the client, it will be done in reaction to new player creation (see "Create the player" above)
else if (ControlledEntity == null && Sync.IsServer && !Engine.Platform.Game.IsDedicated)
{
MyLog.Default.WriteLine("ControlledObject was null, respawning character");
m_cameraAwaitingEntity = true;
MyPlayerCollection.RequestLocalRespawn();
}
if (!Engine.Platform.Game.IsDedicated)
{
var playerId = new MyPlayer.PlayerId(Sync.MyId, 0);
var toolbar = Toolbars.TryGetPlayerToolbar(playerId);
if (toolbar == null)
{
MyToolBarCollection.RequestCreateToolbar(playerId);
MyToolbarComponent.InitCharacterToolbar(Scenario.DefaultToolbar);
}
else
{
MyToolbarComponent.InitCharacterToolbar(toolbar.GetObjectBuilder());
}
}
Gpss.LoadGpss(checkpoint);
LoadChatHistory(checkpoint);
if (MyFakes.ENABLE_MISSION_TRIGGERS)
MySessionComponentMissionTriggers.Static.Load(checkpoint.MissionTriggers);
MyEncounterGenerator.Load(sector.Encounters);
MyRenderProxy.RebuildCullingStructure();
Settings.ResetOwnership = false;
if (MyFinalBuildConstants.IS_OFFICIAL && !CreativeMode)
MyDebugDrawSettings.DEBUG_DRAW_PHYSICS = false;
MyRenderProxy.CollectGarbage();
}
public virtual void FixSessionObjectBuilders(MyObjectBuilder_Checkpoint checkpoint, MyObjectBuilder_Sector sector)
{ }
public void LoadIdentities(MyObjectBuilder_Checkpoint checkpoint, MyPlayer.PlayerId? savingPlayerId = null)
{
if (checkpoint.NonPlayerIdentities != null)
{
LoadNpcIdentities(checkpoint.NonPlayerIdentities);
}
//checkpoint.Identities or checkpoint.AllPlayers will never be null, because it's a .NET bug :-(
if (checkpoint.AllPlayers.Count != 0)
{
Debug.Assert(checkpoint.Identities.Count == 0, "Both AllPlayers and Identities were present in checkpoint object builder!");
LoadIdentitiesObsolete(checkpoint.AllPlayers, savingPlayerId);
}
else
{
LoadIdentities(checkpoint.Identities);
}
}
public abstract void SaveToCheckpoint(MyObjectBuilder_Checkpoint checkpoint);
private void LoadGameDefinition(MyObjectBuilder_Checkpoint checkpoint)
{
if (checkpoint.GameDefinition.IsNull())
{
LoadGameDefinition();
return;
}
Static.GameDefinition = MyDefinitionManager.Static.GetDefinition<MyGameDefinition>(checkpoint.GameDefinition);
SessionComponentDisabled = checkpoint.SessionComponentDisabled;
SessionComponentEnabled = checkpoint.SessionComponentEnabled;
RegisterComponentsFromAssemblies();
}
public static bool IsCompatibleVersion(MyObjectBuilder_Checkpoint checkpoint)
{
if (checkpoint == null)
return false;
return checkpoint.AppVersion <= MyFinalBuildConstants.APP_VERSION;
}
private void SaveSessionComponentObjectBuilders(MyObjectBuilder_Checkpoint checkpoint)
{
checkpoint.SessionComponents = new List<MyObjectBuilder_SessionComponent>();
foreach (var comp in m_sessionComponents.Values)
{
var ob = comp.GetObjectBuilder();
if (ob != null)
checkpoint.SessionComponents.Add(ob);
}
}
private void SaveChatHistory(MyObjectBuilder_Checkpoint checkpoint)
{
if (MyFakes.ENABLE_COMMUNICATION)
{
checkpoint.ChatHistory = new List<MyObjectBuilder_ChatHistory>(ChatHistory.Keys.Count);
foreach (var chatHistory in ChatHistory)
{
var chatHistoryBuilder = chatHistory.Value.GetObjectBuilder();
checkpoint.ChatHistory.Add(chatHistoryBuilder);
}
checkpoint.FactionChatHistory = new List<MyObjectBuilder_FactionChatHistory>(FactionChatHistory.Count);
foreach (var factionChatHistory in FactionChatHistory)
{
var factionChatHistoryBuilder = factionChatHistory.GetObjectBuilder();
checkpoint.FactionChatHistory.Add(factionChatHistoryBuilder);
}
}
}
private void LoadCameraControllerSettings(MyObjectBuilder_Checkpoint checkpoint)
{
//m_cameraControllerSettings.Clear();
//// Backwards compatibility section
//if (checkpoint.Players != null)
//{
// MyObjectBuilder_Player playerOb;
// if (checkpoint.Players.Dictionary.TryGetValue(Sync.Clients.LocalClient.SteamUserId, out playerOb))
// {
// foreach (var cameraController in playerOb.CameraData.Dictionary)
// {
// // m_cameraControllerSettings.Add(cameraController.Key, cameraController.Value);
// }
// }
//}
//// End backwards compatibility section
//else
//{
// #warning load camera settings from a new object builder
//}
Cameras.LoadCameraCollection(checkpoint);
}
private void LoadCamera(MyObjectBuilder_Checkpoint checkpoint)
{
if (checkpoint.SpectatorDistance > 0)
{
MyThirdPersonSpectator.Static.UpdateAfterSimulation();
MyThirdPersonSpectator.Static.ResetViewerDistance(checkpoint.SpectatorDistance);
}
MySandboxGame.Log.WriteLine("Checkpoint.CameraAttachedTo: " + checkpoint.CameraEntity);
IMyEntity cameraEntity = null;
var cameraControllerToSet = checkpoint.CameraController;
if (Static.Enable3RdPersonView == false && cameraControllerToSet == MyCameraControllerEnum.ThirdPersonSpectator)
{
cameraControllerToSet = checkpoint.CameraController = MyCameraControllerEnum.Entity;
}
if (checkpoint.CameraEntity == 0 && ControlledEntity != null)
{
cameraEntity = ControlledEntity as MyEntity;
if (cameraEntity != null)
{
Debug.Assert(ControlledEntity is IMyCameraController, "Controlled entity is not a camera controller");
if (!(ControlledEntity is IMyCameraController))
{
cameraEntity = null;
cameraControllerToSet = MyCameraControllerEnum.Spectator;
}
}
}
else
{
if (!MyEntities.EntityExists(checkpoint.CameraEntity))
{
cameraEntity = ControlledEntity as MyEntity;
if (cameraEntity != null)
{
cameraControllerToSet = MyCameraControllerEnum.Entity;
Debug.Assert(ControlledEntity is IMyCameraController, "Controlled entity is not a camera controller");
if (!(ControlledEntity is IMyCameraController))
{
cameraEntity = null;
cameraControllerToSet = MyCameraControllerEnum.Spectator;
}
}
else
{
MyLog.Default.WriteLine("ERROR: Camera entity from checkpoint does not exists!");
cameraControllerToSet = MyCameraControllerEnum.Spectator;
}
}
else
cameraEntity = MyEntities.GetEntityById(checkpoint.CameraEntity);
}
if (cameraControllerToSet == MyCameraControllerEnum.Spectator && MyFinalBuildConstants.IS_OFFICIAL && cameraEntity != null)
cameraControllerToSet = MyCameraControllerEnum.Entity;
MyEntityCameraSettings settings = null;
bool resetThirdPersonPosition = false;
if (!Engine.Platform.Game.IsDedicated)
{
if ((cameraControllerToSet == MyCameraControllerEnum.Entity
|| cameraControllerToSet == MyCameraControllerEnum.ThirdPersonSpectator)
&& cameraEntity != null)
{
MyPlayer.PlayerId pid = LocalHumanPlayer == null ? new MyPlayer.PlayerId(Sync.MyId, 0) : LocalHumanPlayer.Id;
if (Static.Cameras.TryGetCameraSettings(pid, cameraEntity.EntityId, out settings))
{
if (!settings.IsFirstPerson)
{
cameraControllerToSet = MyCameraControllerEnum.ThirdPersonSpectator;
resetThirdPersonPosition = true;
}
}
}
}
Static.IsCameraAwaitingEntity = false;
SetCameraController(cameraControllerToSet, cameraEntity);
if (resetThirdPersonPosition)
{
MyThirdPersonSpectator.Static.ResetViewerAngle(settings.HeadAngle);
MyThirdPersonSpectator.Static.ResetViewerDistance(settings.Distance);
}
}
private void LoadChatHistory(MyObjectBuilder_Checkpoint checkpoint)
{
if (MyFakes.ENABLE_COMMUNICATION)
{
foreach (var chatHistory in checkpoint.ChatHistory)
{
var newChatHistory = new MyChatHistory(chatHistory);
ChatHistory.Add(chatHistory.IdentityId, newChatHistory);
}
foreach (var chatHistory in checkpoint.FactionChatHistory)
{
FactionChatHistory.Add(new MyFactionChatHistory(chatHistory));
}
}
}
private void AddMod(bool active, StringBuilder title, StringBuilder toolTip, StringBuilder modState, MyGuiHighlightTexture? icon, MyObjectBuilder_Checkpoint.ModItem mod, Color? textColor = null)
{
var row = new MyGuiControlTable.Row(mod);
row.AddCell(new MyGuiControlTable.Cell(text: String.Empty, toolTip: modState.ToString(), icon: icon));
row.AddCell(new MyGuiControlTable.Cell(text: title, toolTip: toolTip.ToString(), textColor: textColor));
if (active)
m_modsTableEnabled.Insert(0, row);
else
m_modsTableDisabled.Insert(0, row);
}
public static void LoadMission(string sessionPath, MyObjectBuilder_Checkpoint checkpoint, ulong checkpointSizeInBytes, bool persistentEditMode)
{
LoadMission(sessionPath, checkpoint, checkpointSizeInBytes, checkpoint.SessionName, checkpoint.Description);
Static.PersistentEditMode = persistentEditMode;
Static.LoadedAsMission = true;
}
public void LoadConnectedPlayers(MyObjectBuilder_Checkpoint checkpoint, MyPlayer.PlayerId? savingPlayerId = null)
{
#warning TODO: Probably not needed? If not, remove the method
//long identityId = FindLocalIdentityId(checkpoint);
// Backward compatibility
if (checkpoint.AllPlayers != null && checkpoint.AllPlayers.Count != 0)
{
foreach (var playerItem in checkpoint.AllPlayers)
{
long identityId = playerItem.PlayerId;
var playerOb = new MyObjectBuilder_Player();
playerOb.Connected = true;
playerOb.DisplayName = playerItem.Name;
playerOb.IdentityId = identityId;
var playerId = new PlayerId(playerItem.SteamId, 0);
if (savingPlayerId != null && playerId == savingPlayerId)
{
playerId = new PlayerId(MySteam.UserId);
ChangeDisplayNameOfPlayerAndIdentity(playerOb, MySteam.UserName);
}
LoadPlayerInternal(ref playerId, playerOb, obsolete: true);
}
}
// Backward compatibility
else if (checkpoint.ConnectedPlayers != null && checkpoint.ConnectedPlayers.Dictionary.Count != 0)
{
Debug.Assert(checkpoint.DisconnectedPlayers != null, "Inconsistency in save! ConnectedPlayers were present, but DisconnectedPlayers not!");
foreach (var playerItem in checkpoint.ConnectedPlayers.Dictionary)
{
var playerId = new PlayerId(playerItem.Key.ClientId, playerItem.Key.SerialId);
if (savingPlayerId != null && playerId == savingPlayerId)
{
playerId = new PlayerId(MySteam.UserId);
ChangeDisplayNameOfPlayerAndIdentity(playerItem.Value, MySteam.UserName);
}
playerItem.Value.Connected = true;
LoadPlayerInternal(ref playerId, playerItem.Value, obsolete: false);
}
foreach (var playerItem in checkpoint.DisconnectedPlayers.Dictionary)
{
var playerId = new PlayerId(playerItem.Key.ClientId, playerItem.Key.SerialId);
var playerOb = new MyObjectBuilder_Player();
playerOb.Connected = false;
playerOb.IdentityId = playerItem.Value;
playerOb.DisplayName = null;
if (savingPlayerId != null && playerId == savingPlayerId)
{
playerId = new PlayerId(MySteam.UserId);
ChangeDisplayNameOfPlayerAndIdentity(playerOb, MySteam.UserName);
}
LoadPlayerInternal(ref playerId, playerOb, obsolete: false);
}
//LoadDisconnectedPlayers(checkpoint.DisconnectedPlayers.Dictionary);
}
else if (checkpoint.AllPlayersData != null)
{
foreach (var playerItem in checkpoint.AllPlayersData.Dictionary)
{
var playerId = new MyPlayer.PlayerId(playerItem.Key.ClientId, playerItem.Key.SerialId);
if (savingPlayerId != null && playerId == savingPlayerId)
{
playerId = new PlayerId(MySteam.UserId);
ChangeDisplayNameOfPlayerAndIdentity(playerItem.Value, MySteam.UserName);
}
LoadPlayerInternal(ref playerId, playerItem.Value, obsolete: false);
}
}
/*long identityId = FindLocalIdentityId(checkpoint);
//Player was saved in death state or there is no player
if (identityId == 0)
{
checkpoint.ControlledObject = 0; //This will lead to RequestRespawn
checkpoint.CameraController = MyCameraControllerEnum.Entity;
IsCameraAwaitingEntity = true;
}
else
{
// TODO: Refactor this later
MyEntity controlledObject = null;
if (checkpoint.ControlledObject != -1)
{
MyEntities.TryGetEntityById(checkpoint.ControlledObject, out controlledObject);
System.Diagnostics.Debug.Assert(controlledObject != null);
if (controlledObject is IMyControllableEntity)
{
var cockpit = controlledObject as MyCockpit;
if (cockpit != null)
{
var pilot = cockpit.Pilot;
if (pilot == null)
{
Debug.Fail("Creating new pilot for cockpit, because saved cockpit was controlled and had no pilot sitting in it.");
MySandboxGame.Log.WriteLine("Creating new pilot for cockpit, because saved cockpit was controlled and had no pilot sitting in it.");
var characterOb = MyCharacter.Random();
characterOb.Battery = new MyObjectBuilder_Battery() { CurrentCapacity = MyEnergyConstants.BATTERY_MAX_CAPACITY };
pilot = (MyCharacter)MyEntityFactory.CreateEntity(characterOb);
pilot.Init(characterOb);
MyWorldGenerator.InitInventoryWithDefaults(pilot.GetInventory());
cockpit.RequestUse(UseActionEnum.Manipulate, pilot);
}
MySession.Player.Init(pilot, null, identityId);
}
else if (controlledObject.Parent is MyCockpit)
{
MySession.Player.Init((MyCharacter)controlledObject, null, identityId);
controlledObject = controlledObject.Parent;
}
else
{
if (!MySandboxGame.IsDedicated)
{
if (controlledObject is MyCharacter)
{
MySession.Player.Init((MyCharacter)controlledObject, null, identityId);
}
}
}
if (!MySandboxGame.IsDedicated)
MySession.Player.Controller.TakeControl((IMyControllableEntity)controlledObject);
}
}
if (checkpoint.Players != null)
{
foreach (var playerIt in checkpoint.Players.Dictionary)
{
if (playerIt.Key == Player.SteamUserId)
{
Player.PlayerId = identityId;
if (string.IsNullOrEmpty(Player.Model))
{
if (!string.IsNullOrEmpty(playerIt.Value.PlayerModel))
Player.Model = playerIt.Value.PlayerModel;
else
Player.Model = MyCharacter.DefaultModel;
}
}
MyPlayer player;
if (Sync.Controllers.TryGetPlayer(playerIt.Key, out player))
{
MyCharacter playerEntity;
if (MyEntities.TryGetEntityById<MyCharacter>(playerIt.Value.PlayerEntity, out playerEntity))
{
player.Init(playerEntity, playerIt.Value.PlayerModel, playerIt.Key == Player.SteamUserId ? identityId : playerIt.Value.PlayerId);
}
}
}
}
}*/
}
// Edit game constructor
public MyGuiScreenWorldSettings(MyObjectBuilder_Checkpoint checkpoint, string path)
: base(new Vector2(0.5f, 0.5f), MyGuiConstants.SCREEN_BACKGROUND_COLOR, CalcSize(checkpoint))
{
MySandboxGame.Log.WriteLine("MyGuiScreenWorldSettings.ctor START");
EnabledBackgroundFade = true;
Static = this;
m_checkpoint = checkpoint;
if (checkpoint == null || checkpoint.Mods == null)
m_mods = new List<MyObjectBuilder_Checkpoint.ModItem>();
else
m_mods = checkpoint.Mods;
m_sessionPath = path;
m_isNewGame = (checkpoint == null);
RecreateControls(true);
// If this screen is loaded from "Saved Games" it should not use the EnvironmentHostility logic
m_isHostilityChanged = !m_isNewGame;
MySandboxGame.Log.WriteLine("MyGuiScreenWorldSettings.ctor END");
}
public abstract void InitFromCheckpoint(MyObjectBuilder_Checkpoint checkpoint);
public static Vector2 CalcSize(MyObjectBuilder_Checkpoint checkpoint)
{
float width = checkpoint == null ? 0.9f : 0.65f;
float height = checkpoint == null ? 1.24f : 1.00f;
if (MyFakes.ENABLE_NEW_SOUNDS)
height += 0.05f;
if (checkpoint != null)
height -= 0.05f;
height -= 0.27f;
return new Vector2(width, height);
}
private long FindLocalIdentityId(MyObjectBuilder_Checkpoint checkpoint)
{
long playerId = 0;
playerId = TryGetIdentityId(MySteam.UserId);
if (playerId != 0)
return playerId;
// Backward compatibility:
if (checkpoint.Players != null)
{
if (checkpoint.Players.Dictionary.ContainsKey(MySteam.UserId))
playerId = checkpoint.Players[MySteam.UserId].PlayerId != 0 ? checkpoint.Players[MySteam.UserId].PlayerId : playerId;
}
if (checkpoint.AllPlayers != null)
{
foreach (var player in checkpoint.AllPlayers)
{
if (player.SteamId == MySteam.UserId && !player.IsDead)
{
playerId = player.PlayerId;
break;
}
if (player.SteamId == MySteam.UserId && playerId == player.PlayerId && player.IsDead)
{
playerId = 0;
break;
}
}
}
return playerId;
}
public static void LoadBattle(string sessionPath, MyObjectBuilder_Checkpoint checkpoint, ulong checkpointSizeInBytes, MyObjectBuilder_SessionSettings settings)
{
MyLog.Default.WriteLine("Loading battle session: " + sessionPath);
MyAnalyticsHelper.SetEntry(MyGameEntryEnum.Load);
Load(sessionPath, checkpoint, checkpointSizeInBytes);
Static.Settings = settings;
Debug.Assert(Static.Settings.Battle = true);
}
//public SerializableDictionary<MyObjectBuilder_Checkpoint.PlayerId, MyObjectBuilder_Toolbar> GetSerDictionary()
//{
// var ret = new SerializableDictionary<MyObjectBuilder_Checkpoint.PlayerId, MyObjectBuilder_Toolbar>();
// foreach (var item in m_playerToolbars)
// {
// var pid = new MyObjectBuilder_Checkpoint.PlayerId(item.Key.SteamId);
// pid.SerialId = item.Key.SerialId;
// var ob = item.Value.GetObjectBuilder();
// ret.Dictionary.Add(pid, ob);
// }
// return ret;
//}
public void SaveToolbars(MyObjectBuilder_Checkpoint checkpoint)
{
Dictionary<MyObjectBuilder_Checkpoint.PlayerId, MyObjectBuilder_Player> checkpointData = checkpoint.AllPlayersData.Dictionary;
foreach (var toolbar in m_playerToolbars)
{
var pid = new MyObjectBuilder_Checkpoint.PlayerId(toolbar.Key.SteamId);
pid.SerialId = toolbar.Key.SerialId;
if (checkpointData.ContainsKey(pid))
{
checkpointData[pid].Toolbar = toolbar.Value.GetObjectBuilder();
}
}
}
public static void LoadMission(string sessionPath, MyObjectBuilder_Checkpoint checkpoint, ulong checkpointSizeInBytes, string name, string description)
{
MyAnalyticsHelper.SetEntry(MyGameEntryEnum.Load);
Load(sessionPath, checkpoint, checkpointSizeInBytes);
Static.Name = name;
Static.Description = description;
string safeName = MyUtils.StripInvalidChars(checkpoint.SessionName);
Static.CurrentPath = MyLocalCache.GetSessionSavesPath(safeName, false, false);
while (Directory.Exists(Static.CurrentPath))
{
Static.CurrentPath = MyLocalCache.GetSessionSavesPath(safeName + MyUtils.GetRandomInt(int.MaxValue).ToString("########"), false, false);
};
}
public void SaveCameraCollection(MyObjectBuilder_Checkpoint checkpoint)
{
MyDebug.AssertDebug(checkpoint.AllPlayersData != null, "Players data not initialized!");
if (checkpoint.AllPlayersData == null)
return;
foreach (var playerData in checkpoint.AllPlayersData.Dictionary)
{
PlayerId pid = new PlayerId(playerData.Key.ClientId, playerData.Key.SerialId);
playerData.Value.EntityCameraData = new List<CameraControllerSettings>();
if (!m_entityCameraSettings.ContainsKey(pid))
continue;
m_entitiesToRemove.Clear();
foreach (var cameraSetting in m_entityCameraSettings[pid])
{
if (MyEntities.EntityExists(cameraSetting.Key))
{
CameraControllerSettings settings = new CameraControllerSettings()
{
Distance = cameraSetting.Value.Distance,
IsFirstPerson = cameraSetting.Value.IsFirstPerson,
HeadAngle = cameraSetting.Value.HeadAngle,
EntityId = cameraSetting.Key,
};
playerData.Value.EntityCameraData.Add(settings);
}
else
{
m_entitiesToRemove.Add(cameraSetting.Key);
}
}
foreach (long entityId in m_entitiesToRemove)
m_entityCameraSettings[pid].Remove(entityId);
if (m_characterCameraSettings != null)
{
playerData.Value.CharacterCameraData = new CameraControllerSettings()
{
Distance = m_characterCameraSettings.Distance,
IsFirstPerson = m_characterCameraSettings.IsFirstPerson,
HeadAngle = m_characterCameraSettings.HeadAngle,
};
}
}
}
public static void Load(string sessionPath, MyObjectBuilder_Checkpoint checkpoint, ulong checkpointSizeInBytes)
{
ProfilerShort.Begin("MySession.Static.Load");
MyLog.Default.WriteLineAndConsole("Loading session: " + sessionPath);
//MyAudio.Static.Mute = true;
MyLocalCache.SaveLastLoadedTime(sessionPath, DateTime.Now);
MyEntityIdentifier.Reset();
ulong sectorSizeInBytes;
ProfilerShort.Begin("MyLocalCache.LoadSector");
var sector = MyLocalCache.LoadSector(sessionPath, checkpoint.CurrentSector, out sectorSizeInBytes);
ProfilerShort.End();
if (sector == null)
{
//TODO: If game - show error messagebox and return to menu
// If DS console - write error to console and exit DS
// If DS service - pop up silent exception (dont send report)
throw new ApplicationException("Sector could not be loaded");
}
ulong voxelsSizeInBytes = GetVoxelsSizeInBytes(sessionPath);
#if false
if ( MyFakes.DEBUG_AVOID_RANDOM_AI )
MyBBSetSampler.ResetRandomSeed();
#endif
MyCubeGrid.Preload();
Static = new MySession();
Static.Mods = checkpoint.Mods;
Static.Settings = checkpoint.Settings;
Static.CurrentPath = sessionPath;
if (Static.OnlineMode != MyOnlineModeEnum.OFFLINE)
StartServerRequest();
MySandboxGame.Static.SessionCompatHelper.FixSessionComponentObjectBuilders(checkpoint, sector);
Static.PrepareBaseSession(checkpoint, sector);
ProfilerShort.Begin("MySession.Static.LoadWorld");
Static.LoadWorld(checkpoint, sector);
ProfilerShort.End();
if (Sync.IsServer)
{
Static.InitializeFactions();
}
Static.WorldSizeInBytes = checkpointSizeInBytes + sectorSizeInBytes + voxelsSizeInBytes;
// CH: I don't think it's needed. If there are problems with missing characters, look at it
//FixMissingCharacter();
MyLocalCache.SaveLastSessionInfo(sessionPath);
Static.SendSessionStartStats();
Static.LogSettings();
MyHud.Notifications.Get(MyNotificationSingletons.WorldLoaded).SetTextFormatArguments(Static.Name);
MyHud.Notifications.Add(MyNotificationSingletons.WorldLoaded);
if (MyFakes.LOAD_UNCONTROLLED_CHARACTERS == false)
Static.RemoveUncontrolledCharacters();
MyNetworkStats.Static.ClearStats();
Sync.Layer.TransportLayer.ClearStats();
Static.BeforeStartComponents();
MyLog.Default.WriteLineAndConsole("Session loaded");
ProfilerShort.End();
}
