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 void LoadSaveData(StorageDevice device)
{
result = device.BeginOpenContainer("Storage", null, null);
result.AsyncWaitHandle.WaitOne();
StorageContainer container = device.EndOpenContainer(result);
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 file.
Stream stream = container.OpenFile(filename, FileMode.Open);
XmlSerializer serializer = new XmlSerializer(typeof(SaveGameData));
loadedData = (SaveGameData)serializer.Deserialize(stream);
//close file
stream.Close();
container.Dispose();
}
public GameData(StorageDevice device)
{
this.device = device;
// initialize score
saveGameData.levelCompleted = 0;
saveGameData.currentlevel = 1;
saveGameData.score = 0;
saveGameData.levelData = new LevelData[GameConstants.LEVELS];
for (int i = 0; i < GameConstants.LEVELS; i++)
{
saveGameData.levelData[i].currentlevelNum = i + 1;
saveGameData.levelData[i].time = TimeSpan.Zero.ToString();
saveGameData.levelData[i].levelParTime = TimeSpan.Zero.ToString();
saveGameData.levelData[i].remainingHealth = GameConstants.HEALTH;
}
//
GetDevice();
GetContainer();
if (!Load())
{
GetContainer();
Save();
}
}
public ProfileSelectionScreen(StorageDevice device)
: base("Choose your active profile:")
{
IsPopup = true;
mDevice = device;
this.Buttons.Clear();
var temp = Profile.LoadAll(mDevice);
mDefault = mSelectedButton = temp.Key;
if (temp.Key < 0)
{
mSelectedButton = 0;
}
mProfiles = temp.Value;
for(int i = 0; i < mProfiles.Length; i++)
{
Button btn = new Button(mProfiles[i] != null ? mProfiles[i].Name : "-Empty-");
btn.Pressed += ProfileSelectedButton;
Buttons.Add(btn);
}
}
public void Initialize(ContentManager Content, GraphicsDevice Graphics)
{
StorageDeviceResult = StorageDevice.BeginShowSelector(PlayerIndex.One, null, null);
StorageDeviceResult.AsyncWaitHandle.WaitOne();
StorageDevice = StorageDevice.EndShowSelector(StorageDeviceResult);
StorageDeviceResult.AsyncWaitHandle.Close();
OpenContainer();
this.Content = Content;
this.Graphics = Graphics;
this.SpriteBatch = new SpriteBatch(Graphics);
this.SpriteFont = Content.Load<SpriteFont>("DefaultFont");
ScreenHeight = Graphics.Viewport.Height;
ScreenWidth = Graphics.Viewport.Width;
ScreenHeightHalf = ScreenHeight / 2;
ScreenWidthHalf = ScreenWidth / 2;
FullScreenRectangle = new Rectangle(0, 0, (int)ScreenWidth, (int)ScreenHeight);
Random = new Random();
PixelWhite = new Texture2D(Graphics, 1, 1);
Color[] data = { Color.White };
PixelWhite.SetData<Color>(data);
int GardientSize = 1000;
Gardient = new Texture2D(Graphics, GardientSize, GardientSize);
data = new Color[GardientSize * GardientSize];
for (int x = 0; x < GardientSize; x++)
{
for (int y = 0; y < GardientSize; y++)
{
float c = 1.0f - ((float)(x * y)) / (GardientSize * GardientSize);
data[x + y * GardientSize] = new Color(c, c, c);
}
}
Gardient.SetData<Color>(data);
}
void saveLevel(IAsyncResult result)
{
SaveLevelData data = new SaveLevelData();
data.objectList = level.entityList;
data.currentPosition = level.currentPosition;
data.multiSelect = level.multiSelect;
data.upTime = level.upTime;
data.holdTime = level.holdTime;
data.filename = level.levelName;
device = StorageDevice.EndShowSelector(result);
if (device != null && device.IsConnected)
{
IAsyncResult r = device.BeginOpenContainer("MyGamesStorage", null, null);
result.AsyncWaitHandle.WaitOne();
StorageContainer container = device.EndOpenContainer(r);
if (container.FileExists(level.levelName + ".sav"))
container.DeleteFile(level.levelName + ".sav");
Stream stream = container.CreateFile(level.levelName + ".sav");
XmlSerializer serializer = new XmlSerializer(typeof(SaveLevelData));
serializer.Serialize(stream, data);
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();
}
}
public void ExecuteSave(int slot, Action callback = null)
{
_slot = slot;
_saveCallback = callback;
_storageDevice = null;
StorageDevice.BeginShowSelector(PlayerIndex.One, Save, null);
}
/// <summary>
/// Initializes a new instance of the <see cref="StorageContainer"/> class.
/// </summary>
/// <param name='device'>The attached storage-device.</param>
/// <param name='name'>The title's filename.</param>
/// <param name='rootPath'>The path of the storage root folder</param>
/// <param name='playerIndex'>
/// The index of the player whose data is being saved, or null if data is for all
/// players.
/// </param>
internal StorageContainer(
StorageDevice device,
string name,
string rootPath,
PlayerIndex? playerIndex
)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("A title name has to be provided in parameter name.");
}
StorageDevice = device;
DisplayName = name;
// Generate the path of the game's savefolder
storagePath = Path.Combine(
rootPath,
Path.GetFileNameWithoutExtension(
AppDomain.CurrentDomain.FriendlyName
)
);
// Create the root folder for all titles, if needed.
if (!Directory.Exists(storagePath))
{
Directory.CreateDirectory(storagePath);
}
storagePath = Path.Combine(storagePath, name);
// Create the sub-folder for this container/title's files, if needed.
if (!Directory.Exists(storagePath))
{
Directory.CreateDirectory(storagePath);
}
/* There are two types of subfolders within a StorageContainer.
* The first is a PlayerX folder, X being a specified PlayerIndex.
* The second is AllPlayers, when PlayerIndex is NOT specified.
* Basically, you should NEVER expect to have ANY file in the root
* game save folder.
* -flibit
*/
if (playerIndex.HasValue)
{
storagePath = Path.Combine(storagePath, "Player" + ((int) playerIndex.Value + 1).ToString());
}
else
{
storagePath = Path.Combine(storagePath, "AllPlayers");
}
// Create the player folder, if needed.
if (!Directory.Exists(storagePath))
{
Directory.CreateDirectory(storagePath);
}
}
internal SaveOperationAsyncResult(StorageDevice device, string container, string file, FileAction action, FileMode mode)
{
this.storageDevice = device;
this.containerName = container;
this.fileName = file;
this.fileAction = action;
this.fileMode = mode;
}
// Avaa leveli nimen mukaan
public void loadLevel(string nimi)
{
device = StorageDevice.EndShowSelector(result);
if (device != null && device.IsConnected)
{
DoLoadGame( device );
}
}
/// <summary>
/// This method gets the filenames from the universal storage file LbKTileData.sav
/// </summary>
/// <param name="device"></param>
/// <param name="gamer"></param>
/// <param name="fileNamesOnly"></param>
public static void LoadGame(StorageDevice device, SignedInGamer gamer, bool fileNamesOnly)
{
// Open a storage container.
// name of container is LbK Storage Device
IAsyncResult result =
device.BeginOpenContainer(gamer.Gamertag, 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 = "LbKTileData.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 file = container.OpenFile(filename, FileMode.Open);
// Read the data from the file.
XmlSerializer serializer = new XmlSerializer(typeof(SaveGameData));
SaveGameData data = (SaveGameData)serializer.Deserialize(file);
// Close the file.
file.Close();
// Dispose the container.
container.Dispose();
// Report the data to the console.
if (fileNamesOnly)
{
fileNames = data.Names;
}
else
{
position = data.TilePosition;
type = data.TileType;
objectNumber = data.TileObjectNumber;
count = data.TileCount;
fileNames = data.Names;
}
GamePlayScreen.storageDevice = device;
// load up game with respective device
}
public StorageContainer(StorageDevice device, string name)
{
_device = device;
_name = name;
_path = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)+System.IO.Path.DirectorySeparatorChar+name;
// Creathe the "device" if need
if (!Directory.Exists(_path))
{
Directory.CreateDirectory(_path);
}
}
public void Update()
{
if (pendingDevice)
{
if (deviceResult.IsCompleted)
{
//device = Guide.EndShowStorageDeviceSelector(deviceResult);
device = StorageDevice.EndShowSelector(deviceResult);
pendingDevice = false;
Read(STORE_SETTINGS);
}
}
}
public LevelNames()
{
device = null;
if(check)
{
StorageDevice.BeginShowSelector(PlayerIndex.One, this.loadLevelName, null);
}
if(check == false)
{
filenames = new List<string>();
StorageDevice.BeginShowSelector(PlayerIndex.One, this.saveLevelName, null);
}
}
public SaveScore()
{
device = null;
if (check) {
StorageDevice.BeginShowSelector(PlayerIndex.One, this.loadLevelName, null);
}
if (check == false)
{
levelNames = new List<string>();
timeScores = new List<int>();
hitsScores = new List<int>();
StorageDevice.BeginShowSelector(PlayerIndex.One, this.save, null);
}
}
internal static StorageContainer OpenContainer(StorageDevice storageDevice, string saveGameName)
{
IAsyncResult result = storageDevice.BeginOpenContainer(saveGameName, null, null);
// Wait for the WaitHandle to become signaled.
result.AsyncWaitHandle.WaitOne();
StorageContainer container = storageDevice.EndOpenContainer(result);
// Close the wait handle.
result.AsyncWaitHandle.Close();
return container;
}
/// <summary>
/// This method loads a serialized data object
/// from the StorageContainer for this game.
/// </summary>
/// <param name="device"></param>
public static void LoadGame(StorageDevice device, SignedInGamer gamer)
{
// Open a storage container.
// name of container is LbK Storage Device
IAsyncResult result =
device.BeginOpenContainer("LbK Storage Device", 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 = "LbKSavedItems.sav";
// Check to see whether the save exists.
if (!container.FileExists(filename))
{
// If not, dispose of the container and return.
container.Dispose();
nothingLoaded = true;
return;
}
// Open the file.
Stream file = container.OpenFile(filename, FileMode.Open);
// Read the data from the file.
XmlSerializer serializer = new XmlSerializer(typeof(SaveGameData));
SaveGameData data = (SaveGameData)serializer.Deserialize(file);
// Close the file.
file.Close();
// Dispose the container.
container.Dispose();
// Report the data to the console.
playerName = data.PlayerName;
level = data.Level;
score = data.PlayerScore;
position = new Vector2(data.playerPosition.X, data.playerPosition.Y);
checkPoint = data.CheckPoint;
GamePlayScreen.storageDevice = device;
// load up game with respective device
}
public void InitiateLoad(Game1 game, string filename)
{
this.filename = filename + ".sav";
try
{
device = null;
StorageDevice.BeginShowSelector(LoadFromDevice, null);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public void SaveGame(SaveGameData saveGameData, string containerName, string fileName)
{
device = null;
this.saveGameData = saveGameData;
this.containerName = containerName;
this.fileName = fileName;
try
{
StorageDevice.BeginShowSelector(PlayerIndex.One, this.SaveToFile, null);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public void InitiateLoad()
{
try
{
if (!Guide.IsVisible)
{
device = null;
StorageDevice.BeginShowSelector(PlayerIndex.One, this.LoadFromDevice, null);
}
}
catch (InvalidOperationException invalidOperationException)
{
//Logger.error(“InvalidOperationException”);
StorageDevice.BeginShowSelector(PlayerIndex.One, this.LoadFromDevice, null);
}
}
public void loadGame(StorageDevice device)
{
Console.WriteLine("loading");
IAsyncResult result = device.BeginOpenContainer("Container", null, null);
result.AsyncWaitHandle.WaitOne();
StorageContainer container = device.EndOpenContainer(result);
result.AsyncWaitHandle.Close();
string filename = "savegame.sav";
if (!container.FileExists(filename))
{
container.Dispose();
return;
}
Stream stream = container.OpenFile(filename, FileMode.Open);
XmlSerializer serializer = new XmlSerializer(typeof(SaveGameData));
SaveGameData data = (SaveGameData)serializer.Deserialize(stream);
stream.Close();
container.Dispose();
game.getZoneFactory().loadZones(game.getContentHandler(), data.currentPlayerZone);
game.getZoneFactory().setCurrentZoneFromNumber(data.currentPlayerZone);
game.getPlayer().setZoneLevel(data.currentPlayerLevel);
game.getPlayer().setGlobalLocation(data.playerPosition);
game.getKeyHandler().getMovementHandler().updateDrawLocations(game.getPlayer(), game.getZoneFactory().getCurrentZone());
game.getPlayer().getStats().setFireEnergy(data.fireEnergy);
game.getPlayer().getStats().setCurrentFireEnergy(data.currentFireEnergy);
game.getPlayer().getStats().setWaterEnergy(data.waterEnergy);
game.getPlayer().getStats().setCurrentWaterEnergy(data.currentWaterEnergy);
game.getPlayer().getStats().setNatureEnergy(data.natureEnergy);
game.getPlayer().getStats().setCurrentNatureEnergy(data.currentNatureEnergy);
Console.WriteLine("Zone number: " + data.currentPlayerZone);
Console.WriteLine("Player level: " + data.currentPlayerLevel);
Console.WriteLine("Position: " + data.playerPosition);
loadRequested = false;
Console.WriteLine("load completed");
game.getGameState().setGameState();
game.getKeyHandler().updateKeys(Keyboard.GetState());
}
public TiltMain()
{
g = new globals();
g.gravity = Direction.right;//what side is up. ->Don't start a room unless the direction matches that of the player.
graphics = new GraphicsDeviceManager(this)
{
PreferredBackBufferWidth = 480,
PreferredBackBufferHeight = 272
};
IAsyncResult r = Guide.BeginShowStorageDeviceSelector(null, null);
while (!r.IsCompleted) { }
storageDevice = Guide.EndShowStorageDeviceSelector(r);
// Frame rate is 30 fps by default for Zune.
TargetElapsedTime = TimeSpan.FromSeconds(1 / 30.0);
}
internal StorageContainer(StorageDevice device, string name, PlayerIndex? playerIndex)
{
if (string.IsNullOrEmpty(name))
throw new ArgumentNullException("A title name has to be provided in parameter name.");
this._device = device;
this._name = name;
this._playerIndex = playerIndex;
this._storagePath = Path.Combine(Path.Combine(StorageDevice.StorageRoot, "SavedGames"), name);
string str = string.Empty;
if (playerIndex.HasValue)
str = Path.Combine(this._storagePath, "Player" + (object) playerIndex.Value);
if (!string.IsNullOrEmpty(str))
this._storagePath = Path.Combine(this._storagePath, "Player" + (object) playerIndex.Value);
if (Directory.Exists(this._storagePath))
return;
Directory.CreateDirectory(this._storagePath);
}
void LoadFromDevice(IAsyncResult result)
{
device = StorageDevice.EndShowSelector(result);
IAsyncResult r = device.BeginOpenContainer(ContainerName, null, null);
result.AsyncWaitHandle.WaitOne();
StorageContainer container = device.EndOpenContainer(r);
result.AsyncWaitHandle.Close();
if (container.FileExists(Filename))
{
Stream stream = container.OpenFile(Filename, FileMode.Open);
XmlSerializer serializer = new XmlSerializer(typeof(SaveGame));
SaveGame SaveData = (SaveGame)serializer.Deserialize(stream);
stream.Close();
container.Dispose();
//Update the game based on the save game file
}
Replace();
}
/// <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>
/// Loads the save when StorageDevice is ready.
/// </summary>
/// <param name="result">gives the StorageDevice to use</param>
void LoadFromDevice(IAsyncResult result)
{
_device = StorageDevice.EndShowSelector(result);
var r = _device.BeginOpenContainer(containerName, null, null);
result.AsyncWaitHandle.WaitOne();
var container = _device.EndOpenContainer(r);
result.AsyncWaitHandle.Close();
if (!container.FileExists(filename)) return;
var stream = container.OpenFile(filename, FileMode.Open);
var bfm = new BinaryFormatter();
var saveData = (SaveData)bfm.Deserialize(stream);
stream.Close();
container.Dispose();
//Update the game based on the save game file
// Hero
_inGame.Hero.gold = saveData.HeroData.gold;
_inGame.Hero.Position = saveData.HeroData.Position;
_inGame.Hero.CurrentMana = saveData.HeroData.CurrentMana;
_inGame.Hero.CurrentHitPoints = saveData.HeroData.CurrentHitPoints;
_inGame.Hero.MaxHitPoints = saveData.HeroData.MaxHitPoints;
_inGame.Hero.MaxMana = saveData.HeroData.MaxMana;
_inGame.Hero.exp = saveData.HeroData.exp;
_inGame.Hero.level = saveData.HeroData.level;
_inGame.Hero.tnl = saveData.HeroData.tnl;
// mapGrid
_inGame.mapGrid._tiles = saveData.mapgrid;
_inGame.mapGrid.Initialize();
// liveGrid
_inGame._game.Components.Remove(_inGame.liveGrid);
_inGame.liveGrid = new LiveGrid(_inGame._game, ref _inGame.mapGrid);
_inGame._game.Components.Add(_inGame.liveGrid);
// monsters
UnserializeMonsters(saveData.MonstersData);
// missiles
UnserializeMissiles(saveData.MissilesData);
}
public Storage()
{
PlayersLoaded = new ArrayList();
result = Guide.BeginShowStorageDeviceSelector(PlayerIndex.One, null, null);
Device = Guide.EndShowStorageDeviceSelector(result);
// Open a storage container.
StorageContainer container = Device.OpenContainer("Savegames");
// Add the container path to our file name.
string filename = Path.Combine(container.Path, "savegame.sav");
// Create a new file.
if (!File.Exists(filename))
{
FileStream file = File.Create(filename);
file.Close();
}
// Dispose the container, to commit the data.
container.Dispose();
}
void save(IAsyncResult result)
{
device = StorageDevice.EndShowSelector(result);
if (device != null && device.IsConnected)
{
SaveLevelNames data = new SaveLevelNames();
data.levelName = levelNames;
data.timeScore = timeScores;
data.hitsScore = hitsScores;
IAsyncResult r = device.BeginOpenContainer("MyGamesStorage", null, null);
StorageContainer container = device.EndOpenContainer(r);
if (container.FileExists("ListofScores.sav"))
container.DeleteFile("ListofScores.sav");
Stream stream = container.CreateFile("ListofScores.sav");
XmlSerializer serializer = new XmlSerializer(typeof(SaveLevelNames));
serializer.Serialize(stream, data);
stream.Close();
container.Dispose();
}
}
public void DoLoadGame(StorageDevice device)
{
// Open a storage container.
IAsyncResult 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 = "testlevel.txt";
// 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);
// Read the data from the file.
XmlSerializer serializer = new XmlSerializer(typeof(testidata));
testidata = (int)serializer.Deserialize(stream);
// Close the file.
stream.Close();
// Dispose the container.
container.Dispose();
// Report the data to the console.
Debug.WriteLine("Leveldata: " + testidata);
}
//
// Summary:
// Ends the display of the storage selector user interface. Reference page contains
// links to related code samples.
//
// Parameters:
// result:
// The IAsyncResult returned from BeginShowSelector.
public static StorageDevice EndShowSelector(IAsyncResult result)
{
StorageDevice returnValue = null;
try {
// Retrieve the delegate.
AsyncResult asyncResult = (AsyncResult)result;
// Wait for the WaitHandle to become signaled.
result.AsyncWaitHandle.WaitOne();
// Call EndInvoke to retrieve the results.
if (asyncResult.AsyncDelegate is ShowSelectorAsynchronousShow)
{
returnValue = ((ShowSelectorAsynchronousShow)asyncResult.AsyncDelegate).EndInvoke(result);
}
} finally {
// Close the wait handle.
result.AsyncWaitHandle.Close();
}
return(returnValue);
}
/// <summary>
/// Initializes a new instance of the <see cref="Microsoft.Xna.Framework.Storage.StorageContainer"/> class.
/// </summary>
/// <param name='device'>The attached storage-device.</param>
/// <param name='name'> name.</param>
/// <param name='playerIndex'>The player index of the player to save the data.</param>
internal StorageContainer(StorageDevice device, string name, PlayerIndex?playerIndex)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("A title name has to be provided in parameter name.");
}
_device = device;
_name = name;
// From the examples the root is based on MyDocuments folder
#if WINDOWS_STOREAPP
var saved = "";
#elif LINUX || MONOMAC
// We already have a SaveData folder on Mac/Linux.
var saved = StorageDevice.StorageRoot;
#else
var root = StorageDevice.StorageRoot;
var saved = Path.Combine(root, "SavedGames");
#endif
_storagePath = Path.Combine(saved, name);
var playerSave = string.Empty;
if (playerIndex.HasValue)
{
playerSave = Path.Combine(_storagePath, "Player" + (int)playerIndex.Value);
}
if (!string.IsNullOrEmpty(playerSave))
{
_storagePath = Path.Combine(_storagePath, "Player" + (int)playerIndex);
}
// Create the "device" if need be
CreateDirectoryAbsolute(_storagePath);
}
/// <summary>
/// Initializes a new instance of the <see cref="Microsoft.Xna.Framework.Storage.StorageContainer"/> class.
/// </summary>
/// <param name='_device'>
/// _device.
/// </param>
/// <param name='_name'>
/// _name.
/// </param>
/// <param name='playerIndex'>
/// The player index of the player to save the data
/// </param>
internal StorageContainer(StorageDevice device, string name, PlayerIndex?playerIndex)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("A title name has to be provided in parameter name.");
}
_device = device;
_name = name;
_playerIndex = playerIndex;
// From the examples the root is based on MyDocuments folder
var root = StorageDevice.StorageRoot;
var saved = Path.Combine(root, "SavedGames");
_storagePath = Path.Combine(saved, name);
var playerSave = string.Empty;
if (playerIndex.HasValue)
{
playerSave = Path.Combine(root, "Player" + (int)playerIndex.Value);
}
if (!string.IsNullOrEmpty(playerSave))
{
_storagePath = Path.Combine(root, "Player" + (int)playerIndex);
}
// Creathe the "device" if need be
if (!Directory.Exists(_storagePath))
{
Directory.CreateDirectory(_storagePath);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="StorageContainer"/> class.
/// </summary>
/// <param name='device'>The attached storage-device.</param>
/// <param name='name'>The title's filename.</param>
/// <param name='rootPath'>The path of the storage root folder</param>
/// <param name='playerIndex'>
/// The index of the player whose data is being saved, or null if data is for all
/// players.
/// </param>
internal StorageContainer(
StorageDevice device,
string name,
string rootPath,
PlayerIndex?playerIndex
)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("A title name has to be provided in parameter name.");
}
StorageDevice = device;
DisplayName = name;
/* There are two types of subfolders within a StorageContainer.
* The first is a PlayerX folder, X being a specified PlayerIndex.
* The second is AllPlayers, when PlayerIndex is NOT specified.
* Basically, you should NEVER expect to have ANY file in the root
* game save folder.
* -flibit
*/
storagePath = Path.Combine(
rootPath, // Title folder (EXE name)...
name, // Container folder...
playerIndex.HasValue ? // Player folder...
("Player" + ((int)playerIndex.Value + 1).ToString()) :
"AllPlayers"
);
// Create the folders, if needed.
if (!Directory.Exists(storagePath))
{
Directory.CreateDirectory(storagePath);
}
}
public static IAsyncResult BeginShowSelector(PlayerIndex player, AsyncCallback callback, object state)
{
return(StorageDevice.BeginShowSelector(player, 0, 0, callback, state));
}
public static IAsyncResult BeginShowSelector(AsyncCallback callback, object state)
{
return(StorageDevice.BeginShowSelector(0, 0, callback, state));
}
/// <summary>
/// Initializes a new instance of the <see cref="StorageContainer"/> class.
/// </summary>
/// <param name='device'>The attached storage-device.</param>
/// <param name='name'>The title's filename.</param>
/// <param name='playerIndex'>
/// The index of the player whose data is being saved, or null if data is for all
/// players.
/// </param>
internal StorageContainer(
StorageDevice device,
string name,
PlayerIndex?playerIndex
)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("A title name has to be provided in parameter name.");
}
StorageDevice = device;
DisplayName = name;
string saved;
if (Game.Instance.Platform.OSVersion.Equals("Windows"))
{
// The root on Windows is the "My Documents" folder
saved = Path.Combine(StorageDevice.storageRoot, "SavedGames");
}
else if (Game.Instance.Platform.OSVersion.Equals("Mac OS X") ||
Game.Instance.Platform.OSVersion.Equals("Linux"))
{
// Unix-like systems are expected to have a dedicated userdata folder.
saved = StorageDevice.storageRoot;
}
else
{
throw new Exception("StorageContainer: Platform.OSVersion not handled!");
}
storagePath = Path.Combine(
saved,
Path.GetFileNameWithoutExtension(
AppDomain.CurrentDomain.FriendlyName
)
);
// Create the root folder for all titles, if needed.
if (!Directory.Exists(storagePath))
{
Directory.CreateDirectory(storagePath);
}
storagePath = Path.Combine(storagePath, name);
// Create the sub-folder for this container/title's files, if needed.
if (!Directory.Exists(storagePath))
{
Directory.CreateDirectory(storagePath);
}
/* There are two types of subfolders within a StorageContainer.
* The first is a PlayerX folder, X being a specified PlayerIndex.
* The second is AllPlayers, when PlayerIndex is NOT specified.
* Basically, you should NEVER expect to have ANY file in the root
* game save folder.
* -flibit
*/
if (playerIndex.HasValue)
{
storagePath = Path.Combine(storagePath, "Player" + ((int)playerIndex.Value + 1).ToString());
}
else
{
storagePath = Path.Combine(storagePath, "AllPlayers");
}
// Create the player folder, if needed.
if (!Directory.Exists(storagePath))
{
Directory.CreateDirectory(storagePath);
}
}
