public void Load()
{
_path = $"{Application.persistentDataPath}/{filename}";
if (!File.Exists(_path))
{
Debug.LogWarning("No savefile found. Creating a new one");
File.WriteAllText(_path, "");
}
var bf = new BinaryFormatter();
var file = File.Open(_path, FileMode.Open);
try
{
if (file.Length == 0)
{
file.Close();
_save = CreateSaveData();
Save();
}
else
{
_save = JSONSerializer.Deserialize <SaveData>(typeof(SaveData), (string)bf.Deserialize(file));
}
Debug.Log($"Successfully loaded savefile ({_path})");
GameLoaded?.Invoke(_save);
}
finally
{
file.Close();
}
}
public PlayerMovementHandler(PlayerModel player, float speed, GameLoaded loadedSignal)
{
isEnabled = false;
Speed = speed;
_player = player;
_loadedSignal = loadedSignal;
}
public GameLoaded Load()
{
GameLoaded gload = new GameLoaded {
};
OpenFileDialog openDialog = new OpenFileDialog();
openDialog.Filter = "PGN files (*.pgn)|*.pgn";
Stream stream;
if (openDialog.ShowDialog() == DialogResult.OK)
{
if ((stream = openDialog.OpenFile()) != null)
{
StreamReader sr = new StreamReader(stream);
try
{
gload = TextToGame(sr.ReadToEnd());
} catch (Exception) {
MessageBox.Show("Error al cargar el juego", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
sr.Close();
stream.Close();
}
}
return(gload);
}
public GameLoaded Load()
{
GameLoaded gload = new GameLoaded {};
OpenFileDialog openDialog = new OpenFileDialog();
openDialog.Filter = "PGN files (*.pgn)|*.pgn";
Stream stream;
if (openDialog.ShowDialog() == DialogResult.OK)
{
if ((stream = openDialog.OpenFile()) != null)
{
StreamReader sr = new StreamReader(stream);
try
{
gload = TextToGame(sr.ReadToEnd());
} catch (Exception) {
MessageBox.Show("Error al cargar el juego", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
sr.Close();
stream.Close();
}
}
return gload;
}
// Triggers after the game is loaded
internal static void OnGameLoaded(SceneContext ctx)
{
if (!isInitialized || Levels.isMainMenu())
{
return;
}
GameLoaded?.Invoke(ctx);
}
protected override void LoadContent()
{
IsMouseVisible = true;
_basicDrawer.LoadContent(this);
_imagesStore.LoadContent(this);
//NOTE: views are initalized here because it needs imagesProvider content loaded before this
ViewsManager.Initialize();
GameLoaded?.Invoke();
}
protected override void OnGameLoaded(GameLoaded e)
{
base.OnGameLoaded(e);
switch (Type.ToLower())
{
case "opengl":
BeginOpenGLImageCapture();
break;
default:
BeginDefaultImageCapture();
break;
}
}
protected override void OnGameLoaded(GameLoaded e)
{
SetEditMode(EditMode);
Overlay.SetParent(Window.Handle);
Window.BringToFront();
UpdateState();
WindowTracker = new ChangeTracker <WindowInstance>(Window);
WindowTracker.Changed += OnWindowChanged;
WindowTracker.StartPolling(TimeSpan.FromSeconds(1), Window.Update);
On <EditModeChanged>(mode => SetEditMode(mode.Enabled));
}
public bool LoadGame(String path)
{
if (_persistence == null)
{
return(false);
}
// végrehajtjuk a betöltést
TicTacToeDatas values = _persistence.Load(path);
//if (values.tableSize != _tableSize)
// throw new Exception("Error occured during game loading.");
GameLoaded?.Invoke(this, new GameLoadedEventArgs(values));
return(true);
}
protected virtual void OnGameLoaded(GameLoaded e)
{
}
private void InitializeNewGame()
{
#region Game
#endregion
#region Img
m_source = new D3DImage();
this.Source = m_source;
m_source.IsFrontBufferAvailableChanged += new DependencyPropertyChangedEventHandler(m_source_IsFrontBufferAvailableChanged);
#endregion
#region Size
this.SizeChanged += (e, a) =>
{
a.Handled = true;
m_width = (int)a.NewSize.Width;
m_height = (int)a.NewSize.Height;
m_resizing = true;
////while (!m_drawing)
//// Thread.Sleep(1);
////ResizeGame(m_width, m_height);
////if (Game is IXnapfGameResizeable)
//// (Game as IXnapfGameResizeable).Resize(m_width, m_height);
//m_target = new RenderTarget2D(Game.GraphicsDevice, m_width, m_height, true, SurfaceFormat.Color, DepthFormat.Depth24Stencil8);
////m_current = new RenderTarget2D(Game.GraphicsDevice, m_width, m_height, true, SurfaceFormat.Color, DepthFormat.Depth24Stencil8);
//m_rect = new Int32Rect(m_target.Bounds.X, m_target.Bounds.Y, m_target.Bounds.Width, m_target.Bounds.Height);
};
#endregion
#region Background
m_back = new BackgroundWorker();
m_back.WorkerReportsProgress = true;
#region DoWorkEnded
#endregion
#region DoWork
m_back.DoWork += (e, a) =>
{
Game = new T();
m_manager = Game.Services.GetService(typeof(IGraphicsDeviceManager)) as GraphicsDeviceManager;
if (m_manager != null)
{
m_manager.IsFullScreen = false;
m_manager.ApplyChanges();
}
//Game.Window.AllowUserResizing = true;
m_rasterisation = Game.GraphicsDevice.RasterizerState;
m_width = Game.GraphicsDevice.Viewport.Width;
m_height = Game.GraphicsDevice.Viewport.Height;
ProduceTarget(Game.GraphicsDevice, m_width, m_height);
m_rect = new Int32Rect(m_target.Bounds.X, m_target.Bounds.Y, m_target.Bounds.Width, m_target.Bounds.Height);
m_initialize.Invoke(this.Game, new object[] { });
Dispatcher.Invoke(new Action(() =>
{
m_source_IsFrontBufferAvailableChanged(null, new DependencyPropertyChangedEventArgs());
if (GameLoaded != null)
{
GameLoaded.Invoke(this, EventArgs.Empty);
}
}));
DateTime _save = DateTime.Now;
while (m_running && this.Dispatcher.Thread.IsAlive)
{
DateTime _now = DateTime.Now;
TimeSpan _TimeDiff = (_now - _save);
if (_TimeDiff.TotalMilliseconds < FPSTIME)
{
Thread.Sleep((int)(FPSTIME - _TimeDiff.TotalMilliseconds));
continue;
}
_save = _now;
if (!m_isLock)
{
continue;
}
if (m_resizing)
{
//while (!m_drawing)
// Thread.Sleep(1);
//ResizeGame(m_width, m_height);
//if (Game is IXnapfGameResizeable)
// (Game as IXnapfGameResizeable).Resize(m_width, m_height);
//m_resizing = false;
//ResizeGame(m_width, m_height);
//m_drawing = false;
////Game.Window.ClientSizeChanged += (x, y) =>
//// {
//lock (m_locker)
//{
// m_target = new RenderTarget2D(Game.GraphicsDevice, m_width, m_height, false,
// SurfaceFormat.Color, DepthFormat.Depth24, m_target.MultiSampleCount, RenderTargetUsage.PreserveContents);
// m_rect = new Int32Rect(m_target.Bounds.X, m_target.Bounds.Y, m_target.Bounds.Width, m_target.Bounds.Height);
//}
//m_drawing = true;
//};
//m_current = new RenderTarget2D(Game.GraphicsDevice, m_width, m_height, true, SurfaceFormat.Color, DepthFormat.Depth24Stencil8);
}
//if (!m_drawing)
// continue;
lock (m_locker)
{
if (m_target.IsContentLost || m_target.IsDisposed)
{
ProduceTarget(Game.GraphicsDevice, m_width, m_height);
}
Game.GraphicsDevice.SetRenderTarget(m_target);
if (!Game.IsActive)
{
m_isActive.SetValue(Game, true);
}
Game.Tick();
//Game.GraphicsDevice.SetRenderTarget(null);
}
}
if (!m_isExited)
{
Game.Exit();
}
};
GameLoaded += (e, a) =>
{
Game.Exiting += (obj, args) =>
{
m_running = false;
m_isExited = true;
};
};
#endregion
#region ProgressChanged
#endregion
m_back.RunWorkerAsync();
#endregion
}
protected override void OnGameLoaded(GameLoaded e)
{
Model = new DarkestDungeonViewModel();
On <DataLoaded <Region> >(OnRegionsLoaded);
}
public void LOAD_GAME() => GameLoaded?.Invoke(this, new EventArgs());
internal static void InvokeGameLoaded()
{
GameLoaded.Invoke(null, EventArgs.Empty);
}
protected virtual void OnGameLoaded(GameLoadedArgs e)
{
GameLoaded?.Invoke(this, e);
}
private async Task <GameLoadResult> _CreateGameAsync(string mapName, string gamemode)
{
DevConsole.SetVariable("game.mode", gamemode, true, true);
State = GameLoaderState.ChangingMap;
LoadingHint = "Loading map: " + mapName;
if (ulong.TryParse(mapName, out ulong workshopId))
{
LoadingHint = "Downloading map from workshop";
if (!SteamServer.IsValid &&
!SteamClient.IsValid)
{
return(GameLoadResult.FailedToLoadMap);
}
var item = await Item.GetAsync(workshopId);
if (!item.HasValue)
{
return(GameLoadResult.FailedToLoadMap);
}
var download = await SteamUGC.DownloadAsync(workshopId);
if (!download)
{
return(GameLoadResult.FailedToLoadMap);
}
var provider = FileSystem.AddLocalProvider(item.Value.Directory);
FileSystem.Build();
foreach (var file in provider.Files)
{
file.Value.WorkshopId = workshopId;
}
}
if (MapLoader.Instance.CurrentMap == null || MapLoader.Instance.CurrentMap.Name != mapName)
{
var mapLoadResult = await MapLoader.Instance.LoadMapAsync2(mapName);
if (mapLoadResult != MapLoadState.Loaded)
{
return(GameLoadResult.FailedToLoadMap);
}
}
if (_cancelled)
{
return(GameLoadResult.Cancelled);
}
PreGameLoaded?.Invoke();
LoadingHint = "Loading gamemode: " + gamemode;
var gamemodeLoaded = Game.GamemodeLoader.LoadGamemode(gamemode);
if (!gamemodeLoaded)
{
return(GameLoadResult.FailedToLoadGamemode);
}
GameLoaded?.Invoke();
State = GameLoaderState.Playing;
LoadingHint = "Done, game is created.";
return(GameLoadResult.Success);
}
private async Task <GameLoadResult> _JoinGameAsync(string address, int port = 0, string password = null)
{
if (Game.IsHost)
{
return(GameLoadResult.None);
}
// 1. Connect
LoadingHint = "Connecting to host";
if (_cancelled)
{
return(GameLoadResult.Cancelled);
}
var connectionResult = await(Game.Network as ClientSocketManager).ConnectAsync(address, port, password);
if (connectionResult != ClientSocketStatus.Connected)
{
return(GameLoadResult.FailedToConnect);
}
// 2. Sync files
//LoadingHint = "Synchronizing files";
//if (_cancelled) { return GameLoadResult.Cancelled; }
//_cts?.Dispose();
//_cts = new CancellationTokenSource();
//var syncResult = await Game.GetFSComponent<FileDownloader>().SyncWithHostAsync(_cts);
//_cts?.Dispose();
//if (syncResult != FileDownloader.SyncState.Completed)
//{
// return GameLoadResult.FailedToSync;
//}
// 3. Request ClientIndex and what map, gamemode to load
LoadingHint = "Requesting game info";
if (_cancelled)
{
return(GameLoadResult.Cancelled);
}
Game.Network.BroadcastPacket(PacketUtility.TakePacket <MapChange>());
var mapChange = await(Game.Network as ClientSocketManager).WaitForPacketAsync <MapChange>(5000);
if (mapChange == null)
{
return(GameLoadResult.MissingMapChange);
}
Game.ClientIndex = mapChange.ClientIndex;
State = GameLoaderState.ChangingMap;
// 5. Load the map
LoadingHint = "Loading the map: " + mapChange.MapName;
if (_cancelled)
{
return(GameLoadResult.Cancelled);
}
// with a local server the map should already be loaded, so let's check first
if (MapLoader.Instance.CurrentMap == null || MapLoader.Instance.CurrentMap.Name != mapChange.MapName)
{
var mapLoadResult = await MapLoader.Instance.LoadMapAsync2(mapChange.MapName);
if (mapLoadResult != MapLoadState.Loaded)
{
return(GameLoadResult.FailedToLoadMap);
}
}
PreGameLoaded?.Invoke();
// 6. Load the gamemode
LoadingHint = "Loading the gamemode: " + mapChange.Gamemode;
if (_cancelled)
{
return(GameLoadResult.Cancelled);
}
var gamemodeLoaded = Game.GamemodeLoader.LoadGamemode(mapChange.Gamemode);
if (!gamemodeLoaded)
{
return(GameLoadResult.FailedToLoadGamemode);
}
GameLoaded?.Invoke();
// 7. Notify server we're in
LoadingHint = "Done, entering game";
if (_cancelled)
{
return(GameLoadResult.Cancelled);
}
var pi2 = PacketUtility.TakePacket <PlayerIntroduction>();
pi2.Step = PlayerIntroduction.JoinStep.Introduce;
Game.Network.BroadcastPacket(pi2);
State = GameLoaderState.Playing;
return(GameLoadResult.Success);
}
public static void __OnGameLoaded(int saveSlot)
{
GameLoaded?.Invoke(null, new SaveLoadEventArgs(saveSlot));
}
public static void InvokeGameLoaded()
{
GameLoaded.Invoke();
}
