399 lines
14 KiB
C#
399 lines
14 KiB
C#
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Havok;
|
|
using NLog;
|
|
using NLog.Fluent;
|
|
using Sandbox;
|
|
using Sandbox.Engine.Analytics;
|
|
using Sandbox.Engine.Multiplayer;
|
|
using Sandbox.Engine.Networking;
|
|
using Sandbox.Engine.Platform.VideoMode;
|
|
using Sandbox.Engine.Utils;
|
|
using Sandbox.Game;
|
|
using Sandbox.Game.Gui;
|
|
using Sandbox.Game.World;
|
|
using Sandbox.Graphics.GUI;
|
|
using SpaceEngineers.Game;
|
|
using SpaceEngineers.Game.GUI;
|
|
using Torch.Utils;
|
|
using VRage;
|
|
using VRage.Audio;
|
|
using VRage.FileSystem;
|
|
using VRage.Game;
|
|
using VRage.Game.ObjectBuilder;
|
|
using VRage.Game.SessionComponents;
|
|
using VRage.GameServices;
|
|
using VRage.Plugins;
|
|
using VRage.Steam;
|
|
using VRage.Utils;
|
|
using VRageRender;
|
|
using MyRenderProfiler = VRage.Profiler.MyRenderProfiler;
|
|
|
|
namespace Torch
|
|
{
|
|
public class VRageGame
|
|
{
|
|
private static readonly ILogger _log = LogManager.GetCurrentClassLogger();
|
|
|
|
#pragma warning disable 649
|
|
[ReflectedGetter(Name = "m_plugins", Type = typeof(MyPlugins))]
|
|
private static readonly Func<List<IPlugin>> _getVRagePluginList;
|
|
|
|
[ReflectedGetter(Name = "Static", TypeName = "Sandbox.Game.Audio.MyMusicController, Sandbox.Game")]
|
|
private static readonly Func<object> _getMusicControllerStatic;
|
|
|
|
|
|
[ReflectedSetter(Name = "Static", TypeName = "Sandbox.Game.Audio.MyMusicController, Sandbox.Game")]
|
|
private static readonly Action<object> _setMusicControllerStatic;
|
|
|
|
|
|
[ReflectedMethod(Name = "Unload", TypeName = "Sandbox.Game.Audio.MyMusicController, Sandbox.Game")]
|
|
private static readonly Action<object> _musicControllerUnload;
|
|
|
|
// [ReflectedGetter(Name = "UpdateLayerDescriptors", Type = typeof(MyReplicationServer))]
|
|
// private static readonly Func<MyReplicationServer.UpdateLayerDesc[]> _layerSettings;
|
|
|
|
#pragma warning restore 649
|
|
|
|
private readonly TorchBase _torch;
|
|
private readonly Action _tweakGameSettings;
|
|
private readonly string _userDataPath;
|
|
private readonly string _appName;
|
|
private readonly uint _appSteamId;
|
|
private readonly string[] _runArgs;
|
|
private SpaceEngineersGame _game;
|
|
private readonly Thread _updateThread;
|
|
|
|
private bool _startGame = false;
|
|
private readonly AutoResetEvent _commandChanged = new AutoResetEvent(false);
|
|
private bool _destroyGame = false;
|
|
|
|
private readonly AutoResetEvent _stateChangedEvent = new AutoResetEvent(false);
|
|
private GameState _state;
|
|
|
|
public enum GameState
|
|
{
|
|
Creating,
|
|
Stopped,
|
|
Running,
|
|
Destroyed
|
|
}
|
|
|
|
internal VRageGame(TorchBase torch, Action tweakGameSettings, string appName, uint appSteamId,
|
|
string userDataPath, string[] runArgs)
|
|
{
|
|
_torch = torch;
|
|
_tweakGameSettings = tweakGameSettings;
|
|
_appName = appName;
|
|
_appSteamId = appSteamId;
|
|
_userDataPath = userDataPath;
|
|
_runArgs = runArgs;
|
|
_updateThread = new Thread(Run);
|
|
_updateThread.Start();
|
|
}
|
|
|
|
private void StateChange(GameState s)
|
|
{
|
|
if (_state == s)
|
|
return;
|
|
_state = s;
|
|
_stateChangedEvent.Set();
|
|
}
|
|
|
|
private void Run()
|
|
{
|
|
StateChange(GameState.Creating);
|
|
try
|
|
{
|
|
Create();
|
|
_destroyGame = false;
|
|
while (!_destroyGame)
|
|
{
|
|
StateChange(GameState.Stopped);
|
|
_commandChanged.WaitOne();
|
|
if (_startGame)
|
|
{
|
|
_startGame = false;
|
|
DoStart();
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
Destroy();
|
|
StateChange(GameState.Destroyed);
|
|
}
|
|
}
|
|
|
|
private void Create()
|
|
{
|
|
bool dedicated = Sandbox.Engine.Platform.Game.IsDedicated;
|
|
Environment.SetEnvironmentVariable("SteamAppId", _appSteamId.ToString());
|
|
MyServiceManager.Instance.AddService<IMyGameService>(new MySteamService(dedicated, _appSteamId));
|
|
if (dedicated && !MyGameService.HasGameServer)
|
|
{
|
|
_log.Warn("Steam service is not running! Please reinstall dedicated server.");
|
|
return;
|
|
}
|
|
|
|
SpaceEngineersGame.SetupBasicGameInfo();
|
|
SpaceEngineersGame.SetupPerGameSettings();
|
|
MyFinalBuildConstants.APP_VERSION = MyPerGameSettings.BasicGameInfo.GameVersion;
|
|
MySessionComponentExtDebug.ForceDisable = true;
|
|
MyPerGameSettings.SendLogToKeen = false;
|
|
// SpaceEngineersGame.SetupAnalytics();
|
|
|
|
MyFileSystem.ExePath = Path.GetDirectoryName(typeof(SpaceEngineersGame).Assembly.Location);
|
|
|
|
_tweakGameSettings();
|
|
|
|
MyFileSystem.Reset();
|
|
MyInitializer.InvokeBeforeRun(_appSteamId, _appName, _userDataPath);
|
|
// MyInitializer.InitCheckSum();
|
|
|
|
|
|
// Hook into the VRage plugin system for updates.
|
|
_getVRagePluginList().Add(_torch);
|
|
|
|
if (!MySandboxGame.IsReloading)
|
|
MyFileSystem.InitUserSpecific(dedicated ? null : MyGameService.UserId.ToString());
|
|
MySandboxGame.IsReloading = dedicated;
|
|
|
|
// render init
|
|
{
|
|
IMyRender renderer = null;
|
|
if (dedicated)
|
|
{
|
|
renderer = new MyNullRender();
|
|
}
|
|
else
|
|
{
|
|
MyPerformanceSettings preset = MyGuiScreenOptionsGraphics.GetPreset(MyRenderQualityEnum.NORMAL);
|
|
MyRenderProxy.Settings.User = MyVideoSettingsManager.GetGraphicsSettingsFromConfig(ref preset)
|
|
.PerformanceSettings.RenderSettings;
|
|
MyStringId graphicsRenderer = MySandboxGame.Config.GraphicsRenderer;
|
|
if (graphicsRenderer == MySandboxGame.DirectX11RendererKey)
|
|
{
|
|
renderer = new MyDX11Render(new MyRenderSettings?(MyRenderProxy.Settings));
|
|
if (!renderer.IsSupported)
|
|
{
|
|
MySandboxGame.Log.WriteLine(
|
|
"DirectX 11 renderer not supported. No renderer to revert back to.");
|
|
renderer = null;
|
|
}
|
|
}
|
|
if (renderer == null)
|
|
{
|
|
throw new MyRenderException(
|
|
"The current version of the game requires a Dx11 card. \\n For more information please see : http://blog.marekrosa.org/2016/02/space-engineers-news-full-source-code_26.html",
|
|
MyRenderExceptionEnum.GpuNotSupported);
|
|
}
|
|
MySandboxGame.Config.GraphicsRenderer = graphicsRenderer;
|
|
}
|
|
MyRenderProxy.Initialize(renderer);
|
|
MyRenderProfiler.SetAutocommit(false);
|
|
//This broke services?
|
|
//MyRenderProfiler.InitMemoryHack("MainEntryPoint");
|
|
}
|
|
|
|
// Loads object builder serializers. Intuitive, right?
|
|
_log.Info("Setting up serializers");
|
|
MyPlugins.RegisterGameAssemblyFile(MyPerGameSettings.GameModAssembly);
|
|
if (MyPerGameSettings.GameModBaseObjBuildersAssembly != null)
|
|
MyPlugins.RegisterBaseGameObjectBuildersAssemblyFile(MyPerGameSettings.GameModBaseObjBuildersAssembly);
|
|
MyPlugins.RegisterGameObjectBuildersAssemblyFile(MyPerGameSettings.GameModObjBuildersAssembly);
|
|
MyPlugins.RegisterSandboxAssemblyFile(MyPerGameSettings.SandboxAssembly);
|
|
MyPlugins.RegisterSandboxGameAssemblyFile(MyPerGameSettings.SandboxGameAssembly);
|
|
//typeof(MySandboxGame).GetMethod("Preallocate", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, null);
|
|
MyGlobalTypeMetadata.Static.Init(false);
|
|
}
|
|
|
|
private void Destroy()
|
|
{
|
|
_game.Dispose();
|
|
_game = null;
|
|
|
|
MyGameService.ShutDown();
|
|
|
|
_getVRagePluginList().Remove(_torch);
|
|
|
|
MyInitializer.InvokeAfterRun();
|
|
}
|
|
|
|
private void DoStart()
|
|
{
|
|
_game = new SpaceEngineersGame(_runArgs);
|
|
|
|
if (MySandboxGame.FatalErrorDuringInit)
|
|
{
|
|
throw new InvalidOperationException("Failed to start sandbox game: fatal error during init");
|
|
}
|
|
try
|
|
{
|
|
StateChange(GameState.Running);
|
|
_game.Run();
|
|
}
|
|
finally
|
|
{
|
|
StateChange(GameState.Stopped);
|
|
}
|
|
}
|
|
|
|
private void DoDisableAutoload()
|
|
{
|
|
if (MySandboxGame.ConfigDedicated is MyConfigDedicated<MyObjectBuilder_SessionSettings> config)
|
|
{
|
|
var tempDirectory = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
|
|
Directory.CreateDirectory(tempDirectory);
|
|
config.LoadWorld = null;
|
|
config.PremadeCheckpointPath = tempDirectory;
|
|
}
|
|
}
|
|
|
|
|
|
#pragma warning disable 649
|
|
[ReflectedMethod(Name = "StartServer")]
|
|
private static Action<MySession, MyMultiplayerBase> _hostServerForSession;
|
|
#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;
|
|
}
|
|
MyObjectBuilder_Checkpoint checkpoint = MyLocalCache.LoadCheckpoint(sessionPath, out ulong checkpointSize);
|
|
if (MySession.IsCompatibleVersion(checkpoint))
|
|
{
|
|
if (MyWorkshop.DownloadWorldModsBlocking(checkpoint.Mods, null).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 DoJoinSession(ulong lobbyId)
|
|
{
|
|
MyJoinGameHelper.JoinGame(lobbyId);
|
|
}
|
|
|
|
private void DoUnloadSession()
|
|
{
|
|
if (!Sandbox.Engine.Platform.Game.IsDedicated)
|
|
{
|
|
MyScreenManager.CloseAllScreensExcept(null);
|
|
MyGuiSandbox.Update(16);
|
|
}
|
|
if (MySession.Static != null)
|
|
{
|
|
MySession.Static.Unload();
|
|
MySession.Static = null;
|
|
}
|
|
{
|
|
var musicCtl = _getMusicControllerStatic();
|
|
if (musicCtl != null)
|
|
{
|
|
_musicControllerUnload(musicCtl);
|
|
_setMusicControllerStatic(null);
|
|
MyAudio.Static.MusicAllowed = true;
|
|
}
|
|
}
|
|
if (MyMultiplayer.Static != null)
|
|
{
|
|
MyMultiplayer.Static.Dispose();
|
|
}
|
|
if (!Sandbox.Engine.Platform.Game.IsDedicated)
|
|
{
|
|
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen(MyPerGameSettings.GUI.MainMenu));
|
|
}
|
|
}
|
|
|
|
private void DoStop()
|
|
{
|
|
ParallelTasks.Parallel.Scheduler.WaitForTasksToFinish(TimeSpan.FromSeconds(10.0));
|
|
MySandboxGame.Static.Exit();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Signals the game to stop itself.
|
|
/// </summary>
|
|
public void SignalStop()
|
|
{
|
|
_startGame = false;
|
|
_game.Invoke(DoStop, $"{nameof(VRageGame)}::{nameof(SignalStop)}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Signals the game to start itself
|
|
/// </summary>
|
|
public void SignalStart()
|
|
{
|
|
_startGame = true;
|
|
_commandChanged.Set();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Signals the game to destroy itself
|
|
/// </summary>
|
|
public void SignalDestroy()
|
|
{
|
|
_destroyGame = true;
|
|
SignalStop();
|
|
_commandChanged.Set();
|
|
}
|
|
|
|
public Task LoadSession(string path)
|
|
{
|
|
return _torch.InvokeAsync(()=>DoLoadSession(path));
|
|
}
|
|
|
|
public Task JoinSession(ulong lobbyId)
|
|
{
|
|
return _torch.InvokeAsync(()=>DoJoinSession(lobbyId));
|
|
}
|
|
|
|
public Task UnloadSession()
|
|
{
|
|
return _torch.InvokeAsync(DoUnloadSession);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Waits for the game to transition to the given state
|
|
/// </summary>
|
|
/// <param name="state">State to transition to</param>
|
|
/// <param name="timeout">Timeout</param>
|
|
/// <returns></returns>
|
|
public bool WaitFor(GameState state, TimeSpan? timeout = null)
|
|
{
|
|
// Kinda icky, but we can't block the update and expect the state to change.
|
|
if (Thread.CurrentThread == _updateThread)
|
|
return _state == state;
|
|
|
|
DateTime? end = timeout.HasValue ? (DateTime?) (DateTime.Now + timeout.Value) : null;
|
|
while (_state != state && (!end.HasValue || end > DateTime.Now + TimeSpan.FromSeconds(1)))
|
|
if (end.HasValue)
|
|
_stateChangedEvent.WaitOne(end.Value - DateTime.Now);
|
|
else
|
|
_stateChangedEvent.WaitOne();
|
|
return _state == state;
|
|
}
|
|
}
|
|
} |