@database 002e4fd0-0 @master olaf:graal.guide @$VER: 1.0 @author "Per Thulin" @(c) "1995" @index HeddleyAutoIndex @remark Created with Heddley v1.1 (c) Edd Dumbill 1994 @node "Main" "" @next "GG_INTRO" GRAAL ON-LINE REFERENCE ======================= 2.0 beta (c) Per Thulin 1996 Short Introduction " link "GG_INTRO" 0} ======== Machine Requirements " link "GG_Requirements" 0} \ / version " link "News" 0} | | About Reference " link "GG_Reference" 0} | | Structure GRAAL " link "GG_STRUCTURE" 0} | | Syntax Conventions " link "GG_Syntax" 0} \ / Limitations, Ranges, Reserved Numbers " link "GG_Limits" 0} || Special Characters Strings " link "GG_Vars" 0} ==== GRAAL player interface " link "GG_Interface" 0} Statements graal.main " link "GG_ST_MAIN" 0} Statements n.section files " link "GG_ST_SECT" 0} Statements n.room files " link "GG_ST_ROOM" 0} Conditions " link "GG_Conditions" 0} Commands " link "GG_Commands" 0} Trouble-shooting " link "Troubleshooting" 0} @endnode @node "GG_INTRO" " A Very Short Introduction " @next "GG_Requirements" @prev "GG_INTRO" @{fg shine}@{bg fill}A Very Short Introduction@{fg text}@{bg back} What is GRAAL? GRAAL is a computer language that lets you create graphic adventures in "classic" format using no more than a text editor and a paint/animation package. If you want to see what the result may look like, just play the Olaf 1 to which this guide is attached. Throughout this online reference, the files that make up the demo adventure are used to show working examples of how to construct an adventure using all the available statements and commands. (Just make sure the @{b}graal.guide@{ub} file and all Olaf 1 demo files are in the drawer, otherwise the links from this guide to the script files don't work!) ------------------------------------------------------------------------ @{i}NOTE@{ui}: The registered version of GRAAL contains some programming tools essential for the serious adventure creator, for example devices to un-comment and encrypt your scripts to make it impossible to crack the game by looking at the files. However, the function of the freely distributable version is not limited any other way - you may create as large an adventure as you wish using the GRAAL program contained in the demo package, if you have the stamina perseverence to do so...! ------------------------------------------------------------------------ @endnode @node "GG_Requirements" " Machine Requirements " @next "GG_Reference" @prev "GG_INTRO" @{fg highlight}@{bg fill}MACHINE REQUIREMENTS@{fg text}@{bg back} To develop GRAAL games, you need the following: * A hard disk * 2MB RAM The following is very much recommended: * A machine with at least the speed of an A1200 * Fast RAM @endnode @node "News" " News in version 2 " @{fg shine}@{bg fill}News in GRAAL 2@{fg text}@{bg back} Welcome to GRAAL 2, a massive addition to (and overhaul of) GRAAL 1.2. There are quite a number of new features and enhancements in this version of GRAAL. In the on-line reference, you will see the word *NEW* next to the short descriptions of many statements and commands, indicating they are either completely new or significantly enhanced. Be sure to read the README file for a walk-through of the new features and changes to the system, as well as a description of the bug fixes. Once I delved into the depths of GRAAL 1.2, I found bugs that could make your heart stop. I am certain that most have been erased now, although I am equally certain new ones have been introduced instead. Please bear with me and report them to pethu@wmdata.com @endnode @node "GG_Reference" " About this Tutorial " @next "GG_STRUCTURE" @prev "GG_Requirements" @{fg shine}@{bg fill}About this Reference@{fg text}@{bg back} I recommend all developers to read the GRAAL Tutorial prior to emerging too deep into the art of GRAAL writing. The GRAAL Tutorial is included in the GRAAL 1.0 unregistered development package. Although it is possible to construct an adventure with no other information than the one given in this reference, it is not recommended. That said, Amos Pro users stand a better chance than others of succeeding witout too much pain inflicted, because some Amos Pro concepts are used straight "off the shelf" in GRAAL - for example, animation sequences, hotspots, and fades. @endnode @node "GG_STRUCTURE" " The Structure of a GRAAL Game " @next "GG_Syntax" @prev "GG_Reference" @{fg shine}@{bg fill}GRAAL script structure@{fg text}@{bg back} A GRAAL adventures is based on a number of script files, related other in the following way: +-------------+ | graal.main | +------+------+ | +------------------+----------------+ | | +----+-----+ +----+-----+ |n.section | . . . |n.section | +----+-----+ +----+-----+ | | +--------+--------+ +---------------+ | | | | | +---+---++---+---++---+---+ +---+---+ +---+---+ |n.room ||n.room ||n.room | |n.room | |n.room | +-------++-------++-------+ +-------+ +-------+ There is always a @{"graal.main" link "GG_ST_MAIN" 0} file, describing the characteristics game and of the main character (which is the player controls and commands). The entire adventure is divided into locations or "rooms" called in GRAAL. The specifics of each room is defined in a @{"n.room" link "GG_ST_ROOM" 0} file The rooms may be grouped into sections, as shown above. Each section has a @{"n.section" link "GG_ST_SECT" 0} file. The general idea is that if a player can issue a certain command certain thing in just one specific room, the GRAAL handle action should be placed in the corresponding .room script file. action occur anywhere in the section , the code is placed in .section file; and if the action is something that can occur anywhere in adventure, it is taken care of in the graal.main file. Whenever the player inputs a command, first the current scanned for appropriate action, then the section file, lastly graal.main file. This is why the graal.main file should always contain general "safety nets" to handle most of the totally off-the-wall generally stupid things a player may try during the game! Apart from the three script file types above, there are two other types specific purposes: @{".scene" alink "1.scene/1.scene/main" 0} files, containing the commands making up an animated, non-interactive "cut-scene". @{".ptrn" alink "1.ptrn/main" 0} files, containing animation patterns too big and complex to code of a script file. @endnode @node "GG_Syntax" " Syntax Conventions " @next "GG_Limits" @prev "GG_STRUCTURE" @{fg shine}@{bg fill} GRAAL Syntax @{fg text}@{bg back} @{u}@{fg highlight}Script Syntax@{uu}@{fg text} Scripts can normally contain @{b}empty lines@{ub}, @{b}comment lines@{ub}, and @{b}statement lines@{ub}. (Exceptions are the @{b}.scene@{ub} files, which only contain commands, and @{b}.ptrn@{ub} files, which only contain animation patterns.) Comment lines always begin with the characters @{b}/*@{ub}. Statement lines always begin with the statement followed by a colon and one blank space. After that comes the parameters separated by semicolons, but without spaces in between, like this: @{b}STATEMENT: parameter;parameter;parameter;...;parameter@{ub} In the following statements, each parameter is a condition or command: @{"ACTION" link "ST_ACTION" 0} - Actions taken for player input @{"DACT" link "ST_DACT" 0} - Actions executed when entering a new room @{"LACT" link "ST_LACT" 0} - Actions taken when player chooses a dialogue line Each condition and command then has its own "internal" syntax. Usually, parameters within a command are separated by colons (,). Some statements and command allow you to leave parameter positions "blank" to retain a previous value or set a default value. "blank" does not mean "empty": You MUST enter a blank space in the position! For example, if you wish to leave the two middle parameters of the SHOW command empty, this is the way to do it: SHOW 2, , ,4 (This example tells GRAAL to use image number 4 to display object 2, but let the image remain in its old place, since we left the x and y parameters blank.) @{u}@{fg highlight}Command and Statement Notation@{uu}@{fg text} @{b}UPPERCASE@{ub} Type as written. @{b}lowercase@{ub} Replace with value of specified type. @{b}list@{ub} A list of values separated with | characters may be used. In conditions, any value in the list will make the condition TRUE. In commands, one of the alternatives in the list will be chosen at random each time the command is encountered during gameplay. @{b}option1|option2@{ub} One of the options can be chosen. @{b}[parameter,]@{ub} This parameter is optional. @{u}@{fg highlight}Referring to the Contents of the Input Sentence@{uu}@{fg text} When the scripts are searched for commands to execute, what happens is based entirely on how the current input sentence from the player looks. IN this reference, the first object in the current command sentence input by the player is referred to as @{b}OBJ1@{ub}, and the second - if any - as @{b}OBJ2@{ub}. The "command" itself is referred to as the @{b}VERB@{ub}. @{u}@{fg highlight}Referring to Objects and Images@{uu}@{fg text} An @{b}object number@{ub} can be an ordinary number (@{b}n@{ub}), a room object number (@{b}ROBJn@{ub}) or a section object number (@{b}SOBJn@{ub}). An @{b}image number@{ub} can be an ordinary global image (@{b}n@{ub}), a room image (@{b}RBOBn@{ub}) or a section image (@{b}SBOBn@{ub}). @endnode @node "GG_Limits" " Limitations, Ranges, Reserved Numbers " @next "GG_Vars" @prev "GG_Syntax" @{fg shine}@{bg fill} GRAAL Limits, Ranges & Reserved Numbers @{fg text}@{bg back} These are basic technical limitations to GRAAL 2. @{i}SCREEN GRAPHICS@{ui} @{b}SCENE AREA@{ub}: Background pictures must be lowres, 32 or 64 (EHB) colours, and between 320 and 640 pixels wide. (IFF picture files used for clipart must also be the same number of colours.) @{b}COMMAND AND DIALOGUE AREAS@{ub}: Pictures used must be hires, and 640 pixels wide. (No more than 16 colours.) @{i}BOBS AND BOB IMAGES@{ui} Allowed BOB numbers for general use: 1-59 Allowed BOB image numbers for general use: 11-any number BOB images assigned: 1-10 - Reserved for system use. @{i}ANIMATION@{ui} Animation channels allowed for general use: 3-15 @{i}STATEMENT AND COMMAND LIMITS@{ui} Item Limit Alterable ----------------------------------------- ------ -------------- Max no of DACT lines in room file 50 Y (graal.main) Max no of concurrent dialogues 6 Y -"- Max no of dialogue lines per dialogue 30 Y -"- Max no of LACT statements per dialogue 90 Y -"- Max no of ACTION lines in a room 120 N Max no of ACTION lines in a section 200 N Number of flags for each object 6 N Number of flags for each room 20 N Maximum number of floors in a room 12 N Maximum number of paths in a room 12 N Max.no of objects in the inventory 50 N Max no of objects in current room 30 N (displayed simultaneously, not counting BOBON, STATIC:, ANIM: graphics) @endnode @node "GG_Vars" " Variables in Text Strings " @next "GG_Vars" @prev "GG_Limits" @{fg shine}@{bg fill}Special text characters@{fg text}@{bg back} The following special character strings are replaced with variable values etc. when used in SAY, THINK, RESP, and similar commands @{b}\ @{ub} is replaced with a line break @{b}#R#n#f#@{ub} will be replaced by the value held in flag f for room n @{b}#O#n#f#@{ub} will be replaced by the value held in flag f for object n @{b}#OBJ1@{ub} will be replaced by the name of OBJ1 @{b}#OBJ2@{ub} will be replaced by the name of OBJ2 @{b}#Won@{ub} will be replaced by determination word n for object o (That is, o should be 1 for OBJ1, or 2 for OBJ2.) @{b}#TIME@{ub} will be replaced by the current game time in the format specified in the @{"TIME_FORMAT" link "ST_TIMEFORMAT" 0} statement.. @{b}#DATE@{ub} will be treplaced by the current game date in the format specified by the @{"DATE_FORMAT" link "ST_DATEFORMAT" 0} statement. Example: OBJ1 is "apple", and word 1 for the object "apple" has been defined as "an". The command SAY Just #W11 #OBJ1! will then cause the character to say Just an apple! @endnode @node "GG_Commands" "GRAAL Commands" @next "GG_WAIT" @prev "GG_Commands" @{bg fill}GRAAL Commands:@{bg back} These are all the commands that can be used in the @{"ACTION" link "ST_ACTION" 0}, @{"DACT" link "ST_DACT" 0}, and @{"LACT" link "ST_LACT" 0} statements, as well as in cutscene files. @{i}General program flow control@{ui} W(ait) " link "GG_WAIT" 0} Make a pause " link "GG_EXIT" 0} Stop searching for commands to execute " link "GG_REDO" 0} Re-run current input sentence CUTSCENE " link "GG_CUTSCENE" 0} Execute a cutscene " link "GG_MARK" 0} Mark current position *NEW* RESUME " link "GG_RESUME" 0} Resume marked position *NEW* " link "GG_Quit" 0} Quit GRAAL @{i}Timed events@{ui} DOAFTER " link "GG_DOAFTER" 0} Set a timer *NEW* CANCEL " link "GG_CANCEL" 0} Cancel a timer *NEW* @{i}Dialogue control@{ui} " link "GG_DSET" 0} Start / change a dialogue " link "GG_LINE" 0} Change dialogue line number " link "GG_EDLG" 0} End a dialogue @{i}Sentence control@{ui} " link "GG_OBJ" 0} Change object number " link "GG_VERB" 0} Change verb number @{i}Room control@{ui} " link "GG_GOTO" 0} Go to a new room SETRF " link "GG_SETRF" 0} Set room flag value *NEW* ADDRF " link "GG_ADDRF" 0} Add to room flag value *NEW* DECRF " link "GG_DECRF" 0} Decrease room flag value SHOWEXIT " link "SHOWEXIT" 0} Show a hideen exit *NEW* HIDEEXIT " link "HIDEEXIT" 0} Hide an exit *NEW* @{i}"Speech"@{ui} " link "GG_SAY" 0} Make character speak THINK " link "GG_THINK" 0} Make character think " link "GG_RESP" 0} Make speaking partner respond @{i}Object manipulation@{ui} HANDLE " link "GG_HANDLE" 0} Make character handle object *NEW* " link "GG_PICK" 0} Make character pick up object " link "GG_GET" 0} Add object to inventory REMOVE " link "GG_REMOVE" 0} Remove object from inventory " link "GG_NAME" 0} Alter the name of an object " link "GG_ICON" 0} Alter the icon image for inventory *NEW* " link "GG_PREP" 0} Alter the preposition for an object NEWOBJ " link "GG_NEWOBJ" 0} Create or modify an object SETOF " link "GG_SETOF" 0} Set object flag value *NEW* ADDOF " link "GG_ADDOF" 0} Add to object flag value *NEW* DECOF " link "GG_DECOF" 0} Decrease object flag value @{i}Object display@{ui} OMOVE " link "GG_OMOVE" 0} Move and animate object " link "GG_SHOW" 0} Show object *NEW* " link "GG_HIDE" 0} Hide object OBJONTOP " link "GG_OBJONTOP" 0} Put object on top of other objects *NEW* @{i}Main character display@{ui} " link "GG_CBOB" 0} Change character image CMOVE " link "GG_CMOVE" 0} Move character " link "GG_MOBJ" 0} Move character next to object MEXIT " link "GG_MEXIT" 0} Move character to exit " link "GG_CPOS" 0} Change character position " link "GG_CHAR" 0} Hide / display character @{i}Floor control@{ui} FLOOR " link "GG_FLOOR" 0} Define floor NFLOOR " link "GG_NFLOOR" 0} Set number of floors SETFLOOR " link "GG_SETFLOOR" 0} Change character's floor @{i}Audio control@{ui} TRACK " link "GG_TRACK" 0} Soundtracker module control SAMLOAD " link "GG_SAMLOAD" 0} Load raw or IFF sample " link "GG_SAMPLAY" 0} Sample control @{i}Graphics control@{ui} CLPART " link "GG_CLPART" 0} Load a clipart picture file " link "GG_BOBS" 0} Grab BOB images from clipart picture HOTSP " link "GG_HOTSP" 0} Alter the hotspot of an image LIGHTS " link "GG_LIGHTS" 0} Fade scene area in or out COLOUR " link "GG_COLOUR" 0} Change a single colour " link "GG_FADE" 0} Fade one colour to another CAMERA " link "GG_CAMERA" 0} Pan the camera to any part of background TITLE " link "GG_TITLE" 0} Display / remove a title screen " link "GG_TYPE" 0} Type text on title screen " link "GG_TEXT" 0} Display text in scene area *NEW* BOBON " link "GG_BOBON" 0} Show a BOB BOBOFF " link "GG_BOBOFF" 0} Remove a BOB " link "GG_PBOB" 0} Paste a BOB image @{i}Time and date manipulation@{ui} SETDATE " link "GG_SETDATE" 0} Set the date *NEW* SETTIME " link "GG_SETTIME" 0} Set the time *NEW* ADDTIME " link "ADDTIME" 0} Advance the time *NEW* SAVETIME " link "GG_SAVETIME" 0} Save the current time and date *NEW* RESTORETIME " link "GG_RESTORETIME" 0} Restore the saved time and date *NEW* @{i}Restore the saved time and date Special Cutscene commands:@{ui} NOBREAK " link "GG_NOBREAK" 0} Disable [Esc] in cutscene FINAL " link "GG_FINAL" 0} Marks cutscene [Esc] resume point @endnode @node "GG_Conditions" "GRAAL Conditions" @next "GG_IFOBJ" @prev "GG_Conditions" @{bg fill}GRAAL Conditions:@{bg back} These are the conditions that can be used in the @{"ACTION" link "ST_ACTION" 0}, @{"DACT" link "ST_DACT" 0}, @{"LACT" link "ST_DACT" 0}, and @{"LINE" link "ST_LINE" 0} statements. IFOBJ IFOBJ2 " link "GG_IFOBJ" 0} Test objects in the input sentence IFOF2 " link "GG_IFOF" 0} Test object flags *NEW* IFROOM " link "GG_IFROOM" 0} Test current room " link "GG_IFRF" 0} Test room flags *NEW* IFCARR IFNOTCARR " link "GG_IFCARR" 0} Test if object is in inventory IFPICK " link "GG_IFPICK" 0} Test if object can be picked up IFTYPE " link "GG_IFTYPE" 0} Test object types IFSPOS " link "GG_IFSPOS" 0} Test room starting position IFCBOB " link "GG_CBOB" 0} Test current character image *NEW* IFFLOOR " link "IFFLOOR" 0} Test the current floor *NEW* IFDATE " link "GG_IFDATE" 0} Test the date *NEW* IFTIME " link "GG_IFTIME" 0} Test the time *NEW* IFWEEKDAY " link "GG_WEEKDAY" 0} Test the day of the week *NEW* @endnode @node "GG_Animation" "animation sequences" @{fg shine}@{bg fill}Basics about GRAAL Animation@{fg text}@{bg back} Most simple animation sequences used in GRAAL have the following format: @{b} A n,(image,time)(image,time)(image,time)...(image,time)@{ub} @{b}n@{ub} is a number deciding how many times the animation sequence is played - in GRAAL, it is set to 0 in most cases, which means the animation will go on "forever". Forever in this case means "until GRAAL decides to put a stop to @{b}image@{ub} is an image number. @{b}time@{ub} is the time the image is displayed before the next one comes on screen (in 50ths of a second on PAL machines). Example: A 0,(RBOB1,12)(RBOB2,12)(RBOB3,12)(RBOB4,12) would play the sequence of four room BOB images over and over again. Note that the commas are not GRAAL parameter separators in this case - they are all part of the same sequence definition! @endnode @node "GG_Interface" " The GRAAL player interface" @{fg shine}@{bg fill}The GRAAL Player Interface@{fg text}@{bg back} Although the graphics of the player interface can be changed very much to your liking, all GRAAL games play in pretty much the same way. It presents the alternatives to the user in a very clear and precise way to let them know exactly what objects can be manipulated and what options are available at any time. This is an attempt to explain the elements of GRAAL's intuitive control method. which is really much harder than just doing it:) It also contains some "style guide" tips... SENTENCE AND OBJECT DISPLAYS: ============================= OBJECTS IN THE SCENE AREA: As soon as the mouse cursor moves over an object with a name consisting of anything but an empty string, its name appears above the cursor. IF there is a default command associated with the object, AND neither a verb or other object has actually been clicked by the player, the default command for the object beneath the mouse cursor is shown in the sentence box. IF a verb has been previously clicked, the name of the object also appears in the sentence box. IF the verb / object combination requries a second object to beclicked, the appropriate preposition is also displayed in the sentence box. OBJECTS IN THE INVENTORY: Currently, the default verb or object name is NOT displayed by just moving the mouse cursor over an object in the inventory. However, all objects that can be put in the inventory should have the default command LOOK, so that a right mouse-button click looks at the inventory object. VERBS: IF you move the mouse cursor over a verb in the command area, AND no verb has been clicked, the name of the verb appears in the sentence box. EXITS: If you move the mouse pointer over an exit, and the name of the exit is anything but an empty string, its name apperas above the mouse cursor. Note that object and exit cursor texts in most cases SHOULD be coloured differently, so that players don't accidently leaves a room and wastes a lot of time. KEYBOARD KEYS ============= PLAYER KEYS These keys are avaliable regardless of whether the system is in developer or runtime mode: S and L both bring up the same save/load requester. space puts the game in pause mode. Any key continues. F displays the amount of free memory (mainly for debugging purposes.) V displays the adventure name and version information. I increases the speed of sentence displays. D decreases the speed of sentence displays. Q quits the game. (May be disabled by the DISABLE_QUIT: statement, is you provide another way to QUIT.) DEVELOPER KEYS G brings up the monitor screen. R starts a macro recording. Pressing R again stops the macro recording and asks for a name for the new macro. P asks for a macro name, then starts playing it. ctrl+c aborts GRAAL. Use only in emergencies, as this does not clean up memory, leaves FONTS: assigned to RAM:FONTS, etc. leftA+m (A="Amiga") switches between GRAAL and Workbench. Note that programs running concurrently will be sluggish, and only the fonts in your GRAAL FONTS: drawer will be available. (That's why I have included the DPAINT font in the drawer, because I sometimes need to run that in parallell...) @endnode @node "GG_IFOBJ" " IFOBJ / IFOBJ2 " @next "GG_IFPICK" @prev "GG_Conditions" @{fg shine}@{bg fill}IFOBJ Condition@{fg text}@{bg back} @{i}Test an object in the current sentence@{ui} @{b}IFOBJ obj|list@{ub} This condition is TRUE if the object number of OBJ1 is equal to obj, or to any one of the objects in a list. @{b}IFOBJ2 object number | list@{ub} Same thing, but checks OBJ2. @endnode @node "GG_IFPICK" " IFPICK " @next "GG_IFOF" @prev "GG_IFOBJ" @{fg shine}@{bg fill}IFPICK Condition@{fg text}@{bg back} @{i}Test if an object can be picked up@{ui} @{b} IFPICK [obj]@{ub} This condition is TRUE if OBJ1 (default) or the specified object can be picked up. Example: @{b} IFPICK;MOBJ;HANDLE;PICK;HANDLE -1@{ub} Move to object and pick it up only if it is defined as "pickable"! @endnode @node "GG_IFOF" " IFOF " @next "GG_IFROOM" @prev "GG_IFPICK" @{fg shine}@{bg fill}IFOF Condition@{fg text}@{bg back} @{i}Test the value of an object flag@{ui} @{b}IFOF [obj,]flagvalue|list@{ub} This condition is TRUE if the flag of OBJ1, or the specified object, passes the test (see below). @{b}IFOF2 flagvalue|list@{ub} This condition is TRUE if the flag of OBJ2 passes the test. This form is mainly kept for backwards compatibility - specify the object number of OBJ2 in the format above instead, if you have a choice. @{b}@{ub} op an be any of the standard logical operators: =, >, <, <>, >=, <= @{b}value@{ub} The value can be a fixed integer number or a reference to another flag. The format for flag references is #R#roomnumber#flag# or #O#objectnumber#flag. NOTE: flag references can only be used when testing a single value. That is, you cannot specify a list of flag references to test. @{b}list@{ub} If a list of values is specified, the condition is true if one of the list values makes the condition true. (There is no point in specifying a list if the operator is <> - c'mon, think about it!!) Examples: IFOF 2=3 is true if object flag 2 of OBJ1 is 3 IFOF 4,2>3 is true if object flag 2 of object 4 is greater than 3 IFOF 4=2|4|6|8 is true if object flag 2 of object 4 is 2,4,6, or 8. IFOF 7,4<>#R#3#1# is true if object flag 4 of object 7 is not equal to room flag 1 of room 3. @endnode @node "GG_IFROOM" " IFROOM " @next "GG_IFRF" @prev "GG_IFOF" @{fg shine}@{bg fill}IFROOM Condition@{fg text}@{bg back} @{i}Test the current room@{ui} @{b}IFROOM room|list@{ub} This condition is true if the current room matches the room number(s) specified. @endnode @node "GG_IFRF" " IFRF " @next "GG_IFCARR" @prev "GG_IFROOM" @{fg shine}@{bg fill}IFRF Condition@{fg text}@{bg back} @{i}Test the value of a room flag@{ui} @{b}IFRF [room,]flagvalue|list@{ub} The operator can be any of the following logical operators: =, <, >, <>, >=, <= The IFRF condition works the same way as the @{"IFOF" link "GG_IFOF" 0} condition, so click that to see a number of examples. @endnode @node "GG_IFCARR" " IFCARR / IFNOTCARR " @next "GG_IFTYPE" @prev "GG_IFRF" @{fg shine}@{bg fill}IFCARR Condition@{fg text}@{bg back} @{i}Test if object is in inventory@{ui} @{b}IFCARR [obj]@{ub} This condition is TRUE if the specified object is in the inventory. If no object number is specified, OBJ1 is assumed. @{b}IFNOTCARR [obj]@{ub} TRUE if the object is NOT in the inventory. @endnode @node "GG_IFTYPE" " IFTYPE " @next "GG_IFTYPE" @prev "GG_IFCARR" @{fg shine}@{bg fill}IFTYPE Condition@{fg text}@{bg back} @{i}Test if an object is of specified type(s)@{ui} @{b} IFTYPE type|list@{ub} This condition is TRUE if the type character matches any of the characters defined in the object type for OBJ1. For example, in standard GRAAL notation, an object defined as DW is (D)ead and made of (W)ood. IFTYPE D would be true, as would IFTYPE S|W (checking if the object is of either stone or wood). @{b} IFTYPE2 type|list@{ub} This condition checks OBJ2 according to the same rules as described for OBJ1 above. @endnode @node "GG_IFSPOS" " IFSPOS " @{fg shine}@{bg fill}IFSPOS Condition@{fg text}@{bg back} @{i}Test which starting position was last used@{ui} @{b}IFSPOS spos|list@{ub} This condition is TRUE, if the last GOTO command (or START_ROOM statement) pointed to the specified starting position (= START_POS statement). Its main use is setting the room up in different ways in DACT statements, depending on which entrance was being used. @endnode @node "GG_IFCBOB" " IFCBOB " @{fg shine}@{bg fill}IFCBOB Condition@{fg text}@{bg back} @{i}Test the currently displayed character image@{ui} @{b} IFCBOB image|list@{ub} This is TRUE if the image used to display the main character matches the number given in the condition. It could, for example, be useful in creating "stall anims" (see @{"DOAFTER" link "GG_DOAFTER" 0}) and other main character animations that should look different depending on the main character's current appearance. @endnode @node "IFFLOOR" " IFFLOOR " @{fg shine}@{bg fill}IFFLOOR Condition@{fg text}@{bg back} @{i}Tests the current floor@{ui} @{b}IFFLOOR floor|list@{ub} This condition is true if the main character is currently on any of the specified floors. @endnode @node "GG_IFDATE" " IFDATE " @{fg shine}@{bg fill}IFDATE Condition@{fg text}@{bg back} @{i}Test the game-date@{ui} @{b} IFDATE =|>|19960801 is true if the date has passed. IFDATE <#R#4#1# is true if the date is less than the value held in room flag 1 of room 4. @endnode @node "GG_IFTIME" " IFTIME " @{fg shine}@{bg fill}IFTIME Condition@{fg text}@{bg back} @{i}Test the game-time@{ui} @{b}IFTIME =|>|1130 is true if the clock is past 11:30 IFTIME <#O#1#8# is true if the time is less than the value held in object flag 8 of object @endnode @node "GG_WEEKDAY" " IFWEEKDAY " @{fg shine}@{bg fill}IFWEEKDAY Condition@{fg text}@{bg back} @{i}Tests the day of the week@{ui} @{b} IFWEEKDAY day_number|list@{ub} This condition is true if the weekday, according to the in-game calender, is matched by the number(s) specified. 1=Monday, 2=Tuesday, ... 7=Sunday. Are your shops open on Sunday? @endnode @node "GG_WAIT" " W(ait) " @next "GG_EXIT" @prev "GG_Commands" @{fg shine}@{bg fill}W Command@{fg text}@{bg back} @{i}Wait nn vertical blanks.@{ui} @{b} W vbls@{ub} This command creates a pause. The time is measured in vertical blanks, which occurs at the rate of 50 per second for PAL systems and 60 per second for NTSC systems. On a PAL system, @{b} W 50@{ub} would cause a one second pause. The W command allows the player to end the pause before the specified time by pressing the full stop ( . ) or escape key. (The escape key, when used in a cutscene, also causes a skip to the FINAL section of the cutscene. ) @endnode @node "GG_EXIT" " EXIT " @next "GG_REDO" @prev "GG_WAIT" @{fg shine}@{bg fill}EXIT Command@{fg text}@{bg back} @{i}Ends the execution of commands to handle the current input sentence from the player.@{ui} @{b}EXIT@{ub} is used when all actions for a user sentence has been performed, and you do not wish to search further in the .room, .section, and graal.main files for entries that match the sentence. It is used in ACTION: and DACT: statements, and combined with EDLG to end dialogues. See also: @{"EDLG" link "GG_EDLG" 0}, @{"REDO" link "GG_REDO" 0} @endnode @node "GG_REDO" " REDO " @next "GG_CUTSCENE" @prev "GG_EXIT" @{fg shine}@{bg fill}REDO Command@{fg text}@{bg back} @{i}Re-run the scripts after having changed the player's input sentence.@{ui} @{b}REDO@{ub} This command is used after having changed the current sentence contents with the OBJ1, OBJ2 and VERB commands. The whole idea is that sometimes you want exactly the same actions performed for different sentences, and using REDO is easier and less space-consuming than copying all the actions. For example, if you want the same actions taken for USE BOOK and OPEN BOOK, you can replace the verb USE (3) with the verb OPEN (4) and then start over with checking for appropriate actions. Example, assuming the book is object 1: @{b}ACTION: 3;IFOBJ 1;VERB 4;REDO@{ub} The checking will start over with the first ACTION: statement in the same file, but now looking for actions for OPEN BOOK rather than USE BOOK, which was what the player entered. (Not to worry, the player will never see what is going on!) @endnode @node "GG_CUTSCENE" " CUTSCENE " @next "GG_DSET" @prev "GG_REDO" @{fg shine}@{bg fill}CUTSCENE Command@{fg text}@{bg back} @{i}Loads and executes contents of a cutscene file@{ui} @{b}CUTSCENE file name,S|N|F|NF|H@{ub} Rather straight forward, this one. You only have to remember that cutscenes can only contain commands and not conditions, and also note the effect the second parameter has on the cutscene indicator (in Olaf's case, the movie camera icon) that is shown instead of the command buttons while a cutscene is being played. @{b}S@{ub} Cutscene indicator will be shown as normal and taken away when this cutscene has finished playing. @{b}N@{ub} The whole command area will disappear during the cutscene, and return when the cutscene has finished playing. @{b}F@{ub} The cutscene indicator will appear as normal but remain on screen when this cutscene finishes. This should be used if several cutscenes are played in sequence, or when cutscenes are "nested" (=called from inside other cutscenes). @{b}NF@{ub} The command area will disappear during the cutscene and remain hidden until a cutscene command containing the "N" parameter restores it. @{b}H@{ub} The cutscene indicator will not be used at all. Use for short cutscenes and cutscenes with the NOBREAK command, if appropriate. See also: @{"NOBREAK" link "GG_NOBREAK" 0} @endnode @node "GG_Quit" " QUIT " @{fg shine}@{bg fill}QUIT Command@{fg text}@{bg back} @{i}Cleans up and quits GRAAL@{ui} @{b} QUIT@{ub} This command simply kills GRAAL. Use it after displaying an end-of-game screen, for example. @endnode @node "GG_DOAFTER" " DOAFTER " @{fg shine}@{bg fill}DOAFTER Command@{fg text}@{bg back} @{i}Sets a timer do execute events when a certain time period has elapsed@{ui} @{b}DOAFTER interval,event object,device@{ub} GRAAL has three "timer devices" which can be used to make things happen after a certain period of time or at (almost) regular intervals. Once set up, they continue to operate until a @{"CANCEL" link "GG_CANCEL" 0} command defuses them. Possible uses are machinery where a sequence of actions must be carried out within a certain time limit, rooms where exits close if you take too long, updating of time data, etc. @{b}interval@{ub} This is the timer interval in seconds. (Or, alas, in 5/6ths of seconds if you are an NTSC user. That's standards for you!) If you specify an interval like "10-50", this means the interval will be a random number between 10 and 50. However, once the interval has been set, it remains constant as long as the timer operates - unless it is changed by a new DOAFTER command. Also, timer device "0" is a little different - see below. @{b}event object@{ub} What happens when the interval has elapsed? GRAAL starts looking for ACTION: statements for the special verb number -1, that's what. And which of those will it use? That depends on the event object, which can be any number. For example, if the event object is set to 3, GRAAL will execute statements beginning with ACTION: -1;IFOBJ 3; Of course, you may choose not to test on the object number, if you only use the one timer and intend to always run through all the timer actions. Control is returned to the player with an EXIT command, same as always. Before the EXIT command, you may wish to put one of the following: * A new DOAFTER command for the same device, altering its function or the time interval * A CANCEL command, defusing the timer. @{b}device@{ub} This is the timer device, which is a simple number from 0 to 2. Each device is its own little time bomb - however, device 0 works in a slightly different way from the rest. Device 0 keeps track of how long it has been since the player's last input to the game, rather than counting how long it's been since the DOAFTER command was given. Each mouse click is counted as an action, and thus resets the timer. This timer is also completely disabled during dialogues. This means that timer 0 can be used for things like "stall anims" - making the character urge you to do something if you take too long, for example. (A classic example of this sort of timer is the one in that good old text adventure, "the Hobbit": "You wait... time passes. And it did.) @{fg shine}Limitations to the timed events:@{fg text} Because GRAAL only checks for elapsed timers when it waits for player input in dialogue or command mode, the timing is very approximate. For example, if a timer elapses while your hero is making a long speech, the timed event will occur only after the speech stops and when return normally should have returned directly to the player. In other words, you will have to think about how you set the action in scenes where timing events are critical. Preferably, there shouldn't be long sequences without checks for player input occuring at the same time. Also note that execution of the timer commands in the ACTION: statements does not multitask, and if two or three timers elapse at the same time, the commands for each timer will be carried out in sequence, starting with timer 0 and ending with timer 2, possibly putting the timing off even further from what was expected. Finally, NEVER use timers for things which can be achieved with repeating animation patterns - they are much more accurate in the timing and put much less strain on the system! See also: @{"CANCEL" link "GG_CANCEL" 0} command @endnode @node "GG_CANCEL" " CANCEL " @{fg shine}@{bg fill}CANCEL Command@{fg text}@{bg back} @{i}Cancels the function of a timer@{ui} @{b} CANCEL device@{ub} This command stops a timer started with the @{"DOAFTER" link "GG_DOAFTER" 0} command. @{b}device@{ub} is the device number of the timer (1-3). See also: @{"DOAFTER" link "GG_DOAFTER" 0} command @endnode @node "GG_DSET" " DSET " @next "GG_LINE" @prev "GG_CUTSCENE" @{fg shine}@{bg fill}DSET Command@{fg text}@{bg back} @{i}Handles dialogue alternatives@{ui} @{b}DSET dlg[,com1,com2,...,comn] @{ub} Tell the dialogue dlg how to behave using a number of commands, such as: @{b}+n@{ub} add line n to the available set of lines @{b}-n@{ub} take away line n from the line set temporarily, can be restored by another + later on @{b}Nn@{ub} make line n never appear again in this game, even if a DSET + appears later on. @{b}Ss@{ub} Save the current status (the set of alternatives the player sees) before "branching" in the dialogue. s is a set of saved lines, and can be 1-3 @{b}Rs@{ub} Restore a previously saved dialogue status from set 1-3 @{b}E@{ub} Erase all currently displayed dialogue lines, equal to giving a "-" command for each line. (This is also done automatically by the S (Save) command. If you are not already involved in the dialogue, DSET will put the dialogue control area onto the screen instead of the normal control area. If no commands are specified, the dialogue is only refreshed. However, even this may alter the set of alternatives the player actually sees - because the availability of the alternatives also depend upon conditions set in the LINE: statements themselves, and those conditions may be changed between DSET commands. Remember that although dialogues are specified in the room files, their numbers must be unique for the entire game. The special command "E" takes away all current dialogue alternatives. It is mostly used in conjunction with the save/restore function when you "branch out" in a dialogue and want to present a completely new set to alternatives to the player. For example, this shows a "branching out" of dialogue 4: @{b}DSET 4,S1,+12,+13,+14@{ub} saves the current dialogue status in set 1, clearing all old input alternatives at the same time, and replaces them with lines 12, 13 and 14. The special command "L" allows you to alter the dialogue status without showing what you are doing in the dialogue control area. This is mainly used to restore the dialogue to its proper status just before ending the dialogue, so that the proper alternatives will be in place when the player starts talking to the same dialogue partner the next time. For example, before we leave dialogue 4 we know that we want to go back to the way things looked before we saved the status in set 1: @{b} DSET 4,L,R1;EDLG;EXIT@{ub} restores the previously saved dialogue status for dialogue 4 just before the dialogue is ended, without the user being disturbed by flickering alternatives in the dialogue control area. However, the next time the player engages in this dialogue, the old alternatives will be back to choose from. See also: @{"EDLG" link "GG_EDLG" 0} @endnode @node "GG_LINE" " LINE " @next "GG_EDLG" @prev "GG_DSET" @{fg shine}@{bg fill}LINE Command@{fg text}@{bg back} @{i}Alter the line chosen in a dialogue@{ui} @{b} LINE line_no@{ub} This command, i conjunction with th REDO command, lets you use the same reactions (LACT: statements) for a number of different dialogue alternatives - much easier than copying all commands into a number of LACT:s. Example: You wish the reactions to line 5 in a dialogue to be exactly the same as those for line 3. Simply specify this: @{b}LACT: 5;LINE 3;REDO@{ub} The program now goes through the LACT:s again, now looking for those who are connected to line 3 instead of line 5 which was actually chosen. See also: @{"REDO" link "GG_REDO" 0} @endnode @node "GG_EDLG" " EDLG " @next "GG_RESP" @prev "GG_LINE" @{fg shine}@{bg fill}EDLG Command@{fg text}@{bg back} @{i}Ends a dialogue session@{ui} @{b}EDLG@{ub} This command ends the dialogue. The normal Control Area is put back on screen instead of the Dialogue Control Area. The last set of dialogue lines will be present as default if the dialogue is resumed later on. Normally, you would not want to evaluate any more line action (LACT:) statements after having decided to end the dialogue. Therefore, you should normally put an EXIT command right behind the EDLG: @{b} EDLG;EXIT@{ub} See also: @{"DSET" link "GG_DSET" 0} @endnode @node "GG_OBJ" " OBJ1 / OBJ2 " @next "GG_VERB" @prev "GG_RESP" @{fg shine}@{bg fill}OBJ1 / OBJ2 Command@{fg text}@{bg back} @{i}Alters the object number for OBJ1 or OBJ2.@{ui} @{b}OBJ1 obj OBJ2 obj@{ub} These commands are used in two main ways: a) to temporarily put another object number in the place of OBJ1 or OBJ2 in order to manipulate an object using other commands. In this case, you only need a simple OBJ1 or OBJ2 without any parameters to change the object number back to what it originally was when you are through manipulating the object you specified with "obj". For example, imagine you are about to open a can of gasoline in a room with a lit candle. The gasolin has object number 15 and is currently OBJ1, the object number for the candle is 20. @{b}...OBJ1 20;MOBJ;HANDLE;SHOW 20, , ,10;SAY I put the light out first;HANDLE -1;OBJ1 15;...@{ub} would be an easy way to switch from the gasolin, operate the candle, and then switch back to working with the gasolin. b) to alter the object handled and then use the @{"REDO" link "GG_REDO" 0} command to run through all action statements again. @{i}Note:@{ui} Exit numbers used to check which exit was clicked is actually a special use of the OBJ1 variable. This must be remembered when coding ACTION: statements for verb 0 (= exit click). See also: @{"VERB" link "GG_VERB" 0}, @{"REDO" link "GG_REDO" 0} @endnode @node "GG_VERB" " VERB " @next "GG_ROOM" @prev "GG_OBJ" @{fg shine}@{bg fill}VERB Command@{fg text}@{bg back} @{i}Alters the current verb@{ui} @{b}VERB @{ub} Use this to alter the verb in the current sentence. Mainly used before the @{"REDO" link "GG_REDO" 0} command to make one action synonym to another. If no verb number is specified, the verb number before the last VERB command is restored (but why you should want to do that, I don't know at this stage.) See also: @{"OBJ1/OBJ2" link "GG_OBJ" 0}, @{"REDO" link "GG_REDO" 0} @endnode @node "GG_ROOM" " ROOM " @next "GG_MARK" @prev "GG_VERB" @{fg shine}@{bg fill}ROOM Command@{fg text}@{bg back} @{i}Alter the current room@{ui} @{b}ROOM @{ub} A bit obsolete, this one. You can set flags for rooms other than the current using a special form of the SETRF command, so this one may soon be deleted. Anyway, specifying ROOM without the parameter brings back the room number that was in effect before the last ROOM was called, just like OBJ1/OBJ2 can restore the previous object if used without the parameter. @endnode @node "GG_MARK" " MARK " @next "GG_RESUME" @prev "GG_ROOM" @{fg shine}@{bg fill}MARK Command@{fg text}@{bg back} @{i}Mark the current game position@{ui} @{b} MARK [number]@{ub} This saves the current game state. @{b}number@{ub} If number is specified, this command acts as a "save game" to RAM: (which can take some time). Any number of MARKs can be stored using unique identification numbers to tell them apart. Just keep in mind that each MARK creates a file of about 20K in RAM:, and that the command takes a few seconds to perform. (Older machines can really struggle in comparison with 1200s or accelerated ones, so do not use it excessively.) If a number is not included, the position is saved to a string of variables in memory, which is somewhat faster. However, only one position can be saved this way. The position can be re-created later using a RESUME command. You can use this in a number of ways: * Implement your own "save to RAM:" commands. * Provide an "ooops!" function, allowing the player an easy way to get back into a game where something just has gone terribly wrong... * Cut away to cutscenes using other rooms and restore the game position afterwards, not having to care exactly what the scene looked like when the jump to the cutscene occured. * Use a MARK as the very first command in the game and provide a "try again" option from an end-of-game screen. See also: @{"RESUME" link "GG_RESUME" 0} command @endnode @node "GG_RESUME" " RESUME " @next "GG_SAY" @prev "GG_MARK" @{fg shine}@{bg fill}RESUME Command@{fg text}@{bg back} @{i}Resume the action at the spot saved with the MARK command@{ui} @{b} RESUME [number]@{ub} @{b}number@{ub} The optional number must correspond to the one of a previous MARK command. See the MARK command for a detailed description of what is going on. As with normal "load game" operations, GRAAL searches for and executes any ACTION: statements starting with the special verb number -2 before lighting the scene and returning control to the player. This is to enable you to perform any special actions that need to be taking, for example restoring global BOB images (which are not saved by a "save game" or a MARK command). See also: @{"MARK" link "GG_MARK" 0} command @endnode @node "GG_SAY" " SAY " @next "GG_GOTO" @prev "GG_RESUME" @{fg shine}@{bg fill}SAY Command@{fg text}@{bg back} @{i}Makes the main character speak a sentence (or two).@{ui} @{b}SAY Any kind of text goes here...@{ub} This command uses the animations in the TALK_MAP statements of the graal.main file to animate the character during the length of the text display. The text display may use some @{"special characters" link "GG_Vars" 0} to perform line breaks, put in variable values, etc. Note that the SAY command can only be used if the main character is on screen, not if a @{"CHAR OFF" link "GG_CHAR" 0} or other command has hidden it! See also: @{"THINK" link "GG_THINK" 0} @endnode @node "GG_GOTO" " GOTO " @next "GG_SETEXIT" @prev "GG_SAY" @{fg shine}@{bg fill}GOTO Command@{fg text}@{bg back} @{i}Move to another room@{ui} @{b} GOTO ,@{ub} This command automatically moves to a new room - it is not needed when using exits in the normal way, but is handy in cutscenes and the like. As usual, if a list of alternatives is specified, one is choosen at random. Could be used in maze-like surroundings, perhaps? See also: @{"MARK" link "GG_MARK" 0}, @{"RESUME" link "GG_RESUME" 0} @endnode @node "GG_THINK" " THINK " @next "GG_HANDLE" @prev "GG_SETEXIT" @{fg shine}@{bg fill}THINK Command@{fg text}@{bg back} @{i}Displays text above the main character@{ui} @{b}THINK Any kind of text goes here...@{ub} This command behaves just like @{"SAY" link "GG_SAY" 0}, except it doesn't automatically animate the character. Good for "thinking" as well as using special animation sequences shown using MOVE commands instead of the standard TALK_MAP animations. See also: @{"SAY" link "GG_SAY" 0} @endnode @node "GG_RESP" " RESP " @{fg shine}@{bg fill}RESP Command@{fg text}@{bg back} @{i}Make a dialogue partner respond@{ui} @{b}RESP R|S,dialogue number,sentence@{ub} @{b}R@{ub} means after the character has "spoken", it will be displayed using its default image or animation again. @{b}S@{ub} means the image used just before the RESP command was called will be used again. the @{b}dialogue number@{ub} refers to the number assigned to this dialogue by the @{"DLG:" link "ST_DLG" 0} statement in the graal.main file. The sentence is constructed just like sentences used in, for example, the @{"SAY" link "GG_SAY" 0} and @{"THINK" link "GG_THINK" 0} commands. See also: @{"SAY" link "GG_SAY" 0} and @{"THINK" link "GG_THINK" 0} commands, @{"DLG" link "ST_DLG" 0} statement @endnode @node "GG_HANDLE" " HANDLE " @next "GG_PICK" @prev "GG_THINK" @{fg shine}@{bg fill}HANDLE Command@{fg text}@{bg back} @{i}Make the main character handle an object@{ui} @{b} HANDLE [objno|LOW|MID|HIGH|-1]@{ub} @{b}HANDLE@{ub} on its own uses the HANDLE_MAP animations specified in the graal.main file to make the main character "operate" OBJ1. @{b}HANDLE objno@{ub} makes the character operate the specified object. @{b}HANDLE LOW|MID|HIGH@{ub} uses the "handle animation" - a general, convenient way to stretch out a hand without having to resort to CBOB or OMOVE 0,... commands. @{b}HANDLE -1@{ub} resets the main character to what he/she looked like just before the HANDLE command took effect. @endnode @node "GG_PICK" " PICK " @next "GG_GET" @prev "GG_HANDLE" @{fg shine}@{bg fill}PICK Command@{fg text}@{bg back} @{i}Pick up an object@{ui} @{b} PICK []@{ub} Adds the specified object (or OBJ1, if no object number is specified) to the inventory and erases it from the scene area. This command is often preceded by a MOBJ and a @{"HANDLE" link "GG_HANDLE" 0} command to show on screen what's going on. There is no DROP command that automatically replaces an object on screen. the main reason is that it isn't worth it: For every possible location the object could be dropped, you would have to specify a place for it in the scene area. The most comfortable way to dispose of objects is letting the main character do so automatically when they have filled their purpose, using the @{"REMOVE" link "GG_REMOVE" 0} command. See also: @{"GET" link "GG_GET" 0}, @{"REMOVE" link "GG_REMOVE" 0} @endnode @node "GG_GET" " GET " @next "GG_REMOVE" @prev "GG_PICK" @{fg shine}@{bg fill}GET Command@{fg text}@{bg back} @{i}Add an object to the inventory@{ui} @{b}GET ,U|N@{ub} The object is added to the inventory. Use "U" if the inventory display should be updated (which is the normal procedure), "N" if the inventory should be left unaffected, for example if GET is used during a dialogue, or you make a number of consecutive GETs letting only the last one update the display. The difference between GET and @{"PICK" link "GG_PICK" 0} is that GET does not take any notice of the object's previous whereabouts. See also: @{"PICK" link "GG_PICK" 0}, @{"REMOVE" link "GG_REMOVE" 0} @endnode @node "GG_REMOVE" " REMOVE " @next "GG_SETOF" @prev "GG_GET" @{fg shine}@{bg fill}REMOVE Command@{fg text}@{bg back} @{i}Removes an object from the inventory@{ui} @{b} REMOVE ,N|U,@{ub} Removes the object from the inventory. If "U" is specified, the inventory display is updated. The object is placed in the specified room. If the room is specified as 0, the object "disappears" forever! Note: This command can also be used to put an object in any room except the current at any time. In this case, specify "N" to skip the inventory updating. To put an object in the current room, the @{"SHOW" link "GG_SHOW" 0} command must always be used. See also: @{"GET" link "GG_GET" 0}, @{"PICK" link "GG_PICK" 0} @endnode @node "GG_NAME" " NAME " @{fg shine}@{bg fill}NAME Command@{fg text}@{bg back} @{i}Alter the name of an object@{ui} @{b}NAME new name[,word1,word2,word3]@{ub} Very often in an adventure, an object is "transformed" - that is, one object appears while another disappears at the same time. (For example, a parcel is opened to reveal a book - the parcel is gone, the book exists.) To save memory, it makes sense to use the old object number for the new object also, since there is no risk of confusion - the two objects never appear at the same time. The command NAME alters the name of the current OBJ1 (see the @{"syntax" link "GG_Syntax" 0} conventions). In addition, the determination words (see the @{"OBJECT" link "ST_OBJECT" 0} statement) may be altered to suit the new object description. See also: @{"OBJ1" link "GG_OBJ" 0} command, @{"OBJECT" link "ST_OBJECT" 0} statement. @endnode @node "GG_ICON" " ICON " @{fg shine}@{bg fill}ICON Command@{fg text}@{bg back} @{i}Alter the icon used for inventory display@{ui} @{b} ICON [objno,]image@{ub} This command does a bit of what the NAME command does for a text inventory, but you should probably use both the NAME and the ICON command when changing properties for objects in an icon display - NAME still determines the text shown when the object is referred to in the game, although it doesn't appear in the inventory list... @endnode @node "GG_PREP" " PREP " @{fg shine}@{bg fill} PREP Command@{fg text}@{bg back} @{i}Alter the preposition of OBJ1@{ui} @{b} PREP [preposition]@{ub} By specifying a preposition for an object, the verb USE will assume this object must be used in conjunction with something else, and therefore awaits the input of a second object before checking for actions. Specifying PREP without a preposition will do the opposite, allowing an object to be used on its own again. @endnode @node "GG_NEWOBJ" " NEWOBJ " @{fg shine}@{bg fill}NEWOBJ Command@{fg text}@{bg back} @{i}Creates or modifies an object@{ui} @{b} NEWOBJ: object_parameters@{ub} This command acts exactly like the OBJECT: statement - only here, the parameters are separated by commas instead of semi-colons, so you can not place an animation sequence containing commas as the default object image. Also note that this command resets all object flags to 0. See also: @{"OBJECT" link "ST_OBJS" 0} statement @endnode @node "GG_SETOF" " SETOF " @next "GG_SETOF" @prev "GG_REMOVE" @{fg shine}@{bg fill}SETOF Command@{fg text}@{bg back} @{i}Assigns a value to an object flag@{ui} @{b}SETOF [,]flag=value|list@{ub} If no object number is specified, OBJ1 is assumed. The flag is set to the value. If the value is specified as #DATE, the value is the current in-game date in the format year*10000+month*100+date, e.g. 19960801 for Augist 1, 1996 If the value is specified as #TIME, the value is the current in-game time in the format hour*100+minutes, e.g. 2355 for 11:55 pm. The value can also be a reference to a room or object flag. The format is #R#roomnumber#flag# or #O#objectnumber#flag# For example, SETOF 3,6=#R#3#4# would set flag 6 for object 3 to the value held in room flag 4 of room 3. If a list of values is specified, one of the values is chosen at random. For example, SETOF 2=3|7|9 would set object flag 2 for object 1 to either 3, 7, or 9. A maximum of 12 values may be specified in a list. See also: @{"ADDOF" link "GG_ADDOF" 0}, @{"DECOF" link "GG_DECOF" 0}, @{"IFOF" link "GG_IFOF" 0} @endnode @node "GG_ADDOF" " ADDOF " @next "GG_ADDOF" @prev "GG_SETOF" @{fg shine}@{bg fill}ADDOF Command@{fg text}@{bg back} @{i}Adds to or subtracts from a flag value@{ui} @{b} ADDOF [object,]flag[,value] ADDOF2 flag[,value]@{ub} ADDOF affects a flag for an object. If no value is specified, 1 is added. Negative values may be used, thus subtracting from the flag value. ADDOF2 affects OBJ2 - this form is kept mainly for backwards compatibility, you can achieve exactly the same by specifying object 2's object number in most cases... DECOF is used for special "countdown" purposes. The value can be a reference to a room or object flag. The format is #R#roomnumber#flag# or #O#objectnumber#flag#. For example, ADDOF 1,#O#4#2# would add the value held in object flag 2 for object 4 to object flag 1 for OBJ1. Another example: ADDOF2 4 would add 1 to object flag 4 of OBJ2. See also: @{"SETOF" link "GG_SETOF" 0}, @{"DECOF" link "GG_DECOF" 0}, @{"IFOF" link "GG_IFOF" 0} @endnode @node "GG_DECOF" " DECOF " @next "GG_SETRF" @prev "GG_ADDOF" @{fg shine}@{bg fill}DECOF Command@{fg text}@{bg back} @{i}Counts down the flag value to zero@{ui} @{b} DECOF flag DECOF2 flag@{ub} DECOF is used for OBJ1, DECOF2 for OBJ2. The flag value is decreased by 1 until it reaches zero, then it stays there. See also: @{"SETOF" link "GG_SETOF" 0}, @{"ADDOF" link "GG_ADDOF" 0}, @{"IFOF" link "GG_IFOF" 0} @endnode @node "GG_SETRF" " SETRF " @next "GG_ADDRF" @prev "GG_DECOF" @{fg shine}@{bg fill}SETRF Command@{fg text}@{bg back} @{i}Assigns a value to a room flag@{ui} @{b}SETRF [,]flag=value|list@{ub} If no room number is specified, the current room is assumed. The flag is set to the value. If the value is specified as #DATE, the value will be the current in-game date in the format year*10000+month*100+date, e.g. 19960801 for August 1, 1996. If the value is specified as #TIME, the value will be the current in-game time in the format hours*100 + minutes, e.g. 2355 for 11:55 pm. For example, SETRF 2,1=5 would set room flag 1 for room 2 to 5 The value can be a reference to a room or object flag. The format is #R#roomnumber#flag# or #O#objectnumber#flag# For example, SETRF 2=#R#2#1# would set room flag 2 for the current room to the value of room flag 1 for room 2. If a list of values is specified, one of the values is choosen at random. For example, SETRF 2=3|7|9 would set room flag 2 to either 3, 7, or 9. A maximum of 12 values may be specified in a list. SETRF 1,3=#TIME would set room flag 3 for room 1 to the current game time. SETRF 0,1=#DATE would set room flag 1 for room 0 to the current game date. Room 0 is a "global" room never used as a normal room. Nevertheless, it exists flag-wise, so its 20 flags can be used to hold "global game values". See also: @{"ADDRF" link "GG_ADDRF" 0}, @{"DECRF" link "GG_DECRF" 0}, @{"IFRF" link "GG_IFRF" 0} @endnode @node "GG_ADDRF" " ADDRF " @next "GG_DECRF" @prev "GG_SETRF" @{fg shine}@{bg fill}ADDRF Command@{fg text}@{bg back} @{i}Adds to or subtracts from a room flag value@{ui} @{b} ADDRF [room,]flag[,value]@{ub} ADDRF affects a flag for the current room. The number is added to the flag value. If the number is negative, a subtraction is performed. The value may be a reference to a room or object flag. The format is #R#roomnumber#flag# or #O#objectnumber#flag#. For example, ADDRF 3,1,#O#5#2# adds the value held in object flag 2 of object 5 to room flag 1 of room 3. ADDRF 2 would add 1 to room flag 2 of the current room ADDRF 2,3 would add 3 to room flag 2 of the current room ADDRF 5,2,3 would add 3 to room flag 2 of room 5 See also: @{"SETRF" link "GG_SETRF" 0}, @{"DECRF" link "GG_DECRF" 0}, @{"IFRF" link "GG_IFRF" 0} @endnode @node "SHOWEXIT" " SHOWEXIT " @{fg shine}@{bg fill}SHOWEXIT Command@{fg text}@{bg back} @{i}Shows a previously hidden exit@{ui} @{b} SHOWEXIT exit_no@{ub} This restores a previously hidden exit on screen See also: @{"HIDEEXIT" link "HIDEEXIT" 0} command @endnode @node "HIDEEXIT" " HIDEEXIT " @{fg shine}@{bg fill}HIDEEXIT Command@{fg text}@{bg back} @{i}Hides an exit@{ui} @{b}HIDEEXIT exit_no@{ub} When entering a room, all exit defined by EXIT: statements are always visible and usable. This command hides the exit. It can be restored later by the SHOWEXIT command. See also: @{"SHOWEXIT" link "SHOWEXIT" 0} command @endnode @node "GG_DECRF" " DECRF " @next "GG_CBOB" @prev "GG_ADDRF" @{fg shine}@{bg fill}DECRF Command@{fg text}@{bg back} @{i}Counts down the room flag value to zero@{ui} @{b} DECRF flag@{ub} DECRF decreases the value of the flag until it reaches zero, then it stays there. See also: @{"SETRF" link "GG_SETRF" 0}, @{"ADDRF" link "GG_ADDRF" 0}, @{"IFRF" link "GG_IFRF" 0} @endnode @node "GG_CBOB" " CBOB " @next "GG_CMOVE" @prev "GG_DECRF" @{fg shine}@{bg fill}CBOB Command@{fg text}@{bg back} @{i}Alter the image for the main character@{ui} @{b} CBOB @{ub} The main character changes to the specified image. The screen (hotspot) position is not altered. See also: @{"CPOS" link "GG_CPOS" 0}, @{"CMOVE" link "GG_CMOVE" 0}, @{"OMOVE" link "GG_OMOVE" 0} @endnode @node "GG_CMOVE" " CMOVE " @next "GG_MOBJ" @prev "GG_CBOB" @{fg shine}@{bg fill}CMOVE Command@{fg text}@{bg back} @{i}Moves the character to a new screen position using the default @{"WALK_..." link "ST_WALK" 0} animations.@{ui} @{b} CMOVE x,y,C|P@{ub} @{b}x@{ub} and @{b}y@{ub} are the screen (hotspot) coordinates. Use @{b}P@{ub} to end the CMOVE with an appropriate PAUSE_... image, @{b}C@{ub}" link "ST_PAUSE" 0} image, C to end with a @{"STILL_..." link "ST_STILL" 0} image. C is mainly used when another CMOVE follows immediately. See also: @{"CBOB" link "GG_CBOB" 0}, @{"CPOS" link "GG_CPOS" 0}, @{"OMOVE" link "GG_OMOVE" 0} @endnode @node "GG_MOBJ" " MOBJ " @next "GG_CPOS" @prev "GG_CMOVE" @{fg shine}@{bg fill}MOBJ Command@{fg text}@{bg back} @{i}Move the main character next to an object@{ui} @{b}MOBJ [object number]@{ub} The main character is moved to the position indicated by the character offset parameters of the OBJECT statement or command. If no object number is given, OBJ1 is assumed. @endnode @node "GG_MEXIT" " MEXIT " @{fg shine}@{bg fill}MEXIT Command@{fg text}@{bg back} @{i}Move character to exit@{ui} @{b} MEXIT@{ub} This command can only be used in an ACTION: 0;... statement, and moves the character to the exit point for the clicked exit, as specified in the corresponding @{"EXIT:" link "ST_EXIT" 0} statement @endnode @node "GG_CPOS" " CPOS " @next "GG_CHAR" @prev "GG_MOBJ" @{fg shine}@{bg fill}CPOS Command@{fg text}@{bg back} @{i}Alter the character's screen position@{ui} @{b}CPOS x,y@{ub} Immediately alters the main character's screen position to x,y (without walking there like @{"CMOVE" link "GG_CMOVE" 0}.) The image is not altered: @{"CBOB" link "GG_CBOB" 0} may be used for that. See also: @{"CBOB" link "GG_CBOB" 0}, @{"CMOVE" link "GG_CMOVE" 0}, @{"OMOVE" link "GG_OMOVE" 0} @endnode @node "GG_CHAR" " CHAR " @next "GG_OMOVE" @prev "GG_CPOS" @{fg shine}@{bg fill}CHAR Command@{fg text}@{bg back} @{i}Turn main character display on or off@{ui} @{b} CHAR ON|OFF@{ub} CHAR OFF means the main character is not on screen - use for cutscenes, animated intros and the like. CHAR ON restores the main character to the position before CHAR OFF. See also: @{"CPOS" link "GG_CPOS" 0}, @{"CBOB" link "GG_CBOB" 0} @endnode @node "GG_FLOOR" " FLOOR " @{fg shine}@{bg fill}FLOOR Command@{fg text}@{bg back} @{i}(Re-)defines a floor@{ui} @{b}FLOOR number,x1,y1,x2,y2,floormap1,...,floormapn@{ub} This command works exactly like the @{"FLOOR:" link "ST_FLOOR" 0} statement, and allows you to re-arrange floors for a room any way you like. You can make previously unreachable areas accessible, or quite the opposite. You must make sure that all floormaps are valid - changing a single floor may mean you have to use FLOOR commands for other floors to just to change the floor maps. And if you alter the number of floors, you must also use the @{"NFLOOR" link "GG_NFLOOR" 0} command to set the new number of floors. See also: @{"NFLOOR" link "GG_NFLOOR" 0} and @{"SETFLOOR" link "GG_SETFLOOR" 0} commands, @{"FLOOR:" link "ST_FLOOR" 0} statement @endnode @node "GG_NFLOOR" " NFLOOR " @{fg shine}@{bg fill}NFLOOR command@{fg text}@{bg back} @{i}Changes the number of floors in a room@{ui} @{b}NFLOOR number@{ub} Only use this command when you have changes the floor structure, and number of floors, in a room with the @{"FLOOR" link "GG_FLOOR" 0} command. See also: @{"FLOOR" link "GG_FLOOR" 0} and @{"SETFLOOR" link "GG_SETFLOOR" 0} commands. @endnode @node "GG_SETFLOOR" " SETFLOOR " @{fg shine}@{bg fill}SETFLOOR command@{fg text}@{bg back} @{i}Informs the system about the main character's whereabouts in the floor system.@{ui} @{b} SETFLOOR floor number@{ub} Normally, GRAAL automatically keeps track of on which floor your character is currently positioned. There are, however, a few commands that may leave the system unaware about your hero's whereabouts. These are the @{"FLOOR" link "GG_FLOOR" 0} and @{"OMOVE" link "GG_OMOVE" 0} commands. If one of these commands places your character on another floor previously, you should specify the new floor number with this command. Otherwise, strahnge things may happen when the character tries to move next. See also: @{"FLOOR" link "GG_FLOOR" 0} and @{"OMOVE" link "GG_OMOVE" 0} commands, and the @{"FLOOR:" link "ST_FLOOR" 0} statement. @endnode @node "GG_OMOVE" " OMOVE " @next "GG_SHOW" @prev "GG_CHAR" @{fg shine}@{bg fill}OMOVE Command@{fg text}@{bg back} @{i}Move an object (or the main character) according to specified animation sequence @{ui} @{b} OMOVE object number,x,y,speed adjustment,FLIP| ,WAIT| ,animation sequence@{ub} The object's hot spot is moved to the x,y screen co-ordinates. During the movement, the @{"animation sequence" link "GG_Animation" 0} specified in the last parameter is used. The x and y positions can be set relative to the main character's current position using CX+offset and CY+offset. Example: @{b}OMOVE 2,CX+20,CY+0,1,FLIP, ,A 0,(SBOB1,12)(SBOB2,12)(SBOB3,12)(SBOB2,12)@{ub} moves object 2 to a position 20 pixels to the right of the main character, at the normal WALK_SPEED speed, using an animation consisting of four different images. If the speed adjustment factor is 1, the speed will be the speed set with the WALK_SPEED parameter in the graal.main file. A @{b}lower@{ub} number gives @{b}faster@{ub}" link "ST_WALK_SPEED" 0} parameter in the graal.main file. A lower number gives faster movement, a @{b}higher@{ub} number gives @{b}slower@{ub} movement. If FLIP is specified, and movement is from left to right, the images are used as supplied, but if the movement is from right to left, all images in the animation sequence are automatically flipped first. Specifying any other value (such as a blank) means the images are always used as specified. If WAIT is specified, the entire animation sequence is carried out before GRAAL continues with the next command. Otherwise, GRAAL will not check if the animation has been concluded until the next OMOVE command for the same object. If you put several OMOVE commands for the same object next to each other, you should specify a blank space instead of WAIT - this eliminates the brief pauses between OMOVE commands that will otherwise occur. On the other hand, if the command following an OMOVE is something like a SHOW command for the same object, always specify WAIT - otherwise the SHOW would be affecting the object before the animation sequence had a chance to finish. OMOVE can be used to move and animate the main character using other animations sequences than the default. Just specify object number 0 to point to the main character. If x and y are left blank, the object is animated using the animation string at its curent position. Normally, the animation is automatically stopped when the object reaches the x,y position, and the first BOB image in the animation sequence will the be used as the still image. When no new x,y position is given, the animation goes on until another image-manipulating command for the object is encountered, for example SHOW or CBOB. Example: @{b} OMOVE 0, , ,1,A 0,(11,24)(12,24)@{ub} would animate the main character alternating between BOB images 11 and 12 indefinitely. (Well, until the BOB image for the main character is altered using some other command, anyway.) See also: @{"SHOW" link "GG_SHOW" 0}, @{"CMOVE" link "GG_CMOVE" 0}, @{"CPOS" link "GG_CPOS" 0}, @{"CBOB" link "GG_CBOB" 0}, @{"HIDE" link "GG_HIDE" 0} @endnode @node "GG_SHOW" " SHOW " @next "GG_HIDE" @prev "GG_OMOVE" @{fg shine}@{bg fill}SHOW Command@{fg text}@{bg back} @{i}Show an object@{ui} @{b} SHOW object number,x,y,image@{ub} If the object number is 0, the commands manipulates the graphics of the main character. The image can be a BOB image number, an animation string, or even a pattern (PTRN) specification. If x and y are left blank, the position of the object will not be altered, only the image. If image is left blank, the object is moved to the new co-ordinates retaining the previous image. Note: If the object was in the inventory before the SHOW, it is removed and the inventory is updated. Example: @{b} SHOW 3, , ,PTRN 1@{ub} would show object 3 in its previous position using the animation sequence stored in the 1.ptrn file. Another example: @{b}SHOW ROBJ1,30,70, @{ub} would place room object 1 at the new co-ordinates 30,70. A third example: SHOW 0, , , refreshes the graphics of the main character. This is useful if you have loaded new global images, for instance. See also: @{"HIDE" link "GG_HIDE" 0}, @{"OMOVE" link "GG_OMOVE" 0}, @{"CPOS" link "GG_CPOS" 0}, @{"CBOB" link "GG_CBOB" 0}, @{"CMOVE" link "GG_CMOVE" 0} @endnode @node "GG_HIDE" " HIDE " @next "GG_TRACK" @prev "GG_SHOW" @{fg shine}@{bg fill}HIDE Command@{fg text}@{bg back} @{i}Hides an object@{ui} @{b} HIDE object number@{ub} hides the specified object from view (that is, removes it from the current room). This may often be used in room DACT statements, using room flags to decide what objects are being shown and not in a particular situation or phase of the game. See also: @{"CHAR" link "GG_CHAR" 0}, @{"SHOW" link "GG_SHOW" 0} @endnode @node "GG_OBJONTOP" " OBJONTOP " @{fg shine}@{bg fill}OBJONTOP Command@{fg text}@{bg back} @{i}Puts the object on top of all other displayed objects@{ui} @{b} OBJONTOP object number@{ub} Sometimes it happens that two objects partly occupy the same space on screen - one object being displayed on top op the other. However, the topmost object being displayed properly is not, in itself, a guarantee that the mouse cursor will actually register it when you move the cursor across it. If the underlying object is further up GRAAL's internal list of objects shown in the room, it is that obejct's name that will be shown, which is probably not what you want. And that list was unavailable to you before GRAAL 2. The simple remedy is this command. If, when testing your adventure, you find an object which is unavailable in the manner described above, simply give an OBJONTOP command for it once it's been placed in the room - in a DACT: statement if it is a ROOMOBJect, or right after a SHOW command, for example. @endnode @node "GG_TRACK" " TRACK " @next "GG_SAMLOAD" @prev "GG_HIDE" @{fg shine}@{bg fill}TRACK Command@{fg text}@{bg back} @{i}Handles soundtracker music modules@{ui} @{b}TRACK ,ONCE|LOOP,FILTER|NO@{ub} If the file name is different than the last sound tracker file name used, or no tracker file is currently in memory, the file is loaded and the module starts playing. Currently, the ONCE|LOOP parameter doesn't work - the module always start again when the end is reached, unless you put a tracker "stop" command in the tracker module itself. Specify FILTER if you want the Amiga's low-pass audio filter to be on while the module is playing (takes away some high frequencies and hissing noises.) @{b}TRACK OFF@{ub} Stop the module playing @{b}TRACK ON@{ub} Resume playing a stopped module @{b}TRACK NO@{ub} Stop playing and erase the module from memory (thus freeing memory space). Notes on tempo: Currently, GRAAL only supports the old tracker tempo control of "ticks". The primary tempo is always 33 and the secondary tempo should be set using tracker commands in the module - between 5 and 7 is usually good. See also: @{"SAMLOAD" link "GG_SAMLOAD" 0}, @{"SAMPLAY" link "GG_SAMPLAY" 0} @endnode @node "GG_SAMLOAD" " SAMLOAD " @next "GG_SAMPLAY" @prev "GG_TRACK" @{fg shine}@{bg fill}SAMLOAD Command@{fg text}@{bg back} @{i}Loads a raw or IFF sample into memory@{ui} @{b} SAMLOAD @{ub} This command loads a raw or IFF sample into memory for later use with the SAM command. See also: @{"SAM" link "GG_SAMPLAY" 0} @endnode @node "GG_SAMPLAY" " SAMPLAY " @next "GG_CLPART" @prev "GG_SAMLOAD" @{fg shine}@{bg fill}SAM Command@{fg text}@{bg back} @{i}Plays a previously loaded sample@{ui} @{b}SAM ONCE|LOOP,DEF|@{ub} Play a sample loaded with a previous SAMLOAD command once or in a loop. DEF will make the sample play with the default frequency. To raise or lower the pitch, specify a frequency instead. @{b}SAM OFF@{ub} Stop playing a sample. @{b} SAM NO@{ub} Stop playing a sample and erase it from memory (thus freeing memory space). See also: SAMLOAD @endnode @node "GG_CLPART" " CLPART " @next "GG_BOBS" @prev "GG_SAMPLAY" @{fg shine}@{bg fill}CLPART Command@{fg text}@{bg back} @{i}Load a clipart IFF file@{ui} @{b}CLPART filename@{ub} The specified picture file is loaded into memory, where it is used for grabbing images with the BOBS command. @{b} CLPART OFF@{ub} Get rid off a previously loaded clipart file when it is no longer needed. See also: @{"BOBS" link "GG_BOBS" 0} @endnode @node "GG_BOBS" " BOBS " @next "GG_BOBS" @prev "GG_CLPART" @{fg shine}@{bg fill}BOBS Command@{fg text}@{bg back} @{i}Loads BOB images into the image bank@{ui} @{b}BOBS number of images,starting image,x,y,width,height,x-offset,hotspot@{ub} The parameters for this command are exactly the same as for the @{"BOBS:" link "ST_BOBS" 0} statement, except the parameters should be separated by commas (,) instead of semi-colons (;). There is one slight difference in how you specify the the starting BOB image number (which is the second parameter). This should be specified as n, SBOBn, or RBOBn, depending on the type of images you intend to add / replace in the image bank. This command must be preceeded by a CLPART command. See also: @{"CLPART" link "GG_CLPART" 0} @endnode @node "GG_HOTSP" " HOTSP " @{fg shine}@{bg fill}HOTSP Command@{fg text}@{bg back} @{i}Alters the hotspot of an image@{ui} @{b} HOTSP image number,hotspot position@{ub} This command is used when you need to make changes to the "3D order" in which objects and images are displayed on the screen. A hotspot position of 0 defines the default hotspot at the middle of the bottom of the image. Any other value defines another hotspot in the y direction of the image. The y direction is the important one, because it is the relative position of hotspots in the y direction that determines which image goes in front of another on the screen. An unfortunate side-effect of altering the y hotspot is that the x hotspot position "jumps" from the middle of the image to the left edge - there is no convenient way for me to avoid this. This means that you have to redisplay the image on screen with a new SHOW, OMOVE, BOBON or other such command, and in that command adjust the x position to cancel out the effect of the hotspot having moved in the x direction as well as in the y direction. See also: @{"BOBS" link "ST_BOBS" 0} statement @endnode @node "GG_LIGHTS" " LIGHTS " @next "GG_COLOUR" @prev "GG_BOBS" @{fg shine}@{bg fill}LIGHTS Command@{fg text}@{bg back} @{i}Fade scene area out or in@{ui} @{b} LIGHTS ON|OFF@{ub} ON makes the scene area visible. OFF fades the scene area to black. A LIGHTS ON must always be present in a DACT: statement for a room, otherwise the screen will stay black and nobody will be able to do very much! @endnode @node "GG_COLOUR" " COLOUR " @next "GG_FADE" @prev "GG_LIGHTS" @{fg shine}@{bg fill}COLOUR Command@{fg text}@{bg back} @{i}Change a colour@{ui} @{b}COLOUR [DLY,],@{ub} The colour is changed to the new value. If you want to manipulate colours in DACT: statements before the @{"LIGHTS ON" link "GG_LIGHTS" 0} command has been issued, begin the command with the DLY (delay) parameter. This will cause the new colour to faded in together with the rest when the LIGHTS ON take effect. See also: @{"FADE" link "GG_FADE" 0} @endnode @node "GG_FADE" " FADE " @next "GG_TITLE" @prev "GG_COLOUR" @{fg shine}@{bg fill}FADE Command@{fg text}@{bg back} @{i}Fade one colour to another@{ui} @{b} FADE ,,,WAIT|NOWAIT|STACK@{ub} Fades the specified colour to the new colour value with a certain speed. Use the STACK parameter if several colours should be faded simultaneously - GRAAL will wait until a FADE command with WAIT or NOWAIT specified and then also fade all STACKed colours at the same time. WAIT causes the action to be suspended during the colour fade. NOWAIT means action will continue while the colours are being faded. See also: @{"COLOUR" link "GG_COLOUR" 0} @endnode @node "GG_CAMERA" " CAMERA " @{fg shine}@{bg fill}CAMERA Command@{fg text}@{bg back} @{i}Pan the camera to any part of the background picture in scene area@{ui} @{b}CAMERA x_focus@{ub} @{b}x_focus@{ub} is the horizontal position GRAAL tries to put in the center of the scene area. Of course, the pan stops whenever one of the edges of the background picture comes into view. Use this command in cutscenes and the like, when you need to move the camera away from or independently of the main character. @endnode @node "GG_TITLE" " TITLE " @next "GG_TYPE" @prev "GG_FADE" @{fg shine}@{bg fill}TITLE Command@{fg text}@{bg back} @{i}Show a title screen@{ui} @{b} TITLE filename,effect@{ub} The file is an ordinary iff picture file. The effect can be one of the following: @{b}number@{ub} A previous title picture is gradually dissolved into a new one using a bit pattern that depends on the number given. Odd numbers, and prime numbers in particular, are recommended. Some numbers don't work at all! @{b}FADE@{ub} The old picture is faded to black, then the new one is faded in. @{b}CUT@{ub} Pictures are just swapped without any special effects. HAM screens should be handled this way. See also: @{"TYPE" link "GG_TYPE" 0} @endnode @node "GG_TYPE" " TYPE " @next "GG_BOBON" @prev "GG_TITLE" @{fg shine}@{bg fill}TYPE Command@{fg text}@{bg back} @{i}Type text on a title screen.@{ui} @{b} TYPE font,colour,x,y,effect,text@{ub} This command is used to type text on title background screens. @{b}font@{ub} is 1 or 2, corresponding to the @{"TITLEFONT:" link "ST_XXXFONT" 0} statements in the graal.main file. @{b}colour@{ub} is the colour number @{b}x,y@{ub} is the printing position. x=-1 means the text will be centered. @{b}effect@{ub} is @{b}SHADOW@{ub}, @{b}SHADOW2@{ub} or @{b}BORDER,@{ub} surrounding the text with different kinds of shading for greater legibility. If no effect is desired, use NONE. See also: @{"TITLE" link "GG_TITLE" 0} @endnode @node "GG_TEXT" " TEXT " @{fg shine}@{bg fill}TEXT command@{fg text}@{bg back} @{i}Display text in scene area@{ui} @{b}TEXT x,y,colour,text@{ub} This command uses the same font and pause lengths as the @{"SAY" link "GG_SAY" 0}, @{"THINK" link "GG_THINK" 0}, and @{"RESP" link "GG_RESP" 0} commands, but any text can be used and it is not connected to the main character or a certain dialogue. @{b}x,y@{ub} The text is placed centered around these co-ordinates. If x is set to -1, the text is be centered vertically on screen, no matter how the background is currently scrolled. See also: @{"SAY" link "GG_SAY" 0}, @{"THINK" link "GG_THINK" 0}, and @{"RESP" link "GG_RESP" 0} commands @endnode @node "GG_BOBON" " BOBON " @next "GG_BOBOFF" @prev "GG_TYPE" @{fg shine}@{bg fill}BOBON Command@{fg text}@{bg back} @{i}Places a BOB that is not a GRAAL object on screen.@{ui} @{b} BOBON bob number,x,y,image@{ub} If you are putting a new image on the screen, first make sure the BOB number is not already in use for any object in the room. If the BOB is already placed on screen, and x and y are left empty, only the image is changed and not the position. If the BOB is already placed on screen, and the image number is left blank, only the BOB position changes. See also: @{"BOBOFF" link "GG_BOBOFF" 0} @endnode @node "GG_BOBOFF" " BOBOFF " @next "GG_NOBREAK" @prev "GG_BOBON" @{fg shine}@{bg fill}BOBOFF Command@{fg text}@{bg back} @{i}Take away a BOB that is not an object from the screen@{ui} @{b}BOBOFF bob number@{ub} Used to take away BOBs from display that have been put there by the BOBON command. See also: @{"BOBON" link "GG_BOBON" 0} @endnode @node "GG_PBOB" " PBOB " @{fg shine}@{bg fill}PBOB command@{fg text}@{bg back} @{i}Pastes a BOB image@{ui} @{b} PBOB x,y,image@{ub} The image is pasted into the picture without anyway of removing it afterwards (unlike the BOBON / BOBOFF commands, which actually use a BOB to display an image). Use for animated dotted lines and other special effects. @endnode @node "GG_SETDATE" " SETDATE " @{fg shine}@{bg fill}SETDATE Command@{fg text}@{bg back} @{i}Sets the (game) date@{ui} @{b}SETDATE year,month,date,weekday@{ub} Note that we are talking about the "internal game time", not the system real time clock... If any of the weekday, date, or month parameters are left blank, they retain their old values. @{b}year@{ub} Anything you wish, preferably 2 or 4 digits @{b}month@{ub} 1-12, 1 being January... @{b}date@{ub} 1-31. The GRAAL calendar can handle the normal lengths of the months, but does not consider leap-years. @{b}weekday@{ub} 1-7, 1 being Monday and 7 Sunday. The GRAAL calendar does not check the historical accuracy of weekday versus date, though (see above). See also: @{"SETTIME" link "GG_SETTIME" 0} and @{"ADDTIME" link "ADDTIME" 0} commands @endnode @node "GG_SETTIME" " SETTIME " @{fg shine}@{bg fill}SETTIME command@{fg text}@{bg back} @{i}Sets the time@{ui} @{b}SETTIME hours,minutes@{ub} The time must be set in 24-hour format, regardless of whether it is presented that way or not (see @{"TIME_FORMAT" link "ST_TIMEFORMAT" 0}). Note that we talk about the "in-game clock", not the real-time system clock here. See also: @{"ADDTIME" link "ADDTIME" 0} command @endnode @node "ADDTIME" " ADDTIME " @{fg shine}@{bg fill}ADDTIME command@{fg text}@{bg back} @{i}Advances the clock@{ui} @{b} ADDTIME hours,minutes@{ub} Added time also alters the calendar if needed. Note that this command is only meant to be used for adding minutes, hours or possibly a day or two - when jumping further in time, use the @{"SETDATE" link "GG_SETDATE" 0} command. If @{"TIME_LAYOUT" link "ST_TIMELAYOUT" 0} or @{"DATE_LAYOUT" link "ST_DATELAYOUT" 0} is active, the command also updates the time and/or date displays. See also: @{"SETTIME" link "GG_SETTIME" 0} command @endnode @node "GG_SAVETIME" " SAVETIME " @{fg shine}@{bg fill}SAVETIME Command@{fg text}@{bg back} @{i}Saves the current in-game time and date@{ui} @{b}SAVETIME@{ub} This command is mainly here to make it a little easier to perform operations on dates and times. Doing "maths" on dates and times manually is not very fun, so this command lets you use the @{"ADDTIME" link "ADDTIME" 0} command without loosing the current time and date forever: Using @{"RESTORETIME" link "GG_RESTORETIME" 0} brings back the saved time and date. Example: You wish to store the date and time twelve hours from "now" in room flag 1 for room 1. This sequence of commands ought to do it. SAVETIME;ADDTIME 12,0;SETRF 1,1=#TIME;RESTORETIME @endnode @node "GG_RESTORETIME" " RESTORETIME " @{fg shine}@{bg fill}RESTORETIME Command@{fg text}@{bg back} @{i}Restores a previously saved time and date@{ui} @{b}RESTORETIME@{ub} Use this command to restore the date and time to that saved with @{"SAVETIME" link "GG_SAVETIME" 0}. @endnode @node "GG_NOBREAK" " NOBREAK " @next "GG_FINAL" @prev "GG_BOBOFF" @{fg shine}@{bg fill}NOBREAK Cutscene Command@{fg text}@{bg back} @{i}Disables [Esc] key in cutscenes@{ui} @{b} NOBREAK@{ub} This can only appear as the very first statement in a cutscene, and tells GRAAL that the [Esc] key cannot be used to skip this cutscene. @endnode @node "GG_FINAL" " FINAL" @next "GG_FINAL" @prev "GG_NOBREAK" @{fg shine}@{bg fill}FINAL Cutscene Command@{fg text}@{bg back} @{i}Indicates resume point in cutscene@{ui} @{b} FINAL@{ub} This can only be use in a cutscene. All commands below FINAL will be executed is the rest of the cutscene was skipped with the [Esc] key. @endnode @node "GG_ST_MAIN" " graal.main file " @next "GG_ST_SECT" @prev "Main" @{fg shine}@{bg fill}graal.main Statements@{fg text}@{bg back} @{"=DEMO=>" alink "graal.main/main" 0} Your statements in the @{b}graal.main@{ub} file should appear in the order indicated here. Although the order makes no difference in some cases, there are times when statements and commands depend upon previous statements to load the required resources into memory. This sequence of events is tested and it works! ("Number" below: ONE means statement occurs only once. ANY means zero to any number of times.) Statement Number Description " link "ST_NAME" 0} one Name of the adventure VERSION " link "ST_VERSON" 0} one Version number of the adventure MAX_CACHE " link "ST_MAXCACHE" 0} one Maximum number of files in memory cache N_VERBS " link "ST_NVERBS" 0} 0-1 Number of verbs, default is 9 *NEW* VERB_ZONE " link "ST_VERBZONE" 0} any position and size of each verb "button" *NEW* VERB_TEXT " link "ST_VERBTEXT" 0} any Message when pointing to a verb *NEW* ARROW_CURSOR " link "ST_ARROW_CURSOR" 0} 0-1 Image to use for arrow mouse pointer*NEW* CROSSHAIR_CURSOR " link "ST_ARROW_CURSOR" 0} 0-1 Image to use for crosshair mouse pointer*NEW* CURSOR_PALETTE " link "ST_CURSOR_PALETTE" 0} 0-1 Colours for mouse pointer*NEW* INV_LAYOUT " link "ST_INVLAYOUT" 0} 0-1 position and size of inventory list *NEW* INV_UP " link "ST_INVUP_ETC" 0} 0-1 properties of inventory scroll arrow *NEW* INV_DOWN " link "ST_INVUP_ETC" 0} 0-1 properties of inventory scroll arrow *NEW* CUTSCENE_LAYOUT " link "ST_CUTSCENELAYOUT" 0} 0-1 position and size of inventory list *NEW* DLG_LAYOUT " link "ST_DLGLAYOUT" 0} 0-1 position and size of dialogue lines *NEW* DLG_UP " link "ST_INVUP_ETC" 0} 0-1 properties of dialogue scroll arrow *NEW* DLG_DOWN " link "ST_INVUP_ETC" 0} 0-1 properties of dialogue scroll arrow *NEW* SENTENCE_LAYOUT " link "ST_SENTLAYOUT" 0} 0-1 position and size of sentence display *NEW* TIME_FORMAT " link "ST_TIMEFORMAT" 0} 0-1 format of time display *NEW* TIME_LAYOUT " link "ST_TIMELAYOUT" 0} 0-1 layout of time display *NEW* DATE_FORMAT " link "ST_DATEFORMAT" 0} 0-1 format of date display *NEW* DATE_LAYOUT " link "ST_DATELAYOUT" 0} 0-1 layout of date display *NEW* MONTH_TEXT " link "ST_MONTHTEXT" 0} 0-1 change names of all months *NEW* DAY_TEXT " link "ST_DAYTEXT" 0} 0-1 change names of all the days of the week *NEW* SYSTEM_TEXT " link "ST_SYSTEMTEXT" 0} any change system message texts *NEW* WALK_BUTTON " link "ST_WALKBUTTON" 0} one Left or right button used for walking? DISABLE_QUIT " link "ST_DISQUIT" 0} 0-1 Disables the "q" quit key EXIT_COL " link "ST_EXIT_COL" 0} one Text color of exit names OBJ_COL " link "ST_OBJ_COL" 0} one Text color of object names START_ROOM " link "ST_START_ROOM" 0} one Adventure starting position MAX_ROOM " link "ST_MAX_ROOM" 0} one Maximum room number used MAX_SECTION " link "ST_MAX_SECTION" 0} one Maximum section number used N_DIALOGUES " link "ST_NDIALOGUES" 0} 0-1 Sets the limits for dialogues MAX_DACT " link "ST_MAX_DACT" 0} one Maximum number of DACT statements per room MSGFONT " link "ST_XXXFONT" 0} one Scene area text font and size COMFONT " link "ST_XXXFONT" 0} one Command and dialogue area text font and size TITLEFONT1 " link "ST_XXXFONT" 0} one Titlepage text font and size (1) TITLEFONT2 " link "ST_XXXFONT" 0} one Titlepage text font and size (2) LINE_LENGTH " link "ST_linelength" 0} one Line length for SAY, RESP, etc. NORMAL_WAIT " link "ST_NORMWAIT" 0} 0-1 Normal wait period for texts *NEW* MODE_SWITCH " link "ST_MODESWITCH" 0} 0-1 Command/dialogue switching style *NEW* AREA_SIZES " link "ST_AREASIZES" 0} 0-1 Heights of scene and command areas *NEW* COMMAND_AREA " link "ST_AREAFILES" 0} one Name of picture with command area graphics DLG_AREA " link "ST_AREAFILES" 0} one Name of picture with dialogue area graphics RESOURCE " link "ST_RESOURCE" 0} one Name of interface resource bank GLOBALOBJS " link "ST_OBJS" 0} one Number of global objects SECTIONOBJS " link "ST_OBJS" 0} one Number of section objects ROOMOBJS " link "ST_OBJS" 0} one Number of room objects GLOBALBOBS " link "ST_NBOBS" 0} one Number of global BOB images SECTIONBOBS " link "ST_NBOBS" 0} one Number of section BOB images ROOMBOBS " link "ST_NBOBS" 0} one Number of room BOB images CLPART " link "ST_CLPART" 0} any Name of picture containing clipart graphics " link "ST_BOBS" 0} any Grab global BOB images from clipart picture CHARACTER_HEIGHT " link "ST_CHARSIZE" 0} one "Average" or estimated height of main character CHARACTER_WIDTH " link "ST_CHARSIZE" 0} one "Average" or estimated width of main character CHARACTER_BOB " link "ST_CHARACTER_BOB" 0} one BOB number used for main character CHARACTER_COL " link "ST_CHARACTER_COL" 0} one Text color of main character "speech" STILL_RIGHT " link "ST_STILL" 0} one Main character right profile image STILL_LEFT " link "ST_STILL" 0} one Main character left profile image STILL_BACK " link "ST_STILL" 0} one Main character backside image STILL_FRONT " link "ST_STILL" 0} one Main character front image PAUSE_RIGHT " link "ST_PAUSE" 0} one Main character pause image having walked right PAUSE_LEFT " link "ST_PAUSE" 0} one Main character pause image having walked left PAUSE_BACK " link "ST_PAUSE" 0} one Main character pause image having walked away PAUSE_FRONT " link "ST_PAUSE" 0} one Main character pause image having walked toward WALK_RIGHT " link "ST_WALK" 0} one Main character animation for walking right WALK_LEFT " link "ST_WALK" 0} one Main character animation for walking left WALK_AWAY " link "ST_WALK" 0} one Main character animation for walking away WALK_TOWARD " link "ST_WALK" 0} one Main character animation for walking toward WALK_SPEED " link "ST_WALK_SPEED" 0} one Main character walking speed adjustment TALK_MAP " link "ST_TALK_MAP" 0} 1-8 Speech animations mapped to pause/still images HANDLE_MAP " link "ST_HANDLE_MAP" 0} 1-8 Object manipulation animations mapped to -"- OBJECT " link "ST_OBJECT" 0} any Definitions of global objects " link "ST_DLG" 0} any Definitions of dialogue partners ACTION " link "ST_ACTION" 0} any Actions taken for input relevant to entire game @endnode @node "GG_ST_SECT" " .section files " @next "GG_ST_ROOM" @prev "GG_ST_MAIN" @{fg shine}@{bg fill}n.section Statements@{fg text}@{bg back} @{"=DEMO=>" alink "1.section/main" 0} Follow the statement order presented here in your .section files to avoid any unnecessary trouble. Statement Number Description @{" CLPART " link "ST_CLPART" 0} any Name of picture file containing clipart @{" SECTIONBOBS " link "ST_BOBS" 0} any Grab section BOB images from clipart picture @{" SECTIONOBJ " link "ST_OBJECT" 0} any Define section objects @{" " link "ST_LINE" 0} any Define dialogue lines main character can choose from *NEW* @{" " link "ST_LACT" 0} any Define responses to dialogue lines *NEW* @{" " link "ST_DACT" 0} any Actions executed directly when the section file is first used. @{" ACTION " link "ST_ACTION" 0} any Actions taken for player input relevant to section @endnode @node "GG_ST_ROOM" " .room files " @next "GG_ST_ROOM" @prev "GG_ST_SECT" @{fg shine}@{bg fill}n.room Statements@{fg text}@{bg back} @{"=DEMO=>" alink "1.room/main" 0} Please follow the order indicated here in your .room files to avoid unnecessary errors and trouble. Statement Number Description @{" UPDATE " link "ST_UPDATE" 0} one Frame update rate *NEW* @{" SECTION " link "ST_SECTION" 0} one Section to which room belongs @{" BG_IFF " link "ST_BG_IFF" 0} one Name of background picture for room @{" START_POS " link "ST_START_POS" 0} any Starting positions for main character @{" FLOOR " link "ST_FLOOR" 0} 1-12 Areas where the main character can "put its feet" @{" " link "ST_PATH" 0} 0-12 Path used for navigating between floors @{" " link "ST_EXIT" 0} 1-10 Exits @{" CLPART " link "GG_CLPART" 0} any Name of picture file containing clipart @{" ROOMBOBS " link "ST_BOBS" 0} any Grab room BOB images from clipart picture @{" STATIC " link "ST_STATIC" 0} any Place static graphic elements on background picture @{" " link "ST_ANIM" 0} any Place animated graphic elements on background picture @{" ROOMOBJ " link "ST_OBJECT" 0} any Define room objects @{" " link "ST_DACT" 0} any Actions to be taken directly upon entering the room @{" " link "ST_LINE" 0} any Define dialogue lines main character can choose from @{" " link "ST_LACT" 0} any Define responses to dialogue alternatives @{" ACTION " link "ST_ACTION" 0} any Actions to take for player input relevant to room @endnode @node "ST_NAME" "NAME" @next "ST_VERSON" @prev "ST_NAME" @{fg shine}@{bg fill}NAME Statement (main)@{fg text}@{bg back} @{i}Gives the adventure name@{ui} @{b}NAME: adventure name@{ub} It's always nice to know what you are doing, isn't it? This is shown when the player presses "V" and also identifies saved game files. @endnode @node "ST_VERSON" "VERSION" @next "ST_EXIT_COL" @prev "ST_NAME" @{fg shine}@{bg fill}VERSION Statement (main)@{fg text}@{bg back} @{i}Gives the adventure version@{ui} @{b}VERSION: version number@{ub} This is used to make sure saved game files are compatible with the current status of your adventure - always update this when you do ANYTHING with the adventure that affects the number of rooms, objects, sections, object definitions, or any flag usage! @endnode @node "ST_MAXCACHE" "MAX_CACHE" @next "ST_EXIT_COL" @prev "ST_VERSON" @{fg shine}@{bg fill}MAX_CACHE Statement (main)@{fg text}@{bg back} @{i}Sets the maximum number of files in the memory cache@{ui} @{b} MAX_CACHE: number of files@{ub} For normal use: Set to 0 when creating a game (especially if you are using the on-line debugger to reload altered scripts). Set to 100 once the game is ready to be played to eliminate disk swaps and make use of any extra memory you may have. When GRAAL detects that extra memory is available, it calculates how many files it will be able to fit into RAM, thus reducing disk access during gameplay. GRAAL calculates an average of 50K per file - if this is totally wrong (and don't ask me how, you will probably never have to bother), you may have to set this to a very low number or even to zero. @endnode @node "ST_ARROW_CURSOR" " ARROW_CURSOR: " @{fg shine}@{bg fill}ARROW_CURSOR / CROSSHAIR_CURSOR Statements (main)@{fg text}@{bg back} @{i}Changes the image of the mouse pointer@{ui} @{b} ARROW_CURSOR: image;hotspotx;hotspoty CROSSHAIR_CURSOR: image;hotspotx;hotspoty@{ub} @{b}image@{ub} a normal image number - you must grab the image to be used using a BOBS: statement first. Note that the images to be used as mouse pointer shapes must be drawn i lowres, and in four colours (2 bitplanes) only. Also, the image must be exactly 16 pixels wide. (Actually, the BOBS: statement should read 17 pixels, which will actually pick up 16 - one of life's little mysteries.) @{b}hotspotx;hotspoty@{ub} This sets the "sensitive point" of the cursor image, counted in pixels from the upper left corner of the image. See also: @{"CURSOR_PALETTE" link "ST_CURSOR_PALETTE" 0} statement @endnode @node "ST_CURSOR_PALETTE" " CURSOR_PALETTE: " @{fg shine}@{bg fill}CURSOR_PALETTE Statement (main)@{fg text}@{bg back} @{i}Sets the colours to use for the mouse pointer in the command area @{ui} @{b}CURSOR_PALETTE: rgb;rgb;rgb@{ub} The mouse pointer uses three colours. In the scene area, the colours will always be colours 16, 17, and 18 in the backdrop picture's palette. The colours specified here are used in the scene and command area. Each colour value is given as a a red, green, and blue component value in hexadecimal. FFF means white 000 means black 888 means grey 550 means dark yellow (some red + some blue) 0FF means bright cyan (all green + all blue) ...and so on... @endnode @node "ST_INVLAYOUT" "INV_LAYOUT" @{fg shine}@{bg fill}INV_LAYOUT Statement (main)@{fg text}@{bg back} @{i}Controls the layout of the inventory list@{ui} @{b}INV_LAYOUT: x1;y1;x2;y2;rows;cols;TEXT|ICONS; VERTICAL|HORIZONTAL;ink/image_no;bg@{ub} The first four parameters determines the size and position of the box containing the inventory list. "rows" and "columns" determines how many rows and columsn there are. @{b}TEXT|ICONS@{ub} determines whether text or icons will be used for the objects in the inventory list @{b}VERTICAL|HORIZONTAL@{ub} determines whether the list scrolls vertically (top to bottom) or horizontally (left to right). @{b}ink/image_no@{ub} If the inventory display is TEXT, this is the ink colour. If the display is ICONS, this is the image number to be used for an "empty space" in the inventory display. For example, if all your inventory icons have a border, this image should be a border with nothing in it - it kind of helps fill out the display... When a text inventory is specified, it is assumed there may be a border (1 pixel high, 2 pixels wide) around each "cell" in the inventory display: This means GRAAL does not erase the edges of the "cell". @{b}bg@{ub} specifies the colour to use for the background colour. If no INV_LAYOUT statement is given, the following is assumed: INV_LAYOUT: 284;19;634;60;3;2;TEXT;VERTICAL;7;8 which corresponds to the GRAAL built-in command area (the one used if COMMAND_AREA: DEFAULT is specified). @endnode @node "ST_INVUP_ETC" " INV_UP " @{fg shine}@{bg fill}INV_UP / INV_DOWN / DLG_UP / DLG_DOWN Statements (main)@{fg text}@{bg back} @{i}Sets the properties of the arrows used to scroll the inventory and the dialogue lines@{ui} @{b}INV_UP: x;y;image1;image2 INV_DOWN: x;y;image1;image2 DLG_UP: x;y;image1;image2 DLG_DOWN: x;y;image1;image2@{ub} @{b}x;y@{ub} is the top left hand corner of the aroow of other symbol used to indicate the list can be scrolled (up or down, depending on which statement we're talking about) @{b}image1@{ub} is the image used when the function is available @{b}image2@{ub} is the image used when the function is unavailable The images must be global. The default statements are as follows: INV_UP: 265;18;12;10;3;5 INV_DOWN: 265;48;12;10;4;5 DLG_UP: 8;8;12;10;3;5 DLG_DOWN: 8;38;12;10;4;5 As you see, by default the inventory and dialogue displays use the same symbols (up and down arrows), and all statements use the same image2. This is possible because the "not available" symbol is just a piece of background, erasing the unavailable arrow(s) completely. @endnode @node "ST_DLGLAYOUT" " DLG_LAYOUT " @{fg shine}@{bg fill}DLG_LAYOUT Statement (main)@{fg text}@{bg back} @{i}Determines the layout of the dialogue area@{ui} @{b} DLG_LAYOUT: x1;y1;x2;y2;rows;ink;bg@{ub} @{b}x1;y1;x2;y2@{ub} defines the "box" containing the dialogue lines. @{b}rows@{ub} determines the numer of lines shown at the same time. The height of the box is divided into this many "cells" ink;bg sets the text and background colours When handling the dialogue lines, GRAAL assumes there may be a border 1 pxel high and 2 pixels wide around each "cell" in the list, and therefore does not erase the edges of the cell. @endnode @node "ST_CUTSCENELAYOUT" " CUTSCENE_LAYOUT @{fg shine}@{bg fill}CUTSCENE_LAYOUT Statement (main)@{fg text}@{bg back} @{i}Determines size, position and image for cutscene indicator@{ui} @{b} CUTSCENE: x1;y1;x2;y2;bg;imagex;imagey;imageno@{ub} This is used by the cutscene command ( with the "S" or "F" parameter ) to place the cutscene indicator on the command area. @{b}x1;y1;x2;y2;bg@{ub} defines the area in the command area which should be "blanked out" before placing the indicator itself, an its colour. (A larger area "eats" some memory, because the overlaid graphics have to be stored elsewhere for the duration... @{b}bg@{ub} is the background colour @{b}imagex;imagey@{ub} is the top left corner of the indicator @{b}imageno@{ub} is the bob image containing the actual indicator. If this statement is not in the graal.main file, the following is used: CUTSCENE: 5;18;255;62;8;122;24;6 @endnode @node "ST_SENTLAYOUT" " SENTENCE_LAYOUT " @{fg shine}@{bg fill}SENTENCE_LAYOUT Statement (main)@{fg text}@{bg back} @{i}Determines the size and position of the sentence display area@{ui} @{b} SENTENCE_LAYOUT: x1;y1;x2;y2;ink;inkhi;bg@{ub} This statement sets the box where the constructed sentence is built and displayed. @{b}x1;y1;x2;y2@{ub} are the corners of the area of the sentence box. It is assumed a border is included in the area (1 pixel high, 2 pixels wide), which means the edges of the specified area will not be erased by GRAAL. The text will be centered at the top of the area. @{b}ink;inkhi;bg@{ub} sets the text, highlighted text, and background colours. @endnode @node "ST_TIMEFORMAT" " TIME_FORMAT " @{fg shine}@{bg fill}TIME_FORMAT Statement (main)@{fg text}@{bg back} @{i}Determines how the time is shown@{ui} @{b}TIME_FORMAT: format-string;am-text;pm-text@{ub} The time can be shown either permanently in the command area (using @{"TIME_LAYOUT" link "ST_TIMELAYOUT" 0}), or in a text in the scene area (using the special variable #TIME in a TEXT, SAY, THINK, or RESP command). This statement determines how it is shown (excluding the ANALOGUE display possible with TIME_LAYOUT - see that for more info.) @{b}format-string@{ub} This is a string of characters. The following special characters may appear: the hours will be placed here in 12-hour format the hours will be placed here in 24-hour format the minutes will be placed here the am/pm text will be placed here Examples: TIME_FORMAT: #12:#MM #AM;am;pm may give results such as "3:35 am" and "6:00 pm" TIME_FORMAT: #24:#MM may give results such as "1:30" or "15:37" @endnode @node "ST_TIMELAYOUT" " TIME_LAYOUT " @{fg shine}@{bg fill} TIME_LAYOUT Statement (main)@{fg text}@{bg back} @{i}tells GRAAL to show the time in the command area@{ui} @{b}TIME_LAYOUT: DIGITAL|ANALOGUE;x1;y1;x2;y2;ink;bg[[;px1;py1;px2;py2;ink;bg];font]@{ub} If this statement is present in the graal.main script, the time will be permanently shown in the command area. It will be automatically updated when needed. @{b}DIGITAL|ANALOGUE@{ub} "DIGITAL" will show the time in figures and text using the format specified in @{"TIME_FORMAT" link "ST_TIMEFORMAT" 0} "ANALOGUE" will draw the hands of an analogue clock @{b}x1;y1;x2;y2@{ub} This is the area where either the text or the clock hands are drawn. If ANALOGUE is chosen, the width of the rectangle should be double the height to achieve a circular clock face. In DIGITAL mode, the text will be centered at the top of the rectangle. In ANALOGUE mode, the area is NOT erased when the hands are redrawn - only the old positions of the hands are erased. This means you can draw the rest of the clock face around the hands in the command area backdrop picture - just make sure the hands do not pass over any of your graphics. ink;bg sets colour and background for the "digital text" or the clock face. @{b}px1;py1;px2;py2@{ub} This can only be used together with analogue and defines a second rectangle in the command area where the "am/pm" texts are shown to complement the information in the analogue clock. If you do not want to display this information, just leave the last 7 parameters out. (That is, the last "font" parameter is also left out, because you do not need to specify a font for the display of the clock face...) ink;bg sets the text and background colours for the "am/pm" text display for an analogue clock (if this is included).. @{b}font@{ub} This is the font used for the "DIGITAL" time display, or the "am/pm" display complementing the "ANALOGUE" clock. A number between 1 and 4 is expected: 1 is TITLEFONT1 2 is TITLEFONT2 3 is MSGFONT 4 is COMFONT @endnode @node "ST_DATEFORMAT" " DATE_FORMAT " @{fg shine}@{bg fill}DATE_FORMAT Statement (main)@{fg text}@{bg back} @{i}Sets the date display format@{ui} @{b}DATE_FORMAT: format-string@{ub} The date can be displayed either permanently in the command area (using the @{"DATE_LAYOUT" link "ST_DATELAYOUT" 0} statement) or in the sentence area using the special variable #DATE in a SAY, THINK, TEXT or RESP statement. This statement determines how the date will be presented. @{b}format-string@{ub} In this string, the following special characters will be replaced by "date data" is replaced with the year is replaced by the number of the month without a leading zero is replaced by the number of the month with a leading zero is replaced by the name of the month (is seldom used in the same string as "M", obviously) is replaced by the date without a leading zero is replaced by the date with a leading zero is replaced by the weekday All other characters in the string is kept as is. Examples: DATE_FORMAT: #Y-#0M-#0D may give "1996-08-01" DATE_FORMAT: #M/#D/#Y may give: "8/1/96" (two or four digits in the year simply depends on what you set the year to - see SETDATE command) DATE_FORMAT: #N #D, #Y may give "August 1, 1996" DATE_FORMAT: #W, #N #D may give "Saturday, August 1" Note that the names of months and weekdays can be changed using the @{"MONTH_TEXT:" link "ST_MONTHTEXT" 0} and @{"DAY_TEXT:" link "ST_DAYTEXT" 0} statements. @endnode @node "ST_DATELAYOUT" " DATE_LAYOUT " @{fg shine}@{bg fill}DATE_LAYOUT Statement (main)@{fg text}@{bg back} @{i}tells GRAAL to show the date in the command area@{ui} @{b} DATE_LAYOUT: x1;y1;x2;y2;ink;bg;font@{ub} If this statement is present in the graal.main script, the date will be permanently shown in the command area. It will be automatically updated when needed. The display format is decided by the @{"DATE_FORMAT" link "ST_DATEFORMAT" 0} statement. @{b}x1;y1;x2;y2@{ub} This is the rectangle containing the date. The text will be centered at the top of the rectangle. @{b}ink;bg@{ub} sets the text and background colours @{b}font@{ub} is a number between 1 and 4: 1 is TITLEFONT1 2 is TITLEFONT2 3 is MSGFONT 4 is COMFONT @endnode @node "ST_WALKBUTTON" " WALK_BUTTON " @{fg shine}@{bg fill}WALK_BUTTON Statement (main)@{fg text}@{bg back} @{i}Sets the mouse button used for walking.@{ui} @{b} WALK_BUTTON: LEFT|RIGHT@{ub} The setting determines if you can use the left or right mouse button to command the main character to walk to any spot in the room (that is, click anywhere that isn't an object or an exit). @endnode @node "ST_DISQUIT" " DISABLE_QUIT " @{fg shine}@{bg fill}DISABLE_QUIT Statement (main)@{fg text}@{bg back} @{i}disables the standard "q" quit key and function.@{ui} @{b}DISABLE_QUIT:@{ub} This statement has no parameters. When found in the graal.main file, it disables the use of the "q" quit key to quit the game. You shouldn't do this until you have implemented and tested your own quit function, which probably uses a direct verb (see the @{"VERB_TEXT:" link "ST_ExitMessage" 0} statement) and the QUIT command. @endnode @node "ST_NVERBS" " N_VERBS " @{fg shine}@{bg fill}N_VERBS Statement (main)@{fg text}@{bg back} @{i}Sets the number of commands (verbs) used in the player interface@{ui} @{b} N_VERBS: number of verbs@{ub} The default number of verbs is 9, not counting verb 0 (go to), which is always present but not shown to the player. If you do use this statement, there must also be a VERB_ZONE: statement for each and every verb (that is, the number of VERB_ZONE: statements must match the number given here). @endnode @node "ST_VERBZONE" " VERB_ZONE " @{fg shine}@{bg fill}VERB_ZONE Statement (main)@{fg text}@{bg back} @{i}Sets the position and size of a command (=verb) "button".@{ui} @{b} VERB_ZONE: verb number;x1;y1;x2;y2@{ub} @{b}verb number@{ub} is the number of the verb this zone belongs to @{b}x1;y1;x2;y2@{ub} defines a rectangle (top left and bottom right corner, as always when specifying areas this way). if VERB_ZONE statements are to be used at all, or @{"N_VERBS" link "ST_NVERBS" 0} changed from the default 9, one VERB_ZONE statement must be given for each verb. @endnode @node "ST_VERBTEXT" " VERB_TEXT " @{fg shine}@{bg fill}VERB_TEXT Statement (graal.main)@{fg text}@{bg back} @{i}Contains the message shown when using a verb, and also whether a verb is a direct verb or not.@{ui} @{b}VERB_TEXT: verb_no;[$]text@{ub} This is the text that appears in the sentence area when you use a command or an exit. Texts 0-9 and 999 have default values in English, but all of them can be translated into any language using this statement, and all of them (except a few) can also be changed to a completely different verb. If the text is prefixed with a dollar sign (@{b}$@{ub}), the verb is treated as a @{b}direct verb@{ub}. A direct verb does not use objects - it is executed immediately when the player clicks it. This can be useful for making special functions available in the command area, such as speical forms of QUIT, or a RESTART command - although the possibilities do no end there. These are the default values: 0 - Go to (Meaning can not be changed) 1 - Give (Meaning can not be changed) 2 - Pick up 3 - Use (Meaning can not be changed) 4 - Open 5 - Talk to 6 - Push 7 - Close 8 - Look at 9 - Pull 999 - to (This is the preposition text for command 1, "Give") And here's why you cant change the meaning of 0,1, and 3: 0 - This is not a command shown in the command area, but rather what happens when you click an exit in the scene area - thus, it must always have the meaning "go to" (although you can translate THAT into any language using this statement!) 1 - This command is always suffixed with the preposition " to ". To alter the " to ", use VERB_TEXT: 999;newtext 3 - This command makes use (no pun intended!) of the preposition defined for an object, which is what makes it possible to make objects interact with each other (or not). Of course, some of the other commands are also hard to think of a better replacement for - how are you going to engage in conversations without a "Talk to" command, for instance? Or perhaps you are not planning to - that's also up to you! @endnode @node "ST_MONTHTEXT" " MONTH_TEXT " @{fg shine}@{bg fill} MONTH_TEXT Statement (main)@{fg text}@{bg back} @{i}sets the names of all the months@{ui} @{b} MONTH_TEXT: name1;name2; ... ;name12@{ub} This is the name of the month that can be used when displaying a date. The default names are "January","February", ... , "December" See also: @{"DATE_FORMAT" link "ST_DATEFORMAT" 0} and @{"DATE_LAYOUT" link "ST_DATELAYOUT" 0} statements @endnode @node "ST_DAYTEXT" " DAY_TEXT " @{fg shine}@{bg fill}DAY_TEXT Statement (main)@{fg text}@{bg back} @{i}sets the names of the days in the week@{ui} @{b} DAY_TEXT: name1;name2; ... ;name7@{ub} These are the names that can be used when displaying a date. The default names are "Monday","Tuesday", ... , "Sunday" See also: @{"TIME_FORMAT" link "ST_TIMEFORMAT" 0} and @{"TIME_LAYOUT" link "ST_TIMELAYOUT" 0} statements @endnode @node "ST_SYSTEMTEXT" " SYSTEM_TEXT " @{fg shine}@{bg fill}SYSTEM_TEXT: Statement (main)@{fg text}@{bg back} @{i}changes a system message text@{ui} @{b} SYSTEM_TEXT: number;"message"@{ub} This is of use for translators to foreign languages only (like my own, for instance). Try to keep the text about the same length as the English original. These are the default texts (the quotes must be included in the statement): 1 "Please insert disk " 2 "Select a saved game slot" 3 "Saved game description" 4 "Load" 5 "Save" 6 "Back" 7 "OK" 8 "Cancel" 9 "Change" 10 " There are no saved games on this disk." 11 "Do you want to use this disk for saved games?" 12 "****** GAME PAUSED ******\Press any key to continue" 13 "You are playing" 14 "running under " 15 "Please insert save disk into DF0:" 16 "Please write-enable the disk!" 17 " Yes" 18 "Music & Sounds off" 19 "Music & Sounds on" 20 " Speech speed:" 21 "Slow Fast" @endnode @node "ST_EXIT_COL" "EXIT_COL" @next "ST_OBJ_COL" @prev "ST_VERSON" @{fg shine}@{bg fill}EXIT_COL Statement (main)@{i} @{fg text}@{bg back}Specifies color of exit names shown in scene area@{ui} @{b}EXIT_COL: colour number@{ub} Make this a fairly bright colour - the text will be surrounded by a black outline. @endnode @node "ST_OBJ_COL" "OBJ_COL" @next "ST_OBJ_COL" @prev "ST_EXIT_COL" @{fg shine}@{bg fill}OBJ_COL Statement (main)@{fg text}@{bg back} @{i}Specifies the colour of object names displayed in the scene area@{ui} @{b} OBJ_COL: colour number@{ub} Make this a fairly bright colour - it will be surrounded by a black outline. @endnode @node "ST_START_ROOM" "START_ROOM" @next "ST_MAX_ROOM" @prev "ST_OBJ_COL" @{fg shine}@{bg fill}START_ROOM Statement (main)@{fg text}@{bg back} @{i}Specifies the starting position for the adventure@{ui} @{b}START_ROOM: room;entrance@{ub} The action will commence in this room and at this entrance - also see the .room @{"START_POS" link "ST_START_POS" 0} statement. @endnode @node "ST_MAX_ROOM" "MAX_ROOM" @next "ST_MAX_SECTION" @prev "ST_START_ROOM" @{fg shine}@{bg fill}MAX_ROOM Statement (main)@{fg text}@{bg back} @{i}Highest room number used in this adventure@{ui} @{b} MAX_ROOM: number@{ub} All rooms in an adventure are numbered from 1 and upwards - try not to leave "holes" in the room sequence, since each room number, used or not, takes up valuable memory space! If the adventure is split up onto several disks, there is no way for GRAAL to automatically know how many rooms there actually is, so this statement must be updated continually as more rooms are added to the game. Tip: If you delete a sequence of rooms in the middle of the game, re-use those vacant room numbers if you add more rooms later on - rather than increasing the highest room number. @endnode @node "ST_MAX_SECTION" "MAX_SECTION" @next "ST_MAX_DACT" @prev "ST_MAX_ROOM" @{fg shine}@{bg fill}MAX_SECTION Statement (main)@{fg text}@{bg back} @{i}The highest section number used in the adventure@{ui} @{b} MAX_SECTION: number@{ub} Like MAX_ROOM, this must be manually updated with the highest section number used so far during development. Always start with section 1 and continue upwards without leaving "holes" in the numbering sequence if you can avoid @endnode @node "ST_MAX_DACT" "MAX_DACT" @next "ST_XXXFONT" @prev "ST_MAX_SECTION" @{fg shine}@{bg fill}MAX_DACT Statement (main)@{fg text}@{bg back} @{i}Sets the maximum number of DACT statements that can be used in a room file@{ui} @{b} MAX_DACT: number@{ub} Don't know why I made this customisable, really - 50 should be plenty, and no other limits of a similar nature are possible to alter thus far. Still, in future versions of GRAAL, most limits like this may be defined by the user. @endnode @node "ST_NDIALOGUES" " N_DIALOGUES " @{fg shine}@{bg fill}N_DIALOGUES Statement (main)@{fg text}@{bg back} @{i}Sets the limits for dialogues@{ui} @{b}N_DIALOGUES number;lines;actions@{ub} @{b}number@{ub} is the number of simultaneously available dialogues - that is, the maximum number referred to at any time by the current section and the current room scripts. @{b}lines@{ub} is the maximum number of LINE: statements used in a dialogue @{b}actions@{ub} is the maximum number of LACT: statements used in a dialogue @endnode @node "ST_XXXFONT" "MSGFONT" @next "ST_AREAFILES" @prev "ST_MAX_DACT" @{fg shine}@{bg fill}MSGFONT COMFONT TITLEFONT1 TITLEFONT2 Statements (main)@{fg text}@{bg back} @{i}Defines fonts and sizes for various uses@{ui} @{b} MSGFONT: name;size COMFONT: name;size TITLEFONT1: name;size TITLEFONT2: name;size@{ub} The fonts (in the proper sizes) must be available in a FONTS: drawer in your development directory. Furthermore, FIXFONTS must have been used on the drawer for all the fonts to be OK. @{b}MSGFONT@{ub} is the font used for all text displayed in the scene area. @{b}COMFONT@{ub} is the font used for the input sentence display and dialogue lines. Do not alter these two in GRAAL version 1, since this will probably mess up line spacing (among other things). They will be of more use in GRAAL 2. @{b}TITLEFONT1@{ub} and @{b}TITLEFONT2@{ub} are used with the TYPE command to print text on title screens. Note: When GRAAL starts up, the GRAAL FONTS: drawer is copied to RAM:, and FONTS: is reassigned to RAM:Fonts/. Which is a good reason for not multi- tasking too much when running a GRAAL adventure. Sorry 'bout this, but the fault lies with Amos Pro font handling (and the fact that the Easylife extension font handling had too many bugs in it!). @endnode @node "ST_linelength" " LINE_LENGTH " @{fg shine}@{bg fill}LINE_LENGTH Statement (main)@{fg text}@{bg back} @{i}Determines the line length of displayed sentences (SAY, RESP, and other commands.)@{ui} @{b} LINE_LENGTH characters@{ub} GRAAL does automatic line breaks in long sentences - this is the length it aims for for each line in SAY, RESP, and other similar commands. GRAAL will only break lines in between words, and does not hyphenate. You may control line breaks manually in any sentence - just insert backslash ( \ ) characters where you want line breaks to appear. This will override the setting of the LINE_LENGTH: statement. @endnode @node "ST_NORMWAIT" " NORMAL_WAIT " @{fg shine}@{bg fill}NORMAL_WAIT Statement (main)@{fg text}@{bg back} @{i}Sets the default display time for text and sentences in scene area@{ui} @{b} NORMAL_WAIT: time@{ub} This value is used in a formula calculating for how long a text or spoken sentence should be displayed in the scene area. The formular also incorporates the overall text length and the number of lines it is broken into. Also, character sentences are shown for a slightly shorter period of time than other characters speech, because the contents of a "SAY" sentence uttered by the main character is often known wholly or partly by the player beforehand. The bigger the number, the longer the pause. Default is 100. If this is not enough, try other nice, round numbers like 200 or 400.. @endnode @node "ST_MODESWITCH" " MODE_SWITCH " @{fg shine}@{bg fill}MODE_SWITCH Statement (main)@{fg text}@{bg back} @{i}Decides how a switch between command and dialogue mode is performed.@{ui} @{b} MODE_SWITCH: ROLL|INSTANT@{ub} The command area rolls off the bottom of the screen, and the dialogue area rolls in from where the command area disappeared. (And vice versa.) This is the default, and what GRAAL 1 used. INSTANT The command area disappears instantly, and the dialogue area is created "on the spot" to replace it. (And vice versa.) @endnode @node "ST_AREASIZES" " SPLIT_LINE " @{fg shine}@{bg fill}AREA_SIZES: Statement (main)@{fg text}@{bg back} @{i}Sets the height of the scene area and the command area.@{ui} @{b} AREA_SIZES: scene_height;command_height@{ub} This statement allows you to vary the proportions of the screen set aside to the scene area versus and command/dialogue area. NOTE: If you want NTSC machine users to be able to run your adventures, you should make sure the sum of the values is not higher than 200. "Pal-only" adventures should not use a sum bigger then 256. @endnode @node "ST_AREAFILES" "COMMAND_AREA" @next "ST_RESOURCE" @prev "ST_XXXFONT" @{fg shine}@{bg fill}COMMAND_AREA / DLG_AREA Statements (main)@{fg text}@{bg back} @{i}Graphic files containing the graphics for the command area and dialogue area@{ui} @{b} COMMAND_AREA filename DLG_AREA filename@{ub} These files contain the graphics for the command area and its replacement during dialogues, the dialogue control area. In graal 1, keep all measurements and positions of all boxes and buttons drawn in these files exactly as they are: GRAAL 2 will provide more freedom when designing the user interface, but for now you are stuck with the nine standard commands and the fonts and spacings used in Olaf 1. If DEFAULT is specified as filename, a new file will not be loaded - the default graphics present in GRAALs memory will be used instead, which speeds up the loading time. @endnode @node "ST_RESOURCE" "RESOURCE" @next "ST_OBJS" @prev "ST_AREAFILES" @{fg shine}@{bg fill}RESOURCE Statement (main)@{fg text}@{bg back} @{i}Name of interface resource bank@{ui} @{b}RESOURCE filename@{ub} This must be an Amos Pro resource bank especially designed for GRAAL. It controls the graphic appearance of the disk swapping, save/load and quit dialogue boxes, among other things. Experienced Amos Pro users can also easily use the Amos resource editor to make their own banks, but this will not be explained here. GRAAL 2 will provide several different ready-made resource banks with different looks: High-tech, Stone-age, Medeival... For now, stick with the one used in Olaf 1. @endnode @node "ST_OBJS" "GLOBALOBJS" @next "ST_NBOBS" @prev "ST_RESOURCE" @{fg shine}@{bg fill}GLOBALOBJS / SECTIONOBJS / ROOMOBJS Statements (main)@{fg text}@{bg back} Sets the number of objects that can be used in the game @{b}GLOBALOBJS: number SECTIONOBJS: number ROOMOBJS: number@{ub} Objects are all the objects that have a name within the adventure and thus can be manipulated by the user. It would be wasteful to have the data for all objects in memory all the time, which is why they are divided into three categories: @{b}GLOBAL OBJECTS@{ub} are indeed available all the time. Everything that can be carried in the inventory over more than one section of the game, and all characters that Olaf can have conversations with must be in this category. Numbering of global objects start with 1 and proceeds upwards. @{b}SECTION OBJECTS@{ub} can only exist within one particular section of the game. Note that if a player leaves the section and re-enters it at a later date, all information in object flags and the like has been lost - all object will be re-initialised with the status and position defined in the OBJECT: stetements in the .section file. Therefore, use this with caution! To refer to a section object, use SOBJn, where n is the number of the section object. @{b}ROOM OBJECTS@{ub} are restricted to the current room only, and should preferrably be objects which can not be "seriously" manipulated by the user - usually, they are only there to add a bit of atmosphere and to act as red herrings. The torch in the bar in Olaf 1 is a perfect example of such an object. To refer to a room object, use ROBJn, where n is the number of the room object. These statements decide how many objects of each time GRAAL will make room for. You can alter any of the values any time during the development, so no panic. @endnode @node "ST_NBOBS" "GLOBALBOBS" @next "ST_CLPART" @prev "ST_OBJS" @{fg shine}@{bg fill}GLOBALBOBS / SECTIONBOBS / ROOMBOBS Statements (main)@{fg text}@{bg back} @{i}Sets the number of BOB image bank slots available for each BOB image category@{ui} @{b}N_GLOBALBOBS: number N_SECTIONBOBS: number N_ROOMBOBS: number@{ub} Object images are referred to and treated according to which of the three above categories they belong: GLOBAL BOBS are images that are always in memory for instant access anywhere in the game - for instance, the images used for the animation of the main character. Global BOB images are grabbed by the BOBS: statement in the graal.main file and referred to by their true number. Since BOB images 1-10 are reserved for system use, the ones you normally refer to in the game start with number 11. SECTION BOBS are grabbed with the SECTIONBOBS: statement in a .section file and remain in memory as long as the player stays in the section. They are referred to using SBOBn, where n is the number of the section BOB image. ROOM BOBS are grabbed with the ROOMBOBS: statement in a .room file and remain in memory as long as the player stays in the room. They are referred to using RBOBn, where n is the number of the room BOB image. The numbers set in these statements may be altered at any time during development, so don't panic. Note: If you need some "dynamic" image replacing, any kind of image may also be grabbed/replaced by the @{"BOBS" link "GG_BOBS" 0} command, which has the same parameter as these statements. @endnode @node "ST_CLPART" "CLPART" @next "ST_BOBS" @prev "ST_NBOBS" @{fg shine}@{bg fill}CLPART Statement (main, section, room)@{fg text}@{bg back} @{i}Loads an IFF picture file containing clipart into memory@{ui} @{b}CLPART: filename@{ub} GRAAL doesn't mess around with complicated picture storage formats - all graphics used in the game are "grabbed" from ordinary IFF files. This statement selects the IFF file to be using for subsequent "grabbing" with the BOBS:, SECTIONBOBS: and ROOMBOBS: statements. @endnode @node "ST_BOBS" "BOBS" @next "ST_CHARSIZE" @prev "ST_CLPART" @{fg shine}@{bg fill}BOBS Statement (main)@{fg text}@{bg back} @{fg shine}@{bg fill}SECTIONBOBS Statement (section)@{fg text}@{bg back} @{fg shine}@{bg fill}ROOMBOBS Statement (room)@{fg text}@{bg back} @{i}Grabs BOB images into the BOB image bank@{ui} @{b}BOBS: number;startnumber;x1;y1;width;height;x-offset;hotspot SECTIONBOBS: number;startnumber;x1;y1;width;height;x-offset;hotspot ROOMBOBS: number;startnumber;x1;y1;width;height;x-offset;hotspot@{ub} This command can grab a single image or a row of images, provided they are aligned horisontally and equally sized and spaced. All three versions of the command have the same syntax. The only difference is the BOB image category they grab. BOBS are later referred to by their proper image number, SECTIONBOBS by SOBJn and ROOMBOBS by ROBJn. number The number of images to grab with this statement. startnumber The first image to grab will get this number. If more than one image is grabbed, the number will be assigned in increasing sequence. E.g. BOBS: 4;11;... would grab the global BOB images 11, 12, 13 and 14. ROOMBOBS 1;5;... would grab ROBJ5. x1;y1 Imagine the clipart being cut out of the picture (previously loaded with the CLPART: statement) by placing a rectangular frame over the picture and cutting along the edges, x1;y1 is the co-ordinate in the upper left corner of the frame... width;height ...and this is the width and the height of the frame. Everything that is cut out and is of colour 0 will be transparent when the image is used. x-offset If more than one image is grabbed with the statement, this number tells how many pixels to the right the "frame" should be moved before cutting out the next image. hotspot The hotspot decides which point of an image is actually placed at the co-ordinates of a command using the image. For example, BOBON 10,30,70,SBOB3 is a GRAAL command placing image SBOB3 at the co-ordinates 30,70. Great, but which point of the image is actually placed at 30,70? That is decided by the hotspot. The default hotspot in graal (choosen by setting the hotspot parameter to 0) is in the middle at the bottom of the frame - which is where a character grabbed as an image usually should have its feet. Setting the hotspot parameter to another value retains the x-position of the hotspot but alters the y-value. This has to do with getting objects in 3D scenes in the correct order and is explained in more detail in the GRAAL tutorial. @endnode @node "ST_CHARSIZE" "CHARACTER_HEIGHT" @next "ST_CHARACTER_BOB" @prev "ST_BOBS" @{fg shine}@{bg fill}CHARACTER_HEIGHT / CHARACTER_WIDTH Statements (main)@{fg text}@{bg back} @{i}Gives the average size of the main character@{ui} CHARACTER_HEIGHT: pixels CHARACTER_WIDTH: pixels@{ub} This states how big you main character normally is, and is used to calculate how the main character may move on the screen. A good example is the "alley" in the street outside the bar in Olaf 1. It shows that the system is aware of Olafs width and doesn't put him in the alley unless he fits there - click on a point too close to the walls, and Olaf walks out of the alley again. @endnode @node "ST_CHARACTER_BOB" "CHARACTER_BOB" @next "ST_CHARACTER_COL" @prev "ST_CHARSIZE" @{fg shine}@{bg fill}CHARACTER_BOB Statement (main)@{fg text}@{bg back} @{i}Sets the BOB number used for the main character@{ui} @{b}CHARACTER_BOB: number@{ub} Do not alter this! (But some time in the future there may be a good reason to be able to customise it.) @endnode @node "ST_CHARACTER_COL" "CHARACTER_COL" @next "ST_PAUSE" @prev "ST_CHARACTER_BOB" @{fg shine}@{bg fill}CHARACTER_COL Statement (main)@{fg text}@{bg back} @{i}Sets the colour to use for main character "speech"@{ui} @{b}CHARACTER_COL: colour number@{ub} Make this a fairly bright colour, since it will be surrounded by a black outline. It should also a colour that is the same for all graphics in the adventure, because it does not look good if the main characters speech keeps shifting its colour from dialogue to dialogue. @endnode @node "ST_PAUSE" "PAUSE_RIGHT" @next "ST_STILL" @prev "ST_CHARACTER_COL" @{fg shine}@{bg fill}PAUSE_RIGHT / PAUSE_LEFT / PAUSE_BACK / PAUSE_FRONT Statements (main)@{fg text}@{bg back} @{i}Sets the images used when the character pauses in one of the four main directions@{ui} @{b} PAUSE_RIGHT: image number PAUSE_LEFT: image number PAUSE_BACK: image number PAUSE_FRONT: image number@{ub} These images are used when the main character pauses waiting for player input. You may choose to use exactly the same images as for the corresponding STILL_ statements. @endnode @node "ST_STILL" "STILL_RIGHT" @next "ST_WALK" @prev "ST_PAUSE" @{fg shine}@{bg fill}STILL_RIGHT / STILL_LEFT / STILL_BACK / STILL_FRONT Statements (main)@{fg text}@{bg back} @{i}Sets the still images used for the main character and the four main directions.@{ui} STILL_RIGHT: image number STILL_LEFT: image number STILL_BACK: image number STILL_FRONT: image number@{ub} These images will be used in automatic main character movement. @endnode @node "ST_WALK" "WALK_RIGHT" @next "ST_WALK_SPEED" @prev "ST_STILL" @{fg shine}@{bg fill}WALK_RIGHT / WALK_LEFT / WALK_AWAY / WALK_TOWARD Statements (main)@{fg text}@{bg back} @{i}Defines the animation sequence used for movement in the four directions.@{ui} @{b} WALK_RIGHT: animation sequence WALK_LEFT: animation sequence WALK_AWAY: animation sequence WALK_TOWARD: animation sequence@{ub} These four @{"animation sequences" link "GG_Animation" 0} are used by GRAAL for all automatic movement of the main character. @endnode @node "ST_WALK_SPEED" "WALK_SPEED" @next "ST_TALK_MAP" @prev "ST_WALK" @{fg shine}@{bg fill}WALK_SPEED Statement (main)@{fg text}@{bg back} @{i}Adjust walking speed@{ui} @{b}WALK_SPEED: speed factor@{ub} This statement adjusts the speed of the automatic main character movement so that the speed matches the WALK_xxxxx animation squences - the objective is to make it look like the character actually uses his feet to walk, rather than glide around on a slippery surface. Simply experiment with the value until the movement (especially sideways) looks good! @endnode @node "ST_TALK_MAP" "TALK_MAP" @next "ST_HANDLE_MAP" @prev "ST_WALK_SPEED" @{fg shine}@{bg fill}TALK_MAP Statement (main)@{fg text}@{bg back} @{i}Defines animation sequences used for automatic main character speech@{ui}" link "GG_Animation" 0} used for automatic main character speech @{b}TALK_MAP: previous image;animation sequence@{ub} When a @{"SAY" link "GG_SAY" 0} command is given, GRAAL checks which image is currently used for the main character. (This should normally be one of the @{"STILL_..." link "ST_STILL" 0} or @{"PAUSE_..." link "ST_PAUSE" 0} images.) The image is checked against the TALK_MAP statements (there may be up to 8 of them) and the one where the previous image matches the main character's current image is used for the animation of the speech. @endnode @node "ST_HANDLE_MAP" "HANDLE_MAP" @next "ST_OBJECT" @prev "ST_TALK_MAP" @{fg shine}@{bg fill}HANDLE_MAP Statement (main)@{fg text}@{bg back} @{i}Defines the animation sequences used when main character manipulates objects@{ui}" link "GG_Animation" 0} used when main character manipulates objects @{b} HANDLE_MAP: previous image;anim seq low;anim seq mid;anim seq high@{ub} When a HANDLE command is encountered, GRAAL checks which image is currently being used for the main character, and the "handle position" for the object being manipulated. The proper animation sequence foom the HANDLE_MAP statement matching the current main character image is then used. Note that the animation sequences only show the main character reaching out for something, and that the last image in each sequence should be specified as lasting for only one frame. @endnode @node "ST_OBJECT" "OBJECT" @next "ST_DLG" @prev "ST_HANDLE_MAP" @{fg shine}@{bg fill}OBJECT Statement (main)@{fg text}@{bg back} @{fg shine}@{bg fill}SECTIONOBJ Statement (section)@{fg text}@{bg back} @{fg shine}@{bg fill}ROOMOBJ Statement (room)@{fg text}@{bg back} @{i}Defines an object@{ui} @{b}OBJECT: number;name;start location;VIS|NVIS;default image;bob; x pos;y pos;character x offset;character y offset; character still image;preposition;pickable;animation channel; default command;icon image;handle position;types; word 1;word 2;word 3 SECTIONOBJ: ...ditto... ROOMOBJ: ...ditto...@{ub} same syntax for all three... Note that all parameters should be on the same line in the GRAAL file - a bit difficult to show in ordinary guide format here, though. Anyway, you really should use GRAALs own object editor to be able to edit the parameters in a more user-friendly format. (See the editor documentation for this one.) Yes, this is the most complex statement there is, but let's run through it one parameter at a time: @{b}number@{ub} For global objects specified by the OBJECT statement, the object is later referred to by this very number. Objects defined by SECTIONOBJ will be referred to as ROBJn, where n is the number. Objects defined by ROOMOBJ will be referred to as ROBJn, where n is the number. @{b}name@{ub} The object name shown when the cursor hits the object, and in the inventory. A backslash in the name will cause a line break in that position when it is displayed in the scene area. The @{"NAME" link "GG_NAME" 0} command can alter this at any time. @{b}start location@{ub} The room number where the object is initially positioned. 0 is used for objects that are "nowhere". @{b}VIS|NVIS@{ub} VIS if the object is visible, NVIS if it is hidden. @{"SHOW" link "GG_SHOW" 0} and @{"HIDE" link "GG_HIDE" 0} commands can alter this as you wish later on. @{b}default image@{ub} image number, animation string or pattern definition initially used for the object @{b}bob@{ub} the bob number to use for this object. two objects (including characters and static and animated objects) cannot use the same bob number at the same time. @{b}x pos;y pos@{ub} The object's position on the screen. @{b}character x offset;character y offset@{ub} The main character's position relative to the object when manipulating it, looking at it, or plain walking up to it (with the @{"MOBJ" link "GG_MOBJ" 0} command). @{b}character still image@{ub} The image used for the main character after having walked up to the object. @{b}preposition@{ub} A preposition indicates that the object can not be used on its own, but must be combined with a second object. @{b}PICK|NPICK@{ub} PICK means the object can be picked up and added to the inventory. (NPICK for churches, planet systems and other things hard to carry around.) @{b}animation channel@{ub} The animation channel used for the object. (Only if the object is animated, of course.) Make sure two animated objects in the same room don't try to use the same channel! @{b}default command@{ub} This is the command directly executed if the player points to an object in the scene area and clicks the right mouse button@{b} icon image@{ub} If the inventory is displayed as icons, this is the image number used for the inventory display. Can be a global, room or section bob image - naturally, the image must be available at all times when there is a chance of the oject being in the inventory! @{b}handle position@{ub} Decides whether the object is manipulated using the LOW, MID or HIGH animation (@{"HANDLE" link "GG_HANDLE" 0} command). @{b}types@{ub} A character string, where each character specifies some property for the object. The following are suggested, but using @{"IFTYPE" link "GG_IFTYPE" 0}, you can use this feature for almost anything you like! M = Male character F = Female character A = Animal G = Group V = Alive D = Dead C = Container W = Wood T = Metal S = Stone L = Liquid E = Food ... and so on ... @{b}word 1;word 2;word 3@{ub} When you construct sentences referring to an object, sometimes you would like to use the proper article or other word connected to the object. These parameters give you a chance to specify such words, which can the be put into your @{"sentences" link "GG_Vars" 0}. These can also be altered with the @{"NAME" link "GG_NAME" 0} command during the game. @endnode @node "ST_DLG" "DLG" @next "ST_ACTION" @prev "ST_OBJECT" @{fg shine}@{bg fill}DLG Statement (main)@{fg text}@{bg back} @{i}Defines the dialogue partners.@{ui} @{b} DLG: number;object;speech colour;speech offset;speech animation sequence@{ub} For each dialogue that occurs in the game, a DLG statement must be present. @{b}number@{ub} Dialogue number. Must be unique. Should start from 1 and proceed upwards with as few gaps in the numbering sequence as possible - just like in room and section numbering, any unused numbers take up memory space! @{b}object@{ub} The dialogue "partner" is defined by this object. All such partners must be global objects defined in the graal.main file. @{b}speech colour@{ub} The colour used for the partner's speech @{b}speech offset@{ub} This number determines where the partner's speech is printed. lower numbers=higher above the partner's head. @{b}speech animation sequence@{ub} The animation sequence used with the @{"RESP" link "GG_RESP" 0} command @endnode @node "ST_ACTION" "ACTION" @next "ST_DACT" @prev "ST_DLG" @{fg shine}@{bg fill}ACTION Statement (main, section, room)@{fg text}@{bg back} @{i}Contains conditions and commands checked when player inputs a sentence.@{ui} @{b} ACTION: verb;condition|statement;...;condition|statement@{ub} When the player inputs a sentence, the ACTION: statements are checked for the currently used script files, in this order: room file, top to bottom section file, top to bottom graal.main file, top to bottom When an ACTION statement with the proper verb number is found, its parameters - the conditions and commands - are checked and executed from left to right. As soon as a condition is FALSE, the rest of that ACTION statement is skipped, and GRAAL looks at the next one. (There is a special verb number, -1, for "timer events" - see the @{"DOAFTER" link "GG_DOAFTER" 0} command.) The search for further ACTION statements is stopped as soon as a valid @{"EXIT" link "GG_EXIT" 0} command has been found. If a @{"REDO" link "GG_REDO" 0} statement is encountered, the process is restarted from the first ACTION statement in the file currently being processed. @endnode @node "ST_DACT" "DACT" @next "ST_UPDATE" @prev "ST_ACTION" @{fg shine}@{bg fill}DACT Statement (section, room)@{fg text}@{bg back} @{i}Immediate actions upon entering section / room@{ui} @{b}DACT: condition|command;...;condition|command@{ub} Immediately after a room script has been loaded, all DACT statements in the script are scanned for commands that should be executed before control is returned to the player. As soon as an EXIT command is found, any remaining DACT:s in the script are ignored. DACT:s in sections are executed immediately before the room DACT:s for every room belonging to that section. Note that an EXIT command in a section DACT only skips the rest of the section DACT:s - then the execution of the room DACT:s begins. The structure and function of DACT statements are the same as for @{"ACTION:" link "ST_ACTION" 0} statements, except there is no verb number as first parameter here. @endnode @node "ST_UPDATE" "UPDATE" @next "ST_SECTION" @prev "ST_DACT" @{fg shine}@{bg fill}UPDATE Statement (room)@{fg text}@{bg back} @{i}Set screen update rate@{ui} @{b} UPDATE: scroll_rate[;normal_rate]@{ub} When there is a lot of graphics being updated simultaneously, the animation(s) may become jerky. This is because all elements can't be updated within 1/50th of a second - the time gap available before GRAAL normally refreshes the screen. The problem is most noticeable during background scrolls, because of the added amount of graphics moving about. To make the animations smoother, we sometimes need to slow down the updating rate and update the screen perhaps every 2/50ths or 3/50ths, allowing GRAAL more time to do its graphics work. The UPDATE: statement allows you to set specific rates for each room, optimising the performance, and also to provide different values depending on whether the background is currently scrolling or not. Default values are 6 for background scrolling and 1 for "normal" displays. @endnode @node "ST_SECTION" "SECTION" @next "ST_BG_IFF" @prev "ST_UPDATE" @{fg shine}@{bg fill}SECTION Statement (room)@{fg text}@{bg back} @{i}Defines to which section this room belongs@{ui} @{b} SECTION: n@{ub} When you enter a new room and the section number is not the same as the one for the previous room, the approprita section file (n.section) is loaded and its contents executed. @endnode @node "ST_BG_IFF" "BG_IFF" @next "ST_START_POS" @prev "ST_SECTION" @{fg shine}@{bg fill}BG_IFF Statement (room)@{fg text}@{bg back} @{i}Name of background graphics file@{ui} @{b} BG_IFF: filename@{ub} This statement loads the gackground graphics for the room. The backdrop should be 120 pixels high, and at least 320 pixels wide. @endnode @node "ST_START_POS" "START_POS" @next "ST_FLOOR" @prev "ST_BG_IFF" @{fg shine}@{bg fill}START_POS Statement (room)@{fg text}@{bg back} @{i}Sets possible starting positions@{ui} @{b}START_POS: number;image;x;y;L|R|M;floor@{ub} @{b}number@{ub} Number of entrance for this room, should range from 1 and upwards. @{b}image@{ub} The image used for the main character when placed in the starting position. @{b}x;y@{ub} Position of the main character @{b}L|R|M@{ub} Decides whether the Left, Right, or Middle of the backdrop is initially shown. @{b}floor@{ub} A floor containing the x;y point. If this is not properly set, the main character may do a strange walkabout the frist time he is commanded to move somewhere else... @endnode @node "ST_FLOOR" "FLOOR" @next "ST_EXIT" @prev "ST_START_POS" @{fg shine}@{bg fill}FLOOR Statement (room)@{fg text}@{bg back} @{i}Defines the "path" where the main character can walk and how they are connected@{ui} @{b}FLOOR: number;x1;y1;x2;y2;floormap/.../floormap@{ub} Each floor defines a rectangular area where the main character can "place its feet". Up to 12 such rectangles can be defined in a room, and they should be connected in such a way that no floor becomes an "island" without sharing any space with any other floor. In fact, floors shoull overlap as much as possible in order for the character to be able to move about. OVERLAPPING OF FLOORS There are some vital rules for floor overlapping. Two floors may have one or two intersection points, but not four. In the following diagrams, X marks the intersection points: +------+ +--------+ +--------+ | 1 | | 1 | | 1 | | | | | | | +------X----------+ +-----X--------X--+ +--------X----+ | | | | | | | | | | | | | | 2 | | 2 | | | | 2 +----X---+ | | | | | | | | | +------+----------+ +-----+--------+--+ +-------------+ are all OK, but the following is ILLEGAL: +------+ | 1 | +----X------X-----+ | 2 | | | +----X------X-----+ | | +------+ WALKING AROUND The floormap parameters decide which floors the main character uses to move from one spot to another. For each floor defined, there must be as many floormaps defined as there are floors in the room. Each floormap has the following format: @{b} finishfloor-nextfloor@{ub} and answers the question: "If my final destination is @{b}finishfloor@{ub}, which floor should I go to from where I currently am?" Example: For floor 2, there is a floormap @{b}3-4@{ub} This floormap says that to go to floor 3 from floor 2, you should go via floor 4. Through logic follows that for each floor defined, there is always a floormap for that floor pointing to itself. For example, one of the floormaps for floor one is always @{b}1-1@{ub} because, if you want to get to floor 1, and you already are there, you should not go anywhere else to get there. That's logic! If there is more than one floormap, they are separated by a slash ( / ). PATHS From GRAAL 2, there is a way of navigating between floors that do not require the floors to overlap: A path can be defined between them using the @{"PATH:" link "ST_PATH" 0} statement. Paths can also twist and turn a number of times, which may come in handy in its own right. To use a path in a floormap, prefix the (path) number with a "P". Click PATH: above for a more complete description. @endnode @node "ST_PATH" " PATH " @{fg shine}@{bg fill}PATH Statement (room)@{fg text}@{bg back} @{i}defines a path to walk between two floors@{ui} @{b} PATH: path number;firstfloor;secondfloor;x1;y1;x2;y2[{;xn;yn;}]@{ub} @{b}firstfloor@{ub} The number of the floor containing the first co-ordinate of the path. @{b}secondfloor@{ub} The number of the floor containing the last co-ordinate of the path. @{b}x1;y1;...@{ub} Co-ordinates specifying points along the path. This is an alternative way to move between two floors. If two floors do not overlap, a path can be defined between them: +--------------+ | | | D | |/ | Path 1 / | B-------------C | / | | Floor 1 / +--------------+ +--------/---+ Floor 2 | / | | A | | | +------------+ As shown in the diagram, a path can alter direction a number of times. This path has a starting point (A), two "knees" (B and C), and an ending point (D). Up to six point may be defined. Two is the natural minimum. Example: PATH: 1;2;4;120;40;160;30;230;60 Path 1 goes between floors 2 and 4. The starting point is 120;40 (within floor 2), it turns at 160;30 and ends at 230;60 (within floor 4). These are the rules: * A path must start inside one floor and end inside another. * A when a path should be used, it is specified in a floormap (se the FLOOR: statement) prefixed by a "P". For example, the floormap 3-P2 means "if the destination floor is 3, now use path 2" * Paths cannot be changed by commands, and if the floor settings are changed by the SETFLOOR command, the starting and ending points of all paths must still remain within the original floors. (Just a longwinded way to say "avoid using paths in rooms where you use SETFLOOR a lot...) * When the player clicks a position on the screen, GRAAL tries to calculate the closest point to which the character can walk. This does NOT include points along the paths, but only the nearest point within a floor. For example, is the player clicks point B in the diagram above, the character will actually only move to the point in floor 1 directly below and closest to it. If the player clicks point C, GRAAL thinks "Aha, you want to go to floor 2, and moves the character to the paths ending point (D), then to the point within that floor that is closest to point C. @endnode @node "ST_EXIT" "EXIT" @next "ST_STATIC" @prev "ST_FLOOR" @{fg shine}@{bg fill}EXIT Statement (room)@{fg text}@{bg back} @{i}Defines an exit from the room@{ui} @{b} EXIT: exitno;x1;y1;x2;y2;ex;ey;description@{ub} Up to 10 exits may be defined in each room. @{b}exitno@{ub} is from 1 to 10 and must be unique within the room. @{b}x1;y1;x2;y2@{ub} Defines an area which the player can click to exit. x1;y1 = upper left corner, x2;y2 = lower right corner. @{b}ex;ey@{ub} The co-ordinate the main character will walk to when exiting. @{b}description@{ub} Name of exit displayed in the scene area when the cursor moves over it. When the exit is clicked, GRAAL will execute any room ACTION statements that begin ACTION: 0;IFOBJ exitno;... This should usually be followed by @{"MEXIT" link "GG_MEXIT" 0} and @{"GOTO" link "GG_GOTO" 0} commands, if all you want to do is a straightforward, uncomplicated switch to the next room. However, you may do anything you like in these ACTION statements that you can do when taking care of "normal" player input. Just remember, the @{"VERB" link "GG_Syntax" 0} is 0, and @{"OBJ1" link "GG_Syntax" 0} is the exit number. @endnode @node "ST_STATIC" "STATIC" @next "ST_ANIM" @prev "ST_EXIT" @{fg shine}@{bg fill}STATIC Statement (room)@{fg text}@{bg back} @{i}Display a static image that is not an object@{ui} @{b} STATIC: bob number;image number;x;y@{ub} This statement is particularly useful to insert foreground objects into a scene, which you never want to manipulate in any way. As always, make sure the bob number used isn't used for any other image displayed in this room. See also: @{"ANIM" link "ST_ANIM" 0} @endnode @node "ST_ANIM" "ANIM" @next "ST_ANIM" @prev "ST_STATIC" @{fg shine}@{bg fill}ANIM Statement (room)@{fg text}@{bg back} @{i}Display an animated image that is not an object@{ui} @{b}ANIM: bob number;image number;anim channel;@{"anim sequence" link "GG_Animation" 0};x;y @{ub}This statement is particularly useful for animated foreground images that you do not wish to manipulate in any way in the game. See also: @{"STATIC" link "ST_ANIM" 0} @endnode @node "ST_LINE" "LINE" @next "ST_LACT" @prev "ST_ANIM" @{fg shine}@{bg fill}LINE Statement (section, room)@{fg text}@{bg back} @{i}Define a dialogue alternative@{ui} @{b}LINE: dialogue;line number;sentence;alternative;condition;...;condition@{ub} Each LINE statement defines a sentence to be shown in the dialogue control area during a dialogue. It is the @{"DSET" link "GG_DSET" 0} command that decides which alternatives actually appears at a certain time. See the bottom of this text for special notes on use in .section files. @{b}dialogue@{ub} Dialogue number (defined by the DSET statement in graal.main). @{b}line number@{ub} A number from 1-30, must be unique within the dialogue @{b}sentence@{ub} The sentence the main character will "speak" the first time this line is used. @{b}alternative@{ub} The sentence the main character will "speak" if the line has been used before. This enables you to rephrase alternatives in a way that is more natural than having to repeat the first-time line. For example, in the sentence is Who are you? and you would like to repeat that further on, the alternative should be something like Who did you say you are? because repeating the first version would seem rather stupid. @{b}condition;...;condition@{ub} There are two factors deciding whether a line appears in the dialogue control area or not. The first one is that a DSET command must have given it permission to appear. The second one is that all conditions specified here must be fulfilled. About section dialogues: As of GRAAL 2, dialogues may be common to an entire section of the game. Needless to say, this takes some care in the planning stage: Just keep in mind that everywhere the dialogue can be invoked, the objects, characters and room flags needed to carry out all possible LACT:s are in place. For example, it is wise to make specific references to room flags (IFRF room,flag=value) rather than test for "current room", because the room may change from call to call. At any time, the number of active dialogues loaded from the .room and .section scripts must not exceed the number of dialogues set in the N_DIALOGUES statement (default=6). For example, if there are two dialogues in use by the section, no room belonging to that section must load more than N_DIALOGUES-2 dialogues. @endnode @node "ST_LACT" "LACT" @next "ST_LACT" @prev "ST_LINE" @{fg shine}@{bg fill}LACT Statement (section, room)@{fg text}@{bg back} @{i}Contains actions in response to a certain dialogue alternative@{ui} @{b}LACT: dialogue;line;actions...@{ub} @{i}Important note:@{ui} All LACT: statements for a certain dialogue line must be placed immediately below that precise DLG: statement in the script file. The @{"LINE:" link "ST_LINE" 0} statement description holds some information about using dialogues in section files. @{b}dialogue@{ub} This is the number of the dialogue. @{b}line@{ub} This is the number of the line the player selected. @{b}actions@{ub} These are any ordinary GRAAL conditions and commands. LACT statements often end with a DSET;EXIT combination to refresh the dialogue status, or an EDLG;EXIT combination to end the dialogue and return to normal input mode. See also: @{"LINE" link "ST_LINE" 0} and @{"DLG" link "ST_DLG" 0} statements, and @{"DSET" link "GG_DSET" 0} and @{"EDLG" link "GG_EDLG" 0} commands. @endnode @node "Troubleshooting" " Trouble-shooting " TROUBLE-SHOOTING An ad-hoc creation like GRAAL is bound to have some niggles, many of which I am probably not aware - because I invented the whole thing to suit my needs and no-one else's. However, there are some common mistakes easily made, which will get you into trouble. Here's how to deal with some of them: @{"My command statement doesn't " link "T_statements" 0} @{"My pictures awful crash system " link "T_graphics" 0} @{"GRAAL ignores rooms " link "T_rooms" 0} @{">>Illegal function call>> abort " link "T_Illegalfunc" 0} @{"Mouse cursor register visible object " link "T_grabbingobjects" 0} @{"My exits screen " link "T_showexits" 0} @{"GRAAL 'looses' number " link "T_Exitnumber" 0} @endnode @node "T_statements" "My command / statement doesn't work " @{i}Trouble-shooting: @{ui} MY COMMAND / STATEMENT DOESN'T WORK You have probably got the number of parameters and / or delimiters wrong. In most cases, GRAAL should detect this - in other cases, it doesn't. Check the syntax with the example files and this reference, and above all, use the syntax checker in the GRAAL editor! Pay particular attention to the delimiters used: Be extra careful with those statements and commands where the last parameter in itself may contain a number of other conditions or commands, like the LINE and FLOOR statements. @endnode @node "T_graphics" "My iff pictures look awful / crash the system " @{i}Trouble-shooting@{ui} MY GRAPHICS CAUSE TROUBLE A lot of the trouble that may arise is caused by the graphics capabilities of Amos Pro. Remember that only ECS graphics can be used, and not AGA modes. If you use DPAINT as a paint package, you MUST make sure that stencils and fixed background modes are turned OFF before saving the graphics - otherwise, horrible things will occur when Amos encounter that information in the graphics file. If you use a paint package with AGA capabilities, also remember that there are more and subtler colour shades available: The colours in the picture, and especially gradients, may look different when loaded into GRAAL. In DPAINT IV (at least), there is a SCALE button in the palette requester that scales all colours to "GRAAL-compatible" shades directly, so you may see what the picture will actually look like. Keeping the palette colours in order is pretty much up to you - just remember, * colour 0 is always transparent * colour 1 should be white * colour 2 should be black @endnode @node "T_rooms" "GRAAL ignores my rooms " @{i}Trouble-shooting:@{ui} GRAAL IGNORES MY ROOMS No wonder - you have probably forgot to up the @{"MAX_ROOMS" link "ST_MAX_ROOM" 0} statement parameter in the graal.main file! @endnode @node "T_Illegalfunc" "" @{i}Trouble-shooting:@{ui} Illegal Function Calls Whenever GRAAL stops dead and throws up one of these messages, it means you have managed to do something my own error trapping in GRAAL hasn't been able to detect (or have run into a true bug in GRAAL itself). Some of these errors will (hopefully) be trapped within GRAAL in coming releases. In the meantime, these are some possible errors: * You tried to @{"GOTO" link "GG_GOTO" 0} or @{"EXIT" link "ST_EXIT" 0} to a room that has no .room file. * A @{"RESP" link "GG_RESP" 0} command pointed to a character that is actually not displayed on screen - most likely, you got the dialogue number wrong in the command. Alternatively, the @{"OBJECT" link "ST_OBJECT" 0} defining the character hasn't been made visible or was placed in the wrong room in the OBJECT statement. * Check that all objects / graphics that you have ordered to be present in the scene have actually been loaded into the BOB image bank first using @{"CLPART" link "ST_CLPART" 0}, @{"BOBS" link "GG_BOBS" 0}, @{"ROOMBOBS" link "ST_BOBS" 0}, etc. Also, accidentally grabbing an area of a clipart file that consists only of the background colour as a BOB image, and then trying to display that, may cause problems. I think. Anyway, why should you? * A text string longer than fits onto the screen, and without any spaces or backslash ( \ ) characters was encountered, rendering GRAAL unable to perform automatic line breaks. * You tried to use a room flag number higher than 20 or an object flag number higher than 6. @endnode @node "T_grabbingobjects" "Mouse cursor does not register visible object " @{i}Trouble-shooting@{ui} @{b}Although an object is visible on screen, the mouse cursor does not pick it up.@{ub} This is due to the fact that if more than one object occupies the space where the mouse cursor is, GRAAL only picks up the one that was first added to the list of objects available in the room. Use the @{"OBJONTOP" link "GG_OBJONTOP" 0} command to remedy the problem if and when it occurs. @endnode @node "T_showexits" "My exits do not appear" @{i}Trouble-shooting@{ui} @{b}My exits do not show up on screen@{ub} 1. You have not provided an exit name in the EXIT: statement. This means no "Go to..." message is shown in the sentence box, and no name is shown above the cursor in the scene area. However, this can also be put to good use, because it allows you to use exits for defining any kind of clickable area other than true exits and objects, for use as menu selections and what have 2. An exit is not detected by GRAAL if it is covered by an object. The remedy is often to make the graphics that are to be shown when the exit is available the backdrop picture. A common example would be a door opening. The only time the exit is available is when the door is open. Therefore, the open doorway should be the backdrop picture, the closed door should be an object or a BOB put over the doorway when the door is closed and the exit is hidden. (Completely hiding an exit with an object this way actually means you do not have do issue the HIDE EXIT command. However, I think it is good coding practice to include it just the same. The code makes a lot more sense that way, showing clearly what is going on in the room.) @endnode @node "T_Exitnumber" "GRAAL " @{i}Trouble-shooting@{ui} @{b}GRAAL looses the exit number@{ub} Before you are finished going thorugh the commands for an EXIT click (ACTION: 0;IFOBJ....), the exit number seems to have changed or disappeared. Remember that the exit number is actually a special use of OBJ1, so any commands put in these ACTION: statements that alter @{"OBJ1" link "GG_OBJ" 0} must put the original back before it is time to check the exit number next time! @endnode @node HeddleyAutoIndex "Index" @remark Index auto-generated by Heddley Index of database 002e4fd0-0 Documents @{"" link "Main"} @{"" link "T_Illegalfunc"} CUTSCENE_LAYOUT " link "ST_CUTSCENELAYOUT"} @{" .room files " link "GG_ST_ROOM"} @{" .section files " link "GG_ST_SECT"} @{" A Very Short Introduction " link "GG_INTRO"} @{" About this Tutorial " link "GG_Reference"} @{" ADDOF " link "GG_ADDOF"} @{" ADDRF " link "GG_ADDRF"} @{" ADDTIME " link "ADDTIME"} @{" ARROW_CURSOR: " link "ST_ARROW_CURSOR"} @{" BOBOFF " link "GG_BOBOFF"} @{" BOBON " link "GG_BOBON"} @{" BOBS " link "GG_BOBS"} @{" CAMERA " link "GG_CAMERA"} @{" CANCEL " link "GG_CANCEL"} @{" CBOB " link "GG_CBOB"} @{" CHAR " link "GG_CHAR"} @{" CLPART " link "GG_CLPART"} @{" CMOVE " link "GG_CMOVE"} @{" COLOUR " link "GG_COLOUR"} @{" CPOS " link "GG_CPOS"} @{" CURSOR_PALETTE: " link "ST_CURSOR_PALETTE"} @{" CUTSCENE " link "GG_CUTSCENE"} @{" DATE_FORMAT " link "ST_DATEFORMAT"} @{" DATE_LAYOUT " link "ST_DATELAYOUT"} @{" DAY_TEXT " link "ST_DAYTEXT"} @{" DECOF " link "GG_DECOF"} @{" DECRF " link "GG_DECRF"} @{" DISABLE_QUIT " link "ST_DISQUIT"} @{" DLG_LAYOUT " link "ST_DLGLAYOUT"} @{" DOAFTER " link "GG_DOAFTER"} @{" DSET " link "GG_DSET"} @{" EDLG " link "GG_EDLG"} @{" EXIT " link "GG_EXIT"} @{" FADE " link "GG_FADE"} @{" FINAL" link "GG_FINAL"} @{" FLOOR " link "GG_FLOOR"} @{" GET " link "GG_GET"} @{" GOTO " link "GG_GOTO"} @{" graal.main file " link "GG_ST_MAIN"} @{" HANDLE " link "GG_HANDLE"} @{" HIDE " link "GG_HIDE"} @{" HIDEEXIT " link "HIDEEXIT"} @{" HOTSP " link "GG_HOTSP"} @{" ICON " link "GG_ICON"} @{" IFCARR / IFNOTCARR " link "GG_IFCARR"} @{" IFCBOB " link "GG_IFCBOB"} @{" IFDATE " link "GG_IFDATE"} @{" IFFLOOR " link "IFFLOOR"} @{" IFOBJ / IFOBJ2 " link "GG_IFOBJ"} @{" IFOF " link "GG_IFOF"} @{" IFPICK " link "GG_IFPICK"} @{" IFRF " link "GG_IFRF"} @{" IFROOM " link "GG_IFROOM"} @{" IFSPOS " link "GG_IFSPOS"} @{" IFTIME " link "GG_IFTIME"} @{" IFTYPE " link "GG_IFTYPE"} @{" IFWEEKDAY " link "GG_WEEKDAY"} @{" INV_UP " link "ST_INVUP_ETC"} @{" LIGHTS " link "GG_LIGHTS"} @{" Limitations, Ranges, Reserved Numbers " link "GG_Limits"} @{" LINE " link "GG_LINE"} @{" LINE_LENGTH " link "ST_linelength"} @{" Machine Requirements " link "GG_Requirements"} @{" MARK " link "GG_MARK"} @{" MEXIT " link "GG_MEXIT"} @{" MOBJ " link "GG_MOBJ"} @{" MODE_SWITCH " link "ST_MODESWITCH"} @{" MONTH_TEXT " link "ST_MONTHTEXT"} @{" NAME " link "GG_NAME"} @{" NEWOBJ " link "GG_NEWOBJ"} @{" News in version 2 " link "News"} @{" NFLOOR " link "GG_NFLOOR"} @{" NOBREAK " link "GG_NOBREAK"} @{" NORMAL_WAIT " link "ST_NORMWAIT"} @{" N_DIALOGUES " link "ST_NDIALOGUES"} @{" N_VERBS " link "ST_NVERBS"} @{" OBJ1 / OBJ2 " link "GG_OBJ"} @{" OBJONTOP " link "GG_OBJONTOP"} @{" OMOVE " link "GG_OMOVE"} @{" PATH " link "ST_PATH"} @{" PBOB " link "GG_PBOB"} @{" PICK " link "GG_PICK"} @{" PREP " link "GG_PREP"} @{" QUIT " link "GG_Quit"} @{" REDO " link "GG_REDO"} @{" REMOVE " link "GG_REMOVE"} @{" RESP " link "GG_RESP"} @{" RESTORETIME " link "GG_RESTORETIME"} @{" RESUME " link "GG_RESUME"} @{" ROOM " link "GG_ROOM"} @{" SAMLOAD " link "GG_SAMLOAD"} @{" SAMPLAY " link "GG_SAMPLAY"} @{" SAVETIME " link "GG_SAVETIME"} @{" SAY " link "GG_SAY"} @{" SENTENCE_LAYOUT " link "ST_SENTLAYOUT"} @{" SETDATE " link "GG_SETDATE"} @{" SETFLOOR " link "GG_SETFLOOR"} @{" SETOF " link "GG_SETOF"} @{" SETRF " link "GG_SETRF"} @{" SETTIME " link "GG_SETTIME"} @{" SHOW " link "GG_SHOW"} @{" SHOWEXIT " link "SHOWEXIT"} @{" SPLIT_LINE " link "ST_AREASIZES"} @{" Syntax Conventions " link "GG_Syntax"} @{" SYSTEM_TEXT " link "ST_SYSTEMTEXT"} @{" TEXT " link "GG_TEXT"} @{" The GRAAL player interface" link "GG_Interface"} @{" The Structure of a GRAAL Game " link "GG_STRUCTURE"} @{" THINK " link "GG_THINK"} @{" TIME_FORMAT " link "ST_TIMEFORMAT"} @{" TIME_LAYOUT " link "ST_TIMELAYOUT"} @{" TITLE " link "GG_TITLE"} @{" TRACK " link "GG_TRACK"} @{" Trouble-shooting " link "Troubleshooting"} @{" TYPE " link "GG_TYPE"} @{" Variables in Text Strings " link "GG_Vars"} @{" VERB " link "GG_VERB"} @{" VERB_TEXT " link "ST_VERBTEXT"} @{" VERB_ZONE " link "ST_VERBZONE"} @{" W(ait) " link "GG_WAIT"} @{" WALK_BUTTON " link "ST_WALKBUTTON"} @{"ACTION" link "ST_ACTION"} @{"ANIM" link "ST_ANIM"} @{"animation sequences" link "GG_Animation"} @{"BG_IFF" link "ST_BG_IFF"} @{"BOBS" link "ST_BOBS"} @{"CHARACTER_BOB" link "ST_CHARACTER_BOB"} @{"CHARACTER_COL" link "ST_CHARACTER_COL"} @{"CHARACTER_HEIGHT" link "ST_CHARSIZE"} @{"CLPART" link "ST_CLPART"} @{"COMMAND_AREA" link "ST_AREAFILES"} @{"DACT" link "ST_DACT"} @{"DLG" link "ST_DLG"} @{"EXIT" link "ST_EXIT"} @{"EXIT_COL" link "ST_EXIT_COL"} @{"FLOOR" link "ST_FLOOR"} @{"GLOBALBOBS" link "ST_NBOBS"} @{"GLOBALOBJS" link "ST_OBJS"} @{"GRAAL " link "T_Exitnumber"} @{"GRAAL Commands" link "GG_Commands"} @{"GRAAL Conditions" link "GG_Conditions"} @{"GRAAL ignores my rooms " link "T_rooms"} @{"HANDLE_MAP" link "ST_HANDLE_MAP"} @{"INV_LAYOUT" link "ST_INVLAYOUT"} @{"LACT" link "ST_LACT"} @{"LINE" link "ST_LINE"} @{"MAX_CACHE" link "ST_MAXCACHE"} @{"MAX_DACT" link "ST_MAX_DACT"} @{"MAX_ROOM" link "ST_MAX_ROOM"} @{"MAX_SECTION" link "ST_MAX_SECTION"} @{"Mouse cursor does not register visible object " link "T_grabbingobjects"} @{"MSGFONT" link "ST_XXXFONT"} @{"My command / statement doesn't work " link "T_statements"} @{"My exits do not appear" link "T_showexits"} @{"My iff pictures look awful / crash the system " link "T_graphics"} @{"NAME" link "ST_NAME"} @{"OBJECT" link "ST_OBJECT"} @{"OBJ_COL" link "ST_OBJ_COL"} @{"PAUSE_RIGHT" link "ST_PAUSE"} @{"RESOURCE" link "ST_RESOURCE"} @{"SECTION" link "ST_SECTION"} @{"START_POS" link "ST_START_POS"} @{"START_ROOM" link "ST_START_ROOM"} @{"STATIC" link "ST_STATIC"} @{"STILL_RIGHT" link "ST_STILL"} @{"TALK_MAP" link "ST_TALK_MAP"} @{"UPDATE" link "ST_UPDATE"} @{"VERSION" link "ST_VERSON"} @{"WALK_RIGHT" link "ST_WALK"} @{"WALK_SPEED" link "ST_WALK_SPEED"} Buttons Short Introduction " link "GG_INTRO" 0} About Reference " link "GG_Reference" 0} ACTION " link "ST_ACTION" 0} ADDOF " link "GG_ADDOF" 0} ADDRF " link "GG_ADDRF" 0} ADDTIME " link "ADDTIME" 0} " link "ST_ANIM" 0} AREA_SIZES " link "ST_AREASIZES" 0} ARROW_CURSOR " link "ST_ARROW_CURSOR" 0} BG_IFF " link "ST_BG_IFF" 0} BOBOFF " link "GG_BOBOFF" 0} BOBON " link "GG_BOBON" 0} " link "ST_BOBS" 0} " link "GG_BOBS" 0} CAMERA " link "GG_CAMERA" 0} CANCEL " link "GG_CANCEL" 0} " link "GG_CBOB" 0} " link "GG_CHAR" 0} CHARACTER_BOB " link "ST_CHARACTER_BOB" 0} CHARACTER_COL " link "ST_CHARACTER_COL" 0} CHARACTER_HEIGHT " link "ST_CHARSIZE" 0} CHARACTER_WIDTH " link "ST_CHARSIZE" 0} CLPART " link "ST_CLPART" 0} CLPART " link "GG_CLPART" 0} CLPART " link "GG_CLPART" 0} CMOVE " link "GG_CMOVE" 0} COLOUR " link "GG_COLOUR" 0} COMFONT " link "ST_XXXFONT" 0} Commands " link "GG_Commands" 0} COMMAND_AREA " link "ST_AREAFILES" 0} Conditions " link "GG_Conditions" 0} " link "GG_CPOS" 0} CROSSHAIR_CURSOR " link "ST_ARROW_CURSOR" 0} CURSOR_PALETTE " link "ST_CURSOR_PALETTE" 0} CUTSCENE " link "GG_CUTSCENE" 0} CUTSCENE_LAYOUT " link "ST_CUTSCENELAYOUT" 0} " link "ST_DACT" 0} DATE_FORMAT " link "ST_DATEFORMAT" 0} DATE_LAYOUT " link "ST_DATELAYOUT" 0} DAY_TEXT " link "ST_DAYTEXT" 0} DECOF " link "GG_DECOF" 0} DECRF " link "GG_DECRF" 0} DISABLE_QUIT " link "ST_DISQUIT" 0} " link "ST_DLG" 0} DLG_AREA " link "ST_AREAFILES" 0} DLG_DOWN " link "ST_INVUP_ETC" 0} DLG_LAYOUT " link "ST_DLGLAYOUT" 0} DLG_UP " link "ST_INVUP_ETC" 0} DOAFTER " link "GG_DOAFTER" 0} " link "GG_DSET" 0} " link "GG_EDLG" 0} " link "ST_EXIT" 0} " link "GG_EXIT" 0} EXIT_COL " link "ST_EXIT_COL" 0} " link "GG_FADE" 0} FINAL " link "GG_FINAL" 0} FLOOR " link "ST_FLOOR" 0} FLOOR " link "GG_FLOOR" 0} " link "GG_GET" 0} GLOBALBOBS " link "ST_NBOBS" 0} GLOBALOBJS " link "ST_OBJS" 0} " link "GG_GOTO" 0} HANDLE " link "GG_HANDLE" 0} HANDLE_MAP " link "ST_HANDLE_MAP" 0} " link "GG_HIDE" 0} HIDEEXIT " link "HIDEEXIT" 0} HOTSP " link "GG_HOTSP" 0} " link "GG_ICON" 0} IFCARR IFNOTCARR " link "GG_IFCARR" 0} IFCBOB " link "GG_CBOB" 0} IFDATE " link "GG_IFDATE" 0} IFFLOOR " link "IFFLOOR" 0} IFOBJ IFOBJ2 " link "GG_IFOBJ" 0} IFOF2 " link "GG_IFOF" 0} IFPICK " link "GG_IFPICK" 0} " link "GG_IFRF" 0} IFROOM " link "GG_IFROOM" 0} IFSPOS " link "GG_IFSPOS" 0} IFTIME " link "GG_IFTIME" 0} IFTYPE " link "GG_IFTYPE" 0} IFWEEKDAY " link "GG_WEEKDAY" 0} INV_DOWN " link "ST_INVUP_ETC" 0} INV_LAYOUT " link "ST_INVLAYOUT" 0} INV_UP " link "ST_INVUP_ETC" 0} " link "ST_LACT" 0} LIGHTS " link "GG_LIGHTS" 0} Limitations, Ranges, Reserved Numbers " link "GG_Limits" 0} " link "ST_LINE" 0} " link "GG_LINE" 0} LINE_LENGTH " link "ST_linelength" 0} Machine Requirements " link "GG_Requirements" 0} " link "GG_MARK" 0} MAX_CACHE " link "ST_MAXCACHE" 0} MAX_DACT " link "ST_MAX_DACT" 0} MAX_ROOM " link "ST_MAX_ROOM" 0} MAX_SECTION " link "ST_MAX_SECTION" 0} MEXIT " link "GG_MEXIT" 0} " link "GG_MOBJ" 0} MODE_SWITCH " link "ST_MODESWITCH" 0} MONTH_TEXT " link "ST_MONTHTEXT" 0} MSGFONT " link "ST_XXXFONT" 0} " link "ST_NAME" 0} " link "GG_NAME" 0} NEWOBJ " link "GG_NEWOBJ" 0} version " link "News" 0} NFLOOR " link "GG_NFLOOR" 0} NOBREAK " link "GG_NOBREAK" 0} NORMAL_WAIT " link "ST_NORMWAIT" 0} N_DIALOGUES " link "ST_NDIALOGUES" 0} N_VERBS " link "ST_NVERBS" 0} " link "GG_OBJ" 0} OBJECT " link "ST_OBJECT" 0} OBJONTOP " link "GG_OBJONTOP" 0} OBJ_COL " link "ST_OBJ_COL" 0} OMOVE " link "GG_OMOVE" 0} " link "ST_PATH" 0} PAUSE_BACK " link "ST_PAUSE" 0} PAUSE_FRONT " link "ST_PAUSE" 0} PAUSE_LEFT " link "ST_PAUSE" 0} PAUSE_RIGHT " link "ST_PAUSE" 0} " link "GG_PBOB" 0} " link "GG_PICK" 0} " link "GG_PREP" 0} " link "GG_Quit" 0} " link "GG_REDO" 0} REMOVE " link "GG_REMOVE" 0} RESOURCE " link "ST_RESOURCE" 0} " link "GG_RESP" 0} RESTORETIME " link "GG_RESTORETIME" 0} RESUME " link "GG_RESUME" 0} ROOMBOBS " link "ST_NBOBS" 0} ROOMBOBS " link "ST_BOBS" 0} ROOMOBJ " link "ST_OBJECT" 0} ROOMOBJS " link "ST_OBJS" 0} " link "GG_SAMPLAY" 0} SAMLOAD " link "GG_SAMLOAD" 0} SAVETIME " link "GG_SAVETIME" 0} " link "GG_SAY" 0} SECTION " link "ST_SECTION" 0} SECTIONBOBS " link "ST_NBOBS" 0} SECTIONBOBS " link "ST_BOBS" 0} SECTIONOBJ " link "ST_OBJECT" 0} SECTIONOBJS " link "ST_OBJS" 0} SENTENCE_LAYOUT " link "ST_SENTLAYOUT" 0} SETDATE " link "GG_SETDATE" 0} SETFLOOR " link "GG_SETFLOOR" 0} SETOF " link "GG_SETOF" 0} SETRF " link "GG_SETRF" 0} SETTIME " link "GG_SETTIME" 0} " link "GG_SHOW" 0} SHOWEXIT " link "SHOWEXIT" 0} Special Characters Strings " link "GG_Vars" 0} START_POS " link "ST_START_POS" 0} START_ROOM " link "ST_START_ROOM" 0} Statements graal.main " link "GG_ST_MAIN" 0} Statements n.room files " link "GG_ST_ROOM" 0} Statements n.section files " link "GG_ST_SECT" 0} STATIC " link "ST_STATIC" 0} STILL_BACK " link "ST_STILL" 0} STILL_FRONT " link "ST_STILL" 0} STILL_LEFT " link "ST_STILL" 0} STILL_RIGHT " link "ST_STILL" 0} Syntax Conventions " link "GG_Syntax" 0} SYSTEM_TEXT " link "ST_SYSTEMTEXT" 0} TALK_MAP " link "ST_TALK_MAP" 0} " link "GG_TEXT" 0} GRAAL player interface " link "GG_Interface" 0} Structure GRAAL " link "GG_STRUCTURE" 0} THINK " link "GG_THINK" 0} TIME_FORMAT " link "ST_TIMEFORMAT" 0} TIME_LAYOUT " link "ST_TIMELAYOUT" 0} TITLE " link "GG_TITLE" 0} TITLEFONT1 " link "ST_XXXFONT" 0} TITLEFONT2 " link "ST_XXXFONT" 0} TRACK " link "GG_TRACK" 0} Trouble-shooting " link "Troubleshooting" 0} " link "GG_TYPE" 0} UPDATE " link "ST_UPDATE" 0} " link "GG_VERB" 0} VERB_TEXT " link "ST_VERBTEXT" 0} VERB_ZONE " link "ST_VERBZONE" 0} VERSION " link "ST_VERSON" 0} W(ait) " link "GG_WAIT" 0} WALK_AWAY " link "ST_WALK" 0} WALK_BUTTON " link "ST_WALKBUTTON" 0} WALK_LEFT " link "ST_WALK" 0} WALK_RIGHT " link "ST_WALK" 0} WALK_SPEED " link "ST_WALK_SPEED" 0} WALK_TOWARD " link "ST_WALK" 0} @{".ptrn" alink "1.ptrn/main" 0} @{".scene" alink "1.scene/1.scene/main" 0} @{"=DEMO=>" alink "graal.main/main" 0} @{"=DEMO=>" alink "1.section/main" 0} @{"=DEMO=>" alink "1.room/main" 0} @{">>Illegal function call>> abort " link "T_Illegalfunc" 0} @{"ACTION" link "ST_ACTION" 0} @{"ACTION:" link "ST_ACTION" 0} @{"ADDOF" link "GG_ADDOF" 0} @{"ADDRF" link "GG_ADDRF" 0} @{"ADDTIME" link "ADDTIME" 0} @{"ANIM" link "ST_ANIM" 0} @{"anim sequence" link "GG_Animation" 0} @{"animation sequence" link "GG_Animation" 0} @{"animation sequences" link "GG_Animation" 0} @{"BOBOFF" link "GG_BOBOFF" 0} @{"BOBON" link "GG_BOBON" 0} @{"BOBS" link "GG_BOBS" 0} @{"BOBS" link "ST_BOBS" 0} @{"BOBS:" link "ST_BOBS" 0} @{"CANCEL" link "GG_CANCEL" 0} @{"CBOB" link "GG_CBOB" 0} @{"CHAR" link "GG_CHAR" 0} @{"CHAR OFF" link "GG_CHAR" 0} @{"CLPART" link "GG_CLPART" 0} @{"CLPART" link "ST_CLPART" 0} @{"CMOVE" link "GG_CMOVE" 0} @{"COLOUR" link "GG_COLOUR" 0} @{"CPOS" link "GG_CPOS" 0} @{"CURSOR_PALETTE" link "ST_CURSOR_PALETTE" 0} @{"DACT" link "ST_DACT" 0} @{"DATE_FORMAT" link "ST_DATEFORMAT" 0} @{"DATE_LAYOUT" link "ST_DATELAYOUT" 0} @{"DAY_TEXT:" link "ST_DAYTEXT" 0} @{"DECOF" link "GG_DECOF" 0} @{"DECRF" link "GG_DECRF" 0} @{"DLG" link "ST_DLG" 0} @{"DLG:" link "ST_DLG" 0} @{"DOAFTER" link "GG_DOAFTER" 0} @{"DSET" link "GG_DSET" 0} @{"EDLG" link "GG_EDLG" 0} @{"EXIT" link "GG_EXIT" 0} @{"EXIT" link "ST_EXIT" 0} @{"EXIT:" link "ST_EXIT" 0} @{"FADE" link "GG_FADE" 0} @{"FLOOR" link "GG_FLOOR" 0} @{"FLOOR:" link "ST_FLOOR" 0} @{"GET" link "GG_GET" 0} @{"GOTO" link "GG_GOTO" 0} @{"GRAAL 'looses' number " link "T_Exitnumber" 0} @{"GRAAL ignores rooms " link "T_rooms" 0} @{"graal.main" link "GG_ST_MAIN" 0} @{"HANDLE" link "GG_HANDLE" 0} @{"HIDE" link "GG_HIDE" 0} @{"HIDEEXIT" link "HIDEEXIT" 0} @{"IFOF" link "GG_IFOF" 0} @{"IFRF" link "GG_IFRF" 0} @{"IFTYPE" link "GG_IFTYPE" 0} @{"LACT" link "ST_LACT" 0} @{"LACT" link "ST_DACT" 0} @{"LIGHTS ON" link "GG_LIGHTS" 0} @{"LINE" link "ST_LINE" 0} @{"LINE:" link "ST_LINE" 0} @{"MARK" link "GG_MARK" 0} @{"MAX_ROOMS" link "ST_MAX_ROOM" 0} @{"MEXIT" link "GG_MEXIT" 0} @{"MOBJ" link "GG_MOBJ" 0} @{"MONTH_TEXT:" link "ST_MONTHTEXT" 0} @{"Mouse cursor register visible object " link "T_grabbingobjects" 0} @{"My command statement doesn't " link "T_statements" 0} @{"My exits screen " link "T_showexits" 0} @{"My pictures awful crash system " link "T_graphics" 0} @{"n.room" link "GG_ST_ROOM" 0} @{"n.section" link "GG_ST_SECT" 0} @{"NAME" link "GG_NAME" 0} @{"NFLOOR" link "GG_NFLOOR" 0} @{"NOBREAK" link "GG_NOBREAK" 0} @{"N_VERBS" link "ST_NVERBS" 0} @{"OBJ1" link "GG_OBJ" 0} @{"OBJ1" link "GG_Syntax" 0} @{"OBJ1/OBJ2" link "GG_OBJ" 0} @{"OBJECT" link "ST_OBJECT" 0} @{"OBJECT" link "ST_OBJS" 0} @{"OBJONTOP" link "GG_OBJONTOP" 0} @{"OMOVE" link "GG_OMOVE" 0} @{"PATH:" link "ST_PATH" 0} @{"PAUSE_..." link "ST_PAUSE" 0} @{"PICK" link "GG_PICK" 0} @{"REDO" link "GG_REDO" 0} @{"REMOVE" link "GG_REMOVE" 0} @{"RESP" link "GG_RESP" 0} @{"RESTORETIME" link "GG_RESTORETIME" 0} @{"RESUME" link "GG_RESUME" 0} @{"ROOMBOBS" link "ST_BOBS" 0} @{"SAM" link "GG_SAMPLAY" 0} @{"SAMLOAD" link "GG_SAMLOAD" 0} @{"SAMPLAY" link "GG_SAMPLAY" 0} @{"SAVETIME" link "GG_SAVETIME" 0} @{"SAY" link "GG_SAY" 0} @{"sentences" link "GG_Vars" 0} @{"SETDATE" link "GG_SETDATE" 0} @{"SETFLOOR" link "GG_SETFLOOR" 0} @{"SETOF" link "GG_SETOF" 0} @{"SETRF" link "GG_SETRF" 0} @{"SETTIME" link "GG_SETTIME" 0} @{"SHOW" link "GG_SHOW" 0} @{"SHOWEXIT" link "SHOWEXIT" 0} @{"special characters" link "GG_Vars" 0} @{"START_POS" link "ST_START_POS" 0} @{"STATIC" link "ST_ANIM" 0} @{"STILL_..." link "ST_STILL" 0} @{"syntax" link "GG_Syntax" 0} @{"THINK" link "GG_THINK" 0} @{"TIME_FORMAT" link "ST_TIMEFORMAT" 0} @{"TIME_LAYOUT" link "ST_TIMELAYOUT" 0} @{"TITLE" link "GG_TITLE" 0} @{"TITLEFONT:" link "ST_XXXFONT" 0} @{"TYPE" link "GG_TYPE" 0} @{"VERB" link "GG_VERB" 0} @{"VERB" link "GG_Syntax" 0} @{"VERB_TEXT:" link "ST_ExitMessage" 0} @{"WALK_..." link "ST_WALK" 0} @endnode