Authoring systems which can only create parser, or choice, or hybrid games

General IF Community Resources
1

This was a wiki post but I’ll remove the “wiki” functionality now. Many thanks to everybody who helped! :+1:

As part of a project on IFWiki we were trying automatically to classify as many games as possible as “Parser”, “Choice”, “Parser-choice Hybrid” or “Other”. We already were using IFWiki templates and some IDFB tags to work this out for some games, but wondered about authoring systems for the rest.

Originally I asked which authoring systems can only create games of one of these types.

It turned out that essentially any parser authoring system could be used to create choice games, and this has happened fairly regularly (though not often), so we added another (hopefully temporary) classification: “Probably Parser”.

It was said that choice authoring systems could be used to create parser games, but the evidence for that in practice suggested that we could get away with treating Twine etc games as “Choice”.

We ended up with the following. It isn’t entirely applicable generally because it only applies to the games on IFWiki at the time of writing so, for example, “Assembly language” is marked as “Parser” because there are only two relevant games and we checked both manually.

Parser: ZIL, The Quill, AAS, PAW, Scott Adams database, JACL, Graphic Adventure Creator, T.A.G., Robico Engine, AdvSys, Magnetic Scrolls, Assembly language, Eamon, PunyInform, A-code (Level 9), Adventuron

Probably Parser: Inform 7, Inform 6, ADRIFT 4, TADS 2, ADRIFT 3.9, TADS 3, ADRIFT 5, Hugo, AGT, Inform 5, Alan 2.8, Inform, Alan 3, InformATE, ADRIFT 3.8, ADRIFT, Alan, TADS, Alan 2.5

Choice: Twine, ChoiceScript, Undum, Ink, inklewriter, Ren’Py, Adventure Book, Adventure Book for Inform 7, Squiffy, Qiaobooks, StoryNexus, Seltani, Varytale, Moiki

Hybrid: Texture, Versificator, Gruescript

For reference, here is the full list and a legend to understand the symbols.

Full list of authoring systems used for games with IFWiki pages.
  1. Inform 7 (games: 872) :four_leaf_clover:
  2. Inform 6 (games: 753) :four_leaf_clover:
  3. ADRIFT 4 (games: 406) :four_leaf_clover:
  4. TADS 2 (games: 312) :four_leaf_clover:
  5. Twine (games: 279) :white_check_mark: Choice
  6. ADRIFT 3.9 (games: 169) :four_leaf_clover:
  7. ChoiceScript (games: 145) :white_check_mark: Choice
  8. TADS 3 (games: 89) :four_leaf_clover:
  9. ADRIFT 5 (games: 62) :four_leaf_clover:
  10. Hugo (games: 40) :four_leaf_clover:
  11. ZIL (games: 37) :white_check_mark: Parser
  12. Quest (games: 36) :cross_mark:
  13. AGT (games: 34) :four_leaf_clover:
  14. Inform 5 (games: 24) :four_leaf_clover:
  15. The Quill (games: 24) :white_check_mark: Parser
  16. Alan 2.8 (games: 23) :four_leaf_clover:
  17. BASIC (games: 21) :cross_mark:
  18. Inform (games: 17) :four_leaf_clover:
  19. JavaScript (games: 15) :cross_mark:
  20. Alan 3 (games: 13) :four_leaf_clover:
  21. AAS (games: 12) :white_check_mark: Parser
  22. Unity (games: 12) :cross_mark:
  23. InformATE (games: 12) :four_leaf_clover:
  24. Undum (games: 12) :white_check_mark: Choice
  25. PAW (games: 10) :white_check_mark: Parser
  26. Quest 5 (games: 10) :cross_mark:
  27. ADRIFT 3.8 (games: 10) :four_leaf_clover:
  28. A-code (Level 9) (games: 9) :white_check_mark: Parser
  29. Ink (games: 8) :white_check_mark: Choice
  30. Vorple (games: 8) :cross_mark:
  31. Scott Adams database (games: 8) :white_check_mark: Parser
  32. inklewriter (games: 8) :white_check_mark: Choice
  33. Machine Code (games: 6) :cross_mark:
  34. Java (games: 6) :cross_mark:
  35. Ren’Py (games: 6) :white_check_mark: Choice
  36. JACL (games: 5) :white_check_mark: Parser
  37. Texture (games: 5) :white_check_mark: Parser-choice hybrid
  38. AXMA Story Maker (games: 5)
  39. RAGS (games: 5) ???
  40. Dialog (games: 5) :cross_mark:
  41. C (games: 5) :cross_mark:
  42. Graphic Adventure Creator (games: 4) :white_check_mark: Parser
  43. Custom (games: 4) :cross_mark:
  44. Visual C++ (games: 4) :cross_mark:
  45. Squiffy (games: 4) :white_check_mark: Choice
  46. Adventure Book (games: 4) :white_check_mark: Choice
  47. Adventure Book for Inform 7 (games: 4) :white_check_mark: Choice
  48. Versificator (games: 3) :white_check_mark: Parser-choice hybrid
  49. Adventuron (games: 3) :white_check_mark: Parser
  50. Python (games: 3) :cross_mark:
  51. T.A.G. (games: 3) :white_check_mark: Parser
  52. Visual Basic (games: 3) :cross_mark:
  53. Robico Engine (games: 3) :white_check_mark: Parser
  54. AdvSys (games: 3) :white_check_mark: Parser
  55. Magnetic Scrolls (games: 3) :white_check_mark: Parser
  56. Gamefic (games: 3) :cross_mark:
  57. Scratch (games: 3) :cross_mark:
  58. Qiaobooks (games: 3) :white_check_mark: Choice
  59. Quest 4 (games: 3) :cross_mark:
  60. Node-X (games: 2)
  61. SAGA (games: 2)
  62. BBC BASIC (games: 2)
  63. Quest 3 (games: 2) :cross_mark:
  64. CNCS (games: 2)
  65. C++ (games: 2) :cross_mark:
  66. Assembly language (games: 2) :white_check_mark: Parser (checked these two games)
  67. Adventure Maker (games: 2)
  68. GAGS (games: 2)
  69. Pascal (games: 2) :cross_mark_button:
  70. Frolg (games: 2)
  71. Flash (games: 2)
  72. Eamon (games: 2) :white_check_mark: Parser
  73. StoryNexus (games: 2) :white_check_mark: Choice
  74. StoryFactory (games: 1)
  75. ADVENT (games: 1)
  76. Platypus (games: 1)
  77. GW-BASIC (games: 1)
  78. Curveship (games: 1)
  79. DEC Basic (games: 1)
  80. ADRIFT (games: 1) :four_leaf_clover:
  81. Alan 2.8 (games: 1) :four_leaf_clover:
  82. Instagram (games: 1)
  83. Elm Narrative Engine (games: 1)
  84. BASH script (games: 1)
  85. AXMA (games: 1)
  86. Smash (games: 1)
  87. Proprietary (games: 1) :cross_mark:
  88. M.A.C. (games: 1)
  89. Versificator (a Javascript engine) (games: 1) :white_check_mark: Parser-choice hybrid
  90. txt2cyoa (games: 1)
  91. Jade (games: 1)
  92. GameMaker Studio aka The Iji Engine (games: 1)
  93. An Interactive Environment Engine (games: 1)
  94. Gruescript (games: 1) :white_check_mark: Parser-choice hybrid
  95. Adobe Shockwave (games: 1)
  96. SWAN (games: 1)
  97. thinBASIC Adventure Builder (games: 1)
  98. Adventure Prompt (games: 1)
  99. Delphi (games: 1)
  100. node.js (games: 1)
  101. WorldClass (games: 1)
  102. PAWS (games: 1)
  103. PunyInform (games: 1) :white_check_mark: Parser
  104. TADS (games: 1) :four_leaf_clover:
  105. King Edward Adventure (games: 1)
  106. Alan 2.5 (games: 1) :four_leaf_clover:
  107. Seltani (games: 1) :white_check_mark: Choice
  108. INFSP (games: 1)
  109. C Adventure Toolkit (games: 1)
  110. Varytale (games: 1) :white_check_mark: Choice (checked the one game)
  111. textallion (games: 1)
  112. jQuery (games: 1) :cross_mark:
  113. Alan (games: 1) :four_leaf_clover:
  114. Wordpress (games: 1) :cross_mark:
  115. TAB (games: 1)
  116. Visionary (games: 1)
  117. SUDS (games: 1)
  118. Commodore Basic (games: 1)
  119. uglifyJS (games: 1)
  120. Windrift (games: 1)
  121. Moiki (games: 1) :white_check_mark: Choice
  122. Quest 2 (games: 1) :cross_mark:
  123. Adventure Builder System (games: 1)
  124. Versu (games: 1)
  125. Iced Coffeescript (games: 1)
  126. Nib (games: 1)
  127. PHP (games: 1) :cross_mark:
  128. JotaCode (games: 1)
  129. T/SAL (games: 1)
  130. QuickBASIC (games: 1) :cross_mark:
  131. BTZ (games: 1)
  132. URQ (games: 1)
  133. Rexx-Adventure (games: 1)
  134. Floo (games: 1)
  135. Ruby (games: 1) :cross_mark:
  136. Better Basic (games: 1)
  137. INSTEAD (games: 1)
  138. IntFicPy (games: 1)
  139. Turbo Pascal (games: 1) :cross_mark:
  140. Medium Series (games: 1)
  141. QuestJS (games: 1) :cross_mark:
  142. IAGE (games: 1)
  143. The Adventure Generator 2 (games: 1)
  144. OASYS (games: 1)
  145. C# (games: 1) :cross_mark:
  146. Blink! (games: 1)
  147. QBASIC64 (games: 1) :cross_mark:
  148. Stylus (games: 1)
  149. Raconteur (games: 1)
  150. O.H.R.RPG.C.E. (games: 1)
  151. Balladeer (games: 1)
  152. ifSpace (games: 1)

:white_check_mark: = This authoring system creates games of the style noted (e.g. Twine).
:four_leaf_clover: = Probably Parser (e.g. Inform 7).
:cross_mark: = We can’t work out style from this authoring system (e.g. Quest).

2

We are on the finishing straight of an IFWiki project (details to follow). I’d like to find ways automatically to work out the Interaction style of games, which in this context means means “Parser”, “Choice”, “Parser-choice hybrid”. There is also “Other”, for things like Z-code arcade games.

I’ve made some progress with these rules:

  1. Choice, Hybrid or Other if the wiki page currently uses one of those templates. There is no template for Parser in the same way as British coins and stamps do not state the country, but unfortunately in our case no template doesn’t always mean parser.
  2. Parser, Choice or Hybrid based on some IFDB tags (e.g. “parser” and “CYOA”).
  3. Choice if authoring system is Twine or ChoiceScript.
  4. Parser if the authoring system is ZIL or Magnetic Scrolls.

We’d like to add some more authoring systems to points 3 and 4 above. Just writing this post has helped already. Please can you reply below or edit the post above to fill in some details?

  • I believe that Inform and TADS, and probably most other parser authoring systems, can create choice games, so we can’t use them. But maybe it’s known that some old ones just never have.
  • I imagine that nearly all choice authoring systems can only create choice games.
  • There are some that we can’t judge (e.g. BASIC or C) without seeing the individual games. That wouldn’t be worth the effort at this stage for authoring systems with just 1 or 2 games.

Thanks in advance :slight_smile:

3

Inform, at least, can only create choice games through extensions (e.g. Hybrid Choices) and doesn’t do it out of the box. I’ve seen Twine games that are basically parser games but you click to enter the command (e.g. click LANTERN → TAKE LANTERN). So I think for all intents and purposes, classifying Inform and TADS as parser, Twine as choice, etc. would work.

If you misclassify the few that are using a system not actually originally intended for that playstyle, I think that’s a sacrifice that’s worth taking for the sake of not marking every system as “either”. For instance, Drew Cook’s Portrait with Wolf could easily be classified as a choice game despite being made in Inform 7, but the majority of Inform 7 games will undoubtedly be parser games.

I’m also confused about the :white_check_mark: :cross_mark: system going on. Can you elaborate on that, as well as your goal for this as a whole?

4

That is what we mean by saying “Inform can create choice games.”

1 Like
5

If you’re going based on “can”, what’s the point of classifying these systems in the first place? Inform was designed first and foremost for parsers.

If you’re trying to classify each and every game on the IFWiki…good luck.

6

:white_check_mark: = This authoring system can only create (or has only created) games of one of the interaction styles.
:cross_mark: = The above statement isn’t true.

We’d like to classify as many as is possible without checking each game. Thanks for the luck :slight_smile:

3 Likes
7

So the IFWiki volunteers can look at a game file and say “oh, it was written in system-X, it must be a parser-based game”. Without having to launch the game and check.

For Inform, you have to launch the game and check. (Or at least look at comments by somebody who has done that.)

3 Likes
8

I think Quest can make either hybrid (clickable parser) or parser-only games–can anyone confirm? Does it differ between versions of Quest?

I think Seltani is choice only–can anyone confirm?

9

That’s correct.

1 Like
10

I think it’s might be impossible to put a :white_check_mark: on any of these. I disagree with at least the top three :white_check_mark:s on this list, Twine, ChoiceScript and ZIL.

I think for many authors it’s inherently fun to try using a system to develop a game that it wasn’t intended to develop. As long as a system is Turing Complete, and it allows keyboard-based text input, it is possible to implement a parser game in that system.

Twine doesn’t normally use text-based input, but it can do so, and I’m aware of at least one excellent game that I’d call a “parser” game written in Twine, Type Help. You interact with Type Help mostly by typing commands in a box, and guessing which commands to type next, kinda like EYE.

To pick another example, ChoiceScript has an *input_text command, and it’s Turing Complete, so it would be possible in principle to implement a parser game in ChoiceScript. I’m not aware of anyone doing that, but I know it’s possible.

Similarly, I’m sure you could implement a choice-based game in ZIL if you put your mind to it. At a minimum, you could implement a choice-based game inside Z-Code help menus. Should you? Probably not, but someone would probably get a kick out of it.

A :white_check_mark: on a system means that some kind of software is impossible in that system. IMO, that’s very rare, and it doesn’t apply to any of the popular/semi-popular dev systems in IFDB/IFWiki.

2 Likes
11

That’s true, but imo we can still meaningfully distinguish interaction style from gameplay style. If you build a choice-based game in ZIL, it’ll still involve typing of some sort, because ZIL only compiles to the Z-machine which can’t handle mouse input in any meaningful way. If you want to make a parser game in Ink, you’ll have to bolt on some external module for free-form text input, because out of the box Ink only supports clicking.

(As opposed to Inform 7, which has readily-available extensions for hyperlinks, and Twine, which can easily insert an HTML text-input box, even if it’s not what they’re meant for.)

12

We can argue terms all day, but I wouldn’t say that “choice-based” means “mouse based.”

A choice-based game in a Z-code hint menu would certainly be a thing. (… come to think of it… is there one of those out there? Seems like there could be?)

And especially if the question is “is it possible to type commands?” Twine and ChoiceScript both allow that, for sure.

13

There is at least one full-on parser game created in Twine, The Roads Not Taken.

It’s not common or easy or possibly even a good idea, but if we’re talking about what you can do…

1 Like
14

I should have made this clearer. This is all about a one-off decision about game pages that are currently on IFWiki. We won’t be using authoring systems to guess interaction style on an ongoing basis, as we hope to make it easy for editors to add that. So what’s important is what games are currently on IFWiki, not what might be in future.

Fortunately, neither of the two Twine games mentioned above are on the wiki, we don’t know of any parser ChoiceScript games, and all the ZIL ones on the wiki are definitely parser. (Also, we could create exceptions when very many games are X style but one or two are Y.)

1 Like
15

The scale of the potential problem with Z-code (or Glulx) seems similar to Inform, TADS, etc, as usually they’ll be parser but there are probably a few choice games written with them.

With the choice-based authoring systems it seems that there’s a really small chance of getting it wrong.

16

I think the chances of getting it wrong are small but present from either direction and it’s probably best to focus on identifying the few systems that have enough use for multiple different kinds of game that you do have to go on a case-by-case basis for them.

17

In that case, I think, to a first approximation, would wouldn’t regret categorizing all of the games in these systems as parser only: Inform, ADRIFT, TADS, Hugo, ZIL, Quest, AGT, Quill, Alan, AAS, Dialog. You might accidentally mark one choice game as parser, but that guess would be easily 99.9% correct, and you could manually fix it later if you wanted.

Similarly, if you mark all of the Twine, ChoiceScript, Undum, Ink, Ren’Py, Texture, and inklewriter games as “choice-based,” you’re probably at least 99.9% correct.

6 Likes
18

I’d actually leave off Dialog, because about half the Dialog games on IFDB are either choice or parser-choice hybrid (at least according to the tags). But there are also a grand total of 15 Dialog games on IFDB so that’s easy to handle by hand.

2 Likes
19

If we can even go with Inform, TADS, ADRIFT, Twine and ChoiceScript, that would account for nearly everything…

Then we could encourage people with knowledge to fix the anomalies.

I imagine some of the 8-bit authoring systems probably never had choice-based games made for them. Does that sound right? @8bitAG @Warrigal

We could probably find some exceptions using IFDB, e.g. “system:Inform tag:choice-based”. I’ve only checked the first on the list, but it has an IFWiki CYOA/Choice template so is OK.

20

Every time I think about this I think something different, as now I hate the idea of introducing any errors at all like this :laughing:

It would be good to get some more ticks and crosses based on the original question before deciding.