/// <summary> /// index.xml を新規に作成します。 /// </summary> void CreateIndexFile() { indexFilePath = ResolveChildPath(indexFileName); index = new StorageDirectoryIndex(); using (var stream = container.CreateFile(indexFilePath)) { indexSerializer.Serialize(stream, index); } }
private void SaveToFile(IAsyncResult result) { device = StorageDevice.EndShowSelector(result); // Open a storage container. IAsyncResult r = device.BeginOpenContainer(containerName, null, null); result.AsyncWaitHandle.WaitOne(); StorageContainer container = device.EndOpenContainer(r); result.AsyncWaitHandle.Close(); // Delete old file and create new one. if (container.FileExists(fileName)) { container.DeleteFile(fileName); } Stream fileStream = container.CreateFile(fileName); // Write data to file. XmlSerializer serializer = new XmlSerializer(typeof(SaveGameData)); serializer.Serialize(fileStream, saveGameData); // Close file. fileStream.Close(); container.Dispose(); }
public override void Save() { // Open a storage device. StorageDevice device = getStorageDevice(); // Open a storage container. IAsyncResult resultStorage = device.BeginOpenContainer(folderName, null, null); resultStorage.AsyncWaitHandle.WaitOne(); using (StorageContainer container = device.EndOpenContainer(resultStorage)) { resultStorage.AsyncWaitHandle.Close(); // Delete old save file. if (container.FileExists(fileName)) { container.DeleteFile(fileName); } // Create new save file. using (Stream stream = container.CreateFile(fileName)) { // Convert the object to XML data and put it in the stream. XmlSerializer serializer = new XmlSerializer(typeof(SaveData)); serializer.Serialize(stream, Data); } } }
/// <summary> /// This method serializes the master save file into /// the StorageContainer for this game. /// By: Joseph Shaw /// </summary> /// <param name="device"></param> public static void SaveMasterFile(StorageDevice device, MasterSaveFile masterSaveFile) { // Open a storage container. IAsyncResult result = device.BeginOpenContainer("DungeonCrawler", null, null); // Wait for the WaitHandle to become signaled. result.AsyncWaitHandle.WaitOne(); StorageContainer container = device.EndOpenContainer(result); // Close the wait handle. result.AsyncWaitHandle.Close(); // Check to see whether the save exists. if (container.FileExists(masterFileName)) { // Delete it so that we can create one fresh. container.DeleteFile(masterFileName); } // Create the file. Stream stream = container.CreateFile(masterFileName); // Create the BinaryFormatter BinaryFormatter binaryFormatter = new BinaryFormatter(); // Convert the file to binary and save it binaryFormatter.Serialize(stream, masterSaveFile); // Close the file. stream.Close(); // Dispose the container, to commit changes. container.Dispose(); }
//Creates folder on users computer where data will be saved private void DoSaveGame(StorageDevice a_device, Game a_game, string a_file) { try { // Open a storage container. IAsyncResult f_result = a_device.BeginOpenContainer("Cubes_are_acute", null, null); // Wait for the WaitHandle to become signaled. f_result.AsyncWaitHandle.WaitOne(); StorageContainer container = a_device.EndOpenContainer(f_result); // Close the wait handle. f_result.AsyncWaitHandle.Close(); //Path is Documents/SavedGames/Cubes_are_acute on C: string filename = a_file; String[] f_str = container.GetFileNames(); if (filename == "Empty") { filename = "Save" + (f_str.Length + 1); } else if (filename == "New Save") { filename = "Save" + (f_str.Length + 1); } else { filename = a_file; } // Check to see whether the save exists. if (container.FileExists(filename)) { // Delete it so that we can create one fresh. container.DeleteFile(filename); } // Create the file. Stream stream = container.CreateFile(filename); // Convert the object to Binary data and put it in the stream. BinaryFormatter binFormatter = new BinaryFormatter(); //serializes Game and writes it's data to savegame.sav binFormatter.Serialize(stream, a_game); // Close the file. stream.Close(); // Dispose the container, to commit changes. container.Dispose(); } catch (Exception) { throw; } }
private void Save(IAsyncResult result) { _storageDevice = StorageDevice.EndShowSelector(result); if (_storageDevice != null && _storageDevice.IsConnected) { var filename = String.Format("save{0:00}.dat", _slot); var player = PlayerManager.Instance; GameSave save = new GameSave() { Ammo = player.Ammo, Lives = player.Lives, Hearts = player.Hearts, Coins = player.Coins, StagesCompleted = player.StagesCompleted }; IAsyncResult r = _storageDevice.BeginOpenContainer(_storageContainerName, null, null); result.AsyncWaitHandle.WaitOne(); Thread.Sleep(1500); StorageContainer container = _storageDevice.EndOpenContainer(r); if (container.FileExists(filename)) { container.DeleteFile(filename); } Stream stream = container.CreateFile(filename); IFormatter formatter = new BinaryFormatter(); formatter.Serialize(stream, save); stream.Close(); container.Dispose(); result.AsyncWaitHandle.Close(); if (_saveCallback != null) { _saveCallback(); } } }
private void SaveCallback(IAsyncResult result) { StorageContainer container = StorageDevice.EndOpenContainer(result); SaveGameRequest saveGameRequest = (SaveGameRequest)result.AsyncState; // Overwrite existing save. if (container.FileExists(saveGameRequest.SaveName)) { container.DeleteFile(saveGameRequest.SaveName); } // Create the file. Stream stream = container.CreateFile(saveGameRequest.SaveName); // Convert the object to XML data and put it in the stream. XmlSerializer serializer = new XmlSerializer(saveGameRequest.SaveType); serializer.Serialize(stream, saveGameRequest.SaveData); // Close the file. stream.Close(); // Dispose the container, to commit changes. container.Dispose(); }
private static void SaveToDevice(IAsyncResult result) { storageDevice = StorageDevice.EndShowSelector(result); if (storageDevice != null && storageDevice.IsConnected) { List <Player.PlayerData> playersDataToSave = new List <Player.PlayerData>(); foreach (Player player in PlayerManager.playersList) { playersDataToSave.Add(player.getSaveData()); } SaveData SaveData = new SaveData() { playersData = playersDataToSave }; IAsyncResult r = storageDevice.BeginOpenContainer(storageName, null, null); result.AsyncWaitHandle.WaitOne(); StorageContainer container = storageDevice.EndOpenContainer(r); if (container.FileExists(fileName)) { container.DeleteFile(fileName); } Stream stream = container.CreateFile(fileName); XmlSerializer serializer = new XmlSerializer(typeof(SaveData)); serializer.Serialize(stream, SaveData); stream.Close(); container.Dispose(); result.AsyncWaitHandle.Close(); } }
/// <summary> /// Saves the entire session with all the relevant information per added frame. Should only be called after exiting the game. /// </summary> public void SaveSession() { IAsyncResult result = storageDevice.BeginOpenContainer("SPB", null, null); // Get the Storage Container // Wait for the WaitHandle to become signaled. result.AsyncWaitHandle.WaitOne(); StorageContainer container = storageDevice.EndOpenContainer(result); // Close the wait handle. result.AsyncWaitHandle.Close(); String fileName; do // Create a new XML file with a new, randomly chosen, name. { fileName = RandomString(10) + Extension; } while (container.FileExists(fileName)); Stream stream = container.CreateFile(fileName); SessionData sessionData = new SessionData() { session = session }; XmlSerializer serializer = new XmlSerializer(typeof(SessionData)); // Serialize the sessionData so it can be stored. serializer.Serialize(stream, sessionData); stream.Close(); container.Dispose(); }
public void RequestSave(string fileName, SaveData data) { try { IAsyncResult device = StorageDevice.BeginShowSelector(PlayerIndex.One, null, null); device.AsyncWaitHandle.WaitOne(); StorageDevice storageDevice = StorageDevice.EndShowSelector(device); if (storageDevice.IsConnected && storageDevice != null) { IAsyncResult result = storageDevice.BeginOpenContainer("Save Game", null, null); result.AsyncWaitHandle.WaitOne(); StorageContainer container = storageDevice.EndOpenContainer(result); result.AsyncWaitHandle.Close(); if (container.FileExists(fileName)) { container.DeleteFile(fileName); } Stream stream = container.CreateFile(fileName); XmlSerializer serializer = new XmlSerializer(typeof(SaveData)); serializer.Serialize(stream, data); stream.Close(); container.Dispose(); } Console.WriteLine("Save complete!"); } catch { Console.WriteLine("ERROR! SAVE FAILED!!!"); } }
public static void SaveHighScores(HighScores360 data, string filename, StorageDevice storageDevice) { if (storageDevice.IsConnected) { IAsyncResult result = storageDevice.BeginOpenContainer("Highscores", null, null); result.AsyncWaitHandle.WaitOne(); StorageContainer container = storageDevice.EndOpenContainer(result); result.AsyncWaitHandle.Close(); if (container.FileExists(filename)) { container.DeleteFile(filename); } Stream stream = container.CreateFile(filename); try { XmlSerializer serializer = new XmlSerializer(typeof(HighScores360)); serializer.Serialize(stream, data); } finally { stream.Close(); } container.Dispose(); } }
public void Save() { Core.res = StorageDevice.BeginShowSelector(PlayerIndex.One, null, null); Core.sDev = StorageDevice.EndShowSelector(Core.res); IAsyncResult result = Core.sDev.BeginOpenContainer("Phone", null, null); result.AsyncWaitHandle.WaitOne(); StorageContainer container = Core.sDev.EndOpenContainer(result); result.AsyncWaitHandle.Close(); string filename = "phoneBookContacts.sav"; if (container.FileExists(filename)) { container.DeleteFile(filename); } Stream stream = container.CreateFile(filename); XmlSerializer serializer = new XmlSerializer(typeof(ContactsList)); ContactsList contactsList = new ContactsList(); contactsList.name = new string[contacts.Count]; contactsList.number = new string[contacts.Count]; for (int i = 0; i < contacts.Count; i++) { contactsList.name[i] = contacts[i].name; contactsList.number[i] = contacts[i].number; } contactsList.fStart = firstStart; serializer.Serialize(stream, contactsList); stream.Close(); container.Dispose(); }
public void SavePreferenceData(PreferenceData preferenceData) { try { IAsyncResult device = StorageDevice.BeginShowSelector(PlayerIndex.One, null, null); device.AsyncWaitHandle.WaitOne(); StorageDevice storageDevice = StorageDevice.EndShowSelector(device); if (storageDevice.IsConnected && storageDevice != null) { IAsyncResult result = storageDevice.BeginOpenContainer("A Troll in the Hay Data", null, null); result.AsyncWaitHandle.WaitOne(); StorageContainer container = storageDevice.EndOpenContainer(result); result.AsyncWaitHandle.Close(); if (container.FileExists(""))//come edit the file name { container.DeleteFile(""); } Stream stream = container.CreateFile(""); XmlSerializer serializer = new XmlSerializer(typeof(PreferenceData)); serializer.Serialize(stream, preferenceData); stream.Close(); container.Dispose(); } Console.WriteLine("Preference data save complete!"); } catch { Console.WriteLine("ERROR! PREFERENCE SAVE FAILED!!!"); } }
void SaveToDevice(IAsyncResult result) { device = StorageDevice.EndShowSelector(result); if (device != null && device.IsConnected) { SaveGame SaveData = new SaveGame() { skinSave = skin, soundONSave = soundON, showFPSSave = showFps, difficultySave = difficulty, classicModeSave = classicMode }; IAsyncResult r = device.BeginOpenContainer(containerName, null, null); result.AsyncWaitHandle.WaitOne(); StorageContainer container = device.EndOpenContainer(r); if (container.FileExists(filename)) { container.DeleteFile(filename); } Stream stream = container.CreateFile(filename); XmlSerializer serializer = new XmlSerializer(typeof(SaveGame)); serializer.Serialize(stream, SaveData); stream.Close(); container.Dispose(); result.AsyncWaitHandle.Close(); } }
private void Save() { using (Stream stream = storageContainer.CreateFile(filename)) { XmlSerializer serializer = new XmlSerializer(typeof(SaveGameData)); serializer.Serialize(stream, saveGameData); } }
/// <summary> /// Reads the in buffer. /// </summary> /// <param name="result">The result.</param> private void ReadInBuffer(IAsyncResult result) { try { StorageContainer container = device.EndOpenContainer(result); // Create a new file if it does not exist. if (!container.FileExists(filename)) { // Check to see whether the save exists. if (container.FileExists(this.backupFilename)) { Stream file = container.OpenFile(this.backupFilename, FileMode.Open); Stream copyfile = container.CreateFile(this.filename); for (int i = 0; i < file.Length; i++) { copyfile.WriteByte((byte)file.ReadByte()); } copyfile.Close(); file.Close(); } else { Stream file = container.CreateFile(this.filename); file.Close(); } } this.ReadOverwriteBuffer(container); container.Dispose(); if (this.buffer.Length < 33) { this.buffer = null; this.hasBufferChanged = true; this.updateScoreboard = true; return; } } catch { } }
private void MakeScreenshot() { try { //NOTE: This doesn't always work on all cards, especially if // desktop mode switches in fullscreen mode! screenshotNum++; // Make sure screenshots directory exists if (Directory.Exists(Directories.ScreenshotsDirectory) == false) { Directory.CreateDirectory(Directories.ScreenshotsDirectory); } int width = BaseGame.Device.PresentationParameters.BackBufferWidth; int height = BaseGame.Device.PresentationParameters.BackBufferHeight; using ( var tex = new Texture2D(BaseGame.Device, width, height, false, BaseGame.Device.PresentationParameters.BackBufferFormat)) { int[] backbuffer = new int[width * height]; #if WINDOWS // TODO !!! //BaseGame.Device.GetBackBufferData(backbuffer); #endif tex.SetData(backbuffer); FileHelper.StorageContainerMRE.WaitOne(); FileHelper.StorageContainerMRE.Reset(); // Open a storage container StorageDevice storageDevice = FileHelper.XnaUserDevice; if ((storageDevice != null) && storageDevice.IsConnected) { IAsyncResult async = storageDevice.BeginOpenContainer("RacingGame", null, null); async.AsyncWaitHandle.WaitOne(); using (StorageContainer container = storageDevice.EndOpenContainer(async)) { async.AsyncWaitHandle.Close(); using (Stream stream = container.CreateFile(ScreenshotNameBuilder(screenshotNum))) { tex.SaveAsJpeg(stream, width, height); } } } } } catch (Exception ex) { Log.Write("Failed to save Screenshot: " + ex.ToString()); } }
private static void do_SaveGame() { saving = true; while (!deviceFound) { ; } if (result.IsCompleted) { if (device != null && device.IsConnected) { try { IAsyncResult result2 = device.BeginOpenContainer("Contract: Void Justice", null, null); result2.AsyncWaitHandle.WaitOne(); StorageContainer container = device.EndOpenContainer(result2); result2.AsyncWaitHandle.Close(); // Check to see whether the save exists. if (container.FileExists(filename)) { container.DeleteFile(filename); } Stream stream = container.CreateFile(filename); XmlSerializer serializer = new XmlSerializer(typeof(List <HighScoresState.HighScoreValue>)); serializer.Serialize(stream, HighScoresState.highScores); stream.Close(); container.Dispose(); } catch (Exception) { saving = false; return; } } else { //Console.WriteLine("No save device detected"); } } saving = false; }
/// <summary> /// Save this replay, will be saved to /// TrackBeginner.replay, TrackAdvanced.replay or TrackExpert.replay. /// </summary> public void Save() { FileHelper.StorageContainerMRE.WaitOne(); FileHelper.StorageContainerMRE.Reset(); try { StorageDevice storageDevice = FileHelper.XnaUserDevice; if ((storageDevice != null) && storageDevice.IsConnected) { IAsyncResult async = storageDevice.BeginOpenContainer("RacingGame", null, null); async.AsyncWaitHandle.WaitOne(); using (StorageContainer container = storageDevice.EndOpenContainer(async)) { async.AsyncWaitHandle.Close(); using (Stream stream = container.CreateFile(ReplayFilenames[trackNum])) { using (BinaryWriter writer = new BinaryWriter(stream)) { // Save lap time writer.Write(lapTime); // Save track matrix values writer.Write(trackMatrixValues.Count); for (int num = 0; num < trackMatrixValues.Count; num++) { FileHelper.WriteMatrix(writer, trackMatrixValues[num]); } // Save checkpoint times writer.Write(checkpointTimes.Count); for (int num = 0; num < checkpointTimes.Count; num++) { writer.Write(checkpointTimes[num]); } } } } } } catch (Exception exc) { System.Diagnostics.Trace.WriteLine("Settings Load Failure: " + exc.ToString()); } FileHelper.StorageContainerMRE.Set(); }
public void InitializeXbox(StorageContainer c) { if (!c.FileExists("save.txt")) { c.CreateFile("save.txt").Close(); StreamWriter writer = new StreamWriter(c.OpenFile("save.txt", FileMode.Open)); WriteTheSave(writer); } StreamReader reader = new StreamReader(c.OpenFile("save.txt", FileMode.Open)); ReadTheSave(reader); }
private static void DoSaveGame(StorageDevice device) { // Open a storage container. IAsyncResult result = device.BeginOpenContainer("Storage", null, null); // Wait for the WaitHandle to become signaled. result.AsyncWaitHandle.WaitOne(); StorageContainer container = device.EndOpenContainer(result); // Close the wait handle. result.AsyncWaitHandle.Close(); string filename = "savegame.sav"; // Check to see whether the save exists. if (container.FileExists(filename)) { // Delete it so that we can create one fresh. container.DeleteFile(filename); } // Create the file. Stream stream = container.CreateFile(filename); #if WINDEMO // Convert the object to XML data and put it in the stream. XmlSerializer serializer = new XmlSerializer(typeof(SaveGameData)); serializer.Serialize(stream, data); #else using (StreamWriter sw = new StreamWriter(stream)) { foreach (int score in HighScores) { System.Console.WriteLine("{0}", score); sw.WriteLine("{0}", score); } sw.Close(); } #endif // Close the file. stream.Close(); // Dispose the container, to commit changes. container.Dispose(); }
private void SaveFile(StorageContainer container, string fileName, SaveData data) { try { Stream stream = container.CreateFile(fileName); SaveFile(data, stream); stream.Close(); } catch { Console.WriteLine("Error creating filestream for " + fileName); } finally { container.Dispose(); } }
public int SyncData(StorageDevice device, bool[] Switches, int[] Variables) { SaveData gs = new SaveData(); gs.gSwitches = Switches; gs.gVariables = Variables; // Open a storage container. IAsyncResult result = device.BeginOpenContainer("StorageDemo", null, null); device.BeginOpenContainer("GameData", null, null); // Wait for the WaitHandle to become signaled. result.AsyncWaitHandle.WaitOne(); StorageContainer container = device.EndOpenContainer(result); // Close the wait handle. result.AsyncWaitHandle.Close(); string filename = "savegame.sav"; // Check to see whether the save exists. if (container.FileExists(filename)) { // Delete it so that we can create one fresh. container.DeleteFile(filename); } // Create the file. Stream stream = container.CreateFile(filename); // Convert the object to XML data and put it in the stream. XmlSerializer serializer = new XmlSerializer(typeof(SaveData)); serializer.Serialize(stream, gs); // Close the file. stream.Close(); // Dispose the container, to commit changes. container.Dispose(); return(0); }
/// <summary> /// Saves a file. /// </summary> /// <param name="containerName">The name of the container in which to save the file.</param> /// <param name="fileName">The file to save.</param> /// <param name="saveAction">The save action to perform.</param> public void Save(string containerName, string fileName, FileAction saveAction) { VerifyIsReady(); // lock on the storage device so that only one storage operation can occur at a time lock (_lock) { // open a container using (StorageContainer currentContainer = OpenContainer(containerName)) { // attempt the save using (var stream = currentContainer.CreateFile(fileName)) { saveAction(stream); } } } }
public void SaveSettings() { StorageContainer container = GetContainer(); if (container.FileExists(SettingsFilename)) { container.DeleteFile(SettingsFilename); } Stream stream = container.CreateFile(SettingsFilename); XmlSerializer serializer = new XmlSerializer(typeof(Settings)); serializer.Serialize(stream, Settings); stream.Close(); container.Dispose(); }
public void SaveGameConfiguration(GameConfiguration gameConfig) { StorageContainer container = GetContainer("Config"); if (container.FileExists(ConfigurationFileName)) { container.DeleteFile(ConfigurationFileName); } Stream stream = container.CreateFile(ConfigurationFileName); XmlSerializer serializer = new XmlSerializer(typeof(GameConfiguration)); serializer.Serialize(stream, gameConfig); stream.Close(); container.Dispose(); }
private void PersistedStorageCallbackLoad(IAsyncResult result) { Guid playerId = Guid.Empty; bool success = false; using (StorageContainer container = storageDevice.EndOpenContainer(result)) { try { if (container.FileExists(FileName)) { using (var reader = container.OpenFile(FileName, FileMode.Open)) { byte[] buffer = new byte[reader.Length]; reader.Read(buffer, 0, (int)reader.Length); playerId = new Guid(buffer); success = true; } } } catch { /* swallow errors */ } if (!success) { playerId = Guid.NewGuid(); try { using (var writer = container.CreateFile(FileName)) { var bytes = playerId.ToByteArray(); writer.Write(bytes, 0, bytes.Length); } } catch { /* swallow errors */ } } } _playerIdGuid = playerId; if (LoadPlayerIdCompleted != null) { System.Windows.Deployment.Current.Dispatcher.BeginInvoke(() => LoadPlayerIdCompleted(this, playerId)); } }
} // GetSerializableProperties #endregion #region Save Scene public static void SaveScene() { // If a save is pending, save as soon as the storage device is chosen. IAsyncResult result = StorageDevice.BeginShowSelector(PlayerIndex.One, null, null); result.AsyncWaitHandle.WaitOne(); StorageDevice device = StorageDevice.EndShowSelector(result); // Create the data to save. SceneData data = CreateSaveData(); // Open a storage container. result = device.BeginOpenContainer("StorageDemo", null, null); // Wait for the WaitHandle to become signaled. result.AsyncWaitHandle.WaitOne(); StorageContainer container = device.EndOpenContainer(result); // Close the wait handle. result.AsyncWaitHandle.Close(); string filename = "savegame.sav"; // Check to see whether the save exists. if (container.FileExists(filename)) // Delete it so that we can create one fresh. container.DeleteFile(filename); // Create the file. Stream stream = container.CreateFile(filename); // Convert the object to XML data and put it in the stream. XmlSerializer serializer = new XmlSerializer(typeof(SceneData)); serializer.Serialize(stream, data); // Close the file. stream.Close(); // Dispose the container, to commit changes. container.Dispose(); } // Save Scene
/// <summary> /// Event handler for when the user selects ok on the "are you sure /// you want to exit" message box. /// </summary> void ConfirmExitMessageBoxAccepted(object sender, PlayerIndexEventArgs e) { #region save if ((null == evdEnGlobals.Storage) || !evdEnGlobals.Storage.IsConnected) { } else { try { IAsyncResult result = evdEnGlobals.Storage.BeginOpenContainer(evdEnGlobals.GameName, null, null); // Wait for the WaitHandle to become signaled. result.AsyncWaitHandle.WaitOne(); StorageContainer container = evdEnGlobals.Storage.EndOpenContainer(result); // Close the wait handle. result.AsyncWaitHandle.Close(); string filename = string.Format("save{0}.evden", evdEnGlobals.random.Next(10)); if (container.FileExists(filename)) { container.DeleteFile(filename); } Stream stream = container.CreateFile(filename); evdEnData.evdRunningGame.Save(stream, evdEnGlobals.myGame); stream.Close(); container.Dispose(); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } } #endregion ExitScreen(); evdEnGlobals.screenManager.AddScreen(new BackgroundScreen(), null); evdEnGlobals.screenManager.AddScreen(new MainMenuScreen(), null); }
private void SaveToDevice(IAsyncResult r) { try { device = StorageDevice.EndShowSelector(r); SaveGame data = new SaveGame() { PlayerPosition = playerPosition, PlayerSize = playerSize, Terrain = terrain, ModelRotation = modelRotation, ModelActivated = modelActivated, }; IAsyncResult result = device.BeginOpenContainer(containerName, null, null); result.AsyncWaitHandle.WaitOne(); StorageContainer container = device.EndOpenContainer(result); result.AsyncWaitHandle.Close(); if (container.FileExists(this.filename)) { container.DeleteFile(this.filename); } Stream stream = container.CreateFile(this.filename); XmlSerializer serializer = new XmlSerializer(typeof(SaveGame)); serializer.Serialize(stream, data); stream.Close(); container.Dispose(); } catch (System.ArgumentException e) { Console.WriteLine(e.Message); } }