Look for map files in a "Maps" subfolder, with root fallback

RPG Maker 2000/2003 games traditionally keep MapNNNN.lmu files directly
in the project root. This adds support for storing them in a "Maps"
subfolder instead, which existing games and tools can adopt for a
tidier project layout.

RPG_RT.lmt (TreeMap) itself needed no changes: it only stores map IDs,
names and hierarchy/metadata, never file paths. The ID-to-filename
mapping is a pure Player-side convention, so only the file lookup
logic needed updating.

To avoid breaking the large existing library of RPG Maker 2000/2003
games that keep maps in the root, lookup prefers "Maps/" but falls
back to the root directory when not found there. This affects map
loading (Game_Map::LoadMapFile), async map prefetching
(Game_Map::RequestMap), the start-map existence check used to trigger
non-standard-extension guessing, and the non-standard LMU extension
guesser itself.

Author: Your Name

src/fileext_guesser.cpp

@@ -67,17 +67,10 @@ FileExtGuesser::RPG2KNonStandardFilenameGuesser FileExtGuesser::GetRPG2kProjectW
 	return RPG2KNonStandardFilenameGuesser();
 }
 
-void FileExtGuesser::GuessAndAddLmuExtension(const FilesystemView& fs, Meta const& meta, RPG2KFileExtRemap& mapping)
-{
-	// If metadata is provided, rely on that.
-	std::string metaLmu = meta.GetLmuAlias();
-	if (!metaLmu.empty()) {
-		mapping.extMap[SUFFIX_LMU] = metaLmu;
-		Output::Debug("Metadata-provided non-standard extension for LMU({})", metaLmu);
-	} else {
-		// Try to rescue and determine file extensions.
-		// Without metadata, scan for matching files. Stop after you find a few;
-		//   we can't just pick the first since there may be some backup files on disk.
+namespace {
+	// Scans a single directory for "mapXXXX.???" files and guesses the LMU
+	// extension from whichever non-standard extension occurs most often.
+	void GuessLmuExtensionIn(const FilesystemView& fs, FileExtGuesser::RPG2KFileExtRemap& mapping) {
 		std::unordered_map<std::string, int> extCounts; // ext => count
 
 		const auto* entries = fs.ListDirectory();
@@ -94,14 +87,38 @@ void FileExtGuesser::GuessAndAddLmuExtension(const FilesystemView& fs, Meta cons
 					if (extCounts[ext] >= 5) {
 						mapping.extMap[SUFFIX_LMU] = ext;
 						Output::Debug("Guessing non-standard extension for LMU({})", ext);
-						break;
+						return;
 					}
 				}
 			}
 		}
 	}
 }
 
+void FileExtGuesser::GuessAndAddLmuExtension(const FilesystemView& fs, Meta const& meta, RPG2KFileExtRemap& mapping)
+{
+	// If metadata is provided, rely on that.
+	std::string metaLmu = meta.GetLmuAlias();
+	if (!metaLmu.empty()) {
+		mapping.extMap[SUFFIX_LMU] = metaLmu;
+		Output::Debug("Metadata-provided non-standard extension for LMU({})", metaLmu);
+		return;
+	}
+
+	// Try to rescue and determine file extensions.
+	// Without metadata, scan for matching files. Stop after you find a few;
+	//   we can't just pick the first since there may be some backup files on disk.
+	// Maps are preferably stored in the "Maps" subfolder, but fall back to
+	// the project root for games that keep their maps there.
+	FilesystemView maps_fs = fs.Subtree(MAPS_DIR_NAME);
+	if (maps_fs) {
+		GuessLmuExtensionIn(maps_fs, mapping);
+	}
+	if (mapping.extMap.find(SUFFIX_LMU) == mapping.extMap.end()) {
+		GuessLmuExtensionIn(fs, mapping);
+	}
+}
+
 FileExtGuesser::RPG2KFileExtRemap FileExtGuesser::RPG2KNonStandardFilenameGuesser::guessExtensions(Meta& meta)
 {
 	RPG2KFileExtRemap res;

src/game_map.cpp

@@ -330,11 +330,11 @@ std::unique_ptr<lcf::rpg::Map> Game_Map::LoadMapFile(int map_id) {
 	// FIXME: Assert map was cached for async platforms
 	bool map_is_easyrpg_file = Player::player_config.prefer_easyrpg_map_files.Get();
 	std::string map_name = Game_Map::ConstructMapName(map_id, map_is_easyrpg_file);
-	std::string map_file = FileFinder::Game().FindFile(map_name);
+	std::string map_file = Game_Map::FindMapFile(map_name);
 	if (map_file.empty()) {
 		map_is_easyrpg_file = !map_is_easyrpg_file;
 		map_name = Game_Map::ConstructMapName(map_id, map_is_easyrpg_file);
-		map_file = FileFinder::Game().FindFile(map_name);
+		map_file = Game_Map::FindMapFile(map_name);
 
 		if (map_file.empty()) {
 			Output::Error("Loading of Map {} failed.\nThe map was not found.", map_name);
@@ -2017,12 +2017,26 @@ std::string Game_Map::ConstructMapName(int map_id, bool is_easyrpg) {
 	}
 }
 
+std::string Game_Map::FindMapFile(std::string_view map_name) {
+	// Maps are preferably stored in the "Maps" subfolder, but fall back to
+	// the game's root directory for compatibility with games that keep
+	// their maps there.
+	std::string map_file = FileFinder::Game().FindFile(MAPS_DIR_NAME, map_name);
+	if (map_file.empty()) {
+		map_file = FileFinder::Game().FindFile(map_name);
+	}
+	return map_file;
+}
+
 FileRequestAsync* Game_Map::RequestMap(int map_id) {
 #ifdef __EMSCRIPTEN__
 	Player::translation.RequestAndAddMap(map_id);
 #endif
 
-	auto* request = AsyncHandler::RequestFile(Game_Map::ConstructMapName(map_id, false));
+	std::string map_name = Game_Map::ConstructMapName(map_id, false);
+	bool in_maps_dir = !FileFinder::Game().FindFile(MAPS_DIR_NAME, map_name).empty();
+
+	auto* request = AsyncHandler::RequestFile(in_maps_dir ? MAPS_DIR_NAME : ".", map_name);
 	request->SetImportantFile(true);
 	return request;
 }

src/game_map.h

@@ -710,6 +710,16 @@ namespace Game_Map {
 	 */
 	std::string ConstructMapName(int map_id, bool is_easyrpg);
 
+	/**
+	 * Searches for a map file on disk. Maps are preferably stored in the
+	 * "Maps" subfolder, but the game's root directory is also searched for
+	 * compatibility with existing games that were never reorganized.
+	 *
+	 * @param map_name The filename to search for, as returned by ConstructMapName
+	 * @return Path to the found file, or an empty string when not found
+	 */
+	std::string FindMapFile(std::string_view map_name);
+
 	FileRequestAsync* RequestMap(int map_id);
 
 	namespace Caching {

src/options.h

@@ -82,6 +82,10 @@
 #define TREEMAP_NAME RPG_RT_PREFIX "." SUFFIX_LMT
 #define TREEMAP_NAME_EASYRPG EASY_RT_PREFIX "." SUFFIX_EMT
 
+/** Subfolder that map files (.lmu/.emu) are preferably stored in.
+ *  Games that still keep them in the project root are also supported. */
+#define MAPS_DIR_NAME "Maps"
+
 /** File name for additional metadata, such as multi-game save imports. */
 #define META_NAME "Meta.ini"
 

src/player.cpp

@@ -995,8 +995,8 @@ static bool DefaultLmuStartFileExists(const FilesystemView& fs) {
 	int map_id = Player::start_map_id == -1 ? lcf::Data::treemap.start.party_map_id : Player::start_map_id;
 	std::string mapName = Game_Map::ConstructMapName(map_id, false);
 
-	// Now see if the file exists.
-	return !fs.FindFile(mapName).empty();
+	// Now see if the file exists, preferring the "Maps" subfolder.
+	return !fs.FindFile(MAPS_DIR_NAME, mapName).empty() || !fs.FindFile(mapName).empty();
 }
 
 void Player::GuessNonStandardExtensions() {