protected void LoadFromDevice(StorageDevice device) { IAsyncResult result = device.BeginOpenContainer(containerName, null, null); result.AsyncWaitHandle.WaitOne(); StorageContainer container = device.EndOpenContainer(result); result.AsyncWaitHandle.Close(); string filename = gameName + ".sav"; if (!container.FileExists(filename)) { container.Dispose(); return; } Stream stream = container.OpenFile(filename, FileMode.Open); if (stream.Length > 0) { XmlSerializer serializer = new XmlSerializer(typeof(List <HighScoreDataItem>)); highScores = (List <HighScoreDataItem>)serializer.Deserialize(stream); } stream.Close(); container.Dispose(); }
public static void Load() { IAsyncResult result = StorageDevice.BeginShowSelector(PlayerIndex.One, null, null); StorageDevice device = StorageDevice.EndShowSelector(result); 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(); // Check to see whether the save exists. if (!container.FileExists(filename)) { // If not, dispose of the container and return. container.Dispose(); return; } // Open the file. Stream stream = container.OpenFile(filename, FileMode.Open); XmlSerializer serializer = new XmlSerializer(typeof(SaveGameData)); SaveGameData data = (SaveGameData)serializer.Deserialize(stream); // Close the file. stream.Close(); // Dispose the container. container.Dispose(); LoadData(data); }
public void Load() { 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.Dispose(); return; } Stream stream = container.OpenFile(filename, FileMode.Open); XmlSerializer serializer = new XmlSerializer(typeof(ContactsList)); ContactsList contactsList = (ContactsList)serializer.Deserialize(stream); for (int i = 0; i < contactsList.name.Length; i++) { Contact c = new Contact(phone, contactsList.name[i], contactsList.number[i]); contacts.Add(c); } firstStart = contactsList.fStart; stream.Close(); container.Dispose(); }
private void Load(IAsyncResult result) { _storageDevice = StorageDevice.EndShowSelector(result); if (_storageDevice != null && _storageDevice.IsConnected) { _gameSettings = CreateNewSettings(); IAsyncResult r = _storageDevice.BeginOpenContainer(StorageContainerName, null, null); result.AsyncWaitHandle.WaitOne(); StorageContainer container = _storageDevice.EndOpenContainer(r); if (container.FileExists(Filename)) { Stream stream = container.OpenFile(Filename, FileMode.Open); try { IFormatter formatter = new BinaryFormatter(); _gameSettings = (Settings)formatter.Deserialize(stream); stream.Close(); container.Dispose(); } catch (Exception ex) { Debug.WriteLine(ex.ToString()); stream.Close(); container.Dispose(); container.DeleteFile(Filename); } } result.AsyncWaitHandle.Close(); OnSettingsLoaded(); } }
private static void do_LoadGame() { saving = true; while (!deviceFound) { ; } try { 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)) { saving = false; container.Dispose(); return; } Stream stream = container.OpenFile(filename, FileMode.Open); XmlSerializer serializer = new XmlSerializer(typeof(List <HighScoresState.HighScoreValue>)); HighScoresState.highScores = (List <HighScoresState.HighScoreValue>)serializer.Deserialize(stream); stream.Close(); container.Dispose(); } catch (FileNotFoundException) { saving = false; return; } } } } catch (Exception) { saving = false; } saving = false; }
/// <summary> /// Dispose and go dormant, normally only at end of program. /// </summary> public static void Shutdown() { if (storageContainer != null) { storageContainer.Dispose(); } storageContainer = null; storageDevice = null; dirty = false; }
private static void DoLoadGame(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)) { // If not, dispose of the container and return. container.Dispose(); return; } // Open the file. Stream stream = container.OpenFile(filename, FileMode.Open); HighScores = new List <int>(); #if WINDEMO // Read the data from the file. XmlSerializer serializer = new XmlSerializer(typeof(SaveGameData)); SaveGameData data = (SaveGameData)serializer.Deserialize(stream); #else using (StreamReader sr = new StreamReader(stream)) { System.Console.WriteLine("Loading..."); String input; displayText = ""; while ((input = sr.ReadLine()) != null) { System.Console.WriteLine(input); HighScores.Add(Int32.Parse(input)); } sr.Close(); } #endif // Close the file. stream.Close(); // Dispose the container. container.Dispose(); }
/// <summary> /// Automatically creates or reconnects to locally saved data. /// </summary> /// <param name="Name">The name of the object (should be the same each time to access old data).</param> /// <returns>Whether or not you successfully connected to the save data.</returns> public bool bind(string Name) { _so = null; name = Name; try { _savedata = new FlxSaveData(); // Open a storage container. IAsyncResult result = _device.BeginOpenContainer(Name, null, null); // Wait for the WaitHandle to become signaled. result.AsyncWaitHandle.WaitOne(); _so = _device.EndOpenContainer(result); // Close the wait handle. result.AsyncWaitHandle.Close(); // Check to see whether the save exists. if (!_so.FileExists(_savefile)) { // If not, dispose of the container and return new blank data. _so.Dispose(); _savedata = new FlxSaveData(); return(true); } // Open the file. Stream stream = _so.OpenFile(_savefile, FileMode.Open); _savedata.deserialize(stream); // Close the file. stream.Close(); // Dispose the container. _so.Dispose(); } catch { FlxG.log("WARNING: There was a problem binding to\nthe shared object data from FlxSave."); name = null; _so = null; _savedata = null; return(false); } return(true); }
//public static PrimitiveBatch primitiveBatch = null; #endregion public static bool LoadOptions() { if ((null != Storage) && Storage.IsConnected) { // Open a storage container. 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); // Get the path of the save game. if (container.FileExists(OptionsFileName)) { // Open the file. Stream stream = container.OpenFile(OptionsFileName, FileMode.Open, FileAccess.Read); BinaryFormatter formatter = new BinaryFormatter(); try { evdEnGlobals.Options = (OptionsData)formatter.Deserialize(stream); } catch { stream.Close(); container.Dispose(); // better to show some diagnostics... return(evdEnGlobals.SaveOptions()); } stream.Close(); container.Dispose(); return(true); } else { return(evdEnGlobals.SaveOptions()); } } else if (null != Storage) { // Storage was disconnected return(false); } return(false); }
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 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!!!"); } }
protected override void OnCancel(PlayerIndex playerIndex) { #if WINDOWS (Manager.Game as Game1).WriteSave(); #endif #if XBOX try { StorageContainer c = ScreenManager.GetContainer(); if (c != null) { StreamWriter writer = new StreamWriter(c.OpenFile("save.txt", FileMode.Open)); (Manager.Game as Game1).WriteTheSave(writer); c.Dispose(); } } catch { } #endif Manager.Game.Exit(); }
/// <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(); }
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(); } } }
public void SaveOptions(bool bAutoArangeClues, bool bShowClueDescriptions, bool bShowClock, bool bShowPuzzleNumber, bool bRandomizeClues, float fSoundVol, float fMusicVol) { #if XBOX StorageContainer container = m_Storage.OpenContainer("Happiness"); string filename = Path.Combine(container.Path, "Happiness.opt"); #else string filename = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\Happiness\\Happiness.opt"; #endif try { BinaryWriter bw = new BinaryWriter(File.Open(filename, FileMode.Create, FileAccess.Write)); bw.Write(m_iOptionsVersion); bw.Write(bAutoArangeClues); bw.Write(bShowClueDescriptions); bw.Write(bShowClock); bw.Write(bShowPuzzleNumber); bw.Write(bRandomizeClues); bw.Write(fSoundVol); bw.Write(fMusicVol); bw.Close(); } catch (Exception) { } #if XBOX if (container != null) { container.Dispose(); } #endif }
/// <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(); }
//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; } }
public void Write(StorageDevice device, string windowTitle, string filename) { if (device == null) { return; } // Open a storage container.StorageContainer container #if XDK bool isTransferredFromOtherPlayer; StorageContainer container = device.OpenContainer(windowTitle, false, out isTransferredFromOtherPlayer); #else IAsyncResult result = device.BeginOpenContainer(windowTitle, null, null); // wait for the waithandle to become signaled result.AsyncWaitHandle.WaitOne(); StorageContainer container = device.EndOpenContainer(result); #endif // Open the file, creating it if necessary. using (Stream stream = container.OpenFile(filename, FileMode.Create)) { StreamWriter writer = new StreamWriter(stream); Write(writer); writer.Close(); } // Dispose the container, to commit changes. container.Dispose(); }
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(); }
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(); }
void SaveBookletData(string filename, StorageDevice storageDevice, Booklet booklet) { using (StorageContainer storageContainer = storageDevice.OpenContainer("Content")) { string filenamePath = Path.Combine(storageContainer.Path, filename); using (FileStream fileStream = File.Create(filenamePath)) { BinaryWriter myBw = new BinaryWriter(fileStream); try { myBw.Write(booklet.ToByteArray()); } catch (Exception e) { ; } finally { myBw.Flush(); myBw.Close(); fileStream.Close(); _operationPending = false; storageContainer.Dispose(); } } } }
public void LoadSettings() { // Open a storage container.StorageContainer container = IAsyncResult result = device.BeginOpenContainer(Window.Title, null, null); // wait for the waithandle to become signaled result.AsyncWaitHandle.WaitOne(); StorageContainer container = device.EndOpenContainer(result); // Open the file, creating it if necessary. if (container.FileExists("settings.xml")) { using (Stream stream = container.OpenFile("settings.xml", FileMode.Open)) { XmlSerializer serializer = new XmlSerializer(typeof(Settings)); settings = (Settings)serializer.Deserialize(stream); ApplySettings(); } } else { settings.effectsVolume = DefaultEffectsVolume; settings.musicVolume = DefaultMusicVolume; ApplySettings(); } // Dispose the container, to commit changes. container.Dispose(); }
protected override void UnloadContent() { texture = null; if (storageDevice != null) { //Save out our highscores to disk if (container != null) { container.Dispose(); container = null; } } base.UnloadContent(); }
public static void saveScores(int trackID, HighScoreType mode) { { System.Diagnostics.Debug.WriteLine(scoreDoc); StorageContainer container = null; while (container == null) { IAsyncResult result = BeatShift.Storage.BeginOpenContainer(BeatShift.Title, null, null); result.AsyncWaitHandle.WaitOne(); container = BeatShift.Storage.EndOpenContainer(result); result.AsyncWaitHandle.Close(); } Stream scoreStream = container.OpenFile("HighScore_" + trackID + "_" + ((int)mode) + ".xml", FileMode.Create, FileAccess.Write); XmlWriter optsStreamWriter = XmlWriter.Create(scoreStream); scoreDoc.WriteTo(optsStreamWriter); optsStreamWriter.Flush(); scoreStream.Dispose(); scoreStream.Close(); container.Dispose(); } }
//Returns the number of existing savefiles private String[] GetSaves(StorageDevice a_device) { try { 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(); string[] filename = container.GetFileNames(); container.Dispose(); return(filename); } catch (Exception) { throw; } }
private static void init(int trackID, HighScoreType mode) { StorageContainer container = null; Boolean fileExists; while (container == null) { IAsyncResult result = BeatShift.Storage.BeginOpenContainer(BeatShift.Title, null, null); result.AsyncWaitHandle.WaitOne(); container = BeatShift.Storage.EndOpenContainer(result); result.AsyncWaitHandle.Close(); } Stream scoreStream; fileExists = container.FileExists("HighScore_" + trackID + "_" + ((int)mode) + ".xml"); if (fileExists) { scoreStream = container.OpenFile("HighScore_" + trackID + "_" + ((int)mode) + ".xml", FileMode.Open, FileAccess.Read); } else { scoreStream = TitleContainer.OpenStream("HighScore_" + trackID + "_" + ((int)mode) + ".xml"); } StreamReader scoreStreamReader = new StreamReader(scoreStream); scoreDoc = XDocument.Load(scoreStreamReader); scoreStream.Dispose(); scoreStream.Close(); container.Dispose(); }
public static bool FileExists(string filename) { try { // Open a storage container. IAsyncResult result = device.BeginOpenContainer("GreyInfection", 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. bool ret = container.FileExists(filename); container.Dispose(); return(ret); } catch (Exception) { return(false); } }
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(); } }
/// <summary> /// Loads the high score from a text file. The StorageDevice was selected during the loading screen. /// </summary> private void LoadHighscore() { StorageDevice device = (StorageDevice)ScreenManager.Game.Services.GetService(typeof(StorageDevice)); if (device != null) { StorageContainer container = device.OpenContainer("AlienGame"); if (File.Exists(Path.Combine(container.Path, "highscores.txt"))) { StreamReader reader = null; try { reader = new StreamReader(Path.Combine(container.Path, "highscores.txt")); highScore = Int32.Parse(reader.ReadToEnd(), System.Globalization.CultureInfo.InvariantCulture); } catch (FormatException) { highScore = 10000; } finally { if (reader != null) { reader.Close(); reader.Dispose(); } } } 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(); } }