[Chapter Sixteen][Previous] [Art of Assembly] [Randall Hyde]

Art of Assembly: Chapter Sixteen


16.8.5 - The "MADVENTURE" Game

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:

Madventure Noun/Verb Table
  No Verb GO GET DROP Inventory Quit Help
No Noun - - - - Inventory Quit Help
North - Do North - - - - -
South - Do South - - - - -
East - Do East - - - - -
West - Do West - - - - -
Lime - - Get Item Drop Item - - -
Beer - - Get Item Drop Item - - -
Card - - Get Item Drop Item - - -
Sign - - Get Item Drop Item - - -
Program - - Get Item Drop Item - - -
Homework - - Get Item Drop Item - - -
Money - - Get Item Drop Item - - -
Form - - Get Item Drop Item - - -
Coupon - - Get Item Drop Item - - -


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


Art of Assembly: Chapter Sixteen - 29 SEP 1996

[Chapter Sixteen][Previous][Art of Assembly][Randall Hyde]



Number of Web Site Hits since Jan 1, 2000: