Updated mapper to handle new GMCP Room.Info structure and improved game detection

Added:
- Support for new GMCP Room.Info structure with exits directly under
Room.Info.Exits
- Door details handling with state in exitData.details.state instead of
exitData.status
- Exit locking/unlocking based on door states (closed/locked doors
prevent pathfinding)
- Generic mmp.setEnvironmentColors() function for automatic room
coloring
- mmp.setGame() function to ensure game names are always lowercase
- Game detection requirement for mconfig command
- "mmp game" diagnostic command to check game detection status
- Debug messages for coordinate parsing and room repositioning

Changed:
- Door update logic to check exitData.details.type == "door" and use
details.state
- All game name comparisons to use lowercase consistently
- GoMud environment data registration to apply colors immediately
- mconfig to require game detection before showing options

Fixed:
- Game name inconsistency between "GoMud" and "gomud"
- Coordinate positioning for rooms with GMCP coordinates
- Game-specific options not showing due to incorrect filtering
- Exit locking now properly affects speedwalking pathfinding

Removed:
- GoMud-specific mmp.setgomudcolorcodes() function (replaced with
generic version)

Author: MorquinDevlar

mfile

@@ -2,7 +2,7 @@
        "package": "GoMudMapper",
        "title": "GoMud Mapper",
        "description": "Custom GMCP mapper for GoMud.",
-       "version": "2.0.2",
+       "version": "2.0.3",
        "author": "Morquin - forked from the IRE Mudlet Mapper",
        "icon": "gomud-mapper-icon.png",
        "dependencies": "",

src/aliases/GoMudMapper/utility/aliases.json

@@ -51,7 +51,14 @@
     {
         "name": "option",
         "isActive": "yes",
-        "regex": "^mconfig( (\\w+) (.*))?$",
+        "regex": "^mconfig(?: (\\w+)(?: (.*))?)?$",
+        "script": "",
+        "isFolder": "no"
+    },
+    {
+        "name": "mmp_game",
+        "isActive": "yes",
+        "regex": "^mmp game$",
         "script": "",
         "isFolder": "no"
     },

src/aliases/GoMudMapper/utility/mmp_game.lua

@@ -0,0 +1,32 @@
+-- Alias to show current game detection status
+if mmp.game then
+    mmp.echo(string.format("Game detected: %s", mmp.game))
+    
+    -- Show if there are any game-specific features enabled
+    local gameSpecificOptions = {}
+    for name, def in pairs(mmp.option_definitions or {}) do
+        if def.games and table.contains(def.games, mmp.game) then
+            table.insert(gameSpecificOptions, name)
+        end
+    end
+    
+    if #gameSpecificOptions > 0 then
+        mmp.echo(string.format("Game-specific options available: %s", table.concat(gameSpecificOptions, ", ")))
+    end
+else
+    mmp.echo("No game detected yet.")
+    mmp.echo("The mapper will try to detect your game from GMCP when you connect.")
+    mmp.echo("Your game should set gmcp.Game.Info.engine to identify itself.")
+    
+    -- Show current GMCP status if available
+    if gmcp and gmcp.Game and gmcp.Game.Info then
+        if gmcp.Game.Info.engine then
+            mmp.echo(string.format("GMCP reports engine as: %s", gmcp.Game.Info.engine))
+            mmp.echo("Try reconnecting to properly initialize the mapper.")
+        else
+            mmp.echo("GMCP is available but engine is not set.")
+        end
+    else
+        mmp.echo("No GMCP game information available.")
+    end
+end

src/aliases/GoMudMapper/utility/option.lua

@@ -1,9 +1,54 @@
+-- matches[1] is the full command
+-- matches[2] is the option name (if provided)
+-- matches[3] is the value (if provided)
+
+-- Check if game is detected
+if not mmp.game then
+	mmp.echo("Game not detected. Please reconnect to your MUD so the mapper can identify which game you're playing.")
+	mmp.echo("Games should either set gmcp.Game.Info.engine or use a login trigger to set mmp.game")
+	return
+end
+
 if not matches[2] then
+	-- Show all options with the new display format
 	mmp.settings:showAllOptions(mmp.game)
 	return
 end
 
-local val = matches[4]
+local option = matches[2]
+local val = matches[3]
+
+-- If only option name is provided (no value), show description
+if option and (not val or val == "") then
+	-- Use the new getOptionDef method to get the option definition
+	local optionDef = mmp.settings:getOptionDef(option)
+	
+	if optionDef then
+		-- Use mapper color scheme: light green for labels, white for values
+		echo("\n")
+		decho("<112,229,0>" .. option .. ":<255,255,255> " .. (optionDef.use or "No description available") .. "\n")
+		-- Show current value
+		local currentValue = mmp.settings[option]
+		if type(currentValue) == "boolean" then
+			currentValue = currentValue and "on" or "off"
+		end
+		decho("<112,229,0>Current value: <255,255,255>" .. tostring(currentValue) .. "\n")
+		
+		-- Show accepted values
+		if optionDef.allowedVarTypes and table.contains(optionDef.allowedVarTypes, "boolean") then
+			decho("<112,229,0>Accepted values: <128,128,128>on, off\n")
+		elseif option == "laglevel" then
+			decho("<112,229,0>Accepted values: <128,128,128>1-5 (1=fast, 5=very slow)\n")
+		elseif option == "echocolour" then
+			decho("<112,229,0>Accepted values: <128,128,128>Any valid color name (see 'mcolor' for options)\n")
+		end
+	else
+		mmp.echo("Unknown option: " .. option)
+	end
+	return
+end
+
+-- Convert values
 if val == "true" or val == "yes" or val == "on" then
 	val = true
 end
@@ -12,4 +57,4 @@ if val == "false" or val == "no" or val == "off" then
 end
 local numberVal = tonumber(val)
 val = numberVal and numberVal or val
-mmp.settings:setOption(matches[3], val)
+mmp.settings:setOption(option, val)

src/aliases/aliases.json

@@ -1,6 +1,6 @@
 [
     {
-        "name": "gomud_mapper",
+        "name": "GoMudMapper",
         "isActive": "yes",
         "script": "",
         "isFolder": "yes"

src/scripts/GoMudMapper/core/create_option_table.lua

@@ -68,13 +68,16 @@ function mmp.createOptionsTable(defaultTable)
 	end
 
 	function proxyTable:showAllOptions(game)
-		proxyTable.disp("Available options: \n")
+		-- Display header using mapper color scheme
+		decho("<112,229,0>Setting:               <255,255,255>State:          <128,128,128>Option:\n")
+		decho("<128,128,128>" .. string.rep("-", 60) .. "\n")
+		
+		-- Display all options
 		for k, v in spairs(self[index]) do
 			if not game or not v.games or v.games[game] then
 				self.dispOption(k, v)
 			end
 		end
-		echo("\n")
 		for k, v in spairs(self["_customOptions"]) do
 			self.dispOption(k, v)
 		end
@@ -88,12 +91,41 @@ function mmp.createOptionsTable(defaultTable)
 
 		return t
 	end
+	
+	function proxyTable:getOptionDef(option)
+		-- Check custom options first
+		if self["_customOptions"][option] then
+			return self["_customOptions"][option]
+		-- Then check default options
+		elseif self[index][option] then
+			return self[index][option]
+		end
+		return nil
+	end
 
 	function proxyTable:setOption(option, value, silent)
 		if self[option] == nil then
 			proxyTable.disp("No such option!\n")
 			return
 		end
+		
+		-- Convert on/off to boolean for boolean options
+		local optionDef = self["_customOptions"][option] or self[index][option]
+		if optionDef and optionDef.allowedVarTypes and table.contains(optionDef.allowedVarTypes, "boolean") then
+			if value == "on" then
+				value = true
+			elseif value == "off" then
+				value = false
+			elseif type(value) == "string" then
+				-- Try to parse other string boolean values
+				local lowerValue = value:lower()
+				if lowerValue == "true" or lowerValue == "yes" or lowerValue == "1" then
+					value = true
+				elseif lowerValue == "false" or lowerValue == "no" or lowerValue == "0" then
+					value = false
+				end
+			end
+		end
 
 		-- otherwise, set the option
 		if self["_customOptions"][option] then

src/scripts/GoMudMapper/core/load_settings.lua

@@ -25,12 +25,12 @@ mmp.lagtable = {
     [4] = { description = "Bad. Terrible. Terribad.", time = 5 },
     [5] = { description = "Carrier Pigeon", time = 10 },
 }
-local newversion = "2.0.2"
+local newversion = "__VERSION__"
 if mmp.version and mmp.version ~= newversion then
     if not mmp.game then
         -- Check if this is GoMud via GMCP
-        if gmcp and gmcp.Game and gmcp.Game.Info and gmcp.Game.Info.engine == "GoMud" then
-            mmp.game = "GoMud"
+        if gmcp and gmcp.Game and gmcp.Game.Info and gmcp.Game.Info.engine then
+            mmp.setGame(gmcp.Game.Info.engine)
             mmp.echo("Mapper script updated - thanks! You don't need to restart.")
         else
             mmp.echo(
@@ -54,78 +54,55 @@ function mmp.startup()
     if not mmp.firstRun then
         return
     end
-    local private_settings = {}
 
-    --General settings
+    -- Load options from the simple definition table
+    local private_settings = mmp.convertOptionsFromDefinitions()
 
-    private_settings["echocolour"] = mmp.createOption(
-        "cyan",
-        mmp.changeEchoColour,
-        { "string" },
-        "Set the color for room number echos?",
-        function(newSetting)
-            return color_table[newSetting] ~= nil
+    mmp.settings = mmp.createOptionsTable(private_settings)
+    mmp.settings.disp = mmp.echo
+
+    -- Detect game type if not already set
+    if not mmp.game then
+        if gmcp and gmcp.Game and gmcp.Game.Info and gmcp.Game.Info.engine then
+            mmp.setGame(gmcp.Game.Info.engine)
+        else
+            mmp.game = false
         end
-    )
-    private_settings["crowdmap"] = mmp.createOption(
-        false,
-        mmp.changeMapSource,
-        { "boolean" },
-        "Use a crowd-sourced map instead of games default?",
-        nil,
-        { gomud = true }
-    )
-    private_settings["showcmds"] = mmp.createOption(true, mmp.changeBoolFunc, { "boolean" }, "Show walking commands?")
-    private_settings["laglevel"] = mmp.createOption(
-        1,
-        mmp.changeLaglevel,
-        { "number" },
-        "How laggy is your connection, (fast 1<->5 slow)?",
-        mmp.verifyLaglevel
-    )
-    private_settings["slowwalk"] =
-        mmp.createOption(false, mmp.setSlowWalk, { "boolean" }, "Walk slowly instead of as quick as possible?")
-    private_settings["fastwalk"] = mmp.createOption(
-        false,
-        mmp.changeBoolFunc,
-        { "boolean" },
-        "Walk as quick as possible instead of waiting for prompts?"
-    )
-    private_settings["updatemap"] =
-        mmp.createOption(true, mmp.changeUpdateMap, { "boolean" }, "Check for new maps from your MUD?")
-    private_settings["autopositionrooms"] = mmp.createOption(
-        true,
-        mmp.setAutoPositionRooms,
-        { "boolean" },
-        "Auto position rooms when mapping?",
-        nil,
-        { gomud = true }
-    )
-    private_settings["debug"] = mmp.createOption(false, mmp.changeBoolFunc, { "boolean" }, "Enable debug messages?")
+    end
 
-    --Settings that lock things
+    mmp.settings.dispOption = function(opt, val)
+        -- Format boolean values as on/off
+        local displayValue = val.value
+        if type(val.value) == "boolean" then
+            displayValue = val.value and "on" or "off"
+        end
 
-    private_settings["lockspecials"] =
-        mmp.createOption(false, mmp.lockSpecials, { "boolean" }, "Lock all special exits?")
+        -- Determine options available
+        local options = ""
+        if val.allowedVarTypes and table.contains(val.allowedVarTypes, "boolean") then
+            options = "on|off"
+        elseif opt == "laglevel" then
+            options = "1-5"
+        elseif opt == "echocolour" then
+            options = "See mcolor for options"
+        else
+            options = tostring(displayValue)
+        end
 
-    mmp.settings = mmp.createOptionsTable(private_settings)
-    mmp.settings.disp = mmp.echo
-    mmp.game = false
-    mmp.settings.dispOption = function(opt, val)
-        cecho(
-            "<green>"
-            .. val.use
-            .. "<white> ("
-            .. opt
-            .. ") "
-            .. string.rep(" ", 50 - val.use:len() - opt:len())
-            .. tostring(val.value)
-            .. "\n"
-        )
+        -- Display in columns: Setting, State, Option
+        -- Using mapper's color scheme: light green for settings, white for values, dim gray for options
+        decho(string.format("<112,229,0>%-22s <255,255,255>%-15s <128,128,128>%s\n", opt, tostring(displayValue), options))
     end
+
     mmp.settings.dispDefaultWriteError = function()
         mmp.echo("Please use the mconfig alias to set options!")
     end
+
+    -- Set environment colors if they're defined
+    if mmp.setEnvironmentColors then
+        mmp.setEnvironmentColors()
+    end
+
     raiseEvent("mmp areas changed")
     mmp.firstRun = false
     mmp.echon("Mudlet Mapper script for GoMud (" .. tostring(mmp.version) .. ") loaded! (")

src/scripts/GoMudMapper/core/mmp.packageinstalled.lua

@@ -0,0 +1,21 @@
+-- Event handler for when the package is installed or reinstalled
+-- This ensures the mapper reinitializes properly after package updates
+
+function mmp.onPackageInstalled(_, package)
+    -- Check if this is our package being installed
+    if package and (package:find("MudletMapper") or package:find("GoMudMapper")) then
+        -- Small delay to ensure all files are loaded
+        tempTimer(0.5, function()
+            if mmp and mmp.reload then
+                mmp.reload()
+                mmp.echo("GoMudMapper reinitialized after package installation.")
+            end
+        end)
+    end
+end
+
+-- Register the event handler
+if mmp.packageInstalledHandler then
+    killAnonymousEventHandler(mmp.packageInstalledHandler)
+end
+mmp.packageInstalledHandler = registerAnonymousEventHandler("sysInstallPackage", "mmp.onPackageInstalled")

src/scripts/GoMudMapper/core/mmp.setenvcolors.lua

@@ -0,0 +1,24 @@
+-- Generic function to set environment colors if mmp.colorcodes is defined
+function mmp.setEnvironmentColors()
+    -- Check if color codes are defined
+    if not mmp.colorcodes or type(mmp.colorcodes) ~= "table" then
+        return false
+    end
+    
+    -- Apply color codes to environments
+    local count = 0
+    for id, rgba in pairs(mmp.colorcodes) do
+        if type(rgba) == "table" and #rgba >= 3 then
+            -- setCustomEnvColor expects RGB values, with optional alpha (default 255)
+            local r, g, b, a = rgba[1], rgba[2], rgba[3], rgba[4] or 255
+            setCustomEnvColor(id, r, g, b, a)
+            count = count + 1
+        end
+    end
+    
+    if count > 0 and mmp.settings and mmp.settings.debug then
+        mmp.echo(string.format("Applied custom colors to %d environments", count))
+    end
+    
+    return count > 0
+end

src/scripts/GoMudMapper/core/mmp.setgame.lua

@@ -0,0 +1,23 @@
+-- Function to set the game, ensuring it's always lowercase
+function mmp.setGame(gameName)
+    if gameName and type(gameName) == "string" then
+        mmp.game = string.lower(gameName)
+        
+        -- Initialize game-specific data if needed
+        if mmp.game == "gomud" and mmp.registergomudenvdata then
+            mmp.registergomudenvdata(nil, mmp.game)
+        end
+        
+        if mmp.settings and mmp.settings.debug then
+            mmp.echo(string.format("Game set to: %s", mmp.game))
+        end
+        
+        -- Raise event for other scripts that might need to know
+        raiseEvent("mmp game detected", mmp.game)
+    else
+        mmp.game = false
+        if mmp.settings and mmp.settings.debug then
+            mmp.echo("Game detection cleared")
+        end
+    end
+end