Different Descriptions for Entering Room from Different Direction

[sooooocrates]

I am making a game in Quest (web version) and I would like to be able to display different room descriptions (or the equivalent scripted messages) based on the direction the player is entering the room from.

I have tried using the code from this old forum post with little success (I was able to get Quest 5.8 running on macOS through CrossOver, so that also might be complicating things). I have also tried wrapping my head around the other method mentioned in that forum post, but it both seems a little over my head and a lot of tedious work given how many rooms I would like this to work for.

Would there be a way to do something like this? Thanks for your help!

[KVonGit]

Hello.

Any approach would end up being a lot of tedious work, really. If you actually want each room's description to change based upon the direction the player used to get to that room, that would mean writing something specific for each possibility for each room.

Jay's method would be the best, mostly -- after a few minor changes.

Jay's post

I had a similar desire in my game (an old one that I never finished). The solution involved two parts:

1. Override the core exit types and add a field to indicate the direction.
2. Override the "go" command to store the last exit the player traversed into the pov object.

With those two pieces, you can then query "game.pov.lastExit.direction" to find out what the last direction was.

Here is the code to add to your game:

  <command name="go" pattern="[go]" unresolved="[UnresolvedLocation]">
    if (exit.visible) {
      if (exit.locked) {
        msg (exit.lockmessage)
      }
      else if (exit.runscript) {
        if (HasScript(exit, "script")) {
          do (exit, "script")
        }
      }
      else if (exit.lookonly) {
         msg ("[UnresolvedLocation]")
      } 
      else {
       game.pov.parent = exit.to
       game.pov.lastExit = exit
      }   
    } 
    else {   
      msg ("[UnresolvedLocation]")
    }
  </command>
  <type name="northdirection">
    <inherit name="compassdirection" />
    <alias>north</alias>
    <alt type="simplestringlist">n</alt>
    <direction>northdir</direction>
  </type>
  <type name="northwestdirection">
    <inherit name="compassdirection" />
    <alias>northwest</alias>
    <alt type="simplestringlist">nw</alt>
    <direction>northwestdir</direction>
  </type>
  <type name="westdirection">
    <inherit name="compassdirection" />
    <alias>west</alias>
    <alt type="simplestringlist">w</alt>
    <direction>westdir</direction>
  </type>
  <type name="southwestdirection">
    <inherit name="compassdirection" />
    <alias>southwest</alias>
    <alt type="simplestringlist">sw</alt>
    <direction>southwestdir</direction>
  </type>
  <type name="southdirection">
    <inherit name="compassdirection" />
    <alias>south</alias>
    <alt type="simplestringlist">s</alt>
    <direction>southdir</direction>
  </type>
  <type name="southeastdirection">
    <inherit name="compassdirection" />
    <alias>southeast</alias>
    <alt type="simplestringlist">se</alt>
    <direction>southeastdir</direction>
  </type>
  <type name="eastdirection">
    <inherit name="compassdirection" />
    <alias>east</alias>
    <alt type="simplestringlist">e</alt>
    <direction>eastdir</direction>
  </type>
  <type name="northeastdirection">
    <inherit name="compassdirection" />
    <alias>northeast</alias>
    <alt type="simplestringlist">ne</alt>
    <direction>northeastdir</direction>
  </type>
  <type name="updirection">
    <inherit name="updowndirection" />
    <alias>up</alias>
    <alt type="simplestringlist">u</alt>
    <direction>updir</direction>
  </type>
  <type name="downdirection">
    <inherit name="updowndirection" />
    <alias>down</alias>
    <alt type="simplestringlist">d</alt>
    <direction>downdir</direction>
  </type>
  <type name="indirection">
    <inherit name="inoutdirection" />
    <alias>in</alias>
    <alt type="simplestringlist"></alt>
    <direction>indir</direction>
  </type>
  <type name="outdirection">
    <inherit name="inoutdirection" />
    <alias>out</alias>
    <alt type="simplestringlist">o</alt>
    <direction>outdir</direction>
  </type>

The direction fields have names like "northdir", "southdir", etc. I decided to go that route rather than using (say) the "alias" field, as those other fields were user-facing and would be changed if the game were ever translated to a non-English language.

Let me know if you need anything clarified. I believe if you just drop that in your game somewhere (e.g. before the closing element), then it should just work.

As always, be sure to backup your game before doing any major mods like this...

END OF JAY'S POST

---

Well.. Let me back up...

What is or isn't working for you? Here's what I ran into when I tried to create a game following those instructions while using the web editor just now:

• Can't name a new command go, because it already exists
  • get around this my naming it gomod or go2 or whatever floats your boat and isn't already defined in Quest =)
• Using the pattern [go] does not work. (It does not pass an exit argument to the script.) -> Error running script: Error compiling expression 'exit.visible': Unknown object or variable 'exit'
  • get around this by adding this to the game object's start script: gomod.pattern = go.pattern
• Can't create types online (and couldn't use the same names if we could do so)
  • get around this by simply using game.pov.lastExit.alias
    • Jay states the only reason he didn't use alias in his code was to make the code he posted easy to adapt to languages other than English.

So, we just need Jay's go command, except we'll name ours gomod, and we need to add gomod.pattern = go.pattern to the game's start script to set the pattern. Then, we can ignore all those direction types, and we just need to alter Jay's instruction: “query game.pov.lastExit.direction to find out what the last direction was.”

We will use alias rather than direction and save a lot of time and effort. We will query game.pov.lastExit.alias to find out what the last direction was.

...and this is the point where we will still need to write a little extra code to handle things.

NEW FUNCTION
name: OppoDir
type: string
parameters: dir

script:

dirs = NewStringDictionary()
dictionary add (dirs, "north", "south")
dictionary add (dirs, "south", "north")
dictionary add (dirs, "east", "west")
dictionary add (dirs, "west", "east")
dictionary add (dirs, "northwest", "southeast")
dictionary add (dirs, "southeast", "northwest")
dictionary add (dirs, "northeast", "southwest")
dictionary add (dirs, "southwest", "northeast")
dictionary add (dirs, "in", "out")
dictionary add (dirs, "out", "in")
dictionary add (dirs, "up", "underneath")
dictionary add (dirs, "down", "above")
if (StringDictionaryItem(dirs, dir) <> null) {
  return (StringDictionaryItem(dirs, dir))
}
return ("undefined")

Finally, we can actually start the real work, which is adding a script¹ for each room's description, using game.pov.lastExit.alias to know the direction entered to get to the room² along with the OppoDir function.

Example room description script:

came_from = "undefined"
if (not HasAttribute(game.pov, "lastExit")) {
  // The attribute will not exist when play begins. This avoids an error in that in case.
  came_from = "@@GAME_START@@"
}
else {
  came_from = OppoDir(game.pov.lastExit.alias)
}
if (came_from = "@@GAME_START@@") {
  // Do nothing, the game just started
}
else if (came_from = "undefined") {
  // The exit used was not listed in the OppoDir function
  msg ("You seem to appear out of nowhere!")
}
else {
  // In this example room, there are exits east and north
  if (came_from = "west") {
    // We entered WEST to get here
    msg ("You came here from the room which is east of this location.")
  }
  else if (came_from = "south") {
    // We entered SOUTH to get here
    msg ("The butler asks that you wipe your feet before the next time you come inside from the fields which are north from this room!")
  }
  else {
    msg ("You have entered from a direction which is listed in the OppoDir function, but was not handled in this room's script. Please submit a bug report.")
  }
}

---

OR...

... if you're just wanting to tack on an extra line that prints when entering every room with a default string like "You just entered from...", then that wouldn't be very hard, but it would require:

• the gomod command (from Jay's post)

    if (exit.visible) {
      if (exit.locked) {
        msg (exit.lockmessage)
      }
      else if (exit.runscript) {
        if (HasScript(exit, "script")) {
          do (exit, "script")
        }
      }
      else if (exit.lookonly) {
         msg ("[UnresolvedLocation]")
      } 
      else {
       game.pov.parent = exit.to
       game.pov.lastExit = exit
      }   
    } 
    else {   
      msg ("[UnresolvedLocation]")
    }

• the OppoDir function (from above)
• a script when entering rooms (set on the game object) which:
  • checks that there is an opposite direction defined before attempting to print anything
  • prints a default message, same for each room (except the direction we enter from isn't the same, of course)

Script when entering a room on the game object:

came_from = "undefined"
if (not HasAttribute(game.pov, "lastExit")) {
  // The attribute will not exist when play begins. This avoids an error in that in case.
  came_from = "@@GAME_START@@"
}
else {
  came_from = OppoDir(game.pov.lastExit.alias)
}
if (came_from = "@@GAME_START@@") {
  // Do nothing, the game just started
}
else if (came_from = "undefined") {
  // The exit used was not listed in the OppoDir function
  msg ("You seem to appear out of nowhere!")
}
else {
  msg ("You enter from " + came_from + ".")
}

Footnotes

1. We could also use text processor commands in a text attribute for room descriptions, but it seems it would be more complicated in this case ↩

2. Assuming this isn't the beginning of the game or that the last exit didn't use a script instead of the defaults, and the example room script will check for that ↩

[sooooocrates]

I see that I had that backward, and the change works! Thank you so much again!

[KVonGit]

If you want to have a script like this in more than one room, I think I just came up with a way to do that without having to put all that code in each room's description script.

[sooooocrates]

That is my plan! So that would certainly be helpful.

[KVonGit]

I created a function named PrintCameFrom with no type and one parameter named args.

With this function, you could change your room's description script to this:

options = NewStringDictionary()
dictionary add (options, "above", "You came here from Apartment.")
dictionary add (options, "south", "You came from Osage.")
dictionary add (options, "north", "You came from Pine.")
dictionary add (options, "east", "You came from S 43rd.")
// unlisted is optional. If not included here, nothing will print if the direction is unlisted
dictionary add (options, "unlisted", "You seem to appear out of nowhere!")
// unresolved is optional. If not included here, nothing will print if the direction is unresolved (meaning the direction is listed, but not handled in this script)
dictionary add (options, "unresolved", "You have entered from a direction which is listed in the OppoDir function, but was not handled in this room's script. Please submit a bug report.")
PrintCameFrom (options)
msg ("{once:The door slams shut behind you despite your best effort to close it gently while also clipping your keys to your beltloop. You look out on the street from four steps up the front stoop. You try to look past the small front yard that the landlord is hell bent on ignoring, strewn with trash and leaves.} Sunlight streams through the branches of the honey locust tree in front of you, casting a shifting pattern on the front door.")

It would also make it so you could add similar code to other rooms' description scripts.

Function name: PrintCameFrom

• type: none (leave it at the default)
• parameters: args
• script:

came_from = "unlisted"
if (not HasAttribute(game.pov, "lastExit")) {
  // The attribute will not exist when play begins. This avoids an error in that in case.
  came_from = "@@GAME_START@@"
}
else {
  came_from = OppoDir(game.pov.lastExit.alias)
}
if (came_from = "@@GAME_START@@") {
  // Do nothing, the game just started
}
else if (came_from = "unlisted") {
  // The exit used was not listed in the OppoDir function's directions dictionary (which might be intentional)
  // To debug, uncomment the next line and check the log during play
  // Log ("PrintCameFrom: came_from (" + came_from + ") is unlisted")
  if (DictionaryContains(args, "unlisted")) {
    msg (StringDictionaryItem(args, "unlisted"))
  }
}
else {
  if (DictionaryContains(args, came_from)) {
    msg (StringDictionaryItem(args, came_from))
  }
  else {
    // The direction is listed in OppoDirs, but the room script does not handle it specifically (which might be intentional)
    // To debug, uncomment the next line and check the log during play
    // Log ("PrintCameFrom: came_from (" + came_from + ") is unresolved")
    if (DictionaryContains(args, "unresolved")) {
      msg (StringDictionaryItem(args, "unresolved"))
    }
  }
}

[sooooocrates]

This is also working great! I can see how it is simpler, and will certainly be easier to get working with multiple rooms.

[Pertex]

@KVonGit What do you think about this idea? It's not easy to do it in the webeditor.

• First import function GetRoomDescription into your game
• Change it this way (not tested):

    <![CDATA[
    fulldesc = ""
    
    if (CheckDarkness()) {
      if (HasString(game.pov.parent, "darkroomdescription")) {
        if (LengthOf(game.pov.parent.darkroomdescription) > 0) {
          fulldesc = game.pov.parent.darkroomdescription
        }
      }
      // Added by The Pixie to correct what appears to be a bug
      if (fulldesc = "") fulldesc = DynamicTemplate("LookAtDarkness", game.pov.parent)
    }
    else {  //Pertex: this is new 
		if (HasString(game.pov, "lastExit") and HasString(game.pov.parent, "description"+game.pov.lastExit)) {
			lastExit=game.pov.lastExit
			fulldesc=GetString(game.pov.parent,"description"+lastExit)
		} //till here
        else if (HasString(game.pov.parent, "description")) {
         if (LengthOf(game.pov.parent.description) > 0) {
             fulldesc = game.pov.parent.description
         }
       }
    }
    
    if (game.appendobjectdescription) {
      foreach (val, ScopeVisibleNotHeld()) {
        if (HasString(val, "inroomdescription")) {
          if (LengthOf(val.inroomdescription) > 0 and val <> game.pov) {
            fulldesc = fulldesc + " " + val.inroomdescription
          }
        }
      }
    }
    
    return (Trim(fulldesc))
    ]]>
  </function>

• Then add in every room you want a text attribute 'description'+exit like 'descriptionwest' when you enter the room from the west. If such an attribute doesn't exist, it prints the standard description.

EDIT: OK, it's not possible to overwrite functions in the webeditor :-(

[KVonGit]

not possible to overwrite functions in the webeditor :-(

Correct... Can't do it (yet). Great approach, though!

[KVonGit]

Here's a different (fun little) way things could be handled.

• Modify the changedparent script on the player object, adding a lastparent object attribute to the player
• In this example, use a simple "Entering a room" script on the game object, to print a default message using GetDisplayName(game.pov.lastparent) (if it exists) after entering each room

lastparent.zip

<!--Saved by Quest 5.9.9166.36226-->
<asl version="580">
  <include ref="English.aslx" />
  <include ref="Core.aslx" />
  <game name="lastparent">
    <gameid>666abc76-c241-4d55-97d6-370f6433ff13</gameid>
    <version>1.0</version>
    <firstpublished>2025</firstpublished>
    <start type="script"><![CDATA[
      game.pov.changedparent => {
        if (game.pov = this) {
          if (IsDefined("oldvalue")) {
            // The next line is new
            game.pov.lastparent = oldvalue
            OnEnterRoom (oldvalue)
          }
          else {
            OnEnterRoom (null)
          }
          if (game.gridmap) {
            MergePOVCoordinates
          }
        }
        this.hasbeenmoved = true
      }
    ]]></start>
    <roomenter type="script"><![CDATA[
      if (HasAttribute(game.pov, "lastparent")) {
        msg ("<b>You came here from " + GetDisplayName(game.pov.lastparent) + ".</b>")
      }
    ]]></roomenter>
  </game>
  <object name="living room">
    <inherit name="editor_room" />
    <usedefaultprefix type="boolean">false</usedefaultprefix>
    <prefix>the</prefix>
    <object name="player">
      <inherit name="editor_object" />
      <inherit name="editor_player" />
    </object>
    <exit alias="north" to="outside">
      <inherit name="northdirection" />
      <suffix>(outside)</suffix>
    </exit>
    <exit alias="south" to="kitchen">
      <inherit name="southdirection" />
      <suffix>(to the kitchen)</suffix>
    </exit>
    <exit alias="west" to="hallway">
      <inherit name="westdirection" />
      <suffix>(to the hallway)</suffix>
    </exit>
  </object>
  <object name="hallway">
    <inherit name="editor_room" />
    <usedefaultprefix type="boolean">false</usedefaultprefix>
    <prefix>the</prefix>
    <exit alias="east" to="living room">
      <inherit name="eastdirection" />
      <suffix>(to the living room)</suffix>
    </exit>
  </object>
  <object name="kitchen">
    <inherit name="editor_room" />
    <usedefaultprefix type="boolean">false</usedefaultprefix>
    <prefix>the</prefix>
    <exit alias="north" to="living room">
      <inherit name="northdirection" />
      <suffix>(to the lving room)</suffix>
    </exit>
  </object>
  <object name="outside">
    <inherit name="editor_room" />
    <usedefaultprefix type="boolean">false</usedefaultprefix>
    <descprefix>{=WriteVerb(game.pov, "be")}</descprefix>
    <exit alias="south" to="living room">
      <inherit name="southdirection" />
      <suffix>(to the living room)</suffix>
    </exit>
  </object>
</asl>

---

You are in the living room.
You can go north (outside), south (to the kitchen) or west (to the hallway).

> go north

You are outside.
You can go south (to the living room).
You came here from the living room.

> go south

You are in the living room.
You can go north (outside), south (to the kitchen) or west (to the hallway).
You came here from outside.

> go south

You are in the kitchen.
You can go north (to the lving room).
You came here from the living room.

> go north

You are in the living room.
You can go north (outside), south (to the kitchen) or west (to the hallway).
You came here from the kitchen.

> go west

You are in the hallway.
You can go east (to the living room).
You came here from the living room.

> go east

You are in the living room.
You can go north (outside), south (to the kitchen) or west (to the hallway).
You came here from the hallway.

---

• This could be modified to use room descriptions for this instead of using the game's "entering a room" script.
• The lastparent object could be used in a script to determine the direction the lastparent is from the current parent.