From 4ef2fa8226d4f8ef8f958d651cb76094a647d276 Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Tue, 9 Jan 2024 18:08:22 +0800
Subject: [PATCH 01/19] Add game_profile.conf and Gradle settings

---
 .github/workflows/autobuild.yml | 59 ++++++++++++++-------------------
 build.gradle                    | 21 +++++++++++-
 game_profile.conf               |  2 ++
 3 files changed, 47 insertions(+), 35 deletions(-)
 create mode 100644 game_profile.conf

diff --git a/.github/workflows/autobuild.yml b/.github/workflows/autobuild.yml
index f7662bdb5..3276c3f53 100644
--- a/.github/workflows/autobuild.yml
+++ b/.github/workflows/autobuild.yml
@@ -3,7 +3,7 @@ on:
   schedule:
     - cron:  '0 0 * * *'
   workflow_dispatch:
-  
+
 jobs:
   gradle:
     strategy:
@@ -16,18 +16,28 @@ jobs:
     - uses: actions/checkout@v3
       with:
         token: ${{ secrets.LITOROMTOKEN }}
-    - name: Update ingame version
-      uses: jacobtomlinson/gha-find-replace@v3
-      with:
-        find: "${{ vars.VERSION }}-dev${{ vars.VERSION_old }}"
-        replace: "${{ vars.VERSION }}-dev${{ vars.VERSION_s }}"
-        include: "src/client/java/minicraft/core/Game.java"
-    - name: Update gradle version
-      uses: jacobtomlinson/gha-find-replace@v3
-      with:
-        find: "version = \"${{ vars.VERSION }}-dev${{ vars.VERSION_old }}\""
-        replace: "version = \"${{ vars.VERSION }}-dev${{ vars.VERSION_s }}\""
-        include: "build.gradle"
+    - name: Read game profile configs
+      run: |
+        source game_profile.conf
+        echo "GAME_VER=$version" >> $GITHUB_ENV
+        echo "DEV_BUILD=$devBuild" >> $GITHUB_ENV
+    # Do no increment game version if it is not currently in a development build state.
+    # Source: https://stackoverflow.com/a/75809743
+    - name: Abort
+      if: ${{ ! env.DEV_BUILD }}
+      run: |
+        gh run cancel ${{ github.run_id }}
+        gh run watch ${{ github.run_id }}
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    - name: Increment game version
+      run: |
+        dev_num=$( [[ $GAME_VER = *"dev"* ]] && ( echo $GAME_VER | grep -Po "[0-9.]+-dev\K\d+" ) || ( echo 0 ) )
+        ((dev_num++))
+        base_ver=$( echo $GAME_VER | grep -o "^[^-]*" )
+        echo "GAME_VER=$base_ver-dev$dev_num" >> $GITHUB_ENV
+    - name: Update game version
+      run: sed -E -i "/^version=.+$/ s/[0-9]+.+$/$GAME_VER/" game_profile.conf
     - name: Push changes
       uses: stefanzweifel/git-auto-commit-action@v4
       with:
@@ -35,34 +45,15 @@ jobs:
         token: ${{ secrets.LITOROMTOKEN }}
         repository: ${{ secrets.GITHUB_REPOSITORY }}
         branch: ${{ github.ref }}
-      
+
     - uses: actions/setup-java@v3
       with:
         distribution: temurin
         java-version: 8
-
-    - name: Increment old version number
-      uses: action-pack/increment@v2
-      with:
-        name: 'VERSION_old'
-        token: ${{ secrets.LITOROMTOKEN }}
-        repository: ${{ secrets.GITHUB_REPOSITORY }}
-        owner: 'MinicraftPlus'
-        
-    - name: Increment new version number
-      uses: action-pack/increment@v2
-      with:
-        name: 'VERSION_s'
-        token: ${{ secrets.LITOROMTOKEN }}
-        repository: ${{ secrets.GITHUB_REPOSITORY }}
-        owner: 'MinicraftPlus'
-        
     - name: Setup Gradle
       uses: gradle/gradle-build-action@v2.4.2
-      
     - name: Execute Gradle build
       run: ./gradlew build
-
     - uses: "dciborow/action-github-releases@v1.0.1"
       with:
         repo_token: "${{ secrets.GITHUB_TOKEN }}"
@@ -74,4 +65,4 @@ jobs:
           LICENSE
           ChangeLog.md
           build/libs/**.jar
-          
+
diff --git a/build.gradle b/build.gradle
index 8033cff4b..7805a9f20 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,3 +1,5 @@
+import groovy.json.JsonBuilder
+
 plugins {
     id 'application'
 }
@@ -5,7 +7,10 @@ plugins {
 allprojects {
     apply plugin: "java"
 
-    version = "2.2.0-dev6"
+    Properties profile = new Properties()
+    profile.load(new FileInputStream("game_profile.conf"))
+
+    version = profile.getProperty("version")
 
     sourceCompatibility = 8
     [compileJava, compileTestJava]*.options*.encoding = 'UTF-8'
@@ -41,6 +46,20 @@ project(":common") {
 project(":client") {
     archivesBaseName = "minicraft-plus"
 
+    File genDir = new File(project.buildDir, "tmp/generatedResources/")
+    genDir.mkdirs()
+    JsonBuilder json = new JsonBuilder()
+    json {
+        version version
+    }
+    File metaFile = new File(genDir.toString(), "profile.meta.json")
+    metaFile.text = json.toString()
+    processResources {
+        from(genDir) {
+            include(metaFile.getName())
+        }
+    }
+
     repositories {
         maven { url "https://plugins.gradle.org/m2/" }
         maven { url "https://jitpack.io" }
diff --git a/game_profile.conf b/game_profile.conf
new file mode 100644
index 000000000..2cec452f1
--- /dev/null
+++ b/game_profile.conf
@@ -0,0 +1,2 @@
+version=2.2.0-dev6
+devBuild=true

From 50dd972d5dc4e8facb28c8d484243dd208b09d16 Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Tue, 9 Jan 2024 18:22:56 +0800
Subject: [PATCH 02/19] Make Game read game_profile.conf

---
 build.gradle                             |  2 +-
 src/client/java/minicraft/core/Game.java | 29 +++++++++++++++++++++---
 2 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/build.gradle b/build.gradle
index 7805a9f20..81c3c9f64 100644
--- a/build.gradle
+++ b/build.gradle
@@ -8,7 +8,7 @@ allprojects {
     apply plugin: "java"
 
     Properties profile = new Properties()
-    profile.load(new FileInputStream("game_profile.conf"))
+    profile.load(new FileInputStream(new File(rootDir, "game_profile.conf")))
 
     version = profile.getProperty("version")
 
diff --git a/src/client/java/minicraft/core/Game.java b/src/client/java/minicraft/core/Game.java
index 449b5ad96..b0ce4ff76 100644
--- a/src/client/java/minicraft/core/Game.java
+++ b/src/client/java/minicraft/core/Game.java
@@ -14,10 +14,18 @@
 import minicraft.screen.TitleDisplay;
 import minicraft.util.Logging;
 import org.jetbrains.annotations.Nullable;
+import org.json.JSONObject;
 
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.UncheckedIOException;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
 
 public class Game {
 	protected Game() {
@@ -25,7 +33,7 @@ protected Game() {
 
 	public static final String NAME = "Minicraft Plus"; // This is the name on the application window.
 
-	public static final Version VERSION = new Version("2.2.0-dev6");
+	public static final Version VERSION;
 
 	public static InputHandler input; // Input used in Game, Player, and just about all the *Menu classes.
 	public static Player player;
@@ -91,10 +99,25 @@ public static void quit() {
 		running = false;
 	}
 
-
-	public static void main(String[] args) {
+	static {
 		Thread.setDefaultUncaughtExceptionHandler(CrashHandler::crashHandle);
 
+		InputStream is = Game.class.getResourceAsStream("/profile.meta.json");
+		if (is == null)
+			throw new IllegalStateException("Malformed application setup");
+
+		JSONObject meta = new JSONObject(new BufferedReader(new InputStreamReader(is)).lines().collect(Collectors.joining("\n")));
+
+		VERSION = new Version(meta.getString("version"));
+
+		try {
+			is.close();
+		} catch (IOException e) {
+			throw new UncheckedIOException(e);
+		}
+	}
+
+	public static void main(String[] args) {
 		Initializer.parseArgs(args); // Parses the command line arguments
 		// Applying Game#debug first.
 

From 7849996c56ecd0e90b81bfcd35ab17dc872f76d5 Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Fri, 2 Feb 2024 02:47:46 +0800
Subject: [PATCH 03/19] Separate HistoricLoad from LegacyLoad

---
 src/client/java/minicraft/core/World.java     |   4 +-
 .../java/minicraft/saveload/HistoricLoad.java | 961 ++++++++++++++++++
 .../java/minicraft/saveload/LegacyLoad.java   | 112 +-
 src/client/java/minicraft/saveload/Load.java  | 150 ++-
 .../java/minicraft/screen/LoadingDisplay.java |  15 +-
 .../minicraft/screen/WorldSelectDisplay.java  |   6 +-
 6 files changed, 1133 insertions(+), 115 deletions(-)
 create mode 100644 src/client/java/minicraft/saveload/HistoricLoad.java

diff --git a/src/client/java/minicraft/core/World.java b/src/client/java/minicraft/core/World.java
index 6aeb52452..a5202464c 100644
--- a/src/client/java/minicraft/core/World.java
+++ b/src/client/java/minicraft/core/World.java
@@ -103,7 +103,9 @@ public static void resetGame(boolean keepPlayer) {
 	 * This method is used to create a brand new world, or to load an existing one from a file.
 	 * For the loading screen updates to work, it it assumed that *this* is called by a thread *other* than the one rendering the current *menu*.
 	 **/
-	public static void initWorld() { // This is a full reset; everything.
+	public static void initWorld()
+		throws Load.BackupCreationFailedException, Load.WorldLoadingFailedException,
+		Load.DungeonRegenerationCancelledException { // This is a full reset; everything.
 		Logging.WORLD.debug("Resetting world...");
 
 		PlayerDeathDisplay.shouldRespawn = false;
diff --git a/src/client/java/minicraft/saveload/HistoricLoad.java b/src/client/java/minicraft/saveload/HistoricLoad.java
new file mode 100644
index 000000000..8cc77a118
--- /dev/null
+++ b/src/client/java/minicraft/saveload/HistoricLoad.java
@@ -0,0 +1,961 @@
+package minicraft.saveload;
+
+import minicraft.core.Game;
+import minicraft.core.Updater;
+import minicraft.core.World;
+import minicraft.core.io.Settings;
+import minicraft.entity.Entity;
+import minicraft.entity.furniture.Bed;
+import minicraft.entity.furniture.Chest;
+import minicraft.entity.furniture.Crafter;
+import minicraft.entity.furniture.DeathChest;
+import minicraft.entity.furniture.DungeonChest;
+import minicraft.entity.furniture.Lantern;
+import minicraft.entity.furniture.Spawner;
+import minicraft.entity.furniture.Tnt;
+import minicraft.entity.mob.AirWizard;
+import minicraft.entity.mob.Cow;
+import minicraft.entity.mob.Creeper;
+import minicraft.entity.mob.Knight;
+import minicraft.entity.mob.Mob;
+import minicraft.entity.mob.MobAi;
+import minicraft.entity.mob.Pig;
+import minicraft.entity.mob.Player;
+import minicraft.entity.mob.Sheep;
+import minicraft.entity.mob.Skeleton;
+import minicraft.entity.mob.Slime;
+import minicraft.entity.mob.Snake;
+import minicraft.entity.mob.Zombie;
+import minicraft.gfx.Color;
+import minicraft.item.ArmorItem;
+import minicraft.item.Inventory;
+import minicraft.item.Item;
+import minicraft.item.Items;
+import minicraft.item.PotionItem;
+import minicraft.item.PotionType;
+import minicraft.item.StackableItem;
+import minicraft.item.UnknownItem;
+import minicraft.level.Level;
+import minicraft.level.tile.Tiles;
+import minicraft.util.Logging;
+import org.jetbrains.annotations.Nullable;
+import org.tinylog.Logger;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.FileAlreadyExistsException;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.regex.MatchResult;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/** This is used for loading save files before 1.9.1. */
+@SuppressWarnings("SpellCheckingInspection")
+public class HistoricLoad {
+	/*
+	 * Save Structure Change History (UTC)
+	 *
+	 * Notes:
+	 *   - For indices, the indices are the new values when there are changes; old values if they are being removed.
+	 *   - Indices are still counted whatever the conditions of the save values are.
+	 *   - "<index> (tail)" indicates that the data value is at the tail of the save file.
+	 *   - All save data files are saved in .miniplussave (CSV), all comma separated, tailing comma exists.
+	 *   - KeyPrefs.miniplussave here is saved in world save.
+	 *   - All save files here are saved by world instance, i.e. no global preferences.
+	 *   - In Level5 save files, there is an extra tailing comma. (seems like a mistake)
+	 *   - Although in some time periods, max armor is saved instead of armor point, it is still loaded as armor point.
+	 *   - Skin-On is an abandoned feature. It controls whether to render the player skin suits,
+	 *     which has already been removed now.
+	 *
+	 * Commit History
+	 * (1.9.1) 1930f326 Apr 12, 2017 (23:30) # 1.9.1 has been released on the next day (01:53)
+	 * - Game.miniplussave Versioning added
+	 * b8766a33 Apr 11, 2017 (03:34)
+	 * - Player.miniplussave (index: 13,14 (tail)) Armor values inserted (saved only when armor exists)
+	 *   - index: 13 - Armor damage buffer value
+	 *   - index: 14 - Current armor name
+	 * 58c9922f Apr 2, 2017 (02:59)
+	 * - Game.miniplussave (index: 3) Arrow count removed
+	 * - Player.miniplussave (index: 5) Max armor value changed to armor value
+	 * - Player.miniplussave (index: 7) Arrow count inserted
+	 * - Player.miniplussave (index: 10) PotionEffects data save conditions changed
+	 *   - saved only non-empty -> always saved; saved as empty when empty
+	 *     - When empty: "PotionEffects[]"
+	 * e0e2549b Mar 29, 2017 (22:12)
+	 * - Player.miniplussave (index: 11 (tail)) Skin-On (boolean) inserted
+	 *   - Skin-On indicates whether skin should be rendered (preference).
+	 *     - It was a temporary in-game option.
+	 * f95343bf Mar 24, 2017 (04:48)
+	 * - Entities.miniplussave Spawner data (extradata index: 0) mob name changed ...
+	 *   - Value changed from class name (from class) to spawner mob name (hardcoded value property)
+	 *   - Availabilities of mob property for spawner changes; mob names here are only applicable in spawner class;
+	 *     non-mob data is set as zombie; previously, non-mob entities can be set for spawners
+	 *     - Mob names that differ from class names: AirWizardII
+	 *       The above mobs are not loaaded correctly (thus bug fix), loaded as AirWizard (I)
+	 * 01d8e558 Mar 21, 2017 (23:26)
+	 * - Entities.miniplussave Spawner data instance added
+	 *   - Extradata: entity name (extracted from entity class name), mob level
+	 * 13507725 Mar 20, 2017 (10:18)
+	 * - Entities.miniplussave DungeonChest data (extradata index: 1) is-locked: always false -> property saved
+	 *   - Key and dungeon locking feature are reimplemented
+	 *   - No effect to save structure
+	 * d97784ce Mar 19, 2017 (11:48)
+	 * - Player.miniplussave (index: 9) PotionEffects inserted (saved only data is non-empty)
+	 *   - Format: "PotionEffects[<potion data>]"
+	 *     - Potion data is separated by ":", no tail separator is added
+	 *       - Potion data: "<name>;<time>"
+	 * 67d0b872 Mar 11, 2017 (02:28)
+	 * - Game.miniplussave (index: 4,5 (tail)) autosave (boolean) and sound toggle (boolean) inserted
+	 * 1b392bea Mar 8, 2017 (05:47)
+	 * - KeyPrefs.miniplussave added
+	 *   - Each data value represents a key-value pair in format: "<name>;<value>"
+	 *     - One key bind binds to only one physical key.
+	 * 0fbeae59 Feb 26, 2017 (06:22)
+	 * - Save/Load files reformatted, and some features disabled:
+	 *   - Spawner data instance is disabled.
+	 *   - Dungeon locking feature is disabled and forcedly set to "unlocked".
+	 * 473bbe5b Feb 26, 2017 (06:21)
+	 * - Save/Load system added
+	 *
+	 * Initial Save Structure (473bbe5b+0fbeae59)
+	 *   - Game.miniplussave
+	 *     - Data: tick count, autosave time interval, game speed, arrow count
+	 *   - Level<index>.miniplussave (for each level)
+	 *     - Data: size, size, depth, <tile id> (order: x * h + y)
+	 *   - Level<index>data.miniplussave (for each level)
+	 *     - Data: <tile data> (order: x * h + y)
+	 *   - Player.miniplussave
+	 *     - Data: x, y, spawnpoint x, spawnpoint y, health point, max armor value, score, current level index,
+	 *       mode, clothing color
+	 *       - Mode data value: "<mode>[;<score>]", ";<>" is written only in score mode.
+	 *       - Color data value: "[<r>;<g>;<b>]", this seems like to be cloth color
+	 */
+
+	static void loadSave(String worldName) throws Load.LoadingSessionFailedException {
+		String location = Game.gameDir + "/saves/" + worldName + "/";
+		String filePath;
+
+		try {
+			Game.player.getInventory().clearInv(); // Prepare for loading.
+			createBackup(filePath = location + "Game" + Save.extension);
+			loadGame(filePath);
+			// KeyPrefs are now saved in global preferences, but not world-wide.
+			createBackup(filePath = location + "KeyPrefs" + Save.extension);
+			if (new File(filePath).delete()) // World-wide KeyPrefs are ignored.
+				Logging.SAVELOAD.debug("\"{}\" is deleted.", filePath);
+
+			try {
+				for (int i = 0; i < 6; ++i) {
+					String dataPath = location + "Level" + i + "data" + Save.extension;
+					createBackup(filePath = location + "Level" + i + Save.extension);
+					createBackup(dataPath);
+					loadLevel(filePath, dataPath, i);
+				}
+			} catch (Load.MalformedSaveDataException e) {
+				throw new Load.MalformedSaveException("World", e);
+			}
+
+			createBackup(filePath = location + "Player" + Save.extension);
+			loadPlayer(filePath);
+			createBackup(filePath = location + "Inventory" + Save.extension);
+			loadInventory(filePath);
+			// loadEntities is not checked by me, but I assume that it is implemented correctly.
+			createBackup(filePath = location + "Entities" + Save.extension);
+			loadEntities(filePath); // Most parts of the code are not modified.
+		} catch (Load.MalformedSaveException e) {
+			throw new Load.LoadingSessionFailedException("Failed to load world \"" + worldName + "\"", e);
+		} catch (IndexOutOfBoundsException e) {
+			// By design, all checks should be done and this exception should not be thrown anywhere here.
+			// MalformedSaveDataFormatException is expected to be used here in case of this.
+			/* TODO Implement CodeDesignSecurityError
+			 *   Such error would be thrown when there is unexpected behavior happened.
+			 *   The cause should be either a design bug or memory integrity failure.
+			 *   If it is a design bug, it should be reported and fixed as soon as possible.
+			 *   If it is memory integrity failure, it may be because there was a bad runtime injection or
+			 *     memory error.
+			 */
+			throw new AssertionError(e);
+		}
+	}
+
+	private static List<String> loadFile(String path) throws Load.FileLoadingException {
+		try {
+			List<String> data = Arrays.asList(Load.loadFromFile(path, true).split(","));
+			if (!data.get(data.size() - 1).isEmpty())
+				throw new Load.MalformedSaveDataFormatException("The last character is expected to be a comma (\",\")");
+			data.remove(data.size() - 1); // Removes the empty value as the last character is a comma.
+			return data;
+		} catch (IOException | Load.MalformedSaveDataFormatException e) {
+			throw new Load.FileLoadingException("Failed to load \"" + path + "\"", e);
+		}
+	}
+
+	private static void createBackup(String path) {
+		File file = new File(path);
+		File bakFile = new File(path + ".bak");
+		if (bakFile.exists()) {
+			Logging.SAVELOAD.warn("\"{}\" exists, contents will be overwritten by new backup.",
+				bakFile.getPath());
+		}
+
+		try {
+			if (Files.copy(file.toPath(), bakFile.toPath(), StandardCopyOption.REPLACE_EXISTING).toFile().exists()) {
+				Logging.SAVELOAD.trace("Backup \"{}\" is successfully created for \"{}\".",
+					bakFile.getPath(), file.getPath());
+			} else {
+				Logging.SAVELOAD.warn("Backup \"{}\" created for \"{}\" is unexpectedly disappeared",
+					bakFile.getPath(), file.getPath());
+			}
+		} catch (FileAlreadyExistsException e) { // This should not be thrown as REPLACE_EXISTING is set.
+			Logging.SAVELOAD.error(new SecurityException("Unexpected exception", e));
+		} catch (IOException | SecurityException | UnsupportedOperationException e) {
+			Logging.SAVELOAD.error(e, "Failed to create backup of \"{}\"", file.getPath());
+			Logging.SAVELOAD.warn("Backup for \"{}\" is ignored.", path);
+		}
+	}
+
+	private static final Predicate<Integer> POSITIVE_INTEGER_CHECK = v -> v > 0;
+	private static final Predicate<Integer> NON_NEGATIVE_INTEGER_CHECK = v -> v >= 0;
+
+	/** Performs quick validation over an integral data. An exception is thrown when necessary. */
+	private static void validateIntegralData(int data, @Nullable Predicate<Integer> condition)
+		throws Load.IllegalSaveDataValueException {
+		if (!(condition == null ? POSITIVE_INTEGER_CHECK : condition).test(data))
+			throw new Load.IllegalSaveDataValueException("Input: " + data);
+	}
+
+	/** Validates for integral data when it is not loaded but a validation is required. */
+	private static void validateIntegralSaveData(String data, String msg)
+		throws Load.MalformedSaveDataValueException {
+		try {
+			validateIntegralData(Integer.parseInt(data), null);
+		} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+			throw new Load.MalformedSaveDataValueException(msg, e);
+		}
+	}
+
+	/** Validates for boolean data when it is not loaded but a validation is required. */
+	private static void validateBooleanSaveData(String data, String msg)
+		throws Load.MalformedSaveDataValueException {
+		try {
+			Load.parseBoolean(data);
+		} catch (Load.IllegalDataValueException e) {
+			throw new Load.MalformedSaveDataValueException(msg, e);
+		}
+	}
+
+	private static void loadArrowCount(int ac) {
+		Game.player.getInventory().add(Items.get("arrow"), ac);
+	}
+
+	private static void loadGame(String path) throws Load.MalformedSaveException {
+		try {
+			List<String> data = loadFile(path);
+			if (data.size() < 3) // Avoids the needs for IndexOutOfBoundsException catch clauses.
+				throw new Load.MalformedSaveDataFormatException(
+					"Corrupted .miniplussave (data count: " + data.size() + ")");
+
+			try {
+				Updater.setTime(Integer.parseInt(data.get(0)));
+			} catch (NumberFormatException e) {
+				throw new Load.MalformedSaveDataValueException("Index 0 (Game tick count)", e);
+			}
+
+			// Index 1 (Auto-save time interval) -> Updater#astime is now fixed; data validation only.
+			validateIntegralSaveData(data.get(1), "Index 1 (Auto-save time interval)");
+
+			// Index 2 (Game speed) -> Updater#gamespeed is now no longer saved in saves; data validation only.
+			validateIntegralSaveData(data.get(2), "Index 2 (Game speed)");
+
+			if (data.size() == 4) { // before Mar 11, 2017
+				try {
+					int val = Integer.parseInt(data.get(3));
+					validateIntegralData(val, NON_NEGATIVE_INTEGER_CHECK);
+					loadArrowCount(val);
+				} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+					throw new Load.MalformedSaveDataValueException("Primary version, Index 3 (Arrow count)", e);
+				}
+			} else if (data.size() == 6) { // Since Mar 11, 2017 until Apr 2, 2017
+				try {
+					int val = Integer.parseInt(data.get(3));
+					validateIntegralData(val, NON_NEGATIVE_INTEGER_CHECK);
+					loadArrowCount(val);
+				} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+					throw new Load.MalformedSaveDataValueException("Secondary version, Index 3 (Arrow count)", e);
+				}
+
+				try {
+					Settings.set("autosave", Load.parseBoolean(data.get(4)));
+				} catch (IndexOutOfBoundsException | Load.IllegalDataValueException e) {
+					throw new Load.MalformedSaveDataValueException("Secondary version, Index 4 (Auto-save toggle)", e);
+				}
+
+				// Index 5 (Sound toggle) -> Settings->sound is now saved in preferences instead of world-wide,
+				// data validation only.
+				validateBooleanSaveData(data.get(5), "Seconadry version, Index 5 (Sound toggle)");
+			} else if (data.size() == 5) { // Since Apr 2, 2017 until Apr 12, 2017 (1.9.1)
+				try {
+					Settings.set("autosave", Load.parseBoolean(data.get(3)));
+				} catch (IndexOutOfBoundsException | Load.IllegalDataValueException e) {
+					throw new Load.MalformedSaveDataValueException("Tertiary version, Index 3 (Auto-save toggle)", e);
+				}
+
+				// Index 4 (Sound toggle) -> Settings->sound is now saved in preferences instead of world-wide,
+				// data validation only.
+				validateBooleanSaveData(data.get(4), "Tertiary version, Index 4 (Sound toggle)");
+			} else // If data count does not match, it is not able to load as it depends on the count.
+				throw new Load.MalformedSaveDataFormatException(
+					"Corrupted .miniplussave (data count: " + data.size() + ")");
+		} catch (Load.FileLoadingException | Load.MalformedSaveDataFormatException |
+		         Load.MalformedSaveDataValueException e) {
+			throw new Load.MalformedSaveException("Game", new Load.MalformedSaveDataException("Game", e));
+		}
+	}
+
+	private static void loadLevel(String pathA, String pathB, int index) throws Load.MalformedSaveDataException {
+		try {
+			List<String> dataA = loadFile(pathA);
+			List<String> dataB = loadFile(pathB);
+			if (dataA.size() < 3)
+				throw new Load.MalformedSaveDataFormatException(
+					"Corrupted .miniplussave (Level data count: " + dataA.size() + ")");
+
+			int w, h, depth;
+			try {
+				w = Integer.parseInt(dataA.get(0));
+				validateIntegralData(w, null);
+			} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+				throw new Load.MalformedSaveDataValueException("Index 0 (Level width)", e);
+			}
+
+			try {
+				h = Integer.parseInt(dataA.get(1));
+				validateIntegralData(h, null);
+			} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+				throw new Load.MalformedSaveDataValueException("Index 1 (Level height)", e);
+			}
+
+			try {
+				depth = Integer.parseInt(dataA.get(2));
+				validateIntegralData(depth, v -> v >= 0 && v <= 4);
+			} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+				throw new Load.MalformedSaveDataValueException("Index 2 (Level depth)", e);
+			}
+
+			if (w != h) {
+				// Prevents badly formed level
+				Logging.SAVELOAD.error("Non-squared ({}, {}) level size is not supported.", w, h);
+				throw new Load.MalformedSaveDataValueException("Level width (Index 0) & height (Index 1)",
+					new Load.IllegalSaveDataValueException("width: " + w + "; height: " + h));
+			}
+
+			if (dataA.size() < 3 + w * h)
+				throw new Load.MalformedSaveDataFormatException(
+					"Corrupted .miniplussave (Level data count: " + dataA.size() + ")");
+			if (dataB.size() < w * h)
+				throw new Load.MalformedSaveDataFormatException(
+					"Corrupted .miniplussave (Level data data count: " + dataA.size() + ")");
+
+			Settings.set("size", w);
+			short[] tiles = new short[w * h];
+			short[] data = new short[w * h];
+			for (int x = 0; x < w; ++x) {
+				for (int y = 0; y < h; ++y) {
+					int src = x * h + y;
+					int trg = y * w + x;
+					try { // For old saves, these are bytes.
+						int id = Byte.parseByte(dataA.get(src + 3)) & 0xFF;
+						if (id >= Tiles.oldids.size())
+							throw new Load.IllegalSaveDataValueException("Input: " + id);
+						// This should not throw IndexOutOfBoundsException as it is checked above.
+						tiles[trg] = Tiles.get(Tiles.oldids.get(id)).id;
+					} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+						throw new Load.MalformedSaveDataValueException(
+							"Index " + (src + 3) + " (Tile id " + trg + "/" + x + ";" + y + ")", e);
+					}
+					try {
+						data[trg] = (short) (Byte.parseByte(dataB.get(src)) & 0xFF);
+					} catch (NumberFormatException e) {
+						throw new Load.MalformedSaveDataValueException(
+							"Index " + src + " (Tile data " + trg + "/" + x + ";" + y + ")", e);
+					}
+				}
+			}
+
+			World.levels[index] = new Level(w, h, depth, null, false);
+			World.levels[index].tiles = tiles;
+			World.levels[index].data = data;
+		} catch (Load.FileLoadingException | Load.MalformedSaveDataValueException |
+		         Load.MalformedSaveDataFormatException e) {
+			throw new Load.MalformedSaveDataException("Level " + index, e);
+		}
+	}
+
+	private static void loadMode(String data) throws Load.MalformedSaveDataValueException {
+		/*
+		* Survival = 1
+		* Creative = 2
+		* Hardcore = 3
+		* Score = 4
+		* Format: <mode>[;<time>]
+		* [;<time>] is added when mode = 4
+		*/
+
+		int mode;
+		if (data.contains(";")) {
+			String[] split = data.split(";", 2);
+			try {
+				mode = Integer.parseInt(split[0]);
+				validateIntegralData(mode, v -> v >= 1 && v <= 4);
+			} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+				throw new Load.MalformedSaveDataValueException("Mode index: " + split[0], e);
+			}
+
+			int time;
+			try {
+				time = Integer.parseInt(split[1]);
+				validateIntegralData(time, NON_NEGATIVE_INTEGER_CHECK);
+			} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+				throw new Load.MalformedSaveDataValueException("Score time: " + split[1], e);
+			}
+
+			if (mode == 4) Updater.scoreTime = time;
+			else throw new Load.MalformedSaveDataValueException("Mode",
+				new Load.IllegalSaveDataValueException("Score time is illegal in mode \"" + mode + "\""));
+		} else {
+			try {
+				mode = Integer.parseInt(data);
+				validateIntegralData(mode, v -> v >= 1 && v <= 4);
+			} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+				throw new Load.MalformedSaveDataValueException("Mode", e);
+			}
+
+			if (mode == 4) Updater.scoreTime = 300;
+		}
+
+		Settings.setIdx("mode", mode - 1); // Value is shifted in newer versions.
+	}
+
+	private static final Pattern CLOTHING_COLOR_REGEX = Pattern.compile("\\[(\\d+);(\\d+);(\\d+)]");
+
+	private static void loadClothingColor(String data) throws Load.MalformedSaveDataValueException {
+		// Format: [<r>;<g>;<b>]
+		Matcher matcher = CLOTHING_COLOR_REGEX.matcher(data);
+		if (matcher.matches()) {
+			MatchResult matched = matcher.toMatchResult();
+			int r, g, b;
+
+			try {
+				r = Integer.parseInt(matched.group(1));
+				validateIntegralData(r, v -> v >= 0 && v <= 255);
+			} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+				throw new Load.MalformedSaveDataValueException("Clothing color index 0 (Red)", e);
+			}
+
+			try {
+				g = Integer.parseInt(matched.group(2));
+				validateIntegralData(g, v -> v >= 0 && v <= 255);
+			} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+				throw new Load.MalformedSaveDataValueException("Clothing color index 1 (Green)", e);
+			}
+
+			try {
+				b = Integer.parseInt(matched.group(3));
+				validateIntegralData(b, v -> v >= 0 && v <= 255);
+			} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+				throw new Load.MalformedSaveDataValueException("Clothing color index 2 (Blue)", e);
+			}
+
+			// It is assumed that normal RGB is used here.
+			Game.player.shirtColor = Color.get(1, r, g, b);
+		} else
+			throw new Load.MalformedSaveDataValueException("Clothing color: " + data);
+	}
+
+	private static final Pattern POTION_EFFECTS_REGEX = Pattern.compile("PotionEffects\\[([.\\w;:]+)]");
+
+	private static void loadPotionEffects(String data, boolean allowEmpty) throws Load.MalformedSaveDataValueException {
+		if (allowEmpty && data.equals("PotionEffects[]")) return;
+		Matcher matcher = POTION_EFFECTS_REGEX.matcher(data);
+		if (matcher.matches()) {
+			MatchResult result = matcher.toMatchResult();
+			int count = 0;
+			try {
+				for (String pair : result.group(1).split(":")) {
+					String[] split = pair.split(";", 2);
+					try {
+						int time;
+						try {
+							time = Integer.parseInt(split[1]);
+							validateIntegralData(time, NON_NEGATIVE_INTEGER_CHECK);
+						} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+							throw new Load.MalformedSaveDataValueException("Potion effect time", e);
+						}
+
+						switch (split[0]) { // In fact, "P." should not be saved as an effect name.
+							case "Potion": break;// "Potion" takes no effect but saved in some versions.
+							case "Speed": PotionItem.applyPotion(Game.player, PotionType.Speed, time); break;
+							case "Light": PotionItem.applyPotion(Game.player, PotionType.Light, time); break;
+							case "Swim": PotionItem.applyPotion(Game.player, PotionType.Swim, time); break;
+							case "Energy": PotionItem.applyPotion(Game.player, PotionType.Energy, time); break;
+							case "Regen": PotionItem.applyPotion(Game.player, PotionType.Regen, time); break;
+							case "Time": PotionItem.applyPotion(Game.player, PotionType.Time, time); break;
+							case "Lava": PotionItem.applyPotion(Game.player, PotionType.Lava, time); break;
+							case "Shield": PotionItem.applyPotion(Game.player, PotionType.Shield, time); break;
+							case "Haste": PotionItem.applyPotion(Game.player, PotionType.Haste, time); break;
+							default:
+								throw new Load.IllegalSaveDataValueException("Invalid potion type: " + split[0]);
+						}
+					} catch (Load.IllegalSaveDataValueException | Load.MalformedSaveDataValueException e) {
+						throw new Load.MalformedSaveDataValueException("Potion effect (index: " + count + ")", e);
+					}
+
+					count++;
+				}
+			} catch (Load.MalformedSaveDataValueException e) {
+				throw new Load.MalformedSaveDataValueException("Active potion effects", e);
+			}
+		} else
+			throw new Load.MalformedSaveDataValueException("Active potion effects: " + data);
+	}
+
+	private static void loadPlayer(String path) throws Load.MalformedSaveException {
+		try {
+			List<String> data = loadFile(path);
+			if (data.size() <  6)
+				throw new Load.MalformedSaveDataFormatException(
+					"Corrupted .miniplussave (data count: " + data.size() + ")");
+
+			try {
+				Game.player.x = Integer.parseInt(data.get(0));
+				validateIntegralData(Game.player.x, NON_NEGATIVE_INTEGER_CHECK);
+			} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+				throw new Load.MalformedSaveDataValueException("Index 0 (Player position x)", e);
+			}
+
+			try {
+				Game.player.y = Integer.parseInt(data.get(1));
+				validateIntegralData(Game.player.y, NON_NEGATIVE_INTEGER_CHECK);
+			} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+				throw new Load.MalformedSaveDataValueException("Index 1 (Player position y)", e);
+			}
+
+			try {
+				Game.player.spawnx = Integer.parseInt(data.get(2));
+				validateIntegralData(Game.player.spawnx, NON_NEGATIVE_INTEGER_CHECK);
+			} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+				throw new Load.MalformedSaveDataValueException("Index 2 (Player spawnpoint x)", e);
+			}
+
+			try {
+				Game.player.spawny = Integer.parseInt(data.get(3));
+				validateIntegralData(Game.player.spawny, NON_NEGATIVE_INTEGER_CHECK);
+			} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+				throw new Load.MalformedSaveDataValueException("Index 3 (Player spawnpoint y)", e);
+			}
+
+			try {
+				Game.player.health = Integer.parseInt(data.get(4));
+				// It is rejected if it is out of the range; old max health is 10.
+				validateIntegralData(Game.player.health, v -> v >= 0 && v <= 10);
+			} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+				throw new Load.MalformedSaveDataValueException("Index 4 (Player health point)", e);
+			}
+
+			try {
+				Game.player.armor = Integer.parseInt(data.get(5));
+				// It is rejected if it is out of the range.
+				validateIntegralData(Game.player.armor, v -> v >= 0 && v <= 100);
+			} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+				throw new Load.MalformedSaveDataValueException("Index 5 (Player armor point)", e);
+			}
+
+			try {
+				Game.player.setScore(Integer.parseInt(data.get(6)));
+			} catch (NumberFormatException e) {
+				throw new Load.MalformedSaveDataValueException("Index 6 (Player score)", e);
+			}
+
+			/*
+			 * Before Mar 19, 2017 # Primary
+			 *   - Data count 10
+			 *   - PotionEffects not added
+			 * Since Mar 19, 2017 until Mar 29, 2017 # Primary revision 1
+			 *   - Data count 10 when PotionEffects is empty
+			 *   - Data count 11 otherwise
+			 * Since Mar 29, 2017 until Apr 2, 2017
+			 *   - Data count 11 when PotionEffects is empty
+			 *   - Data count 12 otherwise
+			 * Since Apr 2, 2017 until Apr 11, 2017
+			 *   - Data count 13
+			 * Since Apr 11, 2017
+			 *   - Data count 13 when no armor
+			 *   - Data count 15 otherwise
+			 */
+
+			if (data.size() >= 10 && data.size() <= 12) { // Before Apr 2, 2017 # Primary
+				/*
+				 * Data first 9 is the same (indices: 0-8)
+				 * Since Mar 19, 2017 until Mar 29, 2017
+				 *   When PotionEffects is empty (data count 10)
+				 *     Data index 9 Clothing color # Non-revised
+				 *   When PotionEffects is non-empty (data count 11)
+				 *     Data index 9 Active potion effects # Revision 1
+				 *     Data index 10 Clothing color # Revision 1
+				 * Since Mar 29, 2017 until Apr 2, 2017
+				 *   When PotionEffects is empty (data count 11)
+				 *     Data index 9 Clothing color # Non-revised
+				 *     Data index 10 Skin-On # Revision 2 Case 1
+				 *   When PotionEffects is non-empty (data count 12)
+				 *     Data index 9 Active potion effects # Revision 1
+				 *     Data index 10 Clothing color # Revision 1
+				 *     Data index 11 Skin-On # Revision 2 Case 2
+				 *
+				 * Non-revised
+				 *   Data index 9 Clothing color
+				 * Revision 1
+				 *   Data index 9 Active potion effects
+				 *   Data index 10 Clothing color
+				 * Revision 2
+				 *   Data index 10 (Case 1)/11 (Case 2) Skin-On
+				 */
+
+				try {
+					Game.currentLevel = Integer.parseInt(data.get(7));
+					World.levels[Game.currentLevel].add(Game.player);
+				} catch (NumberFormatException e) {
+					throw new Load.MalformedSaveDataValueException(
+						"Primary version, Index 7 (Player active level index)", e);
+				}
+
+				try {
+					loadMode(data.get(8));
+				} catch (Load.MalformedSaveDataValueException e) {
+					throw new Load.MalformedSaveDataValueException("Primary version, Index 8 (Game mode)", e);
+				}
+
+				if (!data.get(9).startsWith("PotionEffects[")) { // PotionEffects is empty
+					// Data count 10-11
+					if (data.size() != 10 && data.size() != 11)
+						throw new Load.MalformedSaveDataFormatException(
+							"Corrupted .miniplussave (data count: " + data.size() + ")");
+
+					try {
+						loadClothingColor(data.get(9));
+					} catch (Load.MalformedSaveDataValueException e) {
+						throw new Load.MalformedSaveDataValueException(
+							"Primary version Non-revised, Index 9 (Clothing color)", e);
+					}
+
+					if (data.size() == 11) {
+						// Index 10 (Skin-On) -> Suits has been removed; this is also removed; data validation only.
+						validateBooleanSaveData(data.get(10),
+							"Primary version Revision 2 Case 1, Index 10 (Skin-On)");
+					}
+				} else { // PotionEffects is non-empty
+					// Data count 11-12
+					if (data.size() != 11 && data.size() != 12)
+						throw new Load.MalformedSaveDataFormatException(
+							"Corrupted .miniplussave (data count: " + data.size() + ")");
+
+					try {
+						loadPotionEffects(data.get(9), false);
+					} catch (Load.MalformedSaveDataValueException e) {
+						throw new Load.MalformedSaveDataValueException(
+							"Primary version Revision 1, Index 9 (Active potion effects)", e);
+					}
+
+					try {
+						loadClothingColor(data.get(10));
+					} catch (Load.MalformedSaveDataValueException e) {
+						throw new Load.MalformedSaveDataValueException(
+							"Primary version Revision 1, Index 10 (Clothing color)", e);
+					}
+
+					if (data.size() == 12) {
+						// Index 11 (Skin-On) -> Suits has been removed; this is also removed; data validation only.
+						validateBooleanSaveData(data.get(11),
+							"Primary version Revision 2 Case 2, Index 11 (Skin-On)");
+					}
+				}
+			} else if (data.size() == 13 || data.size() == 15) { // Since Apr 2, 2017 # Seconary
+				try {
+					int val = Integer.parseInt(data.get(7));
+					validateIntegralData(val, NON_NEGATIVE_INTEGER_CHECK);
+					loadArrowCount(val);
+				} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+					throw new Load.MalformedSaveDataValueException("Secondary version, Index 7 (Arrow count)", e);
+				}
+
+				try {
+					Game.currentLevel = Integer.parseInt(data.get(8));
+					World.levels[Game.currentLevel].add(Game.player);
+				} catch (NumberFormatException e) {
+					throw new Load.MalformedSaveDataValueException(
+						"Secondary version, Index 8 (Player active level index)", e);
+				}
+
+				try {
+					loadMode(data.get(9));
+				} catch (Load.MalformedSaveDataValueException e) {
+					throw new Load.MalformedSaveDataValueException("Secondary version, Index 9 (Game mode)", e);
+				}
+
+				try {
+					loadPotionEffects(data.get(10), true);
+				} catch (Load.MalformedSaveDataValueException e) {
+					throw new Load.MalformedSaveDataValueException(
+						"Secondary version, Index 10 (Active potion effects)", e);
+				}
+
+				try {
+					loadClothingColor(data.get(11));
+				} catch (Load.MalformedSaveDataValueException e) {
+					throw new Load.MalformedSaveDataValueException(
+						"Secondary version, Index 11 (Clothing color)", e);
+				}
+
+				// Index 11 (Skin-On) -> Suits has been removed; this is also removed; data validation only.
+				validateBooleanSaveData(data.get(12),
+					"Secondary version, Index 12 (Skin-On)");
+
+				if (data.size() == 15) {
+					try {
+						int val = Integer.parseInt(data.get(13));
+						validateIntegralData(val, NON_NEGATIVE_INTEGER_CHECK);
+						Game.player.armorDamageBuffer = val;
+					} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+						throw new Load.MalformedSaveDataValueException(
+							"Secondary version revised, Index 13 (Player armor damage buffer)", e);
+					}
+
+					try {
+						String val = data.get(14);
+						Item item = Items.get(val);
+						if (item instanceof ArmorItem)
+							Game.player.curArmor = (ArmorItem) item;
+						else
+							throw new Load.IllegalSaveDataValueException("Input: " + val);
+					} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+						throw new Load.MalformedSaveDataValueException(
+							"Secondary version revised, Index 14 (Player active armor)", e);
+					}
+				} else {
+					Game.player.armor = 0;
+				}
+			}
+		} catch (Load.FileLoadingException | Load.MalformedSaveDataValueException |
+		         Load.MalformedSaveDataFormatException e) {
+			throw new Load.MalformedSaveException("Player", e);
+		}
+	}
+
+	private static final Pattern ITEM_REGEX = Pattern.compile("([\\w ]+)(?:;(\\d+))?");
+
+	private static void loadInventory(String path) throws Load.MalformedSaveException {
+		DeathChest deathChest = new DeathChest();
+		try {
+			List<String> data = loadFile(path);
+			Inventory inv = Game.player.getInventory();
+
+			try {
+				for (int i = 0; i < data.size(); i++) {
+					try {
+						loadToInventory(data.get(i), inv, deathChest);
+					} catch (Load.MalformedSaveDataValueException | Load.IllegalSaveDataValueException e) {
+						throw new Load.MalformedSaveDataValueException("Index " + i, e);
+					}
+				}
+			} catch (Load.MalformedSaveDataValueException e) {
+				throw new Load.MalformedSaveDataException("Invalid item entry", e);
+			}
+		} catch (Load.FileLoadingException | Load.MalformedSaveDataException e) {
+			throw new Load.MalformedSaveException("Inventory", e);
+		}
+
+		if (deathChest.getInventory().invSize() > 0) {
+			Game.player.getLevel().add(deathChest, Game.player.x, Game.player.y);
+			Logging.SAVELOAD.info("Added DeathChest which contains exceed items.");
+		}
+	}
+
+	private static void loadToInventory(String data, Inventory inv, @Nullable DeathChest deathChest)
+		throws Load.IllegalSaveDataValueException, Load.MalformedSaveDataValueException {
+		Matcher matcher = ITEM_REGEX.matcher(data);
+		if (matcher.matches()) {
+			String itemName = matcher.group(1);
+			Item item = Items.get(Load.subOldName(itemName
+				.replace("P.", "Potion")
+				.replace("Fish Rod", "Fishing Rod")
+				.replace("bed", "Bed"), new Version("0.0.0")));
+			if (item instanceof UnknownItem)
+				throw new Load.MalformedSaveDataValueException("Item name",
+					new Load.IllegalSaveDataValueException("Input: " + data));
+			int count = 1;
+			String countStr = matcher.group(2);
+			if (countStr != null) { // When ";<amount>" exists.
+				try {
+					count = Integer.parseInt(countStr);
+					if (count == 0) count = 1; // I am not sure about this.
+					validateIntegralData(count, POSITIVE_INTEGER_CHECK);
+				} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+					throw new Load.MalformedSaveDataValueException(
+						"Item count", e);
+				}
+			}
+
+			item = item.copy();
+			if (item instanceof StackableItem) {
+				((StackableItem) item).count = count;
+				int added = inv.add(item);
+				if (deathChest != null && added < count) {
+					deathChest.getInventory().add(item);
+				}
+			} else {
+				int added = inv.add(item, count);
+				if (deathChest != null && added < count) {
+					deathChest.getInventory().add(item, count - added);
+				}
+			}
+		} else {
+			throw new Load.IllegalSaveDataValueException("Input: " + data);
+		}
+	}
+
+	private static void loadEntities(String path) throws Load.MalformedSaveException {
+		try {
+			List<String> data = loadFile(path);
+			// Simply just copy
+			for (int i = 0; i < data.size(); i++) {
+				try {
+					List<String> info = Arrays.asList(data.get(i).substring(data.get(i).indexOf("[") + 1, data.get(i).indexOf("]")).split(":")); // This gets everything inside the "[...]" after the entity name.
+
+					String entityName = data.get(i).substring(0, data.get(i).indexOf("[")).replace("bed", "Bed").replace("II", ""); // This gets the text before "[", which is the entity name.
+					int x = Integer.parseInt(info.get(0));
+					int y = Integer.parseInt(info.get(1));
+
+					int mobLvl = 0;
+					try {
+						if (Class.forName("EnemyMob").isAssignableFrom(Class.forName(entityName)))
+							mobLvl = Integer.parseInt(info.get(info.size() - 2));
+					} catch (ClassNotFoundException ignored) { }
+
+					Entity newEntity = getEntity(entityName, Game.player, mobLvl);
+
+					if (newEntity != null && newEntity != Game.player) { // the method never returns null, but...
+						int currentlevel;
+						if (newEntity instanceof Mob) {
+							Mob mob = (Mob) newEntity;
+							mob.health = Integer.parseInt(info.get(2));
+							currentlevel = Integer.parseInt(info.get(info.size() - 1));
+							World.levels[currentlevel].add(mob, x, y);
+						} else if (newEntity instanceof Chest) {
+							Chest chest = (Chest) newEntity;
+							boolean isDeathChest = chest instanceof DeathChest;
+							boolean isDungeonChest = chest instanceof DungeonChest;
+							List<String> chestInfo = info.subList(2, info.size() - 1);
+
+							int endIdx = chestInfo.size() - (isDeathChest || isDungeonChest ? 1 : 0);
+							for (int idx = 0; idx < endIdx; idx++) {
+								String itemData = chestInfo.get(idx);
+								if (itemData.isEmpty()) continue; // this skips any null items
+								try {
+									loadToInventory(itemData, chest.getInventory(), null);
+								} catch (Load.IllegalSaveDataValueException | Load.MalformedSaveDataValueException e) {
+									throw new Load.IllegalSaveDataValueException("Data Index " + idx, e);
+								}
+							}
+
+							if (isDeathChest) {
+								((DeathChest) chest).time = Integer.parseInt(chestInfo.get(chestInfo.size() - 1).replace("tl;", "")); // "tl;" is only for old save support
+							} else if (isDungeonChest) {
+								((DungeonChest) chest).setLocked(Boolean.parseBoolean(chestInfo.get(chestInfo.size() - 1)));
+							}
+
+							currentlevel = Integer.parseInt(info.get(info.size() - 1));
+							World.levels[currentlevel].add(chest instanceof DeathChest ? chest : chest instanceof DungeonChest ? (DungeonChest) chest : chest, x, y);
+						} else if (newEntity instanceof Spawner) {
+							MobAi mob = (MobAi) getEntity(info.get(2), Game.player, Integer.parseInt(info.get(3)));
+							currentlevel = Integer.parseInt(info.get(info.size() - 1));
+							if (mob != null)
+								World.levels[currentlevel].add(new Spawner(mob), x, y);
+						} else {
+							currentlevel = Integer.parseInt(info.get(2));
+							World.levels[currentlevel].add(newEntity, x, y);
+						}
+					} // End of entity not null conditional
+				} catch (Load.IllegalSaveDataValueException e) {
+					throw new Load.MalformedSaveDataException("Invalid entity entry",
+						new Load.MalformedSaveDataValueException("Index " + i, e));
+				}
+			}
+		} catch (Load.FileLoadingException | Load.MalformedSaveDataException e) {
+			throw new Load.MalformedSaveException("Entities", e);
+		}
+	}
+
+	private static Entity getEntity(String string, Player player, int mobLevel) {
+		switch (string) {
+			case "Player":
+				return player;
+			case "Cow":
+				return new Cow();
+			case "Sheep":
+				return new Sheep();
+			case "Pig":
+				return new Pig();
+			case "Zombie":
+				return new Zombie(mobLevel);
+			case "Slime":
+				return new Slime(mobLevel);
+			case "Creeper":
+				return new Creeper(mobLevel);
+			case "Skeleton":
+				return new Skeleton(mobLevel);
+			case "Knight":
+				return new Knight(mobLevel);
+			case "Snake":
+				return new Snake(mobLevel);
+			case "AirWizard":
+				if (mobLevel > 1) return null;
+				return new AirWizard();
+			case "Spawner":
+				return new Spawner(new Zombie(1));
+			case "Workbench":
+				return new Crafter(Crafter.Type.Workbench);
+			case "Chest":
+				return new Chest();
+			case "DeathChest":
+				return new DeathChest();
+			case "DungeonChest":
+				return new DungeonChest(false);
+			case "Anvil":
+				return new Crafter(Crafter.Type.Anvil);
+			case "Enchanter":
+				return new Crafter(Crafter.Type.Enchanter);
+			case "Loom":
+				return new Crafter(Crafter.Type.Loom);
+			case "Furnace":
+				return new Crafter(Crafter.Type.Furnace);
+			case "Oven":
+				return new Crafter(Crafter.Type.Oven);
+			case "Bed":
+				return new Bed();
+			case "Tnt":
+				return new Tnt();
+			case "Lantern":
+				return new Lantern(Lantern.Type.NORM);
+			case "IronLantern":
+				return new Lantern(Lantern.Type.IRON);
+			case "GoldLantern":
+				return new Lantern(Lantern.Type.GOLD);
+			default:
+				Logger.tag("SaveLoad/LegacyLoad").warn("Unknown or outdated entity requested: " + string);
+				return null;
+		}
+	}
+}
diff --git a/src/client/java/minicraft/saveload/LegacyLoad.java b/src/client/java/minicraft/saveload/LegacyLoad.java
index b902c3775..2a6d54596 100644
--- a/src/client/java/minicraft/saveload/LegacyLoad.java
+++ b/src/client/java/minicraft/saveload/LegacyLoad.java
@@ -37,6 +37,7 @@
 import minicraft.level.tile.Tiles;
 import minicraft.screen.LoadingDisplay;
 import minicraft.util.Logging;
+import org.jetbrains.annotations.Nullable;
 import org.tinylog.Logger;
 
 import java.io.BufferedReader;
@@ -58,17 +59,10 @@ public class LegacyLoad {
 	ArrayList<String> extradata;
 
 	public boolean hasloadedbigworldalready;
-	Version currentVer, worldVer;
-	boolean oldSave = false;
-
-	Game game = null;
-
+	@Nullable Version worldVer = null;
 	private DeathChest deathChest;
 
 	{
-		currentVer = Game.VERSION;
-		worldVer = null;
-
 		data = new ArrayList<>();
 		extradata = new ArrayList<>();
 		hasloadedbigworldalready = false;
@@ -77,13 +71,6 @@ public class LegacyLoad {
 	public LegacyLoad(String worldname) {
 		location += "/saves/" + worldname + "/";
 
-		File testFile = new File(location + "KeyPrefs" + extension);
-		if (!testFile.exists()) {
-			worldVer = new Version("1.8");
-			oldSave = true;
-		} else
-			testFile.delete(); // We don't care about it anymore anyway.
-
 		// This is used in loadInventory().
 
 		loadGame("Game"); // More of the version will be determined here
@@ -181,37 +168,18 @@ protected void updateUnlocks(File file) {
 
 	public void loadGame(String filename) {
 		loadFromFile(location + filename + extension);
-		boolean hasVersion = data.get(0).contains(".");
-		if (hasVersion) {
-			worldVer = new Version(data.get(0)); // Gets the world version
-			Updater.setTime(Integer.parseInt(data.get(1)));
-			Updater.gameTime = 65000; // Prevents time cheating.
-
-			if (worldVer.compareTo(new Version("1.9.2")) < 0) {
-				Settings.set("autosave", Boolean.parseBoolean(data.get(3)));
-				Settings.set("sound", Boolean.parseBoolean(data.get(4)));
-				if (worldVer.compareTo(new Version("1.9.2-dev2")) >= 0)
-					AirWizard.beaten = Boolean.parseBoolean(data.get(5));
-			} else { // This is 1.9.2 official or after
-				Settings.setIdx("diff", Integer.parseInt(data.get(3)));
-				AirWizard.beaten = Boolean.parseBoolean(data.get(4));
-			}
-		} else {
-			if (data.size() == 5) {
-				worldVer = new Version("1.9");
-				Updater.setTime(Integer.parseInt(data.get(0)));
-				Settings.set("autosave", Boolean.parseBoolean(data.get(3)));
-				Settings.set("sound", Boolean.parseBoolean(data.get(4)));
-			} else { // version == 1.8?
-				if (!oldSave) {
-					Logging.SAVELOAD.warn("UNEXPECTED WORLD VERSION");
-					worldVer = new Version("1.8.1");
-				}
-				// For backwards compatibility
-				Updater.tickCount = Integer.parseInt(data.get(0));
-				playerac = Integer.parseInt(data.get(3));
-				Settings.set("autosave", false);
-			}
+		worldVer = new Version(data.get(0)); // Gets the world version
+		Updater.setTime(Integer.parseInt(data.get(1)));
+		Updater.gameTime = 65000; // Prevents time cheating.
+
+		if (worldVer.compareTo(new Version("1.9.2")) < 0) {
+			Settings.set("autosave", Boolean.parseBoolean(data.get(3)));
+			Settings.set("sound", Boolean.parseBoolean(data.get(4)));
+			if (worldVer.compareTo(new Version("1.9.2-dev2")) >= 0)
+				AirWizard.beaten = Boolean.parseBoolean(data.get(5));
+		} else { // This is 1.9.2 official or after
+			Settings.setIdx("diff", Integer.parseInt(data.get(3)));
+			AirWizard.beaten = Boolean.parseBoolean(data.get(4));
 		}
 	}
 
@@ -252,21 +220,14 @@ public void loadPlayer(String filename, Player player) {
 		player.armor = Integer.parseInt(data.get(5));
 
 		String modedata;
-		if (!oldSave) {
-			if (data.size() >= 14) {
-				if (worldVer == null) worldVer = new Version("1.9.1-pre1");
-				player.armorDamageBuffer = Integer.parseInt(data.get(13));
-				player.curArmor = (ArmorItem) Items.get(data.get(14));
-			} else player.armor = 0;
+		if (data.size() >= 14) {
+			if (worldVer == null) worldVer = new Version("1.9.1-pre1");
+			player.armorDamageBuffer = Integer.parseInt(data.get(13));
+			player.curArmor = (ArmorItem) Items.get(data.get(14));
+		} else player.armor = 0;
 
-			Game.currentLevel = Integer.parseInt(data.get(8));
-			modedata = data.get(9);
-
-		} else {
-			// Old, 1.8 save.
-			Game.currentLevel = Integer.parseInt(data.get(7));
-			modedata = data.get(8);
-		}
+		Game.currentLevel = Integer.parseInt(data.get(8));
+		modedata = data.get(9);
 
 		player.setScore(Integer.parseInt(data.get(6)));
 		World.levels[Game.currentLevel].add(player);
@@ -284,25 +245,18 @@ public void loadPlayer(String filename, Player player) {
 		Settings.setIdx("mode", mode);
 
 		boolean hasEffects;
-		int potionIdx = 10;
-		if (oldSave) {
-			hasEffects = data.size() > 10 && data.get(data.size() - 2).contains("PotionEffects[");
-			potionIdx = data.size() - 2;
-		} else
-			hasEffects = !data.get(10).equals("PotionEffects[]"); // Newer save
+		hasEffects = !data.get(10).equals("PotionEffects[]"); // Newer save
 
 		if (hasEffects) {
-			String[] effects = data.get(potionIdx).replace("PotionEffects[", "").replace("]", "").split(":");
-
-			for (int i = 0; i < effects.length; i++) {
-				String[] effect = effects[i].split(";");
+			String[] effects = data.get(10).replace("PotionEffects[", "").replace("]", "").split(":");
+			for (String s : effects) {
+				String[] effect = s.split(";");
 				String pName = effect[0];
-				if (oldSave) pName = pName.replace("P.", "Potion");
 				PotionItem.applyPotion(player, Enum.valueOf(PotionType.class, pName), Integer.parseInt(effect[1]));
 			}
 		}
 
-		String colors = data.get(oldSave ? data.size() - 1 : 11).replace("[", "").replace("]", "");
+		String colors = data.get(11).replace("[", "").replace("]", "");
 		String[] color = colors.split(";");
 		player.shirtColor = Integer.parseInt(color[0] + color[1] + color[2]);
 	}
@@ -312,9 +266,7 @@ public void loadInventory(String filename, Inventory inventory) {
 		loadFromFile(location + filename + extension);
 		inventory.clearInv();
 
-		for (int i = 0; i < data.size(); i++) {
-			String item = data.get(i);
-			if (i == 0 && oldSave && item.contains(";")) item = item.replace(";0", ";1");
+		for (String item : data) {
 			loadItemToInventory(item, inventory);
 		}
 
@@ -329,7 +281,6 @@ public void loadItemToInventory(String item, Inventory inventory) {
 		if (item.contains(";")) {
 			String[] curData = item.split(";");
 			String itemName = curData[0];
-			if (oldSave) itemName = subOldName(itemName);
 
 			//System.out.println("Item to fetch: " + itemName + "; count=" + curData[1]);
 			Item newItem = Items.get(itemName);
@@ -337,7 +288,6 @@ public void loadItemToInventory(String item, Inventory inventory) {
 			for (int i = 0; i < count; i++)
 				loadItem(inventory, newItem);
 		} else {
-			if (oldSave) item = subOldName(item);
 			Item toAdd = Items.get(item);
 			loadItem(inventory, toAdd);
 		}
@@ -353,14 +303,6 @@ private void loadItem(Inventory inventory, Item item) {
 		}
 	}
 
-	private String subOldName(String oldName) {
-		//System.out.println("Old name: " + oldName);
-		String newName = oldName.replace("P.", "Potion").replace("Fish Rod", "Fishing Rod").replace("bed", "Bed");
-		newName = Load.subOldName(newName, worldVer);
-		//System.out.println("New name: " + newName);
-		return newName;
-	}
-
 	public void loadEntities(String filename, Player player) {
 		loadFromFile(location + filename + extension);
 
diff --git a/src/client/java/minicraft/saveload/Load.java b/src/client/java/minicraft/saveload/Load.java
index c0f24ce99..0e11a4904 100644
--- a/src/client/java/minicraft/saveload/Load.java
+++ b/src/client/java/minicraft/saveload/Load.java
@@ -96,25 +96,38 @@ public class Load {
 	private ArrayList<String> data;
 	private ArrayList<String> extradata; // These two are changed when loading a new file. (see loadFromFile())
 
-	private Version worldVer;
+	private @Nullable Version worldVer = null;
 
 	private DeathChest deathChest;
 
 	{
-		worldVer = null;
-
 		data = new ArrayList<>();
 		extradata = new ArrayList<>();
 	}
 
-	public Load(String worldname) {
+	public Load(String worldname)
+		throws BackupCreationFailedException, WorldLoadingFailedException, DungeonRegenerationCancelledException {
 		this(worldname, true);
 	}
 
-	public Load(String worldname, boolean loadGame) {
+	public static class WorldLoadingInterruptedException extends Exception {
+		public WorldLoadingInterruptedException() {}
+		public WorldLoadingInterruptedException(Exception cause) {
+			super(cause);
+		}
+	}
+	public static class DungeonRegenerationCancelledException extends WorldLoadingInterruptedException {}
+	public static class BackupCreationFailedException extends WorldLoadingInterruptedException {}
+	public static class WorldLoadingFailedException extends WorldLoadingInterruptedException {
+		public WorldLoadingFailedException(Exception cause) {
+			super(cause);
+		}
+	}
+
+	public Load(String worldname, boolean loadGame)
+		throws DungeonRegenerationCancelledException, WorldLoadingFailedException, BackupCreationFailedException {
 		loadFromFile(location + "/saves/" + worldname + "/Game" + extension);
 		if (data.get(0).contains(".")) worldVer = new Version(data.get(0));
-		if (worldVer == null) worldVer = new Version("1.8");
 
 		//if (!hasGlobalPrefs)
 		//	hasGlobalPrefs = worldVer.compareTo(new Version("1.9.2")) >= 0;
@@ -122,7 +135,7 @@ public Load(String worldname, boolean loadGame) {
 		if (!loadGame) return;
 
 		// Is dev build
-		if (Game.VERSION.getDev() != 0 && worldVer.compareTo(Game.VERSION) < 0) {
+		if (Game.VERSION.getDev() != 0 && worldVer != null && worldVer.compareTo(Game.VERSION) < 0) {
 			Logging.SAVELOAD.info("Old world detected, backup prompting...");
 			ArrayList<ListEntry> entries = new ArrayList<>();
 			entries.addAll(Arrays.asList(StringEntry.useLines(Color.WHITE, false,
@@ -179,7 +192,7 @@ public Load(String worldname, boolean loadGame) {
 									f.toPath(), FileHandler.SKIP, false);
 							} catch (IOException e) {
 								Logging.SAVELOAD.error(e, "Error occurs while performing world backup, loading aborted");
-								throw new RuntimeException(new InterruptedException("World loading interrupted."));
+								throw new BackupCreationFailedException();
 							}
 
 							Logging.SAVELOAD.info("World backup \"{}\" is created.", filename);
@@ -189,7 +202,7 @@ public Load(String worldname, boolean loadGame) {
 						Logging.SAVELOAD.debug("World loading continues...");
 					} else {
 						Logging.SAVELOAD.info("User cancelled world loading, loading aborted.");
-						throw new RuntimeException(new InterruptedException("World loading interrupted."));
+						throw new DungeonRegenerationCancelledException();
 					}
 
 					break;
@@ -202,9 +215,15 @@ public Load(String worldname, boolean loadGame) {
 			}
 		}
 
-		if (worldVer.compareTo(new Version("1.9.2")) < 0)
+		if (worldVer == null) {
+			try {
+				HistoricLoad.loadSave(worldname);
+			} catch (LoadingSessionFailedException e) {
+				throw new WorldLoadingFailedException(e);
+			}
+		} else if (worldVer.compareTo(new Version("1.9.2")) < 0) {
 			new LegacyLoad(worldname);
-		else {
+		} else {
 			location += "/saves/" + worldname + "/";
 
 			percentInc = 5 + World.levels.length - 1; // For the methods below, and world.
@@ -227,14 +246,14 @@ public Load(String worldname, boolean loadGame) {
 				Logging.SAVELOAD.trace("Old version dungeon detected.");
 				ArrayList<ListEntry> entries = new ArrayList<>();
 				entries.addAll(Arrays.asList(StringEntry.useLines(Color.RED,
-					Localization.getLocalized("minicraft.displays.loading.regeneration_popup.display.0"),
-					Localization.getLocalized("minicraft.displays.loading.regeneration_popup.display.1"),
-					Localization.getLocalized("minicraft.displays.loading.regeneration_popup.display.2")
+						Localization.getLocalized("minicraft.displays.loading.regeneration_popup.display.0"),
+						Localization.getLocalized("minicraft.displays.loading.regeneration_popup.display.1"),
+						Localization.getLocalized("minicraft.displays.loading.regeneration_popup.display.2")
 				)));
 
 				entries.addAll(Arrays.asList(StringEntry.useLines(Color.WHITE, "",
-					Localization.getLocalized("minicraft.displays.loading.regeneration_popup.display.3", Game.input.getMapping("select")),
-					Localization.getLocalized("minicraft.displays.loading.regeneration_popup.display.4", Game.input.getMapping("exit"))
+						Localization.getLocalized("minicraft.displays.loading.regeneration_popup.display.3", Game.input.getMapping("select")),
+						Localization.getLocalized("minicraft.displays.loading.regeneration_popup.display.4", Game.input.getMapping("exit"))
 				)));
 
 				AtomicBoolean acted = new AtomicBoolean(false);
@@ -276,7 +295,7 @@ public Load(String worldname, boolean loadGame) {
 					try {
 						//noinspection BusyWait
 						Thread.sleep(10);
-					} catch (InterruptedException ignored) {}
+					} catch (InterruptedException ignored) { }
 				}
 			}
 		}
@@ -286,7 +305,7 @@ public Load() {
 		this(Game.VERSION);
 	}
 
-	public Load(Version worldVersion) {
+	public Load(@Nullable Version worldVersion) {
 		this(false);
 		worldVer = worldVersion;
 	}
@@ -448,13 +467,13 @@ private static ArrayList<String> splitUnwrappedCommas(String input) {
 		return out;
 	}
 
-	public static String loadFromFile(String filename, boolean isWorldSave) throws IOException {
+	public static String loadFromFile(String filename, boolean oneLine) throws IOException {
 		StringBuilder total = new StringBuilder();
 
 		try (BufferedReader br = new BufferedReader(new FileReader(filename))) {
 			String curLine;
 			while ((curLine = br.readLine()) != null)
-				total.append(curLine).append(isWorldSave ? "" : "\n");
+				total.append(curLine).append(oneLine ? "" : "\n");
 		}
 
 		return total.toString();
@@ -505,6 +524,7 @@ private void loadGame(String filename) {
 	}
 
 	private void loadMode(String modedata) {
+		assert worldVer != null;
 		int mode;
 		if (modedata.contains(";")) {
 			String[] modeinfo = modedata.split(";");
@@ -687,6 +707,7 @@ private void loadUnlocks(String filename) {
 	}
 
 	private void loadWorld(String filename) {
+		assert worldVer != null;
 		for (int l = World.maxLevelDepth; l >= World.minLevelDepth; l--) {
 			LoadingDisplay.setMessage(Level.getDepthString(l));
 			int lvlidx = World.lvlIdx(l);
@@ -825,6 +846,7 @@ public void loadPlayer(String filename, Player player) {
 	}
 
 	public void loadPlayer(Player player, List<String> origData) {
+		assert worldVer != null;
 		List<String> data = new ArrayList<>(origData);
 		player.x = Integer.parseInt(data.remove(0));
 		player.y = Integer.parseInt(data.remove(0));
@@ -969,6 +991,7 @@ public void loadInventory(String filename, Inventory inventory) {
 	}
 
 	public void loadInventory(Inventory inventory, List<String> data) {
+		assert worldVer != null;
 		inventory.clearInv();
 
 		for (String item : data) {
@@ -1286,4 +1309,91 @@ private static Entity getEntity(String string, int mobLevel) {
 				return null;
 		}
 	}
+
+	/**
+	 * Parses a string into a boolean, throws exception if the string is not a boolean.
+	 * @throws IllegalDataValueException if the string does not contain a parseable boolean.
+	 */
+	static boolean parseBoolean(String s) throws IllegalDataValueException {
+		if (s.equalsIgnoreCase("true")) return true;
+		else if (s.equalsIgnoreCase("false")) return false;
+		else throw new IllegalDataValueException("s is not a boolean value");
+	}
+
+	static class FileLoadingException extends IOException {
+		FileLoadingException(String message, Exception cause) {
+			super(message, cause);
+		}
+	}
+	static class LoadingSessionFailedException extends Exception {
+		LoadingSessionFailedException(String message) {
+			super(message);
+		}
+		LoadingSessionFailedException(String message, Exception cause) {
+			super(message, cause);
+		}
+	}
+	/** Denotes the whole save. */
+	static class MalformedSaveException extends Exception {
+		MalformedSaveException(String message) {
+			super(message);
+		}
+		MalformedSaveException(String message, Exception cause) {
+			super(message, cause);
+		}
+	}
+	/** Denotes the save file data. */
+	static class MalformedSaveDataException extends Exception {
+		MalformedSaveDataException(String message) {
+			super(message);
+		}
+		MalformedSaveDataException(String message, Exception cause) {
+			super(message, cause);
+		}
+	}
+	/** Denotes the save file data "format" (not only a value), or the file format. */
+	static class MalformedSaveDataFormatException extends Exception {
+		MalformedSaveDataFormatException(String message) {
+			super(message);
+		}
+		MalformedSaveDataFormatException(String message, Exception cause) {
+			super(message, cause);
+		}
+	}
+	/** Denotes the save data "value". */
+	static class MalformedSaveDataValueException extends Exception {
+		MalformedSaveDataValueException(String message) {
+			super(message);
+		}
+		MalformedSaveDataValueException(String message, Exception cause) {
+			super(message, cause);
+		}
+	}
+	/** Denotes a data value but not specifically a specific save data value. */
+	static class MalformedDataValueException extends Exception {
+		MalformedDataValueException(String message) {
+			super(message);
+		}
+		MalformedDataValueException(String message, Exception cause) {
+			super(message, cause);
+		}
+	}
+	/** Denotes a well-formatted save data value, but the value is illegal. */
+	static class IllegalSaveDataValueException extends Exception {
+		IllegalSaveDataValueException(String message) {
+			super(message);
+		}
+		IllegalSaveDataValueException(String message, Exception cause) {
+			super(message, cause);
+		}
+	}
+	/** Denotes a well-formatted data value, but the value is illegal, and not specifically a specific save data value.*/
+	static class IllegalDataValueException extends Exception {
+		IllegalDataValueException(String message) {
+			super(message);
+		}
+		IllegalDataValueException(String message, Exception cause) {
+			super(message, cause);
+		}
+	}
 }
diff --git a/src/client/java/minicraft/screen/LoadingDisplay.java b/src/client/java/minicraft/screen/LoadingDisplay.java
index 6315ace84..ded163899 100644
--- a/src/client/java/minicraft/screen/LoadingDisplay.java
+++ b/src/client/java/minicraft/screen/LoadingDisplay.java
@@ -10,6 +10,7 @@
 import minicraft.gfx.Font;
 import minicraft.gfx.FontStyle;
 import minicraft.gfx.Screen;
+import minicraft.saveload.Load;
 import minicraft.saveload.Save;
 
 import javax.swing.Timer;
@@ -30,14 +31,12 @@ public LoadingDisplay() {
 			try {
 				World.initWorld();
 				Game.setDisplay(null);
-			} catch (RuntimeException ex) {
-				Throwable t = ex.getCause();
-				if (t instanceof InterruptedException) {
-					World.onWorldExits();
-					Game.exitDisplay(); // Exits the loading display and returns to world select display.
-					Game.setDisplay(new PopupDisplay(null, "minicraft.displays.loading.regeneration_cancellation_popup.display"));
-				} else
-					throw ex;
+			} catch (Load.DungeonRegenerationCancelledException | Load.BackupCreationFailedException |
+			         Load.WorldLoadingFailedException ex) {
+				World.onWorldExits();
+				Game.exitDisplay(); // Exits the loading display and returns to world select display.
+				Game.setDisplay(new PopupDisplay(null,
+					"minicraft.displays.loading.regeneration_cancellation_popup.display"));
 			}
 		}, "World Initialization Thread").start());
 		t.setRepeats(false);
diff --git a/src/client/java/minicraft/screen/WorldSelectDisplay.java b/src/client/java/minicraft/screen/WorldSelectDisplay.java
index 320ef1320..19e7c5b2c 100644
--- a/src/client/java/minicraft/screen/WorldSelectDisplay.java
+++ b/src/client/java/minicraft/screen/WorldSelectDisplay.java
@@ -281,7 +281,11 @@ public static void updateWorlds() {
 				if (files != null && files.length > 0 && Arrays.stream(files).anyMatch(f -> f.endsWith(Save.extension))) {
 					String name = file.getName();
 					worldNames.add(name);
-					worldVersions.add(new Load(name, false).getWorldVersion());
+					try {
+						worldVersions.add(new Load(name, false).getWorldVersion());
+					} catch (Load.DungeonRegenerationCancelledException | Load.BackupCreationFailedException |
+					         Load.WorldLoadingFailedException ignored) {} // This is supposed to be not happening.
+					// Ideally, this way should not be used.
 				}
 			}
 		}

From 06f14cf1ecd9b0adbfd3d821f180fb3550c1a0c4 Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Fri, 2 Feb 2024 04:04:10 +0800
Subject: [PATCH 04/19] Fix loading failure exception throws

---
 src/client/java/minicraft/saveload/Load.java | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/client/java/minicraft/saveload/Load.java b/src/client/java/minicraft/saveload/Load.java
index 0e11a4904..00aa37d55 100644
--- a/src/client/java/minicraft/saveload/Load.java
+++ b/src/client/java/minicraft/saveload/Load.java
@@ -117,7 +117,11 @@ public WorldLoadingInterruptedException(Exception cause) {
 		}
 	}
 	public static class DungeonRegenerationCancelledException extends WorldLoadingInterruptedException {}
-	public static class BackupCreationFailedException extends WorldLoadingInterruptedException {}
+	public static class BackupCreationFailedException extends WorldLoadingInterruptedException {
+		public BackupCreationFailedException(@Nullable Exception cause) {
+			super(cause);
+		}
+	}
 	public static class WorldLoadingFailedException extends WorldLoadingInterruptedException {
 		public WorldLoadingFailedException(Exception cause) {
 			super(cause);
@@ -192,7 +196,7 @@ public Load(String worldname, boolean loadGame)
 									f.toPath(), FileHandler.SKIP, false);
 							} catch (IOException e) {
 								Logging.SAVELOAD.error(e, "Error occurs while performing world backup, loading aborted");
-								throw new BackupCreationFailedException();
+								throw new BackupCreationFailedException(e);
 							}
 
 							Logging.SAVELOAD.info("World backup \"{}\" is created.", filename);
@@ -202,7 +206,7 @@ public Load(String worldname, boolean loadGame)
 						Logging.SAVELOAD.debug("World loading continues...");
 					} else {
 						Logging.SAVELOAD.info("User cancelled world loading, loading aborted.");
-						throw new DungeonRegenerationCancelledException();
+						throw new BackupCreationFailedException(null);
 					}
 
 					break;
@@ -286,7 +290,7 @@ public Load(String worldname, boolean loadGame)
 							World.levels[lvlidx] = new Level(oriLevel.w, oriLevel.h, oriLevel.getSeed(), -4, World.levels[World.lvlIdx(-3)], true);
 							if (reAdd) World.levels[lvlidx].add(Game.player);
 						} else {
-							throw new RuntimeException(new InterruptedException("World loading interrupted."));
+							throw new DungeonRegenerationCancelledException();
 						}
 
 						break;

From 6bf717fa57d0d2abca1888943259d7e4db04ae26 Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Wed, 7 Feb 2024 11:07:41 +0800
Subject: [PATCH 05/19] Remove unmatched tailing comma check

`String#split` trims the trailing empty string so there is no empty string in the resultant list.
---
 src/client/java/minicraft/saveload/HistoricLoad.java | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/client/java/minicraft/saveload/HistoricLoad.java b/src/client/java/minicraft/saveload/HistoricLoad.java
index 8cc77a118..cab110055 100644
--- a/src/client/java/minicraft/saveload/HistoricLoad.java
+++ b/src/client/java/minicraft/saveload/HistoricLoad.java
@@ -184,12 +184,8 @@ static void loadSave(String worldName) throws Load.LoadingSessionFailedException
 
 	private static List<String> loadFile(String path) throws Load.FileLoadingException {
 		try {
-			List<String> data = Arrays.asList(Load.loadFromFile(path, true).split(","));
-			if (!data.get(data.size() - 1).isEmpty())
-				throw new Load.MalformedSaveDataFormatException("The last character is expected to be a comma (\",\")");
-			data.remove(data.size() - 1); // Removes the empty value as the last character is a comma.
-			return data;
-		} catch (IOException | Load.MalformedSaveDataFormatException e) {
+			return Arrays.asList(Load.loadFromFile(path, true).split(","));
+		} catch (IOException e) {
 			throw new Load.FileLoadingException("Failed to load \"" + path + "\"", e);
 		}
 	}

From 84b7a0ceb4780f16c36caee0ad045589059c2780 Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Tue, 13 Feb 2024 22:38:34 +0800
Subject: [PATCH 06/19] Resolve errors when loading old world

Revision tested: 585fef39
Only initial world is tested
---
 .../java/minicraft/saveload/HistoricLoad.java | 29 +++++++++++++++----
 .../minicraft/screen/WorldSelectDisplay.java  |  6 ++--
 2 files changed, 26 insertions(+), 9 deletions(-)

diff --git a/src/client/java/minicraft/saveload/HistoricLoad.java b/src/client/java/minicraft/saveload/HistoricLoad.java
index cab110055..3b433765d 100644
--- a/src/client/java/minicraft/saveload/HistoricLoad.java
+++ b/src/client/java/minicraft/saveload/HistoricLoad.java
@@ -225,8 +225,7 @@ private static void validateIntegralData(int data, @Nullable Predicate<Integer>
 	}
 
 	/** Validates for integral data when it is not loaded but a validation is required. */
-	private static void validateIntegralSaveData(String data, String msg)
-		throws Load.MalformedSaveDataValueException {
+	private static void validateIntegralSaveData(String data, String msg) throws Load.MalformedSaveDataValueException {
 		try {
 			validateIntegralData(Integer.parseInt(data), null);
 		} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
@@ -234,6 +233,23 @@ private static void validateIntegralSaveData(String data, String msg)
 		}
 	}
 
+	private static final Predicate<Float> POSITIVE_FLOAT_CHECK = v -> v > 0;
+	private static final Predicate<Float> NON_NEGATIVE_FLOAT_CHECK = v -> v >= 0;
+
+	private static void validateFloatData(float data, @Nullable Predicate<Float> condition)
+		throws Load.IllegalSaveDataValueException {
+		if (!(condition == null ? POSITIVE_FLOAT_CHECK : condition).test(data))
+			throw new Load.IllegalSaveDataValueException("Input: " + data);
+	}
+
+	private static void validateFloatSaveData(String data, String msg) throws Load.MalformedSaveDataValueException {
+		try {
+			validateFloatData(Float.parseFloat(data), null);
+		} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+			throw new Load.MalformedSaveDataValueException(msg, e);
+		}
+	}
+
 	/** Validates for boolean data when it is not loaded but a validation is required. */
 	private static void validateBooleanSaveData(String data, String msg)
 		throws Load.MalformedSaveDataValueException {
@@ -265,7 +281,7 @@ private static void loadGame(String path) throws Load.MalformedSaveException {
 			validateIntegralSaveData(data.get(1), "Index 1 (Auto-save time interval)");
 
 			// Index 2 (Game speed) -> Updater#gamespeed is now no longer saved in saves; data validation only.
-			validateIntegralSaveData(data.get(2), "Index 2 (Game speed)");
+			validateFloatSaveData(data.get(2), "Index 2 (Game speed)");
 
 			if (data.size() == 4) { // before Mar 11, 2017
 				try {
@@ -337,7 +353,7 @@ private static void loadLevel(String pathA, String pathB, int index) throws Load
 
 			try {
 				depth = Integer.parseInt(dataA.get(2));
-				validateIntegralData(depth, v -> v >= 0 && v <= 4);
+				validateIntegralData(depth, v -> v >= -4 && v <= 1);
 			} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
 				throw new Load.MalformedSaveDataValueException("Index 2 (Level depth)", e);
 			}
@@ -750,7 +766,7 @@ private static void loadPlayer(String path) throws Load.MalformedSaveException {
 		}
 	}
 
-	private static final Pattern ITEM_REGEX = Pattern.compile("([\\w ]+)(?:;(\\d+))?");
+	private static final Pattern ITEM_REGEX = Pattern.compile("([\\w .]+)(?:;(\\d+))?");
 
 	private static void loadInventory(String path) throws Load.MalformedSaveException {
 		DeathChest deathChest = new DeathChest();
@@ -787,7 +803,8 @@ private static void loadToInventory(String data, Inventory inv, @Nullable DeathC
 			Item item = Items.get(Load.subOldName(itemName
 				.replace("P.", "Potion")
 				.replace("Fish Rod", "Fishing Rod")
-				.replace("bed", "Bed"), new Version("0.0.0")));
+				.replace("bed", "Bed"), new Version("0.0.0"))
+				.replace("St.", "Stone "));
 			if (item instanceof UnknownItem)
 				throw new Load.MalformedSaveDataValueException("Item name",
 					new Load.IllegalSaveDataValueException("Input: " + data));
diff --git a/src/client/java/minicraft/screen/WorldSelectDisplay.java b/src/client/java/minicraft/screen/WorldSelectDisplay.java
index 19e7c5b2c..1a69d63c2 100644
--- a/src/client/java/minicraft/screen/WorldSelectDisplay.java
+++ b/src/client/java/minicraft/screen/WorldSelectDisplay.java
@@ -61,7 +61,7 @@ private void updateEntries() {
 			final Version version = worldVersions.get(i);
 			entries[i] = new SelectEntry(name, () -> {
 				// Executed when we select a world.
-				if (version.compareTo(Game.VERSION) > 0)
+				if (version != null && version.compareTo(Game.VERSION) > 0)
 					return; // cannot load a game saved by a higher version!
 				worldName = name;
 				Game.setDisplay(new LoadingDisplay());
@@ -226,11 +226,11 @@ public void render(Screen screen) {
 		if (sel >= 0 && sel < worldVersions.size()) {
 			Version version = worldVersions.get(sel);
 			int col = Color.WHITE;
-			if (version.compareTo(Game.VERSION) > 0) {
+			if (version != null && version.compareTo(Game.VERSION) > 0) {
 				col = Color.RED;
 				Font.drawCentered(Localization.getLocalized("minicraft.displays.world_select.display.world_too_new"), screen, Font.textHeight() * 5, col);
 			}
-			Font.drawCentered(Localization.getLocalized("minicraft.displays.world_select.display.world_version", (version.compareTo(new Version("1.9.2")) <= 0 ? "~" : "") + version), screen, Font.textHeight() * 7 / 2, col);
+			Font.drawCentered(Localization.getLocalized("minicraft.displays.world_select.display.world_version", (version == null ? "<1.9.1" : (version.compareTo(new Version("1.9.2")) <= 0 ? "~" : "") + version)), screen, Font.textHeight() * 7 / 2, col);
 		}
 
 		Font.drawCentered(Localization.getLocalized("minicraft.displays.world_select.display.help.0", Game.input.getMapping("select")), screen, Screen.h - 60, Color.GRAY);

From 868b02dd706b17200e5043aa65767f204ba14b54 Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Tue, 13 Feb 2024 22:53:55 +0800
Subject: [PATCH 07/19] HistoricLoad perform backups only fully loaded

---
 .../java/minicraft/saveload/HistoricLoad.java | 40 ++++++++++---------
 1 file changed, 21 insertions(+), 19 deletions(-)

diff --git a/src/client/java/minicraft/saveload/HistoricLoad.java b/src/client/java/minicraft/saveload/HistoricLoad.java
index 3b433765d..3dd22c961 100644
--- a/src/client/java/minicraft/saveload/HistoricLoad.java
+++ b/src/client/java/minicraft/saveload/HistoricLoad.java
@@ -137,35 +137,22 @@ public class HistoricLoad {
 
 	static void loadSave(String worldName) throws Load.LoadingSessionFailedException {
 		String location = Game.gameDir + "/saves/" + worldName + "/";
-		String filePath;
-
 		try {
 			Game.player.getInventory().clearInv(); // Prepare for loading.
-			createBackup(filePath = location + "Game" + Save.extension);
-			loadGame(filePath);
-			// KeyPrefs are now saved in global preferences, but not world-wide.
-			createBackup(filePath = location + "KeyPrefs" + Save.extension);
-			if (new File(filePath).delete()) // World-wide KeyPrefs are ignored.
-				Logging.SAVELOAD.debug("\"{}\" is deleted.", filePath);
-
+			loadGame(location + "Game" + Save.extension);
+			// KeyPrefs is handled later.
 			try {
 				for (int i = 0; i < 6; ++i) {
-					String dataPath = location + "Level" + i + "data" + Save.extension;
-					createBackup(filePath = location + "Level" + i + Save.extension);
-					createBackup(dataPath);
-					loadLevel(filePath, dataPath, i);
+					loadLevel(location + "Level" + i + Save.extension, location + "Level" + i + "data" + Save.extension, i);
 				}
 			} catch (Load.MalformedSaveDataException e) {
 				throw new Load.MalformedSaveException("World", e);
 			}
 
-			createBackup(filePath = location + "Player" + Save.extension);
-			loadPlayer(filePath);
-			createBackup(filePath = location + "Inventory" + Save.extension);
-			loadInventory(filePath);
+			loadPlayer(location + "Player" + Save.extension);
+			loadInventory(location + "Inventory" + Save.extension);
 			// loadEntities is not checked by me, but I assume that it is implemented correctly.
-			createBackup(filePath = location + "Entities" + Save.extension);
-			loadEntities(filePath); // Most parts of the code are not modified.
+			loadEntities(location + "Entities" + Save.extension); // Most parts of the code are not modified.
 		} catch (Load.MalformedSaveException e) {
 			throw new Load.LoadingSessionFailedException("Failed to load world \"" + worldName + "\"", e);
 		} catch (IndexOutOfBoundsException e) {
@@ -180,6 +167,21 @@ static void loadSave(String worldName) throws Load.LoadingSessionFailedException
 			 */
 			throw new AssertionError(e);
 		}
+
+		// Do backups for all files, when the whole world is successfully loaded.
+		createBackup(location + "KeyPrefs" + Save.extension);
+		// KeyPrefs are now saved in global preferences, but not world-wide.
+		if (new File(location + "KeyPrefs" + Save.extension).delete()) // World-wide KeyPrefs are ignored.
+			Logging.SAVELOAD.debug("\"{}\" is deleted.", location + "KeyPrefs" + Save.extension);
+		createBackup(location + "Game" + Save.extension);
+		createBackup(location + "KeyPrefs" + Save.extension);
+		for (int i = 0; i < 6; ++i) {
+			createBackup(location + "Level" + i + Save.extension);
+			createBackup(location + "Level" + i + "data" + Save.extension);
+		}
+		createBackup(location + "Player" + Save.extension);
+		createBackup(location + "Inventory" + Save.extension);
+		createBackup(location + "Entities" + Save.extension);
 	}
 
 	private static List<String> loadFile(String path) throws Load.FileLoadingException {

From d6cb57d439744e7ff3cd799cc1662f8f071d998c Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Tue, 13 Feb 2024 23:07:21 +0800
Subject: [PATCH 08/19] Add popup messages for each loading error

---
 src/client/java/minicraft/core/World.java      |  2 +-
 src/client/java/minicraft/saveload/Load.java   | 15 ++++++++-------
 .../java/minicraft/screen/LoadingDisplay.java  | 18 +++++++++++++++---
 .../minicraft/screen/WorldSelectDisplay.java   |  2 +-
 .../resources/assets/localization/en-us.json   |  4 +++-
 5 files changed, 28 insertions(+), 13 deletions(-)

diff --git a/src/client/java/minicraft/core/World.java b/src/client/java/minicraft/core/World.java
index a5202464c..cf198b3dc 100644
--- a/src/client/java/minicraft/core/World.java
+++ b/src/client/java/minicraft/core/World.java
@@ -105,7 +105,7 @@ public static void resetGame(boolean keepPlayer) {
 	 **/
 	public static void initWorld()
 		throws Load.BackupCreationFailedException, Load.WorldLoadingFailedException,
-		Load.DungeonRegenerationCancelledException { // This is a full reset; everything.
+		Load.UserPromptCancelledException { // This is a full reset; everything.
 		Logging.WORLD.debug("Resetting world...");
 
 		PlayerDeathDisplay.shouldRespawn = false;
diff --git a/src/client/java/minicraft/saveload/Load.java b/src/client/java/minicraft/saveload/Load.java
index 00aa37d55..630cc6847 100644
--- a/src/client/java/minicraft/saveload/Load.java
+++ b/src/client/java/minicraft/saveload/Load.java
@@ -65,6 +65,7 @@
 import minicraft.screen.entry.StringEntry;
 import minicraft.util.AdvancementElement;
 import minicraft.util.Logging;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.json.JSONArray;
 import org.json.JSONException;
@@ -106,7 +107,7 @@ public class Load {
 	}
 
 	public Load(String worldname)
-		throws BackupCreationFailedException, WorldLoadingFailedException, DungeonRegenerationCancelledException {
+		throws BackupCreationFailedException, WorldLoadingFailedException, UserPromptCancelledException {
 		this(worldname, true);
 	}
 
@@ -116,20 +117,20 @@ public WorldLoadingInterruptedException(Exception cause) {
 			super(cause);
 		}
 	}
-	public static class DungeonRegenerationCancelledException extends WorldLoadingInterruptedException {}
+	public static class UserPromptCancelledException extends WorldLoadingInterruptedException {}
 	public static class BackupCreationFailedException extends WorldLoadingInterruptedException {
-		public BackupCreationFailedException(@Nullable Exception cause) {
+		public BackupCreationFailedException(@NotNull Exception cause) {
 			super(cause);
 		}
 	}
 	public static class WorldLoadingFailedException extends WorldLoadingInterruptedException {
-		public WorldLoadingFailedException(Exception cause) {
+		public WorldLoadingFailedException(@NotNull Exception cause) {
 			super(cause);
 		}
 	}
 
 	public Load(String worldname, boolean loadGame)
-		throws DungeonRegenerationCancelledException, WorldLoadingFailedException, BackupCreationFailedException {
+		throws UserPromptCancelledException, WorldLoadingFailedException, BackupCreationFailedException {
 		loadFromFile(location + "/saves/" + worldname + "/Game" + extension);
 		if (data.get(0).contains(".")) worldVer = new Version(data.get(0));
 
@@ -206,7 +207,7 @@ public Load(String worldname, boolean loadGame)
 						Logging.SAVELOAD.debug("World loading continues...");
 					} else {
 						Logging.SAVELOAD.info("User cancelled world loading, loading aborted.");
-						throw new BackupCreationFailedException(null);
+						throw new UserPromptCancelledException();
 					}
 
 					break;
@@ -290,7 +291,7 @@ public Load(String worldname, boolean loadGame)
 							World.levels[lvlidx] = new Level(oriLevel.w, oriLevel.h, oriLevel.getSeed(), -4, World.levels[World.lvlIdx(-3)], true);
 							if (reAdd) World.levels[lvlidx].add(Game.player);
 						} else {
-							throw new DungeonRegenerationCancelledException();
+							throw new UserPromptCancelledException();
 						}
 
 						break;
diff --git a/src/client/java/minicraft/screen/LoadingDisplay.java b/src/client/java/minicraft/screen/LoadingDisplay.java
index ded163899..1ef604cbe 100644
--- a/src/client/java/minicraft/screen/LoadingDisplay.java
+++ b/src/client/java/minicraft/screen/LoadingDisplay.java
@@ -12,6 +12,7 @@
 import minicraft.gfx.Screen;
 import minicraft.saveload.Load;
 import minicraft.saveload.Save;
+import minicraft.screen.entry.StringEntry;
 
 import javax.swing.Timer;
 
@@ -31,12 +32,23 @@ public LoadingDisplay() {
 			try {
 				World.initWorld();
 				Game.setDisplay(null);
-			} catch (Load.DungeonRegenerationCancelledException | Load.BackupCreationFailedException |
-			         Load.WorldLoadingFailedException ex) {
+			} catch (Load.UserPromptCancelledException ex) {
 				World.onWorldExits();
 				Game.exitDisplay(); // Exits the loading display and returns to world select display.
 				Game.setDisplay(new PopupDisplay(null,
-					"minicraft.displays.loading.regeneration_cancellation_popup.display"));
+					"minicraft.displays.loading.user_cancellation_popup.display"));
+			} catch (Load.BackupCreationFailedException ex) {
+				World.onWorldExits();
+				Game.exitDisplay(); // Exits the loading display and returns to world select display.
+				Game.setDisplay(new PopupDisplay(null,
+					StringEntry.useLines(Color.WHITE, false, Localization.getLocalized(
+						"minicraft.displays.loading.backup_creation_failed_popup", ex.getCause().getMessage()))));
+			} catch (Load.WorldLoadingFailedException ex) {
+				World.onWorldExits();
+				Game.exitDisplay(); // Exits the loading display and returns to world select display.
+				Game.setDisplay(new PopupDisplay(null,
+					StringEntry.useLines(Color.WHITE, false, Localization.getLocalized(
+						"minicraft.displays.loading.loading_failed_popup", ex.getCause().getMessage()))));
 			}
 		}, "World Initialization Thread").start());
 		t.setRepeats(false);
diff --git a/src/client/java/minicraft/screen/WorldSelectDisplay.java b/src/client/java/minicraft/screen/WorldSelectDisplay.java
index 1a69d63c2..61e3b2b24 100644
--- a/src/client/java/minicraft/screen/WorldSelectDisplay.java
+++ b/src/client/java/minicraft/screen/WorldSelectDisplay.java
@@ -283,7 +283,7 @@ public static void updateWorlds() {
 					worldNames.add(name);
 					try {
 						worldVersions.add(new Load(name, false).getWorldVersion());
-					} catch (Load.DungeonRegenerationCancelledException | Load.BackupCreationFailedException |
+					} catch (Load.UserPromptCancelledException | Load.BackupCreationFailedException |
 					         Load.WorldLoadingFailedException ignored) {} // This is supposed to be not happening.
 					// Ideally, this way should not be used.
 				}
diff --git a/src/client/resources/assets/localization/en-us.json b/src/client/resources/assets/localization/en-us.json
index 15e918460..d2816dd2c 100644
--- a/src/client/resources/assets/localization/en-us.json
+++ b/src/client/resources/assets/localization/en-us.json
@@ -127,6 +127,8 @@
   "minicraft.displays.key_input.popup_display.press_key_sequence": "Press the desired key sequence",
   "minicraft.displays.key_input.title": "Controls",
   "minicraft.displays.language_settings.title": "Language...",
+  "minicraft.displays.loading.backup_creation_failed_popup": "Failed to create a backup:\n%s",
+  "minicraft.displays.loading.loading_failed_popup": "Failed to load the world:\n%s",
   "minicraft.displays.loading.message.dungeon_regeneration": "Regenerating B4",
   "minicraft.displays.loading.message.entities": "Entities",
   "minicraft.displays.loading.message.generating": "Generating",
@@ -141,7 +143,7 @@
   "minicraft.displays.loading.regeneration_popup.display.2": "Old data on that floor are going to be erased:",
   "minicraft.displays.loading.regeneration_popup.display.3": "%s to continue",
   "minicraft.displays.loading.regeneration_popup.display.4": "%s to cancel world loading",
-  "minicraft.displays.loading.regeneration_cancellation_popup.display": "World loading cancelled",
+  "minicraft.displays.loading.user_cancellation_popup.display": "World loading cancelled",
   "minicraft.displays.options_main_menu": "Main Menu Options",
   "minicraft.displays.options_main_menu.resource_packs": "Resource packs",
   "minicraft.displays.options_world": "World Options",

From f0d79799e0b33dc2388c9c5748f7d9163873ed4a Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Tue, 13 Feb 2024 23:15:54 +0800
Subject: [PATCH 09/19] Removed extra line to backup KeyPrefs

---
 src/client/java/minicraft/saveload/HistoricLoad.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/client/java/minicraft/saveload/HistoricLoad.java b/src/client/java/minicraft/saveload/HistoricLoad.java
index 3dd22c961..7eca03176 100644
--- a/src/client/java/minicraft/saveload/HistoricLoad.java
+++ b/src/client/java/minicraft/saveload/HistoricLoad.java
@@ -174,7 +174,6 @@ static void loadSave(String worldName) throws Load.LoadingSessionFailedException
 		if (new File(location + "KeyPrefs" + Save.extension).delete()) // World-wide KeyPrefs are ignored.
 			Logging.SAVELOAD.debug("\"{}\" is deleted.", location + "KeyPrefs" + Save.extension);
 		createBackup(location + "Game" + Save.extension);
-		createBackup(location + "KeyPrefs" + Save.extension);
 		for (int i = 0; i < 6; ++i) {
 			createBackup(location + "Level" + i + Save.extension);
 			createBackup(location + "Level" + i + "data" + Save.extension);

From d7b996547a2c9c83d01204ce7bdce77e796277bb Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Wed, 14 Feb 2024 00:25:13 +0800
Subject: [PATCH 10/19] Throw error for unknown entity

---
 .../java/minicraft/saveload/HistoricLoad.java | 44 ++++++++++++-------
 1 file changed, 27 insertions(+), 17 deletions(-)

diff --git a/src/client/java/minicraft/saveload/HistoricLoad.java b/src/client/java/minicraft/saveload/HistoricLoad.java
index 7eca03176..9142f9f86 100644
--- a/src/client/java/minicraft/saveload/HistoricLoad.java
+++ b/src/client/java/minicraft/saveload/HistoricLoad.java
@@ -38,6 +38,7 @@
 import minicraft.level.Level;
 import minicraft.level.tile.Tiles;
 import minicraft.util.Logging;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.tinylog.Logger;
 
@@ -779,7 +780,7 @@ private static void loadInventory(String path) throws Load.MalformedSaveExceptio
 				for (int i = 0; i < data.size(); i++) {
 					try {
 						loadToInventory(data.get(i), inv, deathChest);
-					} catch (Load.MalformedSaveDataValueException | Load.IllegalSaveDataValueException e) {
+					} catch (Load.IllegalSaveDataValueException | Load.MalformedDataValueException e) {
 						throw new Load.MalformedSaveDataValueException("Index " + i, e);
 					}
 				}
@@ -797,18 +798,17 @@ private static void loadInventory(String path) throws Load.MalformedSaveExceptio
 	}
 
 	private static void loadToInventory(String data, Inventory inv, @Nullable DeathChest deathChest)
-		throws Load.IllegalSaveDataValueException, Load.MalformedSaveDataValueException {
+		throws Load.IllegalSaveDataValueException, Load.MalformedDataValueException {
 		Matcher matcher = ITEM_REGEX.matcher(data);
 		if (matcher.matches()) {
 			String itemName = matcher.group(1);
 			Item item = Items.get(Load.subOldName(itemName
 				.replace("P.", "Potion")
 				.replace("Fish Rod", "Fishing Rod")
-				.replace("bed", "Bed"), new Version("0.0.0"))
-				.replace("St.", "Stone "));
+				.replace("bed", "Bed"), new Version("0.0.0")));
 			if (item instanceof UnknownItem)
-				throw new Load.MalformedSaveDataValueException("Item name",
-					new Load.IllegalSaveDataValueException("Input: " + data));
+				throw new Load.MalformedDataValueException("Item name",
+					new Load.IllegalDataValueException("Input: " + data));
 			int count = 1;
 			String countStr = matcher.group(2);
 			if (countStr != null) { // When ";<amount>" exists.
@@ -817,7 +817,7 @@ private static void loadToInventory(String data, Inventory inv, @Nullable DeathC
 					if (count == 0) count = 1; // I am not sure about this.
 					validateIntegralData(count, POSITIVE_INTEGER_CHECK);
 				} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
-					throw new Load.MalformedSaveDataValueException(
+					throw new Load.MalformedDataValueException(
 						"Item count", e);
 				}
 			}
@@ -858,9 +858,14 @@ private static void loadEntities(String path) throws Load.MalformedSaveException
 							mobLvl = Integer.parseInt(info.get(info.size() - 2));
 					} catch (ClassNotFoundException ignored) { }
 
-					Entity newEntity = getEntity(entityName, Game.player, mobLvl);
+					Entity newEntity;
+					try {
+						newEntity = getEntity(entityName, Game.player, mobLvl);
+					} catch (Load.IllegalDataValueException e) {
+						throw new Load.IllegalSaveDataValueException("Entity", e);
+					}
 
-					if (newEntity != null && newEntity != Game.player) { // the method never returns null, but...
+					if (newEntity != Game.player) { // the method never returns null, but...
 						int currentlevel;
 						if (newEntity instanceof Mob) {
 							Mob mob = (Mob) newEntity;
@@ -879,7 +884,7 @@ private static void loadEntities(String path) throws Load.MalformedSaveException
 								if (itemData.isEmpty()) continue; // this skips any null items
 								try {
 									loadToInventory(itemData, chest.getInventory(), null);
-								} catch (Load.IllegalSaveDataValueException | Load.MalformedSaveDataValueException e) {
+								} catch (Load.IllegalSaveDataValueException | Load.MalformedDataValueException e) {
 									throw new Load.IllegalSaveDataValueException("Data Index " + idx, e);
 								}
 							}
@@ -893,10 +898,13 @@ private static void loadEntities(String path) throws Load.MalformedSaveException
 							currentlevel = Integer.parseInt(info.get(info.size() - 1));
 							World.levels[currentlevel].add(chest instanceof DeathChest ? chest : chest instanceof DungeonChest ? (DungeonChest) chest : chest, x, y);
 						} else if (newEntity instanceof Spawner) {
-							MobAi mob = (MobAi) getEntity(info.get(2), Game.player, Integer.parseInt(info.get(3)));
-							currentlevel = Integer.parseInt(info.get(info.size() - 1));
-							if (mob != null)
+							try {
+								MobAi mob = (MobAi) getEntity(info.get(2), Game.player, Integer.parseInt(info.get(3)));
+								currentlevel = Integer.parseInt(info.get(info.size() - 1));
 								World.levels[currentlevel].add(new Spawner(mob), x, y);
+							} catch (Load.IllegalDataValueException e) {
+								throw new Load.IllegalSaveDataValueException("Spawner entity", e);
+							}
 						} else {
 							currentlevel = Integer.parseInt(info.get(2));
 							World.levels[currentlevel].add(newEntity, x, y);
@@ -912,7 +920,9 @@ private static void loadEntities(String path) throws Load.MalformedSaveException
 		}
 	}
 
-	private static Entity getEntity(String string, Player player, int mobLevel) {
+	@NotNull
+	private static Entity getEntity(String string, Player player, int mobLevel)
+			throws Load.IllegalDataValueException {
 		switch (string) {
 			case "Player":
 				return player;
@@ -935,7 +945,7 @@ private static Entity getEntity(String string, Player player, int mobLevel) {
 			case "Snake":
 				return new Snake(mobLevel);
 			case "AirWizard":
-				if (mobLevel > 1) return null;
+				if (mobLevel > 1) throw new Load.IllegalDataValueException("Mob level: " + mobLevel);
 				return new AirWizard();
 			case "Spawner":
 				return new Spawner(new Zombie(1));
@@ -968,8 +978,8 @@ private static Entity getEntity(String string, Player player, int mobLevel) {
 			case "GoldLantern":
 				return new Lantern(Lantern.Type.GOLD);
 			default:
-				Logger.tag("SaveLoad/LegacyLoad").warn("Unknown or outdated entity requested: " + string);
-				return null;
+				Logger.tag("SaveLoad/HistoricLoad").error("Unknown entity requested: " + string);
+				throw new Load.IllegalDataValueException("Input: " + string);
 		}
 	}
 }

From a974bc7e91458fe7d5c7278ba4dc32338987ca82 Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Wed, 14 Feb 2024 00:25:36 +0800
Subject: [PATCH 11/19] Load KeyPrefs only when exists

---
 src/client/java/minicraft/saveload/HistoricLoad.java | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/client/java/minicraft/saveload/HistoricLoad.java b/src/client/java/minicraft/saveload/HistoricLoad.java
index 9142f9f86..3dee84037 100644
--- a/src/client/java/minicraft/saveload/HistoricLoad.java
+++ b/src/client/java/minicraft/saveload/HistoricLoad.java
@@ -170,10 +170,13 @@ static void loadSave(String worldName) throws Load.LoadingSessionFailedException
 		}
 
 		// Do backups for all files, when the whole world is successfully loaded.
-		createBackup(location + "KeyPrefs" + Save.extension);
-		// KeyPrefs are now saved in global preferences, but not world-wide.
-		if (new File(location + "KeyPrefs" + Save.extension).delete()) // World-wide KeyPrefs are ignored.
-			Logging.SAVELOAD.debug("\"{}\" is deleted.", location + "KeyPrefs" + Save.extension);
+		File keyPrefsFile = new File(location + "KeyPrefs" + Save.extension);
+		if (keyPrefsFile.exists()) {
+			createBackup(location + "KeyPrefs" + Save.extension);
+			// KeyPrefs are now saved in global preferences, but not world-wide.
+			if (new File(location + "KeyPrefs" + Save.extension).delete()) // World-wide KeyPrefs are ignored.
+				Logging.SAVELOAD.debug("\"{}\" is deleted.", location + "KeyPrefs" + Save.extension);
+		}
 		createBackup(location + "Game" + Save.extension);
 		for (int i = 0; i < 6; ++i) {
 			createBackup(location + "Level" + i + Save.extension);

From 014aa06dff076b1ca75c4a4c69d0b1e7fc4c3882 Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Wed, 14 Feb 2024 03:52:48 +0800
Subject: [PATCH 12/19] Detailed error message in world load error popup

---
 .../java/minicraft/screen/LoadingDisplay.java       | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/client/java/minicraft/screen/LoadingDisplay.java b/src/client/java/minicraft/screen/LoadingDisplay.java
index 1ef604cbe..b4afda4d0 100644
--- a/src/client/java/minicraft/screen/LoadingDisplay.java
+++ b/src/client/java/minicraft/screen/LoadingDisplay.java
@@ -42,18 +42,27 @@ public LoadingDisplay() {
 				Game.exitDisplay(); // Exits the loading display and returns to world select display.
 				Game.setDisplay(new PopupDisplay(null,
 					StringEntry.useLines(Color.WHITE, false, Localization.getLocalized(
-						"minicraft.displays.loading.backup_creation_failed_popup", ex.getCause().getMessage()))));
+						"minicraft.displays.loading.backup_creation_failed_popup", getErrorMessage(ex)))));
 			} catch (Load.WorldLoadingFailedException ex) {
 				World.onWorldExits();
 				Game.exitDisplay(); // Exits the loading display and returns to world select display.
 				Game.setDisplay(new PopupDisplay(null,
 					StringEntry.useLines(Color.WHITE, false, Localization.getLocalized(
-						"minicraft.displays.loading.loading_failed_popup", ex.getCause().getMessage()))));
+						"minicraft.displays.loading.loading_failed_popup", getErrorMessage(ex)))));
 			}
 		}, "World Initialization Thread").start());
 		t.setRepeats(false);
 	}
 
+	private String getErrorMessage(Throwable e) {
+		StringBuilder msg = new StringBuilder(e.getMessage());
+		while ((e = e.getCause()) != null) {
+			msg.append(": ").append(e.getMessage());
+		}
+
+		return msg.toString();
+	}
+
 	@Override
 	public void init(Display parent) {
 		if (parent != null && parent.getParent() == this) return; // Undefined behaviour

From 6b3df867af112463ea9e48b6cf19eb4e19a7e3c6 Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Wed, 14 Feb 2024 04:00:48 +0800
Subject: [PATCH 13/19] Use switch-case for item name in HistoricLoad

---
 .../java/minicraft/saveload/HistoricLoad.java | 92 ++++++++++++++++++-
 src/client/java/minicraft/saveload/Load.java  |  4 +-
 2 files changed, 90 insertions(+), 6 deletions(-)

diff --git a/src/client/java/minicraft/saveload/HistoricLoad.java b/src/client/java/minicraft/saveload/HistoricLoad.java
index 3dee84037..bf5446038 100644
--- a/src/client/java/minicraft/saveload/HistoricLoad.java
+++ b/src/client/java/minicraft/saveload/HistoricLoad.java
@@ -805,10 +805,7 @@ private static void loadToInventory(String data, Inventory inv, @Nullable DeathC
 		Matcher matcher = ITEM_REGEX.matcher(data);
 		if (matcher.matches()) {
 			String itemName = matcher.group(1);
-			Item item = Items.get(Load.subOldName(itemName
-				.replace("P.", "Potion")
-				.replace("Fish Rod", "Fishing Rod")
-				.replace("bed", "Bed"), new Version("0.0.0")));
+			Item item = Items.get(resolveItemName(itemName));
 			if (item instanceof UnknownItem)
 				throw new Load.MalformedDataValueException("Item name",
 					new Load.IllegalDataValueException("Input: " + data));
@@ -843,6 +840,93 @@ private static void loadToInventory(String data, Inventory inv, @Nullable DeathC
 		}
 	}
 
+	private static String resolveItemName(String itemName) {
+		/*
+		 * Item Name Change History (UTC)
+		 *
+		 * Notes:
+		 * - "St.BrickWall" Stone Wall -> unknown version change to be resolved, so resolved here.
+		 * - Note that "Cooked Pork" and "Pork Chop" were 2 separated items, but resolved later?
+		 *
+		 * Commit History
+		 *
+		 * c3f2e0ea Apr 02, 2017 (23:01)
+		 * - Item "Fish Rod" is removed.
+		 * - Tool type "Rod" is added, and "Wood Rod" is added with "Wood" level.
+		 * 3e572c1e Mar 31, 2017 (19:38)
+		 * - Items added: "Ob.BrickWall", "Obsidian Door"
+		 * 9c1abfe2 Mar 29, 2017 (06:01)
+		 * - " P." is trimmed out from potions' names except for item "Potion".
+		 * - "P." is instead changed to "Potion".
+		 * f95343bf Mar 24, 2017 (04:48)
+		 * - List of spawners changed.
+		 * - New list of spawners: "Cow Spawner", "Pig Spawner", "Sheep Spawner", "Slime Spawner", "Zombie Spawner",
+		 *   "Creeper Spawner", "Skeleton Spawner", "Snake Spawner", "Knight Spawner", "AirWizard Spawner",
+		 *   "AirWizardII Spawner"
+		 * 01d8e558 Mar 21, 2017 (23:26)
+		 * - Spawners are implemented.
+		 * - Items added: "Zombie Spawner", "Slime Spawner", "Knight Spawner", "Snake Spawner", "Skeleton Spawner",
+		 *   "Creeper Spawner", "AirWizard Spawner", "AirWizard Spawner" (duplicated), "Pig Spawner", "Sheep Spawner"
+		 * 13507725 Mar 20, 2017 (10:18)
+		 * - Item "Key" added
+		 * aa565e20 Mar 20, 2017 (01:09)
+		 * - Colored wools and clothes implemented.
+		 * - 5 "Wool" variations are renamed to the corresponding colors.
+		 * - Items added: "Red Clothes", "Blue Clothes", "Green Clothes", "Yellow Clothes", "Black Clothes",
+		 *   "Orange Clothes", "Purple Clothes", "Cyan Clothes", "Reg Clothes"
+		 * - "Wool" items renamed: "Red Wool", "Blue Wool", "Green Wool", "Yellow Wool", "Black Wool"
+		 * - One "Wool" is kept.
+		 * d97784ce Mar 19, 2017 (11:48)
+		 * - Potions added: "Potion", "Speed P.", "Light P.", "Swim P.", "Energy P.", "Regen P.", "Time P.",
+		 *   "Lava P.", "Shield P.", "Haste P."
+		 * 3fb901de Mar 11, 2017 (07:34)
+		 * - Renamed class "bed" to "Bed", but no effect to the entity name and item name.
+		 * 0fbeae59 Feb 26, 2017 (06:22)
+		 * - Dungeon Chest "D.Chest" -> "Dungeon Chest"
+		 * - "Cooked Pork" is added as a food, but at the same time, "Pork Chop" exists.
+		 * 11c3260d Feb 25, 2017 (22:52) First commit
+		 * - Save/Load is not added yet, but items exist.
+		 * - 6 "Wool" variations existed, but with the same name
+		 * - "bed" existed as class name but not as item name even furniture name.
+		 *
+		 * Several items that have doubt to be saved, and not included in the check and mappings:
+		 * - "D.Chest" Dungeon Chest -> cannot be picked up # Since the initial
+		 * - "God Lantern" -> not included in ListItems; no longer existed # Since the initial
+		 * - "God Workbench" -> not included in ListItems; no longer existed # Since the initial
+		 */
+
+		switch (itemName) {
+			// Since the initial
+				// It was not set that can be picked up, but still checked here.
+			case "D.Chest": // Until Feb 26, 2017
+				itemName = "Dungeon Chest"; break;
+			case "St.BrickWall": // Until 1.9.4-dev4?
+				itemName = "Stone Wall"; break;
+			case "Fish Rod": // ?
+				itemName = "Fishing Rod"; break;
+			case "Speed P.": // Until Mar 29, 2017 (06:01)
+				itemName = "Speed Potion"; break;
+			case "Light P.": // Until Mar 29, 2017 (06:01)
+				itemName = "Light Potion"; break;
+			case "Swim P.": // Until Mar 29, 2017 (06:01)
+				itemName = "Swim Potion"; break;
+			case "Energy P.": // Until Mar 29, 2017 (06:01)
+				itemName = "Energy Potion"; break;
+			case "Regen P.": // Until Mar 29, 2017 (06:01)
+				itemName = "Regen Potion"; break;
+			case "Time P.": // Until Mar 29, 2017 (06:01)
+				itemName = "Time Potion"; break;
+			case "Lava P.": // Until Mar 29, 2017 (06:01)
+				itemName = "Lava Potion"; break;
+			case "Shield P.": // Until Mar 29, 2017 (06:01)
+				itemName = "Shield Potion"; break;
+			case "Haste P.": // Until Mar 29, 2017 (06:01)
+				itemName = "Haste Potion"; break;
+		}
+
+		return Load.subOldName(itemName, new Version("0.0.0"));
+	}
+
 	private static void loadEntities(String path) throws Load.MalformedSaveException {
 		try {
 			List<String> data = loadFile(path);
diff --git a/src/client/java/minicraft/saveload/Load.java b/src/client/java/minicraft/saveload/Load.java
index 630cc6847..8d0a81574 100644
--- a/src/client/java/minicraft/saveload/Load.java
+++ b/src/client/java/minicraft/saveload/Load.java
@@ -982,8 +982,8 @@ protected static String subOldName(String name, Version worldVer) {
 		}
 
 		if (worldVer.compareTo(new Version("2.2.0-dev4")) < 0) {
-			if (name.startsWith("Potion"))
-				name = name.replace("Potion", "Awkward Potion");
+			if (name.equals("Potion"))
+				name = "Awkward Potion";
 		}
 
 		return name;

From a70c7f5dc39638105fec133bf87ca7c88fee9811 Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Wed, 14 Feb 2024 04:17:41 +0800
Subject: [PATCH 14/19] Add handles for particle loading in HistoricLoad

---
 src/client/java/minicraft/saveload/HistoricLoad.java | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/client/java/minicraft/saveload/HistoricLoad.java b/src/client/java/minicraft/saveload/HistoricLoad.java
index bf5446038..48f051966 100644
--- a/src/client/java/minicraft/saveload/HistoricLoad.java
+++ b/src/client/java/minicraft/saveload/HistoricLoad.java
@@ -26,6 +26,8 @@
 import minicraft.entity.mob.Slime;
 import minicraft.entity.mob.Snake;
 import minicraft.entity.mob.Zombie;
+import minicraft.entity.particle.SmashParticle;
+import minicraft.entity.particle.TextParticle;
 import minicraft.gfx.Color;
 import minicraft.item.ArmorItem;
 import minicraft.item.Inventory;
@@ -71,6 +73,8 @@ public class HistoricLoad {
 	 *   - Although in some time periods, max armor is saved instead of armor point, it is still loaded as armor point.
 	 *   - Skin-On is an abandoned feature. It controls whether to render the player skin suits,
 	 *     which has already been removed now.
+	 *   - Note that conical class name is saved and "com.mojang.ld22.entity." is trimmed when entity is saved,
+	 *     unintended "particle." exists as entity name.
 	 *
 	 * Commit History
 	 * (1.9.1) 1930f326 Apr 12, 2017 (23:30) # 1.9.1 has been released on the next day (01:53)
@@ -1064,6 +1068,10 @@ private static Entity getEntity(String string, Player player, int mobLevel)
 				return new Lantern(Lantern.Type.IRON);
 			case "GoldLantern":
 				return new Lantern(Lantern.Type.GOLD);
+			case "particle.SmashParticle":
+				return new SmashParticle(0, 0);
+			case "particle.TextParticle":
+				return new TextParticle("UNKNOWN", 0, 0, 0);
 			default:
 				Logger.tag("SaveLoad/HistoricLoad").error("Unknown entity requested: " + string);
 				throw new Load.IllegalDataValueException("Input: " + string);

From f054ebafa9261c66cd27f1cbf50cc12c52a7b899 Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Wed, 14 Feb 2024 21:24:55 +0800
Subject: [PATCH 15/19] Complement Historic about bugs and data fixer

---
 .../java/minicraft/saveload/HistoricLoad.java | 159 ++++++++++++++++++
 src/client/java/minicraft/saveload/Load.java  | 121 +++++++++++++
 .../java/minicraft/screen/LoadingDisplay.java |  62 ++++++-
 .../resources/assets/localization/en-us.json  |  21 ++-
 4 files changed, 357 insertions(+), 6 deletions(-)

diff --git a/src/client/java/minicraft/saveload/HistoricLoad.java b/src/client/java/minicraft/saveload/HistoricLoad.java
index 48f051966..f7f55232a 100644
--- a/src/client/java/minicraft/saveload/HistoricLoad.java
+++ b/src/client/java/minicraft/saveload/HistoricLoad.java
@@ -26,6 +26,7 @@
 import minicraft.entity.mob.Slime;
 import minicraft.entity.mob.Snake;
 import minicraft.entity.mob.Zombie;
+import minicraft.entity.particle.FireParticle;
 import minicraft.entity.particle.SmashParticle;
 import minicraft.entity.particle.TextParticle;
 import minicraft.gfx.Color;
@@ -49,6 +50,7 @@
 import java.nio.file.FileAlreadyExistsException;
 import java.nio.file.Files;
 import java.nio.file.StandardCopyOption;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.function.Predicate;
@@ -125,6 +127,39 @@ public class HistoricLoad {
 	 *   - Dungeon locking feature is disabled and forcedly set to "unlocked".
 	 * 473bbe5b Feb 26, 2017 (06:21)
 	 * - Save/Load system added
+	 * - Potion system is disabled.
+	 * (1.8; May 2013)
+	 * - Mostly the same as the initial commit except that potion exists. Therefore, it is the same as Mar 19, 2017
+	 *   for Player save file format.
+	 * - FireParticle exists.
+	 *
+	 * Known Bugs with Old Versions (at least existed before 1.9.1)
+	 * - Level saves using WorldGenMenu#sized to save level size
+	 *   - Existed since Save/Load system was added (also for 1.8), remained unfixed even after 1.9.1
+	 *   - Steps to reproduce in old versions:
+	 *     - Let the world size setting in World Creation menu be the desired value.
+	 *     - Load another world with a world size different from the value set in the menu.
+	 *     - Save the loaded world.
+	 *     - The resultant world save would use the set value from the menu, instead of Level#h and Level#w.
+	 *     - The world save is then corrupted.
+	 *   - If the world save is then tried being loaded in the old version, it crashes with IndexOutOfBoundsException.
+	 *   - This bug is regarded as a possible case and handled with an on-demand data fixer.
+	 * - Entities save using entity class (binary) name to save entity keys
+	 *   - Existed since Save/Load system was added (also for 1.8), remained unfixed even after 1.9.1
+	 *   - Reasons for exception to occur in old versions:
+	 *     - When an entity is saved, its class name is obtained with "com.mojang.ld22.entity." trimmed, but not fully
+	 *       applicable to all entities.
+	 *     - If the entity class is not barely just belongs to the entity package, but a subpackage underneath it,
+	 *       a tailing package subpackage path is append to the entity key.
+	 *     - In the old versions, there existed only (2 to 3) particle types that belong to a subpackage under entity.
+	 *     - However, since the lifespans of the particles are short, the chance to get them to be saved is low,
+	 *       and any entity in the world is saved in old versions.
+	 *   - Results in old versions:
+	 *     - In 1.8, unknown entity is loaded as an empty Entity instance, and existed in the world forever.
+	 *     - Starting from the first commit adding Save/Load system, an error log is printed instead, without it loaded.
+	 *   - This exception has been included here with 3 particle cases.
+	 * - (Unknown) For 1.8, player's position is sometimes saved in obviously different values.
+	 *   - It can be out of the level for a 128-sized world.
 	 *
 	 * Initial Save Structure (473bbe5b+0fbeae59)
 	 *   - Game.miniplussave
@@ -337,6 +372,8 @@ private static void loadGame(String path) throws Load.MalformedSaveException {
 		}
 	}
 
+	private static final int[] legalWorldSizes = new int[] { 128, 256, 512 };
+
 	private static void loadLevel(String pathA, String pathB, int index) throws Load.MalformedSaveDataException {
 		try {
 			List<String> dataA = loadFile(pathA);
@@ -346,6 +383,7 @@ private static void loadLevel(String pathA, String pathB, int index) throws Load
 					"Corrupted .miniplussave (Level data count: " + dataA.size() + ")");
 
 			int w, h, depth;
+			//noinspection DuplicatedCode
 			try {
 				w = Integer.parseInt(dataA.get(0));
 				validateIntegralData(w, null);
@@ -374,6 +412,125 @@ private static void loadLevel(String pathA, String pathB, int index) throws Load
 					new Load.IllegalSaveDataValueException("width: " + w + "; height: " + h));
 			}
 
+			// Recovery attempt for a known bug about corrupted world size; details above
+			if (dataA.size() != 3 + w * h && dataA.size() - 3 == dataB.size()) {
+				// If both data sets match the case, an auto fix is available.
+				// Otherwise, an exception will still be thrown, if it is still illegal.
+				// Additional modifications to the world save causing case mismatch are not allowed.
+				for (int a : legalWorldSizes) {
+					for (int b : legalWorldSizes) {
+						if (a != b && dataA.size() == 3 + a * a && b == w) {
+							Load.setDataFixer(new Load.AutoDataFixer() {
+								@Override
+								protected void performFix(String worldName) {
+									// Corruption Validation
+									setMessageValidating();
+									String location = Game.gameDir + "/saves/" + worldName + "/";
+									int[] levelWidths = new int[6];
+									int[] levelHeights = new int[6];
+									int[] levelSizes = new int[6];
+									ArrayList<List<String>> dataAs = new ArrayList<>(6);
+									for (int i = 0; i < 6; ++i) {
+										try {
+											List<String> dataA = loadFile(location + "Level" + i + Save.extension);
+											List<String> dataB = loadFile(location + "Level" + i +
+												"data" + Save.extension);
+											int w, h;
+											//noinspection DuplicatedCode
+											try {
+												w = Integer.parseInt(dataA.get(0));
+												validateIntegralData(w, null);
+											} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+												throw new Load.MalformedSaveDataValueException("Index 0 (Level width)", e);
+											}
+
+											try {
+												h = Integer.parseInt(dataA.get(1));
+												validateIntegralData(h, null);
+											} catch (NumberFormatException | Load.IllegalSaveDataValueException e) {
+												throw new Load.MalformedSaveDataValueException("Index 1 (Level height)", e);
+											}
+
+											if (w != h || Arrays.stream(legalWorldSizes).noneMatch(v -> v == w) ||
+												dataA.size() - 3 != dataB.size() ||
+												Arrays.stream(legalWorldSizes).noneMatch(v -> v * v == dataB.size())) {
+												Logging.SAVELOAD.error("Unexpected value set detected: w: {}; h: {}; " +
+													"Level{} data count: {}; Level{}data data count: {}", w, h,
+													i, dataA.size(), i, dataB.size());
+												Logging.SAVELOAD.warn("World save recovery for world \"{}\" failed.",
+													worldName);
+												finish(false);
+												return; // Cancelled
+											}
+
+											levelWidths[i] = w;
+											levelHeights[i] = h;
+											levelSizes[i] = dataB.size();
+											dataAs.add(dataA);
+										} catch (Load.FileLoadingException e) {
+											Logging.SAVELOAD.error(e, "Unable to load Level {} save data", i);
+											Logging.SAVELOAD.warn("World save recovery for world \"{}\" failed.",
+												worldName);
+											finish(false);
+											return; // Cancelled
+										} catch (Load.MalformedSaveDataValueException e) {
+											Logging.SAVELOAD.error(e, "Malformed Level {} save data", i);
+											Logging.SAVELOAD.warn("World save recovery for world \"{}\" failed.",
+												worldName);
+											finish(false);
+											return; // Cancelled
+										}
+									}
+
+									for (int i = 1; i < 6; ++i) {
+										if (levelWidths[i] != levelWidths[0] || levelHeights[i] != levelHeights[0] ||
+											levelSizes[i] != levelSizes[0]) {
+											Logging.SAVELOAD.error("Inconsistent level sizes detected (found level {}: " +
+												"(w: {}; h: {}; data count: {}); expected (level 0): (w: {}; h: {}; " +
+												"data count: {})), but disallowed in this save recovery.", i,
+												levelWidths[i], levelHeights[i], levelSizes[i],
+												levelWidths[0], levelHeights[0], levelSizes[0]);
+											Logging.SAVELOAD.warn("World save recovery for world \"{}\" failed.",
+												worldName);
+											finish(false);
+											return; // Cancelled
+										}
+									}
+
+									// Validation Completed; Perform Recovery
+									setMessagePerforming();
+									for (int v : legalWorldSizes) {
+										if (v * v == levelSizes[0]) {
+											// v is now the desired world size.
+											for (int i = 0; i < 6; ++i) {
+												List<String> dataA = dataAs.get(i);
+												// Replacing the original size values with the desired value.
+												dataA.set(0, String.valueOf(v));
+												dataA.set(1, String.valueOf(v));
+												// Resaving the recovered data.
+												try {
+													Save.writeToFile(location + "Level" + i + Save.extension,
+														dataA.toArray(new String[0]), true);
+												} catch (IOException e) {
+													Logging.SAVELOAD.error(e, "Unable to save recovered data");
+													Logging.SAVELOAD.warn(
+														"World save recovery for world \"{}\" failed.", worldName);
+													finish(false);
+													return; // Cancelled
+												}
+											}
+										}
+									}
+
+									// Recovery successfully completed.
+									finish(true);
+								}
+							});
+						}
+					}
+				}
+			}
+
 			if (dataA.size() < 3 + w * h)
 				throw new Load.MalformedSaveDataFormatException(
 					"Corrupted .miniplussave (Level data count: " + dataA.size() + ")");
@@ -1072,6 +1229,8 @@ private static Entity getEntity(String string, Player player, int mobLevel)
 				return new SmashParticle(0, 0);
 			case "particle.TextParticle":
 				return new TextParticle("UNKNOWN", 0, 0, 0);
+			case "particle.FireParticle": // Added since Mar 18, 2017 (04:44) c15adeb8
+				return new FireParticle(0, 0);
 			default:
 				Logger.tag("SaveLoad/HistoricLoad").error("Unknown entity requested: " + string);
 				throw new Load.IllegalDataValueException("Input: " + string);
diff --git a/src/client/java/minicraft/saveload/Load.java b/src/client/java/minicraft/saveload/Load.java
index 8d0a81574..fde4976cd 100644
--- a/src/client/java/minicraft/saveload/Load.java
+++ b/src/client/java/minicraft/saveload/Load.java
@@ -4,6 +4,7 @@
 import minicraft.core.Updater;
 import minicraft.core.World;
 import minicraft.core.io.FileHandler;
+import minicraft.core.io.InputHandler;
 import minicraft.core.io.Localization;
 import minicraft.core.io.Settings;
 import minicraft.entity.Arrow;
@@ -40,6 +41,10 @@
 import minicraft.entity.particle.SmashParticle;
 import minicraft.entity.particle.TextParticle;
 import minicraft.gfx.Color;
+import minicraft.gfx.Ellipsis;
+import minicraft.gfx.Font;
+import minicraft.gfx.FontStyle;
+import minicraft.gfx.Screen;
 import minicraft.item.ArmorItem;
 import minicraft.item.Inventory;
 import minicraft.item.Item;
@@ -53,10 +58,12 @@
 import minicraft.network.Network;
 import minicraft.screen.AchievementsDisplay;
 import minicraft.screen.CraftingDisplay;
+import minicraft.screen.Display;
 import minicraft.screen.LoadingDisplay;
 import minicraft.screen.MultiplayerDisplay;
 import minicraft.screen.PopupDisplay;
 import minicraft.screen.QuestsDisplay;
+import minicraft.screen.RelPos;
 import minicraft.screen.ResourcePackDisplay;
 import minicraft.screen.SkinDisplay;
 import minicraft.screen.TutorialDisplayHandler;
@@ -65,12 +72,15 @@
 import minicraft.screen.entry.StringEntry;
 import minicraft.util.AdvancementElement;
 import minicraft.util.Logging;
+import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 
+import javax.swing.Timer;
+
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
@@ -91,6 +101,8 @@ public class Load {
 
 	private String location = Game.gameDir;
 
+	private static @Nullable AutoDataFixer dataFixer = null;
+
 	private static final String extension = Save.extension;
 	private float percentInc;
 
@@ -224,6 +236,7 @@ public Load(String worldname, boolean loadGame)
 			try {
 				HistoricLoad.loadSave(worldname);
 			} catch (LoadingSessionFailedException e) {
+				Logging.SAVELOAD.error(e, "Failed to load world \"{}\"", worldname);
 				throw new WorldLoadingFailedException(e);
 			}
 		} else if (worldVer.compareTo(new Version("1.9.2")) < 0) {
@@ -1315,6 +1328,114 @@ private static Entity getEntity(String string, int mobLevel) {
 		}
 	}
 
+	public static void setDataFixer(@Nullable AutoDataFixer dataFixer) {
+		Load.dataFixer = dataFixer;
+	}
+
+	public static @Nullable AutoDataFixer getDataFixer() {
+		return dataFixer;
+	}
+
+	public static abstract class AutoDataFixer {
+		protected abstract void performFix(String worldName);
+
+		protected final void setMessagePerforming() {
+			display.msg = "minicraft.displays.load.data_fixer.message.performing";
+		}
+
+		protected final void setMessageValidating() {
+			display.msg = "minicraft.displays.load.data_fixer.message.validating";
+		}
+
+		protected final void finish(boolean successful) {
+			display.finished = successful;
+		}
+
+		private DataFixerDisplay display = null;
+
+		private class DataFixerDisplay extends Display {
+			private volatile String msg = "minicraft.displays.load.data_fixer.message.starting";
+			private volatile @Nullable Boolean finished = null; // true -> successful; false -> failed
+
+			private final Timer t;
+			private final Ellipsis ellipsis = new Ellipsis.SmoothEllipsis(new Ellipsis.DotUpdater.TimeUpdater());
+			private final String worldName;
+
+			private DataFixerDisplay(String worldName) {
+				super(true, false);
+				this.worldName = worldName;
+				t = new Timer(200, e -> new Thread(() -> performFix(worldName),
+					"World Save Corruption Data Recovery Thread").start());
+				t.setRepeats(false);
+			}
+
+			@Override
+			public void init(Display parent) {
+				if (parent != null && parent.getParent() == this) return; // Undefined behaviour
+				super.init(parent);
+				t.start();
+			}
+
+			@Override
+			public void tick(InputHandler input) {
+				super.tick(input);
+				if (finished != null) {
+					if (input.getMappedKey("EXIT").isClicked()) {
+						Game.exitDisplay(); // Returns to world selection menu.
+					} else if (input.getMappedKey("SELECT").isClicked()) {
+						Game.exitDisplay(); // Exits this display first.
+						Game.setDisplay(new LoadingDisplay()); // Loads the same world again.
+					}
+				} else {
+					if (input.getMappedKey("EXIT|SELECT").isClicked()) {
+						Game.exitDisplay(); // Returns to world selection menu.
+					}
+				}
+			}
+
+			@Override
+			public void render(Screen screen) {
+				super.render(screen);
+				Font.drawCentered(Localization.getLocalized("minicraft.displays.load.data_fixer.title"),
+					screen, 40, Color.WHITE);
+				if (finished != null) {
+					if (Boolean.TRUE.equals(finished)) {
+						Font.drawCentered(Localization.getLocalized(
+							"minicraft.displays.load.data_fixer.completed.display"), screen, 64, Color.GREEN);
+						Font.drawParagraph(Localization.getLocalized(
+							"minicraft.displays.load.data_fixer.completed.message", worldName),
+							screen, Screen.w - 8 * 6, Screen.h, new FontStyle()
+							.setAnchor(Screen.w / 2, 80).setRelTextPos(RelPos.BOTTOM, true), 2);
+						Font.drawCentered(Localization.getLocalized(
+							"minicraft.displays.load.data_fixer.completed.return",
+							Game.input.getMapping("EXIT")), screen, Screen.h - 40, Color.WHITE);
+						Font.drawCentered(Localization.getLocalized(
+							"minicraft.displays.load.data_fixer.completed.continue",
+							Game.input.getMapping("SELECT")), screen, Screen.h - 30, Color.WHITE);
+					} else {
+						Font.drawCentered(Localization.getLocalized(
+							"minicraft.displays.load.data_fixer.failed.display"), screen, 64, Color.RED);
+						Font.drawParagraph(Localization.getLocalized(
+							"minicraft.displays.load.data_fixer.failed.message", worldName),
+							screen, Screen.w - 8 * 6, Screen.h, new FontStyle()
+							.setAnchor(Screen.w / 2, 80).setRelTextPos(RelPos.BOTTOM, true), 2);
+						Font.drawParagraph(Localization.getLocalized(
+							"minicraft.displays.load.data_fixer.failed.return",
+								Game.input.getMapping("EXIT"), Game.input.getMapping("SELECT")),
+							screen, Screen.w - 8 * 8, Screen.h, new FontStyle()
+							.setAnchor(Screen.w / 2, 40).setRelTextPos(RelPos.BOTTOM, true), 0);
+					}
+				} else
+					Font.drawCentered(Localization.getLocalized("minicraft.displays.load.data_fixer.message",
+						Localization.getLocalized(msg), ellipsis.updateAndGet()), screen, 70, Color.WHITE);
+			}
+		}
+
+		public void startFixer(String worldName) {
+			Game.setDisplay(display = new DataFixerDisplay(worldName));
+		}
+	}
+
 	/**
 	 * Parses a string into a boolean, throws exception if the string is not a boolean.
 	 * @throws IllegalDataValueException if the string does not contain a parseable boolean.
diff --git a/src/client/java/minicraft/screen/LoadingDisplay.java b/src/client/java/minicraft/screen/LoadingDisplay.java
index b4afda4d0..bf066469c 100644
--- a/src/client/java/minicraft/screen/LoadingDisplay.java
+++ b/src/client/java/minicraft/screen/LoadingDisplay.java
@@ -12,10 +12,15 @@
 import minicraft.gfx.Screen;
 import minicraft.saveload.Load;
 import minicraft.saveload.Save;
+import minicraft.screen.entry.ListEntry;
 import minicraft.screen.entry.StringEntry;
 
 import javax.swing.Timer;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.concurrent.atomic.AtomicBoolean;
+
 public class LoadingDisplay extends Display {
 
 	private static float percentage = 0;
@@ -30,6 +35,7 @@ public LoadingDisplay() {
 		super(true, false);
 		t = new Timer(500, e -> new Thread(() -> { // A new thread is required as this blocks the running thread.
 			try {
+				Load.setDataFixer(null); // Resets fixer
 				World.initWorld();
 				Game.setDisplay(null);
 			} catch (Load.UserPromptCancelledException ex) {
@@ -42,13 +48,61 @@ public LoadingDisplay() {
 				Game.exitDisplay(); // Exits the loading display and returns to world select display.
 				Game.setDisplay(new PopupDisplay(null,
 					StringEntry.useLines(Color.WHITE, false, Localization.getLocalized(
-						"minicraft.displays.loading.backup_creation_failed_popup", getErrorMessage(ex)))));
+						"minicraft.displays.loading.backup_creation_failed_popup.display", getErrorMessage(ex.getCause())))));
 			} catch (Load.WorldLoadingFailedException ex) {
 				World.onWorldExits();
 				Game.exitDisplay(); // Exits the loading display and returns to world select display.
-				Game.setDisplay(new PopupDisplay(null,
-					StringEntry.useLines(Color.WHITE, false, Localization.getLocalized(
-						"minicraft.displays.loading.loading_failed_popup", getErrorMessage(ex)))));
+				Load.AutoDataFixer dataFixer;
+				if ((dataFixer = Load.getDataFixer()) != null) {
+					AtomicBoolean acted = new AtomicBoolean(false);
+					AtomicBoolean perform = new AtomicBoolean(false);
+					ArrayList<PopupDisplay.PopupActionCallback> callbacks = new ArrayList<>();
+					callbacks.add(new PopupDisplay.PopupActionCallback("EXIT", m -> {
+						acted.set(true);
+						return true;
+					}));
+					callbacks.add(new PopupDisplay.PopupActionCallback("SELECT", m -> {
+						perform.set(true);
+						acted.set(true);
+						return true;
+					}));
+
+					ArrayList<ListEntry> entries = new ArrayList<>();
+					Collections.addAll(entries, StringEntry.useLines(Color.WHITE, false,
+						Localization.getLocalized("minicraft.displays.loading.corrupted_world_fixer_available.display",
+							WorldSelectDisplay.getWorldName())));
+					Collections.addAll(entries, StringEntry.useLines(Color.WHITE, false,
+						Localization.getLocalized("minicraft.displays.loading.corrupted_world_fixer_available.select",
+							Game.input.getMapping("SELECT"))));
+					Game.setDisplay(new PopupDisplay(new PopupDisplay.PopupConfig(
+						"minicraft.displays.loading.corrupted_world.title", callbacks, 2),
+						entries.toArray(new ListEntry[0])));
+
+					while (true) {
+						if (acted.get()) {
+							if (perform.get()) {
+								dataFixer.startFixer(WorldSelectDisplay.getWorldName());
+							} else {
+								Game.setDisplay(new PopupDisplay(new PopupDisplay.PopupConfig(
+									"minicraft.displays.loading.corrupted_world_fixing_cancelled.title",
+									null, 2),
+									StringEntry.useLines(Color.WHITE, false, Localization.getLocalized(
+										"minicraft.displays.loading.corrupted_world_fixing_cancelled.display",
+										getErrorMessage(ex.getCause())))));
+							}
+
+							break;
+						}
+
+						try {
+							//noinspection BusyWait
+							Thread.sleep(10);
+						} catch (InterruptedException ignored) { }
+					}
+				} else
+					Game.setDisplay(new PopupDisplay(null,
+						StringEntry.useLines(Color.WHITE, false, Localization.getLocalized(
+							"minicraft.displays.loading.loading_failed_popup.display", getErrorMessage(ex.getCause())))));
 			}
 		}, "World Initialization Thread").start());
 		t.setRepeats(false);
diff --git a/src/client/resources/assets/localization/en-us.json b/src/client/resources/assets/localization/en-us.json
index d2816dd2c..2651974b9 100644
--- a/src/client/resources/assets/localization/en-us.json
+++ b/src/client/resources/assets/localization/en-us.json
@@ -127,8 +127,25 @@
   "minicraft.displays.key_input.popup_display.press_key_sequence": "Press the desired key sequence",
   "minicraft.displays.key_input.title": "Controls",
   "minicraft.displays.language_settings.title": "Language...",
-  "minicraft.displays.loading.backup_creation_failed_popup": "Failed to create a backup:\n%s",
-  "minicraft.displays.loading.loading_failed_popup": "Failed to load the world:\n%s",
+  "minicraft.displays.load.data_fixer.completed.continue": "%s to continue",
+  "minicraft.displays.load.data_fixer.completed.display": "Recovery Completed",
+  "minicraft.displays.load.data_fixer.completed.message": "Recovery is successfully completed, would you like to load the world \"%s\" again?",
+  "minicraft.displays.load.data_fixer.completed.return": "%s to return to world list",
+  "minicraft.displays.load.data_fixer.failed.display": "Recovery Failed",
+  "minicraft.displays.load.data_fixer.failed.message": "It seems like recovery is not applicable to the world \"%s\".",
+  "minicraft.displays.load.data_fixer.failed.return": "%s or %s to return to world list",
+  "minicraft.displays.load.data_fixer.message": "%s%s",
+  "minicraft.displays.load.data_fixer.message.performing": "Recovery Performing",
+  "minicraft.displays.load.data_fixer.message.starting": "Starting Recovery",
+  "minicraft.displays.load.data_fixer.message.validating": "Corruption Validating",
+  "minicraft.displays.load.data_fixer.title": "World Save Recovery",
+  "minicraft.displays.loading.backup_creation_failed_popup.display": "Failed to create a backup:\n%s",
+  "minicraft.displays.loading.corrupted_world.title": "Corrupted World",
+  "minicraft.displays.loading.corrupted_world_fixer_available.display": "It seems like your world \"%s\" is corrupted, but auto recovery seems to be available. Would you like to perform recovery?",
+  "minicraft.displays.loading.corrupted_world_fixer_available.select": "%s to perform",
+  "minicraft.displays.loading.corrupted_world_fixing_cancelled.display": "Recovery is cancelled, loading failure:\n%s",
+  "minicraft.displays.loading.corrupted_world_fixing_cancelled.title": "World Recovery Cancelled",
+  "minicraft.displays.loading.loading_failed_popup.display": "Failed to load the world:\n%s",
   "minicraft.displays.loading.message.dungeon_regeneration": "Regenerating B4",
   "minicraft.displays.loading.message.entities": "Entities",
   "minicraft.displays.loading.message.generating": "Generating",

From a92a8c195afb8e4fb93be52cfa450925d5aad3d6 Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Thu, 15 Feb 2024 03:27:06 +0800
Subject: [PATCH 16/19] Fix a word of grammar mistake

---
 src/client/java/minicraft/saveload/HistoricLoad.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/client/java/minicraft/saveload/HistoricLoad.java b/src/client/java/minicraft/saveload/HistoricLoad.java
index f7f55232a..d0bc1ae68 100644
--- a/src/client/java/minicraft/saveload/HistoricLoad.java
+++ b/src/client/java/minicraft/saveload/HistoricLoad.java
@@ -247,7 +247,7 @@ private static void createBackup(String path) {
 				Logging.SAVELOAD.trace("Backup \"{}\" is successfully created for \"{}\".",
 					bakFile.getPath(), file.getPath());
 			} else {
-				Logging.SAVELOAD.warn("Backup \"{}\" created for \"{}\" is unexpectedly disappeared",
+				Logging.SAVELOAD.warn("Backup \"{}\" created for \"{}\" has unexpectedly disappeared",
 					bakFile.getPath(), file.getPath());
 			}
 		} catch (FileAlreadyExistsException e) { // This should not be thrown as REPLACE_EXISTING is set.

From 0cb84e8814feeb8c34676d12cb90cec1dada49cc Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Thu, 2 May 2024 20:10:53 +0800
Subject: [PATCH 17/19] Update game_profile.conf and add GameVersion

---
 build.gradle                                  | 30 ++++++++++++++---
 game_profile.conf                             |  8 +++--
 src/client/java/minicraft/core/Game.java      | 10 ++++--
 .../java/minicraft/core/GameVersion.java      | 32 +++++++++++++++++++
 4 files changed, 72 insertions(+), 8 deletions(-)
 create mode 100644 src/client/java/minicraft/core/GameVersion.java

diff --git a/build.gradle b/build.gradle
index 81c3c9f64..1ab49db54 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,4 +1,8 @@
 import groovy.json.JsonBuilder
+import groovy.json.JsonSlurper
+import java.time.LocalDateTime
+import java.time.ZoneOffset
+import java.time.format.DateTimeFormatter
 
 plugins {
     id 'application'
@@ -10,7 +14,12 @@ allprojects {
     Properties profile = new Properties()
     profile.load(new FileInputStream(new File(rootDir, "game_profile.conf")))
 
-    version = profile.getProperty("version")
+    ext.id = profile.getProperty("id")
+    ext.stable = Boolean.parseBoolean(profile.getProperty("stable"))
+    ext.branch = profile.getProperty("branch")
+    ext.packVersionResource = Integer.parseInt(profile.getProperty("pack_version_resource"))
+    ext.packVersionData = Integer.parseInt(profile.getProperty("pack_version_data"))
+    ext.worldVersion = Integer.parseInt(profile.getProperty("world_version"))
 
     sourceCompatibility = 8
     [compileJava, compileTestJava]*.options*.encoding = 'UTF-8'
@@ -49,9 +58,13 @@ project(":client") {
     File genDir = new File(project.buildDir, "tmp/generatedResources/")
     genDir.mkdirs()
     JsonBuilder json = new JsonBuilder()
-    json {
-        version version
-    }
+    json id: ext.id,
+            use_editor: false,
+            build_time: LocalDateTime.now().withNano(0).atOffset(ZoneOffset.UTC).format(DateTimeFormatter.ISO_OFFSET_DATE_TIME),
+            stable: ext.stable,
+            branch: ext.branch,
+            world_version: ext.worldVersion,
+            pack_version: [ resource: ext.packVersionResource, data: ext.packVersionData ]
     File metaFile = new File(genDir.toString(), "profile.meta.json")
     metaFile.text = json.toString()
     processResources {
@@ -123,3 +136,12 @@ tasks.withType(Tar) {
 tasks.withType(Zip) {
     duplicatesStrategy = DuplicatesStrategy.INCLUDE
 }
+
+// Please configure this in editor run configuration manually for this to work.
+// This should run before build
+project(":client").tasks.register('configEditor') {
+    File metaFile = new File(project.buildDir, "tmp/generatedResources/profile.meta.json")
+    def obj = new JsonSlurper().parse(new File(project.buildDir, "tmp/generatedResources/profile.meta.json"))
+    obj.use_editor = true
+    metaFile.text = new JsonBuilder(obj).toString()
+}
diff --git a/game_profile.conf b/game_profile.conf
index 2cec452f1..24a0cef45 100644
--- a/game_profile.conf
+++ b/game_profile.conf
@@ -1,2 +1,6 @@
-version=2.2.0-dev6
-devBuild=true
+id=2.2.0-dev6
+stable=false
+branch=main
+pack_version_resource=1
+pack_version_data=0
+world_version=1000
diff --git a/src/client/java/minicraft/core/Game.java b/src/client/java/minicraft/core/Game.java
index b0ce4ff76..df24af64a 100644
--- a/src/client/java/minicraft/core/Game.java
+++ b/src/client/java/minicraft/core/Game.java
@@ -21,6 +21,8 @@
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.UncheckedIOException;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.List;
@@ -33,7 +35,7 @@ protected Game() {
 
 	public static final String NAME = "Minicraft Plus"; // This is the name on the application window.
 
-	public static final Version VERSION;
+	public static final GameVersion VERSION;
 
 	public static InputHandler input; // Input used in Game, Player, and just about all the *Menu classes.
 	public static Player player;
@@ -107,8 +109,12 @@ public static void quit() {
 			throw new IllegalStateException("Malformed application setup");
 
 		JSONObject meta = new JSONObject(new BufferedReader(new InputStreamReader(is)).lines().collect(Collectors.joining("\n")));
+		JSONObject packVersion = meta.getJSONObject("pack_version");
 
-		VERSION = new Version(meta.getString("version"));
+		VERSION = new GameVersion(meta.getString("id"), meta.getInt("world_version"),
+			packVersion.getInt("resource"), packVersion.getInt("data"), meta.getBoolean("stable"),
+			meta.getBoolean("use_editor"), meta.getString("series_id"),
+			LocalDateTime.parse(meta.getString("build_time"), DateTimeFormatter.ISO_OFFSET_DATE_TIME));
 
 		try {
 			is.close();
diff --git a/src/client/java/minicraft/core/GameVersion.java b/src/client/java/minicraft/core/GameVersion.java
new file mode 100644
index 000000000..cf84e45fe
--- /dev/null
+++ b/src/client/java/minicraft/core/GameVersion.java
@@ -0,0 +1,32 @@
+package minicraft.core;
+
+import java.time.LocalDateTime;
+
+public final class GameVersion {
+	public final String id;
+	public final int dataVersion;
+	public final int packResourceVersion, packDataVersion;
+	public final boolean stable;
+	public final boolean useEditor;
+	public final String seriesId;
+	public final LocalDateTime buildTime;
+
+	public GameVersion(String id, int dataVersion, int packResourceVersion, int packDataVersion, boolean stable,
+	                   boolean useEditor, String seriesId, LocalDateTime buildTime) {
+		this.id = id;
+		this.dataVersion = dataVersion;
+		this.packResourceVersion = packResourceVersion;
+		this.packDataVersion = packDataVersion;
+		this.stable = stable;
+		this.useEditor = useEditor;
+		this.seriesId = seriesId;
+		this.buildTime = buildTime;
+	}
+
+	public static int mapOldVersionToDataVersion(String version) { // This should be better than using a JSON file.
+		switch (version) {
+			case "": return 100;
+			default: throw new AssertionError(String.format("Missing handle for version \"%s\"", version));
+		}
+	}
+}

From db23300ed0495bab2f5161b713b97e76b5d70752 Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Thu, 2 May 2024 20:13:59 +0800
Subject: [PATCH 18/19] Update game_profile.conf

---
 game_profile.conf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/game_profile.conf b/game_profile.conf
index 24a0cef45..a930dcff2 100644
--- a/game_profile.conf
+++ b/game_profile.conf
@@ -1,4 +1,4 @@
-id=2.2.0-dev6
+id=2.2.1
 stable=false
 branch=main
 pack_version_resource=1

From 8df5a4b10e771d14a5060eea716807d3273e9561 Mon Sep 17 00:00:00 2001
From: BenCheung0422 <74168521+BenCheung0422@users.noreply.github.com>
Date: Thu, 2 May 2024 20:32:31 +0800
Subject: [PATCH 19/19] Complement old version mappings to data versions

---
 game_profile.conf                             |  2 +-
 .../java/minicraft/core/GameVersion.java      | 82 ++++++++++++++++++-
 src/client/java/minicraft/saveload/Load.java  |  2 +-
 3 files changed, 83 insertions(+), 3 deletions(-)

diff --git a/game_profile.conf b/game_profile.conf
index a930dcff2..4a2fcf4c4 100644
--- a/game_profile.conf
+++ b/game_profile.conf
@@ -1,4 +1,4 @@
-id=2.2.1
+id=2.3.0
 stable=false
 branch=main
 pack_version_resource=1
diff --git a/src/client/java/minicraft/core/GameVersion.java b/src/client/java/minicraft/core/GameVersion.java
index cf84e45fe..586697285 100644
--- a/src/client/java/minicraft/core/GameVersion.java
+++ b/src/client/java/minicraft/core/GameVersion.java
@@ -25,7 +25,87 @@ public GameVersion(String id, int dataVersion, int packResourceVersion, int pack
 
 	public static int mapOldVersionToDataVersion(String version) { // This should be better than using a JSON file.
 		switch (version) {
-			case "": return 100;
+			// Versions are not saved in earlier versions, so they are ignored.
+			case "1.9.1": return 100;
+			case "1.9.2": return 101;
+			case "1.9.3-dev1": return 102;
+			case "1.9.3-dev2": return 103;
+			case "1.9.3": return 104;
+			case "1.9.4-dev1": return 105;
+			case "1.9.4-dev2": return 106;
+			case "1.9.4-dev3": return 107;
+			case "1.9.4-dev4": return 108;
+			case "1.9.4-dev5": return 109;
+			case "1.9.4-dev6": return 110;
+			case "1.9.4-dev7": return 111;
+			case "1.9.4": return 112;
+			case "2.0.0-dev1": return 113;
+			case "2.0.0-dev2": return 114;
+			case "2.0.0-dev3": return 115;
+			case "2.0.0": return 116;
+			case "2.0.1-dev1": return 117;
+			case "2.0.1-dev2": return 118;
+			case "2.0.1-dev3": return 119;
+			case "2.0.1-dev4": return 120;
+			case "2.0.1-dev5": return 121;
+			case "2.0.1-dev6": return 122;
+			case "2.0.1-dev7": return 123;
+			case "2.0.1-dev8": return 124;
+			case "2.0.1-dev9": return 125;
+			case "2.0.1": return 126;
+			case "2.0.2-dev1": return 127;
+			case "2.0.2-dev2": return 128;
+			case "2.0.2-dev3": return 129;
+			case "2.0.2": return 130;
+			case "2.0.3-dev1": return 131;
+			case "2.0.3-dev2": return 132;
+			case "2.0.3-dev3": return 133;
+			case "2.0.3-dev4": return 134;
+			case "2.0.3-dev5": return 135;
+			case "2.0.3-dev6": return 136;
+			case "2.0.3": return 137;
+			case "2.0.4-dev1": return 138;
+			case "2.0.4-dev2": return 139;
+			case "2.0.4-dev3": return 140;
+			case "2.0.4-dev4": return 141;
+			case "2.0.4-dev5": return 142;
+			case "2.0.4-dev6": return 143;
+			case "2.0.4-dev7": return 144;
+			case "2.0.4-dev8": return 145;
+			case "2.0.4-dev9": return 146;
+			case "2.0.4": return 147;
+			case "2.0.5-dev1": return 148;
+			case "2.0.5-dev2": return 149;
+			case "2.0.5-dev3": return 150;
+			case "2.0.5-dev4": return 151;
+			case "2.0.5-dev5": return 152;
+			case "2.0.5-dev6": return 153;
+			case "2.0.5": return 154;
+			case "2.0.6-dev1": return 155;
+			case "2.0.6-dev2": return 156;
+			case "2.0.6-dev3": return 157;
+			case "2.0.6-dev4": return 158;
+			case "2.0.6": return 159;
+			case "2.0.7-dev1": return 160;
+			case "2.0.7-dev2": return 161;
+			case "2.0.7-dev3": return 162;
+			case "2.0.7-dev4": return 163;
+			case "2.0.7": return 164;
+			case "2.1.0-dev1": return 165;
+			case "2.1.0-dev2": return 166;
+			case "2.1.0-dev3": return 167;
+			case "2.1.0": return 168;
+			case "2.1.1": return 169;
+			case "2.1.2": return 170;
+			case "2.1.3": return 171;
+			case "2.2.0-dev1": return 172;
+			case "2.2.0-dev2": return 173;
+			case "2.2.0-dev3": return 174;
+			case "2.2.0-dev4": return 175;
+			case "2.2.0-dev5": return 176;
+			case "2.2.0-dev6": return 177;
+			case "2.2.0-dev7": return 178;
+			case "2.2.0": return 179;
 			default: throw new AssertionError(String.format("Missing handle for version \"%s\"", version));
 		}
 	}
diff --git a/src/client/java/minicraft/saveload/Load.java b/src/client/java/minicraft/saveload/Load.java
index c36e0fccd..876f79237 100644
--- a/src/client/java/minicraft/saveload/Load.java
+++ b/src/client/java/minicraft/saveload/Load.java
@@ -160,7 +160,7 @@ public Load(String worldname, boolean loadGame)
 		if (!loadGame) return;
 
 		// Is dev build
-		if (Game.VERSION.getDev() != 0 && worldVer != null && worldVer.compareTo(Game.VERSION) < 0) {
+		if (!Game.VERSION.stable && worldVer != null && worldVer.compareTo(Game.VERSION) < 0) {
 			Logging.SAVELOAD.info("Old world detected, backup prompting...");
 			ArrayList<ListEntry> entries = new ArrayList<>();
 			entries.addAll(Arrays.asList(StringEntry.useLines(Color.WHITE, false,