16.8.5 The "MADVENTURE" Game

Computer games are a perfect example of programs that often use pattern matching. One class of computer games in general the adventure game is a perfect example of games that use pattern matching. An adventure style game excepts English-like commands from the user parses these commands and acts upon them. In this section we will develop an adventure game shell. That is it will be a reasonably functional adventure style game capable of accepting and processing user commands. All you need do is supply a story line and a few additional details to develop a fully functioning adventure class game.

An adventure game usually consists of some sort of maze through which the player moves. The program processes commands like go north or go right to move the player through the maze. Each move can deposit the player in a new room of the game. Generally each room or area contains objects the player can interact with. This could be reward objects such as items of value or it could be an antagonistic object like a monster or enemy player.

Usually an adventure game is a puzzle of some sort. The player finds clues and picks up useful object in one part of the maze to solve problems in other parts of the maze. For example a player could pick up a key in one room that opens a chest in another; then the player could find an object in the chest that is useful elsewhere in the maze. The purpose of the game is to solve all the interlocking puzzles and maximize one's score (however that is done). This text will not dwell upon the subtleties of game design; that is a subject for a different text. Instead we'll look at the tools and data structures required to implement the game design.

The Madventure game's use of pattern matching is quite different from the previous examples appearing in this chapter. In the examples up to this point the matching routines specifically checked the validity of an input string; Madventure does not do this. Instead it uses the pattern matching routines to simply determine if certain key words appear on a line input by the user. The program handles the actual parsing (determining if the command is syntactically correct). To understand how the Madventure game does this it would help if we took a look at how to play the Madventure game.

The Madventure prompts the user to enter a command. Unlike the original adventure game that required commands like "GO NORTH" (with no other characters other than spaces as part of the command) Madventure allows you to write whole sentences and then it attempts to pick out the key words from those sentences. For example Madventure accepts the "GO NORTH" command; however it also accepts commands like "North is the direction I want to go" and "I want to go in the north direction." Madventure doesn't really care as long as it can find "GO" and "NORTH" somewhere on the command line. This is a little more flexible that the original Adventure game structure. Of course this scheme isn't infallible it will treat commands like "I absolutely positively do NOT want to go anywhere near the north direction" as a "GO NORTH" command. Oh well the user almost always types just "GO NORTH" anyway.

A Madventure command usually consists of a noun keyword and a verb keyword. The Madventure recognizes six verbs and fourteen nouns. The verbs are

verbs  go | get | drop | inventory | quit | help

The nouns are

nouns north | south | east | west | lime | beer | card | sign | program | homework | money | form | coupon

Obviously Madventure does not allow all combinations of verbs and nouns. Indeed the following patterns are the only legal ones:

LegalCmds go direction | get item | drop item | inventory | quit | help

direction north | south | east | west

item lime | beer | card | sign | program | homework | money | form | coupon

However the pattern does not enforce this grammar. It just locates a noun and a verb on the line and if found sets the noun and verb variables to appropriate values to denote the keywords it finds. By letting the main program handle the parsing the program is somewhat more flexible.

There are two main patterns in the Madventure program: NounPat and VerbPat. These patterns match words (nouns or verbs) using a regular expression like the following:

(ARB* ` ` | ) word (` ` | EOS)

This regular expression matches a word that appears at the beginning of a sentence at the end of a sentence anywhere in the middle of a sentence or a sentence consisting of a single word. Madventure uses a macro (MatchNoun or MatchVerb) to create an expression for each noun and verb in the above expression.

To get an idea of how Madvent processes words consider the following VerbPat pattern:

VerbPat         pattern         {sl_match2
MatchGo}
MatchVerb       MatchGO
MatchGet
"GO"
1
MatchVerb       MatchGet
MatchDrop
"GET"
2
MatchVerb       MatchDrop
MatchInv
"DROP"
3
MatchVerb       MatchInv
MatchQuit
"INVENTORY"
4
MatchVerb       MatchQuit
MatchHelp
"QUIT"
5
MatchVerb       MatchHelp
0
"HELP"
6

The MatchVerb macro expects four parameters. The first is an arbitrary pattern name; the second is a link to the next pattern in the list; the third is the string to match and the fourth is a number that the matching routines will store into the verb variable if that string matches (by default the verb variable contains zero). It is very easy to add new verbs to this list. For example if you wanted to allow "run" and "walk" as synonyms for the "go" verb you would just add two patterns to this list:

VerbPat         pattern         {sl_match2
MatchGo}
MatchVerb       MatchGO
MatchGet
"GO"
1
MatchVerb       MatchGet
MatchDrop
"GET"
2
MatchVerb       MatchDrop
MatchInv
"DROP"
3
MatchVerb       MatchInv
MatchQuit
"INVENTORY"
4
MatchVerb       MatchQuit
MatchHelp
"QUIT"
5
MatchVerb       MatchHelp
MatchRun
"HELP"
6
MatchVerb       MatchRun
MatchWalk
"RUN"
1
MatchVerb       MatchWalk
0
"WALK"
1

There are only two things to consider when adding new verbs: first don't forget that the next field of the last verb should contain zero; second the current version of Madventure only allows up to seven verbs. If you want to add more you will need to make a slight modification to the main program (more on that later). Of course if you only want to create synonyms as we've done here you simply reuse existing verb values so there is no need to modify the main program.

When you call the match routine and pass it the address of the VerbPat pattern it scans through the input string looking for the first verb. If it finds that verb ("GO") it sets the verb variable to the corresponding verb value at the end of the pattern. If match cannot find the first verb it tries the second. If that fails it tries the third and so on. If match cannot find any of the verbs in the input string it does not modify the verb variable (which contains zero). If there are two or more of the above verbs on the input line match will locate the first verb in the verb list above. This may not be the first verb appearing on the line. For example if you say "Let's get the money and go north" the match routine will match the "go" verb not the "get" verb. By the same token the NounPat pattern would match the north noun not the money noun. So this command would be identical to "GO NORTH."

The MatchNoun is almost identical to the MatchVerb macro; there is however one difference - the MatchNoun macro has an extra parameter which is the name of the data structure representing the given object (if there is one). Basically all the nouns (in this version of Madventure) except NORTH SOUTH EAST and WEST have some sort of data structure associated with them.

The maze in Madventure consists of nine rooms defined by the data structure:

Room            struct
north           word    ?
south           word    ?
west            word    ?
east            word    ?
ItemList        word    MaxWeight dup (?)
Description     word    ?
Room            ends

The north south west and east fields contain near pointers to other rooms. The program uses the CurRoom variable to keep track of the player's current position in the maze. When the player issues a "GO" command of some sort Madventure copies the appropriate value from the north south west or east field to the CurRoom variable effectively changing the room the user is in. If one of these pointers is NULL then the user cannot move in that direction.

The direction pointers are independent of one another. If you issue the command "GO NORTH" and then issue the command "GO SOUTH" upon arriving in the new room there is no guarantee that you will wind up in the original room. The south field of the second room may not point at the room that led you there. Indeed there are several cases in the Madventure game where this occurs.

The ItemList array contains a list of near pointers to objects that could be in the room. In the current version of this game the objects are all the nouns except north south east and west. The player can carry these objects from room to room (indeed that is the major purpose of this game). Up to MaxWeight objects can appear in the room (MaxWeight is an assembly time constant that is currently four; so there are a maximum of four items in any one given room). If an entry in the ItemList is non-NULL then it is a pointer to an Item object. There may be zero to MaxWeight objects in a room.

The Description field contains a pointer to a zero terminated string that describes the room. The program prints this string each time through the command loop to keep the player oriented.

The second major data type in Madventure is the Item structure. This structure takes the form:

Item            struct
Value           word    ?
Weight          word    ?
Key             word    ?
ShortDesc       word    ?
LongDesc        word    ?
WinDesc         word    ?
Item            ends

The Value field contains an integer value awarded to the player when the player drops this object in the appropriate room. This is how the user scores points.

The Weight field usually contains one or two and determines how much this object "weighs." The user can only carry around MaxWeight units of weight at any one given time. Each time the user picks up an object the weight of that object is added to the user's total weight. When the user drops an object Madventure subtracts the object's weight from the total.

The Key field contains a pointer to a room associated with the object. When the user drops the object in the Key room the user is awarded the points in the Value field and the object disappears from the game. If the user drops the object in some other room the object stays in that room until the user picks it up again.

The ShortDesc LongDesc and WinDesc fields contain pointers to zero terminated strings. Madventure prints the ShortDesc string in response to an INVENTORY command. It prints the LongDesc string when describing a room's contents. It prints the WinDesc string when the user drops the object in its Key room and the object disappears from the game.

The Madventure main program is deceptively simple. Most of the logic is hidden in the pattern matching routines and in the parsing routine. We've already discussed the pattern matching code; the only important thing to remember is that it initializes the noun and verb variables with a value uniquely identifying each noun and verb. The main program's logic uses these two values as an index into a two dimensional table that takes the following form:

The empty entries in this table correspond to illegal commands. The other entries are addresses of code within the main program that handles the given command.

To add more nouns (objects) to the game you need only extend the NounPat pattern and add additional rows to the table (of course you may need to add code to handle the new objects if they are not easily handled by the routines above). To add new verbs you need only extended the VerbPat pattern and add new columns to this table.

Other than the goodies mentioned above the rest of the program utilizes techniques appearing throughout this and previous chapters. The only real surprising thing about this program is that you can implement a fairly complex program with so few lines of code. But such is the advantage of using pattern matching techniques in your assembly language programs.

; MADVENT.ASM
;
; This is a "shell" of an adventure game that you can use to create
; your own adventure style games.

.xlist
.286
include         stdlib.a
includelib      stdlib.lib
matchfuncs
.list

dseg            segment         para public 'data'

; Equates:

NULL            equ     0
MaxWeight       equ     4       ;Max weight user can carry at one time.


; The "ROOM" data structure defines a room
or area
where a player can
; go. The NORTH
SOUTH
EAST
and WEST fields contain the address of
; the rooms to the north
south
east
and west of the room. The game
; transfers control to the room whose address appears in these fields
; when the player supplies a GO NORTH
GO SOUTH
etc.
command.
;
; The ITEMLIST field contains a list of pointers to objects appearing
; in this room. In this game
the user can pick up and drop these
; objects (if there are any present).
;
; The DESCRIPTION field contains a (near) address of a short description
; of the current room/area.

Room            struct
north           word    ?       ;Near pointers to other structures where
south           word    ?       ; we will wind up on the GO NORTH
GO SOUTH

west            word    ?       ; etc.
commands.
east            word    ?

ItemList        word    MaxWeight dup (?)

Description     word    ?       ;Description of room.
Room            ends


; The ITEM data structure describes the objects that may appear
; within a room (in the ITEMLIST above). The VALUE field contains
; the number of points this object is worth if the user drops it
; off in the proper room (i.e
solves the puzzle). The WEIGHT
; field provides the weight of this object. The user can only
; carry four units of weight at a time. This field is usually
; one
but may be more for larger objects. The KEY field is the
; address of the room where this object must be dropped to solve
; the problem. The SHORTDESC field is a pointer to a string that
; the program prints when the user executes an INVENTORY command.
; LONGDESC is a pointer to a string the program prints when des-
; cribing the contents of a room. The WINDESC field is a pointer
; to a string that the program prints when the user solves the
; appropriate puzzle.

Item            struct
Value           word    ?
Weight          word    ?
Key             word    ?
ShortDesc       word    ?
LongDesc        word    ?
WinDesc         word    ?
Item            ends


; State variables for the player:

CurRoom         word    Room1            ;Room the player is in.
ItemsOnHand     word    MaxWeight dup (?) ;Items the player carries.
CurWeight       word    0                ;Weight of items carried.
CurScore        word    15               ;Player's current score.
TotalCounter    word    9                ;Items left to place.
Noun            word    0                ;Current noun value.
Verb            word    0                ;Current verb value.
NounPtr         word    0                ;Ptr to current noun item.


; Input buffer for commands

InputLine       byte    128 dup (?)

; The following macros generate a pattern which will match a single word
; which appears anywhere on a line. In particular
they match a word
; at the beginning of a line
somewhere in the middle of the line
or
; at the end of a line. This program defines a word as any sequence
; of character surrounded by spaces or the beginning or end of a line.
;
; MatchNoun/Verb matches lines defined by the regular expression:
;
;       (ARB* ' ' | e) string (' ' | EOS)

MatchNoun       macro   Name
next
WordString
ItemVal
ItemPtr
local   WS1
WS2
WS3
WS4
local   WS5
WS6
WordStr

Name            Pattern {sl_match2
WS1
next}
WS1             Pattern {MatchStr
WordStr
WS2
WS5}
WS2             Pattern {arb
0
0
WS3}
WS3             Pattern {Matchchar
' '
0
WS4}
WS4             Pattern {MatchStr
WordStr
0
WS5}
WS5             Pattern {SetNoun
ItemVal
0
WS6}
WS6             Pattern {SetPtr
ItemPtr
0
MatchEOS}
WordStr         byte    WordString
byte    0
endm


MatchVerb       macro   Name
next
WordString
ItemVal
local   WS1
WS2
WS3
WS4
local   WS5
WordStr

Name            Pattern {sl_match2
WS1
next}
WS1             Pattern {MatchStr
WordStr
WS2
WS5}
WS2             Pattern {arb
0
0
WS3}
WS3             Pattern {Matchchar
' '
0
WS4}
WS4             Pattern {MatchStr
WordStr
0
WS5}
WS5             Pattern {SetVerb
ItemVal
0
MatchEOS}
WordStr         byte    WordString
byte    0
endm




; Generic patterns which most of the patterns use:

MatchEOS        Pattern {EOS
0
MatchSpc}
MatchSpc        Pattern {MatchChar
' '}


; Here are the list of nouns allowed in this program.

NounPat         pattern         {sl_match2
MatchNorth}

MatchNoun       MatchNorth
MatchSouth
"NORTH"
1
0
MatchNoun       MatchSouth
MatchEast
"SOUTH"
2
0
MatchNoun       MatchEast
MatchWest
"EAST"
3
0
MatchNoun       MatchWest
MatchLime
"WEST"
4
0
MatchNoun       MatchLime
MatchBeer
"LIME"
5
Item3
MatchNoun       MatchBeer
MatchCard
"BEER"
6
Item9
MatchNoun       MatchCard
MatchSign
"CARD"
7
Item2
MatchNoun       MatchSign
MatchPgm
"SIGN"
8
Item1
MatchNoun       MatchPgm
MatchHW
"PROGRAM"
9
Item7
MatchNoun       MatchHW
MatchMoney
"HOMEWORK"
10
Item4
MatchNoun       MatchMoney
MatchForm
"MONEY"
11
Item5
MatchNoun       MatchForm
MatchCoupon
"FORM"
12
Item6
MatchNoun       MatchCoupon
0
"COUPON"
13
Item8


; Here is the list of allowable verbs.

VerbPat         pattern         {sl_match2
MatchGo}

MatchVerb       MatchGO
MatchGet
"GO"
1
MatchVerb       MatchGet
MatchDrop
"GET"
2
MatchVerb       MatchDrop
MatchInv
"DROP"
3
MatchVerb       MatchInv
MatchQuit
"INVENTORY"
4
MatchVerb       MatchQuit
MatchHelp
"QUIT"
5
MatchVerb       MatchHelp
0
"HELP"
6

; Data structures for the "maze".

Room1           room    {Room1
Room5
Room4
Room2

{Item1
0
0
0}

Room1Desc}

Room1Desc       byte    "at the Commons"
0

Item1           item    {10
2
Room3
GS1
GS2
GS3}
GS1             byte    "a big sign"
0
GS2             byte    "a big sign made of styrofoam with funny "
byte    "letters on it."
0
GS3             byte    "The ETA PI Fraternity thanks you for return"
byte    "ing their sign
they"
cr
lf
byte    "make you an honorary life member
as long as "
byte    "you continue to pay"
cr
lf
byte    "your $30 monthly dues
that is."
0

Room2           room    {NULL
Room5
Room1
Room3

{Item2
0
0
0}

Room2Desc}

Room2Desc       byte    'at the "C" on the hill above campus'
0

Item2           item    {10
1
Room1
LC1
LC2
LC3}
LC1             byte    "a lunch card"
0
LC2             byte    "a lunch card which someone must have "
byte    "accidentally dropped here."
0
LC3             byte    "You get a big meal at the Commons cafeteria"
byte    cr
lf
byte    "It would be a good idea to go visit the "
byte    "student health center"
cr
lf
byte    "at this time."
0

Room3           room    {NULL
Room6
Room2
Room2

{Item3
0
0
0}

Room3Desc}

Room3Desc       byte    "at ETA PI Frat House"
0

Item3           item    {10
2
Room2
BL1
BL2
BL3}
BL1             byte    "a bag of lime"
0
BL2             byte    "a bag of baseball field lime which someone "
byte    "is obviously saving for"
cr
lf
byte    "a special occasion."
0
BL3             byte    "You spread the lime out forming a big '++' "
byte    "after the 'C'"
cr
lf
byte    "Your friends in Computer Science hold you "
byte    "in total awe."
0

Room4           room    {Room1
Room7
Room7
Room5

{Item4
0
0
0}

Room4Desc}

Room4Desc       byte    "in Dr. John Smith's Office"
0

Item4           item    {10
1
Room7
HW1
HW2
HW3}
HW1             byte    "a homework assignment"
0
HW2             byte    "a homework assignment which appears to "
byte    "to contain assembly language"
0
HW3             byte    "The grader notes that your homework "
byte    "assignment looks quite"
cr
lf
byte    "similar to someone else's assignment "
byte    "in the class and reports you"
cr
lf
byte    "to the instructor."
0

Room5           room    {Room1
Room9
Room7
Room2

{Item5
0
0
0}

Room5Desc}

Room5Desc       byte    "in the computer lab"
0

Item5           item    {10
1
Room9
M1
M2
M3}
M1              byte    "some money"
0
M2              byte    "several dollars in an envelope in the "
byte    "trashcan"
0
M3              byte    "The waitress thanks you for your "
byte    "generous tip and gets you"
cr
lf
byte    "another pitcher of beer. "
byte    "Then she asks for your ID."
cr
lf
byte    "You are at least 21 aren't you?"
0

Room6           room    {Room3
Room9
Room5
NULL

{Item6
0
0
0}

Room6Desc}

Room6Desc       byte    "at the campus book store"
0

Item6           item    {10
1
Room8
AD1
AD2
AD3}
AD1             byte    "an add/drop/change form"
0
AD2             byte    "an add/drop/change form filled out for "
byte    "assembly to get a letter grade"
0
AD3             byte    "You got the form in just in time. "
byte    "It would have been a shame to"
cr
lf
byte    "have had to retake assembly because "
byte    "you didn't realize you needed to "
cr
lf
byte    "get a letter grade in the course."
0

Room7           room    {Room1
Room7
Room4
Room8

{Item7
0
0
0}

Room7Desc}

Room7Desc       byte    "in the assembly lecture"
0

Item7           item    {10
1
Room5
AP1
AP2
AP3}
AP1             byte    "an assembly language program"
0
AP2             byte    "an assembly language program due in "
byte    "the assemblylanguage class."
0
AP3             byte    "The sample program the instructor gave "
byte    "you provided all the information"
cr
lf
byte    "you needed to complete your assignment. "
byte    "You finish your work and"
cr
lf
byte    "head to the local pub to celebrate."
byte    cr
lf
0

Room8           room    {Room5
Room6
Room7
Room9

{Item8
0
0
0}

Room8Desc}

Room8Desc       byte     "at the Registrar's office"
0

Item8           item    {10
1
Room6
C1
C2
C3}
C1              byte    "a coupon"
0
C2              byte    "a coupon good for a free text book"
0
C3              byte    'You get a free copy of "Cliff Notes for '
byte    'The Art of Assembly'
cr
lf
byte    'Language Programming" Alas
it does not '
byte    "provide all the"
cr
lf
byte    "information you need for the class
so you "
byte    "sell it back during"
cr
lf
byte    "the book buy-back period."
0



Room9           room    {Room6
Room9
Room8
Room3

{Item9
0
0
0}

Room9Desc}

Room9Desc       byte    "at The Pub"
0
Item9           item    {10
2
Room4
B1
B2
B3}
B1              byte    "a pitcher of beer"
0
B2              byte    "an ice cold pitcher of imported beer"
0
B3              byte    "Dr. Smith thanks you profusely for your "
byte    "good taste in brews."
cr
lf
byte    "He then invites you to the pub for a "
byte    "round of pool and"
cr
lf
byte    "some heavy duty hob-nobbing
"
byte    "CS Department style."
0

dseg            ends


cseg            segment         para public 'code'
assume          ds:dseg


; SetNoun-      Copies the value in SI (the matchparm parameter) to the
;               NOUN variable.

SetNoun         proc    far
push    ds
mov     ax
dseg
mov     ds
ax
mov     Noun
si
mov     ax
di
stc
pop     ds
ret
SetNoun         endp


; SetVerb-      Copies the value in SI (the matchparm parameter) to the
;               VERB variable.

SetVerb         proc    far
push    ds
mov     ax
dseg
mov     ds
ax
mov     Verb
si
mov     ax
di
stc
pop     ds
ret
SetVerb         endp

; SetPtr-       Copies the value in SI (the matchparm parameter) to the
;               NOUNPTR variable.

SetPtr          proc    far
push    ds
mov     ax
dseg
mov     ds
ax
mov     NounPtr
si
mov     ax
di
stc
pop     ds
ret
SetPtr          endp

; CheckPresence-
;               BX points at an item. DI points at an item list. This
;               routine checks to see if that item is present in the
;               item list. Returns Carry set if item was found

;               clear if not found.

CheckPresence   proc

; MaxWeight is an assembly-time adjustable constant that determines
; how many objects the user can carry
or can be in a room
at one
; time. The following repeat macro emits "MaxWeight" compare and
; branch sequences to test each item pointed at by DS:DI.

ItemCnt         =       0
repeat  MaxWeight
cmp     bx
[di+ItemCnt]
je      GotIt

ItemCnt         =       ItemCnt+2
endm

clc
ret

GotIt:          stc
ret
CheckPresence   endp

; RemoveItem-   BX contains a pointer to an item. DI contains a pointer
;               to an item list which contains that item. This routine
;               searches the item list and removes that item from the
;               list. To remove an item from the list
we need only
;               store a zero (NULL) over the top of its pointer entry
;               in the list.

RemoveItem      proc

; Once again
we use the repeat macro to automatically generate a chain
; of compare
branch
and remove code sequences for each possible item
; in the list.

ItemCnt         =       0
repeat  MaxWeight
local   NotThisOne
cmp     bx
[di+ItemCnt]
jne     NotThisOne
mov     word ptr [di+ItemCnt]
NULL
ret
NotThisOne:
ItemCnt         =       ItemCnt+2
endm

ret
RemoveItem      endp


; InsertItem-   BX contains a pointer to an item
DI contains a pointer to
;               and item list. This routine searches through the list for
;               the first empty spot and copies the value in BX to that point.
;               It returns the carry set if it succeeds. It returns the
;               carry clear if there are no empty spots available.

InsertItem      proc

ItemCnt         =       0
repeat  MaxWeight
local   NotThisOne
cmp     word ptr [di+ItemCnt]
0
jne     NotThisOne
mov     [di+ItemCnt]
bx
stc
ret
NotThisOne:
ItemCnt         =       ItemCnt+2
endm

clc
ret
InsertItem      endp

; LongDesc- Long description of an item.
; DI points at an item - print the long description of it.

LongDesc        proc
push    di
test    di
di
jz      NoDescription
mov     di
[di].item.LongDesc
puts
putcr
NoDescription:  pop     di
ret
LongDesc        endp


; ShortDesc- Print the short description of an object.
; DI points at an item (possibly NULL). Print the short description for it.

ShortDesc       proc
push    di
test    di
di
jz      NoDescription
mov     di
[di].item.ShortDesc
puts
putcr
NoDescription:  pop     di
ret
ShortDesc       endp

; Describe:     "CurRoom" points at the current room. Describe it and its
;               contents.

Describe        proc
push    es
push    bx
push    di
mov     di
ds
mov     es
di

mov     bx
CurRoom
mov     di
[bx].room.Description
print
byte    "You are currently "
0
puts
putcr
print
byte    "Here you find the following:"
cr
lf
0

; For each possible item in the room
print out the long description
; of that item. The repeat macro generates a code sequence for each
; possible item that could be in this room.

ItemCnt         =       0
repeat  MaxWeight
mov     di
[bx].room.ItemList[ItemCnt]
call    LongDesc

ItemCnt         =       ItemCnt+2
endm


pop     di
pop     bx
pop     es
ret
Describe        endp


; Here is the main program
that actually plays the game.

Main            proc
mov     ax
dseg
mov     ds
ax
mov     es
ax
meminit

print
byte    cr
lf
lf
lf
lf
lf
byte    "Welcome to "
'"MADVENTURE"'
cr
lf
byte    'If you need help
type the command "HELP"'
byte    cr
lf
0

RoomLoop:       dec     CurScore                ;One point for each move.
jnz     NotOverYet

; If they made too many moves without dropping anything properly
boot them
; out of the game.

print
byte    "WHOA! You lost! You get to join the legions of "
byte    "the totally lame"
cr
lf
byte    'who have failed at "MADVENTURE"'
cr
lf
0
jmp     Quit

; Okay
tell 'em where they are and get a new command from them.

NotOverYet:     putcr
call    Describe
print
byte    cr
lf
byte    "Command: "
0
lesi    InputLine
gets
strupr                  ;Ignore case by converting to U.C.

; Okay
process the command. Note that we don't actually check to see
; if there is a properly formed sentence. Instead
we just look to see
; if any important keywords are on the line. If they are
the pattern
; matching routines load the appropriate values into the noun and verb
; variables (nouns: north=1
south=2
east=3
west=4
lime=5
beer=6

; card=7
sign=8
program=9
homework=10
money=11
form=12
coupon=13;
; verbs: go=1
get=2
drop=3
inventory=4
quit=5
help=6).
;
; This code uses the noun and verb variables as indexes into a two
; dimensional array whose elements contain the address of the code
; to process the given command. If a given command does not make
; any sense (e.g.
"go coupon") the entry in the table points at the
; bad command code.

mov     Noun
0
mov     Verb
0
mov     NounPtr
0

ldxi    VerbPat
xor     cx
cx
match

lesi    InputLine
ldxi    NounPat
xor     cx
cx
match

; Okay
index into the command table and jump to the appropriate
; handler. Note that we will cheat and use a 14x8 array. There
; are really only seven verbs
not eight. But using eight makes
; things easier since it is easier to multiply by eight than seven.

mov     si
CurRoom     ;The commands expect this here.

mov     bx
Noun
shl     bx
3           ;Multiply by eight.
add     bx
Verb
shl     bx
1           ;Multiply by two - word table.
jmp     cseg:jmptbl[bx]

; The following table contains the noun x verb cross product.
; The verb values (in each row) are the following:
;
;       NONE    GO      GET      DROP   INVNTRY QUIT    HELP    unused
;        0       1       2        3      4       5       6       7
;
; There is one row for each noun (plus row zero
corresponding to no
; noun found on line).

jmptbl          word    Bad             ;No noun
no verb
word    Bad             ;No noun
GO
word    Bad             ;No noun
GET
word    Bad             ;No noun
DROP
word    DoInventory     ;No noun
INVENTORY
word    QuitGame        ;No noun
QUIT
word    DoHelp          ;No noun
HELP
word    Bad             ;N/A

NorthCmds       word    Bad
GoNorth
Bad
Bad
Bad
Bad
Bad
Bad
SouthCmds       word    Bad
GoSouth
Bad
Bad
Bad
Bad
Bad
Bad
EastCmds        word    Bad
GoEast
Bad
Bad
Bad
Bad
Bad
Bad
WestCmds        word    Bad
GoWest
Bad
Bad
Bad
Bad
Bad
Bad
LimeCmds        word    Bad
Bad
GetItem
DropItem
Bad
Bad
Bad
Bad
BeerCmds        word    Bad
Bad
GetItem
DropItem
Bad
Bad
Bad
Bad
CardCmds        word    Bad
Bad
GetItem
DropItem
Bad
Bad
Bad
Bad
SignCmds        word    Bad
Bad
GetItem
DropItem
Bad
Bad
Bad
Bad
ProgramCmds     word    Bad
Bad
GetItem
DropItem
Bad
Bad
Bad
Bad
HomeworkCmds    word    Bad
Bad
GetItem
DropItem
Bad
Bad
Bad
Bad
MoneyCmds       word    Bad
Bad
GetItem
DropItem
Bad
Bad
Bad
Bad
FormCmds        word    Bad
Bad
GetItem
DropItem
Bad
Bad
Bad
Bad
CouponCmds      word    Bad
Bad
GetItem
DropItem
Bad
Bad
Bad
Bad

; If the user enters a command we don't know how to process
print an
; appropriate error message down here.

Bad:            printf
byte    "I'm sorry
I don't understand how to '%s'\n"
0
dword   InputLine
jmp     NotOverYet


; Handle the movement commands here.
; Movements are easy
all we've got to do is fetch the NORTH
SOUTH

; EAST
or WEST pointer from the current room's data structure and
; set the current room to that address. The only catch is that some
; moves are not legal. Such moves have a NULL (zero) in the direction
; field. A quick check for this case handles illegal moves.

GoNorth:        mov     si
[si].room.North
jmp     MoveMe

GoSouth:        mov     si
[si].room.South
jmp     MoveMe

GoEast:         mov     si
[si].room.East
jmp     MoveMe

GoWest:         mov     si
[si].room.West
MoveMe:         test    si
si                  ;See if move allowed.
jnz     SetCurRoom
printf
byte    "Sorry
you cannot go in this direction."
byte    cr
lf
0
jmp     RoomLoop

SetCurRoom:     mov     CurRoom
si             ;Move to new room.
jmp     RoomLoop

; Handle the GetItem command down here. At this time the user
; has entered GET and some noun that the player can pick up.
; First
we will make sure that item is in this room.
; Then we will check to make sure that picking up this object
; won't overload the player. If these two conditions are met

; we'll transfer the object from the room to the player.

GetItem:        mov     bx
NounPtr             ;Ptr to item user wants.
mov     si
CurRoom
lea     di
[si].room.ItemList  ;Ptr to item list in di.
call    CheckPresence           ;See if in room.
jc      GotTheItem
printf
byte    "Sorry
that item is not available here."
byte    cr
lf
0
jmp     RoomLoop

; Okay
see if picking up this object will overload the player.

GotTheItem:     mov     ax
[bx].Item.Weight
add     ax
CurWeight
cmp     ax
MaxWeight
jbe     WeightOkay
printf
byte    "Sorry
you are already carrying too many items "
byte    "to safely carry\nthat object\n"
0
jmp     RoomLoop

; Okay
everything's cool
transfer the object from the room to the user.

WeightOkay:     mov     CurWeight
ax           ;Save new weight.
call    RemoveItem              ;Remove item from room.
lea     di
ItemsOnHand         ;Ptr to player's list.
call    InsertItem
jmp     RoomLoop


; Handle dropped objects down here.

DropItem:       lea     di
ItemsOnHand         ;See if the user has
mov     bx
NounPtr             ; this item on hand.
call    CheckPresence
jc      CanDropIt1
printf
byte    "You are not currently holding that item\n"
0
jmp     RoomLoop

; Okay
let's see if this is the magic room where this item is
; supposed to be dropped. If so
award the user some points for
; properly figuring this out.

CanDropIt1:     mov     ax
[bx].item.key
cmp     ax
CurRoom
jne     JustDropIt

; Okay
success! Print the winning message for this object.

mov     di
[bx].item.WinDesc
puts
putcr

; Award the user some points.

mov     ax
[bx].item.value
add     CurScore
ax

; Since the user dropped it
they can carry more things now.

mov     ax
[bx].item.Weight
sub     CurWeight
ax

; Okay
take this from the user's list.

lea     di
ItemsOnHand
call    RemoveItem

; Keep track of how may objects the user has successfully dropped.
; When this counter hits zero
the game is over.

dec     TotalCounter
jnz     RoomLoop

printf
byte    "Well
you've found where everything goes "
byte    "and your score is %d.\n"
byte    "You might want to play again and see if "
byte    "you can get a better score.\n"
0
dword   CurScore
jmp     Quit

; If this isn't the room where this object belongs
just drop the thing
; off. If this object won't fit in this room
ignore the drop command.

JustDropIt:     mov     di
CurRoom
lea     di
[di].room.ItemList
call    InsertItem
jc      DroppedItem
printf
byte    "There is insufficient room to leave "
byte    "that item here.\n"
0
jmp     RoomLoop

; If they can drop it
do so. Don't forget we've just unburdened the
; user so we need to deduct the weight of this object from what the
; user is currently carrying.

DroppedItem:    lea     di
ItemsOnHand
call    RemoveItem
mov     ax
[bx].item.Weight
sub     CurWeight
ax
jmp     RoomLoop

; If the user enters the INVENTORY command
print out the objects on hand

DoInventory:    printf
byte    "You currently have the following items in your "
byte    "possession:"
cr
lf
0
mov     di
ItemsOnHand[0]
call    ShortDesc
mov     di
ItemsOnHand[2]
call    ShortDesc
mov     di
ItemsOnHand[4]
call    ShortDesc
mov     di
ItemsOnHand[6]
call    ShortDesc
printf
byte    "\nCurrent score: %d\n"
byte    "Carrying ability: %d/4\n\n"
0
dword   CurScore
CurWeight
inc     CurScore                ;This command is free.
jmp     RoomLoop


; If the user requests help
provide it here.

DoHelp:         printf
byte    "List of commands:"
cr
lf
lf
byte    "GO {NORTH
EAST
WEST
SOUTH}"
cr
lf
byte    "{GET
DROP} {LIME
BEER
CARD
SIGN
PROGRAM
"
byte    "HOMEWORK
MONEY
FORM
COUPON}"
cr
lf
byte    "SHOW INVENTORY"
cr
lf
byte    "QUIT GAME"
cr
lf
byte    "HELP ME"
cr
lf
lf
byte    "Each command costs you one point."
cr
lf
byte    "You accumulate points by picking up objects and "
byte    "dropping them in their"
cr
lf
byte    " appropriate locations."
cr
lf
byte    "If you drop an item in its proper location
it "
byte    "disappears from the game."
cr
lf
byte    "The game is over if your score drops to zero or "
byte    "you properly place"
cr
lf
byte    " all items."
cr
lf
byte    0
jmp     RoomLoop


; If they quit prematurely
let 'em know what a wimp they are!

QuitGame:       printf
byte    "So long
your score is %d and there are "
byte    "still %d objects unplaced\n"
0
dword   CurScore
TotalCounter

Quit:           ExitPgm                 ;DOS macro to quit program.
Main            endp
cseg            ends

sseg            segment para stack 'stack'
stk             db      1024 dup ("stack ")
sseg            ends

zzzzzzseg       segment para public 'zzzzzz'
LastBytes       db      16 dup (?)
zzzzzzseg       ends
end     Main

Chapter Sixteen: Pattern Matching (Part 12)
29 SEP 1996