diff --git a/StarterNG.Tests/BinaryTerrainFilesTests.cs b/StarterNG.Tests/BinaryTerrainFilesTests.cs
new file mode 100644
index 0000000..159d8d3
--- /dev/null
+++ b/StarterNG.Tests/BinaryTerrainFilesTests.cs
@@ -0,0 +1,157 @@
+using StarterNG.Infrastructure.Adapters;
+using StarterNG.Infrastructure.Sceneries;
+using StarterNG.Tests.Fakes;
+
+namespace StarterNG.Tests;
+
+public class BinaryTerrainFilesTests
+{
+ private const string Record = "user/sbt-cleanup.txt";
+
+ private static BinaryTerrainFiles Build(InMemoryFileSystem files, string root = "game") =>
+ new(files, new GamePaths(root), TestLog.Over(files), Record);
+
+ private static string Scenery(string name) => $"game/scenery/{name}";
+
+ [Fact]
+ public void An_sbt_whose_terrain_files_are_all_there_goes()
+ {
+ var files = new InMemoryFileSystem()
+ .WithLegacyFile(Scenery("kato.scn"), "include kato/kato_ter.scm end\nFirstInit\n")
+ .WithFile(Scenery("kato/kato_ter.scm"), "node")
+ .WithFile(Scenery("kato.sbt"), "EU07SBT2");
+
+ var cleanup = Build(files).CleanUpOnce(1)!;
+
+ Assert.Equal("kato.sbt", Assert.Single(cleanup.Deleted));
+ Assert.False(files.FileExists(Scenery("kato.sbt")));
+ }
+
+ [Fact]
+ public void An_sbt_standing_in_for_missing_terrain_files_stays()
+ {
+ var files = new InMemoryFileSystem(caseSensitive: true)
+ .WithLegacyFile(Scenery("Lk2_Sandbox.scn"), "include nmt/nmt100_mazowieckie_ter.scm end\nFirstInit\n")
+ .WithFile(Scenery("lk2_sandbox.sbt"), "EU07SBT2");
+
+ var cleanup = Build(files).CleanUpOnce(1)!;
+
+ Assert.Empty(cleanup.Deleted);
+ Assert.Equal(("lk2_sandbox.sbt", "nmt/nmt100_mazowieckie_ter.scm"), Assert.Single(cleanup.Kept));
+ Assert.True(files.FileExists(Scenery("lk2_sandbox.sbt")));
+ }
+
+ [Theory]
+ [InlineData(true)]
+ [InlineData(false)]
+ public void Terrain_included_through_another_file_is_looked_for_too(bool present)
+ {
+ var files = new InMemoryFileSystem()
+ .WithLegacyFile(Scenery("td.scn"), "include td/base.inc end\nFirstInit\n")
+ .WithLegacyFile(Scenery("td/base.inc"), "include td/td_ter.scm 1 2 end\n")
+ .WithFile(Scenery("td.sbt"), "EU07SBT2");
+ if (present)
+ files.WithFile(Scenery("td/td_ter.scm"), "node");
+
+ var cleanup = Build(files).CleanUpOnce(1)!;
+
+ Assert.Equal(present, cleanup.Deleted.Count == 1);
+ Assert.Equal(present, !files.FileExists(Scenery("td.sbt")));
+ }
+
+ [Fact]
+ public void A_missing_include_other_than_terrain_does_not_keep_the_sbt()
+ {
+ var files = new InMemoryFileSystem()
+ .WithLegacyFile(Scenery("tomaszewo.scn"), "include tomaszewo/modele.scm end\nFirstInit\n")
+ .WithLegacyFile(Scenery("tomaszewo/modele.scm"),
+ "include;przejazdy_kombud\\1t12m_0rog_2zar_1x_1dzw.inc;p_czernica15;0;0;0;end\n")
+ .WithFile(Scenery("tomaszewo.sbt"), "EU07SBT2");
+
+ Assert.Single(Build(files).CleanUpOnce(1)!.Deleted);
+ }
+
+ [Fact]
+ public void An_include_commented_out_needs_no_file()
+ {
+ var files = new InMemoryFileSystem()
+ .WithLegacyFile(Scenery("td.scn"), "// include gone_ter.scm end\n/* include gone.inc end */\nFirstInit\n")
+ .WithFile(Scenery("td.sbt"), "EU07SBT2");
+
+ Assert.Single(Build(files).CleanUpOnce(1)!.Deleted);
+ }
+
+ [Fact]
+ public void A_scenery_bringing_terrain_by_a_terrain_directive_keeps_its_sbt()
+ {
+ var files = new InMemoryFileSystem()
+ .WithLegacyFile(Scenery("td.scn"), "terrain td.sbt endterrain\nFirstInit\n")
+ .WithFile(Scenery("td.sbt"), "EU07SBT2");
+
+ Assert.Equal("td.sbt", Assert.Single(Build(files).CleanUpOnce(1)!.Kept).File);
+ }
+
+ [Fact]
+ public void An_sbt_of_no_scenery_stays()
+ {
+ var files = new InMemoryFileSystem()
+ .WithFile(Scenery("old.sbt"), "EU07SBT2");
+
+ Assert.Equal(("old.sbt", "old.scn"), Assert.Single(Build(files).CleanUpOnce(1)!.Kept));
+ }
+
+ [Fact]
+ public void Each_generation_clears_an_installation_once()
+ {
+ var files = new InMemoryFileSystem()
+ .WithLegacyFile(Scenery("td.scn"), "FirstInit\n")
+ .WithFile(Scenery("td.sbt"), "EU07SBT2");
+ var sbt = Build(files);
+
+ Assert.NotNull(sbt.CleanUpOnce(1));
+ files.WithFile(Scenery("td.sbt"), "EU07SBT2");
+
+ Assert.Null(sbt.CleanUpOnce(1));
+ Assert.True(files.FileExists(Scenery("td.sbt")));
+
+ Assert.Single(sbt.CleanUpOnce(2)!.Deleted);
+ }
+
+ [Fact]
+ public void Generation_zero_clears_nothing()
+ {
+ var files = new InMemoryFileSystem()
+ .WithLegacyFile(Scenery("td.scn"), "FirstInit\n")
+ .WithFile(Scenery("td.sbt"), "EU07SBT2");
+
+ Assert.Null(Build(files).CleanUpOnce(0));
+ Assert.True(files.FileExists(Scenery("td.sbt")));
+ }
+
+ [Fact]
+ public void Another_installation_has_a_cleanup_of_its_own()
+ {
+ var files = new InMemoryFileSystem()
+ .WithLegacyFile(Scenery("td.scn"), "FirstInit\n")
+ .WithLegacyFile("other/scenery/td.scn", "FirstInit\n")
+ .WithFile("other/scenery/td.sbt", "EU07SBT2");
+
+ Assert.NotNull(Build(files).CleanUpOnce(1));
+
+ Assert.Single(Build(files, "other").CleanUpOnce(1)!.Deleted);
+ }
+
+ [Fact]
+ public void One_scenery_s_sbt_is_found_whatever_its_case_and_deleted()
+ {
+ var files = new InMemoryFileSystem(caseSensitive: true)
+ .WithLegacyFile(Scenery("Kato.scn"), "FirstInit\n")
+ .WithFile(Scenery("kato.sbt"), "EU07SBT2");
+ var sbt = Build(files);
+
+ Assert.Equal(Path.Combine("game", "scenery", "kato.sbt"), sbt.Of(Scenery("Kato.scn")));
+ Assert.Null(sbt.MissingOriginal(Scenery("Kato.scn")));
+ Assert.True(sbt.Delete(Scenery("Kato.scn")));
+ Assert.Null(sbt.Of(Scenery("Kato.scn")));
+ }
+}
diff --git a/StarterNG.Tests/SceneryFileWatchTests.cs b/StarterNG.Tests/SceneryFileWatchTests.cs
index d33bd3f..f731294 100644
--- a/StarterNG.Tests/SceneryFileWatchTests.cs
+++ b/StarterNG.Tests/SceneryFileWatchTests.cs
@@ -53,6 +53,26 @@ public class SceneryFileWatchTests
Assert.Equal("Katowice Główne", change.Fresh!.Name);
}
+ [Theory]
+ [InlineData(true)]
+ [InlineData(false)]
+ public void An_sbt_made_or_removed_makes_the_scenery_read_anew(bool there)
+ {
+ string sbt = TestInstallation.At("scenery", "kato.sbt");
+ var files = Folder();
+ if (there)
+ files.WithFile(sbt, "EU07SBT2");
+ var (installation, watch, _) = Rig(files);
+
+ if (there)
+ files.DeleteFile(sbt);
+ else
+ files.WithFile(sbt, "EU07SBT2");
+
+ var change = Assert.Single(watch.Look(installation.Library.Sceneries));
+ Assert.Equal(!there, change.Fresh!.HasCompanionTimetable);
+ }
+
[Fact]
public void An_include_that_changed_or_came_makes_the_scenery_read_anew()
{
diff --git a/StarterNG/App.axaml.cs b/StarterNG/App.axaml.cs
index 747cf9b..86b9234 100644
--- a/StarterNG/App.axaml.cs
+++ b/StarterNG/App.axaml.cs
@@ -160,6 +160,9 @@ public partial class App : Avalonia.Application
});
});
+ // Ahead of the sceneries, so the list knows which still have their .sbt.
+ try { AppServices.Current.BinaryTerrain.CleanUpOnce(); }
+ catch (Exception ex) { Diagnostics.Log("sbt cleanup", ex); }
AppServices.Current.Library.Load(progress);
}).ContinueWith(load =>
{
diff --git a/StarterNG/Application/AppServices.cs b/StarterNG/Application/AppServices.cs
index 2f6f1a8..808a03a 100644
--- a/StarterNG/Application/AppServices.cs
+++ b/StarterNG/Application/AppServices.cs
@@ -43,6 +43,7 @@ public sealed class AppServices
paths.FromRoot("starter"),
paths.FromRoot("lang")));
Sceneries = new SceneryRepository(files, paths, log, new SceneryParser(clock, random));
+ BinaryTerrain = new BinaryTerrainFiles(files, paths, log, settingsPaths.SbtCleanupPath());
SceneryImages = new SceneryImageLocator(files);
MiniTextures = new MiniTextureIndex(files, paths);
@@ -111,6 +112,8 @@ public sealed class AppServices
public SceneryFileWatch SceneryFiles { get; }
+ public BinaryTerrainFiles BinaryTerrain { get; }
+
public SceneryImageLocator SceneryImages { get; }
public IMiniTextureIndex MiniTextures { get; }
diff --git a/StarterNG/Infrastructure/Sceneries/BinaryTerrainFiles.cs b/StarterNG/Infrastructure/Sceneries/BinaryTerrainFiles.cs
new file mode 100644
index 0000000..2036ba0
--- /dev/null
+++ b/StarterNG/Infrastructure/Sceneries/BinaryTerrainFiles.cs
@@ -0,0 +1,257 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using StarterNG.Application.Abstractions;
+using StarterNG.Domain;
+using StarterNG.Domain.Sceneries;
+using StarterNG.Infrastructure.Adapters;
+
+namespace StarterNG.Infrastructure.Sceneries;
+
+///
+/// The sceneries' binary terrain files (.sbt): the simulator writes one beside a
+/// scenery on its first load and from then on takes the terrain from it, passing
+/// the scenery's terrain includes (*_ter.scm) over. It never asks whether
+/// the text changed since, so a file made by an older simulator, or before the
+/// scenery was updated, keeps showing what was there then.
+///
+/// A file goes only when the scenery's text still holds what it was made of: some
+/// sceneries come with the .sbt in place of their terrain includes, and without it
+/// they would have no terrain at all.
+///
+///
+public sealed class BinaryTerrainFiles
+{
+ ///
+ /// Raised by a release that wants the .sbt files made anew: each installation is
+ /// cleared once for each value, on the first start of a starter carrying it.
+ /// Zero clears nothing.
+ ///
+ public const int CleanupGeneration = 1;
+
+ private const string Extension = ".sbt";
+
+ // The simulator splits its text into words at spaces, tabs, line ends and semicolons.
+ private static readonly Regex Word = new(@"[^\s;]+", RegexOptions.CultureInvariant);
+
+ private readonly IFileSystem _files;
+ private readonly IGamePaths _paths;
+ private readonly IDiagnosticsLog _log;
+ private readonly string _recordPath;
+
+ /// Where the cleanups done are noted, for each installation.
+ public BinaryTerrainFiles(IFileSystem files, IGamePaths paths, IDiagnosticsLog log, string recordPath)
+ {
+ _files = files;
+ _paths = paths;
+ _log = log;
+ _recordPath = recordPath;
+ }
+
+ /// The scenery's own .sbt as it is on disk, whatever the case of its letters; null when it has none.
+ public string? Of(string sceneryPath)
+ {
+ string? file = new CaseInsensitivePaths(_files)
+ .Resolve(_paths.Scenery, Path.GetFileNameWithoutExtension(sceneryPath) + Extension);
+ return file is null ? null : Path.Combine(_paths.Scenery, file);
+ }
+
+ ///
+ /// What the simulator would miss to make the scenery's .sbt again - the first
+ /// terrain file its text names and the installation lacks, or the terrain directive
+ /// that brings terrain from elsewhere; null when the text holds it all.
+ ///
+ public string? MissingOriginal(string sceneryPath)
+ {
+ try
+ {
+ var names = new CaseInsensitivePaths(_files, keepListings: true);
+ string? own = names.Resolve(_paths.Scenery, Path.GetFileName(sceneryPath));
+ if (own is null)
+ return Path.GetFileName(sceneryPath);
+
+ var seen = new HashSet(StringComparer.OrdinalIgnoreCase);
+ var pending = new Stack();
+ pending.Push(own);
+ while (pending.Count > 0)
+ {
+ string file = pending.Pop();
+ if (!seen.Add(file))
+ continue;
+
+ if (Scan(file, names, pending) is { } missing)
+ return missing;
+ }
+
+ return null;
+ }
+ catch (Exception ex)
+ {
+ _log.Log($"sbt/{Path.GetFileName(sceneryPath)}", ex);
+ return Path.GetFileName(sceneryPath);
+ }
+ }
+
+ ///
+ /// Reads one file of the scenery for its includes: the terrain ones have to be
+ /// there, the others are read in turn. Terrain files are not opened - they are the
+ /// largest of all and include nothing.
+ ///
+ private string? Scan(string file, CaseInsensitivePaths names, Stack pending)
+ {
+ string text = LegacyText.Decode(_files.ReadAllBytes(Path.Combine(_paths.Scenery, file)));
+ string code = SceneryCode.Mask(text, out _);
+
+ bool includeNext = false;
+ for (var word = Word.Match(code); word.Success; word = word.NextMatch())
+ {
+ string token = word.Value;
+ if (includeNext)
+ {
+ includeNext = false;
+ bool terrain = SimulatorNames.Lower(token).Contains("_ter.scm");
+ string? found = names.Resolve(_paths.Scenery, token);
+ if (found is null && terrain)
+ return token;
+ // Any other file the simulator reads from the text, .sbt or not: missing,
+ // it is missing either way, and the .sbt made again lacks nothing.
+ if (found is not null && !terrain)
+ pending.Push(found);
+ }
+ else if (token.Equals("include", StringComparison.OrdinalIgnoreCase))
+ includeNext = true;
+ else if (token.Equals("terrain", StringComparison.OrdinalIgnoreCase))
+ return token;
+ }
+
+ return null;
+ }
+
+ /// Removes the scenery's .sbt; false when it has none or it could not go.
+ public bool Delete(string sceneryPath)
+ {
+ if (Of(sceneryPath) is not { } file)
+ return false;
+
+ try
+ {
+ _files.DeleteFile(file);
+ _log.Log($"{file} removed, the simulator makes it again on the next load of the scenery");
+ return true;
+ }
+ catch (Exception ex)
+ {
+ _log.Log($"sbt/{Path.GetFileName(file)}", ex);
+ return false;
+ }
+ }
+
+ ///
+ /// Clears the .sbt files the simulator can make again, once for each
+ /// on this installation; null when it was done
+ /// already. A file that could not go leaves the cleanup to the next start.
+ ///
+ public BinaryTerrainCleanup? CleanUpOnce(int generation = CleanupGeneration)
+ {
+ if (generation <= 0 || !_files.DirectoryExists(_paths.Scenery))
+ return null;
+
+ var record = ReadRecord();
+ string installation = Installation();
+ if (record.TryGetValue(installation, out int done) && done >= generation)
+ return null;
+
+ var deleted = new List();
+ var kept = new List<(string File, string Reason)>();
+ var failed = new List();
+ var names = new CaseInsensitivePaths(_files);
+
+ foreach (string sbt in _files.GetFiles(_paths.Scenery)
+ .Where(f => Path.GetExtension(f).Equals(Extension, StringComparison.OrdinalIgnoreCase)))
+ {
+ string name = Path.GetFileName(sbt);
+ string? scenery = names.Resolve(_paths.Scenery, Path.GetFileNameWithoutExtension(sbt) + ".scn");
+ string? missing = scenery is null ? Path.GetFileNameWithoutExtension(sbt) + ".scn" : MissingOriginal(scenery);
+ if (missing is not null)
+ {
+ kept.Add((name, missing));
+ _log.Log($"{name} kept: the scenery cannot be made without it, {missing} is missing");
+ continue;
+ }
+
+ try
+ {
+ _files.DeleteFile(sbt);
+ deleted.Add(name);
+ }
+ catch (Exception ex)
+ {
+ failed.Add(name);
+ _log.Log($"sbt/{name}", ex);
+ }
+ }
+
+ if (deleted.Count > 0)
+ _log.Log($"Binary terrain files removed, the simulator makes them again: {string.Join(", ", deleted)}");
+
+ if (failed.Count == 0)
+ {
+ record[installation] = generation;
+ WriteRecord(record);
+ }
+
+ return new BinaryTerrainCleanup(deleted, kept, failed);
+ }
+
+ private string Installation() =>
+ Path.TrimEndingDirectorySeparator(Path.GetFullPath(_paths.Root));
+
+ private Dictionary ReadRecord()
+ {
+ var record = new Dictionary(
+ _files.IgnoresCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);
+ try
+ {
+ if (!_files.FileExists(_recordPath))
+ return record;
+
+ foreach (string line in _files.ReadAllLines(_recordPath))
+ {
+ int tab = line.IndexOf('\t');
+ if (tab > 0 && int.TryParse(line[..tab], out int generation))
+ record[line[(tab + 1)..]] = generation;
+ }
+ }
+ catch (Exception ex)
+ {
+ _log.Log("sbt cleanup record", ex);
+ }
+
+ return record;
+ }
+
+ private void WriteRecord(Dictionary record)
+ {
+ try
+ {
+ if (Path.GetDirectoryName(_recordPath) is { Length: > 0 } folder)
+ _files.CreateDirectory(folder);
+ _files.WriteAllTextAtomic(_recordPath,
+ string.Concat(record.Select(entry => $"{entry.Value}\t{entry.Key}\n")));
+ }
+ catch (Exception ex)
+ {
+ _log.Log("sbt cleanup record", ex);
+ }
+ }
+}
+
+/// The files removed.
+/// The files left, as nothing could make them again, each with what is missing.
+/// The files that could not be removed.
+public sealed record BinaryTerrainCleanup(
+ IReadOnlyList Deleted,
+ IReadOnlyList<(string File, string Reason)> Kept,
+ IReadOnlyList Failed);
diff --git a/StarterNG/Infrastructure/Sceneries/SceneryRepository.cs b/StarterNG/Infrastructure/Sceneries/SceneryRepository.cs
index 229d59a..63c02c3 100644
--- a/StarterNG/Infrastructure/Sceneries/SceneryRepository.cs
+++ b/StarterNG/Infrastructure/Sceneries/SceneryRepository.cs
@@ -79,7 +79,12 @@ public sealed class SceneryRepository : ISceneryRepository
// With its own .sbt the scenery's terrain comes from it, and the simulator
// passes its terrain includes over without opening them.
- bool binaryTerrain = Opens(Path.GetFileNameWithoutExtension(path) + ".sbt");
+ // Watched with the text: made by the simulator on a load, or removed, it changes the scenery too.
+ string sbtName = Path.GetFileNameWithoutExtension(path) + ".sbt";
+ string? sbt = ResolveInclude(sbtName);
+ bool binaryTerrain = sbt is not null;
+ string sbtPath = Path.Combine(_paths.Scenery, sbt ?? sbtName);
+ sources[sbtPath] = FileStamp.Of(_files, sbtPath);
bool OpensInclude(string name) =>
Opens(name) || (binaryTerrain && SimulatorNames.Lower(name).Contains("_ter.scm"));
diff --git a/StarterNG/Infrastructure/Settings/SettingsPaths.cs b/StarterNG/Infrastructure/Settings/SettingsPaths.cs
index a80a297..55130cf 100644
--- a/StarterNG/Infrastructure/Settings/SettingsPaths.cs
+++ b/StarterNG/Infrastructure/Settings/SettingsPaths.cs
@@ -53,6 +53,9 @@ public sealed class SettingsPaths
/// The sceneries starred in the list.
public string FavoritesPath() => Path.Combine(UserConfigDirectory(), "favorites.txt");
+ /// Which cleanup of the .sbt files each installation had.
+ public string SbtCleanupPath() => Path.Combine(UserConfigDirectory(), "sbt-cleanup.txt");
+
public string UserConfigDirectory() =>
Path.GetDirectoryName(UserConfigPath()) ?? _environment.BaseDirectory;
}
diff --git a/StarterNG/Views/Scenarios.axaml b/StarterNG/Views/Scenarios.axaml
index 7e733dd..5c541b0 100644
--- a/StarterNG/Views/Scenarios.axaml
+++ b/StarterNG/Views/Scenarios.axaml
@@ -45,6 +45,8 @@
Header="{Binding [ReloadSceneries], Source={x:Static starterNg:App.Loc}}" />
+
diff --git a/StarterNG/Views/Scenarios.axaml.cs b/StarterNG/Views/Scenarios.axaml.cs
index 326a283..856e09f 100644
--- a/StarterNG/Views/Scenarios.axaml.cs
+++ b/StarterNG/Views/Scenarios.axaml.cs
@@ -165,6 +165,39 @@ public partial class Scenarios : UserControl
favoriteMenuItem.Header = App.Loc[scenery is not null && AppServices.Current.Favorites.Contains(scenery)
? "FavoriteRemove"
: "FavoriteAdd"];
+ deleteSbtMenuItem.IsEnabled = scenery is not null
+ && !AppServices.Current.State.SimulatorRunning
+ && AppServices.Current.BinaryTerrain.Of(scenery.Path) is not null;
+ }
+
+ // Only a file the simulator can make again from the scenery's text goes: one
+ // standing in for terrain files the installation lacks takes the terrain with it.
+ private async void DeleteSbt_OnClick(object? sender, RoutedEventArgs e)
+ {
+ if (SelectedScenery is not { } scenery || TopLevel.GetTopLevel(this) is not Window owner)
+ return;
+
+ var sbt = AppServices.Current.BinaryTerrain;
+ if (sbt.Of(scenery.Path) is not { } file)
+ return;
+
+ string name = Path.GetFileName(file);
+ string title = App.Loc["DeleteSbt"];
+ if (await Task.Run(() => sbt.MissingOriginal(scenery.Path)) is { } missing)
+ {
+ await MessageBox.Show(owner, string.Format(App.Loc["DeleteSbtNoOriginal"], name, missing), title,
+ MessageBoxButtons.Ok);
+ return;
+ }
+
+ long megabytes = AppServices.Current.Files.GetFileSize(file) / (1024 * 1024);
+ if (!await MessageBox.Show(owner, string.Format(App.Loc["DeleteSbtConfirm"], name, megabytes), title,
+ MessageBoxButtons.YesNo))
+ return;
+
+ // Gone, the scenery follows by the watch on its files, as it would after any other change.
+ if (!await Task.Run(() => sbt.Delete(scenery.Path)))
+ await MessageBox.Show(owner, string.Format(App.Loc["DeleteSbtFailed"], name), title, MessageBoxButtons.Ok);
}
private void ToggleFavorite_OnClick(object? sender, RoutedEventArgs e)
diff --git a/StarterNG/startercfg/lang/cz.xml b/StarterNG/startercfg/lang/cz.xml
index 9bbfc85..2e18be6 100644
--- a/StarterNG/startercfg/lang/cz.xml
+++ b/StarterNG/startercfg/lang/cz.xml
@@ -69,6 +69,10 @@
Přidat do oblíbených
Odebrat z oblíbených
Otevřít složku
+ Smazat SBT
+ Smazat {0} ({1} MB)? Simulátor jej znovu sestaví ze souborů scenérie při jejím dalším načtení, které potrvá déle.
+ Soubor {0} zůstává: není z čeho jej znovu sestavit, chybí {1}. Bez něj by scenérie přišla o terén.
+ Soubor {0} nelze smazat. Možná jej používá simulátor, nebo je složka jen pro čtení.
Volitelné prvky
Otevřít složku s texturami
Kopírovat název
diff --git a/StarterNG/startercfg/lang/en.xml b/StarterNG/startercfg/lang/en.xml
index db28d6a..819f111 100644
--- a/StarterNG/startercfg/lang/en.xml
+++ b/StarterNG/startercfg/lang/en.xml
@@ -69,6 +69,10 @@
Add to favourites
Remove from favourites
Open folder
+ Delete SBT
+ Delete {0} ({1} MB)? The simulator makes it again from the scenery files on its next load, which takes longer.
+ {0} stays: nothing is there to make it again, {1} is missing. Without it the scenery would lose its terrain.
+ Could not delete {0}. The simulator may be using it, or the folder is read-only.
Optional elements
Open texture folder
Copy name
diff --git a/StarterNG/startercfg/lang/hu.xml b/StarterNG/startercfg/lang/hu.xml
index e65ecd9..8d0c08c 100644
--- a/StarterNG/startercfg/lang/hu.xml
+++ b/StarterNG/startercfg/lang/hu.xml
@@ -69,6 +69,10 @@
Hozzáadás a kedvencekhez
Eltávolítás a kedvencek közül
Mappa megnyitása
+ SBT törlése
+ Törlöd: {0} ({1} MB)? A szimulátor a színtér fájljaiból a következő betöltéskor újra elkészíti, ami tovább tart.
+ {0} megmarad: nincs miből újra elkészíteni, hiányzik: {1}. Nélküle a színtér elveszítené a terepet.
+ Nem sikerült törölni: {0}. Lehet, hogy a szimulátor használja, vagy a mappa csak olvasható.
Opcionális elemek
Textúramappa megnyitása
Név másolása
diff --git a/StarterNG/startercfg/lang/pl.xml b/StarterNG/startercfg/lang/pl.xml
index 5ab0d59..b3c9fd2 100644
--- a/StarterNG/startercfg/lang/pl.xml
+++ b/StarterNG/startercfg/lang/pl.xml
@@ -69,6 +69,10 @@
Dodaj do ulubionych
Usuń z ulubionych
Otwórz folder
+ Usuń SBT
+ Usunąć {0} ({1} MB)? Symulator zbuduje go od nowa z plików scenerii przy jej następnym wczytaniu, które potrwa dłużej.
+ Plik {0} zostaje: sceneria nie ma z czego go odbudować, brakuje {1}. Bez niego straciłaby teren.
+ Nie udało się usunąć {0}. Może używa go symulator albo folder jest tylko do odczytu.
Elementy opcjonalne
Otwórz folder tekstury
Kopiuj nazwę
diff --git a/StarterNG/startercfg/lang/ru.xml b/StarterNG/startercfg/lang/ru.xml
index 6e499d3..3ee4aa4 100644
--- a/StarterNG/startercfg/lang/ru.xml
+++ b/StarterNG/startercfg/lang/ru.xml
@@ -69,6 +69,10 @@
Добавить в избранное
Удалить из избранного
Открыть папку
+ Удалить SBT
+ Удалить {0} ({1} МБ)? Симулятор заново соберёт его из файлов сценария при следующей загрузке, которая займёт больше времени.
+ Файл {0} остаётся: его не из чего собрать заново, нет {1}. Без него сценарий лишится рельефа.
+ Не удалось удалить {0}. Возможно, его использует симулятор или папка только для чтения.
Дополнительные элементы
Открыть папку с текстурами
Копировать название