/// <summary>
/// Delete the save game specified by the description.
/// </summary>
/// <param name="storageDevice">The chosen storage device.</param>
/// <param name="saveGameDescription">The description of the save game.</param>
public static void DeleteSaveGameResult(StorageDevice storageDevice, SaveGameDescription saveGameDescription)
{
if (saveGameDescription == null)
{
throw new ArgumentNullException("saveGameDescription");
}
if (storageDevice == null)
{
throw new ArgumentNullException("storageDevice");
}
if (!storageDevice.IsConnected)
{
throw new InvalidOperationException("Cannot connect to storage device.");
}
// open the container
using (StorageContainer storageContainer = OpenContainer(storageDevice))
{
storageContainer.DeleteFile(saveGameDescription.FileName);
storageContainer.DeleteFile("SaveGameDescription" +
Path.GetFileNameWithoutExtension(saveGameDescription.FileName).Substring(8) + ".xml");
}
}
/// <summary>
/// ファイルを削除します。
/// </summary>
/// <param name="name">ファイル名。</param>
public void DeleteFile(string name)
{
var path = ResolveChildPath(name);
container.DeleteFile(path);
index.FileNames.Remove(name);
SaveIndexFile();
}
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>
/// 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();
}
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!!!");
}
}
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();
}
}
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!!!");
}
}
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();
}
}
private void DeleteExisting()
{
if (storageContainer.FileExists(filename))
{
storageContainer.DeleteFile(filename);
}
}
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();
}
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();
}
//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 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);
}
}
}
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();
}
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(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();
}
}
}
/// <summary>
/// Deletes the save file in the given save slot.
/// </summary>
/// <param name="saveSlot"></param>
public void Delete(SaveSlot saveSlot)
{
StorageContainer container = SmileyUtil.GetStorageContainer();
container.DeleteFile(saveSlot.GetDescription());
Saves[saveSlot] = new SaveFile(saveSlot.GetDescription())
{
IsEmpty = true
};
}
/// <summary>
/// Saves the current configuration data.
/// </summary>
public void SaveConfig()
{
StorageContainer container = SmileyUtil.GetStorageContainer();
container.DeleteFile(ConfigFile);
using (Stream stream = container.OpenFile(ConfigFile, FileMode.Create))
{
XmlSerializer serializer = new XmlSerializer(typeof(SmileyConfig));
serializer.Serialize(stream, _config);
}
}
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;
}
private void CopyFile(StorageContainer container, string fileName, string newFileName)
{
if (!container.FileExists(fileName))
{
return;
}
if (container.FileExists(newFileName))
{
container.DeleteFile(newFileName);
}
Stream oldFile = container.OpenFile(fileName, FileMode.Open);
Stream newFile = container.CreateFile(newFileName);
oldFile.CopyTo(newFile);
oldFile.Close();
newFile.Close();
container.DeleteFile(fileName);
}
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();
}
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);
}
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();
}
protected void DeleteFile(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.DeleteFile(filename);
}
container.Dispose();
}
/// <summary>
/// Deletes a file.
/// </summary>
/// <param name="containerName">The name of the container from which to delete the file.</param>
/// <param name="fileName">The file to delete.</param>
public void Delete(string containerName, string fileName)
{
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 to delete the file
if (currentContainer.FileExists(fileName))
{
currentContainer.DeleteFile(fileName);
}
}
}
}
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();
}
} // 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);
}
public void SaveData(SaveGameData data)
{
// 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(SaveGameData));
serializer.Serialize(stream, data);
stream.Close();
container.Dispose();
}
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);
}
}
