Tiles

Now that the ui is on screen I’d like to fill it with something. Sometime ago I did a tileset for character potraits so let’s take that and find a way to get it on screen.

Importing the file

First off I export the tile and char set as asm data and import it into my code at address $a000 (the space normally blocked by the basic rom) for now.

Copy to Clipboard

Then I add some constants that I am going to need for easy access.

Copy to Clipboard

Now I reserve an address space for all pc data and store the tile id for each potrait there.

Copy to Clipboard

I am going to need some tables to help me find all the addresses for the tiles, chars, and screen addresses. So I create manual tables for the row starting points and offsets and use Kick Assemblers for function to generate the addressing tables.

Copy to Clipboard

portrait_bitmap_rows_LSB:                       // starting bitmap rows of pc portraits
    .byte < BITMAP_ADDR+(17*40)*8
    .byte < BITMAP_ADDR+(17*40)*8
    .byte < BITMAP_ADDR+(21*40)*8
    .byte < BITMAP_ADDR+(21*40)*8
    .byte < BITMAP_ADDR+(21*40)*8

portrait_bitmap_rows_MSB: 
    .byte > BITMAP_ADDR+(17*40)*8
    .byte > BITMAP_ADDR+(17*40)*8
    .byte > BITMAP_ADDR+(21*40)*8
    .byte > BITMAP_ADDR+(21*40)*8
    .byte > BITMAP_ADDR+(21*40)*8

portrait_rows_bitmap_offset_LSB:                // bitmap offset of pc potraits
    .byte < 30*8
    .byte < 34*8
    .byte < 28*8
    .byte < 32*8
    .byte < 36*8

portrait_rows_bitmap_offset_MSB:
    .byte > 30*8
    .byte > 34*8
    .byte > 28*8
    .byte > 32*8
    .byte > 36*8

portrait_color_rows_LSB:                        // starting screen rows of pc portraits
    .byte < SCREEN_RAM_BANK_1+(17*40)
    .byte < SCREEN_RAM_BANK_1+(17*40)
    .byte < SCREEN_RAM_BANK_1+(21*40)
    .byte < SCREEN_RAM_BANK_1+(21*40)
    .byte < SCREEN_RAM_BANK_1+(21*40)

portrait_color_rows_MSB:
    .byte > SCREEN_RAM_BANK_1+(17*40)
    .byte > SCREEN_RAM_BANK_1+(17*40)
    .byte > SCREEN_RAM_BANK_1+(21*40)
    .byte > SCREEN_RAM_BANK_1+(21*40)
    .byte > SCREEN_RAM_BANK_1+(21*40)

portrait_rows_offset:                           // screen offset of pc potraits
    .byte 30
    .byte 34
    .byte 28
    .byte 32
    .byte 36

portraitTilePos_LSB:                            // table of pc portrait tile position addresses
    .for(var i=0; i<PORTRAIT_TILESET_SIZE; i++) {
        .byte < (portraits_chartileset_data+i*PORTRAIT_TILE_SIZE)
    }

portraitTilePos_MSB:
    .for (var i=0; i<PORTRAIT_TILESET_SIZE; i++) {
        .byte > (portraits_chartileset_data+i*PORTRAIT_TILE_SIZE)
    }

portraitCharPos_LSB:                            // table of pc potrait char position addresses
    .for (var i=0; i<PORTRAIT_CHARSET_SIZE; i++) {
        .byte < (portraits_charset_data+i*8)
    }

portraitCharPos_MSB:
    .for (var i=0; i<PORTRAIT_CHARSET_SIZE; i++) {
        .byte > (portraits_charset_data+i*8)
    }

Now let’s start with the code. First I write a short loop for traversing through all the portrait positions and getting the tile id for that position.

Copy to Clipboard

For drawing the portrait I need to get the current tile, starting position, char, and color data. So first off I start by getting the tile height and current potrait number.

Copy to Clipboard

Now I read the starting positions and tile addresses from my tables based on the current potrait number.

Copy to Clipboard

!get_rows:
        lda portrait_bitmap_rows_LSB, y         // load starting bitmap row
        sta ZP_BITMAP_ADDR_LO                   // and store in zeropage
        lda portrait_bitmap_rows_MSB, y
        sta ZP_BITMAP_ADDR_HI
        clc                                     // clear any carry that may remain
        lda portrait_rows_bitmap_offset_LSB, y  // load horizontal offset of portrait
        adc ZP_BITMAP_ADDR_LO                   // add row address
        sta ZP_BITMAP_ADDR_LO                   // and store in zeropage
        lda portrait_rows_bitmap_offset_MSB, y
        adc ZP_BITMAP_ADDR_HI
        sta ZP_BITMAP_ADDR_HI
        lda portrait_color_rows_LSB, y          // load starting screen ram row for color
        sta ZP_SCREEN_ADDR_LO                   // and store in zeropage for screen and color ram
        sta ZP_COLOR_ADDR_LO
        lda portrait_color_rows_MSB, y
        sta ZP_SCREEN_ADDR_HI
        clc                                     // clear any carry that may remain
        lda portrait_rows_offset, y             // load horizontal offset of portrait
        adc ZP_SCREEN_ADDR_LO                   // add row address
        sta ZP_SCREEN_ADDR_LO                   // and store in zeropage
        sta ZP_COLOR_ADDR_LO
        lda ZP_SCREEN_ADDR_HI
        adc #0
        sta ZP_SCREEN_ADDR_HI
        clc
        adc #$94                                // add offset to screen ram to get color ram
        sta ZP_COLOR_ADDR_HI
        ldy ZP_TILENO                           // load current tile number to y
        lda portraitTilePos_LSB, y              // get tile position in ram from tile number
        sta ZP_TILE_ADDR_LO                     // and store in zeropage
        lda portraitTilePos_MSB, y
        sta ZP_TILE_ADDR_HI

To get the address of the char data I read the current tile data from the address I just calculated and use it to look up my character table. As I can use the same index to load the color data addresses I do that as well.

Copy to Clipboard

I now have all the addresses I need to start actually drawing the tile. First I iterate through the tile from left to right and store the color information at its respective screen addresses. After that is done I load the portrait pixel height minus one (0 to 23) to setup the loop through the actual char data.

Copy to Clipboard

I iterate through all the char data and draw it on screen until I reach the end, or rather the beginning.

Copy to Clipboard

After the row has been successfully drawn I calculate the next screen and tile addresses and repeat the entire process until the tileheight stored in the zeropage reaches 0.

Copy to Clipboard

add_row_to_address:
        clc                                     // clear carry
        lda #40                                 // load 40 (cols per row to get next screen row)
        adc ZP_SCREEN_ADDR_LO                   // add to current screen and color addr
        sta ZP_SCREEN_ADDR_LO
        sta ZP_COLOR_ADDR_LO
        lda ZP_SCREEN_ADDR_HI                   
        adc #0
        sta ZP_SCREEN_ADDR_HI
        clc                                     // clear carry
        adc #$94
        sta ZP_COLOR_ADDR_HI
        lda #PORTRAIT_TILE_WIDTH                // load tile width of portrait
        adc ZP_TILE_ADDR_LO                     // and add to current tile address
        sta ZP_TILE_ADDR_LO                     // store in zeropage
        lda #0
        adc ZP_TILE_ADDR_HI
        sta ZP_TILE_ADDR_HI
        lda #$40                                // load $40 (64)
        adc ZP_BITMAP_ADDR_LO                   // and add to LSB of bitmap address
        sta ZP_BITMAP_ADDR_LO                   // store in zeropage
        clc                                     // clear carry
        lda #$1                                 // load $1 (256 as it is the MSB)
        adc ZP_BITMAP_ADDR_HI                   // and add to MSB of bitmap address resulting in 320
        sta ZP_BITMAP_ADDR_HI                   // store in zeropage
        dec ZP_TILEHEIGHT                       // decrease tileheight stored in zeropage
        bne !get_char_data-                     // as long as it is not 0 get new char data
        rts

Compiling the code

After compiling the code the portraits have been added in their propper places.

And as allways I run it on TheC64 as well.

And once again the complete code listing.

Copy to Clipboard

#import "includes/constants.asm" // import constants
.const SCREEN_RAM_BANK_1 = SCREEN_RAM + $4000
.const SCREEN_RAM_VIC = $5c00
.const BITMAP_ADDR = $6000

// Zeropages
.const ZP_TEMP = $52
.const ZP_TILENO = $02
.const ZP_TILEHEIGHT = $2a
.const ZP_CHARDATA = $52
.const ZP_BITMAP_ADDR_LO = $FB
.const ZP_BITMAP_ADDR_HI = $FC
.const ZP_SCREEN_ADDR_LO = $59
.const ZP_SCREEN_ADDR_HI = $5a
.const ZP_COLOR_ADDR_LO = $04
.const ZP_COLOR_ADDR_HI = $05
.const ZP_TILE_POS_X = $92
.const ZP_TILE_POS_Y = $93
.const ZP_CHAR_ADDR_LO = $94
.const ZP_CHAR_ADDR_HI = $95
.const ZP_TILE_ADDR_LO = $9B
.const ZP_TILE_ADDR_HI = $9C
.const ZP_COLOR = $c003
.const ZP_COLOR_2 = $A3

// Portrait Tileset
.const PORTRAIT_TILESET_SIZE = 72
.const PORTRAIT_CHARSET_SIZE = 46
// Tilesize
.const PORTRAIT_TILE_HEIGHT = 3
.const PORTRAIT_TILE_WIDTH = 3
.const PORTRAIT_TILE_SIZE = PORTRAIT_TILE_HEIGHT * PORTRAIT_TILE_WIDTH
// Pixelsize
.const PORTRAIT_PIXEL_HEIGHT = 24
.const PORTRAIT_PIXEL_WIDTH = 24
.const PORTRAIT_PIXEL_SIZE = PORTRAIT_PIXEL_HEIGHT * PORTRAIT_PIXEL_WIDTH

BasicUpstart2(main)

*=$0810 "CODE"                  // code address start
main:
    jsr init
    jmp game_loop

init:
    jsr set_vic_bank            // switch vic bank to $4000
    jsr set_basic_to_ram        // clear basic rom from memory freeing $a000 - $c000 (8kb)
    jsr clr_screen
    jsr init_screen
    jsr load_bitmap_color_data
    jsr draw_portraits
    rts

set_vic_bank:
    lda #$02
    sta $dd00
    rts

set_basic_to_ram:
    lda $01                     // load address $01
    and #$6                     // do bitwise and to disable basic rom
    sta $01                     // store back to ram
    rts

clr_screen:
    jsr KERNAL_CLEAR_SCREEN     // call kernal address for clear screen
    rts

init_screen:
    lda #%000011111
    sta VIC_MEM_POINTERS        // set memory pointer to bitmap data at $6000, char data at $7000, and screenram at $4400

lda VIC_CONTROL_REG_1       // load VIC-II register 17
    ora #$20                    // bitwise or compare %1000000 to activate bitmap mode
    sta VIC_CONTROL_REG_1       // store to VIC-II register 17

lda VIC_CONTROL_REG_2       // load VIC-II register 22
    ora #$10                    // bitwise or compare %10000 to activate multicolor mode
    sta VIC_CONTROL_REG_2       // store VIC-II register 22

lda border_color            // setup colors
    sta BORDER_COLOR
    lda background_color
    sta BACKGROUND_COLOR
    rts

load_bitmap_color_data:
    ldx #0
    !loop:
        lda screenram_color_data, x         // load first byte of color data
        sta SCREEN_RAM_BANK_1, x
        lda color_ram_data, x
        sta COLOR_RAM, x
        lda screenram_color_data+$100, x    // load second byte of color data
        sta SCREEN_RAM_BANK_1+$100, x
        lda color_ram_data+$100, x
        sta COLOR_RAM+$100, x
        lda screenram_color_data+$200, x    // load third byte of color data
        sta SCREEN_RAM_BANK_1+$200, x
        lda color_ram_data+$200, x
        sta COLOR_RAM+$200, x
        lda screenram_color_data+$300, x    // load fourth byte of color data
        sta SCREEN_RAM_BANK_1+$300, x
        lda color_ram_data+$300, x
        sta COLOR_RAM+$300, x
        inx
        bne !loop-
    rts

draw_portraits:
    ldy #0
    sta ZP_TEMP
    !loop:
        ldy ZP_TEMP
        lda pc_portraits, y
        sta ZP_TILENO
        jsr draw_portrait
        inc ZP_TEMP
        lda ZP_TEMP
        cmp #5
        bne !loop-
    rts

draw_portrait:
    lda #PORTRAIT_TILE_HEIGHT                   // load tile height of portrait
    sta ZP_TILEHEIGHT                           // store in zeropage
    ldy ZP_TEMP                                 // load current portrait number
    !get_rows:
        lda portrait_bitmap_rows_LSB, y         // load starting bitmap row
        sta ZP_BITMAP_ADDR_LO                   // and store in zeropage
        lda portrait_bitmap_rows_MSB, y
        sta ZP_BITMAP_ADDR_HI
        clc                                     // clear any carry that may remain
        lda portrait_rows_bitmap_offset_LSB, y  // load horizontal offset of portrait
        adc ZP_BITMAP_ADDR_LO                   // add row address
        sta ZP_BITMAP_ADDR_LO                   // and store in zeropage
        lda portrait_rows_bitmap_offset_MSB, y
        adc ZP_BITMAP_ADDR_HI
        sta ZP_BITMAP_ADDR_HI
        lda portrait_color_rows_LSB, y          // load starting screen ram row for color
        sta ZP_SCREEN_ADDR_LO                   // and store in zeropage for screen and color ram
        sta ZP_COLOR_ADDR_LO
        lda portrait_color_rows_MSB, y
        sta ZP_SCREEN_ADDR_HI
        clc                                     // clear any carry that may remain
        lda portrait_rows_offset, y             // load horizontal offset of portrait
        adc ZP_SCREEN_ADDR_LO                   // add row address
        sta ZP_SCREEN_ADDR_LO                   // and store in zeropage
        sta ZP_COLOR_ADDR_LO
        lda ZP_SCREEN_ADDR_HI
        adc #0
        sta ZP_SCREEN_ADDR_HI
        clc
        adc #$94                                // add offset to screen ram to get color ram
        sta ZP_COLOR_ADDR_HI
        ldy ZP_TILENO                           // load current tile number to y
        lda portraitTilePos_LSB, y              // get tile position in ram from tile number
        sta ZP_TILE_ADDR_LO                     // and store in zeropage
        lda portraitTilePos_MSB, y
        sta ZP_TILE_ADDR_HI
        !get_char_data:
            ldy #0                              // load 0 into y register
            lda (ZP_TILE_ADDR_LO), y            // to get content of address stored in zeropage
            tay                                 // transfer content to y register
            lda portraitCharPos_LSB, y          // load address of char from set stored in tile address
            sta ZP_CHAR_ADDR_LO                 // store in zeropage
            lda portraitCharPos_MSB, y
            sta ZP_CHAR_ADDR_HI
            lda portraits_charset_attrib_L1_data, y // load color data for color ram from charset
            sta ZP_COLOR                            // store in zeropage
            lda portraits_charset_attrib_L2_data, y // load color data for screen ram from charset
            sta ZP_COLOR_2                          // store in zeropage
            ldy #PORTRAIT_TILE_WIDTH-1              // load tile width of portrait minus 1 (0 - 3) to y register
            !color:
                lda ZP_COLOR                        // load color data for color ram
                sta (ZP_COLOR_ADDR_LO), y           // and store at calculated address
                lda ZP_COLOR_2                      // load color data for screen ram
                sta (ZP_SCREEN_ADDR_LO), y          // and store at calculated address
                dey                                 // decrease tile width to get next offset
                cpy #$ff                            
                bcc !color-                         // as long as y is above zero repeat
                ldy #PORTRAIT_PIXEL_HEIGHT-1        // load pixel height of portrait minus 1 (0 - 23) to y register
                !loop_char:
                    lda (ZP_CHAR_ADDR_LO), y        // load char data at offset
                    sta (ZP_BITMAP_ADDR_LO), y      // and store to bitmap address
                    dey                             // decrease tile height
                    cpy #$ff
                    bcc !loop_char-                 // as long as y is above zero repeat
        add_row_to_address:
        clc                                     // clear carry
        lda #40                                 // load 40 (cols per row to get next screen row)
        adc ZP_SCREEN_ADDR_LO                   // add to current screen and color addr
        sta ZP_SCREEN_ADDR_LO
        sta ZP_COLOR_ADDR_LO
        lda ZP_SCREEN_ADDR_HI                   
        adc #0
        sta ZP_SCREEN_ADDR_HI
        clc                                     // clear carry
        adc #$94
        sta ZP_COLOR_ADDR_HI
        lda #PORTRAIT_TILE_WIDTH                // load tile width of portrait
        adc ZP_TILE_ADDR_LO                     // and add to current tile address
        sta ZP_TILE_ADDR_LO                     // store in zeropage
        lda #0
        adc ZP_TILE_ADDR_HI
        sta ZP_TILE_ADDR_HI
        lda #$40                                // load $40 (64)
        adc ZP_BITMAP_ADDR_LO                   // and add to LSB of bitmap address
        sta ZP_BITMAP_ADDR_LO                   // store in zeropage
        clc                                     // clear carry
        lda #$1                                 // load $1 (256 as it is the MSB)
        adc ZP_BITMAP_ADDR_HI                   // and add to MSB of bitmap address resulting in 320
        sta ZP_BITMAP_ADDR_HI                   // store in zeropage
        dec ZP_TILEHEIGHT                       // decrease tileheight stored in zeropage
        bne !get_char_data-                     // as long as it is not 0 get new char data
        rts

game_loop:
    jmp game_loop               // start infinite loop to prevent breaking back to command line

end:
    rts