Inform - Support - Suggestions

About Suggestions  

Under consideration  
Accepted for next release  
Completed  
Rejected  
Complete list  

Complete list of suggestions

These are all of the received suggestions.

Anybody is welcome to submit a suggestion; please keep it succinct and in the style of the proposals already published here.

     
     
180.  Better handling in Locale of objects found on a scenic supporter, for example using their 'initial' properties.
     
179.  Extend -l compiler switch to list current switch settings.
     
178.  Overload the "concealed" attribute to also hide an object from the player's inventory display. The usage is reasonably intuitive as per "concealed from view but present".
     
177.  There are a few places in the library where a bunch of globals have to be saved and restored. Usually, local vars are used, but in a few cases the globals have to be pushed and popped from the stack, which means #if statements to check for Z-code or Glulx. How about a special block statement: preserve (var1,var2,var3,...) {...} which pushes the listed variables onto the stack, executes the block, and pops them back off. This reduces semantic clutter in those places where local vars are currently used, and avoids assembly where you can't use them, and incidentally guarantees that you don't mismatch the push and pop statements..
     
176.  Enable a routine's arguments to be addressed as an array. Thus, the current [ myRoutine x y z; ... could also be specified as [ myRoutine a-->2;..., where a-->0, a-->1 and a-->2 are equivalent to x, y and z respectively.
     
175.  Extend the debugging verbs ABSTRACT, GONEAR, PURLOIN, SCOPE and TREE to accept object numbers, as was done for SHOWOBJ (L61030). Display object numbers wherever possible in debug verb messages.
     
174.  Define an 'infer_second' property to provide a standard hook whereby [UN]LOCK NOUN could automatically infer the correct key, if available. Potentially, this mechanism could also apply to HIT|LIGHT|DIG|OPEN| NOUN.
     
173.  Allow for "lock noun" and "unlock noun" without providing a key. If the object is lockable and its with_key value is 'nothing', allow the action with "You unlock <the noun>." This is, of course, unless a before or react_before has intercepted the action.
     
172.  Object print routines, such as "initial", should return TRUE/FALSE to indicate whether anything was printed, and the library should then suppress the carriage return it puts out if the return was FALSE. I can see this is slightly tricky because the library puts out its new-line first, regardless of what the object does.
     
171.  Better behavior on switches with duplicated cases. The code

switch (n) {
  1, 4: print "square ";
  2, 4: print "even ";
  default: print "neither ";
}

will currently just show "square" when n is 4; it should either show both "square" and "even" (probably too much to get this effect if default is allowed), or refuse to compile with a 'duplicated case' error.
     
170.  If you write an assignment as the expression in an if-statement, the Inform compiler gives a useful warning: "'=' used as condition: '==' intended?". I think it would be good to have a similar warning for '~' and '~~'. For example, if I write a condition '~self.opened' rather than '~~self.opened', it compiles without warnings but the condition succeeds when self.opened is any value except -1 (NULL). I doubt most people use the bitwise operators, and anyone who did insist on using one as a condition and didn't like the warning could either make the test explicit ( ~= 0 ) or stick an extra pair of brackets around it.
     
169.  Devise an object-oriented ChooseObjects( ) supplement. For example:object.choose_n( ) to choose the noun, object.choose_s( ) to choose the second, and object.choose_m( ) to handle being included in multi lists. They'd act like "before" and "after", switching with action_to_be to evaluate the object and returning a value as per the existing ChooseObjects. They'll need to be additive properties, of course, so that a chocolate door would inherit the choose_* rules from your TwoWayLockedDoor class and from your FoodAsScenery class.
     
168.  Ensure that ChooseObjects( ) can determine whether it's been called in the context of 'noun' or 'second'.
     
167.  In parserm.h, after the call to AfterGameOver( ), add a line if (deadflag == 0) jump very__late__error;.
     
166.  The grammar lines for ##Disrobe are defined with the [held] token and once, in the case of 'take off' with [worn]. Wouldn't it be better to change the tokens to [noun] and enforce the held condition in the second line of DisrobeSub, together with the worn check? That wouldn't try to pick up an item only to remark that it can't be taken off right now.
     
165.  It ought to be possible for an interpreter to start up, load the game file, and then immediately load a saved game (without executing any of the game code until the restore is successful.) This is a standard gimmick in GUI interfaces -- Zoom and MaxZip can do it for Z-code. Glulx can *nearly* handle this, if you hack an interpreter to do a restore before the execution loop, but two things go wrong. First, the way the library is written, the @setiosys opcode (which initializes Glk output) is not in GGRecoverObjects( ). Second, the library's GGRecoverObjects( ) assumes that the basic two windows already exist. This is a valid assumption after the player types RESTORE or UNDO, but not after an auto-restore at terp startup.
     
164.  If you know C++ or Java, then it's easy to understand: there are not (as far as I know) static methods in Inform. If you create a method inside a class, then you won't be able to execute it until you have an object of that class. This makes it difficult to create certain patterns in Inform, such as the object factory.

Static methods are normal functions; the only difference is that they are inside a namespace (the name of the class). They don't have access to the attributes of the object, because they are not related to its state. I'm afraid this involves modifying the compiler (static methods are not copied to new objects), and probably add a modifier to methods:

Class C(200)
    with static createNewC[; return C.create( ); ];

[ Initialise;
    C::createNewC( );  ! C++ style (probably not very homogeneous)
    C.createNewC( );   ! Java Style
];
     
163.  Be able to deal with classes as with objects. As far as I understand how Inform works, this shouldn't be difficult. I think that in Inform, classes are plain objects. It would be nice to be able to do something like:

Class Characters
  with static prepare [;
       ! To be overwritten by derived classes
       ],
       ... ;

Class Warriors
  class Characters
  with prepare [; ... ],
       ... ;

Class Dwarfs
  class Characters
  with prepare [; ... ],
       ... ;

[ Initialise cl;
    classloop (cl ofclass Characters) {
        cl.prepare( ); ! cl::prepare( ) ?
    }
];
     
162.  Add a "#Ifndef NO_TURNS" check to the relevant part of the DrawStatusLine routine, enabling the display of turns to be turned off by adding NO_TURNS to your code, just as the display of the score can be turned off by adding NO_SCORE.
     
161.  Why isn't there a COMMANDS or SHOWCOMMANDS command?
     
160.  Make IN an alias for ENTER when a noun is given.
     
159.  Let games use mood MIDIs.
     
158.  Give all objects and rooms aliases which can be named and renamed by an appropriate command. Go to then moves the character to where the object was, or to the named room, either using the last open path or the shortest calculated path.
     
157.  I don't like the corrupted language of the "You haven't got that." message. Can you straighten it?
     
156.  Commands to turn Strict mode on and off for certain bits of code.
     
155.  It would be very clever if the compiler detected the expression "(A .# B) / K", for constant K, and threw a warning if K was not 2 (in Zcode) or 4 (in Glulx).
     
154.  Give a compiler warning for 'surprising' expressions of the form ~~x && y -- where '~~' can also be '~' and '&&' can also be '&', '||' or '|' -- but not when parentheses are used to clarify the association: (~~x) && y or ~~(x && y).
     
153.  Create different extentions for Z-machine and Glulx blorb files.
     
152.  Emulate DOS "F3" key funtion, i.e. print last command typed as new text. This is useful for editing a long miskeyed command, like "Get torch, turn it on, then put it on tablr". In any DOS v3-5 game, this works. Maybe "again", in singular use, could do this, and to bypass it you would simply hit "g(return,return)" Or even a command like "typo", or "oops".
     
151.  Support easy internationalisation of Banner( ), VersionSub( ), RunTimeError( ) and PrintCommand( ).
     
150.  Give better responses to verbs like RUB when the subject is animate.
     
149.  I'd like to see 4 "directions" added to the compass if possible: FORWARD, BACK or REVERSE, LEFT, and RIGHT.
     
148.  Add bibliographic data as blorb chunks or ID3-like tags.
     
147.  It might be useful for preprocessors if there were a way to indicate that errors should be reported at a given file and line number.
     
146.  Allow ASK ABOUT X, to infer most recently referred to NPC. Also consider topic management as extension or core library.
     
145.  Add a blorbifier to the compiler.
     
144.  Provide a macro facility for Inform.
     
143.  Support "compile-time" print formatting.
     
142.  Provide a way to access the 16-bit opcodes in Glulx.
     
141.  Allow arbitrary flags to be set on dictionary words, so along with 'cats//p', one might say 'furniture//m' to mark mass nouns .
     
140.  After having failed to open an Included filename as is, try the filename converted to lower-case.
     
139.  Provide -P compiler switch to list actual paths used for input, output and all included files (eg, am I using the verblibm.h that I thought I was?).
     
138.  #If[n]def directives should support && and ||.
     
137.  The implicit messages produced by 'INSERT|PUTON worn' should match those from 'DROP|EAT|THROWAT worn'.
     
136.  Compiler to ignore completely (ie not complain about errors in) code which has been #Idfed'd out.
     
135.  Support block comments in Inform.
     
134.  Increase the Z-machine dictionary resolution beyond nine characters.
     
133.  TAKE ALL additionally to attempt objects on supporters and in open [transparent] containers.
     
132.  Make VERBOSE the default mode.
     
131.  Provide a very basic volume/weight filter system for containers and supporters, or at least an Entry Point to facilitate this.
     
130.  Add WordValue(wordnum), NumberWords( ), GetKeyBufLength( ) and SetKeyBufLength( ) functions to complement the platform-independent WordLength(wordnum) and WordAddress(wordnum). Also add optional parameters to all of these so they can work on other parse arrays besides 'parse'.
     
129.  Control of word separators, e.g. if you don't want to use '.' as a separator, or do want to use '?' as one.
     
128.  When a new identifier is expected, but the compiler finds an already defined one, it should give the location of the previous definition. Also, the message itself should be reworded for clarity.
     
127.  Add grammar for GET OUT OF, since it appears in an English.h message.
     
126.  If you try to give something to a creature that's moved away, you get 'You can only do that to something animate' rather than 'You can't see that here'. GIVE CHEESE TO MOUSE after the mouse has gone back in its hole suggests it's still around (or you've made a programming error), or GIVE BISCUIT TO GIRAFFE (at the start of 'Curses') that there are somehow dead giraffes about. There should perhaps be a test for the creature to be present before checking whether it's animate or not.
     
125.  In the Compiler, provide the ability to define arbitrary constants (not just DEBUG) in ICL.
     
124.  Allow AND to mean the same as THEN when unambiguous.
     
123.  The parser prefers to TAKE an object the player is already holding rather than one on a container or supporter, causing some player frustration unless a ChooseObjects( ) is provided. The rules in S33 of DM4 should be changed so that A is set to 0 for Take. (This can be done by adding one line 'if (action_to_be ~= ##Take)' before 'a_s = SCORE__NEXTBESTLOC;')
     
122.  You can take an item from the SACK_OBJECT but you can't drop an item directly if it's in the sack; instead you get the rather unhelpful 'You haven't got that'. It would be good to at least get a response like 'You need to take that out of the sack first' (or whatever).
     
121.  If the parser attempts to put something in the SACK_OBJECT but fails, it should try another item. (See also Suggestion 82)
     
120.  The 'You need to be holding the thing before you can...' for PutOn and Insert can be an annoyance, e.g., when the object is in a sack object. Maybe the action routines should include an implicit take.
     
119.  I especially dislike the name of the new Length( ) routine. StringSize( ) would be better.
     
117.  I think TAKE ALL shouldn't attempt to take scenery objects (or animates).
     
116.  CONNECT and DISCONNECT should be synonymous with ATTACH and DETACH.
     
115.  An #Undef directive to cause a previously defined constant (only) to become undefined.
     
114.  The #End directive in a #Included file should simply exit from that specific inclusion rather than terminate the entire input stream.
     
113.  Make UNDO repeatable: UNDO.G.G.G should undo the last four actions.
     
112.  Allow "male" and "female" to be assignable to non-animate things. This will make it easier to implement dead bodies.
     
111.  #Include the file named by constant MASTER_INCLUDE four times: before Parser and after Parser, VerbLib, and Grammar.
     
110.  Enhance #Include by: accepting a comma-separated list of files.
     
109.  Enhance #Include by: taking a "?" prefix to mean ignore a missing file; accepting a string constant as a filename.
     
108.  Allow libraries to define compile time checks to be performed against the objects defined in the program. This would allow some world model violations and coding slips to be detected with the aid of the compiler. The new directive could take the form of:
  #Check;
    Iftrue #self has door && #self hasnt static;
      Message "a door normally has static";
    Endif;
  #Endcheck;
When the compiler encounters #Check ... #Endcheck instead of executing the contents it memorises them for use in a later phase. Towards the end of compilation a checking phase is entered and the new system constant #self is set to each object in turn and all the memorised checks executed. (Line number needs to be set too so that the cause of Messages can be located.) During the checking phase, expression constant folding is extended to allow 'has', 'provides', 'parent( )' etc to be executed against the finished objects; this allows the compiler to evaluate the library defined tests.
     
107.  For games that don't want an automatic LOOK at the beginning of the game, allow programmers to define a constant (NOINITIAL_LOOK) to deactivate it, so they don't have to edit the libraries or replace a large part of code.
     
106.  Move Uppercase( ) and Lowercase( ) to English.h, to assist Cyrillic, Polish, Greek etc porters. The current routines work only for ISO 8895-1, and need replacing with other character sets.
     
105.  Support unless (condition)... to complement if (condition)....
     
104.  Enhance +charset_map by: searching +include_path; supporting hex numbers; treating a mapping of zero as 'pass this char through without change'.
     
103.  Support an Epilogue( ) entry point, called at end-of-game between DeathMessage( ) and ScoreSub( ), to permit additional commentary when a game is over.
     
102.  Remove the compile- and Strict runtime error for writing to the 0th entry in a string or table array -- it goes beyond protective to become intrusive and inconvenient.
     
101.  Optionally, support serial (aka Oxford) commas in the listmaker: some favor the result, some think it fustily eccentric, and some can't abide it.
     
100.  Make the property name a parameter to RunTimeErrors 5 and 11.
     
99.  Extend the Replace directive such that if the compiler encounters Replace routine newname; then the compiler transparently renames routine as newname when it is encountered (rather than skipping over it as happens now). Only the routine definition is so renamed, calls to it are not. Often a replaced routine ends up behaving almost exactly like the original, but with a minor change, usually because the coder does not actually want to alter the normal semantics of the routine in any way, but merely wants to do something when that routine is being called - "hitching a ride", as it were. This change would facilitate this.
     
98.  To make the syntax of the has operator consistent with the syntax of the give command, allow it to take more than one attribute like this: if (item has animate ~flying male creature) whereas now you'd have to use the following instead: if (item has animate && item hasnt flying && item has male && item has creature).
     
97.  The ability to define grammar tables arranged by action rather than verb (word).
     
96.  An attribute you can give an object so that it don't appear in a room description, but don't change the object in any other way. (scenery makes it so that the object can't be picked up, concealed makes it so that the object can't be picked up by typing TAKE ALL.)
     
95.  There are a lot of rules that stop a player from doing stuff, like you can't get off something you are not on. If you try to make a NPC responding to orders, you have to more or less write all these rules from scratch. It would be helpful if there existed somewhere the source code to an NPC that responds to all the orders, by which I mean all the default commands that a player character responds to, and which follows all the rules that a default player character do. Then it would be fairly easy to edit the source code into the NPC one wants.
     
94.  I would like a way of deciding it what order the described items occur in the room description. For instance say a room contains a lion. The lion will never be in any other rooms. But at some point it will disappear from the room. So I give it describe, but the description of the lion is meant to still feel as part of the room description, even if it isn't technically. The problem comes if a player drops an item with describe. The description of the item will then come before the description of the lion. So maybe one could put numbers on the descriptions, so that the game first describes number 1 and then number 2 and so on.
     
93.  I am writing a game without EXAMINE. Therefore all stuff must be described when the player uses LOOK. One can get a long way with describe, but the describe attribute dos not work if the object is on, for instance, a table. I would like another attribute that makes it so that you can see the description even when the object is on the table. Maybe there could be a line first saying: "On the table you see:" followed by the descriptions of all objects on the table. This should also happen if the player is on the table.
     
92.  If a class has a react_before and an object with that class has a react_before the game ignores the react_before of the class. Would be useful if there was a way the object could have both reacts_befores and one decides which one comes into play first.
     
91.  An easier way of deciding what happens first. So that you can make a "before" happen before a "react before" or a "react before" happen before an "order". And also a way of deciding which "react before" happens first. Maybe one could put numbers on them, so that number 1 happens before number 2 etc.
     
90.  Make Exit actions consult the before property of any enterable object, the way Go actions do. This seems more intuitive, and is unlikely to break existing code, since objects shouldn't have existing Exit cases.
     
89.  I would like to see the use of the library "interger.h" removed and now since the current machines have more memory incorporate a feature that will allow the author to have numbers over 32767.
     
88.  The description of PrintCapitalised( ) seems to suggest it works the same way as PrintOrRun( ), only it can capitalise the output as well. I noticed however, that it doesn't return the value returned by the routine if a routine was indeed called.
     
87.  It would nice if there could be some way of notifying a location that an actor has just left it; the Go action is offered to X's before property and Y's after property as now, but (say) a GoneFrom fake action is also sent to X's after routine.
     
86.  Make x=obj.prop synonymous with x=obj.&prop-->0 if the property happens to be an array.
     
85.  How about treating 'listen' 'smell' and 'taste' the same as 'touch'? At a minimum, tasting should at least require an object to be touchable. Smelling yourself or tasting or smelling a creature should also generate special responses.
     
84.  Consolidated messages when handling multiple objects, so take TAKE ALL APPLES replies "4 apples: Taken" rather than "Apple: Taken" four times.
     
83.  Compiler to read Unicode source files.
     
82.  Call before_implicit ##Insert from AttemptToTakeObject( ) for each object about to be placed in SACK_OBJECT; return true to reject.
     
81.  Define the external names of the CompassDirection objects using their short_name properties, so that they can be changed at runtime. Also, move the values embedded in LanguageDirection( ) into XXX_to properties of those objects.
     
80.  Sensible substitution of "actor" for "player" in select verb routines (and handlers).
     
79.  A NO_DARKNESS constant to shine light everywhere.
     
78.  The compiler could eliminate unreferenced objects and classes.
     
77.  The compiler could eliminate unreferenced routines.
     
76.  Add an optional flag parameter to YesOrNo( ), which prevents the routine from redrawing the status line (eg, when within a menu).
     
75.  Re-enable support for v3 games.
     
74.  Support for even larger Z-machine versions: double v6 (1088K) and double v8 (1024K).
     
73.  Removing one level of indentation in the veneer strings would save about 10K on the compiler size. (BTW if there's a compilation error in the veneer, which of course should never happen, the quoted line is missing its first character.)
     
72.  The compiler error for undefined action routines, eg 'Error: There is no action routine called "TaekSub"' should quote the location where ->Taek or <Taek> or ##Taek first appears.
     
71.  Unicode support for Glulx targets.
     
70.  Infix support for Glulx targets.
     
69.  Why not make it so you can use either initialise or initialize for your routine that sets the game up, at the beginning? The compiler would accept either, and if both exist it would be an error.
     
68.  Better NPC implementation. The ORLibrary has some excellent routines. Why not implement something along those lines considering many IF games make heavy use of NPCs anyway?.
     
67.  An intelligent UNLOCK verb, so that if the player is carrying the required key to unlock an object, the UNLOCK command should use it to unlock the object automatically.
     
66.  Reverse Strict mode's dependency on Debug mode, so that a game can have Strict's run-time checks without Debug's extra commands.
     
65.  It would be nice to use #Ifdef constructs within a class definition to eliminate entire methods.
     
64.  It would be nice if Class Foo(0) was treated as Class Foo, thus allowing classes to be dynamic or not based on a constant (for example).
     
63.  In v6 games, SaveSub( ) should set the header bit requesting a screen update (since after the restore the v6 screen model will need to be reinitialized). Conversely, the default DrawStatusLine( ) method should probably clear this after it reinits the screen.
     
62.  Create a WriteListFromWithSeparators( ) which has parameters for the separators (one for between words and one for the final word). The standard WriteListFrom(obj,style) would just be rewritten to call WriteListFromWithSeparators(obj,style,",",AND__TX), but a 'choices' list -- A, B, C or D -- would also be possible.
     
61.  Static variables, or some other version of scoping within .h files.
     
60.  Allow multiple UNDO.
     
59.  How about a separate file containing all of the Inform compiler's messages, so that the compiler itself (and any output generated by the veneer) can be translated into other languages? This might not be as useful for the compiler warnings/errors, but the veneer errors at least should be translatable.
     
58.  It should be possible to define a constant early to suppress the SCORE and FULL verbs and all score reporting, so that people don't have to hack this for puzzleless or otherwise score-free games. (As Zarf has pointed out, it's very easy to remove SCORE incorrectly.)
     
57.  The move towards a single Z-Machine/Glulx compiler increases the requirement for compiler options settable within the source file rather than on the command line. Currently, Switches G; seems to crash the compiler, while statements like +include_path= and $MAX_STATIC_DATA= are unsupported.
     
56.  Better code generation for the constructs objectloop (x ofclass y), objectloop (x provides p) and objectloop (x .& p). These can be determined at compile time, so it is possible to (say) autogenerate an array and simply iterate over it for the objectloop. [Both this and the previous suggestion trade off writable memory for speed, and getting the balance right is the tricky part. Since writable memory is precious, we'd almost need a pragma or compiler switch to override the compiler's decision.]
     
55.  Better code generation for the switch statement. When possible, generate a lookup table, or a binary-searchable table.
     
54.  Remove the 'wall' concept of compass directions, renaming them "the direction north", or "the northerly view", or simply "north" as in the Inform FAQ entry.
     
53.  Add a mechanism to extend the -Cx input character set argument so that other character sets for source code can be read from a file, so that Inform can compile from (say) Windows-Cyrillic sources.
     
52.  Add a mechanism to specify extra values in the header extension table.
     
51.  Support Z-Spec 1.1 opcodes.
     
50.  Ensure all Z-Spec 1.0 opcodes are included in the assembler.
     
49.  The library has support for only three different genders. Swedish, and possibly other languages as well, has four genders, which necessitates changing some arrays and the routines which access them, making it less likely that Swedish.h can be used with a newer version of the library. There's no obvious reason for providing support for only three genders -- four is just as easy. Going beyond four is slightly trickier, since it means the possible GNA values can't be held in a 16-bit integer anymore.
     
48.  Make it possible to temporarily disable parser inference messages in circumstances where they add no value.
     
47.  A route back into the Parser when an action routine realizes that it needs more information and wants to issue the disambiguation message "What do you want to XXXXX that with?".
     
46.  Make task_scores a word array -- the extra bytes are trivial, compared with the benefits of large and negative scores.
     
45.  An optional better form of objectloop: objectloop( x : (complicated expression involving x) ) { body; } , loops over objects, setting x to each, then executes the body statement if the complicated expression is true. This stops you needing to make x the first variable mentioned in the expression.
     
44.  Floating point veneer, Floating Point Veneer, FLOATING POINT VENEER. (only occasionally needed, but VERY necessary in those cases)
     
43.  "and" keyword: (func(x) < 5 and >= 10 and ~= 8) should be like (func(x) < 5 && func(x) >= 10 && func(x) ~= 8), except that it only calls func(x) once, and is thus faster.
     
42.  Some form of _explicit_ list separator (a keyword like "item"/"next"/"then" would be good for this) would then be REQUIRED to write an array that didn't just look like one humongous function call.
     
41.  Pointer referencing and dereferencing (using * and & would work fine, wouldn't they?) would be nice, along with C-style function pointers
     
40.  If dictionary words, AND ONLY dictionary words, could be enclosed in backquotes (ASCII 96; 'a'-1), then that would get rid of that darn ugly 'a//' notation.
     
39.  I would like to see TestScope work the way I think it ought to. That is that it tests to see if the noun and/or the second is in scope and returns the appropriate error messages: "I'm sorry but (the noun) isn't here", "I'm sorry but the (the second) isnt here", or "I'm sorry but neither (the noun or the second) are here"; or some such and allowing the auther to further customize it as well.
     
38.  Initialising a word array with a single string should generate a warning that the string has been unpacked.
     
37.  I notice that printing rules are available for both the capitalized and lowercase versions of the definite article, (The) and (the), but only a lowercase version is present for the indefinite article, (a). There is no (A), as I discovered when I found myself needing one. I think this inconsistancy should be fixed.
     
36.  Maybe also include some contributed libraries as optional within the package, such as WaterElement and pname.
     
35.  Defining Verb 'pry' 'prise' 'prize' 'lever' * noun 'with' held -> Unlock in the standard library. I promise I will shut up about this when I play a game that allows 'pry' but also 'prise'.
     
34.  "Int" and "Ext" room classes, the former with walls and a ceiling (or some alternative simple way of reinstating walls where needed).
     
33.  Compiler warning/error if non-dictionary words are included in name property. (see also suggestion 1)
     
32.  A constant, which, when defined, will cause referring to names of the current location to print the location description, rather than the usual "You don't need to refer to that".
     
31.  Making "ASK|TELL X TO Y" a (near) synonym for "X, Y"
     
30.  A variable representing the PC's posture (standing, lying, sitting etc.)
     
29.  Compiler warning or error when using unqualified properties within routines (e.g. a C programmer forgot to include "self.").
     
28.  Some method in the language of generating auto-incrementing Constants, like enums in C. For instance, "Constants A, B, C;" would be equivalent to "Constant A=0; Constant B=1; Constant C=2;".
     
27.  For the twelve compass directions: either make the numbers assigned to XXX_obj and XXX_to consistent throughout or make them completely distinct; the current half-and-half situation promotes confusion.
     
26.  Give selfobj an empty add_to_scope property, so that it's easy to extend by player.add_to_scope=myScopeRoutine; without needing to create a whole new player object.
     
25.  Define LIBRARY_PARSER, LIBRARY_VERBLIB and LIBRARY_GRAMMAR constants in library files so that contributed packages can check their own correct inclusion; also suggests a standard for general dependency checking.
     
24.  String manipulation, like concatenation or substring searches.
     
23.  Provide an "assert" verb.
     
22.  Provide support for arrays local to functions.
     
21.  Don't really understand why the Inform compiler limits selected things like MAX_STATIC_DATA.
     
20.  The use of "$..." to introduce compiler options is intensely annoying on *NIX systems that use "$" as an environment variable indicator, e.g. $PATH -- it requires the constant use of quotes to avoid unpleasant and confusing results.
     
19.  Add a spelling checker to the compiler.
     
18.  Make printing strings (as in 'Array mumble string "foobar"') a standard function.
     
17.  Give up on trying to promote "for (::)" and just accept that everyone uses semicolons "for (;;)". Drop the warning.
     
16.  Add an alternative syntax of array[index] for array->index and array-->index.
     
15.  Provide warnings when -> is used to reference arrays declared as word arrays/tables, and also when --> is used to reference byte arrays
     
14.  Make Stubs do something much better. See the implementation of GNU C's "#pragma weak" for an idea of what would be useful.
     
13.  Generalize Entry Points into 'event listeners', so that multiple library extensions or game modules can arrange to receive entry point notifications.
     
12.  Provide easy override for disambiguation rules, so that the designer controls the question "Which pen do you mean, the red one or the blue one?".
     
11.  Extended directive: Array name buffer, to create an array with a length word and character bytes, as used by print_to_array.
     
10.  Automatically compile to v8 if the game overflows v5.
     
9.  Support Global X value; for symmetry with the three forms of Constant. Also provide Variable as a synonym.
     
8.  Permit objects to be both containers and supporters.
     
7.  Replace Fake actions by before_second and after_second properties.
     
6.  Provide tighter control over the scope of TAKE ALL.
     
5.  Provide some control over the implied TAKE which is built into verbs like EAT (as in EAT BIG ROCK CANDY MOUNTAIN).
     
4.  Provide simple control over "The object is currently switched on/off" style messages.
     
3.  Provide simple control over all "(providing light)" and "(which is open)" style annotations, in room descriptions as well as the inventory -- see this Inform FAQ entry.
     
2.  Make RECORDING and REPLAY available even when Debug mode is switched off.
     
1.  Introduce a default Incompatibility mode, slightly similar to Strict mode, in which the compiler rejects (as errors, not warnings) the use of constructs from earlier versions of Inform. For example: "\" in multi-line strings; "xxx" instead of 'xxx' in name properties and Verb definitions; #n$X instead of 'X//', etc.


Last updated 17 April 2013. This web site has not been fully supported since April 2008. Information may be out of date. This page was originally managed by Roger Firth.