Just wanted to see if anyone had any thoughts about this, good, bad, or indifferent:
I was playing En Garde the other day and I had an idea. En Garde is an Inform 7 game which replaces the parser command line with colored buttons using Vorple. This is a cute gimmick in the game, as buttons are slowly added and eventually labeled as the game progesses. However, those buttons could have easily been in addition to the parser command line as opposed to replacing it.
In a nutshell, I’m pondering if buttons for navigation and simple commands could be introduced in the beginning orientation, and then slowly eliminated as the game explained how each was more flexible (and attributable towards specific NPCs and objects) as a parser entry.
For example, a game begins in a room with a single object and a single exit to the north. The only interaction points on the screen (other than an unobtrusive cursor at the bottom) would be three command buttons, “take,” “look,” and “north.”
When “take” is selected, the new command buttons “drop” and “inventory” appear. When the player selects north, they move north to the next room, which contains a staircase, and the “south” and “up” buttons are added.
In this way, within a few rooms all the core commands typical to parser games are introduced to the player in an intuitive way. This would continue long enough for the uninitiated to get the hang of navigation and basic inquiry and interaction.
Once all of the core commands are introduced and the player solves a couple of trivial puzzles using these command buttons, they move into the next section. The first room in this section would have multiple things to look at. Clicking the look command would result in a message asking “I don’t know what you wish to look at: X, Y, Z1, Z2, or Y?” At this point, the game would then introduce and highlight the parser, explaining how it allows you to specify which thing to look at. The game would then prompt the player to look at two of the things mentioned with the parser, explicitly demonstrating how those commands could be entered. After successfully examining those two things using the “look X” command in the parser, and then briefly explaining to the player the sorts of things they can look at going forward, the “Look” button fades away forever. The next room has multiple objects, making the simple “take” button similarly insufficient for the task. Rinse and repeat the same method used with the Look command. After demonstrating understanding and proficiency, the “take” button fades. Variate on this theme for each basic command button, belaboring the point a little less each time.
Eventually, you would be left with only the navigational buttons and the parser. After demonstrating how direction commands can be entered into the parser (and also abbreviated), the game would then give you the option to remove the navigational buttons or continue with them if you prefer (although you could simply leave the navigational buttons up while you still type north, south, etc. anyway).
All parser functions would function at the very outset of the game, and using the parser immediately (and correctly) would prompt the game into asking if you wish to skip the tutorial, but if you don’t know to use the Parser, this option would appropriately not appear. For those skipping the tutorial, this would leave a fairly simple set of rooms for the parser pro to zip right through to get to the game proper. Demonstrating understanding of the parser by using it as directed would be necessary to not only remove the associated buttons, but to advance the game forward. Demonstrating this immediately simply expedites this.
I feel this might be a fantastic way to ease those new to Parser games into the format. The game starts as an intuitive point-and-click with an optional parser (assuming they even notice the cursor at first) and by the end of the tutorial section transforms to a nearly parser-only game with an optional N-S-E-W navigational pad.
Assuming the player is a novice and works their way through the tutorial, the game gives them enough information to encourage them to continue exploring the format themselves. Specifically, after the game allows the player to choose whether to keep the navigational pad or not, the game gives a few examples of actions the parser will recognize that were not in the tutorial (dance and throw for example) and then hints that there are yet more possible commands and encourages the player to explore possibilities with the parser. Furthermore, as a final crutch, the game lets the player know that typing the word ‘actions’ into the parser will list all of the commands (and associated abbreviations) discovered by the player thus far, but not necessarily an exhaustive list of all the commands implemented in the game. Each new command discovered is another added to the list.
Other common IF tropes could be explored as the game progressed, with the goal of equipping the player with the skills, vocabulary, and general familiarity needed to approach most other parser works with some confidence. Ideally, the game would include enough depth and hidden content to keep those already parser pros engaged in the story and game anyway.
Obviously, this is likely a fairly one-off project and likely would be too much work to regularly implement into the beginning of all but the largest IF projects. However, this could be an excellent “First IF parser Game” to refer to for those in our lives who’ve never touched a single IF title. Consider it a possible parser gateway game, lol. Feel free to dissuade me and disparage the idea as a whole, both actions could be warranted, but be aware that I’ll probably pursue it regardless. If you want to weigh in with suggestions for improvements, possible pitfalls, or use-cases I haven’t considered, I’m definitely all ears.
Thanks for reading!