TinTin++ Mud Client Manual
         MAP

Command: #map

         The map command is the backbone of the auto mapping feature.

         #map at <exit|vnum> <command>
           Execute the command at the given exit or vnum.

         #map center <x> <y> <z>
           Sets displaying center of the map viewer, default is 0 0 0.

         #map color <field> [value]
           Sets the map color for the given color field.

         #map create <size>
           Creates a new map and room 1. The default size is 50000 rooms.

         #map destroy {area|world} <name>
           Deletes the map or given area.

         #map delete <exit|vnum>
           Deletes the room for the given exit or vnum.

         #map dig <exit|vnum> [new|<vnum>]
           Creates an exit for the given exit name. If no valid exit name
           is given or no existing room is found a new room is created.
           Useful for portal links and other alternative forms of
           transportation. If the 'new' argument is provided all existing
           rooms are ignored and a new room is created. If a room vnum is
           given as the second argument an exit will be created leading
           to the given room vnum. If the room vnum doesn't exist a new
           room is created.

         #map entrance <exit> [option] [arg]
           Set the entrance data for the given exit. You must specify a
           valid two-way exit for this to work.

         #map exit <exit> <option> <arg>
           Set the exit data. Useful with a closed door where you can
           set the exit command: '#map exit e command {open east;e}'.
           Use #map exit <exit> for a list of available options.

         #map exitflag <exit> <AVOID|BLOCK|HIDE|INVIS> [on|off]
           Set exit flags. See #map roomflag for more info.

         #map explore <exit>
           Explores the given exit until a dead end or an
           intersection is found. The route is stored in #path and can
           subsequently be used with #walk. Useful for long roads.

         #map find <name> <exits> <desc> <area> <note> <terrain> <flag>
           searches for the given room name. If found the shortest path
           from your current location to the destination is calculated.
           The route is stored in #path and can subsequently be used with
           the various #path commands. If <exits> is provided all exits
           must be matched, if <roomdesc>, <roomarea> or <roomnote> or
           <roomterrain> or <roomflag> is provided these are matched as
           well against the room to be found.
           These options are also available to the at, delete, goto
           link, list and run commands.

         #map flag asciigraphics
           Takes up more space but draws a more detailed
           map that displays the ne se sw nw exits and room symbols.

         #map flag asciivnums
           Display room vnums if asciigraphics is enabled.

         #map flag nofollow
           When you enter movement commands the map will no longer
           automatically follow along. Useful for MSDP and GMCP
           automapping scripts.

         #map flag static
           Will make the map static so new rooms are no longer
           created when walking into an unmapped direction. Useful when
           you're done mapping and regularly bump into walls accidentally
           creating a new room. #map dig etc will still work.

         #map flag vtgraphics
           Enables vt line drawing on some terminals

         #map flag vtmap
           Will enable the vtmap which is shown in the top split
           screen if you have one. You can create a 16 rows high top
           screen by using '#split 16 1'.

         #map get <option> <variable> [vnum]
           Store a map value into a variable, if no vnum is given the
           current room is used. Use 'all' as the option to store all
           values as a table.

         #map get roomexits <variable>
           Store all room exits into variable.

         #map global <room vnum>
           Set the vnum of a room that contains global
           exits, for example an exit named 'recall' that leads to the
           recall location. The room can contain multiple exits, in case
           there are multiple commands that are similar to recall.

         #map goto <room vnum> [dig]
           Takes you to the given room vnum, with the
           dig argument a new room will be created if none exists.

         #map goto <name> <exits> <desc> <area> <note> <terrain>
           Takes you to the given room name, if you provide exits those
           must match.

         #map info
           Gives information about the map and room you are in.

         #map insert <direction> [roomflag]
           Insert a room in the given direction. Most useful for inserting
           void rooms.

         #map jump <x> <y> <z>
           Jump to the given coordinate, which is relative
           to your current room.

         #map landmark <name> <vnum> [description] [size]
           Creates an alias to target the provided room vnum. The
           description is optional and should be brief. The size
           determines from how many rooms away the landmark can be
           seen.

         #map leave
           Makes you leave the map. Useful when entering a maze. You
           can return to your last known room using #map return.

         #map legend <legend> [symbols|reset]
         #map legend <legend> <index> [symbol]
           There are several legends and sub-legends available for
           drawing maps to suit personal preference and character sets.
           Use #map legend all to see the legend as currently defined.
           Use #map legend <legend> <reset> to set the default legend.
           Use #map legend <legend> <character list> to create a custom
           legend. Custom legends are automatically saved and loaded by
           using #map read and #map write.

         #map link <direction> <room name> [both]
           Links two rooms. If the both
           argument and a valid direction is given the link is two ways.

         #map list <name> <exits> <desc> <area> <note> <terrain>
           Lists all matching rooms and their distance. The following
           search keywords are supported.

           {roomarea}    <arg> will list rooms with matching area name.
           {roomdesc}    <arg> will list rooms with matching room desc.
           {roomexits}   <arg> will list rooms with identical room exits.
           {roomflag}    <arg> will list rooms with matching room flags.
           {roomid}      <arg> will list rooms with identical id name.
           {roomname}    <arg> will list rooms with matching room name.
           {roomnote}    <arg> will list rooms with matching room note.
           {roomterrain} <arg> will list rooms with matching room terrain.
           {variable}    <arg> will save the output to given variable.

         #map map <rows> <cols> <append|overwrite|list|variable> <name>
           Display a drawing of the map of the given height and width.
           All arguments are optional. If {rows} or {cols} are set to {}
           or {0} they will use the scrolling window size as the default.
           If {rows} or {cols} are a negative number this number is
           subtracted from the scrolling window size.

         #map map <rows> <cols> draw <square>
           Display a drawing of the map of the given height and width.
           The square argument exists of 4 numbers formulating the top
           left corner and bottom right corner of a square.

           If you use {append|overwrite} the map is written to the specified
           file name which must be given as the 4th argument.
           If you use {list|variable} the map is saved to the specified
           variable name.

         #map move <direction>
           This does the same as an actual movement
           command, updating your location on the map and creating new
           rooms. Useful when you are following someone and want the map
           to follow. You will need to create actions using '#map move',
           for this to work.

         #map offset <row> <col> <row> <col>
           Define the offset of the vtmap as a square. Without an argument
           it defaults to the entire top split region.

         #map read <filename>
           Will load the given map file.

         #map resize <size>
           Resize the map, setting the maximum number of rooms.

         #map return
           Returns you to your last known room after leaving the map
           or loading a map.

         #map roomflag <flags> <get|on|off>
         
         #map roomflag avoid
           When set, '#map find' will avoid a route leading
           through that room. Useful for locked doors, etc.
         #map roomflag block
           When set the automapper will prevent movement into or through
           the room. Useful for death traps.
         #map roomflag hide
           When set, '#map' will not display the map beyond
           this room. When mapping overlapping areas or areas that aren't
           build consistently you need this flag as well to stop
           auto-linking, unless you use void rooms.
         #map roomflag invis
           When set the room will be colored with the INVIS color.
         #map roomflag leave
           When entering a room with this flag, you will
           automatically leave the map. Useful when set at the entrance
           of an unmappable maze.
         #map roomflag noglobal
           This marks a room as not allowing global
           transportation, like norecall rooms that block recall.
         #map roomflag void
           When set the room becomes a spacing room that can
           be used to connect otherwise overlapping areas. A void room
           should only have two exits. When entering a void room you are
           moved to the connecting room until you enter a non void room.
         #map roomflag static
           When set the room will no longer be autolinked
           when walking around. Useful for mapping mazes.

         #map run <room name> [delay]
           Calculates the shortest path to the destination and walks you
           there. The delay is optional and requires using braces. Besides
           the room name a list of exits can be provided for more precise
           matching.

         #map set <option> <value> [vnum]
           Set a map value for your current room, or given room if a room
           vnum is provided.

         #map sync <filename>
           Similar to #map read except the current map won't be unloaded
           or overwritten.

         #map terrain <name> <symbol> [flag]
           Set the terrain symbol and flag.

         #map terrain <name> <symbol> [DENSE|SPARSE|SCANT]
           Determine symbol density, omit for the default.

         #map terrain <name> <symbol> [NARROW|WIDE|VAST]
           Determine symbol spread range, omit for the default.

         #map terrain <name> <symbol> [FADEIN|FADEOUT]
           Determine symbol spread density, omit for the default.

         #map terrain <name> <symbol> [DOUBLE]
           You're using two characters for the symbol.

         #map travel <direction> <delay>
           Follows the direction until a dead end or an intersection is
           found. Use braces around the direction if you use the delay,
           which will add the given delay between movements.
           Use #path stop to stop a delayed run.

         #map undo
           Will undo your last move. If this created a room or a link
           they will be deleted, otherwise you'll simply move back a
           room. Useful if you walked into a non existant direction.

         #map uninsert <direction>
           Exact opposite of the insert command.

         #map unlandmark <name>
           Removes a landmark.

         #map unlink <direction> [both]
           Will remove the exit, this isn't two way so you can have the
           properly display no exit rooms and mazes.
           If you use the both argument the exit is removed two-ways.

         #map unterrain <name>
           Removes a terrain.

         #map update [now]
           Sets the vtmap to update within the next 0.1 seconds, or
           instantly with the now argument.

         #map vnum <low> [high]
           Change the room vnum to the given number, if a range is
           provided the first available room in that range is selected.

         #map write <filename> [force]
           Will save the map, if you want to save a map to a .tin file
           you must provide the {force} argument.

Related: path and pathdir.