I will be going through the Main Program subroutine line-by-line
and explaining what each line of code is doing and how it affects the outcome
of the program.
38 *********************************************
This is just a comment line
breaker and helps to space out each subroutine or section of code.
39 *****
MAIN PROGRAM *************
This is the main comment line
telling the reader where the starting section of code begins for the main
program. Remember; an * is what
represents a comment field.
40 BEGIN JSR PGM
Lines 40 thru 82 consist of
the main subroutine, and the header name of this subroutine is called
BEGIN. For the program to jump to
specific subroutines within the program it needs to see the header name. Line 40 is where the program starts and goes
from line to line in a top-down fashion telling the program to “[J]ump to [S]ub[R]outine” with the header PGM. Once the subroutine PGM finishes it will
return back to this line and continue down the rest of the program. Subroutine PGM is where the screen is blanked out and cleared of text and
graphics. PGM will be explained in more detail later in the blog.
41 JSR INITIAL
After subroutine PGM
completes and returns, line 41 tells the program to “[J]ump
to [S]ub[R]outine”
to the subroutine with the header INITIAL. Subroutine INITIAL is where all starting variables for the map, character, and
tiles graphics are initialized to a value of [0] or predetermined values. INITIAL
will be explained in more detail later in the blog.
42 START8 JSR PREMAP
After subroutine INITIAL
completes and returns, line 42 tells the program to “[J]ump
to [S]ub[R]outine”
to the subroutine with the header PREMAP. Line 42 also has a header name so it can also
be referenced and can be called to run just line BEGIN was. When the game starts and your character is
placed on the world map this region is defined ahead of time by a ROW and
COLUMN value. Subroutine PREMAP helps define where the ULTIMA 1 world
map will start from based on the row number it see, which is predefined in the
INITIAL subroutine when the program starts.
The world map is made up of 84 ROWS from top to bottom. This row number is used in PREMAP to search
through the map address for certain values to obtain the starting map corner
location. Subroutine PREMAP will be explained in more detail
later in the blog. START8 is a
subroutine within BEGIN that is used when after the main program starts and all
variables have been initialized for the first time, once the ULTIMA map needs
to be redrawn again you can’t have the program call BEGIN or it would reset
everything, so START8 let you redraw the map but with updated character
movements and current variable.
43 JSR PREPROW
After subroutine PREMAP
completes and returns, line 43 tells the program to “[J]ump
to [S]ub[R]outine”
to the subroutine with the header PREPROW. Since we know the world map is 84 rows deep,
it is also made up of numerous columns. Also, because memory usage is critical
on the APPLE computer I had to figure out a way to compress the map data that
would be read to figure out the number of columns and tiles which make up the
entire world map width. PREPMAP is used
to obtain the specific number of data strings which are represented in each
separate map row. Subroutine PREPROW will be explained in more
detail later in the blog.
44 JSR FRNTBYT
After subroutine PREMAP
completes and returns, line 44 tells the program to “[J]ump
to [S]ub[R]outine”
to the subroutine with the header FRNTBYT. FRNTBYT is used to help uncompress the map
data so it can read a HIGH byte and a LOW byte to figure out the number and
type of tile which is used in the given ROW of the world map. Subroutine FRNTBYT will be explained in more detail later in the blog.
45 JSR TILEPLC
After subroutine FNRTBYT
completes and returns, line 45 tells the program to “[J]ump
to [S]ub[R]outine”
to the subroutine with the header TILEPLC. Earlier
in my BLOG I explained how since I was trying to save memory by compressing the
map data, I had to come up with a way to compress the way the number of tiles
and type of tiles that were being used on each row of the world map. This compression process uses a number of
subroutines to help uncompress the map data and put the number of tile and type
of tiles in temporary storage memory regions.
The subroutine TILEPLC uses the HIGH and LOW byte values found in
FRNTBYT and breaks it down so it counts out each tile type on the world map row
and stores it in an array variable. This
array stores each map tile from the starting row and column up to the next 20
tiles because the screen only represents 20 graphic tiles at a time. Subroutine TILEPLC will be explained in more detail later in the blog.
46 LDA #$00
After subroutine TILEPLC
completes and returns, line 46 is used to “[L]oa[D] the [A]ccumulator”
or register A with the HEX value of zero!
So you could think of it as [A] holding the value of [0].
On the Apple 6502, there are
six instructions that load and store
the registers.
These are:
LDA v Load the A register with v
LDX v Load the X register with v
LDY v Load the Y register with v
STA v Store the A register with v
STX v Store the Y register with v
STY v Store the Y register with v
Here LD stands for “LOAD”; ST
stands for “STORE”; and v can be and cell in the main memory.
47 INC ROWNO
Line 47 is used to “[INC]rement” whatever value is in ROWNO by 1! This is to get ready to help draw the next
row of graphics tile on the screen.
There are six instructions on the 6502 which increment and
decrement:
INC v increment v
DEC v decrement v
INX Increment the X register
DEX Decrement
the X register
INY Increment
the Y register
DEY Decrement
the Y register
Here v can be any cell in the
main memory, as before. Note that we
cannot increment or decrement, the A register!!!
48 JSR LOADMAP
Line 48 tells the program to
“[J]ump to the [S]ub[R]outine” with the header LOADMAP. This subroutine take the [20] row tiles that
will be displayed on the screen and stores them into a MAPSTORE array, to be
used after all 200 tiles have been stored and are ready for the screen.
Subroutine LOADMAP will be explained
in more detail later in the blog.
49 INC CHKER1
Line 49 is used to “[INC]rement” whatever value is in CHKER1 by 1! This
variable is part of an incremental counter within the LOADMAP subroutine to
check when all ten screen line of tiles have been stored in the MAPSTORE array.
50 LDA CHKER1
Line 50 is used to “[L]oa[D] the [A]ccumulator” or register A with the value from CHKER1
after it has been incremented in line 49.
51 CMP #$0A
Once the value of CHKER1 is
loaded into register A, Line 51 is used to “[C]o[MP]are” what is in register A to the HEX value of $0A
or 10. The value of 10 is the number of
horizontal line on the screen that will hold graphic tiles.
52 BLT
START8
Line 52 is used to “[B]ranch on [L]ess [T]han”, which means that as long as the value in
register A is less than [<] 10 it will continue to call the subroutine with
the header START8. Once the value of A
is greater than [>] 10 it will bypass line 52 and continue to line 53.
53 LDA #$00
Line 53 is used to “[L]oa[D] the [A]ccumulator” with the HEX value of zero! So you could think of it as [A] holding the
value of [0].
54 STA CHKER1
Line 54 is used to “[ST]ore the [A]ccumulator” which has the value of zero into the
variable CHKER1. So the variable CHKER1
will equal zero after line 54 completes.
55 JSR CHARTILE
Line 55 tells the program to
“[J]ump to the [S]ub[R]outine” with the header CHARTILE. This subroutine is used to load the type of
character graphic tile that will be displayed on the screen, such as the fighter,
the horse, the cart, etc… Subroutine CHARTILE will be explained in more
detail later in the blog.
56 LDX #$00
Line 56 is used to “[L]oa[D] the [X] register” with the HEX value of zero! So you could think of it as [x] holding the
value of [0].
57 STX MAPCOUNT
Line 57 is used to “[ST]ore the [X] register”
which holds the HEX value of zero into the variable MAPCOUNT! Remember that MAPCOUNT is going to be used as
a step counter in another subroutine. So
you could think of it as, variable MAPCOUNT is equal to the value of [0].
58 START1
JSR LOADSHP
Line 58 tells the program to
“[J]ump to the [S]ub[R]outine” with the header LOADSHP. Line 58 also has a header name so it can also
be referenced and can be called to run just line START8 was. Subroutine LOADSHP takes each map address stored into MAPSTORE which represent
a single graphic tile and start to recreate the tile from individual bytes and
once it creates the entire shape it then draws it to the screen from top to
bottom and left to right! Subroutine LOADSHP will be explained in more
detail later in the blog. START1 is a SUB-subroutine
OR “a subroutine within a subroutine” which is also within the BEGIN subroutine
that is used to load each shape into a tile graphic and draw it to the screen
for each of the 20 graphics tiles shown across the screen. START1 is part of a loop that when it finishes
drawing the 20 tiles it continues on to the rest of the main subroutine.
59 JSR DRAW
Line 59 tells the program to
“[J]ump to the [S]ub[R]outine” with the header DRAW. This subroutine is used to DRAW the actual
graphic tile to the screen. Since each
graphic tile in Ultima is made up of two bytes wide and two byte deep, the DRAW
subroutine draws the two byte right next to each other one line at a time until
it draws the entire column of 10 tiles or 160 graphic lines down the screen. Subroutine DRAW will be explained in more detail later in the blog.
60 INC LINEA
Line 60 is used to “[INC]rement” whatever value is in LINEA by 1! This
variable LINEA is part of an incremental counter within the START1 SUB-subroutine
of the subroutine BEGIN that counts up to 20 to check for each ROW of graphic
tiles on the screen as the DRAW subroutine is called. Once LINEA reaches a certain value the counter
check will be completed and the next statement will be bypassed.
61 LDA LINEA
Line 61 is used to “[L]oa[D] the [A]ccumulator” with the value that is in variable LINEA! So you could think of it as [A] holding the
value of variable LINEA.
62 CMP #$14
Once the value of LINEA is
loaded into register A, Line 62 is used to “[C]o[MP]are” what is in register A to the HEX value of $14
or 20. The value of 20 is the number of
horizontal lines the graphics tiles, which are two bytes high, are drawn on. Remember, a graphic tile is 2x2 bytes, so it
is two bytes high and there are 10 graphic tiles that run from the top of the
screen down to the bottom of the screen.
63 BLT
START1
Line 63 is used to “[B]ranch on [L]ess [T]han”, which means that as long as the value in
register A is less than [<] 20 “in this case” it will continue to call the
subroutine with the header START1. Once
the value of A is greater than [>] 20 it will bypass line 63 and continue to
line 64.
64 RTS
Line 64 is used to “[R]e[T]urn from [S]ubroutine”, which means that everything in this
subroutine has completed and will be returned back the statement line which
called it. In this case, this means
since this is the Main Program Subroutine “BEGIN”, this return statement will END
the program altogether.
Joe
