View source for AGI Specifications: Chapter 4 - The Logic Language

[[Category:AGI Pages]]
[[Adventure Game Interpreter Specifications|Table of Contents]]

&nbsp;

== <div id="logic"></div><div id="s4"></div><br />4. The Logic language ==

== <div id="syntax"></div><div id="ss4.1"></div><br />4.1 Logic syntax ==

<div align="center">''Written by [[agiw:Peter Kelly|Peter Kelly]]''<br />
''(Last updated: 27 January 1998).''</div>

&nbsp;

This is the &quot;official&quot; Logic syntax that has been decided on. It is not the same syntax as Sierra used. All Logic decoders and compilers should comply with this syntax, so that programmers can be sure that code they produce can be used properly with any program.

&nbsp;

==== Action Commands ====

Normal action commands are specified by the command name followed by brackets which contain the arguments, separated by commas. A semicolon is placed after the brackets. The brackets are required even if there are no arguments. The arguments given must have the correct prefix for that type of argument as explained later in this document (this is to make sure the programmer does not use a var, for example, when they think they are using a flag).

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
assign.v(v50,0);
program.control();
</syntaxhighlight>
</blockquote>

Multiple commands may be placed on the one line:

<blockquote> 
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
reset(f6); reset(f7);
</syntaxhighlight>
</blockquote>

Substitutions for the following action commands are available:

<blockquote>
{| class="wikitable" width="450"
|-
|width="175"|<code>increment(v30);)</code>||width="275"|<code>v30++;</code>
|-
|<code>decrement(v30);)</code>||<code>v30--;</code>
|-
|<code>assignn(v30,4);)</code>||<code>v30 = 4;</code>
|-
|<code>assignv(v30,v32);)</code>||<code>v30 = v32;</code>
|-
|<code>addn(v30,4);)</code>||<code>v30 = v30 + 4; or v30 += 4;</code>
|-
|<code>addv(v30,v32);)</code>||<code>v30 = v30 + v32; or v30 += v32;</code>
|-
|<code>subn(v30,4);)</code>||<code>v30 = v30 - 4; or v30 -= 4;</code>
|-
|<code>subv(v30,v32);)</code>||<code>v30 = v30 - v32; or v30 -= v32;</code>
|-
|<code>mul.n(v30,4);)</code>||<code>v30 = v30 * 4; or v30 *= 4;</code>
|-
|<code>mul.v(v30,v32);)</code>||<code>v30 = v30 * v32; or v30 *= v32;</code>
|-
|<code>div.n(v30,4);)</code>||<code>v30 = v30 / 4; or v30 /= 4;</code>
|-
|<code>div.v(v30,v32);)</code>||<code>v30 = v30 / v32; or v30 /= v32;</code>
|-
|<code>lindirectn(v30,4);)</code>||<code>*v30 = 4;</code>
|-
|<code>lindirectv(v30,v32);)</code>||<code>*v30 = v32;</code>
|-
|<code>rindirect(v30,v32);)</code>||<code>v30 = *v32;</code>
|}
</blockquote>

&nbsp;

==== <code>if</code> structures and test commands ====

An <code>if</code> structure looks like this:

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
if (&lt;test commands&gt;) {
    &lt;action commands&gt;
}
</syntaxhighlight>
</blockquote>

or like this :

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
if (&lt;test commands&gt;) {
    &lt;action commands&gt;
}
else {
  &lt;more action commands&gt;
}
</syntaxhighlight>
</blockquote>

Carriage returns are not necessary:

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
if (&lt;test commands&gt;) { &lt;action Commands&gt; } else { &lt;more action commands&gt; }
</syntaxhighlight>
</blockquote>

Test commands are coded like action commands except there is no semicolon. They are separated by &amp;&amp; or || for AND or OR.

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
if (isset(f5) &&
    greatern(v5,6)) { ......
</syntaxhighlight>
</blockquote>

Again, carriage returns are not necessary within the if statement:

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
if (lessn(v5,6) && (greatern(v5,2)) { .......

if (isset(f90) && equalv(v32,v34)
    && greatern(v34,20)) { .......
</syntaxhighlight>
</blockquote>

A &quot;!&quot; placed in front of a command signifies a NOT.

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
if (!isset(f7)) {
  ......
</syntaxhighlight>
</blockquote>

Boolean expressions are not necessarily simplified so they must follow the rules set down by the file format. If test commands are to be ORed together, they must be placed in brackets.

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
if ((isset(f1) || isset(f2)) {
  ......

if (isset(f1) && (isset(f2) || isset(f3))) {
  ......

if (isset(1) || (isset(2) && isset(3))) {    is NOT legal
</syntaxhighlight>
</blockquote>

Depending on the compiler, simplification of boolean expressions may be supported, so the above may not apply in all cases (although if these are rules are followed then the logic will work with all compilers).

Substitutions for the following test commands are available:

<blockquote>
{| class="wikitable" width="275"
|-
|width="150"|<code>equaln(v30,4)</code>||width="125"|<code>v30 == 4</code>
|-
|<code>qualv(v30,v32)</code>||<code>v30 == v32</code>
|-
|<code>greatern(v30,4)</code>||<code>v30 &gt; 4</code>
|-
|<code>greaterv(v30,v32)</code>||<code>v30 &gt; v32</code>
|-
|<code>lessn(v30,4)</code>||<code>v30 &lt; 4</code>
|-
|<code>lessv(v30,v32)</code>||<code>v30 &lt; v32</code>
|-
|<code>!equaln(v30,4)</code>||<code>v30 != 4</code>
|-
|<code>!equalv(v30,v32)</code>||<code>v30 != v32</code>
|-
|<code>!greatern(v30,4)</code>||<code>v30 &lt;= 4</code>
|-
|<code>!greaterv(v30,v32)</code>||<code>v30 &lt;= v32</code>
|-
|<code>!lessn(v30,4)</code>||<code>v30 &gt;= 4</code>
|-
|<code>!lessv(v30,v32)</code>||<code>v30 &gt;= v32</code>
|}
</blockquote>

Also, flags can be tested for by just using the name of the flag:

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
if (f6) { .....

if (v7 &gt; 0 && !f6) { .....
</syntaxhighlight>
</blockquote>

&nbsp;

==== Argument types ====

There are 9 different types of arguments that commands use:

* Number (no prefix)
* Var (prefix &quot;v&quot;)
* Flag (prefix &quot;f&quot;)
* Message (prefix &quot;m&quot;)
* Object (prefix &quot;o&quot;)
* Inventory Item (prefix &quot;i&quot;)
* String (prefix &quot;s&quot;)
* Word (prefix &quot;w&quot;)
* Controller (prefix &quot;c&quot;)
<br />

The <code>said</code> test command uses its own special arguments which will be described later.

Each of these types of arguments is given by the prefix and then a number from 0--255, e.g. v5, f6, m27, o2.

The word type is words that the player has typed in, not words that are stored in the <code>words.tok</code> file. Strings are the temporary string variables stored in memory, not to be confused with messages (that are stored in the Logic resources). Controllers are menu items and keys.

Compilers can enforce type checking, so that the programmer must use the correct prefix for an argument so that they know they are using the right type. Decoders should display arguments with the right type.

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
move.obj(so4,80,120,2,f66);
if (obj.in.box(so2,30,60,120,40)) { .....
</syntaxhighlight>
</blockquote>

A complete list of the commands and their argument types is available as part of AGI Specs.

Messages and inventory items may be given in either numerical text format:

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
print("He's not here.");
print(m12);
if (has("Jetpack")) { .....
if (has(io9)) { .....
</syntaxhighlight>
</blockquote>

Messages can also be split over multiple lines:

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
print("This message is split "
      "over multiple lines.");
</syntaxhighlight>
</blockquote>

Quote marks must be used around messages and object names. This is important because some messages or object names may contain brackets or commas, which could confuse the compiler. This is also the case for the <code>said</code> command which will be described shortly.

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
if (has("Buckazoid(s)")) { .....        // no ambiguity here about where
                                        // the argument ends
</syntaxhighlight>
</blockquote>

The <code>said</code> test command uses different parameters to all the other commands. Where as the others use 8 bit arguments (0--255), <code>said</code> takes 16 bit arguments (0--65535). Also, the number of arguments in a <code>said</code> command can vary. The numbers given in the arguments are the word group numbers from the <code>words.tok</code> file.

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
if (said(4,80)) { .....
</syntaxhighlight>
</blockquote>

Words can also be given in place of the numbers:

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
if (said("look")) { .....
if (said("open","door")) { .....
</syntaxhighlight>
</blockquote>

Quote marks must also be used around the words.

&nbsp;

==== Labels and the goto command ====

Labels are given like this:

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
Label1:
</syntaxhighlight>
</blockquote>

The label name can contain letters, numbers, and the characters "_" and ".". No spaces are allowed.

The <code>goto</code> command takes one parameter, the name of a label.

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
goto(Label1);
</syntaxhighlight>
</blockquote>

&nbsp;

==== Comments ====

There are three ways that comments can be used.

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
// Rest of line is ignored
[  Rest of line is ignored
/* Text between these are ignored */
</syntaxhighlight>
</blockquote>

The /*...*/ can be nested:

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
/* comment start
  print(&quot;Hello&quot;);    // won't be run
  /*                 // a new comment start (will be ignored!)
    v32 = 15;        // won't be run
*/                   // uncomments the most inner comment
  print("Hey!");     // won't be run, still inside comments
*/                   // uncomments
</syntaxhighlight>
</blockquote>

&nbsp;

==== Defines ====

To give vars, flags etc. proper names the <code>#define</code> command is used. The name of the define is given followed by the define value:

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
#define ego o0
#define room_descr "This is a large hall with tall pillars down each side."
</syntaxhighlight>
</blockquote>

Then the define name can be used in place of the define value:

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
draw(ego);
print(room_descr);
</syntaxhighlight>
</blockquote>

Define names can only be used in arguments of commands (including <code>goto</code>s and the <code>v0 == 3</code> type syntax), although some compilers may allow you to use them anywhere.

Defines must be defined in the file before they are used.

The define name can contain letters, numbers, and the characters <code>'_'</code> and <code>.</code>. No spaces are allowed.

&nbsp;

==== Including files ====

You can include another file in your logic source code by using the <code>#include</code> command:

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
#include "file.txt"
</syntaxhighlight>
</blockquote>

When the compiler encounters the above line, it will replace it with the contents of <code>file.txt</code>.

It is a good idea to have all the defines that you need for multiple logics in an <code>#include</code> file, so if you need to change the define value you only have to do it once (although you will need to recompile all logics that use that define).

&nbsp;

==== More on messages ====

In some cases you may want to assign a specific number to a message so you can refer to it in other places. This is done by using the <code>#message</code> command, followed by the number of the message then the message itself:

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
#message 4 "You can't do that now."
</syntaxhighlight>
</blockquote>

Then you can give the message number as the parameter in commands:

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
print(m4);
</syntaxhighlight>
</blockquote>

Or embed the message in commands as normal and the number you assigned to it before will be used:

<blockquote> 
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
print("You can't do that now.");
</syntaxhighlight>
</blockquote>

<code>#message</code> can be used anywhere in the file, so you do not have to set the message before you use it.

&nbsp;

==== The return Command ====

The return command is just a normal action command (number 0), with no arguments. This must be the last command in every logic.

&nbsp;

== <div id="cmdref"></div><div id="ss4.2"></div><br />4.2 Reference of the Logic Commands ==

<div align="center">''From the AGDS documentation translated by [[agiw:Vassili Bykov|Vassili Bykov]]''<br />
''Additions/modifications by [[agiw:Claudio Matsuoka|Claudio Matsuoka]] and [[agiw:XoXus|XoXus]]''<br />
''Last update 22 May 1999''</div>

&nbsp;

==== Arithmetic Commands ====

Commands that operate on variables:

<div id="increment"></div>
'''<code>increment(n)</code>'''
<blockquote>
The value of the variable ''n'' is incremented by one, i.e. <code>v</code>''n'' = <code>v</code>''n''+1. If the value is already 255, it is left unchanged.
</blockquote>
  
<div id="decrement"></div>
'''<code>decrement(n)</code>'''
<blockquote>
The value of the variable <code>v</code>''n'' is decremented by one, i.e. <code>v</code>''n'' = <code>v</code>''n''-1. If the value is 0, it is left unchanged.    
</blockquote>

<div id="assign"></div>
'''<code>assign(n,m)</code>'''
<blockquote>
Variable <code>v</code>''n'' is assigned the value m, i.e. <code>v</code>''n'' = m  
</blockquote>
  
<div id="assignv"></div>
'''<code>assignv(n,m)</code>'''
<blockquote>
Variable <code>v</code>''n'' is assigned the value of <code>v</code>''m'', i.e. <code>v</code>''n'' = <code>v</code>''m''.
</blockquote>
    
<div id="addn"></div><div id="addv"></div>
'''<code>addn(n,m),addv(n,m)</code>'''
<blockquote>
The value of variable <code>v</code>''n'' is incremented by m (<code>v</code>''m''), i.e. <code>v</code>''n'' = <code>v</code>''n'' + m (<code>v</code>''m'').

If the value is greater than 255 the result wraps over 0 (so 250 + 10 == 4). (Information by [[agiw:XoXus|XoXus]])
</blockquote>
 
<div id="subn"></div><div id="subv"></div> 
* '''<code>subn(n,m), subv(n,m)</code>'''
<blockquote>
The value of <code>v</code>''n'' is decremented by m (<code>v</code>''m''), i.e. <code>v</code>''n'' = <code>v</code>''n'' - m (<code>v</code>''m'').

If the value is lesser than 0 the result wraps (so 1 - 2 == 255). (Information by [[agiw:XoXus|XoXus]])
</blockquote>
  
<div id="lindirectn"></div>
'''<code>lindirectn(n,m)</code>'''
<blockquote>
Variable <code>v</code>''i'' where ''i'' is the value of <code>v</code>''n'' is assigned a value m, i.e. Var(<code>v</code>''n'') = m.
</blockquote>
 
<div id="lindirectv"></div>
'''<code>lindirectv(n,m)</code>'''
<blockquote>
Variable <code>v</code>''i'' where ''i'' is the value of <code>v</code>''n'' is assigned the value of <code>v</code>''m'', i.e. Var(<code>v</code>''n'') = <code>v</code>''m''.
</blockquote>
    
<div id="rindirect"></div>
'''<code>rindirect(n,m)</code>'''
<blockquote>
Variable <code>v</code>''n'' is assigned the value of <code>v</code>''i'' where ''i'' is the value of <code>v</code>''m'', i.e. <code>v</code>''n'' = Var(<code>v</code>''m'').
</blockquote>

<div id="muln"></div>
'''<code>muln(n,m)</code>'''
<blockquote>
Variable <code>v</code>''n'' is multiplied by m, i.e. <code>v</code>''n'' = <code>v</code>''n'' * m.
</blockquote>

<div id="mulv"></div>
'''<code>mulv(n,m)</code>'''
<blockquote>
Variable <code>v</code>''n'' is multiplied by the value of <code>v</code>''m'', i.e. <code>v</code>''n'' = <code>v</code>''n'' * <code>v</code>''m''.

''(What happens on overflow? --VB)''
</blockquote>

<div id="divn"></div>
'''<code>divn(n,m)</code>'''
<blockquote>
Variable <code>v</code>''n'' is divided by m, i.e. <code>v</code>''n'' = <code>v</code>''n'' / m.
</blockquote>

<div id="divv"></div>
'''<code>divv(n,m)</code>'''
<blockquote>
Variable <code>v</code>''n'' is divided by the value of <code>v</code>''m'', i.e. <code>v</code>''n'' = <code>v</code>''n'' / <code>v</code>''m''.

''(What happens on division by 0? --VB)''
</blockquote>

<div id="random"></div>
'''<code>random(n,m,k)</code>'''
<blockquote>
Variable <code>v</code>''k'' is assigned a random value in the range between n and m. Now let us consider the commands changing flag values. Remember that a flag can only have a value 0 or 1.
</blockquote>
    
<div id="set"></div>
'''<code>set(n)</code>'''
<blockquote>
<code>f</code>''n'' is set to 1.
</blockquote>

<div id="set.v"></div>
'''<code>set.v(n)</code>'''
<blockquote>
<code>f</code>''i'', where ''i'' is the value of <code>v</code>''n'', is set to 1. i.e. flag(<code>v</code>''n'') = 1.
</blockquote>

<div id="reset"></div>
'''<code>reset(n)</code>'''
<blockquote>
<code>f</code>''n'' is set to 0.
</blockquote>
  
<div id="reset.v"></div>
'''<code>reset.v(n)</code>'''
<blockquote>
<code>f</code>''i'', where ''i'' is the value of <code>v</code>''n'', is set to 0, i.e. flag(<code>v</code>''n'') = 0.
</blockquote>

<div id="toggle"></div>
'''<code>toggle(n)</code>'''
<blockquote>
<code>f</code>''n'' toggles its value.
</blockquote>
   
<div id="toggle.v"></div>
'''<code>toggle.v(n)</code>'''
<blockquote>
<code>f</code>''i'', where ''i'' is the value of <code>v</code>''n'', i.e. flag(<code>v</code>''n''), toggles is value.
</blockquote>

&nbsp;

==== Commands to load and unload resources ====

Commands in this chapter load (into the interpreter's memory) and unload (discard, thus freeing interpreter's memory) Logic, Picture, View, and Sound resources. Always remember that the internal memory of the interpreter is 64K. This restriction is rarely a problem, but do not forget about it.

When the internal memory is full, the program has to be broken into parts which are loaded and unloaded as the story unfolds in the given room, or Picture, View, and Sound resources have to be manipulated using the commands below.

Remember that when a resource is unloaded, all resources loaded after it ''are also automatically unloaded''!

<div id="load.logic"></div>
'''<code>load.logic(n)</code>'''
<blockquote>
Load into memory the Logic resource number ''n'', i.e. Logic(n)
</blockquote>

'''<code>load.logic.v(n)</code>'''
<blockquote>
Load into memory the Logic resource number ''i'', where ''i'' is the value of <code>v</code>''n'', i.e. Logic(<code>v</code>''n'')  
</blockquote>
  
<div id="load.pic"></div> 
'''<code>load.pic(n)</code>'''
<blockquote>
Loads into memory the PICTURE resource number ''i'', where ''i'' is the value of <code>v</code>''n'', i.e. Picture(<code>v</code>''n'')<br />
&nbsp;<br />


''(This may be a mistake in the original: I would expect this command to be <code>load.pic.v</code>, while <code>load.pic(n)</code> would load resource number ''n''. --VB)''<br />
&nbsp;<br />


''(<code>load.pic.v</code> may be a more appropriate name for it, but the name above is what they gave it. There is no equivalent command that takes a number rather than a variable. --LE)''
</blockquote>

<div id="load.view"></div>
'''<code>load.view(n)</code>'''
<blockquote>
Loads into memory the View resource number ''n'', i.e. View(n).
</blockquote>
   
<div id="load.view.v"></div>
'''<code>load.view.v(n)</code>'''
<blockquote>
Loads into memory the View resource number ''i'', where ''i'' is the value of <code>v</code>''n'', i.e. View(<code>v</code>''n'')
</blockquote>
 
<div id="load.sound"></div>
'''<code>load.sound(n)</code>'''
<blockquote>
Loads into memory the SOUND resource number ''n'', i.e. Sound(n).<br />
&nbsp;<br />


''(Note that there is no <code>load.sound.v</code> listed. I wonder if this is a mistake or there really is no way to load a sound with indirection (unlikely, I think) --VB)''<br />
&nbsp;<br />


''(There really is no way of loading a sound with indirection. The command doesn't exist. --LE)''
</blockquote>
   
<div id="discard.pic"></div>
'''<code>discard.pic(n)</code>'''
<blockquote>
Unloads PICTURE resource number ''i'', where ''i'' is the value of <code>v</code>''n''.
</blockquote>
   
<div id="discard.view"></div>
'''<code>discard.view(n)</code>'''
<blockquote>
Unload View resource number ''n'', i.e. View(''n'').
</blockquote>
   
<div id="discard.view.v"></div>
'''<code>discard.view.v(n)</code>'''
<blockquote>
Unloads View resource number ''i'' where ''i'' is the value of <code>v</code>''n'', i.e. View(<code>v</code>''n'').<br />
&nbsp;<br />


''(And what about <code>discard.logic</code>, <code>discard.logic.v</code>, <code>discard.sound</code>, and <code>discard.sound.v</code>? --VB)''<br />
&nbsp;<br />


''(There must be some other way that those commands are removed from memory, because the commands you mention above don't exist. --LE)''
</blockquote>

&nbsp;

==== Program control commands ====

new.room command is one of the most powerful commands of the interpreter.

It is used to change algorithms of the object behaviour, props, etc. Automatic change of Ego coordinates imitates moving into a room adjacent to the edge of the initial one. ''(Sounds awkward but that's what it says. --VB)''

The format of the command:

<div id="new.room"></div><div id="new.room.v"></div>
* '''<code>new.room(n), new.room.v(n)</code>'''
<blockquote>
These commands do the following:

# Commands <code> [[#stop.update|stop.update]]</code> and <code>unanimate</code> are issued to all objects;
# All resources except Logic(0) are discarded;
# Command <code> [[#player.control|player.control]]</code> is issued;
# <code>[[#unblock|unblock]]</code> command is issued;
# <code>set.horizon(36)</code> command is issued;
# <code>v1</code> is assigned the value of <code>v0</code>; <code>v0</code> is assigned ''n'' (or the value of <code>v</code>''n'' when the command is <code> [[#new.room.v|new.room.v]]</code>); <code>v4</code> is assigned 0; <code>v5</code> is assigned 0; <code>v16</code> is assigned the ID number of the View resource that was associated with Ego (the player character).
# Logic(i) resource is loaded where ''i'' is the value of <code>v0</code> !
# Set Ego coordinates according to <code>v2</code>: 
## if Ego touched the bottom edge, put it on the horizon:
## if Ego touched the top edge, put it on the bottom edge of the screen;
## if Ego touched the right edge, put it at the left and vice versa.
# <code>v2</code> is assigned 0 (meaning Ego has not touched any edges).
# <code>f5</code> is set to 1 (meaning in the first interpreter cycle after the new_room command all initialization parts of all logics loaded and called from the initialization part of the new room's logic will be called. In the subsequent cycle <code>f5</code> is reset to 0 (see section [[AGI Specifications: Chapter 3 - AGI Internals#workcycle|Interpreter work cycle]] and [[AGI Specifications: Chapter 13 - Other Information#thunderstorm|the source of the &quot;Thunderstorm&quot; program]]. ''This is very important!'').
# Clear keyboard input buffer and return to the main AGI loop.
</blockquote>
&nbsp;

==== Subroutine call commands ====

<div id="call"></div>
* '''<code>call(n), call.v(n)</code>'''
<blockquote>
Logic resource number ''n'' (or number ''i'' where i the value of <code>v</code>''n'') is executed as a subroutine. If the logic with the given ID is not loaded in memory, it is temporarily loaded and discarded after returning from the call (this takes extra time). <code> [[#call|call]]</code> does not change any variables or flags.    
</blockquote>

<div id="return"></div>
* '''<code>return</code>'''
<blockquote>
This command returns control to the interpreter if it is executed in Logic(0), or to the command following the call command which called the current logic.
</blockquote>

'''<code>jump &lt;label></code>'''
<blockquote>
This command unconditionally transfers control to a command starting after label <code>label</code> within the same logic.
</blockquote>
   
<div id="set.scan.start"></div><div id="reset.scan.start"></div>
'''<code>set.scan.start(), reset.scan.start()</code>'''
<blockquote>
Normally, when a logic is called using call command, execution begins at the first instruction. <code> [[#set.scan.start|set.scan.start]]</code> command sets the entry point at the command following it, while <code> [[#reset.scan.start|reset.scan.start]]</code> returns the entry point to the beginning.
</blockquote>
&nbsp;

==== Object control commands ====

The interpreter controls the movement of objects in the screen automatically checking the following conditions:

* If an object priority is 0 it cannot cross an unconditional barrier (pixels with priority 0). 
* If an object priority is 15 and a command <code>ignore.block</code> has not been given to it, it cannot cross a conditional barrier (pixels with priority 1) and leave the block set using the <code> [[#block|block]]</code> command. 
* If an object has not been given <code> [[#ignore.horizon|ignore.horizon]]</code> command, it cannot move above the horizon set using the <code> [[#set.horizon|set.horizon]]</code> command. 
* An object should follow the conditions set using <code> [[#object.on.water|object.on.water]]</code> and <code> [[#object.on.land|object.on.land]]</code> commands (see below).<br />


Object number 0 is called Ego. It is different from others in that the player may move it around using the keyboard.

&nbsp;

==== Object description commands ====

<div id="animate.obj"></div>
'''<code>animate.obj(n)</code>'''
<blockquote>
Object number ''n'' is included in the list of object controlled by the interpreter. ''Objects not included in that list are considered inexistent!''
</blockquote>

<div id="unanimate.all"></div>
'''<code>unanimate.all()</code>'''
<blockquote>
All objects are removed from the control list and are considered inexistent.
</blockquote>

<div id="set.view"></div>
'''<code>set.view(n,m), set.view.v(n,m)</code>'''
<blockquote>
Object ''n'' is associated with a View resource number ''m'' (or pointed to by <code>v</code>''m''), which may be an image of the object.
</blockquote>

<div id="set.loop"></div>
'''<code>set.loop(n,m), set.loop.v(n,m)</code>'''
<blockquote>
Chooses a loop m (or <code>v</code>''m'') in the View resource associated with the object ''n''.
</blockquote>

<div id="fix.loop"></div>
'''<code>fix.loop(n)</code>'''
<blockquote>
Turns off automatic choice of loop number for the object number ''n''.
</blockquote>

<div id="release.loop"></div>
'''<code>release.loop(n)</code>'''
<blockquote>
Turns on automatic choice of loop number depending on the direction of motion of the object ''n''.<br />
&nbsp;


{| border="1px" cellspacing="0" cellpadding="0" bordercolor="#F2F2F2"
|<pre>
                      1
                8     |     2
                  \   |   /
                    \ | /
              7 ------------- 3      0 - object stands still
                    / | \
                  /   |   \
                6     |     4
                      5
   
</pre>
|}

Automatic choice of the loop is done according to the table: 

* for objects with fewer than 4 but more than 1 loops: 

<blockquote>
{|
|-
|Direction &nbsp;||width="20"|<code>0</code>||width="20"|<code>1</code>||width="20"|<code>2</code>||width="20"|<code>3</code>||width="20"|<code>4</code>||width="20"|<code>5</code>||width="20"|<code>6</code>||width="20"|<code>7</code>||width="20"|<code>8</code>
|-
|Loop ||width="20"|<code>x</code>||width="20"|<code>x</code>||width="20"|<code>0</code>||width="20"|<code>0</code>||width="20"|<code>0</code>||width="20"|<code>x</code>||width="20"|<code>1</code>||width="20"|<code>1</code>||width="20"|<code>1</code> 
|-
|
|}
</blockquote>

* for objects with more than 4 loops: 

<blockquote>
{|Direction
|-
|Direction &nbsp;||width="20"|<code>0</code>||width="20"|<code>1</code>||width="20"|<code>2</code>||width="20"|<code>3</code>||width="20"|<code>4</code>||width="20"|<code>5</code>||width="20"|<code>6</code>||width="20"|<code>7</code>||width="20"|<code>8</code>
|-
|Loop ||width="20"|<code>x</code>||width="20"|<code>3</code>||width="20"|<code>0</code>||width="20"|<code>0</code>||width="20"|<code>0</code>||width="20"|<code>2</code>||width="20"|<code>1</code>||width="20"|<code>1</code>||width="20"|<code>1</code>
|}
</blockquote>

<code>x</code> means that the current loop number is retained.
</blockquote>
  
<div id="set.cel"></div> 
'''<code>set.cel(n,m), set.cel.v(n,m)</code>'''
<blockquote>
Selects a cel ''m'' in the current loop of the object ''n''.
</blockquote>

<div id="last.cel"></div>
'''<code>last.cel(n,m)</code>'''
<blockquote>
The number of the last cel of the current loop of the object ''n'' is stored in <code>v</code>''m''.
</blockquote>

<div id="current.cel"></div>
'''<code>current.cel(n,m)</code>'''
<blockquote>
The number of the current cel of the object ''n'' is stored in <code>v</code>''m''.
</blockquote>

<div id="current.loop"></div>
'''<code>current.loop(n,m)</code>'''
<blockquote>
The number of the current loop of the object ''n'' is stored in <code>v</code>''m''.
</blockquote>

<div id="current.view"></div>
'''<code>current.view(n,m)</code>'''
<blockquote>
The number of the current View resource associated with the object ''n'' is stored in <code>v</code>''m''.
</blockquote>

<div id="set.priority"></div>
'''<code>set.priority(n,m), set.priority.v(n,m)</code>'''
<blockquote>
Set priority of the view of the object ''n'' to ''m'' (or <code>v</code>''m'').
</blockquote>

<div id="release.priority"></div>
'''<code>release.priority(n)</code>'''
<blockquote>
Turns on the automatic priority choice for the object ''n''. The priority is set depending on the vertical coordinate of the object. This way, as an object moves down it approaches the viewer. See section [[AGI Specifications: Chapter 2 - Overview#bands|Priority bands and control lines]] for a table of y coordinates and the associated priorities.
</blockquote>

<div id="get.priority"></div>
'''<code>get.priority(n,m)</code>'''
<blockquote>
The value of the current priority of the object ''n'' is stored in <code>v</code>''m''.
</blockquote>

<div id="position"></div>
'''<code>position(n,x,y), position.v(n,x,y)</code>'''
<blockquote>
Coordinates of the object ''n'', not yet displayed on the screen, are set to ''x'' and ''y'' (or <code>v</code>''x'' and <code>v</code>''y'').
</blockquote>

<div id="draw"></div>
'''<code>draw(n)</code>'''
<blockquote>
Object ''n'' is shown on the screen. The image uses the values of the loop and the cel in the View resource associated with the object ''n'' (see <code> [[#set.view|set.view]]</code>), as well as the priority and coordinates of the object. If a command <code> [[#start.cycling|start.cycling]]</code> is also issued, a looped animation for object ''n'' is shown until stopped (for example, with <code> [[#stop.cycling|stop.cycling]]</code>).
</blockquote>

<div id="erase"></div>
'''<code>erase(n)</code>'''
<blockquote>
Object ''n'' is erased from the screen.
</blockquote>
  
<div id="get.posn"></div>
'''<code>get.posn(n,x,y)</code>'''
<blockquote>
Coordinates of the object ''n'' are stored in <code>v</code>''x'' and <code>v</code>''y''. Coordinates of the object are coordinates of the base point (bottom left corner) of cels of the View resource associated with the object.<br />
&nbsp;<br />


The interpreter automatically plays the animation (a loop in the View resource) associated with the object, starting at the specified cel. The following commands control this process.
</blockquote>

<div id="start.cycling"></div>
'''<code>start.cycling(n)</code>'''
<blockquote>
Enables automatic change of cels in a chosen (using <code> [[#set.loop">set.loop]]</code>) loop of a View resource associated with the object ''n'' (using <code>[[#set.view">set.view]]</code>).
</blockquote>

<div id="stop.cycling"></div> 
'''<code>stop.cycling(n)</code>'''
<blockquote>
Disables automatic change of cels in a chosen (using <code> [[#set.loop|set.loop]]</code>) loop of a View resource associated with the object ''n'' (using <code>[[#set.view|set.view]]</code>).
</blockquote>

<div id="normal.cycle"></div>
'''<code>normal.cycle(n)</code>'''
<blockquote>
Cels of the loop associated with the object ''n'' follow in a normal order: 0, 1, 2, ..., ''k''-1, 0, 1, 2, ...
</blockquote>

<div id="reverse.cycle"></div>
'''<code>reverse.cycle(n)</code>'''
<blockquote>
Cels of the loop associated with the object ''n'' follow a reverse order: ''k''-1, ''k''-2, ..., 1, 0, ''k''-1, ''k''-2, ..., 1, 0, ...
</blockquote>

<div id="end.of.loop"></div>
'''<code>end.of.loop(n,m)</code>'''
<blockquote>
Plays the loop associated with the object ''n'' once, from the current cel to the last. When finished, <code>f</code>''m'' is set to 1.
</blockquote>

<div id="reverse.loop"></div>
'''<code>reverse.loop(n,m)</code>'''
<blockquote>
Plays the loop associated with the object ''n'' once in a reverse order, from the current cel to the first. When finished, <code>f</code>''m'' is set to 1.
</blockquote>

<div id="cycle.time"></div>
'''<code>cycle.time(n,m)</code>'''
<blockquote>
<code>v</code>''m'' sets the time in interpreter cycles between cel changes for the object n. When <code>v</code>''m'' = 1 cels are changed every cycle.
</blockquote>

&nbsp;

==== Object motion control commands ====

The following commands can be given to the object included in the interpreter control list with <code> [[#animate.obj|animate.obj]]</code>:

<div id="set.horizon"></div> 
'''<code>set.horizon(n)</code>'''
<blockquote>
Set the horizon to y = ''n''
</blockquote>
    
<div id="ignore.horizon"></div>
'''<code>ignore.horizon(n)</code>'''
<blockquote>
Object ''n'' moves regardless of the horizon position.
</blockquote>

<div id="observe.horizon"></div>
'''<code>observe.horizon(n)</code>'''
<blockquote>
Object ''n'' cannot move above the horizon.
</blockquote>

<div id="block"></div>
'''<code>block(x1,y1,x2,y2)</code>'''
<blockquote>
Sets a rectangular area (block). 
</blockquote>

<blockquote>

{| border="1px" cellspacing="0" cellpadding="0" bordercolor="#F2F2F2"
|<code><pre>
(x1, y1)
   +----------------+
   |                |
   |                |
   |                |
   +----------------+
                 (x2, y2)
</pre></code>
|}
</blockquote>

<div id="unblock"></div>
'''<code>unblock()</code>'''
<blockquote>
Cancels previously set block.
</blockquote>
  
<div id="ignore.blocks"></div>
'''<code>ignore.blocks(n)</code>'''
<blockquote>
Object ''n'' moves ignoring conditional barriers (pixels with priority 1) and a block set with the <code> [[#block|block]]</code> command.
</blockquote>

<div id="observe.blocks"></div>
'''<code>observe.blocks(n)</code>'''
<blockquote>
Object ''n'' may not cross conditional barriers or leave the block.
</blockquote>

<div id="ignore.objs"></div>
'''<code>ignore.objs(n)</code>'''
<blockquote>
Object ''n'' moves regardless of positions of other objects.
</blockquote>

<div id="observe.objs"></div> 
'''<code>observe.objs(n)</code>'''
<blockquote>
Object ''n'' treats other objects as obstacles.
</blockquote>

<div id="player.control"></div>
'''<code>player.control()</code>'''
<blockquote>
The player is allowed to control Ego (object number 0) using the keyboard or the joystick.
</blockquote>

<div id="program.control"></div>
'''<code>program.control()</code>'''
<blockquote>
The player is not allowed to control object 0 (Ego).
</blockquote>

<div id="stop.motion"></div>
'''<code>stop.motion(n)</code>'''
<blockquote>
Motion of object ''n'' is stopped. If ''n'' == 0, <code> [[#program.control|program.control]]</code> is automatically executed.
</blockquote>

<div id="start.motion"></div>
'''<code>start.motion(n)</code>'''
<blockquote>
Motion of object ''n'' is started. If ''n'' == 0 (Ego), <code> [[#player.control|player.control]]</code> automatically executed.
</blockquote>

<div id="step.size"></div>
'''<code>step.size(n,m)</code>'''
<blockquote>
<code>v</code>''n'' determines the number of pixels the object ''n'' moves each step. ''(The actual value in pixels is the step size / 4! --CM)''
</blockquote>

<div id="step.time"></div>
'''<code>step.time(n,m)</code>'''
<blockquote>
<code>v</code>''n'' determines the speed of object ''n'' motion: delay in the interpreter cycles between consecutive steps. If <code>v</code>''m'' = 1, step occurs on every cycle.
</blockquote>

<div id="move.obj"></div>
'''<code>move.obj(n,x,y,s,m), move.obj.v(n,x,y,s,m)</code>'''
<blockquote>
Object ''n'' is told to move to the point ''(x,y)'' (or <code>v</code>''x'', <code>v</code>''y'') by s pixels every step. When the destination is reached, <code>f</code>''m'' is set to 1. If ''n'' == 0 (Ego), <code> [[#program.control|program.control]]</code> is executed automatically.
</blockquote>

<div id="follow.ego"></div>
'''<code>follow.ego(n,s,m)</code>'''
<blockquote>
Object ''n'' is told to chase object 0 (Ego) by ''s'' pixels every step. When Ego and object coordinates become equal, <code>f</code>''m'' is set to 1.
</blockquote>

<div id="wander"></div>
'''<code>wander(n)</code>'''
<blockquote>
Object ''n'' randomly changes the direction of its motion (wanders). If ''n'' == 0 (Ego), <code> [[#program.control|program.control]]</code> is issued automatically.
</blockquote>

<div id="normal.motion"></div>
'''<code>normal.motion(n)</code>'''
<blockquote>
Special object motion mode is canceled. The object continues to move in the direction it was moving in at the time the command was issued.
</blockquote>

<div id="set.dir"></div>
'''<code>set.dir(n,m)</code>'''
<blockquote>
Object ''n'' is told to move in the direction <code>v</code>''m''.
</blockquote>

<blockquote>
{| border="1px" cellspacing="0" cellpadding="0" bordercolor="#F2F2F2"
|<pre>
                      1
                8     |     2
                  \   |   /
                    \ | /
              7 ------------- 3      0 - stop
                    / | \
                  /   |   \
                6     |     4
                      5
</pre>
|}
</blockquote>

<div id="get.dir"></div>
'''<code>get.dir(n,m)</code>'''
<blockquote>
Direction of object ''n'' motion is stored in <code>v</code>''m''.
</blockquote>

<div id="object.on.water"></div>
'''<code>object.on.water(n)</code>'''
<blockquote>
Object ''n'' is allowed to be only in the area where its base line is completely on pixels with priority 3 (water surface).
</blockquote>

<div id="object.on.land"></div>
'''<code>object.on.land(n)</code>'''
<blockquote>
Object ''n'' is not allowed to touch pixels of water surface (priority 3).
</blockquote>

<div id="object.on.anything"></div>
'''<code>object.on.anything(n)</code>'''
<blockquote>
Motion restrictions previously set on the object ''n'' with commands <code> [[#object.on.water|object.on.water]]</code> or <code>object.on.land</code> are cancelled.
</blockquote>

<div id="reposition"></div>
'''<code>reposition(n,dx,dy)</code>'''
<blockquote>
Object ''n'' jumps from its current location into the location with coordinates (''x'' + <code>v</code>''dx'', ''y'' + <code>v</code>''dy'').<br />
&nbsp;<br />

''(Shouldn't there be reposition and reposition.v? --VB)''<br />
&nbsp;<br />

''(There should be, but they don't exist. --LE)''
</blockquote>

<div id="reposition.to"></div>
'''<code>reposition.to(n,x,y), reposition.to.v(n,x,y)</code>'''
<blockquote>
Similar to the preceding command, but the object is moved to the point ''x'', ''y'' (<code>v</code>''x'',<code>v</code>''y'').
</blockquote>

<div id="stop.update"></div>
'''<code>stop.update(n)</code>'''
<blockquote>
Object ''n'' is removed from the list of objects updated by the interpreter on each step. The object stays on the screen unchanged.
</blockquote>

<div id="start.update"></div>
'''<code>start.update(n)</code>'''
<blockquote>
Object ''n'' is redrawn on each interpreter step.
</blockquote>

<div id="force.update"></div>
'''<code>force.update(n)</code>'''
<blockquote>
Object ''n'' is redrawn immediately, without waiting for the end of the interpreter cycle.
</blockquote>

<div id="distance"></div>
'''<code>distance(n,m,d)</code>'''
<blockquote>
If both objects ''n'' and ''m'' are on the screen, then<br />
&nbsp;<br />


<code>v</code>''d'' = abs(x(n) - x(m)) + abs(y(n) - y(m)),<br />
&nbsp;<br />

  
otherwise <code>v</code>''d'' = 255.
</blockquote>

&nbsp;

==== Inventory item management commands ====

OBJECT resources, stored in a separate file <code>object</code>, are most often used to represent inventory items. An item is a structure which consists of a one-byte field called room and a string of text, the item name.

If the room field of an item is 255, the item belongs to the player. Otherwise the item is considered to be in the room with the corresponding ID number.

<div id="get"></div>
'''<code>get(n), get.v(n)</code>'''
<blockquote>
Stores 255 in room field of an object ''n'', which means that the player owns it.
</blockquote>

<div id="drop"></div> 
'''<code>drop(n)</code>'''
<blockquote>
Stores 0 in the room field of object ''n''.
</blockquote>

<div id="put"></div>
'''<code>put(n,m), put.v(n,m)</code>'''
<blockquote>
Stores the value ''m'' (or <code>v</code>''m'') in the room field of the object ''n''.
</blockquote>

<div id="get.room.v"></div>
'''<code>get.room.v(n,m)</code>'''
<blockquote>
Stores the value of the room field of object <code>v</code>''n'' in <code>v</code>''m''.
</blockquote>

<div id="status"></div>
'''<code>status()</code>'''
<blockquote>
The screen is switched to text mode; the top line displays &quot;You are carrying:&quot;, then the names of the object with room field equal to 255 are listed. If there are no such objects, the word &quot;nothing&quot; is displayed.<br />
&nbsp;<br />


If <code>f13</code> is set (allow item selection), a highlight appears which allows the player to select an item name. When <code>ENTER</code> is pressed, the selected object number is stored in <code>v25</code>. When <code>ESC</code> is pressed, 255 is stored in <code>v25</code>.
</blockquote>

&nbsp;

==== Picture resource management commands ====

The following commands operate on PICTURE resources, loaded in the interpreter memory using <code> [[#load.pic|load.pic]]</code>:

<div id="draw.pic"></div>
'''<code>draw.pic(n)</code>'''
<blockquote>
A PICTURE resource number ''i'', where ''i'' is the value of <code>v</code>''n'' is executed. As the result, the background picture is created in the internal buffer of the interpreter. Before execution, the buffer is cleared, i.e. all pixels are set to color 15 and priority 4.
</blockquote>

<div id="overlay.pic"></div>
'''<code>overlay.pic(n)</code>'''
<blockquote>
Just like the above, only the internal buffer is not cleared before drawing. Picture(<code>v</code>''n'') is drawn over the existing picture.
</blockquote>

<div id="add.to.pic"></div>
'''<code>add.to.pic(a,b,c,d,e,f,g), add.to.pic.v(a,b,c,d,e,f,g)</code>'''
<blockquote>
A picture of a View resource is added to the background as its component. Typically, this is used to add small complicated details which would require too many PICTURE resource commands to draw.<br />
&nbsp;<br />

Parameters are:

* ''a'' (<code>v</code>''a''): number of the View resource;
* ''b'' (<code>v</code>''b''): loop number;
* ''c'' (<code>v</code>''c''): cel number;
* ''d'' (<code>v</code>''d''): x coordinate;
* ''e'' (<code>v</code>''e''): y coordinate;
* ''f'' (<code>v</code>''f''): priority;
* ''g'' (<code>v</code>''g''): margin.<br />
&nbsp;<br />


If margin is 0, 1, 2, or 3, the base of the cel is surrounded with a rectangle of the corresponding priority. If margin > 4, this extra margin is not shown.
</blockquote>

<div id="show.pic"></div>
'''<code>show.pic()</code>'''
<blockquote>
Shows internal buffer on the screen.<br />
&nbsp;<br />

''ATTENTION!'' Please use the following sequence of commands when loading PICTURE resources in the interpreter memory:<br />
&nbsp;<br />

<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
load.pic(n);
draw.pic(n);
discard.pic(n);
...
show.pic();
</syntaxhighlight><br />

Any other order may crash the interpreter without any diagnostic messages.
</blockquote>

&nbsp;

==== Sound resource management commands ====

<div id="sound"></div>
'''<code>sound(n,m)</code>'''
<blockquote>
Starts playback of the SOUND resource number n. When finished, <code>f</code>''m'' is set to 1.
</blockquote>

<div id="stop.sound"></div>
'''<code>stop.sound()</code>'''
<blockquote>
Stops the playback.
</blockquote>

&nbsp;

==== Text management commands ====

<div id="prevent.input"></div>
'''<code>prevent.input()</code>'''
<blockquote>
Prevents the user from entering anything using the keyboard.   
</blockquote>

<div id="accept.input"></div>
'''<code>accept.input()</code>'''
<blockquote>
Allows the user to enter text using the keyboard.
</blockquote>

<div id="print"></div>
'''<code>print(n), print.v(n)</code>'''
<blockquote>
Opens a text window in the center of the screen, where a message number ''n'' (or <code>v</code>''n'')

from the messages field of the current Logic resource is displayed. Output mode is determined by <code>f15</code> (see flag description). The message is a NULL-terminated string of text. In addition to letters, digits, and other symbols, the string may contain:<br />
&nbsp;<br />
 
* Newline character (0x0A);
* Format element: 
** <code>%v&lt;decimal number></code>: at this place the output will include a decimal value of variable with the given number.
** <code>%m &lt;number></code>: the text of the message with the given number is inserted at this place.
** <code>%0 &lt;number></code>: the name of the item with the given number is inserted at this place.
** <code>%w &lt;number></code>: a vocabulary word with the given number is inserted at this place.
** <code>%s &lt;number></code>: a string variable with the given number is inserted at this place.
** <code>%g &lt;number></code>: a message with this number from message field of Logic(0) is inserted at this place.
<br />

For <code>%v</code>, you can add a vertical line and a number of characters the output should take. In this case leading zeros are not suppressed in the output.<br />
&nbsp;<br />


Example: <code>%v34|2</code><br />
&nbsp;<br />


When you write your messages, remember that the interpreter wraps the text between the lines as needed when the message is displayed.
</blockquote>

<div id="display"></div>
'''<code>display(r,c,n), display.v(r,c,n)</code>'''
<blockquote>
Prints a message number ''n'' <code>v</code>''n'') in the row ''r'' (<code>v</code>''r''), starting with the column ''c'' (<code>v</code>''c''). No window is created, so it is up to the programmer to erase the output when it is no longer needed.
</blockquote>

<div id="print.at"></div><div id="print.at.v"></div>
'''<code>print.at(n,x,y,l), print.at.v(n,x,y,l)</code>'''
<blockquote>
Analogous to <code> [[#print|print]]</code> but the programmer can specify the window location. ''x'', ''y'', and ''l'' are constants specifying coordinates of the top left corner of the window and its width in character cells of a 40x25 screen.
</blockquote>

<div id="version"></div>
'''<code>version()</code>'''
<blockquote>
Prints interpreter version in the center of the screen.
</blockquote>

<div id="text.screen"></div>
'''<code>text.screen()</code>'''
<blockquote>
The screen switches to the text mode 40x25.
</blockquote>

<div id="graphics"></div>
'''<code>graphics()</code>'''
<blockquote>
The screen returns to the graphics mode. The picture on the screen is restored.
</blockquote>

<div id="set.cursor.char"></div>
'''<code>set.cursor.char(n)</code>'''
<blockquote>
First byte of the message ''n'' is used as a text mode cursor.
</blockquote>

<div id="set.text.attribute"></div>
'''<code>set.text.attribute(fg,bg)</code>'''
<blockquote>
Sets foreground and background colors for <code> [[#display|display]]</code>, <code>get.num</code> and <code> [[#get.string|get.string]]</code> commands.
</blockquote>

<div id="clear.lines"></div>
'''<code>clear.lines(n,m,c)</code>'''
<blockquote>
Clears text lines from ''n'' to ''m'' using color ''c''.
</blockquote>

<div id="clear.text.rect"></div>
'''<code>clear.text.rect(x1,y1,x2,y2,c)</code>'''
<blockquote>
Clears a rectangular area with top left corner coordinates ''(x1,y1)'' and bottom right coordinates ''(x2,y2)'' using color ''c''.
</blockquote>

<div id="status.line.on"></div>
'''<code>status.line.on()</code>'''
<blockquote>
Shows the status line containing the current score and sound status (on/off).
</blockquote>

<div id="status.line.off"></div>
'''<code>status.line.off()</code>'''
<blockquote>
Removes the status line.
</blockquote>

&nbsp;

==== String management commands ====

<div id="set.string"></div>
'''<code>set.string(n,m)</code>'''
<blockquote>
Stores message number ''m'' in the string variable ''n''.
</blockquote>
   
<div id="word.to.string"></div>
'''<code>word.to.string(n,m)</code>'''
<blockquote>
Word number ''m'' of the user input is stored in <code>s</code>''n''.
</blockquote>

<div id="get.string"></div>
'''<code>get.string(n,m,x,y,l)</code>'''
<blockquote>
User input is stored in <code>s</code>''n''. ''m'' is the number of the message used as the prompt. ''x'', ''y'' and ''l'' are input position and maximum string length.
</blockquote>

<div id="parse"></div>
'''<code>parse(n)</code>'''
<blockquote>
Parses <code>s</code>''n'' as if it was entered by the player.
</blockquote>

<div id="get.num"></div>
'''<code>get.num(n,m)</code>'''
<blockquote>
Enters a number from the keyboard into <code>v</code>''m''. Message ''n'' is used as the prompt.
</blockquote>

&nbsp;

==== Initialization commands ====

<div id="set.key"></div>
'''<code>set.key(s,c)</code>'''
<blockquote>
Set interpreter's special key. ''c'' is the key code (decimal number from 0 to 255) and ''s'' (if the key is a regular, or <code>CTRL</code>+key pair). the ASCII code (for example, <code>TAB</code> is 0x0009). If the key is a function key or <code>ALT</code>+key pair, the corresponding IBM-PC keyboard scan code is in the high byte of ''s''. For example, the scan code of <code>F1</code> is 0x3B00, <code>ALT</code>+<code>Z</code> is 0x2C00.

''Does &quot;key code&quot; mean the key scan code, or the ASCII code of the character? Is the IBM-PC scan code valid in other platforms as well? -- CM''
</blockquote>

<div id="set.game.id"></div>
'''<code>set.game.id(n)</code>'''
<blockquote>
Message n is scanned by the interpreter and compared with its internal identifier. On mismatch, the program exits. For the AGDS interpreter the identifier is &quot;TQ&quot;. See also section [[AGI Specifications: Chapter 3 - AGI Internals#gameid|Game IDs]].
</blockquote>

<div id="script.size"></div>
'''<code>script.size(n)</code>'''
<blockquote>
Sets the size of script table in bytes. Script table stores codes of some interpreter commands. It is needed by the interpreter to correctly reload resources when <code>restore_game</code> is executed.
</blockquote>

<div id="trace.info"></div>
'''<code>trace.info(n,m,l)</code>'''
<blockquote>
Sets the built-in debugger parameters. ''n'' is the number of Logic resource with command names, and ''m'' and ''l'' are the first line and height of the debugger window.
</blockquote>

<div id="trace.on"></div>
'''<code>trace.on()</code>'''
<blockquote>
Turns on the debugger. In general, the debugger is turned on with <code>SCROLL LOCK</code> key when the command name table is loaded even if this command does not occur in the program.
</blockquote>

<div id="log"></div>
'''<code>log(n)</code>'''
<blockquote>
This is a debugging command. It writes a log message in the format 

<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
Room &lt;current room&gt; Input line &lt;current input line&gt; ... message ...
</syntaxhighlight>
</blockquote>

where the message is given by number ''n''. Output is sent to a file.

''(Are these debugging commands valid only for AGDS, or they work in AGI as well? --CM)''
</blockquote>

&nbsp;

==== Menu management commands ====

Creating your program, you can offer the player a choice using a system of menus. These may be short one-line questions (menu header) with several answers (menu elements), or a prompt to change some of the system parameters, for example, object movement speed. Let us consider these commands.

<div id="set.menu"></div>
'''<code>set.menu(n)</code>'''
<blockquote>
Message ''n'' is used as the header of the menu elements which follow.
</blockquote>

<div id="set.menu.item"></div>
'''<code>set.menu.item(n,c)</code>'''
<blockquote>
Message <code>n</code> is used as a menu element, where ''c'' is this element's code (a number between 0 and 255).
</blockquote>

<div id="submit.menu"></div>
'''<code>submit.menu()</code>'''
<blockquote>
Ends menu creation.
</blockquote>

<div id="enable.item"></div>
'''<code>enable.item(c), disable.item(c)</code>'''
<blockquote>
Enables or disables a menu item with the code ''c''.


{| border="1px" cellspacing="0" cellpadding="0" bordercolor="#F2F2F2"
|<pre>
                              +-------- heading
                              v
                          +-----------------------------+
                          | File                        |
                          +------------+----------------+
               Menu   ---&gt;| Save       |
               Element    |------------|
                          | Restore    |
                          |------------|
                          |XXXXXXXXXXXX|&lt;---- menu element disabled
                          |------------|      using disable.item
                          | Quit       |
                          +------------+
   
</pre>
|}
</blockquote>

<div id="menu.input"></div>
'''<code>menu.input()</code>'''
<blockquote>
If <code>f14</code> is set, a menu system is shown on the screen, allowing the user to choose an item. Whether an item with the code c has been chosen can be tested using a command <code>controller(c)</code>, where ''c'' is the code assigned to the menu item.
</blockquote>

&nbsp;

==== Logical commands ====

==== Test commands ====

The result of test command can be either TRUE or FALSE.<br />
&nbsp;<br />

<div id="equaln"></div>
'''<code>equaln(n,m)</code>'''
<blockquote>
TRUE if <code>v</code>''n'' = ''m''.
</blockquote>

<div id="equalv"></div>
'''<code>equalv(n,m)</code>'''
<blockquote>
true if <code>v</code>''n'' = <code>v</code>''m''. 
</blockquote>
   
<div id="lessn"></div>
'''<code>lessn(n,m)</code>'''
<blockquote>
TRUE if <code>v</code>''n'' &lt; ''m''.
</blockquote>

<div id="lessv"></div>
'''<code>lessv(n,m)</code>'''
<blockquote>
TRUE if <code>v</code>''n'' &lt; <code>v</code>''m''.
</blockquote>

<div id="greatern"></div>
'''<code>greatern(n,m)</code>'''
<blockquote>
TRUE if <code>v</code>''n'' > ''m''.
</blockquote>

<div id="greaterv"></div>
'''<code>greaterv(n,m)</code>'''
<blockquote>
TRUE if <code>v</code>''n'' > <code>v</code>''m''.
</blockquote>

<div id="isset"></div>
'''<code>isset(n)</code>'''
<blockquote>
TRUE if <code>f</code>''n'' is set.
</blockquote>

'''<code>isset.v(n)</code>'''
<blockquote>
TRUE if Flag(<code>v</code>''n'') is set.
</blockquote>

<div id="has"></div>
'''<code>has(n)</code>'''
<blockquote>
TRUE if the room field of item ''n'' is 255, i.e. the item belongs to the player.
</blockquote>

<div id="obj.in.room"></div>
'''<code>obj.in.room(n,m)</code>'''
<blockquote>
TRUE if room field of the object ''n'' is <code>v</code>''m''.
</blockquote>

<div id="posn"></div>
'''<code>posn(n,x1,y1,x2,y2)</code>'''
<blockquote>
TRUE if the coordinates of the base point of the cel which is the current image of object ''n'' satisfies the equations ''x1'' &lt;= ''x'' &lt;= ''x2'' and ''y1'' &lt;= ''y'' &lt;= ''y2''.    
</blockquote>

<div id="obj.in.box"></div>
'''<code>obj.in.box(n,x1,y1,x2,y2)</code>'''
<blockquote>
TRUE if the base of the object ''n'' is completely within the rectangle specified using its top left ''(x1,y1)'' and bottom right ''(x2,y2)'' corners. 

<blockquote>

{| border="1px" cellspacing="0" cellpadding="0" bordercolor="#F2F2F2"
|<code><pre>
(x1, y1)
   +----------------+
   |                |
   |                |
   |                |
   +----------------+
                  (x2, y2)
</pre></code>
|}
</blockquote>
</blockquote>

'''<code>center.position(n,x1,y1,x2,y2)</code>'''
<blockquote>
TRUE of the center of the base line of the object ''n'' is inside the rectangle specified as its top left and bottom right corners.
</blockquote>

'''<code>right.position(n,x1,y1,x2,y2)</code>'''
<blockquote>
TRUE of the right side of the base line of the object ''n'' is inside the rectangle specified as its top left and bottom right corners.
</blockquote>

<div id="have.key"></div>
'''<code>have.key()</code>'''
<blockquote>
TRUE if the user has pressed any key on the keyboard. Used to create cycles to wait until any key is pressed.
</blockquote>

<div id="compare.strings"></div>
'''<code>compare.strings(s1,s2)</code>'''
<blockquote>
TRUE if <code>s1</code> == <code>s2</code>.
</blockquote>

<div id="said"></div>
'''<code>said(n,W(i))</code>'''
<blockquote>
where ''i'' = 1, ..., ''n''.<br />


See section [[AGI Specifications: Chapter 3 - AGI Internals#parsing|Player input parsing]].
</blockquote>

<div id="controller"></div>
'''<code>controller(n)</code>'''
<blockquote>
TRUE if the event with code ''n'' has occurred: 

* A key with the code ''n'' was pressed (set using <code>set_key</code>);
* Menu item with code ''n'' was selected in command <code>menu_input</code>.
</blockquote>

&nbsp;

==== Other commands ====

<div id="configure.screen"></div>
'''<code>configure.screen(a,b,c)</code>'''
<blockquote>
Sets position of lines on the screen, where ''a'' = 1 (the minimum line number for print), ''b'' is the user input line and ''c'' is the status line.
</blockquote>

''(Sounds confuse --CM)''    
<div id="obj.status.v"></div>
'''<code>obj.status.v(n)</code>'''
<blockquote>
Prints a message for the object <code>v</code>''n'' in the format
</blockquote>

<blockquote>
<code>Obj &lt;n&gt; x: &lt;pos&gt; y: &lt;pos&gt; pri: &lt;priority&gt; stepsize: &lt;step size&gt;.</code>
</blockquote>
   
<div id="show.mem"></div>
'''<code>show.mem()</code>'''
<blockquote>
Displays a report of the interpreter memory status.
</blockquote>

<div id="show.pri.screen"></div>
'''<code>show.pri.screen()</code>'''
<blockquote>
Shows priorities of the screen pixels. Priority n is shown as color number ''n'' (see color setting commands in I.1.2.1.1).
</blockquote>

<div id="show.obj"></div>
'''<code>show.obj(n)</code>'''
<blockquote>
Show cel 0 of loop 0 of the View resource ''n'' in the bottom center of the screen. In the center of the screen, a message associated with the View resource is printed.<br />
&nbsp;<br />

''(That's what they say but I suspect they mean OBJECT n, not View resource. --VB)''<br />
&nbsp;<br />

''(Actually, in this case the argument does refer to the View resource. This is because the View in question isn't meant to be a controlled object but instead is simply the picture and textual description of the an inventory item. --LE)''    
</blockquote>

<div id="shake.screen"></div>
'''<code>shake.screen(n)</code>'''
<blockquote>
The screen shakes ''n'' times.    
</blockquote>

<div id="echo.line"></div>
'''<code>echo.line()</code>'''
<blockquote>
The last line entered by the user is displayed in the input line.    
</blockquote>

<div id="cancel.line"></div>
'''<code>cancel.line()</code>'''
<blockquote>
Input line is cleared.    
</blockquote>

<div id="close.window"></div>
'''<code>close.window()</code>'''
<blockquote>
If there is a text window on the screen, it is removed.    
</blockquote>

<div id="open.dialogue"></div>
'''<code>open.dialogue, close.dialogue()</code>'''
<blockquote>
Enables and disables <code> [[#get.string|get.string]]</code> and <code>get.num</code> commands if <code> [[#prevent.input|prevent.input]]</code> has been issued.    
</blockquote>

<div id="restart.game"></div>
'''<code>restart.game()</code>'''
<blockquote>
Restarts the game from the very beginning.    
</blockquote>

<div id="save.game"></div><div id="restore.game"></div>
'''<code>save.game, restore.game()</code>'''
<blockquote>
These command save and restore the current state of the game into disk files.    
</blockquote>

<div id="pause"></div>
'''<code>pause()</code>'''
<blockquote>
Stops the interpreter until any key is pressed.    
</blockquote>

<div id="quit"></div>
'''<code>quit(n)</code>'''
<blockquote>
Exits the interpreter. If ''n'' = 1, quits immediately. If ''n'' = 0, asks &quot;Press ENTER to quit. Press ESC to continue.&quot;    
</blockquote>

<div id="init.joy"></div>
'''<code>init.joy()</code>'''
<blockquote>
Initialize joystick.    
</blockquote>

<div id="toggle.monitor"></div>
'''<code>toggle.monitor()</code>'''
<blockquote>
Switch RGB monitor into the graphics mode.
</blockquote>

'''<code>upper.left()</code>'''
<blockquote>
Usually the crossing by an object of various areas and lines is tracked by the base point (bottom right corner) of its cel. After this command, top left corner is used as such a point.
</blockquote>

&nbsp;

==== Other commands 2 ====

<div align="center">''Described by [[agiw:Dark Minister|Dark Minister]]''<br />
''(Last update: 13 October 1998).''</div>

&nbsp;

<div id="unknown170"></div>
'''<code>unknown170(n)</code>'''
<blockquote>
This command modifies the behavior of the commands [[#restore.game|restore.game()]] and [[#save.game|save.game()]].<br />
&nbsp;<br />

After calling <code>unknown170(n)</code>, where ''n'' is a string number (ie: if ''n'' == 2 then <code>s2</code>) [[#restore.game|restore.game()]] will automatically (without any prompt) restore a savegame with the name stored in string number ''n'' and [[#save.game|save.game()]] will automatically save a savegame with the name of string number ''n''.<br />
&nbsp;<br />

Note: make sure that at least one savegame is present when you call [[#restore.game|restore.game()]] or [[#save.game|save.game()]] (that is, when saving a game too).<br />
&nbsp;<br />

<div class="CodeBlockHeader">Example:</div>
<syntaxhighlight lang="agi">
set.string(s1,"test");
unknown170(1);
</syntaxhighlight>

will automatically load the savegame named &quot;test&quot;.
</blockquote>

<div id="unknown173"></div>
'''<code>unknown173(n)</code>'''
<blockquote>
This command changes the way that ego is controlled. After calling <code>unknown173()</code>, Ego will only move when a direction key is maintained pressed. If the key is released, ego will stop walking. See also command [[#unknown181|unknown181()]].
</blockquote>

<div id="unknown177"></div>
'''<code>unknown177(n)</code>'''
<blockquote>
This command control the access to the menu. <code>unknown177(0)</code> will disable access to the menu, even if flag 14 (<code>menu_enabled</code>) is set. Calling <code>unknown177()</code> with a value greater than 0 seem to do nothing else than enabling access to the menu.
</blockquote>

<div id="unknown181"></div>
'''<code>unknown181(n)</code>'''

<blockquote>This command reestablishes the default control of Ego. It is normally used after a call to [[#unknown173|unknown173()]]

</blockquote>
'''Note:'''Be aware that commands 175, 176, 178, 179 and 180 of the last version of AGI (ver 3.002.149) do absolutely nothing.

&nbsp;

== <div id="kq4code"></div><div id="ss4.3"></div><br />4.3 Discussion of Sample Logic Code from KQ4 ==

<div align="center">''(Last updated: 31 August 1997)''</div>

&nbsp;

Some of you may know that &quot;The Official Book of King's Quest&quot; included three small fragments of AGI code for room 7 in the AGI version of KQ4. These fragments are given below along with the same fragments taken from the game itself. There are a few differences which is to be expected but generally the code is very similar. These examples show how the coder wrote the code and what it now looks like in the final product. I've included a few comments where some interesting observations can be seen.

&nbsp;

==== Animating the smoke ====

From the book:
<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
animate.obj( smoke);
ignore.horizon( smoke);
set.view( smoke, v.fish.cabin);
set.loop( smoke, 1);
ignore.blocks( smoke);
position( smoke, 95, 16);
work = 3;
step.time( smoke, work);
cycle.time( smoke, work);
draw( smoke);
</syntaxhighlight>
</blockquote>

From the game:
<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
animate.obj(7);
ignore.horizon(7);
set.view(7, 114);
set.loop(7, 1);
ignore.objs(7);                [ These two lines have been added.
set.priority(7, 5);            [
ignore.blocks(7);
position(7, 95, 16);
assignn(152, 3);               [ Equivalent to 'work = 3;'
step.time(7, 152);
cycle.time(7, 152);
draw(7);
</syntaxhighlight>
</blockquote>

&nbsp;

==== Opening the door ====

From the book:
<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
if (said( open, door)) {     [ must be close enough
  if (posn( ego, 86, 120, 106, 133)) {
    if (!night) {
      if ( door.open) {
        print("The door is already open."
      }
      else {
        set( game.control);
        set.priority( ego, 11);
        start.update( door);
        end.of.loop( door, door.done);
      }
    }
    else {
      print("You can't -- it's locked"
    }
  }
  else {
    set( notCloseEnough);
  }
}
</syntaxhighlight>
</blockquote>

From the game:
<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
if (said(OPEN, DOOR||DOORS||DOORWAY||DOORWAYS)) {
  if (posn(0, 86, 120, 106, 133)) {
    if (!isset(38)) {
      if (isset(231)) {
        print("The door is already open.");
      }
      else {
        set(36);
        prevent.input();
        start.update(5);
        assignn(152, 3);
        cycle.time(5, 152);
        end.of.loop(5, 232);
        sound(70, 154);
      }
    }
    else {
      print("You can't.  It's locked and you
             don't have the key.");
    }
  }
  else {
    set(113);
  }
}
</syntaxhighlight>
</blockquote>

&nbsp;

==== Unlocking the door ====

From the book:
<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
if (said( unlock, door)) {     [must be close enough
  if (posn( ego, 86, 120, 106, 133)) {
    if (!night) {
      print("The door is already unlocked. . ."
    }
    else {
      printf("You can't, it's locked. . ."
    }
  }
  else {
    set( notCloseEnough);
  }
}
</syntaxhighlight>
</blockquote>

From the game:
<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
if (said(UNLATCH||UNLOCK, DOOR||DOORS||DOORWAY||DOORWAYS)) {
  if (posn(0, 86, 120, 106, 133)) {
    if (!isset(38)) {
      print("The door is already unlocked.");
    }
    else {
      print("You can't.  It's locked and you
             don't have the key.");
    }
  }
  else {
    set(113);
  }
}
</syntaxhighlight>
</blockquote>

&nbsp;

==== Knocking on the door ====

From the book:
<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
if ((said( knock, at, door) || said( knock) ||
     said( knock, on, door) || said( knock, door)) {
  if (posn( ego, 86, 120, 106, 133)) {
    if (!night) {
      print("You knock on the door. . .
             a woman says. . ."
    }
    else {
      printf("You knock on the. . .
              a man calls out. . ."
    }
  }
  else {
    set( notCloseEnough);
  }
}
</syntaxhighlight>
</blockquote>

From the game:
<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
if (said(BANG||KNOCK||RAP||TAP) ||
    said(BANG||KNOCK||RAP||TAP, DOOR||DOORS||DOORWAY||DOORWAYS)) {
  if (posn(0, 86, 120, 106, 133)) {
    if (!isset(38)) {
      print("You assertively knock on the shanty
             door.  A woman's voice answers, ''Jest come on in!''");
    }
    else {
      print("You assertively knock on the shanty
             door.  From inside, a man's voice calls out, ''D'ya know
             what TIME it is?!  GO AWAY!!''");
    }
  }
  else {
    set(113);
  }
}
</syntaxhighlight>
</blockquote>

&nbsp;

==== Fall rocks ====

From the book:
<blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">
if (hit.special) {
  if ((rf2 || rf3 || rf4)) {
    reset(hit.special);
    get.posn(ego, priorx, priory);
    position.f(dude, priorx, priory);
    ignore.blocks(dude);
    set( game.control);
    set.view( dude, v.ego.land);
    if ((ego.dir == 3 || ego.dir == 4)) {
      set.loop( dude, 2);
    }
    else {
      set.loop( dude, 3);
    }
    fix.loop(dude);
    work = 3;
    step.size( dude, work);
    work = 3;
    cycle.time( dude, work);
    start.cycling(dude);
    erase(ego);
    draw(dude);
    if (rf3) {
      work6 = 0;
      move.obj.f( dude, tempx, tempy, work6, fall.done);
    }
    if (rf4) {
      work6 = 0;
      move.obj.f( dude, tempx, tempy, work6, fall.done);
    }
    if (rf2) {
      if (priory &lt; 125) {
        set.priority( dude, 9);
        tempy=132;
        work6=0;
        move.obj.f( dude, ego,x, tempy, work6, fall.done);
      }
      else {
        set.priority(dude, 15);
        tempy = 156;
        work6 = 0;
        move.obj.f( dude, ego.x, tempy, work6, fall.done);
      }
    }
  }
}
</syntaxhighlight>
</blockquote>

From the game:
 <blockquote>
<div class="CodeBlockHeader">Code:</div>
<syntaxhighlight lang="agi">

if (isset(3)) {     [ hit.special
  if (isset(222) || isset(223) || isset(224)) {     [ rf2, rf3, rf4
    reset(3);
    sound(51, 154);
    get.posn(0, 134, 135);
    position.v(12, 134, 135);
    ignore.blocks(12);
    set(36);
    prevent.input();
    set.view(12, 11);
    if (equaln(6, 3) || equaln(6, 4)) {
      set.loop(12, 2);
    }
    else {
      set.loop(12, 3);
    }
    fix.loop(12);
    assignn(152, 3);
    step.size(12, 152);
    assignn(152, 3);
    cycle.time(12, 152);
    start.cycling(12);
    erase(0);
    draw(12);
    if (isset(223)) {
      assignn(158, 0);
      move.obj.v(12, 107, 108, 158, 226);
    }
    if (isset(224)) {
      assignn(158, 0);
      move.obj.v(12, 107, 108, 158, 226);
      set.priority(12, 14);
    }
    if (isset(222)) {
      if (lessn(135, 125)) {
        set.priority(12, 9);
        assignn(108, 132);
        assignn(158, 0);
        move.obj.v(12, 33, 108, 158, 226);
      }
      else {
        set.priority(12, 14);
        assignn(108, 158);
        assignn(158, 0);
        move.obj.v(12, 33, 108, 158, 226);
      }
    }
  }
}
</syntaxhighlight>
</blockquote>

&nbsp;

[[Adventure Game Interpreter Specifications|Table of Contents]]

<span style="float: left">[[AGI Specifications: Chapter 3 - AGI Internals|&lt; Previous: Chapter 3 - AGI Internals]]</span><span style="float: right">[[AGI Specifications: Chapter 5 - Resource Formats|Next: Chapter 5 - Resource Formats &gt;]]</span>

&nbsp;

[[Category:References]]
[[Category:AGI References]]
[[Category:Documentation]]
[[Category:AGI Documentation]]