nesdev.com

metatiletopleft:;Tile index of the top left corner of each 16x16 metatile
.db $00, $01, $02, $03
metatiletopright:;Tile index of the top right corner of each 16x16 metatile
.db $04, $05, $06, $07
metatilebottomleft:;Tile index of the bottom left corner of each 16x16 metatile
.db $08, $09, $0A, $0B
metatilebottomright:;Tile index of the bottom right corner of each 16x16 metatile
.db $0C, $0D, $0E, $0F
metatilepalette:;palette of each 16x16 metatile
.db 0, 1, 2, 3

;A 16x16 metatile is made of 8x8 tiles

row 0:;A row contains 16x16 tile indices.
.db 0, 1, 2, 3, 0, 3, 2, 1, 2, 0, 1, 3, 2, 0, 3, 1
row1:
.db 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3

;A row is made of 16x16 metatiles

rowlow:;Half the address to access a specific row index
.db low(row0);If you're not using NESASM, you'll want .db <row0 instead
.db low(row1)
rowhigh:;The other half
.db high(row0);If you're not using NESASM, you'll want .db >row0 instead
.db high(row1)

;A list of rows is made up of references to rows

level0:
.db 0, 0, 1, 0, 1
;A level is made of row numbers

;The scroll position will tell us what which row we're on.
;We divide it by 16 to get the row we need to draw
lda scrollylow
sta temp1
lda scrollyhigh
lsr a;shift the high byte into the carry
ror temp1;Shift the carry into the high byte of a copy of the low position of the scroll
;We have just done a 16bit divide by 2.

lsr a
ror temp1
;now we've divided by 4

lsr a
ror temp1
;now we've divided by 8

lsr a
ror temp1
;now we've divided by 16

ldy temp1;This is the row we want to load.
lda level0,y;We get which row we need to draw at that position

tay
lda rowlow,y;We get the low byte of where that row is
sta temp1

lda rowhigh,y;We get the high byte of where that row is.
sta temp2

ldy #0
metatileloop:
lda [temp1],y;If you're not using NESASM, you'll want lda (temp1),y instead
;The above loads the first byte of the given address. So, the leftmost metatile. Let's just copy it in a loop for now
sta metatiledump,y
iny
cpy #16
bne metatileloop

ldy #0;Now we write the left and right side of the top of the metatile alternating
metadrawloop:
lda metatiledump,y
tax;Get the index of the metatile so we can read the table
lda metatiletopleft,x
sta $2007
lda metatiletopright,x
sta $2007
iny
cpy #16
bne metadrawloop
;Top half is copied. Now the bottom half
ldy #0
metadrawloop2:
lda metatiledump,y
tax
lda metatilebottomleft,x
sta $2007
lda metatilebottomright,x
sta $2007
iny
cpy #16
bne metadrawloop2
;Done

MetatileList:
T00:         ; blank tile
 .db $00,$00,$00,$00

T01:         ; test tile
 .db $1D,$0E,$1C,$1D

T02:         ; question mark tile
 .db $26,$26,$26,$26

T03:         ; score part 1
 .db $90,$91,$00,$00

T04:         ; score part 2
 .db $92,$93,$00,$00

T05:         ; lives part 1
 .db $94,$95,$00,$00

T06:         ; lives part 2
 .db $96,$97,$00,$00

T07:         ; bombs part 1
 .db $98,$99,$00,$00

T08:         ; bombs part 2
 .db $9A,$9B,$00,$00

RowList:
R00:         ; blank row
 .dw T00,T00,T00,T00,T00,T00,T00,T00,T00,T00,T00,T00,T00,T00,T00,T00

R01:         ; test row
 .dw T01,T01,T01,T01,T01,T01,T01,T01,T01,T01,T01,T01,T01,T01,T01,T01

R02:         ; question mark row
 .dw T02,T02,T02,T02,T02,T02,T02,T02,T02,T02,T02,T02,T02,T02,T02,T02

R03:         ; status row
 .dw T00,T00,T03,T04,T00,T00,T00,T05,T06,T00,T00,T00,T07,T08,T00,T00

ScreenList:
S00:         ; test screen 1
 .dw R00,R01,R00,R01,R00,R01,R00,R01,R00,R01,R00,R01,R00,R01,R00

S01:         ; test screen 2
 .dw R02,R02,R02,R02,R02,R02,R02,R00,R02,R02,R02,R02,R02,R02,R02

S02:         ; test screen 3
 .dw R00,R00,R03,R00,R00,R03,R00,R00,R03,R00,R00,R03,R00,R00,R03

LevelList:
L01:         ; test level
 .dw S00,S01,S02,S00,S01,S02

lda scrollyhigh
asl a;Since you're storing both bytes of the screen together in your Levels. Multiply by 2 to get the offset for the start
tay;of the address.
lda L01,y;Get the low byte of the screen you're on
sta templo
iny
lda L01,y;Get the high byte of the screen you're on
sta temphi

lda scrollylow;Divide by 16 like before, except we don't need to do 16 bit because we already know what screen we're one
lsr a
lsr a
lsr a
lsr a
tay
lda (templo),y;Get the row.

rowlow:
.dl row0, row1 ;dl writes the low byte of an address
rowhigh:
.dh row0, row1 ;dh writes the high byte of an address

rows .equ row0, row1, row2

rowlow:
  .dl rows
rowhigh:
  .dh rows