/// <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);
}
}
