; life.s is implementation of Conway's Game of Life for Commodore 64 ; Copyright (C) 2009 Tommi Saviranta ; ; This program is free software: you can redistribute it and/or modify ; it under the terms of the GNU General Public License as published by ; the Free Software Foundation, either version 3 of the License, or ; (at your option) any later version. ; ; This program is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ; GNU General Public License for more details. ; ; You should have received a copy of the GNU General Public License ; along with this program. If not, see . ; 1 5.4 s ; 2 10.5 s ; 3 15.8 s ; 4 21.1 s ; 5 26.4 s ; ------------ ; avg 5.28 s processor 6502 seg data org $0801, 0 dc $0b, $08, $d9, $07, $9e, "2061", $00 dc $00, $00 seg code org 2061, 0 cld ; turn off interrupts ; this is NOT needed, but slighly speeds up calculation lda $dc0e and #254 sta $dc0e ; create custom chars ; essentially @ is dead cell, A is a live one lda #0 ldx #8 char_loop_0: sta $3000,X dex bpl char_loop_0 lda #$7f ldx 7 char_loop_1: sta $3009,X dex bpl char_loop_1 ; switch to custom char set lda $d018 and #240 adc #12 sta $d018 ; ; 38 cols ; lda $d016 ; and #$f7 ; sta $d016 ; ; ; 24 rows ; lda $d011 ; and #$f7 ; sta $d011 lda #14 sta SCREEN_BORDER lda #6 sta SCREEN_BG ; initialise screen ; ; set all cells to 0 init_screen: lda #0 ldx #0 init_screen_0: sta SCREEN_A,X sta SCREEN_A + 256,X sta SCREEN_A + 512,X sta SCREEN_A + 768,X inx bne init_screen_0 ; set cell foreground colour to match screen border lda SCREEN_BORDER ldx #0 init_screen_1: sta COLOUR,X sta COLOUR + 256,X sta COLOUR + 512,X sta COLOUR + 768,X inx bne init_screen_1 ; set wrapper border's foreground colour to match screen background ; top and bottom lda SCREEN_BG ldx #39 init_screen_2: sta COLOUR,X sta COLOUR + 24 * 40,X dex bpl init_screen_2 ; left and right ldx #25 init_screen_3: lda SCREEN_BG init_screen_3a: sta COLOUR init_screen_3b: sta COLOUR + 39 lda init_screen_3a + 1 clc adc #40 sta init_screen_3a + 1 bcc init_screen_3bi init_screen_3ai: inc init_screen_3a + 2 init_screen_3bi: lda init_screen_3b + 1 clc adc #40 sta init_screen_3b + 1 bcc init_screen_3c inc init_screen_3b + 2 init_screen_3c: dex bne init_screen_3 create_screen: lda #1 sta SCREEN_A + 15 * 40 + 20 sta SCREEN_A + 16 * 40 + 21 sta SCREEN_A + 17 * 40 + 19 sta SCREEN_A + 17 * 40 + 20 sta SCREEN_A + 17 * 40 + 21 ; sta SCREEN + 10 * 40 + 20 ; sta SCREEN + 10 * 40 + 21 ; sta SCREEN + 11 * 40 + 19 ; sta SCREEN + 11 * 40 + 20 ; sta SCREEN + 12 * 40 + 20 ; ; sta SCREEN + 17 * 40 + 30 ; sta SCREEN + 18 * 40 + 30 ; sta SCREEN + 18 * 40 + 31 copy_to_work: ldx #0 copy_to_work_0: lda SCREEN_A,X sta SCREEN_B,X lda SCREEN_A + 256,X sta SCREEN_B + 256,X lda SCREEN_A + 512,X sta SCREEN_B + 512,X lda SCREEN_A + 768,X sta SCREEN_B + 768,X inx bne copy_to_work_0 ; make sure we start with screen 0 ; set to 1, iterate: will swap screen to 0 lda #1 sta s init_tables: lda #0 sta RULE_TABLE + 0 sta RULE_TABLE + 1 sta RULE_TABLE + 2 sta RULE_TABLE + 3 sta RULE_TABLE + 4 sta RULE_TABLE + 8 sta RULE_TABLE + 9 sta RULE_TABLE + 10 sta RULE_TABLE + 11 sta RULE_TABLE + 12 sta RULE_TABLE + 13 sta RULE_TABLE + 14 sta RULE_TABLE + 15 lda #1 sta RULE_TABLE + 5 sta RULE_TABLE + 6 sta RULE_TABLE + 7 iterate: ; swap screen lda s eor #1 sta s bne swap_to_b lda 53272 and #$0f ora #16 sta 53272 jmp iterate_init swap_to_b: lda 53272 and #$0f ora #128 sta 53272 jmp iterate_init ; fall through iterate_init: lda s beq iterate_alt_init jsr init_iterate_b jmp iterate_pre_row iterate_alt_init: jsr init_iterate_a ; fall through iterate_pre_row: ldx #0 stx y_a iterate_row: ; X = memory index -- don't modify X inside the main loop! ; iterate each row backwards ; this way "dex; bpl" is enough ; other option would be to use "inx; cpx #38; beq" ldx #37 iterate_cell: ; TODO: can we save cycles by clearing carry only when needed? clc ; count neighbours ; 0, 1, 2, 40, 41, 42... try to stay on the same page ; (as opposed to 0, 40, 80, 1, 41, 81...) col_1a: lda $ffff,X ; overwritten (-1, -1) col_1b: adc $ffff,X ; overwritten ( 0, -1) col_1c: adc $ffff,X ; overwritten ( 1, -1) col_2a: adc $ffff,X ; overwritten (-1, 0) col_2c: adc $ffff,X ; overwritten ( 1, 0) col_3a: adc $ffff,X ; overwritten (-1, 1) col_3b: adc $ffff,X ; overwritten ( 0, 1) ; save 2 cycles almost every time! beq life_or_death col_3c: adc $ffff,X ; overwritten ( 1, 1) ; decide what to do with the cell life_or_death: asl col_2b: ora $ffff,X ; overwritten ( 0, 0) tay lda RULE_TABLE,Y set_state: sta $ffff,X ; overwritten ( 0, 0) increment: dex bpl iterate_cell clc inc_1a: lda col_1a + 1 adc #40 sta col_1a + 1 bcc inc_2a inc col_1a + 2 clc inc_2a: lda col_2a + 1 adc #40 sta col_2a + 1 bcc inc_3a inc col_2a + 2 clc inc_3a: lda col_3a + 1 adc #40 sta col_3a + 1 bcc inc_1b inc col_3a + 2 clc inc_1b: lda col_1b + 1 adc #40 sta col_1b + 1 bcc inc_2b inc col_1b + 2 clc inc_2b: lda col_2b + 1 adc #40 sta col_2b + 1 bcc inc_3b inc col_2b + 2 clc inc_3b: lda col_3b + 1 adc #40 sta col_3b + 1 bcc inc_1c inc col_3b + 2 clc inc_1c: lda col_1c + 1 adc #40 sta col_1c + 1 bcc inc_2c inc col_1c + 2 clc inc_2c: lda col_2c + 1 adc #40 sta col_2c + 1 bcc inc_3c inc col_2c + 2 clc inc_3c: lda col_3c + 1 adc #40 sta col_3c + 1 bcc inc_set inc col_3c + 2 clc inc_set: lda set_state + 1 adc #40 sta set_state + 1 bcc inc_done inc set_state + 2 clc inc_done: inc y_a ldy y_a cpy #23 beq screen_done jmp iterate_row ; swap screen screen_done: jmp iterate ; initialise for iteration (screen a) init_iterate_a: ; initialise read/write ; 1a ldx #SCREEN_A_1A stx col_1a + 2 ; 2a ldx #SCREEN_A_2A stx col_2a + 2 ; 3a ldx #SCREEN_A_3A stx col_3a + 2 ; 1b ldx #SCREEN_A_1B stx col_1b + 2 ; 2b ldx #SCREEN_A_2B stx col_2b + 2 ; 3b ldx #SCREEN_A_3B stx col_3b + 2 ; 1c ldx #SCREEN_A_1C stx col_1c + 2 ; 2c ldx #SCREEN_A_2C stx col_2c + 2 ; 3c ldx #SCREEN_A_3C stx col_3c + 2 ; set ldx #SCREEN_B_C stx set_state + 2 ; create wrapper borders ; corners lda SCREEN_A + 1 + 1 * 40 sta SCREEN_A + 39 + 24 * 40 lda SCREEN_A + 38 + 1 * 40 sta SCREEN_A + 0 + 24 * 40 lda SCREEN_A + 1 + 23 * 40 sta SCREEN_A + 39 + 0 * 40 lda SCREEN_A + 38 + 23 * 40 sta SCREEN_A + 0 + 0 * 40 ; horizontal lda SCREEN_A + 1 + 1 * 40 sta SCREEN_A + 1 + 24 * 40 lda SCREEN_A + 1 + 23 * 40 sta SCREEN_A + 1 + 0 * 40 lda SCREEN_A + 2 + 1 * 40 sta SCREEN_A + 2 + 24 * 40 lda SCREEN_A + 2 + 23 * 40 sta SCREEN_A + 2 + 0 * 40 lda SCREEN_A + 3 + 1 * 40 sta SCREEN_A + 3 + 24 * 40 lda SCREEN_A + 3 + 23 * 40 sta SCREEN_A + 3 + 0 * 40 lda SCREEN_A + 4 + 1 * 40 sta SCREEN_A + 4 + 24 * 40 lda SCREEN_A + 4 + 23 * 40 sta SCREEN_A + 4 + 0 * 40 lda SCREEN_A + 5 + 1 * 40 sta SCREEN_A + 5 + 24 * 40 lda SCREEN_A + 5 + 23 * 40 sta SCREEN_A + 5 + 0 * 40 lda SCREEN_A + 6 + 1 * 40 sta SCREEN_A + 6 + 24 * 40 lda SCREEN_A + 6 + 23 * 40 sta SCREEN_A + 6 + 0 * 40 lda SCREEN_A + 7 + 1 * 40 sta SCREEN_A + 7 + 24 * 40 lda SCREEN_A + 7 + 23 * 40 sta SCREEN_A + 7 + 0 * 40 lda SCREEN_A + 8 + 1 * 40 sta SCREEN_A + 8 + 24 * 40 lda SCREEN_A + 8 + 23 * 40 sta SCREEN_A + 8 + 0 * 40 lda SCREEN_A + 9 + 1 * 40 sta SCREEN_A + 9 + 24 * 40 lda SCREEN_A + 9 + 23 * 40 sta SCREEN_A + 9 + 0 * 40 lda SCREEN_A + 10 + 1 * 40 sta SCREEN_A + 10 + 24 * 40 lda SCREEN_A + 10 + 23 * 40 sta SCREEN_A + 10 + 0 * 40 lda SCREEN_A + 11 + 1 * 40 sta SCREEN_A + 11 + 24 * 40 lda SCREEN_A + 11 + 23 * 40 sta SCREEN_A + 11 + 0 * 40 lda SCREEN_A + 12 + 1 * 40 sta SCREEN_A + 12 + 24 * 40 lda SCREEN_A + 12 + 23 * 40 sta SCREEN_A + 12 + 0 * 40 lda SCREEN_A + 13 + 1 * 40 sta SCREEN_A + 13 + 24 * 40 lda SCREEN_A + 13 + 23 * 40 sta SCREEN_A + 13 + 0 * 40 lda SCREEN_A + 14 + 1 * 40 sta SCREEN_A + 14 + 24 * 40 lda SCREEN_A + 14 + 23 * 40 sta SCREEN_A + 14 + 0 * 40 lda SCREEN_A + 15 + 1 * 40 sta SCREEN_A + 15 + 24 * 40 lda SCREEN_A + 15 + 23 * 40 sta SCREEN_A + 15 + 0 * 40 lda SCREEN_A + 16 + 1 * 40 sta SCREEN_A + 16 + 24 * 40 lda SCREEN_A + 16 + 23 * 40 sta SCREEN_A + 16 + 0 * 40 lda SCREEN_A + 17 + 1 * 40 sta SCREEN_A + 17 + 24 * 40 lda SCREEN_A + 17 + 23 * 40 sta SCREEN_A + 17 + 0 * 40 lda SCREEN_A + 18 + 1 * 40 sta SCREEN_A + 18 + 24 * 40 lda SCREEN_A + 18 + 23 * 40 sta SCREEN_A + 18 + 0 * 40 lda SCREEN_A + 19 + 1 * 40 sta SCREEN_A + 19 + 24 * 40 lda SCREEN_A + 19 + 23 * 40 sta SCREEN_A + 19 + 0 * 40 lda SCREEN_A + 20 + 1 * 40 sta SCREEN_A + 20 + 24 * 40 lda SCREEN_A + 20 + 23 * 40 sta SCREEN_A + 20 + 0 * 40 lda SCREEN_A + 21 + 1 * 40 sta SCREEN_A + 21 + 24 * 40 lda SCREEN_A + 21 + 23 * 40 sta SCREEN_A + 21 + 0 * 40 lda SCREEN_A + 22 + 1 * 40 sta SCREEN_A + 22 + 24 * 40 lda SCREEN_A + 22 + 23 * 40 sta SCREEN_A + 22 + 0 * 40 lda SCREEN_A + 23 + 1 * 40 sta SCREEN_A + 23 + 24 * 40 lda SCREEN_A + 23 + 23 * 40 sta SCREEN_A + 23 + 0 * 40 lda SCREEN_A + 24 + 1 * 40 sta SCREEN_A + 24 + 24 * 40 lda SCREEN_A + 24 + 23 * 40 sta SCREEN_A + 24 + 0 * 40 lda SCREEN_A + 25 + 1 * 40 sta SCREEN_A + 25 + 24 * 40 lda SCREEN_A + 25 + 23 * 40 sta SCREEN_A + 25 + 0 * 40 lda SCREEN_A + 26 + 1 * 40 sta SCREEN_A + 26 + 24 * 40 lda SCREEN_A + 26 + 23 * 40 sta SCREEN_A + 26 + 0 * 40 lda SCREEN_A + 27 + 1 * 40 sta SCREEN_A + 27 + 24 * 40 lda SCREEN_A + 27 + 23 * 40 sta SCREEN_A + 27 + 0 * 40 lda SCREEN_A + 28 + 1 * 40 sta SCREEN_A + 28 + 24 * 40 lda SCREEN_A + 28 + 23 * 40 sta SCREEN_A + 28 + 0 * 40 lda SCREEN_A + 29 + 1 * 40 sta SCREEN_A + 29 + 24 * 40 lda SCREEN_A + 29 + 23 * 40 sta SCREEN_A + 29 + 0 * 40 lda SCREEN_A + 30 + 1 * 40 sta SCREEN_A + 30 + 24 * 40 lda SCREEN_A + 30 + 23 * 40 sta SCREEN_A + 30 + 0 * 40 lda SCREEN_A + 31 + 1 * 40 sta SCREEN_A + 31 + 24 * 40 lda SCREEN_A + 31 + 23 * 40 sta SCREEN_A + 31 + 0 * 40 lda SCREEN_A + 32 + 1 * 40 sta SCREEN_A + 32 + 24 * 40 lda SCREEN_A + 32 + 23 * 40 sta SCREEN_A + 32 + 0 * 40 lda SCREEN_A + 33 + 1 * 40 sta SCREEN_A + 33 + 24 * 40 lda SCREEN_A + 33 + 23 * 40 sta SCREEN_A + 33 + 0 * 40 lda SCREEN_A + 34 + 1 * 40 sta SCREEN_A + 34 + 24 * 40 lda SCREEN_A + 34 + 23 * 40 sta SCREEN_A + 34 + 0 * 40 lda SCREEN_A + 35 + 1 * 40 sta SCREEN_A + 35 + 24 * 40 lda SCREEN_A + 35 + 23 * 40 sta SCREEN_A + 35 + 0 * 40 lda SCREEN_A + 36 + 1 * 40 sta SCREEN_A + 36 + 24 * 40 lda SCREEN_A + 36 + 23 * 40 sta SCREEN_A + 36 + 0 * 40 lda SCREEN_A + 37 + 1 * 40 sta SCREEN_A + 37 + 24 * 40 lda SCREEN_A + 37 + 23 * 40 sta SCREEN_A + 37 + 0 * 40 lda SCREEN_A + 38 + 1 * 40 sta SCREEN_A + 38 + 24 * 40 lda SCREEN_A + 38 + 23 * 40 sta SCREEN_A + 38 + 0 * 40 ; vertical lda SCREEN_A + 1 + 1 * 40 sta SCREEN_A + 39 + 1 * 40 lda SCREEN_A + 38 + 1 * 40 sta SCREEN_A + 0 + 1 * 40 lda SCREEN_A + 1 + 2 * 40 sta SCREEN_A + 39 + 2 * 40 lda SCREEN_A + 38 + 2 * 40 sta SCREEN_A + 0 + 2 * 40 lda SCREEN_A + 1 + 3 * 40 sta SCREEN_A + 39 + 3 * 40 lda SCREEN_A + 38 + 3 * 40 sta SCREEN_A + 0 + 3 * 40 lda SCREEN_A + 1 + 4 * 40 sta SCREEN_A + 39 + 4 * 40 lda SCREEN_A + 38 + 4 * 40 sta SCREEN_A + 0 + 4 * 40 lda SCREEN_A + 1 + 5 * 40 sta SCREEN_A + 39 + 5 * 40 lda SCREEN_A + 38 + 5 * 40 sta SCREEN_A + 0 + 5 * 40 lda SCREEN_A + 1 + 6 * 40 sta SCREEN_A + 39 + 6 * 40 lda SCREEN_A + 38 + 6 * 40 sta SCREEN_A + 0 + 6 * 40 lda SCREEN_A + 1 + 7 * 40 sta SCREEN_A + 39 + 7 * 40 lda SCREEN_A + 38 + 7 * 40 sta SCREEN_A + 0 + 7 * 40 lda SCREEN_A + 1 + 8 * 40 sta SCREEN_A + 39 + 8 * 40 lda SCREEN_A + 38 + 8 * 40 sta SCREEN_A + 0 + 8 * 40 lda SCREEN_A + 1 + 9 * 40 sta SCREEN_A + 39 + 9 * 40 lda SCREEN_A + 38 + 9 * 40 sta SCREEN_A + 0 + 9 * 40 lda SCREEN_A + 1 + 10 * 40 sta SCREEN_A + 39 + 10 * 40 lda SCREEN_A + 38 + 10 * 40 sta SCREEN_A + 0 + 10 * 40 lda SCREEN_A + 1 + 11 * 40 sta SCREEN_A + 39 + 11 * 40 lda SCREEN_A + 38 + 11 * 40 sta SCREEN_A + 0 + 11 * 40 lda SCREEN_A + 1 + 12 * 40 sta SCREEN_A + 39 + 12 * 40 lda SCREEN_A + 38 + 12 * 40 sta SCREEN_A + 0 + 12 * 40 lda SCREEN_A + 1 + 13 * 40 sta SCREEN_A + 39 + 13 * 40 lda SCREEN_A + 38 + 13 * 40 sta SCREEN_A + 0 + 13 * 40 lda SCREEN_A + 1 + 14 * 40 sta SCREEN_A + 39 + 14 * 40 lda SCREEN_A + 38 + 14 * 40 sta SCREEN_A + 0 + 14 * 40 lda SCREEN_A + 1 + 15 * 40 sta SCREEN_A + 39 + 15 * 40 lda SCREEN_A + 38 + 15 * 40 sta SCREEN_A + 0 + 15 * 40 lda SCREEN_A + 1 + 16 * 40 sta SCREEN_A + 39 + 16 * 40 lda SCREEN_A + 38 + 16 * 40 sta SCREEN_A + 0 + 16 * 40 lda SCREEN_A + 1 + 17 * 40 sta SCREEN_A + 39 + 17 * 40 lda SCREEN_A + 38 + 17 * 40 sta SCREEN_A + 0 + 17 * 40 lda SCREEN_A + 1 + 18 * 40 sta SCREEN_A + 39 + 18 * 40 lda SCREEN_A + 38 + 18 * 40 sta SCREEN_A + 0 + 18 * 40 lda SCREEN_A + 1 + 19 * 40 sta SCREEN_A + 39 + 19 * 40 lda SCREEN_A + 38 + 19 * 40 sta SCREEN_A + 0 + 19 * 40 lda SCREEN_A + 1 + 20 * 40 sta SCREEN_A + 39 + 20 * 40 lda SCREEN_A + 38 + 20 * 40 sta SCREEN_A + 0 + 20 * 40 lda SCREEN_A + 1 + 21 * 40 sta SCREEN_A + 39 + 21 * 40 lda SCREEN_A + 38 + 21 * 40 sta SCREEN_A + 0 + 21 * 40 lda SCREEN_A + 1 + 22 * 40 sta SCREEN_A + 39 + 22 * 40 lda SCREEN_A + 38 + 22 * 40 sta SCREEN_A + 0 + 22 * 40 lda SCREEN_A + 1 + 23 * 40 sta SCREEN_A + 39 + 23 * 40 lda SCREEN_A + 38 + 23 * 40 sta SCREEN_A + 0 + 23 * 40 rts ; initialise for iteration (screen b) init_iterate_b: ; initialise read/write ; 1a ldx #SCREEN_B_1A stx col_1a + 2 ; 2a ldx #SCREEN_B_2A stx col_2a + 2 ; 3a ldx #SCREEN_B_3A stx col_3a + 2 ; 1b ldx #SCREEN_B_1B stx col_1b + 2 ; 2b ldx #SCREEN_B_2B stx col_2b + 2 ; 3b ldx #SCREEN_B_3B stx col_3b + 2 ; 1c ldx #SCREEN_B_1C stx col_1c + 2 ; 2c ldx #SCREEN_B_2C stx col_2c + 2 ; 3c ldx #SCREEN_B_3C stx col_3c + 2 ; set ldx #SCREEN_A_C stx set_state + 2 ; create wrapper borders ; corners lda SCREEN_B + 1 + 1 * 40 sta SCREEN_B + 39 + 24 * 40 lda SCREEN_B + 38 + 1 * 40 sta SCREEN_B + 0 + 24 * 40 lda SCREEN_B + 1 + 23 * 40 sta SCREEN_B + 39 + 0 * 40 lda SCREEN_B + 38 + 23 * 40 sta SCREEN_B + 0 + 0 * 40 ; horizontal lda SCREEN_B + 1 + 1 * 40 sta SCREEN_B + 1 + 24 * 40 lda SCREEN_B + 1 + 23 * 40 sta SCREEN_B + 1 + 0 * 40 lda SCREEN_B + 2 + 1 * 40 sta SCREEN_B + 2 + 24 * 40 lda SCREEN_B + 2 + 23 * 40 sta SCREEN_B + 2 + 0 * 40 lda SCREEN_B + 3 + 1 * 40 sta SCREEN_B + 3 + 24 * 40 lda SCREEN_B + 3 + 23 * 40 sta SCREEN_B + 3 + 0 * 40 lda SCREEN_B + 4 + 1 * 40 sta SCREEN_B + 4 + 24 * 40 lda SCREEN_B + 4 + 23 * 40 sta SCREEN_B + 4 + 0 * 40 lda SCREEN_B + 5 + 1 * 40 sta SCREEN_B + 5 + 24 * 40 lda SCREEN_B + 5 + 23 * 40 sta SCREEN_B + 5 + 0 * 40 lda SCREEN_B + 6 + 1 * 40 sta SCREEN_B + 6 + 24 * 40 lda SCREEN_B + 6 + 23 * 40 sta SCREEN_B + 6 + 0 * 40 lda SCREEN_B + 7 + 1 * 40 sta SCREEN_B + 7 + 24 * 40 lda SCREEN_B + 7 + 23 * 40 sta SCREEN_B + 7 + 0 * 40 lda SCREEN_B + 8 + 1 * 40 sta SCREEN_B + 8 + 24 * 40 lda SCREEN_B + 8 + 23 * 40 sta SCREEN_B + 8 + 0 * 40 lda SCREEN_B + 9 + 1 * 40 sta SCREEN_B + 9 + 24 * 40 lda SCREEN_B + 9 + 23 * 40 sta SCREEN_B + 9 + 0 * 40 lda SCREEN_B + 10 + 1 * 40 sta SCREEN_B + 10 + 24 * 40 lda SCREEN_B + 10 + 23 * 40 sta SCREEN_B + 10 + 0 * 40 lda SCREEN_B + 11 + 1 * 40 sta SCREEN_B + 11 + 24 * 40 lda SCREEN_B + 11 + 23 * 40 sta SCREEN_B + 11 + 0 * 40 lda SCREEN_B + 12 + 1 * 40 sta SCREEN_B + 12 + 24 * 40 lda SCREEN_B + 12 + 23 * 40 sta SCREEN_B + 12 + 0 * 40 lda SCREEN_B + 13 + 1 * 40 sta SCREEN_B + 13 + 24 * 40 lda SCREEN_B + 13 + 23 * 40 sta SCREEN_B + 13 + 0 * 40 lda SCREEN_B + 14 + 1 * 40 sta SCREEN_B + 14 + 24 * 40 lda SCREEN_B + 14 + 23 * 40 sta SCREEN_B + 14 + 0 * 40 lda SCREEN_B + 15 + 1 * 40 sta SCREEN_B + 15 + 24 * 40 lda SCREEN_B + 15 + 23 * 40 sta SCREEN_B + 15 + 0 * 40 lda SCREEN_B + 16 + 1 * 40 sta SCREEN_B + 16 + 24 * 40 lda SCREEN_B + 16 + 23 * 40 sta SCREEN_B + 16 + 0 * 40 lda SCREEN_B + 17 + 1 * 40 sta SCREEN_B + 17 + 24 * 40 lda SCREEN_B + 17 + 23 * 40 sta SCREEN_B + 17 + 0 * 40 lda SCREEN_B + 18 + 1 * 40 sta SCREEN_B + 18 + 24 * 40 lda SCREEN_B + 18 + 23 * 40 sta SCREEN_B + 18 + 0 * 40 lda SCREEN_B + 19 + 1 * 40 sta SCREEN_B + 19 + 24 * 40 lda SCREEN_B + 19 + 23 * 40 sta SCREEN_B + 19 + 0 * 40 lda SCREEN_B + 20 + 1 * 40 sta SCREEN_B + 20 + 24 * 40 lda SCREEN_B + 20 + 23 * 40 sta SCREEN_B + 20 + 0 * 40 lda SCREEN_B + 21 + 1 * 40 sta SCREEN_B + 21 + 24 * 40 lda SCREEN_B + 21 + 23 * 40 sta SCREEN_B + 21 + 0 * 40 lda SCREEN_B + 22 + 1 * 40 sta SCREEN_B + 22 + 24 * 40 lda SCREEN_B + 22 + 23 * 40 sta SCREEN_B + 22 + 0 * 40 lda SCREEN_B + 23 + 1 * 40 sta SCREEN_B + 23 + 24 * 40 lda SCREEN_B + 23 + 23 * 40 sta SCREEN_B + 23 + 0 * 40 lda SCREEN_B + 24 + 1 * 40 sta SCREEN_B + 24 + 24 * 40 lda SCREEN_B + 24 + 23 * 40 sta SCREEN_B + 24 + 0 * 40 lda SCREEN_B + 25 + 1 * 40 sta SCREEN_B + 25 + 24 * 40 lda SCREEN_B + 25 + 23 * 40 sta SCREEN_B + 25 + 0 * 40 lda SCREEN_B + 26 + 1 * 40 sta SCREEN_B + 26 + 24 * 40 lda SCREEN_B + 26 + 23 * 40 sta SCREEN_B + 26 + 0 * 40 lda SCREEN_B + 27 + 1 * 40 sta SCREEN_B + 27 + 24 * 40 lda SCREEN_B + 27 + 23 * 40 sta SCREEN_B + 27 + 0 * 40 lda SCREEN_B + 28 + 1 * 40 sta SCREEN_B + 28 + 24 * 40 lda SCREEN_B + 28 + 23 * 40 sta SCREEN_B + 28 + 0 * 40 lda SCREEN_B + 29 + 1 * 40 sta SCREEN_B + 29 + 24 * 40 lda SCREEN_B + 29 + 23 * 40 sta SCREEN_B + 29 + 0 * 40 lda SCREEN_B + 30 + 1 * 40 sta SCREEN_B + 30 + 24 * 40 lda SCREEN_B + 30 + 23 * 40 sta SCREEN_B + 30 + 0 * 40 lda SCREEN_B + 31 + 1 * 40 sta SCREEN_B + 31 + 24 * 40 lda SCREEN_B + 31 + 23 * 40 sta SCREEN_B + 31 + 0 * 40 lda SCREEN_B + 32 + 1 * 40 sta SCREEN_B + 32 + 24 * 40 lda SCREEN_B + 32 + 23 * 40 sta SCREEN_B + 32 + 0 * 40 lda SCREEN_B + 33 + 1 * 40 sta SCREEN_B + 33 + 24 * 40 lda SCREEN_B + 33 + 23 * 40 sta SCREEN_B + 33 + 0 * 40 lda SCREEN_B + 34 + 1 * 40 sta SCREEN_B + 34 + 24 * 40 lda SCREEN_B + 34 + 23 * 40 sta SCREEN_B + 34 + 0 * 40 lda SCREEN_B + 35 + 1 * 40 sta SCREEN_B + 35 + 24 * 40 lda SCREEN_B + 35 + 23 * 40 sta SCREEN_B + 35 + 0 * 40 lda SCREEN_B + 36 + 1 * 40 sta SCREEN_B + 36 + 24 * 40 lda SCREEN_B + 36 + 23 * 40 sta SCREEN_B + 36 + 0 * 40 lda SCREEN_B + 37 + 1 * 40 sta SCREEN_B + 37 + 24 * 40 lda SCREEN_B + 37 + 23 * 40 sta SCREEN_B + 37 + 0 * 40 lda SCREEN_B + 38 + 1 * 40 sta SCREEN_B + 38 + 24 * 40 lda SCREEN_B + 38 + 23 * 40 sta SCREEN_B + 38 + 0 * 40 ; vertical lda SCREEN_B + 1 + 1 * 40 sta SCREEN_B + 39 + 1 * 40 lda SCREEN_B + 38 + 1 * 40 sta SCREEN_B + 0 + 1 * 40 lda SCREEN_B + 1 + 2 * 40 sta SCREEN_B + 39 + 2 * 40 lda SCREEN_B + 38 + 2 * 40 sta SCREEN_B + 0 + 2 * 40 lda SCREEN_B + 1 + 3 * 40 sta SCREEN_B + 39 + 3 * 40 lda SCREEN_B + 38 + 3 * 40 sta SCREEN_B + 0 + 3 * 40 lda SCREEN_B + 1 + 4 * 40 sta SCREEN_B + 39 + 4 * 40 lda SCREEN_B + 38 + 4 * 40 sta SCREEN_B + 0 + 4 * 40 lda SCREEN_B + 1 + 5 * 40 sta SCREEN_B + 39 + 5 * 40 lda SCREEN_B + 38 + 5 * 40 sta SCREEN_B + 0 + 5 * 40 lda SCREEN_B + 1 + 6 * 40 sta SCREEN_B + 39 + 6 * 40 lda SCREEN_B + 38 + 6 * 40 sta SCREEN_B + 0 + 6 * 40 lda SCREEN_B + 1 + 7 * 40 sta SCREEN_B + 39 + 7 * 40 lda SCREEN_B + 38 + 7 * 40 sta SCREEN_B + 0 + 7 * 40 lda SCREEN_B + 1 + 8 * 40 sta SCREEN_B + 39 + 8 * 40 lda SCREEN_B + 38 + 8 * 40 sta SCREEN_B + 0 + 8 * 40 lda SCREEN_B + 1 + 9 * 40 sta SCREEN_B + 39 + 9 * 40 lda SCREEN_B + 38 + 9 * 40 sta SCREEN_B + 0 + 9 * 40 lda SCREEN_B + 1 + 10 * 40 sta SCREEN_B + 39 + 10 * 40 lda SCREEN_B + 38 + 10 * 40 sta SCREEN_B + 0 + 10 * 40 lda SCREEN_B + 1 + 11 * 40 sta SCREEN_B + 39 + 11 * 40 lda SCREEN_B + 38 + 11 * 40 sta SCREEN_B + 0 + 11 * 40 lda SCREEN_B + 1 + 12 * 40 sta SCREEN_B + 39 + 12 * 40 lda SCREEN_B + 38 + 12 * 40 sta SCREEN_B + 0 + 12 * 40 lda SCREEN_B + 1 + 13 * 40 sta SCREEN_B + 39 + 13 * 40 lda SCREEN_B + 38 + 13 * 40 sta SCREEN_B + 0 + 13 * 40 lda SCREEN_B + 1 + 14 * 40 sta SCREEN_B + 39 + 14 * 40 lda SCREEN_B + 38 + 14 * 40 sta SCREEN_B + 0 + 14 * 40 lda SCREEN_B + 1 + 15 * 40 sta SCREEN_B + 39 + 15 * 40 lda SCREEN_B + 38 + 15 * 40 sta SCREEN_B + 0 + 15 * 40 lda SCREEN_B + 1 + 16 * 40 sta SCREEN_B + 39 + 16 * 40 lda SCREEN_B + 38 + 16 * 40 sta SCREEN_B + 0 + 16 * 40 lda SCREEN_B + 1 + 17 * 40 sta SCREEN_B + 39 + 17 * 40 lda SCREEN_B + 38 + 17 * 40 sta SCREEN_B + 0 + 17 * 40 lda SCREEN_B + 1 + 18 * 40 sta SCREEN_B + 39 + 18 * 40 lda SCREEN_B + 38 + 18 * 40 sta SCREEN_B + 0 + 18 * 40 lda SCREEN_B + 1 + 19 * 40 sta SCREEN_B + 39 + 19 * 40 lda SCREEN_B + 38 + 19 * 40 sta SCREEN_B + 0 + 19 * 40 lda SCREEN_B + 1 + 20 * 40 sta SCREEN_B + 39 + 20 * 40 lda SCREEN_B + 38 + 20 * 40 sta SCREEN_B + 0 + 20 * 40 lda SCREEN_B + 1 + 21 * 40 sta SCREEN_B + 39 + 21 * 40 lda SCREEN_B + 38 + 21 * 40 sta SCREEN_B + 0 + 21 * 40 lda SCREEN_B + 1 + 22 * 40 sta SCREEN_B + 39 + 22 * 40 lda SCREEN_B + 38 + 22 * 40 sta SCREEN_B + 0 + 22 * 40 lda SCREEN_B + 1 + 23 * 40 sta SCREEN_B + 39 + 23 * 40 lda SCREEN_B + 38 + 23 * 40 sta SCREEN_B + 0 + 23 * 40 rts ; DRAGONS BE HERE SCREEN_A equ $0400 SCREEN_B equ $2000 COLOUR equ $d800 SCREEN_BORDER equ $d020 SCREEN_BG equ $d021 SCREEN_A_1A equ SCREEN_A + 0 + 0 * 40 SCREEN_A_1B equ SCREEN_A + 0 + 1 * 40 SCREEN_A_1C equ SCREEN_A + 0 + 2 * 40 SCREEN_A_2A equ SCREEN_A + 1 + 0 * 40 SCREEN_A_2B equ SCREEN_A + 1 + 1 * 40 SCREEN_A_2C equ SCREEN_A + 1 + 2 * 40 SCREEN_A_3A equ SCREEN_A + 2 + 0 * 40 SCREEN_A_3B equ SCREEN_A + 2 + 1 * 40 SCREEN_A_3C equ SCREEN_A + 2 + 2 * 40 SCREEN_A_C equ SCREEN_A_2B SCREEN_B_1A equ SCREEN_B + 0 + 0 * 40 SCREEN_B_1B equ SCREEN_B + 0 + 1 * 40 SCREEN_B_1C equ SCREEN_B + 0 + 2 * 40 SCREEN_B_2A equ SCREEN_B + 1 + 0 * 40 SCREEN_B_2B equ SCREEN_B + 1 + 1 * 40 SCREEN_B_2C equ SCREEN_B + 1 + 2 * 40 SCREEN_B_3A equ SCREEN_B + 2 + 0 * 40 SCREEN_B_3B equ SCREEN_B + 2 + 1 * 40 SCREEN_B_3C equ SCREEN_B + 2 + 2 * 40 SCREEN_B_C equ SCREEN_B_2B ; we could use zero page, but that doesn't improve performance one bit ; besides, dasm starts spamming with pointless "label mismatch" warnings... y_a equ $fc s equ $fd RULE_TABLE equ $80