private void tsbNew_Click(object sender, EventArgs e)
{
try
{
if (_engine?.IsModified ?? false)
{
if (!_engine.Save())
{
return;
}
}
_engine = new Engine();
_engine.FilenamePrompt = PromptFilename;
propertyGrid1.SelectedObject = _engine;
tsbSave.Enabled = true;
tsbRun.Enabled = true;
tsbAddToProject.Enabled = true;
tsbChangeLog.Enabled = true;
tsbSaveLocalCredentials.Enabled = true;
}
catch (Exception exc)
{
MessageBox.Show(exc.Message);
}
}
public void Test_DereferenceRelatedObjects_ForSingle_IsOwner_WhenHasNoRelatedBO()
{
//The Car has a single relationship to engine. The car->engine relationship is marked
// as a dereference related relationship.
BORegistry.DataAccessor = new DataAccessorInMemory();
//---------------Set up test pack-------------------
new Car();
Engine engine = new Engine();
engine.SetPropertyValue("EngineNo", "NO111");
engine.Save();
engine.MarkForDelete();
SingleRelationshipDef relationshipDef = (SingleRelationshipDef)engine.Relationships["Car"].RelationshipDef;
relationshipDef.DeleteParentAction = DeleteParentAction.DereferenceRelated;
//---------------Assert Precondition----------------
Assert.IsTrue(relationshipDef.OwningBOHasForeignKey);
Assert.AreEqual(DeleteParentAction.DereferenceRelated, relationshipDef.DeleteParentAction);
Assert.IsNull(engine.GetCar());
//---------------Execute Test ----------------------
engine.Save();
//---------------Test Result -----------------------
Assert.IsNull(engine.GetCar());
Assert.IsTrue(engine.Status.IsNew && engine.Status.IsDeleted);
}
/// <summary>
/// Quit the cartridge.
/// </summary>
public void Quit()
{
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.SetTitle(Resource.String.menu_screen_main_quit);
builder.SetMessage(Resource.String.screen_save_before_quit);
builder.SetCancelable(true);
builder.SetPositiveButton(Resource.String.screen_save_before_quit_yes, delegate { engine.Save(new FileStream(cartridge.SaveFilename, FileMode.Create)); DestroyEngine(); Finish(); });
// TODO: Works this also on devices with API < 14 (Pre 4.0)
// var test = Build.VERSION.SdkInt;
// builder.SetNeutralButton(Resource.String.screen_save_before_quit_cancel, delegate { });
builder.SetNegativeButton(Resource.String.screen_save_before_quit_no, delegate { DestroyEngine(); Finish(); });
builder.Show();
}
public DataSet SetUserEngine()
{
int userID = base.Kv.GetInt32("UserID");
string engineName = base.Kv.Get("EngineName");
string userStatus = base.Kv.Get("UserStatus");
DataSet ds = new DataSet();
if (userID != 0)
{
Engine eng;
DataTable dt = Engine.GetEngineByName(base.Kv.Cxt, engineName);
if (dt.Rows.Count > 0)
{
eng = new Engine(base.Kv.Cxt, dt.Rows[0]);
}
else
{
eng = new Engine();
eng.Name = engineName.Trim();
eng.Description = engineName;
eng.Save();
}
User user = new User(base.Kv.Cxt, userID);
user.EngineID = eng.EngineID;
user.UserStatusID = UData.ToInt32(userStatus);
user.Save();
}
return(ds);
}
public void TestDereferenceRelatedObjects()
{
//The Car has a single relationship to engine. The car->engine relationship is marked
// as a dereference related relationship.
BORegistry.DataAccessor = new DataAccessorInMemory();
//---------------Set up test pack-------------------
Car car = new Car();
car.SetPropertyValue("CarRegNo", "NP32459");
car.Save();
Engine engine = new Engine();
engine.SetPropertyValue("EngineNo", "NO111");
const string carIDProp = "CarID";
engine.SetPropertyValue(carIDProp, car.GetPropertyValue(carIDProp));
engine.Save();
BORegistry.DataAccessor.BusinessObjectLoader.Refresh(engine);
Assert.AreSame(engine.GetCar(), car);
//---------------Execute Test ----------------------
car.MarkForDelete();
car.Save();
//---------------Test Result -----------------------
Assert.IsNull(engine.GetPropertyValue(carIDProp));
Assert.IsNull(engine.GetCar());
//---------------Test TearDown -----------------------
}
private bool SaveStory(string filename)
{
try {
_engine.Save(filename);
return(true);
} catch (Exception ex) {
MessageBox.Show(this, $"An error occured during save:\n\n{ex.Message}\n\n{ex.StackTrace}", null, MessageBoxButton.OK, MessageBoxImage.Exclamation);
return(false);
}
}
public void TestChangedEnginesForeignKey_Dereference_Single_Saved()
{
//---------------Set up test pack-------------------
Car car = new Car();
Car car2 = new Car();
Engine engine = new Engine();
engine.CarID = car.CarID;
car.Save();
car2.Save();
engine.Save();
//---------------Assert Precondition----------------
Assert.AreSame(engine, car.GetEngine());
Assert.AreSame(car, engine.GetCar());
//---------------Execute Test ----------------------
engine.CarID = car2.CarID;
engine.Save();
Engine loadedEngine = car.GetEngine();
//---------------Test Result -----------------------
Assert.IsNull(loadedEngine);
}
private void SaveScript_FileOk(object sender, CancelEventArgs e)
{
//Generate String Array
string[] StringList = new string[StrList.Items.Count];
for (int i = 0; i < StringList.Length; i++)
{
StringList[i] = StrList.Items[i].ToString();
}
//Backup if needed
if (!Program.OfflineMode && (!(ZNunca.Checked && Engine.DebugMode)))
{
(new System.Threading.Thread((str) => { Engine.Backup(StringList, true); })).Start(StringList);
}
//Save Script
Engine.Save(SaveScript.FileName, StringList);
FileSaved = true;
Engine.UpdateSelection();
MessageBox.Show(Engine.LoadTranslation(Engine.TLID.SaveAsSucess, System.IO.Path.GetFileName(Engine.ScriptPath)), "VNXTLP", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
public void TestChangedEnginesForeignKey_SetIDToNull()
{
//---------------Set up test pack-------------------
Car car = new Car();
Engine engine = new Engine {
CarID = car.CarID
};
car.Save();
engine.Save();
//---------------Assert Precondition----------------
Assert.AreSame(engine, car.GetEngine());
Assert.AreSame(car, engine.GetCar());
//---------------Execute Test ----------------------
engine.SetPropertyValue("CarID", null);
Engine loadedEngine = car.GetEngine();
//---------------Test Result -----------------------
Assert.IsNull(engine.GetPropertyValue("CarID"));
//Assert.IsNull(car.GetPropertyValue("EngineID"));
Assert.IsNull(loadedEngine);
}
public void Test_SaveFiresUpdatedEvent()
{
//---------------Set up test pack-------------------
Engine engine1 = new Engine();
bool updatedEventFired = false;
//-------------Assert Preconditions -------------
Assert.IsFalse(updatedEventFired);
//---------------Execute Test ----------------------
engine1.Updated += delegate { updatedEventFired = true; };
engine1.EngineNo = "20";
engine1.Save();
//---------------Test Result -----------------------
Assert.IsTrue(updatedEventFired);
}
public void TestChangedEnginesForeignKey_SetIDToNull()
{
//---------------Set up test pack-------------------
Car car = new Car();
Engine engine = new Engine {CarID = car.CarID};
car.Save();
engine.Save();
//---------------Assert Precondition----------------
Assert.AreSame(engine, car.GetEngine());
Assert.AreSame(car, engine.GetCar());
//---------------Execute Test ----------------------
engine.SetPropertyValue("CarID", null);
Engine loadedEngine = car.GetEngine();
//---------------Test Result -----------------------
Assert.IsNull(engine.GetPropertyValue("CarID"));
//Assert.IsNull(car.GetPropertyValue("EngineID"));
Assert.IsNull(loadedEngine);
}
public void TestChangedEnginesForeignKey_Dereference_Single_Saved()
{
//---------------Set up test pack-------------------
Car car = new Car();
Car car2 = new Car();
Engine engine = new Engine();
engine.CarID = car.CarID;
car.Save();
car2.Save();
engine.Save();
//---------------Assert Precondition----------------
Assert.AreSame(engine, car.GetEngine());
Assert.AreSame(car, engine.GetCar());
//---------------Execute Test ----------------------
engine.CarID = car2.CarID;
engine.Save();
Engine loadedEngine = car.GetEngine();
//---------------Test Result -----------------------
Assert.IsNull(loadedEngine);
}
public void Save()
{
Engine.Save();
}
static void Main()
{
Engine engine = InitializeEngine();
//TODO: Create implementation running code
string saveDir = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
@"SimuEngine");
if (!Directory.Exists(saveDir))
{
Directory.CreateDirectory(saveDir);
}
bool readFailed = false;
bool createNew = false;
if (engine.SaveExists(saveDir))
{
Console.WriteLine("Found save file");
bool useSave = YesNo("Do you wish to use the save?");
if (useSave)
{
try {
engine.Load(saveDir, engine.player.Actions);
Console.WriteLine("Deserialized from save file");
} catch (OutOfMemoryException e) {
Console.WriteLine("Ran out of memory while deserializing");
readFailed = true;
throw new SystemException("Ran out of memory while deserializing", e);
} catch (SerializationException ex) {
Console.WriteLine($"Error while deserializing ({ex}), deleting file.");
engine.CleanDir(saveDir);
readFailed = true;
}
}
else
{
//City c = new City(350000, 100);
//engine.system.graph.Add(c);
//// c.NodeCreation(engine.system.graph);
createNew = true;
}
}
else
{
Console.WriteLine("No saved system found");
}
if (engine.system.graph.Count.Nodes == 0 || readFailed || createNew)
{
Console.WriteLine("Creating a new system");
City c = new City(350000, 100);
c.Name = "Irak";
engine.system.graph.Add(c);
// c.NodeCreation(engine.system.graph);
bool ser = YesNo("Initialization finished, serialize?");
if (ser)
{
Console.WriteLine("Serializing...");
try {
engine.Save(saveDir);
Console.WriteLine("Graph initialization complete");
} catch (IOException) {
Console.WriteLine("IO error while serializing, won't keep going");
} catch (OutOfMemoryException) {
Console.WriteLine("Ran out of memory while serializing, no serialisation");
}
}
}
ExcelExport export = new ExcelExport();
FileInfo saveFile = new FileInfo(
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory),
"excel_export.xlsx"));
using (Renderer renderer = new Renderer(engine)) {
renderer.OnTickFinished += export.OnTick;
renderer.Run();
while (true)
{
try {
export.Save(saveFile);
break;
} catch (InvalidOperationException e) {
Console.WriteLine("Error saving excel_export.xslx file");
Console.WriteLine($"Exception: {e}");
bool retry = YesNo("Would you like to try again?");
if (!retry)
{
break;
}
}
}
}
}
/// <summary>
/// When Yes is selected by the user
/// </summary>
private async void YesOptionTriggered()
{
if (confirmationPending)
{
switch (lastUserAction)
{
case EUserAction.Shuffle:
Logger.Logger.Log("Shuffling the deck");
userNotification = "Shuffling the deck...";
engine.Shuffle();
userNotification = "Deck reshuffled successfully.";
break;
case EUserAction.Reset:
Logger.Logger.Log("Resetting the game.");
userNotification = "Resetting the game...";
engine.Reset();
userNotification = "Game reset successfully.";
cardString = closedCardFrame;
break;
case EUserAction.Quit:
Logger.Logger.Log("Quiting the game.");
userNotification = "Exiting...";
Environment.Exit(0);
break;
case EUserAction.Save:
Logger.Logger.Log("Saving the game.");
userNotification = "Saving...";
if (await engine.Save())
{
userNotification = "Game saved successfully.";
}
else
{
userNotification = "Game couldn't be saved.";
}
break;
case EUserAction.Recover:
Logger.Logger.Log("Recovering the game.");
userNotification = "Recovering...";
if (await engine.Recover())
{
cardString = closedCardFrame;
userNotification = "Game recovered successfully.";
}
else
{
userNotification = "Game couldn't be recoverd.";
}
break;
}
//log = "";
}
else
{
userNotification = "Invalid key";
}
confirmationPending = false;
helpString = gamehelp;
}
public async Task Save()
{
await Engine.Save((T)this);
}
