Différences

Ci-dessous, les différences entre deux révisions de la page.

--- agi-game:specifications-resources [2021/05/24 15:11] – [How the interpreter handles the code] frater
+++ agi-game:specifications-resources [2021/05/24 15:30] – [AGI Specifications Resources : Logic resources] frater
@@ Ligne 1: / Ligne 1: @@
-====== Logic resources ======
+====== AGI Specifications Resources : Logic resources ======
-===== Introduction =====
+==== Introduction ====
 At the heart of Sierra's Adventure Game Interpreter is the logic file.
@@ Ligne 287: / Ligne 287: @@
 | FC    | **or**                |
-At present these are the only high value codes encountered. The ''if'' and ''or'' codes are like brackets, i.e. the code will be at the start and the end of the section of codes that it refers to. The following example will illustrate this:
+At present these are the only high value codes encountered. The //if// and //or// codes are like brackets, i.e. the code will be at the start and the end of the section of codes that it refers to. The following example will illustrate this:
 Example: KQ1, Room 2.
@@ Ligne 311: / Ligne 311: @@
 When the interpreter encounters a 0xFF it will then interpret the following code values as being in the condition code range until it encounters the next 0xFF which switches it back into normal AGI command
-mode. The two bytes immediately following the second 0xFF determine how many bytes this ''if'' statement lasts for before the ''if'' is ended.  When the second 0xFF is encountered the interpreter, be it
+mode. The two bytes immediately following the second 0xFF determine how many bytes this //if// statement lasts for before the //if// is ended.  When the second 0xFF is encountered the interpreter, be it
 us or the machine, does three things:
@@ Ligne 331: / Ligne 331: @@
 </code>
-==== The ''else'' command and more on brackets ====
+==== The **else** command and more on brackets ====
-The ''else'' statement will always continue after an ''if'' bracket block. This next feature is important and has caused a number of hassles in the past. When an ''else'' statement follows an ''if'', then the bracket distance given after the ''if'' statement //will be three bytes longer// (this is a consequence of the way the interpreter handles ''if'' and ''else'' codes which is discussed later).
+The **else** statement will always continue after an **if** bracket block. This next feature is important and has caused a number of hassles in the past. When an **else** statement follows an **if**, then the bracket distance given after the **if** statement //will be three bytes longer// (this is a consequence of the way the interpreter handles **if** and **else** codes which is discussed later).
 Here's an example:
@@ Ligne 352: / Ligne 352: @@
 </code>
-Usually you would expect the bracket distance to be 0x0002 but in the above case it is clearly 0x0005 which illustrates the difference between a straight ''if'' statement and an ''if..else'' structure. The situation is the same for nested ''if..else'' structures.
-The ''else'' statements themselves are a lot like ''if'' statements except that they're test condition is given after the 0xFE code but is instead the inverse of the condition given by the above ''if'' statement. Only the bracket distance is given after the 0xFE code and then the AGI command clock that the ''else'' statement encompasses.
+Usually you would expect the bracket distance to be 0x0002 but in the above case it is clearly 0x0005 which illustrates the difference between a straight **if** statement and an **if..else** structure. The situation is the same for nested **if..else** structures.
+The **else** statements themselves are a lot like **if** statements except that they're test condition is given after the 0xFE code but is instead the inverse of the condition given by the above **if** statement. Only the bracket distance is given after the 0xFE code and then the AGI command clock that the **else** statement encompasses.
 ==== Test conditions ====
@@ Ligne 384: / Ligne 385: @@
 ==== Arguments ====
-You may well be asking how the interpreter knows how many arguments each code has and what type of argument each argument is. This information is stored in <tt>agidata.ovl</tt> in the MS-DOS version.
+You may well be asking how the interpreter knows how many arguments each code has and what type of argument each argument is. This information is stored in ''agidata.ovl'' in the MS-DOS version.
 Inside this file there is a table which contains four bytes for each AGI command and condition code. These four bytes are interpreted as follows:
@@ Ligne 436: / Ligne 437: @@
 ==== Implementation ====
-The implementation for each AGI statement is found in the ''agi/'' file. This is the AGI interpreter itself. The data in the ''agidata.ovl'' file is used to find the start of the implementation for an AGI statement. Below are a couple of examples:
+The implementation for each AGI statement is found in the //agi/// file. This is the AGI interpreter itself. The data in the ''agidata.ovl'' file is used to find the start of the implementation for an AGI statement. Below are a couple of examples:
 Example: MH2, equaln.
@@ Ligne 589: / Ligne 590: @@
 //Situation 2.//
-If the code is an 0xFF code, then if jumps to the ''if'' statement handler. In this routine is basically assesses whether the whole test condition evaluates to true or to false. It does this by treating each test separately and calling the relevant test command routines using the jump table in the ''agidata.ovl'' file. Each test command routine will return a value in ''AL'' which says whether it is true or not. Depending on the NOTs and ORs, the whole expression is evaluated. If at any stage during the evaluation the routine decides that the expression will be false, it exits to another routine which skips the rest of the ''if'' statement and then adds the two byte word following the closing 0xFF code to the execution pointer. This usually has the affect of jumping over the ''if'' block of code. If the ''if'' handler gets to the ending 0xFF then it knows the expression is true simply because it hasn't exited out of the routine yet. At this stage it jumps over the two bytes following the closing 0xFF and then goes back to executing straight AGI commands.
+If the code is an 0xFF code, then if jumps to the **if** statement handler. In this routine is basically assesses whether the whole test condition evaluates to true or to false. It does this by treating each test separately and calling the relevant test command routines using the jump table in the ''agidata.ovl'' file. Each test command routine will return a value in //AL// which says whether it is true or not. Depending on the NOTs and ORs, the whole expression is evaluated. If at any stage during the evaluation the routine decides that the expression will be false, it exits to another routine which skips the rest of the **if** statement and then adds the two byte word following the closing 0xFF code to the execution pointer. This usually has the affect of jumping over the **if** block of code. If the **if** handler gets to the ending 0xFF then it knows the expression is true simply because it hasn't exited out of the routine yet. At this stage it jumps over the two bytes following the closing 0xFF and then goes back to executing straight AGI commands.
 //Situation 3.//
-If in the normal execution of AGI commands, the code 0xFE is encountered, a very simple action takes place. The two bytes which follow form a 16-bit twos complement value which is added to execution pointer. This is all it does. Previously we said that the 0xFE code stood for the ''else'' statement which is in actual fact correct for over 90% of the time, but the small number of other occurrences are best described as ''goto'' statements.
+If in the normal execution of AGI commands, the code 0xFE is encountered, a very simple action takes place. The two bytes which follow form a 16-bit twos complement value which is added to execution pointer. This is all it does. Previously we said that the 0xFE code stood for the **else** statement which is in actual fact correct for over 90% of the time, but the small number of other occurrences are best described as **goto** statements.
 If you're confused by this, the following example will probably explain things.
@@ Ligne 619: / Ligne 620: @@
 </code>
-This is exactly how all ''if''s and ''else''s are implemented in the logic code. The ''if'' statement is a conditional branch where the branch is taken if the condition is not met, while the ''else'' statement is a nonconditional jump. If a 0xFE code appears in the middle of some AGI code and wasn't actually originally coded as an ''else'', then it was most likely a ''goto'' statement.
+This is exactly how all **if**s and **else**s are implemented in the logic code. The **if** statement is a conditional branch where the branch is taken if the condition is not met, while the **else** statement is a nonconditional jump. If a 0xFE code appears in the middle of some AGI code and wasn't actually originally coded as an **else**, then it was most likely a **goto** statement.
+==== The **said** test command ====
-===The <tt>said</tt> test command===
 The above assembly language code does raise a very important point.
-The '''said''' command can have a variable number of arguments. Its
+The **said** command can have a variable number of arguments. Its code is 0x0E, and the byte following this byte gives the number of two byte words that follow as parameters.
-code is 0x0E, and the byte following this byte gives the number of
-two byte words that follow as parameters.
 Examples:
-<code type="C++">
+<code C>
 if (said(marble))                          FF 0E 01 1E 01 FF
 if (said( open, door))                     FF 0E 02 37 02 73 00 FF
 </code>
-In the above examples, the values 0x011E, 0x0237, and 0x0073 are just
+In the above examples, the values 0x011E, 0x0237, and 0x0073 are just random word numbers that could stand for the words given.
-random word numbers that could stand for the words given.
-===Inner loops===
+==== Inner loops ====
-At first I almost totally discarded the existence of loops in the AGI
+At first I almost totally discarded the existence of loops in the AGI code because it seemed to me that execution of the logic script continually looped. Loop code like "while", "do..while", and "for" statements wouldn't be needed because you could just use a variable to increment with each pass and an **if** statement to test the value of the variable and take action if it was withing the desired range.
-code because it seemed to me that execution of the logic script
-continually looped. Loop code like "while", "do..while", and "for"
-statements wouldn't be needed because you could just use a variable to
-increment with each pass and an '''if''' statement to test the
-value of the variable and take action if it was withing the desired range.
 Example:
-<code type="C++">
+<code C>
 if (greatern(30, 45) && lessn(30, 55)) {
     print("You're in the hot zone!");
@@ Ligne 654: / Ligne 648: @@
 </code>
-I have found evidence of this sort of thing taking place which means
+I have found evidence of this sort of thing taking place which means that they must loop over continuously. I don't know whether this is something that the interpreter does itself or whether it is part of
-that they must loop over continuously. I don't know whether this is
+the AGI code, e.g. at the end of one logic script it calls another which then calls the first one again. With the existence of the conditional branching and unconditional branching nature of the **if** and
-something that the interpreter does itself or whether it is part of
+**else** statement, it is easy to see that some of the structures such as "do..while" can infact be coded into logic scripts.
-the AGI code, e.g. at the end of one logic script it calls another which
-then calls the first one again. With the existence of the conditional
-branching and unconditional branching nature of the '''if''' and
-'''else''' statement, it is easy to see that some of the
-structures such as "do..while" can infact be coded into logic scripts.
 Example:
-<code type="C++">
+<code C>
 FF FD 0D FF 03 00 FE F7 FF
@@ Ligne 672: / Ligne 661: @@
 </code>
-The above translation is a simple one which is taken from SQ2. The
+The above translation is a simple one which is taken from SQ2. The value 0xFFF7 is the twos complement notation for -9 which is the exact branching value to take the execution back to the start of the **if**
-value 0xFFF7 is the twos complement notation for -9 which is the exact
+statement. If the above example had AGI code between the 0x00 and the 0xFE, then there would be code within the brackets of the "do..while" structure. I don't know whether the original AGI coders used these
-branching value to take the execution back to the start of the '''if'''
+statements or used **goto** statements to achieve the same result.
-statement. If the above example had AGI code between the 0x00 and the
-xFE, then there would be code within the brackets of the "do..while"
-structure. I don't know whether the original AGI coders used these
-statements or used '''goto''' statements to achieve the same result.

Nox-Rhea WiKi

Outils pour utilisateurs

Outils du site

Différences

Outils de la page