Moving Right Along…

Ok let’s make it all a bit more interactive. I want to add the typical WASD + QE controls for moving around in the dungeon map.

Using the Kernal

To keep things simple I will use the Kernal functions to register when a key is pressed. That should not be a problem as I am not relying on having to read and interpret multiple key presses at once.

So I simply jump to the corresponding memory address and compare the result to the key values I want to check for.

Copy to Clipboard

read_keyboard:
    jsr KERNAL_GETIN            // read kernal key input
    cmp #KEY_W                  // compare to value of W
    bne !check_a+               // not equal -> go to next
    jmp move_north
    !check_a:
        cmp #KEY_A              // compare to value of A
        bne !check_s+           // not equal -> go to next
        jmp move_west
        !check_s:
            cmp #KEY_S          // compare to value of S
            bne !check_d+       // not equal -> go to next
            jmp move_south
            !check_d:
                cmp #KEY_D      // compare to value of D
                bne !check_q+   // not equal -> go to next
                jmp move_east
                !check_q:
                    cmp #KEY_Q          // compare to value of Q
                    bne !check_e+       // not equal -> go to next
                    jmp rotate_right
                    !check_e:
                        cmp #KEY_E      // compare to value of E
                        bne !complete+  // not equal ->  go to next
                        jmp rotate_left
    !complete:
    rts

Making a move

After a keypress is detected I jump to the corresponding movement or rotation code. Let’s say I want to move upwards by pressing W. First I have to know how the player is oriented to make the right movement. To do that I simply shift through the bits until I reach 0 to get my orientation. When I have done that I add or substract to the y or x position based on my orientation and store both values. Now I read the data stored at the target coordinates and check if it is passable. For that I use the get_map_tile and blocked methods.

Copy to Clipboard

move_north:
    lda player_orientation  // load current player orientation
    lsr                     // shift right
    bne !orientation_east+  // if not empty go to next
    lda player_pos_y        // load current player y position
    sec                     // set carry for substraction
    sbc #$01                // substract 1
    sta ZP_MAP_ROW          // store in memory
    lda player_pos_x        // load current player x position
    sta ZP_MAP_OFFSET       // store in memory
    jsr get_map_tile
    and #$01                // remove all but bit no 1
    bne !blocked+           // if is set there is a wall in our path
    lda ZP_MAP_ROW          // load stored y position
    sta player_pos_y        // store in player y position
    jmp !complete+
    !orientation_east:
        lsr                         // shift right
        bne !orientation_south+     // if not empty go to next
        lda player_pos_x            // load current player x position
        clc                         // clear carry
        adc #$01                    // add 1
        sta ZP_MAP_OFFSET           // store in memory
        lda player_pos_y            // load current player y position
        sta ZP_MAP_ROW              // store in memory
        jsr get_map_tile
        and #$01                    // remove all but bit no 1
        bne !blocked+               // if it is set there is a wall in our path
        lda ZP_MAP_OFFSET           // load stored x position
        sta player_pos_x            // store in player x position
        jmp !complete+
        !orientation_south:
            lsr
            bne !orientation_west+
            lda player_pos_y
            clc
            adc #$01
            sta ZP_MAP_ROW
            lda player_pos_x
            sta ZP_MAP_OFFSET
            jsr get_map_tile
            and #$01
            bne !blocked+
            lda ZP_MAP_ROW
            sta player_pos_y
            jmp !complete+
            !orientation_west:
            lsr
            bne !complete+
            lda player_pos_x
            sec
            sbc #$01
            sta ZP_MAP_OFFSET
            lda player_pos_y
            sta ZP_MAP_ROW
            jsr get_map_tile
            and #$01
            bne !blocked+
            lda ZP_MAP_OFFSET
            sta player_pos_x
    !complete:
    jsr viewport_routine        // draw view
    rts
    !blocked:
        jmp blocked         // show border effect but don't move
        rts

get_map_tile:
    ldy ZP_MAP_ROW          // load temp y position
    jsr load_map_row
    ldy ZP_MAP_OFFSET       // load temp x position
    lda (ZP_MAP_ADDR_LO), y // get tile at position
    and #%1111              // remove upper nibble
    rts

blocked:
    lda #$0f                // load $0F (15) into temp
    sta ZP_TEMP             // for wait raster
    lda #LIGHT_BLUE         // load light blue color
    sta BORDER_COLOR        // store in border
    jsr wait_raster         // timeout
    lda #BLUE               // load blue color
    sta BORDER_COLOR        // store in border
    rts

Spinning around

Rotation is quite a bit easier to do. I just rotate the bits left or right and check if my value gets out of bound to reset it.

Copy to Clipboard

Compiling the code

After compiling the code I can finally take my first steps in a new world 😉

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
// real 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_STRIP_LO = $FD
.const ZP_STRIP_HI = $FE
.const ZP_MAP_ADDR_LO = $FD
.const ZP_MAP_ADDR_HI = $FE
.const ZP_MAP_TEMP_LO = $92
.const ZP_MAP_TEMP_HI = $93
.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_2 = $A3
.const ZP_STRIP_POS = $A4
.const ZP_TILESX = $A5
// temp zeropages
.const ZP_COLOR = $c003
.const ZP_CHAR_OFFSET = $ba00
.const ZP_PIXEL_OFFSET = $ba01
.const ZP_VIEW_LEFT = $ba02
.const ZP_VIEW_FRONT_LEFT = $ba03
.const ZP_VIEW_FAR_LEFT = $ba04
.const ZP_VIEW_CENTER_LEFT = $ba05
.const ZP_VIEW_CENTER = $ba06
.const ZP_VIEW_CENTER_RIGHT = $ba07
.const ZP_VIEW_FAR_RIGHT = $ba08
.const ZP_VIEW_FRONT_RIGHT = $ba09
.const ZP_VIEW_RIGHT = $ba0a
.const ZP_TILEWIDTH = $ba0d
.const ZP_CHAR_POS = $ba0e
.const ZP_VIEWPORT_Y = $ba0f
.const ZP_TILEY = $ba10
.const ZP_VIEW_STRIP = $ba11
.const ZP_MAP_OFFSET = $ba12
.const ZP_MAP_ROW = $ba13
.const ZP_MAP_TILE = $ba14
.const ZP_MAP_OVERHEAD = $ba15
.const ZP_STRIP_ROW = $ba16
.const ZP_STRIP_OFFSET = $ba17

// 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

// Dungeon View
.const VIEWPORT_MAP_WIDTH = 5
.const VIEWPORT_MAP_HEIGHT = 3
.const VIEWPORT_TILE_HEIGHT = 4
.const VIEWPORT_TILE_WIDTH = 9
.const VIEWPORT_TILE_SIZE = VIEWPORT_TILE_HEIGHT * VIEWPORT_TILE_WIDTH
.const VIEWPORT_PIXEL_HEIGHT = 64
.const VIEWPORT_PIXEL_WIDTH = 144
.const VIEWPORT_PIXEL_SIZE = VIEWPORT_PIXEL_HEIGHT * VIEWPORT_PIXEL_WIDTH
.const VIEWPORT_CHAR_HEIGHT = 16
.const VIEWPORT_CHAR_WIDTH = 36
.const VIEWPORT_CHAR_SIZE = VIEWPORT_CHAR_HEIGHT * VIEWPORT_CHAR_WIDTH
.const VIEWPORT_PIXEL_OFFSET = 16
.const VIEWPORT_CHAR_OFFSET = 2
// Viewport Strips
.const STRIPS_TOTAL = $30
// Strip Types
.const STRIP_EMPTY = 0
.const STRIP_LEFT_WALL = 1
.const STRIP_LEFT_FRONT_WALL = 2
.const STRIP_LEFT_FAR_WALL = 3
.const STRIP_RIGHT_FAR_WALL = 4
.const STRIP_RIGHT_FRONT_WALL = 5
.const STRIP_RIGHT_WALL = 6
// Strip offsets
.const STRIPS_OFFSET_EMPTY = $00
.const STRIPS_OFFSET_LEFT = $01
.const STRIPS_OFFSET_LEFT_FRONT = $06
.const STRIPS_OFFSET_LEFT_FAR = $0B
.const STRIPS_OFFSET_FRONT_1 = $11
.const STRIPS_OFFSET_FRONT_2 = $16
.const STRIPS_OFFSET_FRONT_3 = $1B
.const STRIPS_OFFSET_RIGHT_FRONT = $20
.const STRIPS_OFFSET_RIGHT_FAR = $25
.const STRIPS_OFFSET_RIGHT = $2B

// Dungeon Data
// Dungeon Tileset
.const DUNGEON_TILESET_SIZE = 127
.const DUNGEON_CHARSET_SIZE = 245
.const DUNGEON_TILE_WIDTH = 4
.const DUNGEON_TILE_HEIGHT = 4
.const DUNGEON_TILE_SIZE = DUNGEON_TILE_HEIGHT * DUNGEON_TILE_WIDTH
.const DUNGEON_PIXEL_WIDTH = 32
.const DUNGEON_PIXEL_HEIGHT = 32
.const DUNGEON_PIXEL_SIZE = DUNGEON_PIXEL_HEIGHT * DUNGEON_PIXEL_WIDTH
// Dungeon Map
.const DUNGEON_MAP_HEIGHT = 16
.const DUNGEON_MAP_WIDTH = 16
.const DUNGEON_MAP_SIZE = DUNGEON_MAP_WIDTH * DUNGEON_MAP_HEIGHT

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

wait_raster:
    ldy #$00
    !loop_times:
        lda #$ff
        !loop_raster:
            cmp VIC_RASTER_COUNTER
            bne !loop_raster-
        iny
        cpy ZP_TEMP
        bne !loop_times-
    rts

viewport_routine:
    jsr build_map_view
    jsr store_viewport_strips
    jsr draw_view
    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:
    lda #0                                  // load 0 into accumulator
    sta ZP_TEMP                             // store in zeropage
    !loop:
        ldy ZP_TEMP                         // load current portrait position into y register         
        lda pc_portraits, y                 // load portrait tile id in position
        sta ZP_TILENO                       // store in zeropage
        jsr draw_portrait
        inc ZP_TEMP                         // increase position
        lda ZP_TEMP
        cmp #5
        bne !loop-                          // repeat until we reach the last potrait
    rts

draw_portrait:
    lda #PORTRAIT_TILE_HEIGHT                   // load tile height of portrait
    sta ZP_TILEHEIGHT  
    lda #PORTRAIT_TILE_WIDTH
    sta ZP_TILEWIDTH                         // 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
        jsr set_color
        ldy #PORTRAIT_PIXEL_WIDTH-1        // load pixel height of portrait minus 1 (0 - 23) to y register
        jsr draw_char
        jsr add_row_to_address
        dec ZP_TILEHEIGHT                       // decrease tileheight stored in zeropage
        bne !get_char_data-                     // as long as it is not 0 get new char data
        rts

set_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 set_color                       // as long as y is above zero repeat
    rts

draw_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 draw_char                   // as long as y is above zero repeat
    rts

add_row_to_address:
    clc                                     // clear carry
    lda #$28                                 // 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 #$00
    sta ZP_SCREEN_ADDR_HI
    clc                                     // clear carry
    adc #$94
    sta ZP_COLOR_ADDR_HI
    lda ZP_TILEWIDTH                // 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 #$01                                 // 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
    rts

#import "includes/build_mapview.asm"

#import "includes/build_strips.asm"

#import "includes/draw_view.asm"

blocked:
    lda #$0F                // load $0F (15) into temp
    sta ZP_TEMP             // for wait raster
    lda #LIGHT_BLUE         // load light blue color
    sta BORDER_COLOR        // store in border
    jsr wait_raster         // timeout
    lda #BLUE               // load blue color
    sta BORDER_COLOR        // store in border
    rts

move_east:
    lda player_orientation
    lsr
    bne !orientation_east+
    lda player_pos_x
    clc
    adc #$01
    sta ZP_MAP_OFFSET
    lda player_pos_y
    sta ZP_MAP_ROW
    jsr get_map_tile
    and #$01
    bne !blocked+
    lda ZP_MAP_OFFSET
    sta player_pos_x
    jmp !complete+
    !orientation_east:
        lsr
        bne !orientation_south+
        lda player_pos_y
        clc
        adc #$01
        sta ZP_MAP_ROW
        lda player_pos_x
        sta ZP_MAP_OFFSET
        jsr get_map_tile
        and #$01
        bne !blocked+
        lda ZP_MAP_ROW
        sta player_pos_y
        jmp !complete+
        !orientation_south:
            lsr
            bne !orientation_west+
            lda player_pos_x
            sec
            sbc #$01
            sta ZP_MAP_OFFSET
            lda player_pos_y
            sta ZP_MAP_ROW
            jsr get_map_tile
            and #$01
            bne !blocked+
            lda ZP_MAP_OFFSET
            sta player_pos_x
            jmp !complete+
            !orientation_west:
                lsr
                bne !complete+
                lda player_pos_y
                sec
                sbc #$01
                sta ZP_MAP_ROW
                lda player_pos_x
                sta ZP_MAP_OFFSET
                jsr get_map_tile
                and #$01
                bne !blocked+
                lda ZP_MAP_ROW
                sta player_pos_y
    !complete:
    jsr viewport_routine
    rts
    !blocked:
        jmp blocked
        rts

move_south:
    lda player_orientation
    lsr
    bne !orientation_east+
    lda player_pos_y
    clc
    adc #$01
    sta ZP_MAP_ROW
    lda player_pos_x
    sta ZP_MAP_OFFSET
    jsr get_map_tile
    and #$01
    bne !blocked+
    lda ZP_MAP_ROW
    sta player_pos_y
    jmp !complete+
    !orientation_east:
        lsr
        bne !orientation_south+
        lda player_pos_x
        sec
        sbc #$01
        sta ZP_MAP_OFFSET
        lda player_pos_y
        sta ZP_MAP_ROW
        jsr get_map_tile
        and #$01
        bne !blocked+
        lda ZP_MAP_OFFSET
        sta player_pos_x
        jmp !complete+
        !orientation_south:
            lsr
            bne !orientation_west+
            lda player_pos_y
            sec
            sbc #$01
            sta ZP_MAP_ROW
            lda player_pos_x
            sta ZP_MAP_OFFSET
            jsr get_map_tile
            and #$01
            bne !blocked+
            lda ZP_MAP_ROW
            sta player_pos_y
            jmp !complete+
            !orientation_west:
                lsr
                bne !complete+
                lda player_pos_x
                clc
                adc #$01
                sta ZP_MAP_OFFSET
                lda player_pos_y
                sta ZP_MAP_ROW
                jsr get_map_tile
                and #$01
                bne !blocked+
                lda ZP_MAP_OFFSET
                sta player_pos_x
    !complete:
    jsr viewport_routine
    rts
    !blocked:
        jmp blocked
        rts

move_west:
    lda player_orientation
    lsr
    bne !orientation_east+
    lda player_pos_x
    sec
    sbc #$01
    sta ZP_MAP_OFFSET
    lda player_pos_y
    sta ZP_MAP_ROW
    jsr get_map_tile
    and #$01
    bne !blocked+
    lda ZP_MAP_OFFSET
    sta player_pos_x
    jmp !complete+
    !orientation_east:
        lsr
        bne !orientation_south+
        lda player_pos_y
        sec
        sbc #$01
        sta ZP_MAP_ROW
        lda player_pos_x
        sta ZP_MAP_OFFSET
        jsr get_map_tile
        and #$01
        bne !blocked+
        lda ZP_MAP_ROW
        sta player_pos_y
        jmp !complete+
        !orientation_south:
            lsr
            bne !orientation_west+
            lda player_pos_x
            clc
            adc #$01
            sta ZP_MAP_OFFSET
            lda player_pos_y
            sta ZP_MAP_ROW
            jsr get_map_tile
            and #$01
            bne !blocked+
            lda ZP_MAP_OFFSET
            sta player_pos_x
            jmp !complete+
            !orientation_west:
                lsr
                bne !complete+
                lda player_pos_y
                clc
                adc #$01
                sta ZP_MAP_ROW
                lda player_pos_x
                sta ZP_MAP_OFFSET
                jsr get_map_tile
                and #$01
                bne !blocked+
                lda ZP_MAP_ROW
                sta player_pos_y
    !complete:
    jsr viewport_routine
    rts
    !blocked:
        jmp blocked
        rts

rotate_right:
    clc                         // clear carry
    lda player_orientation      // load current player orientation
    ror                         // rotate right
    bcc !store+                 // check if carry is set (meaning it is a valid orientation)
    lda #$08                    // if value is not valid set to $08 (west)
    !store:
        sta player_orientation  // store new value in orientation
    jsr viewport_routine        // draw view
    rts

rotate_left:
    clc
    lda player_orientation
    rol
    bne !store+
    lda #$08
    !store:
        sta player_orientation
    jsr viewport_routine
    rts

game_loop:
    jsr viewport_routine                // draw viewport
    lda player_orientation              // load player orientation
    !loop:
        jsr read_keyboard
        jmp !loop-

end:
    rts

// TABLES

// #### PORTRAITS ####
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)
    }

// #### END PORTRAITS ####

// #### VIEWPORT ####
view_tile_rows_LSB:                             // view tile starting rows
    .for(var i=0; i<VIEWPORT_PIXEL_HEIGHT; i++) {
        .byte < BITMAP_ADDR+i*40*8*4
    }

view_tile_rows_MSB:
    .for(var i=0; i<VIEWPORT_PIXEL_HEIGHT; i++) {
        .byte > BITMAP_ADDR+i*40*8*4
    }

view_tile_color_rows_LSB:                       // view tile starting screen rows
    .for(var i=0; i<VIEWPORT_CHAR_HEIGHT;i++) {
        .byte < SCREEN_RAM_BANK_1+i*40*4
    }

view_tile_color_rows_MSB:
    .for(var i=0; i<VIEWPORT_CHAR_HEIGHT;i++) {
        .byte > SCREEN_RAM_BANK_1+i*40*4
    }

view_rows_LSB:                                  // view rows
    .for(var i=0; i<VIEWPORT_PIXEL_HEIGHT; i++) {
        .byte < BITMAP_ADDR+i*40*8
    }

view_rows_offset_LSB:                           // view row tile offsets
    .for(var i=0; i<VIEWPORT_TILE_WIDTH; i++) {
        .byte < i*DUNGEON_TILE_WIDTH*8
    }

view_rows_MSB:
    .for(var i=0; i<VIEWPORT_PIXEL_HEIGHT; i++) {
        .byte > BITMAP_ADDR+i*40*8
    }

view_rows_offset_MSB:
    .for(var i=0; i<VIEWPORT_TILE_WIDTH; i++) {
        .byte > i*DUNGEON_TILE_WIDTH*8
    }

view_color_rows_LSB:                            // view screen rows
    .for(var i=0; i<VIEWPORT_CHAR_HEIGHT;i++) {
        .byte < SCREEN_RAM_BANK_1+i*40
    }

view_color_rows_offset_LSB:                     // view screen tile offsets
    .for(var i=0; i<VIEWPORT_TILE_WIDTH; i++) {
        .byte < i*DUNGEON_TILE_WIDTH
    }

view_color_rows_MSB:
    .for(var i=0; i<VIEWPORT_CHAR_HEIGHT;i++) {
        .byte > SCREEN_RAM_BANK_1+i*40
    }

// #### END VIEWPORT ####

// #### DUNGEON ####
view_strips_LSB:
    .for (var i=0; i<STRIPS_TOTAL; i++) {
        .byte < strips_new+i*VIEWPORT_TILE_HEIGHT
    }

view_strips_MSB:
    .for (var i=0; i<STRIPS_TOTAL; i++) {
        .byte > strips_new+i*VIEWPORT_TILE_HEIGHT
    }

dungeon_tile_pos_LSB:                           // table of dungeon tiles
    .for(var i=0; i<DUNGEON_TILESET_SIZE; i++) {
        .byte < dungeon_chartileset_data+i*DUNGEON_TILE_SIZE
    }

dungeon_tile_pos_MSB:
    .for(var i=0; i<DUNGEON_TILESET_SIZE; i++) {
        .byte > dungeon_chartileset_data+i*DUNGEON_TILE_SIZE
    }

dungeon_char_pos_LSB:                           // table of dungeon chars
    .for(var i=0; i<DUNGEON_CHARSET_SIZE; i++) {
        .byte < dungeon_charset_data+i*8
    }

dungeon_char_pos_MSB:
    .for(var i=0; i<DUNGEON_CHARSET_SIZE; i++) {
        .byte > dungeon_charset_data+i*8
    }

dungeon_map_rows_LSB:                           // table of dungeon map rows
    .for (var i=0; i<DUNGEON_MAP_HEIGHT; i++) {
        .byte < (dungeon_map+i*DUNGEON_MAP_WIDTH)
    }
dungeon_map_rows_MSB:
    .for (var i=0; i<DUNGEON_MAP_HEIGHT; i++) {
        .byte > (dungeon_map+i*DUNGEON_MAP_WIDTH)
    }

// #### END DUNGEON ####

*=$6000 "BITMAP-DATA"
#import "../assets/bitmap/steam_ui_v2.asm"

*=$a000 "PORTRAIT-DATA"                         // memory address for pc potrait data
#import "../assets/charsets/PC-Portraits - Chars.asm"
#import "../assets/tilesets/PC-Portraits - Tiles.asm"

*=$a400 "DUNGEON-TILESET"                       // memory address for dungeon tileset
#import "../assets/charsets/Dungeon - Brick Wall - Chars.asm"
#import "../assets/tilesets/Dungeon - Brick Wall - Tiles.asm"

*=$c100 "GAME-DATA"
view_strips:                            // test view
    view_strip_left:                // strip_left -> view_left    
    .byte $00
    view_strip_left_front:          // strip_left_front -> view_left_front
    .byte $00
    view_strip_left_far:            // strip_left_far -> view_left_far
    .byte $00
    view_strip_front_1:             // strip_left_far_1 - 3 -> view_front
    .byte $00
    view_strip_front_2:
    .byte $00
    view_strip_front_3:
    .byte $00
    view_strip_right_far:           // strip_right_far -> view_right_far
    .byte $00
    view_strip_right_front:         // strip_right_front -> view_right_front
    .byte $00
    view_strip_right:               // strip_right -> view_right
    .byte $00

player:
    position:
        player_pos_x:
            .byte $01
        player_pos_y:
            .byte $02
        player_orientation:
            .byte %0001         // %0001 = north | %0010 = east | %0100 = south | %1000 = west
    view:
        player_view_left:       // $C10C
            .byte $00
        player_view_left_front: // $C10D
            .byte $00
        player_view_left_far:   // $C10E
            .byte $00
        player_position:        // $C10F
            .byte $00
        player_view_front:      // $C110
            .byte $00
        player_view_far:        // $C111
            .byte $00
        player_view_right:      // $C112
            .byte $00
        player_view_right_front:// $C113
            .byte $00
        player_view_right_far:  // $C114
            .byte $00

*=$c400 "DUNGEON-DATA"
dungeon:
    strips_new:
        empty:                              // start $00
            .byte $00, $00, $00, $00
        strip_left:                         // start $01
            left_wall:
                .byte $01, $04, $05, $0A
            left_wall_corner:
                .byte $00, $00, $00, $00
            left_wall_straight:
                .byte $00, $00, $00, $00
            left_wall_straight_back:
                .byte $1F, $20, $21, $22
            left_wall_straight_far:
                .byte $46, $47, $48, $00
        strips_left_front:                  // start $06
            left_front_wall:
                .byte $02, $06, $07, $0B
            left_front_corner:
                .byte $17, $18, $19, $1A
            left_front_wall_straight:
                .byte $23, $24, $25, $26
            left_front_straight_back:
                .byte $40, $41, $42, $00
            left_front_straight_far:
                .byte $00, $00, $00, $00
        strips_left_far:                    // start $0B
            left_far_wall:
                .byte $03, $08, $09, $00
            left_far_corner:
                .byte $2B, $2C, $2D, $00
            left_far_wall_straight:
                .byte $40, $41, $42, $00
            left_far_straight_back:
                .byte $00, $00, $00, $00
            left_far_straight_far:
                .byte $00, $00, $00, $00
            left_far_override:
                .byte $1B, $1C, $1D, $1E
        front_strips:                       // start $11
                                            // strip 1 $11
            front_strip_1:
                front_wall_1:
                    .byte $1F, $20, $21, $22
                front_wall_1_corner:
                    .byte $00, $00, $00, $00
                front_wall_1_straight:
                    .byte $00, $00, $00, $00
                front_wall_1_back:
                    .byte $2E, $2F, $30, $00
                front_wall_1_out_of_view:
                    .byte $00, $00, $00, $00
            front_strip_2:                  // strip 2 $16
                front_wall_2:
                    .byte $23, $24, $25, $26
                front_wall_2_corner:
                    .byte $00, $00, $00, $00
                front_wall_2_straight:
                    .byte $00, $00, $00, $00
                far_wall_2_back:
                    .byte $31, $32, $33, $00
                front_wall_2_out_of_view:
                    .byte $00, $00, $00, $00
            front_strip_3:                  // strip 3 $1B
                front_wall_3:
                    .byte $1B, $1C, $1D, $1E
                front_wall_3_corner:
                    .byte $00, $00, $00, $00
                front_wall_3_straight:
                    .byte $00, $00, $00, $00
                far_wall_3_back:
                    .byte $34, $35, $36, $00
                front_wall_3_out_of_view:
                    .byte $00, $00, $00, $00                
        strips_right_front:                 // start $20
            right_front_wall:
                .byte $0D, $0F, $11, $15
            right_front_wall_corner:
                .byte $27, $28, $29, $2A
            right_front_wall_straight:
                .byte $23, $24, $25, $26
            right_front_straight_front:
                .byte $3A, $3B, $3C, $00
            right_front_straight_far:
                .byte $00, $00, $00, $00
        strips_right_far:                   // start $25
            right_far_wall:
                .byte $0C, $13, $14, $00
            right_far_wall_corner:
                .byte $2B, $2C, $2D, $00
            right_far_wall_straight:
                .byte $37, $38, $39, $00
            right_far_straight_front:
                .byte $00, $00, $00, $00
            right_far_straight_far:
                .byte $00, $00, $00, $00
            right_far_override:
                .byte $1F, $20, $21, $22
        strip_right:                        // start $2B
            right_wall:
                .byte $0E, $10, $12, $16
            right_wall_corner:
                .byte $00, $00, $00, $00
            right_wall_straight:
                .byte $00, $00, $00, $00
            right_wall_straight_front:
                .byte $1B, $1C, $1D, $1E
            right_wall_straight_far:
                .byte $3D, $3E, $3F, $00

dungeon_map:
        .byte $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01
        .byte $01, $00, $00, $00, $00, $00, $00, $00, $01, $01, $01, $01, $01, $01, $01, $01
        .byte $01, $00, $01, $01, $00, $01, $01, $00, $01, $01, $01, $01, $01, $01, $01, $01
        .byte $01, $00, $01, $01, $00, $01, $01, $00, $01, $01, $01, $01, $01, $01, $01, $01
        .byte $01, $00, $00, $01, $01, $00, $00, $00, $01, $01, $01, $01, $01, $01, $01, $01
        .byte $01, $00, $00, $01, $01, $00, $00, $00, $01, $01, $01, $01, $01, $01, $01, $01
        .byte $01, $00, $00, $00, $00, $00, $00, $00, $01, $01, $01, $01, $01, $01, $01, $01
        .byte $01, $01, $01, $01, $00, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01
        .byte $01, $01, $01, $01, $00, $01, $01, $01, $01, $01, $00, $00, $01, $01, $01, $01
        .byte $01, $01, $01, $01, $00, $01, $01, $01, $01, $01, $00, $00, $01, $01, $01, $01
        .byte $01, $01, $01, $01, $00, $00, $00, $00, $00, $00, $00, $00, $01, $01, $01, $01
        .byte $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $00, $00, $01, $01, $01, $01
        .byte $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01
        .byte $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01
        .byte $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01
        .byte $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01

*=$c800 "PC-DATA"
pc_portraits:
    pc_0_portrait:
    .byte $02
    pc_1_portrait:
    .byte $05
    pc_2_portrait:
    .byte $01
    pc_3_portrait:
    .byte $03
    pc_4_portrait:
    .byte $04

build_mapview.asm

Copy to Clipboard

build_map_view:
    !init:
    lda player_orientation              // get current player orientation
    lsr                                 // shift right
    bne !orientation_east+              // check if orientation is east
    jmp store_north
    !orientation_east:
        lsr                             // shift right
        bne !orientation_south+         // check if orientation is south
        jmp store_east
    !orientation_south:
        lsr                             // shift right
        bne !orientation_west+          // check if orientation is west
        jmp store_south
    !orientation_west:
        lsr                             // shift right
        bne !error+                     // if there still is something left go to error
        jmp store_west
    !error:
        lda #$01                        // load 1
        sta player_orientation          // store into player orientation
        jsr !init-                      // and try again
    rts

check_right:
    lda ZP_MAP_OVERHEAD                 // load current overhead
    and #%1111                          // remove upper nibble
    bne !return+                        // if not empty return
    ldy ZP_MAP_OFFSET                   // load current offset
    iny                                 // increase by 1
    cpy #DUNGEON_MAP_WIDTH              // compare to dungeon width
    beq !return+                        // if width is reached return
    lda (ZP_MAP_ADDR_LO), y             // load map data at offset
    and #%1111                          // remove upper nibble
    beq !move_right+                    // if empty go to next part
    lda ZP_MAP_OVERHEAD                 // load current overhead
    ora #%100000                        // activate bit 6 to indicate back wall
    sta ZP_MAP_OVERHEAD                 // store in overhead
    jmp !return+                        // return
    !move_right:
        iny                             // increase offset
        cpy #DUNGEON_MAP_WIDTH          // compare to map width
        beq !return+                    // if width reached return
        lda (ZP_MAP_ADDR_LO), y         // load map data at offset
        and #%1111                      // remove upper nibble
        beq !return+                    // if empty return
        lda ZP_MAP_OVERHEAD             // load current overhead
        ora #%10000                     // activate bit 5 to indicate far away wall
        sta ZP_MAP_OVERHEAD             // store in overhead
    !return:
    rts

check_left:
    lda ZP_MAP_OVERHEAD                 // load current overhead
    and #%1111                          // remove upper nibble
    bne !return+                        // if not empty return
    ldy ZP_MAP_OFFSET                   // load current offset
    dey                                 // decrease by 1
    bmi !return+                        // if negative (out of map area) return
    lda (ZP_MAP_ADDR_LO), y             // get map data at offset
    and #%1111                          // remove upper nibble
    beq !move_left+                     // if empty go to next step
    lda ZP_MAP_OVERHEAD                 // load current overhead
    ora #%100000                        // activate bit 6 to indicate back wall
    sta ZP_MAP_OVERHEAD                 // store in overhead
    jmp !return+
    !move_left:
        dey                             // decrease offset by 1
        bmi !return+                    // if negative return
        lda (ZP_MAP_ADDR_LO), y         // load map data at offset
        and #%1111                      // remove upper nibble
        beq !return+                    // if empty return
        lda ZP_MAP_OVERHEAD             // load overhead
        ora #%10000                     // activate bit 5 to indicate far away wall
        sta ZP_MAP_OVERHEAD             // store in overhead
    !return:
    rts

check_top:
    lda ZP_MAP_OVERHEAD                 // load current overhead
    and #%1111                          // remove upper nibble
    bne !return+                        // if not empty return
    lda ZP_MAP_ROW                      // get current y position
    sec                                 // set carry
    sbc #$01                            // decrease by 1
    bmi !return+                        // if negative (out of map area) return
    tay                                 // transfer to y register
    lda dungeon_map_rows_LSB, y         // load map address
    sta ZP_MAP_TEMP_LO                  // store in memory
    lda dungeon_map_rows_MSB, y
    sta ZP_MAP_TEMP_HI
    ldy ZP_MAP_OFFSET                   // load x position
    lda (ZP_MAP_TEMP_LO), y             // get map data (-1y 0x - right above current tile)
    and #%1111                          // remove upper nibble
    beq !move_up+                       // if tile is empty move up one row
    lda ZP_MAP_OVERHEAD                 // load from memory
    ora #%100000                        // set bit 6 to indicate wall behind
    sta ZP_MAP_OVERHEAD                 // store temporary
    !move_up:
        lda ZP_MAP_ROW                  // load y position from memory
        sec                             // set carry
        sbc #$02                        // decrease by two
        bmi !return+                    // if tile is tile is out of range skip
        tay                             // transfer to y register
        lda dungeon_map_rows_LSB, y     // load map address
        sta ZP_MAP_TEMP_LO              // store in memory
        lda dungeon_map_rows_MSB, y
        sta ZP_MAP_TEMP_HI
        ldy ZP_MAP_OFFSET               // load x position
        lda (ZP_MAP_TEMP_LO), y         // get map data (-1y 0x - right above current tile)
        and #%1111                      // remove upper nibble
        beq !return+                    // if empty return
        lda ZP_MAP_OVERHEAD             // load from memory
        ora #%10000                     // set bit 5 to indicate wall further behind
        sta ZP_MAP_OVERHEAD             // store temporary
    !return:
    rts

check_bottom:
    lda ZP_MAP_OVERHEAD
    and #%1111
    bne !return+
    lda ZP_MAP_ROW              // get current y position
    clc
    adc #$01                    // decrease by 1
    cmp #DUNGEON_MAP_WIDTH
    beq !return+
    tay                         // transfer to y register
    lda dungeon_map_rows_LSB, y // load map address
    sta ZP_MAP_TEMP_LO          // store in memory
    lda dungeon_map_rows_MSB, y
    sta ZP_MAP_TEMP_HI
    ldy ZP_MAP_OFFSET          // load x position
    lda (ZP_MAP_TEMP_LO), y    // get map data (-1y 0x - right above current tile)
    and #%1111                 // remove upper nibble
    beq !move_down+            // if tile is empty move down one row
    lda ZP_MAP_OVERHEAD        // load from memory
    ora #%100000               // set bit 6 to indicate wall behind
    sta ZP_MAP_OVERHEAD        // store temporary
    jmp !return+
    !move_down:
        clc
        lda ZP_MAP_ROW              // load y position from memory
        adc #$02                    // decrease by to
        cmp #DUNGEON_MAP_WIDTH
        beq !return+
        tay                         // transfer to y register
        lda dungeon_map_rows_LSB, y // load map address
        sta ZP_MAP_TEMP_LO          // store in memory
        lda dungeon_map_rows_MSB, y
        sta ZP_MAP_TEMP_HI
        ldy ZP_MAP_OFFSET           // load x position
        lda (ZP_MAP_TEMP_LO), y     // get map data (-1y 0x - right above current tile)
        and #%1111                  // remove upper nibble
        beq !return+
        lda ZP_MAP_OVERHEAD         // load from memory
        ora #%10000                 // set bit 5 to indicate wall further behind
        sta ZP_MAP_OVERHEAD         // store temporary
    !return:
    rts

corner_check_down_left:
    ldy ZP_MAP_OFFSET               // load current map offset into y register
    lda (ZP_MAP_ADDR_LO), y         // get map data at address
    and #%1111                      // remove upper nibble
    sta ZP_MAP_OVERHEAD             // store in memory
    !check_adjacent_below:
        ldy ZP_MAP_ROW              // load current map row in y register
        iny                         // add one row
        cpy #DUNGEON_MAP_WIDTH      // compare to map width
        beq !return+                // if out of bound return
        lda dungeon_map_rows_LSB, y // load map address of row
        sta ZP_MAP_TEMP_LO
        lda dungeon_map_rows_MSB, y
        sta ZP_MAP_TEMP_HI
        ldy ZP_MAP_OFFSET           // load current offset into y register
        lda (ZP_MAP_TEMP_LO), y     // get map data at temp address
        and #%1111                  // remove upper nibble
        beq !return+                // if empty skip
        !check_adjacent_before:
            ldy ZP_MAP_OFFSET       // load current offset into y register
            dey                     // decrease offset by one
            bmi !wall_straight+     // if offset is out of bounds go to next step
            lda (ZP_MAP_TEMP_LO), y // load map data at temp address
            and #%1111              // remove upper nibble
            beq !wall_straight+     // if empty go to next step
            ora #%10000000          // set bit 7 to indicate corner
            ora ZP_MAP_OVERHEAD     // add overhead
            sta ZP_MAP_OVERHEAD     // store in memory
            jmp !return+
            !wall_straight:
                ora #%1000000       // set bit 6 to indicate straight wall
                ora ZP_MAP_OVERHEAD // add overhead
                sta ZP_MAP_OVERHEAD // store in memory
    !return:
    rts

corner_check_up_left:
    ldy ZP_MAP_OFFSET               // load current map offset
    lda (ZP_MAP_ADDR_LO), y         // get map data at address
    and #%1111                      // remove upper nibble
    sta ZP_MAP_OVERHEAD             // store in memory
    // beq !return+
    !check_adjacent_above:
        ldy ZP_MAP_ROW              // load current map row
        dey                         // decrease row
        bmi !return+                // if negative (out of bounds) return
        lda dungeon_map_rows_LSB, y // get map address for current row
        sta ZP_MAP_TEMP_LO          // store in memory
        lda dungeon_map_rows_MSB, y
        sta ZP_MAP_TEMP_HI
        ldy ZP_MAP_OFFSET           // load current map offset
        lda (ZP_MAP_TEMP_LO), y     // load map data at temp address
        and #%1111                  // remove upper nibble
        beq !return+                // if empty return
        !check_adjacent_before:
            ldy ZP_MAP_ROW          // load current map row
            lda dungeon_map_rows_LSB, y // get map address for current row
            sta ZP_MAP_TEMP_LO          // store in memory
            lda dungeon_map_rows_MSB, y
            sta ZP_MAP_TEMP_HI
            ldy ZP_MAP_OFFSET       // load current map offset
            dey                     // decrease by one
            bmi !wall_straight+     // check of offset is out of bounds
            lda (ZP_MAP_TEMP_LO), y // load map data add temp address
            and #%1111              // remove upper nibble
            beq !wall_straight+     // if empty go to next step
            ora #%10000000          // set bit 7 to indicate corner
            ora ZP_MAP_OVERHEAD     // add overhead
            sta ZP_MAP_OVERHEAD     // store in memory
            jmp !return+
            !wall_straight:
                lda ZP_MAP_OVERHEAD // load current overhead
                beq !return+        // if empty return
                ora #%1000000       // set bit 6 to indicate straight wall
                ora ZP_MAP_OVERHEAD // add overhead
                sta ZP_MAP_OVERHEAD // store in memory
    !return:
    rts

corner_check_down_right:
    ldy ZP_MAP_OFFSET               // load current map offset into y register
    lda (ZP_MAP_ADDR_LO), y         // get map data at address
    and #%1111                      // remove upper nibble
    sta ZP_MAP_OVERHEAD             // store in memory
    !check_adjacent_below:
        ldy ZP_MAP_ROW              // load current map row in y register
        iny                         // add one row
        cpy #DUNGEON_MAP_WIDTH      // compare to map width
        beq !return+                // if out of bounds return
        lda dungeon_map_rows_LSB, y // load map address of row
        sta ZP_MAP_TEMP_LO
        lda dungeon_map_rows_MSB, y
        sta ZP_MAP_TEMP_HI
        ldy ZP_MAP_OFFSET           // load current offset into y register
        lda (ZP_MAP_TEMP_LO), y     // get map data at temp address
        and #%1111                  // remove upper nibble
        beq !return+                // if empty skip
        !check_adjacent_after:
            ldy ZP_MAP_OFFSET       // load current offset into y register
            iny                     // increase offset by 1
            cmp #DUNGEON_MAP_WIDTH  // decrease offset by one
            beq !wall_straight+     // if offset is out of bounds go to next step
            lda (ZP_MAP_TEMP_LO), y // load map data at temp address
            and #%1111              // remove upper nibble
            beq !wall_straight+     // if empty go to next step
            ora #%10000000          // set bit 7 to indicate corner
            ora ZP_MAP_OVERHEAD     // add overhead
            sta ZP_MAP_OVERHEAD     // store in memory
            jmp !return+
            !wall_straight:
                ora #%1000000       // set bit 6 to indicate straight wall
                ora ZP_MAP_OVERHEAD // add overhead
                sta ZP_MAP_OVERHEAD // store in memory
    !return:
    rts

corner_check_up_right:
    ldy ZP_MAP_OFFSET               // load current map offset
    lda (ZP_MAP_ADDR_LO), y         // get map data at address
    and #%1111                      // remove upper nibble
    sta ZP_MAP_OVERHEAD             // store in memory
    !check_adjacent_above:
        ldy ZP_MAP_ROW              // load current map row
        dey                         // decrease row
        bmi !return+                // if negative (out of bounds) return
        lda dungeon_map_rows_LSB, y // get map address for current row
        sta ZP_MAP_TEMP_LO          // store in memory
        lda dungeon_map_rows_MSB, y
        sta ZP_MAP_TEMP_HI
        ldy ZP_MAP_OFFSET           // load current map offset
        lda (ZP_MAP_TEMP_LO), y     // load map data at temp address
        and #%1111                  // remove upper nibble
        beq !return+                // if empty return
        !check_adjacent_after:
            ldy ZP_MAP_ROW          // load current map row
            lda dungeon_map_rows_LSB, y // get map address for current row
            sta ZP_MAP_TEMP_LO      // store in memory
            lda dungeon_map_rows_MSB, y
            sta ZP_MAP_TEMP_HI
            ldy ZP_MAP_OFFSET       // load current map offset
            iny                     // decrease by one
            cmp #DUNGEON_MAP_WIDTH  // compare to map width
            beq !wall_straight+     // check of offset is out of bounds
            lda (ZP_MAP_TEMP_LO), y // load map data add temp address
            and #%1111              // remove upper nibble
            beq !wall_straight+     // if empty go to next step
            ora #%10000000          // set bit 7 to indicate corner
            ora ZP_MAP_OVERHEAD     // add overhead
            sta ZP_MAP_OVERHEAD     // store in memory
            jmp !return+
            !wall_straight:
                lda ZP_MAP_OVERHEAD // load current overhead
                beq !return+        // if empty return
                ora #%1000000       // set bit 6 to indicate straight wall
                ora ZP_MAP_OVERHEAD // add overhead
                sta ZP_MAP_OVERHEAD // store in memory
    !return:
    rts

corner_check_left_down:
    ldy ZP_MAP_OFFSET               // load current map offset into y register
    lda (ZP_MAP_ADDR_LO), y         // get tile at position
    and #%1111                      // remove upper nibble
    sta ZP_MAP_OVERHEAD             // store temporary
    !check_adjacent_left:
        dey                         // decrease to get horizontal adjacent field
        bmi !return+                // if negative (out of bounds) return
        lda (ZP_MAP_ADDR_LO), y     // load map data at address
        and #%1111                  // remove upper nibble
        beq !return+                // if tile is empty skip
        !check_adjacent_below:
            ldy ZP_MAP_ROW          // load current row
            iny                     // increase
            cpy #DUNGEON_MAP_WIDTH  // compare to map width
            beq !return+            // if out of bounds return
            lda dungeon_map_rows_LSB, y // load map address into temp memory
            sta ZP_MAP_TEMP_LO
            lda dungeon_map_rows_MSB, y
            sta ZP_MAP_TEMP_HI
            ldy ZP_MAP_OFFSET       // load current map offset
            lda (ZP_MAP_TEMP_LO), y // load data stored at map address
            and #%1111              // remove upper nibble
            beq !wall_straight+     // if empty go to next step
            ora #%10000000          // set bit 7 to indicate corner
            ora ZP_MAP_OVERHEAD     // add stored data
            sta ZP_MAP_OVERHEAD     // store memory
            jmp !return+
            !wall_straight:
                ora #%1000000       // set bit 6 to indicate it is a straight wall
                ora ZP_MAP_OVERHEAD // add stored data
                sta ZP_MAP_OVERHEAD // store in memory
    !return:
    rts

corner_check_left_up:
    ldy ZP_MAP_OFFSET           // load current map offset into y register
    lda (ZP_MAP_ADDR_LO), y     // get tile at position
    and #%1111                  // remove upper nibble
    sta ZP_MAP_OVERHEAD         // store temporary
    !check_adjacent_left:
        dey                     // decrease to get horizontal adjacent field
        bmi !return+            // if negative (out of bounds) return
        lda (ZP_MAP_ADDR_LO), y // load map data at address
        and #%1111              // remove upper nibble
        beq !return+            // if tile is empty skip
        !check_adjacent_below:
            ldy ZP_MAP_ROW      // load current row
            dey                 // decrease
            bmi !return+        // if negative (out of bounds) return
            lda dungeon_map_rows_LSB, y // load map address into temp memory
            sta ZP_MAP_TEMP_LO
            lda dungeon_map_rows_MSB, y
            sta ZP_MAP_TEMP_HI
            ldy ZP_MAP_OFFSET   // load current map offset
            lda (ZP_MAP_TEMP_LO), y // load data stored at map address
            and #%1111          // remove upper nibble
            beq !wall_straight+ // if empty go to next step
            ora #%10000000      // set bit 7 to indicate corner
            ora ZP_MAP_OVERHEAD // add stored data
            sta ZP_MAP_OVERHEAD // store memory
            jmp !return+
            !wall_straight:
                ora #%1000000       // set bit 6 to indicate it is a straight wall
                ora ZP_MAP_OVERHEAD // add stored data
                sta ZP_MAP_OVERHEAD // store in memory
    !return:
    rts

corner_check_right_down:
    ldy ZP_MAP_OFFSET           // load current map offset into y register
    lda (ZP_MAP_ADDR_LO), y     // load data stored at map address
    and #%1111                  // remove upper nibble
    sta ZP_MAP_OVERHEAD         // store temporary
    !check_adjacent_right:
        iny                     // increase to get horizontal adjacent field
        cpy #DUNGEON_MAP_WIDTH  // compare to map width
        beq !return+            // if out of bounds return
        lda (ZP_MAP_ADDR_LO), y // load map data at address
        and #%1111              // remove upper nibble
        beq !return+            // if tile is empty skip
        !check_adjacent_below:
            ldy ZP_MAP_ROW      // load current map row
            iny                 // increase by one
            cpy #DUNGEON_MAP_WIDTH  // compare to map width
            beq !return+        // if out of bounds return
            lda dungeon_map_rows_LSB, y // load map row address
            sta ZP_MAP_TEMP_LO
            lda dungeon_map_rows_MSB, y
            sta ZP_MAP_TEMP_HI
            ldy ZP_MAP_OFFSET   // load current offset
            lda (ZP_MAP_TEMP_LO), y // load map data at offset
            and #%1111          // remove upper nibble
            beq !wall_straight+ // below is empty
            ora #%10000000      // set bit 7 to indicate corner
            ora ZP_MAP_OVERHEAD // add overhead
            sta ZP_MAP_OVERHEAD // store temporary
            jmp !return+
            !wall_straight:
                ora #%1000000   // set bit 6 to indicate straight wall
                ora ZP_MAP_OVERHEAD // add overhead
                sta ZP_MAP_OVERHEAD // store overhead
    !return:
    rts

corner_check_right_up:
    ldy ZP_MAP_OFFSET           // load current map offset into y register
    lda (ZP_MAP_ADDR_LO), y     // load data stored at map address
    and #%1111                  // remove upper nibble
    sta ZP_MAP_OVERHEAD         // store temporary
    !check_adjacent_right:
        iny                     // increase to get horizontal adjacent field
        cpy #DUNGEON_MAP_WIDTH  // compare to map width
        beq !return+            // if out of bounds return
        lda (ZP_MAP_ADDR_LO), y // load map data at address
        and #%1111              // remove upper nibble
        beq !return+            // if tile is empty skip
        !check_adjacent_below:
            ldy ZP_MAP_ROW      // load current map row
            dey                 // decrease by one
            bmi !return+        // if negative (out of bounds) return
            lda dungeon_map_rows_LSB, y // load map address of row
            sta ZP_MAP_TEMP_LO
            lda dungeon_map_rows_MSB, y
            sta ZP_MAP_TEMP_HI
            ldy ZP_MAP_OFFSET   // load current offset
            lda (ZP_MAP_TEMP_LO), y // get map data at offset
            and #%1111          // remove upper nibble
            beq !wall_straight+ // below is empty
            ora #%10000000      // set bit 7 to indicate corner
            ora ZP_MAP_OVERHEAD // add overhead
            sta ZP_MAP_OVERHEAD // store temporary
            jmp !return+
            !wall_straight:
                ora #%1000000   // set bit 6 to indicate straight wall
                ora ZP_MAP_OVERHEAD // add overhead
                sta ZP_MAP_OVERHEAD // store overhead
    !return:
    rts

load_map_row:
    lda dungeon_map_rows_LSB, y // load row at current y register position
    sta ZP_MAP_ADDR_LO
    lda dungeon_map_rows_MSB, y
    sta ZP_MAP_ADDR_HI
    rts

store_north:
    lda player_pos_y        // load player y position
    sta ZP_MAP_ROW          // store in memory
    tay                     // transfer to y register
    jsr load_map_row        // load map row at player position
    !view_left:
        lda player_pos_x       // load player x position into accumulator
        sec                     // set carry
        sbc #$01                // substract 1
        clc                     // clear carry
        sta ZP_MAP_OFFSET       // store in zeropage
        tay
        lda (ZP_MAP_ADDR_LO), y // get data from dungeon map at current position
        and #%1111              // remove upper nibble
        sta ZP_MAP_OVERHEAD
        jsr check_top           // check top square (straight wall check) // no need for corner check as ther can be no corners here
        lda ZP_MAP_OVERHEAD     // load current overhead
        sta player_view_left    // store in memory for reference
    !player_position:
        inc ZP_MAP_OFFSET       // increase map offset
        ldy ZP_MAP_OFFSET       // load offset to y register
        lda (ZP_MAP_ADDR_LO), y // get data from dungeon map at current position
        and #%1111              // remove upper nibble
        sta player_position     // store in memory for reference
    !view_right:
        inc ZP_MAP_OFFSET       // add one to y register (player position + 1)
        ldy ZP_MAP_OFFSET       // load offset to y register
        lda (ZP_MAP_ADDR_LO), y // get data from dungeon map at current position
        and #%1111              // remove upper nibble
        sta ZP_MAP_OVERHEAD     // store overhead
        jsr check_top           // check top square (straight wall check) // no need for corner check as ther can be no corners here
        lda ZP_MAP_OVERHEAD     // load overhead
        sta player_view_right   // store in memory for reference
    !front_row:
        dec ZP_MAP_ROW          // decrease y position
        ldy ZP_MAP_ROW          // load y position to y register
        jsr load_map_row        // load map row at player y - 1
        dec ZP_MAP_OFFSET       // decrease x position
        dec ZP_MAP_OFFSET       // decrease x position (back to start)
    !view_front_left:
        jsr corner_check_right_down  // check right square (corner check)
        jsr check_top           // check top square (straight wall check)
        lda ZP_MAP_OVERHEAD     // load overhead
        sta player_view_left_front  // store in memory for reference
    !view_front:
        inc ZP_MAP_OFFSET       // increase x position
        ldy ZP_MAP_OFFSET       // load offset into y register
        lda (ZP_MAP_ADDR_LO), y // get data from dungeon map at current position
        and #%1111              // remove upper nibble
        sta ZP_MAP_OVERHEAD     // store overhead
        jsr check_top           // check top square (straight wall check)
        lda ZP_MAP_OVERHEAD     // load overhead
        sta player_view_front   // store in memory for reference
    !view_front_right:
        inc ZP_MAP_OFFSET       // increase x position
        jsr corner_check_left_down   // check left square (corner check)
        jsr check_top           // check top square (straight wall check)
        lda ZP_MAP_OVERHEAD     // load overhead
        sta player_view_right_front // store in memory for reference
    !far_row:
        dec ZP_MAP_ROW          // decrease y position
        lda ZP_MAP_ROW          // load row
        bmi !complete+          // if negative (out of bounds) skip
        ldy ZP_MAP_ROW          // load y position to y register
        jsr load_map_row        // load map row at player y - 2
        dec ZP_MAP_OFFSET       // decrease x position
        dec ZP_MAP_OFFSET       // decrease x position (back to start)
    !view_far_left:
        jsr corner_check_right_down // check right square (corner check) // no straight wall check needed // outside of view range
        lda ZP_MAP_OVERHEAD         // load overhead
        sta player_view_left_far    // store in memory for reference
    !view_far:      
        inc ZP_MAP_OFFSET       // increase x position
    !view_far_right:
        inc ZP_MAP_OFFSET       // increase x position
        jsr corner_check_left_down  // check left square (corner check) // no straight wall check needed // outside of view range
        jsr check_top               // check top square (straight wall check)
        lda ZP_MAP_OVERHEAD         // load overhead
        sta player_view_right_far   // store in memory for reference
    !complete:
    rts

store_east:
    lda player_pos_y        // load player y position ointo y register
    sec                     // set carry
    sbc #$01                // decrease by 1
    clc                     // clear carry
    sta ZP_MAP_ROW          // store in memory
    tay                     // transfer to y register
    jsr load_map_row        // load map row at y postion
    !view_left:
        lda player_pos_x        // load player x position into accumulator
        sta ZP_MAP_OFFSET       // store in memory
        tay                     // transfer to y register
        lda (ZP_MAP_ADDR_LO), y // get data from dungeon map at current position
        and #%1111              // remove upper nibble
        sta ZP_MAP_OVERHEAD     // store in memory
        jsr check_right         // check right square (straight wall check)
        lda ZP_MAP_OVERHEAD     // load overhead
        sta player_view_left    // store in memory
    !view_front_left:
        inc ZP_MAP_OFFSET       // increase offset by 1
        ldy ZP_MAP_OFFSET       // load into y register
        lda (ZP_MAP_ADDR_LO), y // get data from dungeon map at current position
        and #%1111              // remove upper nibble
        sta ZP_MAP_OVERHEAD     // store overhead
        jsr corner_check_down_left  // check down square (corner check)
        jsr check_right             // check right square (straight wall check)
        lda ZP_MAP_OVERHEAD         // load overhead
        sta player_view_left_front  // store in memory
    !view_far_left:
        inc ZP_MAP_OFFSET       // increase offset by 1
        ldy ZP_MAP_OFFSET       // load into y register
        lda (ZP_MAP_ADDR_LO), y // get data from dungeon map at current position
        and #%1111              // remove upper nibble
        sta ZP_MAP_OVERHEAD     // store overhead
        jsr corner_check_down_left  // check down square (corner check) 
        jsr check_right             // check right square (straight wall check)
        lda ZP_MAP_OVERHEAD         // load overhead
        sta player_view_left_far    // store in memory
    !increase_row:
        inc ZP_MAP_ROW          // increase row
        ldy ZP_MAP_ROW          // load into y regster
        jsr load_map_row
        lda player_pos_x        // load player position
        sta ZP_MAP_OFFSET       // store overhead
    !view_player:
        ldy ZP_MAP_OFFSET       // load offset
        lda (ZP_MAP_ADDR_LO), y // get data from dungeon map at current position
        and #%1111              // remove upper nibble
        sta player_position     // store inn memory
    !view_front:
        inc ZP_MAP_OFFSET       // increase offset
        ldy ZP_MAP_OFFSET       // load into y register
        lda (ZP_MAP_ADDR_LO), y // get data from dungeon map at current position
        and #%1111              // remove upper nibble
        sta ZP_MAP_OVERHEAD     // store overhead
        jsr check_right         // check right square (straight wall check)
        lda ZP_MAP_OVERHEAD     // load overhead
        sta player_view_front   // store in memory
    !view_far:
        inc ZP_MAP_OFFSET
    !increase_row:
        inc ZP_MAP_ROW          // increase row
        ldy ZP_MAP_ROW          // load into y register
        jsr load_map_row
        lda player_pos_x        // load player x position
        sta ZP_MAP_OFFSET       // store in offset
    !view_right:
        ldy ZP_MAP_OFFSET       // load offset
        lda (ZP_MAP_ADDR_LO), y // get data from dungeon map at current position
        and #%1111              // remove upper nibble
        sta ZP_MAP_OVERHEAD     // store overhead
        jsr check_right         // check right square (straight wall check)
        lda ZP_MAP_OVERHEAD     // store overhead
        sta player_view_right   // store in memory
    !view_right_front:
        inc ZP_MAP_OFFSET       // increase offset
        ldy ZP_MAP_OFFSET       // load into y register
        lda (ZP_MAP_ADDR_LO), y // get data from dungeon map at current position
        and #%1111              // remove upper nibble
        sta ZP_MAP_OVERHEAD     // store overhead
        jsr corner_check_up_left// check up square (corner check)
        jsr check_right         // check right square (straight wall check)
        lda ZP_MAP_OVERHEAD     // load overhead
        sta player_view_right_front // store in memory
    !view_right_far:
        inc ZP_MAP_OFFSET       // increase offset
        ldy ZP_MAP_OFFSET       // load into y register
        lda (ZP_MAP_ADDR_LO), y // get data from dungeon map at current position
        and #%1111              // remove upper nibble
        sta ZP_MAP_OVERHEAD     // store overhead
        jsr corner_check_up_left// check up square (corner check)
        jsr check_right         // check right square (straight wall check)
        lda ZP_MAP_OVERHEAD     // load overhead
        sta player_view_right_far   // store in memory
    !complete:
    rts

store_south:
    lda player_pos_y        // load player y position ointo y register
    sta ZP_MAP_ROW          // store in zeropage
    tay                     // transfer to y register
    jsr load_map_row        // load map row at player position
    !view_right:
        lda player_pos_x    // load player x position into accumulator
        sec                 // set carry
        sbc #$01            // substract 1
        clc                 // clear carry
        sta ZP_MAP_OFFSET   // store in zeropage
        tay                 // transfer to y register
        lda (ZP_MAP_ADDR_LO), y // get data from dungeon map at player x - 1
        and #%1111          // remove upper nibble
        sta ZP_MAP_OVERHEAD // store overhead
        jsr check_bottom    // check bottom square (straight wall check)
        lda ZP_MAP_OVERHEAD // store overhead
        sta player_view_right    // store in memory for reference
    !player_position:
        inc ZP_MAP_OFFSET   // increase offset
        ldy ZP_MAP_OFFSET   // load to y register
        lda (ZP_MAP_ADDR_LO), y // get data from dungeon map at current position
        and #%1111          // remove upper nibble
        sta player_position // store in memory for reference
    !view_left:
        inc ZP_MAP_OFFSET   // increase offset
        ldy ZP_MAP_OFFSET   // load to y register
        lda (ZP_MAP_ADDR_LO), y // get data from dungeon map at current position
        and #%1111          // remove upper nibble
        sta ZP_MAP_OVERHEAD // store overhead
        jsr check_bottom    // check bottom square (straight wall check)
        lda ZP_MAP_OVERHEAD // load overhead
        sta player_view_left// store in memory for reference
    !front_row:
        inc ZP_MAP_ROW      // increase row
        ldy ZP_MAP_ROW      // load to y register
        jsr load_map_row    // load map row at player y - 1
        dec ZP_MAP_OFFSET   // decrease offset
        dec ZP_MAP_OFFSET   // decrease offset
    !view_front_right:
        jsr corner_check_right_up   // check right square (corner check)
        jsr check_bottom    // check bottom square (straight wall check)
        lda ZP_MAP_OVERHEAD // load overhead
        sta player_view_right_front  // store in memory for reference
    !view_front:
        inc ZP_MAP_OFFSET   // increase offset
        ldy ZP_MAP_OFFSET   // load into y register
        lda (ZP_MAP_ADDR_LO), y // get data from dungeon map at current position
        and #%1111          // remove upper nibble
        sta ZP_MAP_OVERHEAD // store overhead
        jsr check_bottom    // check bottom square (straight wall check)
        sta player_view_front   // store in memory for reference
    !view_front_left:
        inc ZP_MAP_OFFSET   // increase offset
        jsr corner_check_left_up    // 
        jsr check_bottom    // check bottom square (straight wall check)
        lda ZP_MAP_OVERHEAD // load overhead
        sta player_view_left_front // store in memory for reference
    !far_row:
        inc ZP_MAP_ROW      // increase row
        lda ZP_MAP_ROW      // load into accumulator
        cmp #DUNGEON_MAP_HEIGHT  // compare to map height
        beq !complete+      // if out of bounds skip
        tay                 // transfer to y register
        jsr load_map_row        // load map row at player y - 2
        dec ZP_MAP_OFFSET   // decrease offset
        dec ZP_MAP_OFFSET   // decrease offset
    !view_far_right:
        jsr corner_check_right_up   // check right square (corner check)
        jsr check_bottom            // check bottom square (straight wall check)
        lda ZP_MAP_OVERHEAD         // load overhead
        sta player_view_right_far   // store in memory for reference
    !view_far:
        inc ZP_MAP_OFFSET           // increase offset
    !view_far_left:
        inc ZP_MAP_OFFSET           // increase offset
        jsr corner_check_left_up    // check left square (corner check)
        jsr check_bottom            // check bottom square (straight wall check)
        lda ZP_MAP_OVERHEAD         // load overhead
        sta player_view_left_far    // store in memory for reference
    !complete:
    rts

store_west:
    lda player_pos_y        // load player y position into y register
    sec                     // set carry
    sbc #$01                // substract 1
    clc                     // clear carry
    sta ZP_MAP_ROW          // store in zeropage
    tay                     // transfer to y register
    jsr load_map_row        // load map row at player position
    !view_right:
        lda player_pos_x        // load player x position into accumulator
        sta ZP_MAP_OFFSET       // store in zeropage
        tay                     // transfer to y register
        lda (ZP_MAP_ADDR_LO), y // load map data at offset
        and #%1111              // remove upper nibble
        sta ZP_MAP_OVERHEAD     // store overhead
        jsr check_left          // check left square (straight wall check)
        lda ZP_MAP_OVERHEAD     // load overhead
        sta player_view_right   // store in memory
    !view_front_right:
        dec ZP_MAP_OFFSET       // decrease offset
        jsr corner_check_down_right // check down square (corner check)
        jsr check_left              // check left square (straight wall check)
        lda ZP_MAP_OVERHEAD         // load overhead
        sta player_view_right_front // store in memory
    !view_far_right:
        dec ZP_MAP_OFFSET           // decrease offset
        jsr corner_check_down_right // check down square (corner check)
        jsr check_left              // check left square (straight wall check)
        lda ZP_MAP_OVERHEAD         // load overhead
        sta player_view_right_far   // store in memory
    !increase_row:
        inc ZP_MAP_ROW              // increase row
        ldy ZP_MAP_ROW              // load into y register
        jsr load_map_row
        lda player_pos_x            // load player origin
        sta ZP_MAP_OFFSET           // store in zeropage
    !view_player:
        ldy ZP_MAP_OFFSET           // load offset to y register
        lda (ZP_MAP_ADDR_LO), y     // get map data at offset
        and #%1111                  // remove upper nibble
        sta player_position         // store in memory
    !view_front:
        dec ZP_MAP_OFFSET           // decrease offset
        ldy ZP_MAP_OFFSET           // load into y register
        lda (ZP_MAP_ADDR_LO), y     // get map data at offset
        and #%1111                  // remove upper nibble
        sta ZP_MAP_OVERHEAD         // store overhead
        jsr check_left              // check left square (straight wall check)
        sta player_view_front       // store in memory
    !increase_row:
        inc ZP_MAP_ROW              // increase row
        ldy ZP_MAP_ROW              // load into y register
        jsr load_map_row
        lda player_pos_x            // load player origin
        sta ZP_MAP_OFFSET           // store in offset
    !view_left:
        ldy ZP_MAP_OFFSET           // load offset into y register
        lda (ZP_MAP_ADDR_LO), y     // load map data at offset
        and #%1111                  // remove upper nibble
        sta ZP_MAP_OVERHEAD         // store overhead
        jsr check_left              // check left square (straight wall check)
        lda ZP_MAP_OVERHEAD         // load overhead
        sta player_view_left        // store in memory
    !view_left_front:
        dec ZP_MAP_OFFSET           // decrease offset
        jsr corner_check_up_right   // check up square (corner check) 
        jsr check_left              // check left square (straight wall check)
        lda ZP_MAP_OVERHEAD         // load overhead
        sta player_view_left_front  // store in memory
    !view_left_far:
        dec ZP_MAP_OFFSET           // decrease offset
        jsr corner_check_up_right   // check up square (corner check)
        jsr check_left              // check left square (straight wall check)
        lda ZP_MAP_OVERHEAD         // load overhead
        sta player_view_left_far    // store in memory
    !complete:
    rts

build_strips.asm

Copy to Clipboard

set_strip_offset:
    lda ZP_MAP_OVERHEAD                 // load current overhead data
    bne !check_overhead+                // data is empty
    lda #$0                             // load 0 position of offset for return
    jmp !no_overhead+
    !check_overhead:
        clc
        rol                                 // rotat bits left
        bcc !straight_wall+                 // no carry so go to next type
        clc                                 // clear carry
        lda ZP_STRIP_OFFSET                 // load stored offset
        adc #$01                            // add 1
        jmp !return_tile+                        // return
        !straight_wall:
            rol                                 // rotate bits left
            bcc !back_wall+                     // no carry so go to next type
            clc                                 // clear carry
            lda ZP_STRIP_OFFSET                 // load stored offset
            adc #$02                            // add 2
            jmp !return_tile+                        // return
            !back_wall:
                rol                                 // rotate bits left
                bcc !back_wall_far+                 // no carry so skip
                clc                                 // clear carry
                lda ZP_STRIP_OFFSET                 // load stored offset
                adc #$03                            // add 3
                jmp !return_tile+                        // return
                !back_wall_far:
                    rol                                 // rotate bits left
                    bcc !return_tile+                        // no carry so return
                    clc                                 // clear carry
                    lda ZP_STRIP_OFFSET                 // load stored offset
                    adc #$04                            // add 4
                    jmp !return_tile+
    !no_overhead:
    lda ZP_MAP_TILE             // load current tile
    beq !return_tile+           // if empty return
    lda ZP_STRIP_OFFSET         // load current offset
    bne !return_tile+           // if empty return
    !return_tile:
    rts

store_viewport_strips:
    !front_strips:
    !left_front_strip:                  // start left_front strip
        lda #STRIPS_OFFSET_LEFT_FRONT       // load offset of left front strip
        sta ZP_STRIP_OFFSET                 // store in memory
        lda player_view_left_front          // load stored value in player_view_left_front
        and #%1111                          // get lower nibble
        sta ZP_MAP_TILE                     // store in zeropage
        lda player_view_left_front          // load stored value in player_view_left
        and #%11110000                      // get upper nibble
        sta ZP_MAP_OVERHEAD                 // store in zeropage
        jsr set_strip_offset
        sta view_strip_left_front           // store in memory
    !front_strip:
        lda #STRIPS_OFFSET_FRONT_1          // load offset of first front strip
        sta ZP_STRIP_OFFSET                 // store in memory
        lda player_view_front               // load stored value in player_view_front
        and #%1111                          // get lower nibble
        sta ZP_MAP_TILE                     // store in zeropage
        lda player_view_front               // load stored value in player_view_front
        and #%11110000                      // get upper nibble
        sta ZP_MAP_OVERHEAD                 // store in zeropage
        jsr set_strip_offset
        sta view_strip_front_1              // store in memory
        lda #STRIPS_OFFSET_FRONT_2          // load offset of second fron strip
        sta ZP_STRIP_OFFSET                 // store in memory
        jsr set_strip_offset
        sta view_strip_front_2              // store in memory
        lda #STRIPS_OFFSET_FRONT_3          // load offset of third front strip
        sta ZP_STRIP_OFFSET                 // store in memory
        jsr set_strip_offset
        sta view_strip_front_3              // store in memory
    !right_front_strip:
        lda #STRIPS_OFFSET_RIGHT_FRONT      // load offset of front right strip
        sta ZP_STRIP_OFFSET                 // store in memory
        lda player_view_right_front         // load stored value in player vier right front
        and #%1111                          // get lower nibble
        sta ZP_MAP_TILE                     // store in zeropage
        lda player_view_right_front         // load stored value in player_view_right_front
        and #%11110000                      // get upper nibble
        sta ZP_MAP_OVERHEAD                 // store in zeropage
        jsr set_strip_offset
        sta view_strip_right_front          // store in memory
    !far_strips:
    !left_far_strip:
        lda view_strip_left_front           // load left front viewstrip
        cmp #$07                            // cmp to 7 (corner)
        beq !overwrite_left_far+            // if true go to overwrite
        clc                                 // clear carry
        lda view_strip_left_front           // load left front viewstrip
        cmp #$08                            // compare to 8 (straight wall)
        beq !overwrite_left_far+            // if true go to overwrite
        lda #STRIPS_OFFSET_LEFT_FAR         // load offset of far left strip
        sta ZP_STRIP_OFFSET                 // store in memory
        lda player_view_left_far            // load stored value in player_view_left_far
        and #%1111                          // get lower nibble
        sta ZP_MAP_TILE                     // store in zeropage
        lda player_view_left_far            // load stored value in player_view_left_far
        and #%11110000                      // get upper nibble
        sta ZP_MAP_OVERHEAD                 // store in zeropage
        jsr set_strip_offset
        sta view_strip_left_far             // store in memory
        jmp !right_far_strip+               // skip overwrite code
    !overwrite_left_far:
        lda #STRIPS_OFFSET_LEFT_FAR         // load strip offset
        clc                                 // clear carry
        adc #$05                            // add 5 (override strip)
        sta view_strip_left_far             // store in memory
    !right_far_strip:
        lda view_strip_right_front          // load right front viewstrip
        cmp #$21                            // compare to 21 (corner)
        beq !overwrite_right_far+           // if true go to overwrite
        clc                                 // clear carry
        lda view_strip_right_front          // load right front viewstrip
        cmp #$22                            // compare to 22 (straight wall)
        beq !overwrite_right_far+           // if true go to overwrite
        lda #STRIPS_OFFSET_RIGHT_FAR        // load offset of far right strip
        sta ZP_STRIP_OFFSET                 // store in memory
        lda player_view_right_far           // load stored value in player_view_right_far
        and #%1111                          // get lower nibble
        sta ZP_MAP_TILE                     // store in zeropage
        lda player_view_right_far           // load stored value in player_view_right_far
        and #%11110000                      // get upper nibble
        sta ZP_MAP_OVERHEAD                 // store in zeropage
        jsr set_strip_offset
        sta view_strip_right_far            // store in memory
        jmp !left_strip+                    // skip overwrite code
    !overwrite_right_far:
        lda #STRIPS_OFFSET_RIGHT_FAR        // load strip offset
        clc                                 // clear carry
        adc #$05                            // add 5 (override strip)
        sta view_strip_right_far            // store in memory
    !left_strip:                        // start left strip
        lda #STRIPS_OFFSET_LEFT             // load offset of left strip
        sta ZP_STRIP_OFFSET                 // store in memory
        lda player_view_left                // load stored value in player_view_left
        and #%1111                          // get lower nibble
        sta ZP_MAP_TILE                     // store in zeropage
        lda player_view_left                // load stored value in player_view_left
        and #%11110000                      // get upper nibble
        sta ZP_MAP_OVERHEAD                 // store in zeropage
        jsr set_strip_offset                
        sta view_strip_left                 // store in memory
    !right_strip:
        lda #STRIPS_OFFSET_RIGHT            // load offset of right strip
        sta ZP_STRIP_OFFSET                 // store in memory
        lda player_view_right               // load stored value in player_view_right
        and #%1111                          // get lower nibble
        sta ZP_MAP_TILE                     // store in zeropage
        lda player_view_right               // load stored value in player_view_right
        and #%11110000                      // get upper nibble
        sta ZP_MAP_OVERHEAD                 // store in zeropage
        jsr set_strip_offset
        sta view_strip_right                // store in memory
    !complete:
    rts

draw_view.asm

Copy to Clipboard

draw_view:
    lda #$00
    sta ZP_STRIP_POS  
    sta ZP_VIEW_STRIP                  // set strip pos to 0
    lda #VIEWPORT_CHAR_OFFSET           // load viewport char offset
    sta ZP_CHAR_OFFSET                  // store in zeropage
    lda #VIEWPORT_PIXEL_OFFSET          // load viewport pixel offset
    sta ZP_PIXEL_OFFSET                 // store in zeropage
    !loop:
        jsr get_strip                   
        jsr draw_strip
        lda #$00                        // load 0
        sta ZP_STRIP_POS                // and reset strip position zeropage
        inc ZP_VIEW_STRIP               // increase view strip zeropage
        lda ZP_VIEW_STRIP               
        cmp #VIEWPORT_TILE_WIDTH        // while view strip is lesser than viewport width
        bne !loop-                      // repeat
    rts

get_strip:
    ldx ZP_VIEW_STRIP                    // load current strip position into x register
    lda view_strips, x                  // get strip entry at x position
    tay
    lda view_strips_LSB, y           // load strip address
    sta ZP_STRIP_LO                     // into zeropage
    lda view_strips_MSB, y
    sta ZP_STRIP_HI
    rts

draw_strip:
    lda #VIEWPORT_TILE_HEIGHT
    sta ZP_VIEWPORT_Y
    lda #$00                            // load 0
    sta ZP_TILESX                       // and reset tile x,
    sta ZP_TILEY                        // y,
    sta ZP_CHAR_POS                     // and char position
    !loop:
        ldy ZP_STRIP_POS                    // load strip position into y register
        lda (ZP_STRIP_LO), y                // get value stored at strip address
        sta ZP_TILENO                       // store in zeropage
        jsr get_view_rows
        jsr get_view_offset
        !get_tile:
            lda #DUNGEON_TILE_HEIGHT        // load dungeon tile height
            sta ZP_TILEHEIGHT               // and store in zeropage
            lda #DUNGEON_TILE_WIDTH         // load dungeon tile width
            sta ZP_TILEWIDTH                // and store in zeropage
            ldy ZP_TILENO                   // load current tile number to y register
            lda dungeon_tile_pos_LSB, y     // get dungeon tile address of current tile number
            sta ZP_TILE_ADDR_LO             // and store in zeropage
            lda dungeon_tile_pos_MSB, y
            sta ZP_TILE_ADDR_HI
        !get_char_data:
        !loop_char:
            !draw_chars:
                jsr load_dungeon_char
                ldy #0                      // load 0 to y register to only color current char
                jsr set_color
                ldy #7                      // load 7 into y register to fill one char
                jsr draw_char
                jsr update_viewport_address
                inc ZP_CHAR_POS             // increase char position
                inc ZP_TILESX               // increase tile x position
                lda ZP_TILESX               
                cmp #DUNGEON_TILE_WIDTH     // while tile x position < tile width
                bne !draw_chars-            // repeat
        inc ZP_TILEY                        // increase tile y position
        jsr get_view_rows
        jsr get_view_offset
        lda #$00                        // load 0
        sta ZP_TILESX                   // and reset tile x position
        dec ZP_TILEHEIGHT               // decrese tile height
        bne !get_char_data-             // as long as it is not 0 repeat
        inc ZP_STRIP_POS                // increase strip position
        lda #$00                        // load 0
        sta ZP_CHAR_POS                 // and reset char position
        dec ZP_VIEWPORT_Y               // decrease viewport y position
        bne !loop-                      // as long as viewport y > 0 repeat
        rts

load_dungeon_char:
    ldy ZP_CHAR_POS                         // load tile x position into y register
    lda ZP_TILE_ADDR_LO
    lda ZP_TILE_ADDR_HI
    lda (ZP_TILE_ADDR_LO), y                // get char tile from tile address
    tay
    lda dungeon_char_pos_LSB, y             // get char address
    sta ZP_CHAR_ADDR_LO                     // and store in zeropage
    lda dungeon_char_pos_MSB, y
    sta ZP_CHAR_ADDR_HI
    lda dungeon_charset_attrib_L1_data, y   // get color data from tile address
    sta ZP_COLOR                            // and store in zeropage
    lda dungeon_charset_attrib_L2_data, y
    sta ZP_COLOR_2
    rts

update_viewport_address:
    clc                                     // clear carry           
    lda ZP_BITMAP_ADDR_LO                   // load current bitmap address
    adc #$08                                // add 8
    sta ZP_BITMAP_ADDR_LO                   // and store back to zeropage
    lda ZP_BITMAP_ADDR_HI
    adc #$00
    sta ZP_BITMAP_ADDR_HI
    clc                                     // clear carry
    lda ZP_SCREEN_ADDR_LO                   // load current screen address
    adc #$01                                // add 1
    sta ZP_SCREEN_ADDR_LO                   // and store back to zeropage
    sta ZP_COLOR_ADDR_LO
    lda ZP_SCREEN_ADDR_HI
    adc #$00
    sta ZP_SCREEN_ADDR_HI
    clc                                     // clear carry
    adc #$94                                // add offset to color ram
    sta ZP_COLOR_ADDR_HI
    rts

get_view_rows:
    ldy ZP_TILEY                // load strip position into y register
    lda view_rows_LSB, y        // get bitmap start position for current strip position
    sta ZP_BITMAP_ADDR_LO       // store in zeropage
    lda view_rows_MSB, y
    sta ZP_BITMAP_ADDR_HI
    clc                         // clear carry
    lda ZP_PIXEL_OFFSET         // add pixel offset to bitmap address
    adc ZP_BITMAP_ADDR_LO       // and store in zeropage
    sta ZP_BITMAP_ADDR_LO
    lda ZP_BITMAP_ADDR_HI
    adc #$00
    sta ZP_BITMAP_ADDR_HI
    lda view_color_rows_LSB, y  // get screen ram start position for current strip position
    sta ZP_SCREEN_ADDR_LO       // store in zeropage
    sta ZP_COLOR_ADDR_LO
    lda view_color_rows_MSB, y
    sta ZP_SCREEN_ADDR_HI
    clc                         // clear carry
    lda ZP_CHAR_OFFSET          // add char offset to screen ram address
    adc ZP_SCREEN_ADDR_LO       // and store in zeropage
    sta ZP_SCREEN_ADDR_LO
    sta ZP_COLOR_ADDR_LO
    lda ZP_SCREEN_ADDR_HI
    adc #$00
    sta ZP_SCREEN_ADDR_HI
    clc                         // clear carry
    adc #$94                    // add offset to color ram MSB
    sta ZP_COLOR_ADDR_HI
    rts

get_view_offset:
    clc                             // clear carry
    ldy ZP_VIEW_STRIP               // load view strip number into y register
    lda view_rows_offset_LSB, y     // get bitmap offset based on strip number
    adc ZP_BITMAP_ADDR_LO           // add stored bitmap address
    sta ZP_BITMAP_ADDR_LO           // write to zeropage
    lda ZP_BITMAP_ADDR_HI
    adc view_rows_offset_MSB, y     // add bitmap offset MSB to bitmapp address MSB
    sta ZP_BITMAP_ADDR_HI           // write to zeropage
    clc                             // clear carry
    lda view_color_rows_offset_LSB, y   // get screen offset based on strip number
    adc ZP_SCREEN_ADDR_LO           // add stored screen address
    sta ZP_SCREEN_ADDR_LO           // write to zeropage
    sta ZP_COLOR_ADDR_LO            // write to color address
    lda ZP_SCREEN_ADDR_HI
    adc #$00
    sta ZP_SCREEN_ADDR_HI
    clc                             // clear carry
    adc #$94                        // add offset to screen address
    sta ZP_COLOR_ADDR_HI            // store in color address MSB
    rts

Cookie	Duration	Description
cookielawinfo-checkbox-analytics	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Analytics".
cookielawinfo-checkbox-functional	11 months	The cookie is set by GDPR cookie consent to record the user consent for the cookies in the category "Functional".
cookielawinfo-checkbox-necessary	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookies is used to store the user consent for the cookies in the category "Necessary".
cookielawinfo-checkbox-others	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Other.
cookielawinfo-checkbox-performance	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Performance".
viewed_cookie_policy	11 months	The cookie is set by the GDPR Cookie Consent plugin and is used to store whether or not user has consented to the use of cookies. It does not store any personal data.

Moving Right Along…

Using the Kernal

Making a move

Spinning around

Compiling the code

Related Posts

Leave A Comment Cancel reply