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();
}
/// <summary>
/// Save the current state of the session, with the given storage device.
/// </summary>
/// <param name="storageDevice">The chosen storage device.</param>
/// <param name="overwriteDescription">
/// The description of the save game to over-write, if any.
/// </param>
private static void SaveSessionResult(StorageDevice storageDevice,
SaveGameDescription overwriteDescription)
{
// check the parameter
if ((storageDevice == null) || !storageDevice.IsConnected)
{
return;
}
// open the container
using (StorageContainer storageContainer =
storageDevice.OpenContainer(Session.SaveGameContainerName))
{
string filename;
string descriptionFilename;
// get the filenames
if (overwriteDescription == null)
{
int saveGameIndex = 0;
string testFilename;
do
{
saveGameIndex++;
testFilename = Path.Combine(storageContainer.Path, "SaveGame" +
saveGameIndex.ToString() + ".xml");
}
while (File.Exists(testFilename));
filename = testFilename;
descriptionFilename = "SaveGameDescription" +
saveGameIndex.ToString() + ".xml";
}
else
{
filename = Path.Combine(storageContainer.Path,
overwriteDescription.FileName);
descriptionFilename = "SaveGameDescription" +
Path.GetFileNameWithoutExtension(
overwriteDescription.FileName).Substring(8) + ".xml";
}
using (FileStream stream = new FileStream(filename, FileMode.Create))
{
using (XmlWriter xmlWriter = XmlWriter.Create(stream))
{
// <rolePlayingGameData>
xmlWriter.WriteStartElement("rolePlayingGameSaveData");
// write the map information
xmlWriter.WriteStartElement("mapData");
xmlWriter.WriteElementString("mapContentName",
TileEngine.Map.AssetName);
new XmlSerializer(typeof(PlayerPosition)).Serialize(
xmlWriter, TileEngine.PartyLeaderPosition);
new XmlSerializer(typeof(List<WorldEntry<Chest>>)).Serialize(
xmlWriter, singleton.removedMapChests);
new XmlSerializer(
typeof(List<WorldEntry<FixedCombat>>)).Serialize(
xmlWriter, singleton.removedMapFixedCombats);
new XmlSerializer(typeof(List<WorldEntry<Player>>)).Serialize(
xmlWriter, singleton.removedMapPlayerNpcs);
new XmlSerializer(typeof(List<ModifiedChestEntry>)).Serialize(
xmlWriter, singleton.modifiedMapChests);
xmlWriter.WriteEndElement();
// write the quest information
xmlWriter.WriteStartElement("questData");
xmlWriter.WriteElementString("questLineContentName",
singleton.questLine.AssetName);
xmlWriter.WriteElementString("currentQuestIndex",
singleton.currentQuestIndex.ToString());
new XmlSerializer(typeof(List<WorldEntry<Chest>>)).Serialize(
xmlWriter, singleton.removedQuestChests);
new XmlSerializer(
typeof(List<WorldEntry<FixedCombat>>)).Serialize(
xmlWriter, singleton.removedQuestFixedCombats);
new XmlSerializer(typeof(List<ModifiedChestEntry>)).Serialize(
xmlWriter, singleton.modifiedQuestChests);
xmlWriter.WriteElementString("currentQuestStage",
IsQuestLineComplete ?
Quest.QuestStage.NotStarted.ToString() :
singleton.quest.Stage.ToString());
xmlWriter.WriteEndElement();
// write the party data
new XmlSerializer(typeof(PartySaveData)).Serialize(xmlWriter,
new PartySaveData(singleton.party));
// </rolePlayingGameSaveData>
xmlWriter.WriteEndElement();
}
}
// create the save game description
SaveGameDescription description = new SaveGameDescription();
description.FileName = Path.GetFileName(filename);
description.ChapterName = IsQuestLineComplete ? "Quest Line Complete" :
Quest.Name;
description.Description = DateTime.Now.ToString();
using (FileStream stream = new FileStream(Path.Combine(
storageContainer.Path, descriptionFilename), FileMode.Create))
{
new XmlSerializer(typeof(SaveGameDescription)).Serialize(stream,
description);
}
}
}
/// <summary>
/// Asynchronous storage-device callback for
/// refreshing the save-game descriptions.
/// </summary>
private static void RefreshSaveGameDescriptionsResult(
StorageDevice storageDevice)
{
// check the parameter
if ((storageDevice == null) || !storageDevice.IsConnected)
{
return;
}
// open the container
using (StorageContainer storageContainer =
storageDevice.OpenContainer(Session.SaveGameContainerName))
{
saveGameDescriptions = new List<SaveGameDescription>();
// get the description list
string[] filenames = Directory.GetFiles(storageContainer.Path,
"SaveGameDescription*.xml");
// add each entry to the list
foreach (string filename in filenames)
{
SaveGameDescription saveGameDescription;
// check the size of the list
if (saveGameDescriptions.Count >= MaximumSaveGameDescriptions)
{
break;
}
// open the file stream
using (FileStream fileStream = File.Open(filename, FileMode.Open))
{
// deserialize the object
saveGameDescription =
saveGameDescriptionSerializer.Deserialize(fileStream)
as SaveGameDescription;
// if it's valid, add it to the list
if (saveGameDescription != null)
{
saveGameDescriptions.Add(saveGameDescription);
}
}
}
}
}
protected void SaveFile(StorageDevice device, string fi, string teta, string alfa)
{
//Массив байтов для записи в файл
byte[] fia = new byte[fi.Length];
byte[] tetaa = new byte[teta.Length];
byte[] alfaa = new byte[alfa.Length];
byte[] a = new byte[1];
a[0] = Convert.ToByte(0);
for (byte i = 0; i < fi.Length; i++)
{
fia[i] = Convert.ToByte(fi[i]);
}
for (byte i = 0; i < teta.Length; i++)
{
tetaa[i] = Convert.ToByte(teta[i]);
}
for (byte i = 0; i < alfa.Length; i++)
{
alfaa[i] = Convert.ToByte(alfa[i]);
}
//Открываем контейнер для хранения файлов
//В случае с Windows-играми это - папка с соответствующим
//именем в папке Мои документы текущего пользователя
StorageContainer container = device.OpenContainer("Diplom");
//Соединяем имя файла и имя контейнера
string filename = Path.Combine(container.Path, "corner" + countnumber + ".txt");
//Создаем новый файл
countnumber++;
if (!File.Exists(filename))
{
FileStream file = File.Create(filename);
//Записываем в файл массив байтов, сгенерированный выше
file.Write(fia, 0, fi.Length);
file.Write(a, 0, 1);
file.Write(tetaa, 0, teta.Length);
file.Write(a, 0, 1);
file.Write(alfaa, 0, alfa.Length);
//закрываем файл
file.Close();
this.Window.Title = "Файл создан";
}
else
{
this.Window.Title = "Файл уже создан";
}
//Уничтожаем контейнер - только после этого файл будет
//сохранен
container.Dispose();
}
protected void LoadFile(StorageDevice device, string name)
{
StorageContainer container = device.OpenContainer("Diplom");
long n = 0, m = 0;
if (name.Length == 3)
{
m = Convert.ToInt64(name);
n = Convert.ToInt64(name) / 100;
name = Convert.ToString(m - n * 100);
}
if (name.Length == 6)
{
m = Convert.ToInt64(name);
n = Convert.ToInt64(name) / 1000;
name = Convert.ToString(m - n * 1000);
}
if (name.Length == 10)
{
m = Convert.ToInt64(name);
n = Convert.ToInt64(name) / 10000;
name = Convert.ToString(m - n * 10000);
}
string filename = Path.Combine(container.Path, "Trajectory" + name + ".dat");
int k = -1;
if (File.Exists(filename))
{
FileStream file = File.Open(filename, FileMode.Open);
double[] Trajectory = new double[file.Length];
byte[] bytes = new byte[4];
//Выведем данные, считанные из файла, в заголовок игрового окна
//this.Window.Title = "Содержимое файла: ";
string s;
int d = 14;
double s1 = 0;
double s2 = 0;
double s3 = 0;
length = (int)(file.Length / (14 * 5));
int b;
char c;
for (int i = 1; i < file.Length + 1; i += d)
{
s = "";
for (int j = 0; j < d; j++)
{
b = file.ReadByte();
c = Convert.ToChar(b);
//if (k == 1) s1 += c;
//if (c == 69)k=1;
if (c != 32) s += c;
}
this.Window.Title += s + " ";
string sd = s.Replace(".", ",");
sd = sd.Replace("D", "e");
k++;
if (k == 1)
{
s1 = Convert.ToDouble(sd);
d = 14;
}
if (k == 2)
{
s2 = Convert.ToDouble(sd);
}
if (k == 3)
{
s3 = Convert.ToDouble(sd);
d = 14;
}
if (k == 4)
{
d = 14;
fotonData.AddFatonDataList(s1, s2, s3);
k = -1;
}
//this.Window.Title += Convert.ToString(f) + " ";
}
file.Close();
ScienceMod = true;
readfromfile = true;
}
else
{
this.Window.Title = "Отсутствует файл для чтения";
readfromfile = false;
}
formCollection["LibraryMenu"]["textbox1"].Text = "";
container.Dispose();
}
private void LoadData(StorageDevice storageDevice,ref int numChic, ref int chicQueue, ref int numRooster,
ref int roosterQueue, ref CharacterClass player, ref ChickenClass[] chickens, ref RoosterClass[] roosters,
ref EconomicsClass eco, ref int eggCount, ref int numEgg, ref EggClass[] egg, ref int days, ref float dayTime,
ref bool endOfDay, ref int numBoots, ref RubberBootClass[] boots, ref float bootTime, ref bool bootPresent,
ref bool bootEquipped, ref FoxClass fox)
{
StorageContainer myContainer = storageDevice.OpenContainer("Chicken_Game");
string filename = Path.Combine(myContainer.Path, "ChickenGameSave.sav");
if (!File.Exists(filename))
return;
FileStream fileStream = File.Open(filename, FileMode.OpenOrCreate, FileAccess.Read);
XmlSerializer serializer = new XmlSerializer(typeof(DataToSave));
DataToSave dataToSave = (DataToSave)serializer.Deserialize(fileStream);
fileStream.Close();
myContainer.Dispose();
//load character
player.position = dataToSave.cPosition;
player.rotation = dataToSave.cRotation;
player.hitPoints = dataToSave.hitpoints;
//load chickens
numChic = dataToSave.numChickens;
chicQueue = dataToSave.ChicQueue;
//load chicken1
if (dataToSave.chic1time != -1)
{
chickens[0] = new ChickenClass(Content, graphics);
chickens[0].InitializeChicken(0);
chickens[0].time = dataToSave.chic1time;
chickens[0].state = dataToSave.chic1state;
chickens[0].ground = dataToSave.chic1ground;
chickens[0].ChickenInitNode = dataToSave.chic1InitNode;
chickens[0].ChickenPreviousNode = dataToSave.chic1PreviousNode;
chickens[0].ChickenCurrentNode = dataToSave.chic1CurrentNode;
chickens[0].chickenNextNode = dataToSave.chic1NextNode;
chickens[0].position = dataToSave.chic1Position;
chickens[0].rotation = dataToSave.chic1Rotation;
chickens[0].riseRun = dataToSave.chic1RiseRun;
chickens[0].eggLaid = dataToSave.chic1EggLaid;
}
//load chicken2
if (dataToSave.chic2time != -1)
{
chickens[1] = new ChickenClass(Content, graphics);
chickens[1].InitializeChicken(0);
chickens[1].time = dataToSave.chic2time;
chickens[1].state = dataToSave.chic2state;
chickens[1].ground = dataToSave.chic2ground;
chickens[1].ChickenInitNode = dataToSave.chic2InitNode;
chickens[1].ChickenPreviousNode = dataToSave.chic2PreviousNode;
chickens[1].ChickenCurrentNode = dataToSave.chic2CurrentNode;
chickens[1].chickenNextNode = dataToSave.chic2NextNode;
chickens[1].position = dataToSave.chic2Position;
chickens[1].rotation = dataToSave.chic2Rotation;
chickens[1].riseRun = dataToSave.chic2RiseRun;
chickens[1].eggLaid = dataToSave.chic2EggLaid;
}
//load chicken3
if (dataToSave.chic3time != -1)
{
chickens[2] = new ChickenClass(Content, graphics);
chickens[2].InitializeChicken(0);
chickens[2].time = dataToSave.chic3time;
chickens[2].state = dataToSave.chic3state;
chickens[2].ground = dataToSave.chic3ground;
chickens[2].ChickenInitNode = dataToSave.chic3InitNode;
chickens[2].ChickenPreviousNode = dataToSave.chic3PreviousNode;
chickens[2].ChickenCurrentNode = dataToSave.chic3CurrentNode;
chickens[2].chickenNextNode = dataToSave.chic3NextNode;
chickens[2].position = dataToSave.chic3Position;
chickens[2].rotation = dataToSave.chic3Rotation;
chickens[2].riseRun = dataToSave.chic3RiseRun;
chickens[2].eggLaid = dataToSave.chic3EggLaid;
}
//load chicken4
if (dataToSave.chic4time != -1)
{
chickens[3] = new ChickenClass(Content, graphics);
chickens[3].InitializeChicken(0);
chickens[3].time = dataToSave.chic4time;
chickens[3].state = dataToSave.chic4state;
chickens[3].ground = dataToSave.chic4ground;
chickens[3].ChickenInitNode = dataToSave.chic4InitNode;
chickens[3].ChickenPreviousNode = dataToSave.chic4PreviousNode;
chickens[3].ChickenCurrentNode = dataToSave.chic4CurrentNode;
chickens[3].chickenNextNode = dataToSave.chic4NextNode;
chickens[3].position = dataToSave.chic4Position;
chickens[3].rotation = dataToSave.chic4Rotation;
chickens[3].riseRun = dataToSave.chic4RiseRun;
chickens[3].eggLaid = dataToSave.chic4EggLaid;
}
//load chicken5
if (dataToSave.chic5time != -1)
{
chickens[4] = new ChickenClass(Content, graphics);
chickens[4].InitializeChicken(0);
chickens[4].time = dataToSave.chic5time;
chickens[4].state = dataToSave.chic5state;
chickens[4].ground = dataToSave.chic5ground;
chickens[4].ChickenInitNode = dataToSave.chic5InitNode;
chickens[4].ChickenPreviousNode = dataToSave.chic5PreviousNode;
chickens[4].ChickenCurrentNode = dataToSave.chic5CurrentNode;
chickens[4].chickenNextNode = dataToSave.chic5NextNode;
chickens[4].position = dataToSave.chic5Position;
chickens[4].rotation = dataToSave.chic5Rotation;
chickens[4].riseRun = dataToSave.chic5RiseRun;
chickens[4].eggLaid = dataToSave.chic5EggLaid;
}
//load chicken6
if (dataToSave.chic6time != -1)
{
chickens[5] = new ChickenClass(Content, graphics);
chickens[5].InitializeChicken(0);
chickens[5].time = dataToSave.chic6time;
chickens[5].state = dataToSave.chic6state;
chickens[5].ground = dataToSave.chic6ground;
chickens[5].ChickenInitNode = dataToSave.chic6InitNode;
chickens[5].ChickenPreviousNode = dataToSave.chic6PreviousNode;
chickens[5].ChickenCurrentNode = dataToSave.chic6CurrentNode;
chickens[5].chickenNextNode = dataToSave.chic6NextNode;
chickens[5].position = dataToSave.chic6Position;
chickens[5].rotation = dataToSave.chic6Rotation;
chickens[5].riseRun = dataToSave.chic6RiseRun;
chickens[5].eggLaid = dataToSave.chic6EggLaid;
}
//load chicken7
if (dataToSave.chic7time != -1)
{
chickens[6] = new ChickenClass(Content, graphics);
chickens[6].InitializeChicken(0);
chickens[6].time = dataToSave.chic7time;
chickens[6].state = dataToSave.chic7state;
chickens[6].ground = dataToSave.chic7ground;
chickens[6].ChickenInitNode = dataToSave.chic7InitNode;
chickens[6].ChickenPreviousNode = dataToSave.chic7PreviousNode;
chickens[6].ChickenCurrentNode = dataToSave.chic7CurrentNode;
chickens[6].chickenNextNode = dataToSave.chic7NextNode;
chickens[6].position = dataToSave.chic7Position;
chickens[6].rotation = dataToSave.chic7Rotation;
chickens[6].riseRun = dataToSave.chic7RiseRun;
chickens[6].eggLaid = dataToSave.chic7EggLaid;
}
//load chicken8
if (dataToSave.chic8time != -1)
{
chickens[7] = new ChickenClass(Content, graphics);
chickens[7].InitializeChicken(0);
chickens[7].time = dataToSave.chic8time;
chickens[7].state = dataToSave.chic8state;
chickens[7].ground = dataToSave.chic8ground;
chickens[7].ChickenInitNode = dataToSave.chic8InitNode;
chickens[7].ChickenPreviousNode = dataToSave.chic8PreviousNode;
chickens[7].ChickenCurrentNode = dataToSave.chic8CurrentNode;
chickens[7].chickenNextNode = dataToSave.chic8NextNode;
chickens[7].position = dataToSave.chic8Position;
chickens[7].rotation = dataToSave.chic8Rotation;
chickens[7].riseRun = dataToSave.chic8RiseRun;
chickens[7].eggLaid = dataToSave.chic8EggLaid;
}
//load chicken9
if (dataToSave.chic9time != -1)
{
chickens[8] = new ChickenClass(Content, graphics);
chickens[8].InitializeChicken(0);
chickens[8].time = dataToSave.chic9time;
chickens[8].state = dataToSave.chic9state;
chickens[8].ground = dataToSave.chic9ground;
chickens[8].ChickenInitNode = dataToSave.chic9InitNode;
chickens[8].ChickenPreviousNode = dataToSave.chic9PreviousNode;
chickens[8].ChickenCurrentNode = dataToSave.chic9CurrentNode;
chickens[8].chickenNextNode = dataToSave.chic9NextNode;
chickens[8].position = dataToSave.chic9Position;
chickens[8].rotation = dataToSave.chic9Rotation;
chickens[8].riseRun = dataToSave.chic9RiseRun;
chickens[8].eggLaid = dataToSave.chic9EggLaid;
}
//load chicken1
if (dataToSave.chic10time != -1)
{
chickens[9] = new ChickenClass(Content, graphics);
chickens[9].InitializeChicken(0);
chickens[9].time = dataToSave.chic10time;
chickens[9].state = dataToSave.chic10state;
chickens[9].ground = dataToSave.chic10ground;
chickens[9].ChickenInitNode = dataToSave.chic10InitNode;
chickens[9].ChickenPreviousNode = dataToSave.chic10PreviousNode;
chickens[9].ChickenCurrentNode = dataToSave.chic10CurrentNode;
chickens[9].chickenNextNode = dataToSave.chic10NextNode;
chickens[9].position = dataToSave.chic10Position;
chickens[9].rotation = dataToSave.chic10Rotation;
chickens[9].riseRun = dataToSave.chic10RiseRun;
chickens[9].eggLaid = dataToSave.chic10EggLaid;
}
//economics save
eco.money = dataToSave.money;
eco.startEggs = dataToSave.startEggs;
eco.startChickens = dataToSave.startChickens;
eco.startRoosters = dataToSave.startRoosters;
eco.startmoney = dataToSave.startmoney;
eco.eggsCollected = dataToSave.eggsCollected;
eco.chickenBought = dataToSave.chickenBought;
eco.roosterBought = dataToSave.roosterBought;
eco.eggsEaten = dataToSave.eggsEaten;
eco.eggSold = dataToSave.eggSold;
eco.chickenSold = dataToSave.chickenSold;
eco.roosterSold = dataToSave.roosterSold;
eco.chickenEaten = dataToSave.chickenEaten;
eco.roosterEaten = dataToSave.roosterEaten;
eco.moneyAquired = dataToSave.moneyAquired;
//load roosters
numRooster = dataToSave.numRooster;
roosterQueue = dataToSave.roosterQueue;
//rooster1 load
if (dataToSave.rooster1state != -1)
{
roosters[0] = new RoosterClass(Content, graphics);
roosters[0].InitializeRooster(13);
roosters[0].state = dataToSave.rooster1state;
roosters[0].roosterInitNode = dataToSave.rooster1InitNode;
roosters[0].roosterPreviousNode = dataToSave.rooster1PreviousNode;
roosters[0].roosterCurrentNode = dataToSave.rooster1CurrentNode;
roosters[0].roosterNextNode = dataToSave.rooster1NextNode;
roosters[0].position = dataToSave.rooster1Position;
roosters[0].rotation = dataToSave.rooster1Rotation;
roosters[0].riseRun = dataToSave.rooster1RiseRun;
roosters[0].riseRun2 = dataToSave.rooster1RiseRun2;
roosters[0].start = dataToSave.rooster1Start;
}
//rooster2 load
if (dataToSave.rooster2state != -1)
{
roosters[1] = new RoosterClass(Content, graphics);
roosters[1].InitializeRooster(13);
roosters[1].state = dataToSave.rooster2state;
roosters[1].roosterInitNode = dataToSave.rooster2InitNode;
roosters[1].roosterPreviousNode = dataToSave.rooster2PreviousNode;
roosters[1].roosterCurrentNode = dataToSave.rooster2CurrentNode;
roosters[1].roosterNextNode = dataToSave.rooster2NextNode;
roosters[1].position = dataToSave.rooster2Position;
roosters[1].rotation = dataToSave.rooster2Rotation;
roosters[1].riseRun = dataToSave.rooster2RiseRun;
roosters[1].riseRun2 = dataToSave.rooster2RiseRun2;
roosters[1].start = dataToSave.rooster2Start;
}
//rooster3 load
if (dataToSave.rooster3state != -1)
{
roosters[2] = new RoosterClass(Content, graphics);
roosters[2].InitializeRooster(13);
roosters[2].state = dataToSave.rooster3state;
roosters[2].roosterInitNode = dataToSave.rooster3InitNode;
roosters[2].roosterPreviousNode = dataToSave.rooster3PreviousNode;
roosters[2].roosterCurrentNode = dataToSave.rooster3CurrentNode;
roosters[2].roosterNextNode = dataToSave.rooster3NextNode;
roosters[2].position = dataToSave.rooster3Position;
roosters[2].rotation = dataToSave.rooster3Rotation;
roosters[2].riseRun = dataToSave.rooster3RiseRun;
roosters[2].riseRun2 = dataToSave.rooster3RiseRun2;
roosters[2].start = dataToSave.rooster3Start;
}
//rooster4 load
if (dataToSave.rooster4state != -1)
{
roosters[3] = new RoosterClass(Content, graphics);
roosters[3].InitializeRooster(13);
roosters[3].state = dataToSave.rooster4state;
roosters[3].roosterInitNode = dataToSave.rooster4InitNode;
roosters[3].roosterPreviousNode = dataToSave.rooster4PreviousNode;
roosters[3].roosterCurrentNode = dataToSave.rooster4CurrentNode;
roosters[3].roosterNextNode = dataToSave.rooster4NextNode;
roosters[3].position = dataToSave.rooster4Position;
roosters[3].rotation = dataToSave.rooster4Rotation;
roosters[3].riseRun = dataToSave.rooster4RiseRun;
roosters[3].riseRun2 = dataToSave.rooster4RiseRun2;
roosters[3].start = dataToSave.rooster4Start;
}
//rooster5 load
if (dataToSave.rooster5state != -1)
{
roosters[4] = new RoosterClass(Content, graphics);
roosters[4].InitializeRooster(13);
roosters[4].state = dataToSave.rooster5state;
roosters[4].roosterInitNode = dataToSave.rooster5InitNode;
roosters[4].roosterPreviousNode = dataToSave.rooster5PreviousNode;
roosters[4].roosterCurrentNode = dataToSave.rooster5CurrentNode;
roosters[4].roosterNextNode = dataToSave.rooster5NextNode;
roosters[4].position = dataToSave.rooster5Position;
roosters[4].rotation = dataToSave.rooster5Rotation;
roosters[4].riseRun = dataToSave.rooster5RiseRun;
roosters[4].riseRun2 = dataToSave.rooster5RiseRun2;
roosters[4].start = dataToSave.rooster5Start;
}
//eggclass
eggCount = dataToSave.eggCount;
numEgg = dataToSave.numEgg;
if (numEgg > 0)
{
egg[0].position = new Vector3();
egg[0].position = new Vector3(dataToSave.egg1.X, dataToSave.egg1.Y, dataToSave.egg1.Z);
}
if (numEgg > 1)
{
egg[1].position = new Vector3();
egg[1].position = new Vector3(dataToSave.egg2.X, dataToSave.egg2.Y, dataToSave.egg2.Z);
}
if (numEgg > 2)
{
egg[2].position = new Vector3();
egg[2].position = new Vector3(dataToSave.egg3.X,dataToSave.egg3.Y,dataToSave.egg3.Z);
}
if (numEgg > 3)
{
egg[3].position = new Vector3();
egg[3].position = new Vector3(dataToSave.egg4.X,dataToSave.egg4.Y, dataToSave.egg4.Z);
}
if (numEgg > 4)
{
egg[4].position = new Vector3();
egg[4].position = new Vector3(dataToSave.egg5.X, dataToSave.egg5.Y, dataToSave.egg5.Z);
}
if (numEgg > 5)
{
egg[5].position = new Vector3();
egg[5].position = new Vector3(dataToSave.egg6.X, dataToSave.egg6.Y, dataToSave.egg6.Z);
}
if (numEgg > 6)
{
egg[6].position = new Vector3();
egg[6].position = new Vector3(dataToSave.egg7.X, dataToSave.egg7.Y, dataToSave.egg7.Z);
}
if (numEgg > 7)
{
egg[7].position = new Vector3();
egg[7].position = new Vector3(dataToSave.egg8.X, dataToSave.egg8.Y, dataToSave.egg8.Z);
}
if (numEgg > 8)
{
egg[8].position = new Vector3();
egg[8].position = new Vector3(dataToSave.egg9.X, dataToSave.egg9.Y, dataToSave.egg9.Z);
}
if (numEgg > 9)
{
egg[9].position = new Vector3();
egg[9].position = new Vector3(dataToSave.egg10.X, dataToSave.egg10.Y, dataToSave.egg10.Z);
}
if (numEgg > 10)
{
egg[10].position = new Vector3();
egg[10].position = new Vector3(dataToSave.egg11.X, dataToSave.egg11.Y, dataToSave.egg11.Z);
}
if (numEgg > 11)
{
egg[11].position = new Vector3();
egg[11].position = new Vector3(dataToSave.egg12.X, dataToSave.egg12.Y, dataToSave.egg12.Z);
}
if (numEgg > 12)
{
egg[12].position = new Vector3();
egg[12].position = new Vector3(dataToSave.egg13.X, dataToSave.egg13.Y, dataToSave.egg13.Z);
}
if (numEgg > 13)
{
egg[13].position = new Vector3();
egg[13].position = new Vector3(dataToSave.egg14.X, dataToSave.egg14.Y, dataToSave.egg14.Z);
}
if (numEgg > 14)
{
egg[14].position = new Vector3();
egg[14].position = new Vector3(dataToSave.egg15.X, dataToSave.egg15.Y, dataToSave.egg15.Z);
}
if (numEgg > 15)
{
egg[15].position = new Vector3();
egg[15].position = new Vector3(dataToSave.egg16.X, dataToSave.egg16.Y, dataToSave.egg16.Z);
}
if (numEgg > 16)
{
egg[16].position = new Vector3();
egg[16].position = new Vector3(dataToSave.egg17.X, dataToSave.egg17.Y, dataToSave.egg17.Z);
}
if (numEgg > 17)
{
egg[17].position = new Vector3();
egg[17].position = new Vector3(dataToSave.egg18.X, dataToSave.egg18.Y, dataToSave.egg18.Z);
}
if (numEgg > 18)
{
egg[18].position = new Vector3();
egg[18].position = new Vector3(dataToSave.egg19.X, dataToSave.egg19.Y, dataToSave.egg19.Z);
}
if (numEgg > 19)
{
egg[19].position = new Vector3();
egg[19].position = new Vector3(dataToSave.egg20.X, dataToSave.egg20.Y, dataToSave.egg20.Z);
}
days = dataToSave.days;
dayTime = dataToSave.dayTime;
endOfDay = dataToSave.endOfDay;
//boots
numBoots = dataToSave.numBoots;
if (numBoots > 0)
{
boots[0] = new RubberBootClass(Content, graphics);
boots[0].position = dataToSave.boot1;
}
if (numBoots > 1)
{
boots[1] = new RubberBootClass(Content, graphics);
boots[1].position = dataToSave.boot2;
}
bootTime = dataToSave.bootTime;
bootPresent = dataToSave.bootPresent;
bootEquipped = dataToSave.bootEquipped;
//fox
fox.wandering = dataToSave.foxWandering;
fox.foxInitNode = dataToSave.foxInitNode;
fox.foxPreviousNode = dataToSave.foxPreviousNode;
fox.foxCurrentNode = dataToSave.foxCurrentNode;
fox.foxNextNode = dataToSave.foxNextNode;
fox.position = dataToSave.foxPosition;
fox.positionOld = dataToSave.foxPositionOld;
fox.rotation = dataToSave.foxRotation;
fox.riseRun = dataToSave.foxRiseRun;
fox.riseRun2 = dataToSave.foxRiseRun2;
fox.chasing = dataToSave.foxChasing;
fox.avoiding = dataToSave.foxAvoiding;
fox.timer = dataToSave.foxTimer;
fox.chaseTime = dataToSave.foxChaseTime;
fox.timer2 = dataToSave.foxTimer2;
fox.home = dataToSave.foxHome;
fox.start = dataToSave.foxStart;
fox.temp1 = dataToSave.foxTemp1;
}
private static void Save(StorageDevice storageDevice,int numChics, int chicQueue, CharacterClass player,
int numRooster, int roosterQueue, ChickenClass[] chickens, RoosterClass[] roosters, EconomicsClass eco,
int eggCount, int numEgg, EggClass[] egg, int days, float dayTime, bool endOfDay, int numBoots,
RubberBootClass[] boots,
float bootTime, bool bootPresent, bool bootEquipped, FoxClass fox)
{
// Pass the information into the data objects
DataToSave dataToSave = new DataToSave();
//save character
dataToSave.cPosition = player.position;
dataToSave.cRotation = player.rotation;
dataToSave.hitpoints = player.hitPoints;
//save Chickens
dataToSave.numChickens = numChics;
dataToSave.ChicQueue = chicQueue;
//save chicken1
if (chickens[0].time != null)
{
dataToSave.chic1time = chickens[0].time;
dataToSave.chic1state = chickens[0].state;
dataToSave.chic1ground = chickens[0].ground;
dataToSave.chic1InitNode = chickens[0].ChickenInitNode;
dataToSave.chic1PreviousNode = chickens[0].ChickenPreviousNode;
dataToSave.chic1CurrentNode = chickens[0].ChickenCurrentNode;
dataToSave.chic1NextNode = (int)chickens[0].chickenNextNode;
dataToSave.chic1Position = chickens[0].position;
dataToSave.chic1Rotation = chickens[0].rotation;
dataToSave.chic1RiseRun = chickens[0].riseRun;
dataToSave.chic1EggLaid = chickens[0].eggLaid;
}
else
{
dataToSave.chic1time = -1;
}
//save chicken2
if (chickens[1] != null)
{
dataToSave.chic2time = chickens[1].time;
dataToSave.chic2state = chickens[1].state;
dataToSave.chic2ground = chickens[1].ground;
dataToSave.chic2InitNode = chickens[1].ChickenInitNode;
dataToSave.chic2PreviousNode = chickens[1].ChickenPreviousNode;
dataToSave.chic2CurrentNode = chickens[1].ChickenCurrentNode;
dataToSave.chic2NextNode = (int)chickens[1].chickenNextNode;
dataToSave.chic2Position = chickens[1].position;
dataToSave.chic2Rotation = chickens[1].rotation;
dataToSave.chic2RiseRun = chickens[1].riseRun;
dataToSave.chic2EggLaid = chickens[1].eggLaid;
}
else
{
dataToSave.chic2time = -1;
}
//save chicken3
if (chickens[2] != null)
{
dataToSave.chic3time = chickens[2].time;
dataToSave.chic3state = chickens[2].state;
dataToSave.chic3ground = chickens[2].ground;
dataToSave.chic3InitNode = chickens[2].ChickenInitNode;
dataToSave.chic3PreviousNode = chickens[2].ChickenPreviousNode;
dataToSave.chic3CurrentNode = chickens[2].ChickenCurrentNode;
dataToSave.chic3NextNode = (int)chickens[2].chickenNextNode;
dataToSave.chic3Position = chickens[2].position;
dataToSave.chic3Rotation = chickens[2].rotation;
dataToSave.chic3RiseRun = chickens[2].riseRun;
dataToSave.chic3EggLaid = chickens[2].eggLaid;
}
else
{
dataToSave.chic3time = -1;
}
//save chicken4
if (chickens[3] != null)
{
dataToSave.chic4time = chickens[3].time;
dataToSave.chic4state = chickens[3].state;
dataToSave.chic4ground = chickens[3].ground;
dataToSave.chic4InitNode = chickens[3].ChickenInitNode;
dataToSave.chic4PreviousNode = chickens[3].ChickenPreviousNode;
dataToSave.chic4CurrentNode = chickens[3].ChickenCurrentNode;
dataToSave.chic4NextNode = (int)chickens[3].chickenNextNode;
dataToSave.chic4Position = chickens[3].position;
dataToSave.chic4Rotation = chickens[3].rotation;
dataToSave.chic4RiseRun = chickens[3].riseRun;
dataToSave.chic4EggLaid = chickens[3].eggLaid;
}
else
{
dataToSave.chic4time = -1;
}
//save chicken5
if (chickens[4] != null)
{
dataToSave.chic5time = chickens[4].time;
dataToSave.chic5state = chickens[4].state;
dataToSave.chic5ground = chickens[4].ground;
dataToSave.chic5InitNode = chickens[4].ChickenInitNode;
dataToSave.chic5PreviousNode = chickens[4].ChickenPreviousNode;
dataToSave.chic5CurrentNode = chickens[4].ChickenCurrentNode;
dataToSave.chic5NextNode = (int)chickens[4].chickenNextNode;
dataToSave.chic5Position = chickens[4].position;
dataToSave.chic5Rotation = chickens[4].rotation;
dataToSave.chic5RiseRun = chickens[4].riseRun;
dataToSave.chic5EggLaid = chickens[4].eggLaid;
}
else
{
dataToSave.chic5time = -1;
}
//save chicken6
if (chickens[5] != null)
{
dataToSave.chic6time = chickens[5].time;
dataToSave.chic6state = chickens[5].state;
dataToSave.chic6ground = chickens[5].ground;
dataToSave.chic6InitNode = chickens[5].ChickenInitNode;
dataToSave.chic6PreviousNode = chickens[5].ChickenPreviousNode;
dataToSave.chic6CurrentNode = chickens[5].ChickenCurrentNode;
dataToSave.chic6NextNode = (int)chickens[5].chickenNextNode;
dataToSave.chic6Position = chickens[5].position;
dataToSave.chic6Rotation = chickens[5].rotation;
dataToSave.chic6RiseRun = chickens[5].riseRun;
dataToSave.chic6EggLaid = chickens[5].eggLaid;
}
else
{
dataToSave.chic6time = -1;
}
//save chicken7
if (chickens[6] != null)
{
dataToSave.chic7time = chickens[6].time;
dataToSave.chic7state = chickens[6].state;
dataToSave.chic7ground = chickens[6].ground;
dataToSave.chic7InitNode = chickens[6].ChickenInitNode;
dataToSave.chic7PreviousNode = chickens[6].ChickenPreviousNode;
dataToSave.chic7CurrentNode = chickens[6].ChickenCurrentNode;
dataToSave.chic7NextNode = (int)chickens[6].chickenNextNode;
dataToSave.chic7Position = chickens[6].position;
dataToSave.chic7Rotation = chickens[6].rotation;
dataToSave.chic7RiseRun = chickens[6].riseRun;
dataToSave.chic7EggLaid = chickens[6].eggLaid;
}
else
{
dataToSave.chic7time = -1;
}
//save chicken8
if (chickens[7] != null)
{
dataToSave.chic8time = chickens[7].time;
dataToSave.chic8state = chickens[7].state;
dataToSave.chic8ground = chickens[7].ground;
dataToSave.chic8InitNode = chickens[7].ChickenInitNode;
dataToSave.chic8PreviousNode = chickens[7].ChickenPreviousNode;
dataToSave.chic8CurrentNode = chickens[7].ChickenCurrentNode;
dataToSave.chic8NextNode = (int)chickens[7].chickenNextNode;
dataToSave.chic8Position = chickens[7].position;
dataToSave.chic8Rotation = chickens[7].rotation;
dataToSave.chic8RiseRun = chickens[7].riseRun;
dataToSave.chic8EggLaid = chickens[7].eggLaid;
}
else
{
dataToSave.chic8time = -1;
}
//save chicken9
if (chickens[8] != null)
{
dataToSave.chic9time = chickens[8].time;
dataToSave.chic9state = chickens[8].state;
dataToSave.chic9ground = chickens[8].ground;
dataToSave.chic9InitNode = chickens[8].ChickenInitNode;
dataToSave.chic9PreviousNode = chickens[8].ChickenPreviousNode;
dataToSave.chic9CurrentNode = chickens[8].ChickenCurrentNode;
dataToSave.chic9NextNode = (int)chickens[8].chickenNextNode;
dataToSave.chic9Position = chickens[8].position;
dataToSave.chic9Rotation = chickens[8].rotation;
dataToSave.chic9RiseRun = chickens[8].riseRun;
dataToSave.chic9EggLaid = chickens[8].eggLaid;
}
else
{
dataToSave.chic9time = -1;
}
//save chicken10
if (chickens[9] != null)
{
dataToSave.chic10time = chickens[9].time;
dataToSave.chic10state = chickens[9].state;
dataToSave.chic10ground = chickens[9].ground;
dataToSave.chic10InitNode = chickens[9].ChickenInitNode;
dataToSave.chic10PreviousNode = chickens[9].ChickenPreviousNode;
dataToSave.chic10CurrentNode = chickens[9].ChickenCurrentNode;
dataToSave.chic10NextNode = (int)chickens[9].chickenNextNode;
dataToSave.chic10Position = chickens[9].position;
dataToSave.chic10Rotation = chickens[9].rotation;
dataToSave.chic10RiseRun = chickens[9].riseRun;
dataToSave.chic10EggLaid = chickens[9].eggLaid;
}
else
{
dataToSave.chic10time = -1;
}
//economics save
dataToSave.money = eco.money;
dataToSave.startEggs = eco.startEggs;
dataToSave.startChickens = eco.startChickens;
dataToSave.startRoosters = eco.startRoosters;
dataToSave.startmoney = eco.startmoney;
dataToSave.eggsCollected = eco.eggsCollected;
dataToSave.chickenBought = eco.chickenBought;
dataToSave.roosterBought = eco.roosterBought;
dataToSave.eggsEaten = eco.eggsEaten;
dataToSave.eggSold = eco.eggSold;
dataToSave.chickenSold = eco.chickenSold;
dataToSave.roosterSold = eco.roosterSold;
dataToSave.chickenEaten = eco.chickenEaten;
dataToSave.roosterEaten = eco.roosterEaten;
dataToSave.moneyAquired = eco.moneyAquired;
//rooster save
dataToSave.numRooster = numRooster;
dataToSave.roosterQueue = roosterQueue;
//rooster1 save
if (roosters[0] != null)
{
dataToSave.rooster1state = roosters[0].state;
dataToSave.rooster1InitNode = roosters[0].roosterInitNode;
dataToSave.rooster1PreviousNode = roosters[0].roosterPreviousNode;
dataToSave.rooster1CurrentNode = roosters[0].roosterCurrentNode;
dataToSave.rooster1NextNode = roosters[0].roosterNextNode;
dataToSave.rooster1Position = roosters[0].position;
dataToSave.rooster1Rotation = roosters[0].rotation;
dataToSave.rooster1RiseRun = roosters[0].riseRun;
dataToSave.rooster1RiseRun2 = roosters[0].riseRun2;
dataToSave.rooster1Start = roosters[0].start;
}
else
{
dataToSave.rooster1state = -1;
}
//rooster2 save
if (roosters[1] != null)
{
dataToSave.rooster2state = roosters[1].state;
dataToSave.rooster2InitNode = roosters[1].roosterInitNode;
dataToSave.rooster2PreviousNode = roosters[1].roosterPreviousNode;
dataToSave.rooster2CurrentNode = roosters[1].roosterCurrentNode;
dataToSave.rooster2NextNode = roosters[1].roosterNextNode;
dataToSave.rooster2Position = roosters[1].position;
dataToSave.rooster2Rotation = roosters[1].rotation;
dataToSave.rooster2RiseRun = roosters[1].riseRun;
dataToSave.rooster2RiseRun2 = roosters[1].riseRun2;
dataToSave.rooster2Start = roosters[1].start;
}
else
{
dataToSave.rooster2state = -1;
}
//rooster3 save
if (roosters[2] != null)
{
dataToSave.rooster3state = roosters[2].state;
dataToSave.rooster3InitNode = roosters[2].roosterInitNode;
dataToSave.rooster3PreviousNode = roosters[2].roosterPreviousNode;
dataToSave.rooster3CurrentNode = roosters[2].roosterCurrentNode;
dataToSave.rooster3NextNode = roosters[2].roosterNextNode;
dataToSave.rooster3Position = roosters[2].position;
dataToSave.rooster3Rotation = roosters[2].rotation;
dataToSave.rooster3RiseRun = roosters[2].riseRun;
dataToSave.rooster3RiseRun2 = roosters[2].riseRun2;
dataToSave.rooster3Start = roosters[2].start;
}
else
{
dataToSave.rooster3state = -1;
}
//rooster4 save
if (roosters[3] != null)
{
dataToSave.rooster4state = roosters[3].state;
dataToSave.rooster4InitNode = roosters[3].roosterInitNode;
dataToSave.rooster4PreviousNode = roosters[3].roosterPreviousNode;
dataToSave.rooster4CurrentNode = roosters[3].roosterCurrentNode;
dataToSave.rooster4NextNode = roosters[3].roosterNextNode;
dataToSave.rooster4Position = roosters[3].position;
dataToSave.rooster4Rotation = roosters[3].rotation;
dataToSave.rooster4RiseRun = roosters[3].riseRun;
dataToSave.rooster4RiseRun2 = roosters[3].riseRun2;
dataToSave.rooster4Start = roosters[3].start;
}
else
{
dataToSave.rooster4state = -1;
}
//rooster5 save
if (roosters[4] != null)
{
dataToSave.rooster5state = roosters[4].state;
dataToSave.rooster5InitNode = roosters[4].roosterInitNode;
dataToSave.rooster5PreviousNode = roosters[4].roosterPreviousNode;
dataToSave.rooster5CurrentNode = roosters[4].roosterCurrentNode;
dataToSave.rooster5NextNode = roosters[4].roosterNextNode;
dataToSave.rooster5Position = roosters[4].position;
dataToSave.rooster5Rotation = roosters[4].rotation;
dataToSave.rooster5RiseRun = roosters[4].riseRun;
dataToSave.rooster5RiseRun2 = roosters[4].riseRun2;
dataToSave.rooster5Start = roosters[4].start;
}
else
{
dataToSave.rooster5state = -1;
}
//eggclass
dataToSave.eggCount = eggCount;
dataToSave.numEgg = numEgg;
if (numEgg > 0)
{
dataToSave.egg1 = egg[0].position;
}
if (numEgg > 1)
{
dataToSave.egg2 = egg[1].position;
}
if (numEgg > 2)
{
dataToSave.egg3 = egg[2].position;
}
if (numEgg > 3)
{
dataToSave.egg4 = egg[3].position;
}
if (numEgg > 4)
{
dataToSave.egg5 = egg[4].position;
}
if (numEgg > 5)
{
dataToSave.egg6 = egg[5].position;
}
if (numEgg > 6)
{
dataToSave.egg7 = egg[6].position;
}
if (numEgg > 7)
{
dataToSave.egg8 = egg[7].position;
}
if (numEgg > 8)
{
dataToSave.egg9 = egg[8].position;
}
if (numEgg > 9)
{
dataToSave.egg10 = egg[9].position;
}
if (numEgg > 10)
{
dataToSave.egg11 = egg[10].position;
}
if (numEgg > 11)
{
dataToSave.egg12 = egg[11].position;
}
if (numEgg > 12)
{
dataToSave.egg13 = egg[12].position;
}
if (numEgg > 13)
{
dataToSave.egg14 = egg[13].position;
}
if (numEgg > 14)
{
dataToSave.egg15 = egg[14].position;
}
if (numEgg > 15)
{
dataToSave.egg16 = egg[15].position;
}
if (numEgg > 16)
{
dataToSave.egg17 = egg[16].position;
}
if (numEgg > 17)
{
dataToSave.egg18 = egg[17].position;
}
if (numEgg > 18)
{
dataToSave.egg19 = egg[18].position;
}
if (numEgg > 19)
{
dataToSave.egg20 = egg[19].position;
}
dataToSave.days = days; //tracks number of total days
dataToSave.dayTime = dayTime; //tracks number of seconds since day began
dataToSave.endOfDay = endOfDay;
//boots
dataToSave.numBoots = numBoots;
if (numBoots > 0)
{
dataToSave.boot1 = boots[0].position;
}
if (numBoots > 1)
{
dataToSave.boot2 = boots[1].position;
}
dataToSave.bootTime = bootTime;
dataToSave.bootPresent = bootPresent;
dataToSave.bootEquipped = bootEquipped;
//fox
dataToSave.foxWandering = fox.wandering;
dataToSave.foxInitNode = fox.foxInitNode;
dataToSave.foxPreviousNode = fox.foxPreviousNode;
dataToSave.foxCurrentNode = fox.foxCurrentNode;
dataToSave.foxNextNode = fox.foxNextNode;
dataToSave.foxPosition = fox.position;
dataToSave.foxPositionOld = fox.positionOld;
dataToSave.foxRotation = fox.rotation;
dataToSave.foxRiseRun = fox.riseRun;
dataToSave.foxRiseRun2 = fox.riseRun2;
dataToSave.foxChasing = fox.chasing;
dataToSave.foxAvoiding = fox.avoiding;
dataToSave.foxTimer = fox.timer;
dataToSave.foxChaseTime = fox.chaseTime;
dataToSave.foxTimer2 = fox.timer2;
dataToSave.foxHome = fox.home;
dataToSave.foxStart = fox.start;
dataToSave.foxTemp1 = fox.temp1;
StorageContainer myContainer = storageDevice.OpenContainer("Chicken_Game");
// Here is the path to where you want to save your data
string nameOfFile = Path.Combine(myContainer.Path, "ChickenGameSave.sav");
// If the file doesn't exist, it will be created, if it does, it will be replaced
FileStream fileStream = File.Open(nameOfFile, FileMode.Create);
XmlSerializer serializer = new XmlSerializer(typeof(DataToSave));
serializer.Serialize(fileStream, dataToSave);
//close this file
fileStream.Close();
myContainer.Dispose();
}
protected override void Initialize()
{
IAsyncResult syncResult = Guide.BeginShowStorageDeviceSelector(null, null);
storageDevice = Guide.EndShowStorageDeviceSelector(syncResult);
//if (!storageDevice.IsConnected) Exit();
container = storageDevice.OpenContainer("Minesweeper");
skins = new Dictionary<string, Skin>();
bestTimes = new Dictionary<Difficulty, int>(4);
bestTimes.Add(Difficulty.Beginner, 999);
bestTimes.Add(Difficulty.Intermediate, 999);
bestTimes.Add(Difficulty.Expert, 999);
bestTimes.Add(Difficulty.Zune, 999);
GetBestTimes();
options = new Options(true, false, "Blue");
base.Initialize();
}
/// <summary>
/// Loads the settings from the specified device.
/// </summary>
/// <param name="device">The device.</param>
private void LoadSettings(StorageDevice device)
{
// Open a storage container.
StorageContainer container = device.OpenContainer("Clock");
// Get the path of the save game.
string filename = Path.Combine(container.Path, "settings.xml");
if (File.Exists(filename))
{
#if DEBUG
if (System.Diagnostics.Debugger.IsAttached)
{
using (TextReader tr = new StreamReader(filename))
{
string xml = tr.ReadToEnd();
System.Diagnostics.Trace.WriteLine(xml);
}
}
#endif
try
{
// Open the file
FileStream stream = File.Open(filename, FileMode.Open);
// Convert the object to XML data and put it in the stream.
XmlSerializer serializer = new XmlSerializer(typeof(Settings));
this.settings = serializer.Deserialize(stream) as Settings;
// Close the file.
stream.Close();
}
catch (Exception exception)
{
// In some cases, XmlSerializer throws exception when loading the data. We try to fix the problem by deleting the file.
// Hopefully this issue should be fixed now.
System.Diagnostics.Trace.WriteLine(exception.ToString());
File.Delete(filename);
// As a preliminary way to signal that we didn't load the settings, for now we go into setting mode.
this.BeginSettingMode();
}
}
// Dispose the container, to commit changes.
container.Dispose();
if (this.settings == null)
{
this.settings = new Settings();
}
}
/// <summary>
/// Saves the application settings to the specified device.
/// </summary>
/// <param name="device">The device to use.</param>
private void SaveSettings(StorageDevice device)
{
// Open a storage container.
StorageContainer container = device.OpenContainer("Clock");
// Get the path of the save game.
string filename = Path.Combine(container.Path, "settings.xml");
// Open the file, creating it if necessary.
FileStream stream = File.Open(filename, FileMode.Create);
// Convert the object to XML data and put it in the stream.
XmlSerializer serializer = new XmlSerializer(typeof(Settings));
serializer.Serialize(stream, this.settings);
// Close the file.
stream.Close();
// Dispose the container, to commit changes.
container.Dispose();
}
void SaveNameData(string filename, StorageDevice storageDevice, NameWrapper nameWrapper)
{
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(_nameWrapper.ToByteArray());
}
finally
{
myBw.Flush();
myBw.Close();
fileStream.Close();
_operationPending = false;
storageContainer.Dispose();
}
}
}
}
void LoadNameData(string filename, StorageDevice storageDevice)
{
using (StorageContainer storageContainer = storageDevice.OpenContainer("Content"))
{
string filenamePath = Path.Combine(storageContainer.Path, filename);
try
{
using (FileStream fileStream = File.OpenRead(filenamePath))
{
BinaryReader myBr = new BinaryReader(fileStream);
try
{
fileStream.Position = 0;
_nameWrapper = new NameWrapper(myBr.ReadBytes((int)fileStream.Length));
}
catch (Exception e)
{
_nameWrapper = new NameWrapper();
}
finally
{
myBr.Close();
fileStream.Close();
_operationPending = false;
storageContainer.Dispose();
}
}
}
catch (Exception e)
{
_nameWrapper = new NameWrapper();
_operationPending = false;
}
}
}
void LoadBookletData(string filename, StorageDevice storageDevice)
{
using (StorageContainer storageContainer = storageDevice.OpenContainer("Content"))
{
string filenamePath = Path.Combine(storageContainer.Path, filename);
using (FileStream fileStream = File.OpenRead(filenamePath))
{
BinaryReader myBr = new BinaryReader(fileStream);
try
{
fileStream.Position = 0;
_currentBooklet = new Booklet(myBr.ReadBytes((int)fileStream.Length));
}
finally
{
fileStream.Close();
_operationPending = false;
storageContainer.Dispose();
}
}
}
}
/// <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)
{
// check the parameters
if (saveGameDescription == null)
{
throw new ArgumentNullException("saveGameDescription");
}
// check the parameter
if ((storageDevice == null) || !storageDevice.IsConnected)
{
return;
}
// open the container
using (StorageContainer storageContainer =
storageDevice.OpenContainer(Session.SaveGameContainerName))
{
File.Delete(Path.Combine(storageContainer.Path,
saveGameDescription.FileName));
File.Delete(Path.Combine(storageContainer.Path, "SaveGameDescription" +
Path.GetFileNameWithoutExtension(
saveGameDescription.FileName).Substring(8) +
".xml"));
}
// refresh the save game descriptions
Session.RefreshSaveGameDescriptions();
}
public void CheckWhetherExists(StorageDevice storageDevice)
{
StorageContainer myContainer = storageDevice.OpenContainer("Chicken_Game");
string nameOfFile = Path.Combine(myContainer.Path, "ChickenGameSave.sav");
if (File.Exists(nameOfFile))
{
//LoadData(device, ref world.myCharacter.position);
}
myContainer.Dispose();
}
/// <summary>
/// Receives the storage device and starts a new session,
/// using the data in the given save game.
/// </summary>
/// <remarks>The new session is created in LoadSessionResult.</remarks>
/// <param name="storageDevice">The chosen storage device.</param>
/// <param name="saveGameDescription">The description of the save game.</param>
public static void LoadSessionResult(StorageDevice storageDevice,
SaveGameDescription saveGameDescription)
{
// check the parameters
if (saveGameDescription == null)
{
throw new ArgumentNullException("saveGameDescription");
}
// check the parameter
if ((storageDevice == null) || !storageDevice.IsConnected)
{
return;
}
// open the container
using (StorageContainer storageContainer =
storageDevice.OpenContainer(Session.SaveGameContainerName))
{
string filename = Path.Combine(storageContainer.Path,
saveGameDescription.FileName);
using (FileStream stream = new FileStream(filename, FileMode.Open))
{
using (XmlReader xmlReader = XmlReader.Create(stream))
{
// <rolePlayingGameData>
xmlReader.ReadStartElement("rolePlayingGameSaveData");
// read the map information
xmlReader.ReadStartElement("mapData");
string mapAssetName =
xmlReader.ReadElementString("mapContentName");
PlayerPosition playerPosition = new XmlSerializer(
typeof(PlayerPosition)).Deserialize(xmlReader)
as PlayerPosition;
singleton.removedMapChests = new XmlSerializer(
typeof(List<WorldEntry<Chest>>)).Deserialize(xmlReader)
as List<WorldEntry<Chest>>;
singleton.removedMapFixedCombats = new XmlSerializer(
typeof(List<WorldEntry<FixedCombat>>)).Deserialize(xmlReader)
as List<WorldEntry<FixedCombat>>;
singleton.removedMapPlayerNpcs = new XmlSerializer(
typeof(List<WorldEntry<Player>>)).Deserialize(xmlReader)
as List<WorldEntry<Player>>;
singleton.modifiedMapChests = new XmlSerializer(
typeof(List<ModifiedChestEntry>)).Deserialize(xmlReader)
as List<ModifiedChestEntry>;
ChangeMap(mapAssetName, null);
TileEngine.PartyLeaderPosition = playerPosition;
xmlReader.ReadEndElement();
// read the quest information
ContentManager content = Session.ScreenManager.Game.Content;
xmlReader.ReadStartElement("questData");
singleton.questLine = content.Load<QuestLine>(
xmlReader.ReadElementString("questLineContentName")).Clone()
as QuestLine;
singleton.currentQuestIndex = Convert.ToInt32(
xmlReader.ReadElementString("currentQuestIndex"));
for (int i = 0; i < singleton.currentQuestIndex; i++)
{
singleton.questLine.Quests[i].Stage =
Quest.QuestStage.Completed;
}
singleton.removedQuestChests = new XmlSerializer(
typeof(List<WorldEntry<Chest>>)).Deserialize(xmlReader)
as List<WorldEntry<Chest>>;
singleton.removedQuestFixedCombats = new XmlSerializer(
typeof(List<WorldEntry<FixedCombat>>)).Deserialize(xmlReader)
as List<WorldEntry<FixedCombat>>;
singleton.modifiedQuestChests = new XmlSerializer(
typeof(List<ModifiedChestEntry>)).Deserialize(xmlReader)
as List<ModifiedChestEntry>;
Quest.QuestStage questStage = (Quest.QuestStage)Enum.Parse(
typeof(Quest.QuestStage),
xmlReader.ReadElementString("currentQuestStage"), true);
if ((singleton.questLine != null) && !IsQuestLineComplete)
{
singleton.quest =
singleton.questLine.Quests[CurrentQuestIndex];
singleton.ModifyQuest(singleton.quest);
singleton.quest.Stage = questStage;
}
xmlReader.ReadEndElement();
// read the party data
singleton.party = new Party(new XmlSerializer(
typeof(PartySaveData)).Deserialize(xmlReader)
as PartySaveData, content);
// </rolePlayingGameSaveData>
xmlReader.ReadEndElement();
}
}
}
}
//=========================================================================================
/// <summary>
/// Called when a storage device is selected.
/// </summary>
/// <param name="result"> Result of the operation. </param>
//=========================================================================================
private static void OnStorageDeviceSelect( IAsyncResult result )
{
// This might fail:
try
{
// Save the selected storage device:
s_storage_device = Guide.EndShowStorageDeviceSelector(result);
// Choose a storage container:
if ( s_storage_device != null )
{
// Open seasame:
s_storage_container = s_storage_device.OpenContainer( TITLE_NAME );
}
}
catch ( Exception ){}
}
