Team Members:
        Mike Basil – Graphics and Game-play
        Preston White – Graphics and Game-play
        Jon Moeller – Sound FX
        Mark Smith - Networking

Introduction:
    We plan to implement a Multi-Player Racing Game as viewed from above. Game-play will involve the player's car       being able to rotate isometrically in the center of the screen as the racetrack scrolls in the background according to the orientation and acceleration of the car. Unlike other such games, ours will be a multi-player game over a network connection.

Main Features:

• Scrolling isometric animation in Mode 13h Video
•  MIDI and WAV sound
•  Possibly a modulated engine noise as well
•  2-4 Player network game capability
• AI computer players

    We will be implementing a smooth-scrolling screen for 16 different directions. We will do this with mode 13h VGA graphics. The game map will consist of tiles from a PCX file that will be loaded into the Tile Segment of our program. In order to accomplish scrolling, we keep track of the current player's car position as the center of the screen and map the viewable portion of the game map to the screen.

The network feature of the game will be based upon a server-client relationship. Each player client will receive the positions and orientations of the other players from the server, and will reply by sending its updated movements. All player clients will then have up-to-date information about the other players in the game to refer to when updating their screen. Information will be sent in small packets via NetBios at a fast enough rate so that variations in player speeds will be accurately reflected in the game.

We will implement sound functions for various events in the game. Small noises such as crashes will be handled as short WAV files, and general background music will be played as MIDI files. We may also attempt to directly program the DSP with a value modulated by the current car speed that would represent a crude engine noise. This would need to be tied into both our timer and keyboard handlers.
Writing the game-play code will be the most difficult part of this project. Modularity will be especially important since the network feature will require a smooth exchange of data between the different clients. Another challenge will be the implementation of acceleration. We will need to write a complex keyboard handler that will be able to ramp car speed from zero to a maximum value as a key is held down. Sound processing for the engine noise will be tied directly to this feature. Lastly, we will need to handle a variety of boundary conditions such as sliding on the edge of the track, collisions, and orientation-based speed calculations.
 

Constants

 

Sound Constants

SBRESET	EQU	06h
SBREAD	EQU	0Ah
SBWRITE	EQU	0Ch
SBSTATUS	EQU	0Ch
SBAVAIL	EQU	0Eh
SBACK	EQU	0Fh

 
 

WAV File Constants

SCREECH	EQU	0
ENGINE	EQU	1
HORN	EQU	2
OW	EQU	3
BUILD	EQU	4
SPEED	EQU	5
HARLEY	EQU	6
TAP	EQU	7
TONE1	EQU	8
TONE2	EQU	9
TONE3	EQU	10

 
 

MIDI Files Constants

BREATHE	EQU	0
PULPFICTION	EQU	1
KNIGHTRIDER	EQU	2
MIAMIVICE	EQU	3
MISSIONIMP	EQU	4
ECCOSONG	EQU	5
SMELLS	EQU	6
SPYHUNTER	EQU	7
JUNGLE	EQU	8
SWEETCHILD	EQU	9

 
 

Video Constants/Text Constants

VIDSEG	EQU	0A000h
VIDTEXTSEG	EQU	0B800h
CR	EQU	13
LF	EQU	10

 
 

GamePlay Constants

MAXSPEED	EQU	2
MINSPEED	EQU	10
TURNMAXWAIT	EQU	50	Amount of time waiting before next turn
NUMDIR	EQU	15
FRICMAX	EQU	15	Max time sliding
SLIDEMAX	EQU	15	Number of gameloop turns before tires "Catch"
MAXIMPACT	EQU	2	how much impact a collision has
DRAWSPEED	EQU	3	how often we draw to the screen
NETSPEED	EQU	0	how often we send our info to the net
CARSPACEX	EQU	18	Range for impact
CARSPACEY	EQU	18

 
 

Player keyboard control scan codes (not ASCII)

TURN_L	EQU	75	'4' On Number Pad
TURN_R	EQU	77	'6' On Number Pad
ACCELERATE	EQU	29	'Ctrl
NITROUS	EQU	56	'Alt'

 
 

Values for Turning Car

NO_TURN	EQU	0
LEFT	EQU	1
RIGHT	EQU	2

 
 

Various Tile Constants

TILEWIDTH	EQU	16	Tile Sizes
TILEHEIGHT	EQU	14
SCREENWIDTH	EQU	319	Width of printable screen
SCREENHEIGHT	EQU	167	Height of printable screen (depends on Console)
SCREENTHRUY	EQU	15	used with the map editor to know when to scroll the map
SCREENTHRLY	EQU	152
SCREENTHRLX	EQU	15
SCREENTHRRX	EQU	305
CAROFFSETUL	EQU	22544
NUMCOLS	EQU	320	Number of columns we are using in drawtile
NUMROWS	EQU	168	Number of Rows we are usig in drawtile
DEFAULTTILE	EQU	00	what to print when off map
XCARSCREEN	EQU	160	where car starts X
XOFFSET	EQU	176	offset for easy calculations
XTILEOFFSET	EQU	11
YCARSCREEN	EQU	84	similar to X
YOFFSET	EQU	98
YTILEOFFSET	EQU	07
HORZTILES	EQU	80	how many tiles in X direction of map
HTILESSCRN	EQU	20	how many tiles in 1 viewable screen X
VERTTILES	EQU	60	similar to X
VTILESSCRN	EQU	13
MAPFILEOFFSET	EQU	03
MAPBYTES	EQU	4800
XCARMAPTH	EQU	HORZTILES*TILEWIDTH	XCarMap can't go past this
YCARMAPTH	EQU	VERTTILES*TILEHEIGHT	YCarMap can't go past thi

 
 

Tile Offset Constants

PALTILE0ULX	EQU	1
PALTILE0ULY	EQU	170
PALTILE1ULX	EQU	18
PALTILE1ULY	EQU	170
PALTILE2ULX	EQU	170
PALTILE2ULY	EQU	35
PALTILE3ULX	EQU	170
PALTILE3ULY	EQU	52
PALTILE4ULX	EQU	170
PALTILE4ULY	EQU	69
PALTILE5ULX	EQU	170
PALTILE5ULY	EQU	86
PALTILE6ULX	EQU	170
PALTILE6ULY	EQU	103
PALTILE7ULX	EQU	170
PALTILE7ULY	EQU	120
PALTILE8ULX	EQU	170
PALTILE8ULY	EQU	154
PALTILE9ULX	EQU	170
PALTILE9ULY	EQU	137
PALTILE10ULX	EQU	170
PALTILE10ULY	EQU	171
PALTILE11ULX	EQU	170
PALTILE11ULY	EQU	188
PALTILE12ULX	EQU	170
PALTILE12ULY	EQU	205
PALTILE13ULX	EQU	222
PALTILE13ULY	EQU	170
PALTILE14ULX	EQU	239
PALTILE14ULY	EQU	170
PALTILE15ULX	EQU	256
PALTILE15ULY	EQU	170
PALTILE16ULX	EQU	001
PALTILE16ULY	EQU	185
PALTILE17ULX	EQU	018
PALTILE17ULY	EQU	185
PALTILE18ULX	EQU	035
PALTILE18ULY	EQU	185
PALTILE19ULX	EQU	052
PALTILE19ULY	EQU	185
PALTILE20ULX	EQU	069
PALTILE20ULY	EQU	185
PALTILE21ULX	EQU	086
PALTILE21ULY	EQU	185
PALTILE22ULX	EQU	103
PALTILE22ULY	EQU	185
PALTILE23ULX	EQU	120
PALTILE23ULY	EQU	185
PALTILE24ULX	EQU	137
PALTILE24ULY	EQU	185
PALTILE25ULX	EQU	154
PALTILE25ULY	EQU	185
PALTILE26ULX	EQU	171
PALTILE26ULY	EQU	185
PALTILE27ULX	EQU	188
PALTILE27ULY	EQU	185
PALTILE28ULX	EQU	205
PALTILE28ULY	EQU	185
PALTILE29ULX	EQU	222
PALTILE29ULY	EQU	185
PALTILE30ULX	EQU	239
PALTILE30ULY	EQU	185
PALTILE31ULX	EQU	256
PALTILE31ULY	EQU	185

 
 

Other Tile Constants

PALTILEEULX	EQU	285
PALTILEEULY	EQU	170
PALTILESULX	EQU	302
PALTILESULY	EQU	170
PUDDLETILE	EQU	28
FINISHLINE1	EQU	25
FINISHLINE3	EQU	27
TURBOTILE1	EQU	98
TURBOTILE2	EQU	99
TURBOTILE3	EQU	30
TURBOTILE4	EQU	31
OILTILE	EQU	100

 
 

Constants for Console

CONSOLEOFFSET	EQU	(320*96)
CONSOLEHEIGHT	EQU	32
SMALLMAPOFFSET	EQU	(320*97)+140
SMALLMAPXOS	EQU	140
SMALLMAPYOS	EQU	169
DIGIT0ULX	EQU	052
DIGIT0ULY	EQU	182
DIGIT1ULX	EQU	036
DIGIT1ULY	EQU	182
DIGIT2ULX	EQU	020
DIGIT2ULY	EQU	182
NITROULX	EQU	093
NITROULY	EQU	182
LAPULX	EQU	220
LAPULY	EQU	182
LAPOFULX	EQU	217
LAPOFULY	EQU	182
POINTS0ULX	EQU	283
POINTS0ULY	EQU	182
POINTS1ULX	EQU	267
POINTS1ULY	EQU	182

 
 

Constants for the Main Menu image 

STARTULX	EQU	90	the box coordinates for "Start" choice
STARTULY	EQU	54
STARTLRX	EQU	202
STARTLRY	EQU	78
STARTCHOSEN	EQU	0
EDITULX	EQU	90	for "Edit"
EDITULY	EQU	84
EDITLRX	EQU	202
EDITLRY	EQU	108
EDITCHOSEN	EQU	1
CONTULX	EQU	78	for "Controls"
CONTULY	EQU	116
CONTLRX	EQU	214
CONTLRY	EQU	140
CONTCHOSEN	EQU	2
CREDITULX	EQU	110
CREDITULY	EQU	144	for "Credits"
CREDITLRX	EQU	184
CREDITLRY	EQU	168
CREDITCHOSEN	EQU	3
EXITULX	EQU	95	for "Exit"
EXITULY	EQU	174
EXITLRX	EQU	198
EXITLRY	EQU	196
EXITCHOSEN	EQU	4

 
 

Map Constants

MAP0ULX	EQU	30	for "Map 0"
MAP0ULY	EQU	42
MAP0LRX	EQU	80
MAP0LRY	EQU	63
MAP0CHOSEN	EQU	0
MAP1ULX	EQU	30	for "Map 1"
MAP1ULY	EQU	66
MAP1LRX	EQU	80
MAP1LRY	EQU	87
EQU	1
MAP2ULX	EQU	30	for "Map2"
MAP2ULY	EQU	90
MAP2LRX	EQU	80
MAP2LRY	EQU	110
MAP2CHOSEN	EQU	2
MAP3ULX	EQU	30	for "Map3"
MAP3ULY	EQU	113
MAP3LRX	EQU	80
MAP3LRY	EQU	135
MAP3CHOSEN	EQU	3
MAP4ULX	EQU	30	for "Map 4"
MAP4ULY	EQU	138
MAP4LRX	EQU	80
MAP4LRY	EQU	160
MAP4CHOSEN	EQU	4
MAP5ULX	EQU	151	for Map "5"
MAP5ULY	EQU	42
MAP5LRX	EQU	200
MAP5LRY	EQU	63
MAP5CHOSEN	EQU	5
MAP6ULX	EQU	151	for Map "6"
MAP6ULY	EQU	66
MAP6LRX	EQU	200
MAP6LRY	EQU	87
MAP6CHOSEN	EQU	6
MAP7ULX	EQU	151	for Map 7
MAP7ULY	EQU	90
MAP7LRX	EQU	200
MAP7LRY	EQU	110
EQU	7
MAP8ULX	EQU	151	for Map 8
MAP8ULY	EQU	113
MAP8LRX	EQU	200
MAP8LRY	EQU	135
MAP8CHOSEN	EQU	8
MAP9ULX	EQU	151	for Map 9
MAP9ULY	EQU	138
MAP9LRX	EQU	200
MAP9LRY	EQU	160
MAP9CHOSEN	EQU	9
UPDATEULX	EQU	30	for "Update"
UPDATEULY	EQU	171
UPDATELRX	EQU	85
UPDATELRY	EQU	190
UPDATECHOSEN	EQU	10
BACKULX	EQU	151
BACKULYfor "Back" in the map editor menu	EQU	171
BACKLRX	EQU	200
BACKLRY	EQU	189
BACKCHOSEN	EQU	11
BACKPRACULX	EQU	90	for "Back" in the practice menu
BACKPRACULY	EQU	170
BACKPRACLRX	EQU	132
BACKPRACLRY	EQU	190
BACKPRACCHOSEN	EQU	12

 
 

Constants for Game Type Menu 

PRACULX	EQU	82	for "Practice
PRACULY	EQU	44
PRACLRX	EQU	169
PRACLRY	EQU	66
PRACCHOSEN	EQU	0
SINGLEULX	EQU	64	for "Single Player"
SINGLEULY	EQU	70
SINGLELRX	EQU	196
SINGLELRY	EQU	95
SINGLECHOSEN	EQU	1
NETULX	EQU	75	for "Networking"
NETULY	EQU	100
NETLRX	EQU	188
NETLRY	EQU	125
NETCHOSEN	EQU	2
BACKGTULX	EQU	194	for "Back"
BACKGTULY	EQU	134
BACKGTLRX	EQU	240
BACKGTLRY	EQU	154
BACKGTCHOSEN	EQU	3

 
 

Constants for all menus

NONECHOSEN	EQU	-1
BLUE	EQU	01
BLACK	EQU	00
GREY	EQU	21
WHITE	EQU	15

 
 

Other Constants

VIDSEG	EQU	0A000h	where VGA video memory starts
FADEMAXWAIT	EQU	40	time delay for a fade

 

Data Structures:

Packet struc
        Player_Num         db   ?
        Player_X           dw   ?
        Player_Y           dw   ?
        Player_Lap         db   ?
        Player_Dir         db   ?
        Player_SpcPressed  db   ?
Packet ENDS
 

Sound Data Structures

 XMIFILE Structure-
       Holds pertinent information needed to play
       a specific .XMI file

XMIFILE STRUCT
                FName                db      20 dup(0)       ; string max 20 chars.
                FLength               dw      ?                    ; total file length
                SequenceNum     dw      ?
XMIFILE ends

 XMIList Array
       An Array of XMIFILE structures which holds
       all available .XMI file information.

XMIList XMIFILE  {'breathe.xmi',47442,0},
                                       {'pulp.xmi',19814,0},
                                       {'knightrd.xmi',8024,0},
                                       {'miamivic.xmi',9374,0},
                                       {'missimp.xmi',29066,0},
                                       {'ecco.xmi',21746,0},
                                       {'smells.xmi',25618,0},
                                       {'shunter.xmi',9648,0},
                                       {'jungle.xmi',14420,0},
                                       {'schild.xmi',28262,0}

XMINum          dw      0                                      ; Specifies index for desired XMIFILE.

 DMAC Structure
       Holds the I/O port values for DMA Controller
       registers.

DMAC    STRUCT
                AddReg           dw      ?       ; 2
                PageReg          dw      ?       ; 83h
                LengthReg       dw      ?       ; 3
                MaskReg         dw      ?       ; 0Ah
                ModeReg        dw      ?       ; 0Bh
                ClrbReg           dw      ?       ; 0Ch
DMAC    ends

 SBC Structure
       Holds the settings of the SoundBlaster card
       configuration.

SBC     STRUCT
                DMAChannel         db      ?       ; 1
                BaseAdd               dw      ?       ; 220h
                IRQ                       db      ?       ; 07h
SBC     ends

 WAVFILE Structure
       Holds pertinent information needed to play
       a specific .WAV file

WAVFILE STRUCT
                FileName              db      20 dup(0)       ; string max 20 chars.
                FileLength             dw      ?               ; total file length
                BufLength             dw      ?               ; length minus header
                TimeConstant        db      ?               ; timeconstant of data
WAVFILE ends

 WAVList Array
       An Array of WAVFILE structures which holds
       all available .WAV file information.

WAVList WAVFILE {'screech.wav',2200,,165},
                                     {'engine.wav' ,42266,,211},
                                     {'carhn.wav',2000,,165},
                                     {'ow!.wav',4012,,165},
                                     {'build.wav',14314,,225},
                                     {'speed.wav',20000,,190},
                                     {'hd.wav',65535,,200},
                                     {'tap.wav',2331,,165},
                                     {'tone.wav',5242,,175},
                                    {'tone.wav',5242,,165},
                                     {'tone.wav',5242,,185}

Variables:

BetweenMaps         db 'Between.pcx',0   filename of pcx with screen for when between maps
TileFile                    db 'tiles.pcx',0           pcx with tiles for game
MenuFile                 db 'nMenu.pcx',0      pcx with main menu screen
MapEditorMenu      db 'mapwe.pcx',0      pcx with map editor screen
PracticeMenu          db 'mapne.pcx',0        pcx with practice menu screen
GameTypeMenu      db 'gtype.pcx',0         pcx with game type menu screen
ControlsScreen        db 'controls.pcx',0      pcx with controls screen
CreditScreen1         db 'credits1.pcx',0       pcxs with credit screens
CreditScreen2         db 'credits2.pcx',0
WinPic                    db 'win.pcx',0              pcxs for screens with win, lose, or tie
LosePic                   db 'lose.pcx',0             messages
TiePic                      db 'tied.pcx',0
CurrentSpeed          db  MINSPEED  ; variable to hold speed
DisplaySpeed0        db  0         a BCD representation of the speed
DisplaySpeed1        db  0
DisplaySpeed2        db  0
CurrentDir               db  0         Starting direction (0-15)
CollisionDir              db  0         A separate direction variable for collisions
SpeedStatus             db  0         Value for control of iteration of direction
NitroStatus               dw  0         Variable to take care of duration of nitroboost
CollisionWord          dw  0         Initialized for 0 colision directions.
FrictionStatus           dw  0         keeps a count for friction when sliding on rails
SlideStatus               dw  0         keeps a count for how far to slide
SlideDirection           db  0         direction you are sliding, even though you appear to
                                                 face a different direction
ImpactDir                 db  0         Direction after car impact
ImpactEffect             db  0         Amount fo time to move in the impact direction
MapCounter             db  0         counter for which map you are in

  General Opponent Vars.  For either AI or Network

OppXScreen            dw  0           for holding a value of X for calculation
OppYScreen            dw  0           for holding a value of Y for calculation
OppDir                     db  0           direction of opponent
OppLap                    db  0           number of laps opponent has completed
OppYMap                dw  0         Opp Y coord
OppXMap                dw  0         Opp X Coord
 

        AIVariables
AISpeed                    db  MINSPEED  ;Variable for AISpeed
AISpeedStatus           db  0         Used for acceleration in AI
AIMapOff                  dw  0         Map[] offset for AI car
AICountL                   db  0         Counting varibles for how many safe tiles
AICountR                   db  0         there are in five directions for decision making
AICountF                   db  0
AICountFL                 db  0
AICountFR                 db  0
AITotalCount             dw  0         Variable that holds the number of moves the AI will
                                                    make before it recalculates its turn.
AILapFlag                  db  0          Used for lap counter for AI

    Table holds the values for offsets in Map[] needed to 'Look' in these directions
AILookStupid             dw -80     North
                                   dw 0
                                   dw -79     Northwest
                                   dw 0
                                   dw +1      East
                                   dw 0
                                   dw +81     Southeast
                                   dw 0
                                   dw +80     South
                                   dw 0
                                   dw +79     SouthWest
                                   dw 0
                                   dw -1      West
                                   dw 0
                                   dw -81     NorthWest
                                   dw 0

OppSpcPressed  db 0                      did the opponent (networked player) press
                                                        his space bar
OppWins                     db 0              opponent's score
OppNumP                   db ?              opponents (network) id
OppCarColor              db 1
CarColor                     db 1
myWins                       db 0              my score

TileTable dw    (320*000)+(16*00)       ; grass tile
               dw    (320*000)+(16*01)       ; road tile
               dw    (320*000)+(16*02)       ; road/grass
               dw    (320*000)+(16*03)       ; road/grass
               dw    (320*000)+(16*04)       ; road/grass
               dw    (320*000)+(16*05)       ; road/grass
               dw    (320*000)+(16*06)       ; road/curb
               dw    (320*000)+(16*07)       ; road/curb
               dw    (320*000)+(16*08)       ; road/curb
               dw    (320*000)+(16*09)       ; road/curb
               dw    (320*000)+(16*10)       ; road/curb
               dw    (320*000)+(16*11)       ; road/curb
               dw    (320*000)+(16*12)       ; road/curb
               dw    (320*000)+(16*13)       ; road/curb
               dw    (320*000)+(16*14)       ; grass/curb
               dw    (320*000)+(16*15)       ; grass/curb
               dw    (320*000)+(16*16)       ; grass/curb
               dw    (320*000)+(16*17)       ; grass/curb
               dw    (320*000)+(16*18)       ; water
               dw    (320*000)+(16*19)       ; water/grass
               dw    (320*014)+(16*00)       ; water/grass
               dw    (320*014)+(16*01)       ; tree
               dw    (320*014)+(16*02)       ; tree
               dw    (320*014)+(16*03)       ; tree
               dw    (320*014)+(16*04)       ; tree
               dw    (320*014)+(16*05)       ; finish line
               dw    (320*014)+(16*06)       ; finish line
               dw    (320*014)+(16*07)       ; finish line
               dw    (320*014)+(16*08)       ; puddle
               dw    (320*014)+(16*09)
               dw    (320*014)+(16*10)
               dw    (320*014)+(16*11)
               dw    (320*129)+(16*00)           ; digit 0
               dw    (320*129)+(16*01)           ; digit 1
               dw    (320*129)+(16*02)           ; digit 2
               dw    (320*129)+(16*03)           ; digit 3
               dw    (320*129)+(16*04)           ; digit 4
               dw    (320*129)+(16*05)           ; digit 5
               dw    (320*129)+(16*06)           ; digit 6
               dw    (320*129)+(16*07)           ; digit 7
               dw    (320*129)+(16*08)           ; digit 8
               dw    (320*129)+(16*09)           ; digit 9
               dw    (320*129)+(16*10)        ; exit tile
               dw    (320*129)+(16*11)        ; save tile
               dw    (320*129)+(16*12)         ; 'G' tile
               dw    (320*129)+(16*13)         ; '0' tile
               dw    (320*28)+(16*0)
               dw    (320*28)+(16*1)        ; '291 Pro-Am'
               dw    (320*28)+(16*2)
               dw    (320*28)+(16*3)
               dw    (320*28)+(16*4)
               dw    (320*28)+(16*5)
               dw    (320*28)+(16*6)
               dw    (320*28)+(16*7)
               dw    (320*28)+(16*8)
               dw    (320*28)+(16*9)
               dw    (320*28)+(16*10)
               dw    (320*28)+(16*11)
               dw    (320*28)+(16*12)
               dw    (320*28)+(16*13)
               dw    (320*42)+(16*0)
               dw    (320*42)+(16*1)        ; '291 Pro-Am'
               dw    (320*42)+(16*2)
               dw    (320*42)+(16*3)
               dw    (320*42)+(16*4)
               dw    (320*42)+(16*5)
               dw    (320*42)+(16*6)
               dw    (320*42)+(16*7)
               dw    (320*42)+(16*8)
               dw    (320*42)+(16*9)
               dw    (320*42)+(16*10)
               dw    (320*42)+(16*11)
               dw    (320*42)+(16*12)
               dw    (320*42)+(16*13)
               dw    (320*56)+(16*0)
               dw    (320*56)+(16*1)        ; '291 Pro-Am'
               dw    (320*56)+(16*2)
               dw    (320*56)+(16*3)
               dw    (320*56)+(16*4)
               dw    (320*56)+(16*5)
               dw    (320*56)+(16*6)
               dw    (320*56)+(16*7)
               dw    (320*56)+(16*8)
               dw    (320*56)+(16*9)
               dw    (320*56)+(16*10)
               dw    (320*56)+(16*11)
               dw    (320*56)+(16*12)
              dw    (320*56)+(16*13)
              dw    (320*56)+(16*14)
              dw    (320*80)+(16*0)      ; 'Press Space Bar'
              dw    (320*80)+(16*1)
              dw    (320*80)+(16*2)
              dw    (320*80)+(16*3)
              dw    (320*80)+(16*4)
              dw    (320*80)+(16*5)
              dw    (320*80)+(16*6)
              dw    (320*80)+(16*7)
              dw    (320*80)+(16*8)

             dw    (320*014)+192      ; turbo tile
             dw    (320*014)+208      ; turbo tile
             dw    (320*014)+224      ; oil slick

CarTable  dw    (320*144)+(32*00)         car in direction 0
                dw    (320*144)+(32*01)         car in direction 1...
                dw    (320*144)+(32*02)
               dw    (320*144)+(32*03)
               dw    (320*144)+(32*04)
               dw    (320*144)+(32*05)
               dw    (320*144)+(32*06)
               dw    (320*144)+(32*07)
               dw    (320*172)+(32*00)
               dw    (320*172)+(32*01)
               dw    (320*172)+(32*02)
               dw    (320*172)+(32*03)
               dw    (320*172)+(32*04)
               dw    (320*172)+(32*05)
               dw    (320*172)+(32*06)
               dw    (320*172)+(32*07)
 

XCrop     dw    0           Value of X for cropping in DrawTile
YCrop     dw    0           Value of Y for cropping in DrawTile
EffWidth  dw    0           Value for counting width on cropped Tiles
EffHeight dw    0           Value for counting height on cropped Tiles

Map            db     4800 dup (1) ; will hold current map

MapFile        db     'MapX.map',0  ; X to be filled in later
MapFileOrg     db     'MapXOrg.map',0
fileHandle     dw      ?

XScrLC         dw      0            where to start printing tiles
YScrLC         dw      0
MapTileX       dw      0            where tile you are trying to draw
MapTileY       dw      0
XCarMap        dw      0           where the car is on the map
YCarMap        dw      0
PMXCnt         dw      0           count variable for Print Map
TileSelected   db      0             which tile to update map with (editor)
UACount        db      0
SMCount        db      0
Lap                db      1              which lap the car is on
lapStatus      db      0               has car gone over start line?
lapStatus1     db      0              has car passed checkpoints?
NumLapsTable   db      3        for map 0
                          db      3            map 1
                          db      3            map 2
                          db      3            map 3
                          db      3            map 4
                          db      3            map 5
                          db      3            map 6
                          db      3            map 7
                          db      3            map 8
                          db      3            map 9

CarMaxSpeed    dw      291      impossible speed
                              dw      291      Nitro speed
                              dw      110      MAXSPEED
                              dw       85
                              dw       65
                              dw       50
                              dw       40
                              dw       30
                              dw       20
                              dw       10
                              dw        0       MINSPEED

displaySpeed   dw       0
nitro                 db      9           how many nitros the player has
turbo                db      0           is a player over a turbo strip?
oil                    db      0           is a player over an oil strip?
puddle             db      0           is a player over a puddle?
mapNumber    db      0           which map is the current map
CurTile            db      0
 
 
 

Procedures:

Sound Functions - Written by Jon Moeller
 

•   ResetDSP
•  Purpose: Resets the SoundBlaster DSP. Before programming, the DSP must be initialized.
•  Inputs: SB.BaseAdd--Base Address of SoundBlaster card.
•  Outputs: AL--0 unsuccessful. AA successful.
•  Notes:
                      1) Write a 1 to the SoundBlaster RESET port (2x6h)
                      2) Wait for 3 micro-seconds
                      3) Write a 0 to the SoundBlaster RESET port (2x6h)
                      4) Read the data from the READ-BUFFER STATUS port (2xEh)
                          until bit 7 = 1
                      5) Poll for a ready byte (AAh) from the READ DATA port (2xAh).
                          Before reading the READ-DATA port, this is advisable.
 
•  DSPWrite
•  Purpose: Sends a command to the SoundBlaster DSP I/O port.
•  Inputs: SB.BaseAdd—Base Address of SB Card. Al—DSP command or data.
•  Outputs: DSP function, no return value.
•  Notes: Polls DSP Status port until bit 7 = 0. Writes value to port.

 DSPRead

• Purpose: Reads data from the DSP read port.
• Inputs: SB.BaseAdd—Base Address of SB Card
• Outputs: AL—Data read in.
• Notes: Polls DSP Status port until bit 7 = 1. Reads value from port.

 InstSBInt

•  Purpose: Installs the SoundBlaster interrupt vector.
•  Inputs: None.
•  Outputs: OldSBV = Far address read from interrupt vector table.
•  Notes: The new SB interrupt address is put into interrupt vector table.

 DeInstSBInt

•  Purpose: De-installs the SoundBlaster interrupt vector. Restores old vector.
•  Inputs: None.
•  Outputs: OldSBV = Far address read from interrupt vector table.
•  Notes: The original interrupt address is put into interrupt vector table.

 SBIntHandler

•  Purpose: ISR to handle IRQ generated by DSP at end of DMA sequence. Acknowledges both               DSP and PIC.
•  Inputs: SB.BaseAdd = Base address of SoundBlaster DSP.
                      SB.IRQ = SoundBlaster IRQ number.
•  Outputs: Sends IRQ acknowledge signals to DSP and PIC. Also sends EOI.

LoadSound

•  Purpose: Loads a sound file into a memory segment. Used for loading both WAV and XMI sounds.
•  Inputs: CS = Source segment of the sound file
                       DX = Source Offset of the sound file
                       ES = Destination segment of the buffer
                       DI = Destination offset of the buffer
                       CX = Length of the sound file data including the header.
•  Outputs: Sound segment contains the sound file.
• PlayBack
•  Purpose: Plays back a specified sound file.
•  Inputs: AX = Segment of the sound file
                       DI = Offset of the sound file
                       TimeConstant = Sound transfer rate
                       CX = Length of WAV file data including the header
• Outputs: Playback of a specified sound file.
•  Notes: 1) Load the sound data into memory (should be done prior).
                       2) Set up the DMA chip for the transfer.
                       3) Set up the DSP Time Constant to the sampling rate
                       4) Write DMA Type Value (14h) to the DSP.
                       5) Write DMA Length to the DSP (2 bytes, LSB first) where Length =
                            number of bytes to send - 1.

 PlayWAV

•  Purpose: This procedure loads a specified WAV file to a buffer, sets the
                          TimeConstant, and plays the sound file.
•  Inputs:   WavFile -- WAV file to be played.
•  Outputs: Plays the specified WAV file. Calls appropriate helper functions to set up playback.
•  ProgramDMA
•  Purpose: This procedure sets the DMA Controller for 8-bit single-cycle
                          DMA mode transfer.
•  Inputs: DX = Segment of the transfer data file
                      SI = Offset of the transfer data file
                      SB.BaseAdd = Base Address of SoundBlaster DSP
                      BufLength = Transfer Data Length
                      SB.DMAChannel = DMA Channel number
•  Outputs: Sets the DMAC up for the DMA transfer to the SB Card.
• SetMixerVolume
•                     Purpose: This procedure sets the Master, MIDI, DSP volume control registers
•                                     of the mixer chip according to a specified level.
•                     Inputs: SB.BaseAdd = Base I/O address of SoundBlaster DSP
•                     Outputs: Sets the MIDI and Master volume.

 GetSettings Procedure

•  Purpose: This procedure the base address of the SoundBlaster, the IRQ
•           number, and the DMA channel number according to the particular
•           setting of the computer in use.
•  Inputs: None
•  Outputs: -SB.BaseAdd = Base Address of SoundBlaster DSP
•           -SB.IRQ = IRQ number of the Sound Card
•           -SB.DMAChannel = DMA Channel number

 RegisterXMI

•  Purpose: This procedure registers a XMI file by address for playback.
•  Inputs: -CX = Segment of the XMI file
•             -BX = Offset of the XMI file
•              -SI = Low word of length of XMI data
•              -DI = High word of length of XMI file
•  Outputs: -AX = 0  Unable to register XMIDI data.
•             -AX = 1  XMIDI file registered resident. The XMIDI file was able
•                    to be held entirely in MIDPAK's internal buffer area.
•                    The application can throw away the memory associated
•                    with this XMIDI file because MIDPAK has made a copy of
•                    it for itself.
•             -AX = 2  XMIDI file was registeredto the application. The caller
•                    is responsible for making sure that this fixed memory
•                    address is always contains the data as passed.
•  Note: Uses the midpak driver function 704h (INT 66h).

 PlaySequenceXMI

•  Purpose: This procedure plays a sequence from the currently registered
•           XMI file.
•  Inputs: BX = Sequence number, numbered starting from zero
•  Outputs: -AX = 1  Sequence is being played.
•           -AX = 0  Sequence is not available.
•  Note: Uses the midpak driver function 702h (INT 66h).

 StopXMI

•  Purpose: This procedure stops the current XMI sequence.
•  Inputs: None
•  Outputs: Stops XMI playing
•  Note: Uses the midpak driver function 705h (INT 66h).

 ResumeXMI

•  Purpose: This procedure resumes playing a stopped sequence.
•  Inputs: None
•  Outputs: Resume playing the XMI.
•  Note: Uses the midpak driver function 70Bh (INT 66h).

 CheckXMI

•  Purpose: This procedure checks the status of XMI playing. If XMI
•           sequence has stopped then resumes playing a stopped sequence.
•  Inputs: None
•  Outputs: AX = 0 (Sequence stopped)
•                1 (Sequence is currently playing)
•                2 (Sequence is done playing)
•  Note: Uses the midpak driver function 70Ch (INT 66h).

 PlayXMI

•  Purpose: This procedure loads a specified XMI file to a buffer,
•           registers it and plays a specified sequence.
•  Inputs: -XMINum = File number of XMI file to be played.
• Outputs:  Plays the XMI file referenced by XMINum.

Networking Functions - Written by Mark Smith
 

 ServerMain

•  Purpose: Initializes Input/Output for server. Uses 80x50 text mode video.
•  Inputs: Number of players to initialize the server for and server name
•  Outputs: I/O screen for the server.
•  Notes: Allows the use of an external server on the network. Multiple servers can be run on the network at one time

•  ProcessData
•  Purpose: Takes data from the clients and processes the data. Determines what type of packet is sent from the client. The types of packets that can be sent are exit game, join game, and the general player packet.
•  Inputs: Packet Structure
•  Outputs: Updated game packet with all the new information added to it.
•  Notes: This is the main function used in the server. Makes use of the packet data structures.

• ClientSend
•  Purpose: When ever the player moves, or data needs to be updated the client must send data to the server. The client  uses ClientSend to send off the information to the server.
•  Inputs: Players X and Y coordinates, Player Direction, and Player Lap
•  Outputs: An initialized ClientPacket sent off to the server.

• ClientRecieve
•  Purpose: Client gets a MainPacket from the server containing all the data from all the players. The game main procedure handles the processing of the data.
•  Inputs: MainPacket data structure
•  Outputs: NONE

• ServerRecieve
•  Purpose: Server gets packet from client. ServerRecieve checks to see what type of packet it is. It then handles each type of packet accordingly
•  Inputs: ClientPacket data structure.
•  Outputs: None- If join game packet.
                          MainPacket- If Data packet received.

•  ServerSend
•  Purpose: To send a MainPacket data structure to all the clients participating in the game.
•  Inputs: None
•  Outputs: MainPacket sent to client

•  ClientMain
•  Purpose: Initializes the client for a multi-player game. Asks for the client's name and server name of game to join in.
•  Inputs: PlayerName and ServerName
•  Outputs: A Multiplayer game intialized

• AINetwork
•  Purpose: Controls opponent cars if not in networked game.
•  Inputs: Direction, speed, and position.
•  Outputs: Updates inputs.
•  ControlPicture
•     Purpose: Draw Control Picture
•     Inputs: none
•     Outputs: updates Screen buffer

 CreditPicture

•     Purpose: Draw Credit Picture
•     Inputs: none
•     Outputs: updates Screen buffer

 DrawAnima

• Purpsse: Blasts AnimationPad onto the ScreenBuffer.
• Inputs:   NONE
• Output:  ScreenBuffer onto video segment

 DrawRight

• Purpose: Blasts right side of ScreenBuffer onto the video page.
• Inputs: NONE
• Output: ScreenBuffer onto video segment

 MenuPractice

•      Purpose: This procedure provides the Practice Menu's graphical user interface.
•          It draws the menu screen and handles input from the mouse.  Works similarly
•          to the MainMenu, but with more selections.
•      Inputs: None
•      Outputs: None

 GetMGTSelection

•   Purpose: Figure out what is selected, if anything, and highlight it.  Works
•              similarly to GetMMSelection, but with different choices.
•   Inputs: none
•   Outputs: updates gameTypeChoice and buttonPressed

 GetPSelection

•   Purpose: Figure out what is selected, if anything, and highlight it.
•              Works simialrly to GetMMSelection, but with many more selections
•   Inputs: none
•   Outputs: updates pracMenuChoice and buttonPressed

 GetPSelection

•   Purpose: Figure out what is selected, if anything, and highlight it.
•              Works simialrly to GetMMSelection, but with many more selections
•   Inputs: none
•   Outputs: updates pracMenuChoice and buttonPressed

 MenuGameType

•      Purpose: This procedure provides the Game Type Menu's graphical user interface.
•               It draws the menu screen and handles input from the mouse.  Works
•               similarly to MainMenu, but with different choices.
•      Inputs: None
•      Outputs: None

NetMain

•        Purpose:   Run a networking game.  The user plays agaist another person who
•                   is at a different computer.  Both players are taken through maps
•                   0 through 9 for a complete game.  Either player can abort his game
•                   at any time by pressing esc.
•        Inputs: Keyboard
•        Outputs: Creates a networked game
• CreatePacket
•     Purpose: To load the right information into the packet
•     Inputs: All the player Data and structures
•     Outputs: An updated Player Structure

Graphics Functions - Written by Preston White

DrawTile

• Purpose:  This function takes in an X, Y value and a tile number.  Cropping is
•                  required since we won't be drawing tiles perfectly centered.  The tile number
•                  will get the offset in TileMap to print to the screen.
• Inputs:  X - X location on Screen (Not map)
•               Y - Y Location on Screen (Not map)
•                TNum - Tile Number from Map* array
• OutPut:  Writes tile to ScreenBuffer

InitBuf

• Purpose: Initializes the ScreenBuffer to Black
• Inputs: NONE
• Output: ScreenBuffer initialized with zero (black)
•  LocalControl
• Purpose: This function coordinates the Speed and direction controls, as well as
•                any other timing tricks that need to occur for smooth game play
•                This function is huge due to the number of considerations made when
•                 controlling the car.
• Input: CurrentDir
•            CollisionDir
•            SpeedStatus
•            NitroStatus
•            CollisionWord
•            FrictionStatus
•            SlideStatus
•            SlideDirection
•            ImpactDir
•            ImpactEffect
• Output: Modifies all
• SpeedControl
•    Purpose:This procedure controls the acceleration and deceleration of the car.
•                  Nitrous, and puddles were added later. If a special case is encountered
•                  it is handled accordingly, otherwise  acceleration is slowed down by the
•                  speedTable which holds the values of delays to be used between speed levels
•   Inputs: AccelPressed, Curtile, currentSpeed, nitropressed, nitroStatus
•   Output: New values for currentSpeed

 LookAround

• Purpose:  This function looks in all of the 16 directions before the car is drawn
•                to see if there are any obsticals in the way.  It uses precalculated
•                offsets to "look" at the screen buffer and find any pixels that
•                indicate a collision condition.  A status word "CollisionWord" will tell
•                if the next move he car will make is  "Safe"
• Inputs: Looks at Screenbuffer bytes
• Output:Collisionword with each bit set to 0 for safe, 1 for bad..

CarPerspective

•        This function calculates the screen location of the othercars for the
•        game.  Whether they be network games or single player games vs. the AI
•        this function will also decide if a collision has occured between two
•        cars and set up the impact variable so the local car will move accordingly
• Inputs: The Opponents position on the map, local position on the map
• Output: Modifies ImpactEffect and ImpactDirection so the car will know where
•         to slide and how far to slide.

AILocal

• Purpose: This AI is going to pretend to drive around the track using modified
•                 components of LocalControl.  It looks in front of itself in five directions
•                 and selects which direction has the most open squares, then it proceeds in
•                 that direction until it has gone as far as TotalCount suggests, it then
•                 looks again and decides where to go from there.
• Inputs: Reads all AI variables.
• OutPuts: OppXMap, OppYMap
•                 AILapFlag

DrawTile

• Purpose: This function takes in an X, Y value and a tile number.  Cropping is
•                 required since we won't be drawing tiles perfectly centered.  The tile number
•                will get the offset in TileMap to print to the screen.
• Inputs:  X - X location on Screen (Not map)
•               Y - Y Location on Screen (Not map)
•               TNum - Tile Number from Map* array
• OutPut:  Writes tile to ScreenBuffer

DrawScreen

• Purpose: Blasts ScreenBuffer onto the video page.
• Inputs: NONE
• Output: ScreenBuffer onto video segment

DrawSplash

• Purpose: This function draws a PCX file to the screen buffer
• Inputs:    A file loaded in the TileMap segment
• Output:   Places values in screen buffer

DrawCar

• Purpose: Draw cars to the viewable screen. Clipping is used for any car
•                 that won't fit on the screen.
• Inputs: Color, Direction of car, X on the map, Y on the map
•               X on the screen and Y on the screen.
• Outputs: Draws to Screenbuffer the car, and updats the 'little map'
•                on the console.

InstKey

•        This procedure installs MyKeyHandler instead of the default key handler.
• Inputs:None
• Output: oldKeyV-offset to original key handler

DeInstKey

•       Restores OldKeyV as the default Keyhandler routine.
• Inputs: OldKeyV
• Output: None
• Author: Preston White

MyKeyHandler

•  Puspose:  Sets escPressed to one (1) if the escape key is pressed.
•                   Sets spcPressed to one(1) if the space bar is pressed
•                   Sets XMINum for sound on keys 0-9
•                   Sets TurnPressed to appropriate values for arrow keys
•                   Sets AccelPressed for whether or not 'control' is pressed
•                   Sets NitroPressed for the 'alt' button to control turbo
•                   Sends ACK and end-of-intterrupt.
• Inputs: None
• Output: escPressed, spcPressed

 InstTimer

•        Saves default interrupt vector in OldTimerV.
•        Points the timer interrupt to MyTimerHandler.
•        Configures timer chip to send a signal 72 times per second.
• Input:None
• Output: oldTimerV

 DeInstTimer

•  Purpose: Restores OldTimerV as the default timer routine.
•                  Reconfigures the timer chip to send a signal 18 times per second.
• Inputs: OldTimerV
• Output: None

MyTimerHandler

•  Purpose: Increments timerCount each time that it is called.
•                 Calls OldTimerV 18 times per second (i.e., every fourth time).
•                 Sends ACK and end-of-intterrupt.
• Inputs:None
• Output:Increments all timer variables

StartMain

•     Purpose: This procedure controls the flow of the intro to the game,
•              and leads user to the main menu.
•     Inputs: None
•     Outputs: Creates an introduction
•  IntroInitBuf

•      Purpose: Initializes only the middle of the screenbuffer to all black
•                pixels
•      Inputs: none
•      Outputs: a blank middle section of screenBuffer

InitBotBuf

•      Purpose: Initializes only the bottom of the screenbuffer to all black
•                pixels
•      Inputs: none
•      Outputs: a blank lower screen buffer

GetLeftCornter

•     Purpose: Finds where to start upperleft tile in map, and the tile in the map which is in
•               the center of the screen
•     Inputs:
•         X : XCarMap     where the car is on the map
•         Y : YCarMap
•     Outputs : updates mapTileX,mapTileY,XScrLC,YScrLC
•     Updates:
•         XScrLC         where the upper left tile starts in relation
•        YScrLC