private void AutoLoad()
{
try
{
game.Loading = true;
var lasttrack = Settings.LastSelectedTrack;
var trdr = Constants.TracksDirectory;
if (!lasttrack.StartsWith(trdr))
{
return;
}
if (string.Equals(
Path.GetExtension(lasttrack),
".trk",
StringComparison.InvariantCultureIgnoreCase))
{
var trackname = TrackIO.GetTrackName(lasttrack);
lock (LoadSync)
{
var track = TRKLoader.LoadTrack(lasttrack, trackname);
ChangeTrack(track);
}
}
}
catch (Exception e)
{
Debug.WriteLine("Autoload failure: " + e.ToString());
}
finally
{
game.Loading = false;
}
}
static void Main(string[] args)
{
//Generate new route with each run if route doesn't exist so debugging is consistent between users
string RouteName = "TestRoute1"; //This is what we decide to call a specific route. It is a folder containing track.txt and route.txt
if (!Directory.Exists(Environment.CurrentDirectory + "/" + RouteName))
{
List <Location> destinationsToGenerateRoute = new List <Location>()
{
new Location("2021/03/08 15:30", "Göteborg"),
new Location("2021/03/08 15:52", "Alingsås"),
new Location("2021/03/08 16:23", "Vårgårda"),
new Location("2021/03/08 17:42", "Herrljunga"),
new Location("2021/03/08 18:50", "Falköping"),
new Location("2021/03/08 19:30", "Stockholm")
};
GenerateRoute(RouteName, destinationsToGenerateRoute);
}
var destinations = TrainSchedule.ParseRoute(RouteName); //Here we put the RouteName
ITrackIO trackIO = new TrackIO(RouteName); //Here we put the RouteName
Train[] trains = Train.Parse("trains.txt");
trackIO.Parse();
ITrainSimulation simulation = new TrainSimulation(175, trackIO).AddDestinations(destinations).AddTrain(trains[0]);
simulation.Start();
//trains[0] because we only have one train at the moment. But trains.txt can and will contain multiple ones.
}
public void BackupTrack(bool Crash = true)
{
try
{
if (_track.Lines.Count == 0)
{
return;
}
game.Loading = true;
using (var trk = CreateTrackReader())
{
if (Crash)
{
TrackIO.SaveTrackToFile(_track, "Crash Backup", Settings.Local.CurrentSong?.ToString());
}
else
{
if (TrackChanges > 50)
{
TrackIO.CreateAutosave(_track, Settings.Local.CurrentSong?.ToString());
}
}
}
}
catch (Exception e)
{
Debug.WriteLine("Autosave exception: " + e);
}
finally
{
game.Loading = false;
game.Invalidate();
}
}
private void treeview_SelectionChanged(ControlBase sender, EventArgs e)
{
var tv = (TreeControl)this.FindChildByName("loadtree", true);
var en = (List <TreeNode>)tv.SelectedChildren;
this.Title = DefaultTitle;
if (en.Count == 1)
{
var selected = en[0];
var userdata = selected.UserData;
if (userdata is string filepath)
{
// track folder
bool folder = selected.Children.Count > 0;
if (folder)
{
filepath = (string)selected.Children[0].UserData;
}
var title = Path.GetFileName(filepath);
// if it's a folder container or it's inside one
if (!(selected.IsRoot && selected.Children.Count == 0))
{
title = TrackIO.GetTrackName(filepath) +
Path.DirectorySeparatorChar +
title;
}
this.Title = DefaultTitle + " -- " + title;
}
}
}
private void Load(TreeNode node)
{
var itemdata = (ItemData)node.UserData;
switch (itemdata.ItemType)
{
case ItemType.Folder:
{
var tracks = TrackIO.EnumerateTrackFiles(itemdata.Path);
if (tracks.Length > 0)
{
LoadTrack(tracks[0], itemdata.Name);
Close();
}
}
break;
case ItemType.TrackFile:
{
var path = itemdata.Path;
if (path.EndsWith(".sol", StringComparison.OrdinalIgnoreCase))
{
var sol = SOLLoader.LoadSol(path);
if (sol.Count == 0)
{
return;
}
if (sol.Count == 1)
{
LoadTrackSol(sol[0]);
Close();
}
else if (node.Children.Count == 0)
{
foreach (var track in sol)
{
var solnode = node.AddNode(track.name);
solnode.UserData = new ItemData(ItemType.Sol, path, track);
}
node.ExpandAll();
}
}
else
{
LoadTrack(itemdata.Path, itemdata.Name);
Close();
}
}
break;
case ItemType.Sol:
{
LoadTrackSol(itemdata.sol);
Close();
}
break;
}
}
private void LoadTRK(string filepath)
{
string name = TrackIO.GetTrackName(filepath);
if (!ThreadPool.QueueUserWorkItem((o) => LoadTrack(filepath, name)))
{
LoadTrack(filepath, name);
}
}
public void OneTrackWithIntermediateStations()
{
ITrackIO trackOrm = new TrackIO("Route1");
trackOrm.Parse(true);
var result = trackOrm.Track.StationsID.Count;
Assert.Equal(6, result);
}
private List <string> GetTracks(string directory)
{
var tracks = TrackIO.EnumerateTrackFiles(directory);
var sol = TrackIO.EnumerateSolFiles(directory);
List <string> ret = new List <string>();
ret.AddRange(sol);
ret.AddRange(tracks);
return(ret);
}
public void BackupTrack(bool Crash = true)
{
try
{
if (_track.Lines.Count == 0)
{
return;
}
game.Canvas.Loading = true;
using (var trk = CreateTrackReader())
{
if (Crash)
{
var backupName = ("Crash Backup " + DateTime.Now.Month + "." + DateTime.Now.Day + "." + +DateTime.Now.Year + "_" + DateTime.Now.Hour + "." + DateTime.Now.Minute);
switch (Settings.DefaultCrashBackupFormat)
{
case ".trk":
TrackIO.SaveTrackToFile(_track, backupName);
break;
case ".json":
TrackIO.SaveTrackToJsonFile(_track, backupName);
break;
case ".sol":
TrackIO.SaveToSOL(_track, backupName);
break;
default:
TrackIO.SaveTrackToFile(_track, backupName);
break;
}
}
else
{
if (TrackChanges > Settings.autosaveChanges)
{
TrackIO.CreateAutosave(_track);
}
}
}
}
catch (Exception e)
{
Debug.WriteLine("Autosave exception: " + e);
}
finally
{
game.Canvas.Loading = false;
Invalidate();
}
}
public void OneTrackWithOnlyEndAndStartStations()
{
ITrackIO trackOrm = new TrackIO("Route1");
trackOrm.Parse(true);
var First = trackOrm.Track.StationsID[1];
var Last = trackOrm.Track.StationsID[trackOrm.Track.StationsID.Count - 1];
Station[] result = { First, Last };
Assert.Equal(2, result.Length);
}
public void QuickSave()
{
if (TrackIO.QuickSave(_track, Settings.Local.CurrentSong?.ToString()))
{
ResetTrackChangeCounter();
Settings.LastSelectedTrack = _track.Filename;
Settings.Save();
}
else
{
game.Canvas.ShowSaveWindow();
}
}
public void QuickSave()
{
if (TrackIO.QuickSave(_track))
{
ResetTrackChangeCounter();
Settings.LastSelectedTrack = _track.Filename;
Settings.Save();
}
else
{
game.Canvas.ShowSaveDialog();
}
}
private void savebtn_Clicked(ControlBase sender, ClickedEventArgs arguments)
{
var window = sender.Parent.Parent as WindowControl;
if (window == null)
{
throw new Exception("Invalid window data");
}
if (window.UserData != null)
{
var tb = (TextBox)window.FindChildByName("tb", true);
var txt = (string)window.UserData;
if (txt == "<create new track>")
{
txt = tb.Text;
}
if (!TrackIO.CheckValidFilename(txt + tb.Text) ||
tb.Text == Utils.Constants.DefaultTrackName ||
(txt.Length == 0))
{
game.Canvas.SetTooltip(sender, "Attempted to save with an invalid name");
return;
}
using (var trk = game.Track.CreateTrackWriter())
{
trk.Name = txt;
try
{
var filepath = TrackIO.SaveTrackToFile(trk.Track, tb.Text, Settings.Local.CurrentSong?.ToString());
game.Track.ResetTrackChangeCounter();
Settings.LastSelectedTrack = filepath;
Settings.Save();
}
catch
{
game.Canvas.SetTooltip(sender, "An error occured trying to save");
return;
}
}
}
window.Close();
}
public LoadWindow(Gwen.Controls.ControlBase parent, MainWindow glgame) : base(parent, DefaultTitle)
{
game = glgame;
game.Track.Stop();
MakeModal(true);
var tv = new TreeControl(this);
tv.Margin = Margin.One;
tv.Name = "loadtree";
var files = Program.UserDirectory + "Tracks";
if (Directory.Exists(files))
{
var solfiles = Directory.GetFiles(files, "*.*")
.Where(s => s != null && s.EndsWith(".sol", StringComparison.OrdinalIgnoreCase));
foreach (var sol in solfiles)
{
AddTrack(tv, sol, null);
}
}
if (Directory.Exists(files))
{
var trkfiles = TrackIO.EnumerateTrackFiles(files);
foreach (var trk in trkfiles)
{
AddTrack(tv, trk, null);
}
var folders = Directory.GetDirectories(files);
foreach (var folder in folders)
{
var trackfiles = TrackIO.EnumerateTrackFiles(folder);
AddTrack(tv, folder, trackfiles);
}
}
tv.SelectionChanged += treeview_SelectionChanged;
var container = new ControlBase(this);
container.Height = 30;
container.Dock = Pos.Bottom;
this.Width = 400;
this.Height = 400;
this.MinimumSize = new System.Drawing.Point(this.Width, this.Height);
// wc.DisableResizing();
tv.Dock = Pos.Fill;
var btn = new Button(container);
btn.Margin = new Margin(0, 5, 0, 5);
btn.Dock = Pos.Left;
btn.Height = 20;
btn.Width = 150;
btn.Text = "Load";
btn.Clicked += loadbtn_Clicked;
var btndelete = new Button(container);
btndelete.Margin = btn.Margin;
btndelete.Dock = Pos.Right;
btndelete.Height = 20;
btndelete.Width = 50;
btndelete.Text = "Delete";
btndelete.Clicked += btndelete_Clicked;
game.Cursor = game.Cursors["default"];
}
private void Save()
{
var filetype = (string)_savebutton.UserData;
var filename = _namebox.Text;
var folder = _savelist.SelectedItem.Text;
if (folder == CreateNewTrack)
{
folder = filename;
}
if (
!TrackIO.CheckValidFilename(
folder + filename) ||
filename == Utils.Constants.DefaultTrackName ||
(folder.Length == 0))
{
_errorbox.Text = "Error\n* Save name is invalid";
return;
}
using (var trk = _editor.CreateTrackWriter())
{
var l = trk.GetOldestLine();
if (l == null)
{
_errorbox.Text = "Track must have at least one line";
return;
}
trk.Name = folder;
try
{
string filepath;
switch (filetype)
{
case ".trk":
{
filepath = TrackIO.SaveTrackToFile(trk.Track, filename);
Settings.LastSelectedTrack = filepath;
Settings.Save();
}
break;
case ".sol":
{
if (!CheckSol(trk))
{
return;
}
//purposely do not set this to lastselectedtrack
//currently it's deemed non-performant and slow
TrackIO.SaveToSOL(trk.Track, filename);
}
break;
case ".json":
{
filepath = TrackIO.SaveTrackToJsonFile(trk.Track, filename);
Settings.LastSelectedTrack = filepath;
Settings.Save();
}
break;
default:
throw new InvalidOperationException("Unknown save filetype");
}
_editor.ResetTrackChangeCounter();
}
catch (Exception e)
{
_errorbox.Text = "Error\n* An unknown error occured...\n" + e.Message;
return;
}
}
Close();
}
private void Setup()
{
_tree.SelectionChanged += (o, e) =>
{
if (_tree.SelectedChildren.Count == 1)
{
var itemdata = (ItemData)_tree.SelectedChildren[0].UserData;
if (itemdata.ItemType == ItemType.Folder)
{
var tracks = TrackIO.EnumerateTrackFiles(itemdata.Path);
if (tracks.Length > 0)
{
Title = title + " - " + Path.GetFileName(tracks[0]);
}
}
else
{
Title = title + " - " + Path.GetFileName(itemdata.Path);
}
}
else
{
Title = title;
}
};
string loadedfn;
using (var trk = _editor.CreateTrackReader())
{
loadedfn = trk.Filename;
}
var dirs = GetDirectories();
var rootfiles = GetTracks(Constants.TracksDirectory);
foreach (var file in rootfiles)
{
var filenode = _tree.AddNode(Path.GetFileName(file));
filenode.UserData = new ItemData(ItemType.TrackFile, file, Path.GetFileNameWithoutExtension(file));
if (loadedfn != null && file == loadedfn)
{
filenode.IsSelected = true;
}
}
foreach (var dir in dirs)
{
var dirpath = Constants.TracksDirectory + dir + Path.DirectorySeparatorChar;
var tracks = GetTracks(dirpath);
if (tracks.Count != 0)
{
var node = _tree.AddNode(dir);
node.UserData = new ItemData(ItemType.Folder, dirpath, dir);
foreach (var file in tracks)
{
var filenode = node.AddNode(Path.GetFileName(file));
filenode.UserData = new ItemData(ItemType.TrackFile, file, dir);
if (loadedfn != null && file == loadedfn)
{
node.ExpandAll();
filenode.IsSelected = true;
}
}
}
}
}
public TrackEntiy()
{
Config = new TrackConfig();
TrackIO = new TrackIO();
}
public TrackEntiy(TrackConfig config, TrackIO state)
{
this.TrackIO = state;
this.Config = config;
}
public Dictionary <string, bool> GetFeatures()
{
return(TrackIO.TrackFeatures(Track));
}
private void AutoLoad()
{
try
{
game.Canvas.Loading = true;
string lasttrack;
if (Program.args.Length > 0)
{
Settings.LastSelectedTrack = Program.args[0];
lasttrack = Settings.LastSelectedTrack;
}
else
{
lasttrack = Settings.LastSelectedTrack;
var trdr = Constants.TracksDirectory;
if (!lasttrack.StartsWith(trdr))
{
return;
}
}
if (lasttrack.Contains("Crash Backup"))
{
if (!GameCanvas.ShowLoadCrashBackup(game.Canvas, lasttrack))
{
game.Canvas.Loading = false; return;
}
}
if (string.Equals(
Path.GetExtension(lasttrack),
".trk",
StringComparison.InvariantCultureIgnoreCase))
{
var trackname = TrackIO.GetTrackName(lasttrack);
lock (LoadSync)
{
var track = TRKLoader.LoadTrack(lasttrack, trackname);
ChangeTrack(track);
}
}
else if (string.Equals(
Path.GetExtension(lasttrack),
".json",
StringComparison.InvariantCultureIgnoreCase))
{
var trackname = TrackIO.GetTrackName(lasttrack);
lock (LoadSync)
{
var track = JSONLoader.LoadTrack(lasttrack);
if (track.Name == Constants.DefaultTrackName ||
string.IsNullOrEmpty(track.Name))
{
track.Name = trackname;
}
ChangeTrack(track);
}
}
else if (string.Equals(
Path.GetExtension(lasttrack),
".sol",
StringComparison.InvariantCultureIgnoreCase))
{
var trackname = TrackIO.GetTrackName(lasttrack);
var sol = SOLLoader.LoadSol(lasttrack);
if (sol.Count == 0)
{
return;
}
lock (LoadSync)
{
var track = SOLLoader.LoadTrack(sol[0]);
ChangeTrack(track);
}
}
}
catch (Exception e)
{
Debug.WriteLine("Autoload failure: " + e.ToString());
}
finally
{
game.Canvas.Loading = false;
}
}
//Let's not move this because this is just for user-debugging and has no connection to the API itself
public static void GenerateRoute(string safeFileName, List <Location> destinations)
{
TrainSchedule.SaveRoute(destinations, safeFileName);
TrackIO.ExportTrack("[A]------[B]----[C]---[D]---=--[E]---[F]", safeFileName);
}
