How can I implement a “BeforeCommand” hook in Quest?

[euclidaeun]

Hi everyone,

I want to trigger a check before any player command is processed, so I can modify or override the parser output based on game state. Essentially, I’m looking for something like a global BeforeCommand hook.

Here are some example scenarios I want to implement:

1. Drunk player:

   • Player has drunk alcohol.
   • Each letter typed has a 1% chance to scramble.
   • The player can still type the full word if lucky.

2. Fire rooms:

   • Out of 100 rooms, 15 are “fire” rooms.
   • Whenever the player types a command in a fire room, the output is replaced with simply “ouch”.

3. Vampire enchantment:

   • Player is enchanted by a vampire.
   • All player commands are replaced with pre-defined actions like “player walks to dining table”, “player eats roast turkey”, etc.
   • Player must type the correct parser command to break the enchantment.

My question:

• Does Quest have a built-in way to run a global pre-command script?
• If not, what’s the recommended way to implement something like this without editing every single command or relying on a room-specific getinput loop?

Thanks for any guidance!

P.S. The question was analysed and rephrased by a bot.
P.S. I’m not a coder, so it might take me many months to try out solutions before I can reply or confirm whether they work.

[KVonGit]

The function that actually handles commands is ResolveNextName. It's the first modified function in this file: https://github.com/KVonGit/zork1/blob/quest5_port/Quest5_Port/HACKS.aslx

In that hack, it's checking if the room or any objects have an ACTION attribute. If something has an ACTION attribute which returns true, nothing else will run after that point.

You could use your own conditional checks at every point where I have HANDLED_BY_ACTION = Eval(blahblahblah). (NOTE: I might need to add an extra step when there is text in the command, like ASK BOB ABOUT SO AND SO. I have not tested that at all yet.)

---

There might a better approach, but this seems to work, as far as I've tested things.

[euclidaeun]

Your link stop working, but I am guessing it is the same as your other action attribute post.

beforecommand #1626
reaction/action attribute #1623
get input https://textadventures.co.uk/games/view/9tlenlari02vr69mtdvb4q/loud-room-tester

So, beforecommand and reaction attribute do solve fire rooms, vampire enchantment, and many others, as these scenarios simply requires quest app to skip past the parser output and write/trigger a different prewritten output.
But they do not solve scramble drunk, loud room repeating words or any scenarios that requires improvisation.
What is the internal function that deals with player typed words?

The bot leads me to a dead end with this funny code, attempting to modify player typed words.
In ResolveNextName internal function:

resolvedall = false 
game.pov.currentcommand = game.pov.currentcommand+game.pov.currentcommand

The get input from loud room tester works, but it is too long for me to understand, and if it requires me to trigger get input on every turn, it just sounds confusingly difficult, I am not sure if that would affects other functions or would multiple get input clashes with each other?

[KVonGit]

Oh, whoops, sorry! I combined all the library files into the main game file. Seems easier to have all the code in one file during the creation process.

This link should always lead to the Quest 5 port's game folder: https://github.com/KVonGit/zork1/tree/quest5_port/Quest5_Port

I've got a bunch of extra port-specific code added to the relevant code now, too, now that I think about it. This should eventually be polished into more Quest-friendly code, though -- after I get all the ZIL routines copied over to Quest scripts.

I only use get input in that one scenario, because that's what the ZIL does in that same spot. It's just reading the input and working with it before allowing the parser to do anything. Having said that, it is still kind of a pain in the butt to code it using an "ACTION" function to cover all the possible commands in one script. Edit: almost as much of a pain as that get input stuff, ha-ha.

I think maybe the best approach would be a new boolean attribute on the game object, something like game.handled_by_action. Then, have the ResolveNextName function check for that attribute value before proceeding as normal (always resetting the value to false whenever it is true, then exiting the script). Then, we could basically use verbs on objects and/or room commands, and just change that to true when we want to interrupt the default command-handling.

Maybe... Something like that. =)

[euclidaeun]

KV is right in that ResolveNextName internal function is responsible for triggering the player's typed words.
To access any internal function, go to bottom left of quest app, click filter and click show library elements, type in search bar 'Resolve' and click copy button, unclick library elements.

I had imagined the loud room tester's get input works, but the bot clarified that it never mutate the player's command, the parser command was actually skipped, and it printed a message/ trigger an action based on the input text in get input.

So, because there have never been a first example of a player's typed words being modified and triggered output by any game , it can be deemed mission impossible or that the coding required is extensive that changes how the quest app works.

In our desired Commandchange code, we want to be able to read player's input and then connect to verbs and command patterns. Whereas get input only only read player's input and can't connect with the verbs and command patterns. Loud room tester only works because most player's actions can't actually trigger which fits its theme but I desire a theme where all actions are still available.

---

Next, I have tried the bot's beforecommand.

It works. but the coding is verbose unlike KV's reaction attribute.

  if (HasScript(game.pov.currentcommandpattern, "script")) {
    if (HasAttribute(game.pov.parent, "on_fire")) {
      if (game.pov.parent.on_fire = true) {
        if (GetBoolean(game.pov.currentcommandpattern, "block_on_fire")) {
          msg ("Player: Ouch fire!")
        }
        else {
          // This is the bit that actually runs the commands
          do (game.pov.currentcommandpattern, "script", game.pov.currentcommandresolvedelements)
        }
      }
      else {
        // This is the bit that actually runs the commands
        do (game.pov.currentcommandpattern, "script", game.pov.currentcommandresolvedelements)
      }
    }
    else {
      // This is the bit that actually runs the commands
      do (game.pov.currentcommandpattern, "script", game.pov.currentcommandresolvedelements)
    }
  }

Remember, this is only for fire scenario, I wanted three scenarios as demonstration, but eventually, I expect 10+ scenarios to continously run in the game which is going to be extremely long to code and vulnerable to careless mistakes.

So for KV's reaction attribute.
It is ultra long as well, but it can run all reactions attributes from all objects in the room, so if they do block the player's command, they simply needs to send game.stop_command = true and block in ResolveNextName, so even if there are 10+ scenario scripts, they only have to send game.stop_command = true instead of doing these giant if-else nests in beforecommand example.

The attached code is the inferior example, I ran out of energy to do KV's superior reaction attribute example.

test18 (fire before command inferior example).zip

Although it is inferior, it teaches an important rule

        if (GetBoolean(game.pov.currentcommandpattern, "block_on_fire")) {
          msg ("Player: Ouch fire!")
        }

This means you have to add block_on_fire attribute on each verb and command patterns.
Yes it is tedious, but if you don't do so, the whole game is locked, because the game ignores your movement, look at, take, drop and "solving actions".
Solving actions refers to use antidote for drunk, throw water for fire, look at mirror to break vampire enchantment.
And since no codes that exists can mutate commands, if player types "gsnogsd", it will just print "I dun understand" instead of being ignored.

TLDR version: reaction/action attribute #1623 works

[KVonGit]

Yeah, what I've got going on right now is a rough copy of Infocom's ZIL code, as far as handling the "ACTION" property is concerned.

I think this test game is more Quest-like:

Details

<!--Saved by Quest 5.9.9166.36226-->
<asl version="580">
  <include ref="English.aslx" />
  <include ref="Core.aslx" />
  <game name="After Reading a Command">
    <gameid>e42d0807-d5e6-4801-a023-337e42f353fd</gameid>
    <version>1.1</version>
    <firstpublished>2026</firstpublished>
    <attr name="after_reading_command" type="script">
      msg("command: " + command)
      msg("resolved objects: " + resolved)
      if (game.pov.parent = room) {
        msg ("This message will not interrupt the normal command handling process.\r\n")
      }
      if (GetBoolean(game.pov,"unconscious") and not command = save) {
        msg ("")
        msg ("You can't do jack squat right now. You are unconscious!")
        game.interrupt_command = true
      }
    </attr>
  </game>
  <command name="jump">
    <pattern type="string">^jump$</pattern>
    <script><![CDATA[
      msg ("You jump and hit your head on the ceiling. You are now unconscious.")
      game.pov.unconscious = true
      SetTurnTimeout (4) {
        msg ("<br/>You have regained consciousness.<br/>")
        game.pov.unconscious = false
      }
    ]]></script>
  </command>
  <object name="room">
    <inherit name="editor_room" />
    <object name="player">
      <inherit name="editor_object" />
      <inherit name="editor_player" />
    </object>
  </object>
  <function name="ResolveNextName"><![CDATA[
    resolvedall = false
    queuetype = TypeOf(game.pov, "currentcommandvarlistqueue")
    if (queuetype = "stringlist") {
      queuelength = ListCount(game.pov.currentcommandvarlistqueue)
      if (queuelength > 0) {
        // Pop next variable off the queue
        var = StringListItem(game.pov.currentcommandvarlistqueue, 0)
        if (queuelength = 1) {
          game.pov.currentcommandvarlistqueue = null
        }
        else {
          newqueue = NewStringList()
          for (i, 1, queuelength - 1) {
            list add (newqueue, StringListItem(game.pov.currentcommandvarlistqueue, i))
          }
          game.pov.currentcommandvarlistqueue = newqueue
        }
        // Resolve variable
        value = StringDictionaryItem(game.pov.currentcommandvarlist, var)
        if (value <> "") {
          result = null
          resolvinglist = false
          // This is to resolve issue 626
          if (StartsWith(var, "objectexit")) {
            result = ResolveName(var, value, "exit")
          }
          if (result = null) {
            if (StartsWith(var, "object")) {
              if (GetBoolean(game.pov.currentcommandpattern, "allow_all")) {
                scope = FilterByAttribute(GetScope("object", "", "object"), "scenery", false)
                game.pov.currentcommandpendingobjectscope = ListExclude(scope, FilterByAttribute(scope, "not_all", true))
                game.pov.currentcommandpendingvariable = var
                ResolveNameList (value, "object")
                resolvinglist = true
              }
              else if (HasScript(game.pov.currentcommandpattern, "multipleobjects")) {
                game.pov.currentcommandpendingobjectlist = NewObjectList()
                game.pov.currentcommandpendingvariable = var
                do (game.pov.currentcommandpattern, "multipleobjects")
                ResolveNameList (value, "object")
                resolvinglist = true
              }
              else {
                result = ResolveName(var, value, "object")
              }
            }
            else if (StartsWith(var, "exit")) {
              result = ResolveName(var, value, "exit")
            }
            else if (StartsWith(var, "text")) {
              result = StringDictionaryItem(game.pov.currentcommandvarlist, var)
            }
            else {
              error ("Unhandled command variable '" + var + "' - command variable names must begin with 'object', 'exit' or 'text'")
            }
          }
          // at this point, ResolveName has returned - either an object name, unresolved, or pending
          if (result = null) {
            if ((not resolvinglist) and LengthOf(GetString(game.pov, "currentcommandpendingvariable")) = 0) {
              UnresolvedCommand (value, var)
            }
          }
          else {
            AddToResolvedNames (var, result)
          }
        }
        else {
          ResolveNextName
        }
      }
      else {
        resolvedall = true
      }
    }
    else if (queuetype = "null") {
      resolvedall = true
    }
    else {
      error ("Invalid queue type")
    }
    if (resolvedall) {
      // All the objects have been resolved, so now we can actually do the command
      // TO DO: game.lastobjects should be game.pov.lastobjects
      game.lastobjects = game.pov.currentcommandresolvedobjects
      if (not DictionaryContains(game.pov.currentcommandresolvedelements, "multiple")) {
        dictionary add (game.pov.currentcommandresolvedelements, "multiple", false)
      }
      interrupted = false
      if (HasAttribute(game,"after_reading_command")) {
        do (game, "after_reading_command", QuickParams("command",game.pov.currentcommandpattern,"resolved",game.pov.currentcommandresolvedelements))
        if (GetBoolean(game, "interrupt_command")) {
          game.interrupt_command = false
          interrupted = true
        }
      }
      if (not GetBoolean(game.pov.currentcommandpattern, "isundo") and not interrupted) {
        if (LengthOf(game.pov.currentcommand) > 0) {
          start transaction (game.pov.currentcommand)
        }
      }
      if (not GetBoolean(game.pov.currentcommandpattern, "isoops") and not interrupted) {
        // TO DO: game.unresolved* should be game.pov.unresolved*
        game.unresolvedcommand = null
        game.unresolvedcommandvarlist = null
        game.unresolvedcommandkey = null
      }
      if (DictionaryContains(game.pov.currentcommandresolvedelements, "object") and not interrupted) {
        game.text_processor_this = ObjectDictionaryItem(game.pov.currentcommandresolvedelements, "object")
      }
      else if (DictionaryContains(game.pov.currentcommandresolvedelements, "object1") and not interrupted) {
        game.text_processor_this = ObjectDictionaryItem(game.pov.currentcommandresolvedelements, "object1")
      }
      if (HasScript(game.pov.currentcommandpattern, "script") and not interrupted) {
        // This is the bit that actually runs the commands
        do (game.pov.currentcommandpattern, "script", game.pov.currentcommandresolvedelements)
      }
      //
      // Setting game.runturnscripts to true to run turn scripts after ShowMenu , show menu, ask, or Ask.
      // This works in conjuction with FinishTurn, which has also been modified as of Quest 5.8.
      // - KV, 2018/05/25
      game.runturnscripts = true
      FinishTurn
      HandleNextCommandQueueItem
    }
  ]]></function>
</asl>

We could just create functions to run from the game.after_reading_command script, so it wouldn't be all cluttered with all the code to handle everything.

EDIT: Just updated the test game's code a little.