// Twister 02


//==================================================================================================================
// Preprocessor
                .const testmode = 1 // Make zero to enable final assembly

//==================================================================================================================
// Globals (start at $0340)
                .const twisteri = $fa
                .const twistersi = $fd

//==================================================================================================================
// Autostart
                .if(testmode == 1) {
                    .pc = $0801 "Autostart Stub"
                    :BasicUpstart(autostart)
                    .pc = $0810 "Main Program"
autostart:

//==================================================================================================================
// Init
                    // Small test kernel
                    sei

                    lda #$35
                    sta $01

                    lda #$1b
                    sta $d011

                    lda #$7f
                    sta $dc0d
                    sta $dd0d
                    lda #$01
                    sta $d01a

                    // Init effect
                    jsr twisterdsetup
                    jsr twistersetup

                    lda $dc0d
                    lda $dd0d
                    asl $d019
                    cli

                    jmp *

//==================================================================================================================
// Music Hack
                    .pc = $1003 "Music Hack"
                    // Allow effect to call music routine when none exists
                    rts
                }

//==================================================================================================================
// Twister
                .if(testmode == 1) {
                    .pc = $1200 "Effect Data Setup"
                } else {
                    .pc = $7000 "Effect Data Setup"
                }
                // Relocate sprite data
twisterdsetup:  ldx #$3f
!:                  lda twistersprite - $01,x
                    sta $2fbf,x
                dex
                bne !-
                // Relocate char data
!:                  .for(var i = 0;i < 16;i++) {
                        lda twisterchars + i * $100,x
                        sta $3000 + i * $100,x
                    }
                inx
                bne !-
                rts

                .pc = * "Effect Setup"
                // Set irq
twistersetup:   lda #<twister
                sta $fffe
                lda #>twister
                sta $ffff
                lda #$00
                sta $d012
                // Set index var(s) and set up VIC reg's
                sta $d027
                sta $d028
                sta twisteri
                tax
                lda $d016
                ora #$10
                sta $d016
                lda #$06
                sta $d021
                lda #$0e
                sta $d022
                lda #$03
                sta $d023
                // Set up screen colors
                lda #$06
!:                  sta $d800,x
                    sta $d900,x
                    sta $da00,x
                    sta $dae8,x
                inx
                bne !-
                lda #$09
                ldx #$28
!:                  .for(var y = 0;y < 16;y++) {
                        sta $d800 + [y + 5] * 40 - 1,x
                    }
                dex
                bne !-
                // Set up l/r border sprites
                lda #$bf
                sta $07f8
                sta $07f9
                lda #$18
                sta $d000
                lda #$56
                sta $d002
                lda #$02
                sta $d010
                lda #$03
                sta $d015
                lda #$03
                sta $d017
                rts

                .pc = * "Effect"
twister:        jsr $1003
                // Set up re-entrant irq for top border line
                lda #<twister2
                sta $fffe
                lda #>twister2
                sta $ffff
                lda #$30
                sta $d012
                lda #$0e
                sta $d020
                asl $d019
                cli
                // Update twister
                inc twisteri
                lda twisteri
                asl
                and #$02
                sta $fb
                lda $d018
                and #$f1
                ora #$0d
                sta $d018
                ldy twisteri
                lda twisteritab,y
                sta $fb
                ldx #$28
!:                  stx $fc
                    lda $fb
                    adc twisterdtab,y
                    sta $fb
                    tax
                    lda twisterttab,x
                    ldx $fc
                    // Gotta love this little bit of speedcode :)
                    .for(var r = 0;r < 8;r++) {
                        .if(r > 0) {
                            .if(r > 1) {
                                and #$f8
                            }
                            ora #r
                        }
                        sta $03ff + [r + 5] * 40,x
                        sta $03ff + [r + 13] * 40,x
                    }
                    iny
                dex
                bne !-
                // Change charset halfway through twister
                lda #$9a
                    cmp $d012
                bne * - 3
                ldx #$09
                    dex
                bne * - 1
                bit $00
                inc $d018
                // Bottom border line
                lda #$fa
                    cmp $d012
                bne * - 3
                ldx #$0a
                    dex
                bne * - 1
                lda #$00
                sta $d020
                lda #$fc
                    cmp $d012
                bne * - 3
                ldx #$0a
                    dex
                bne * - 1
                lda #$0e
                sta $d020
                asl $d019
                rti

twister2:       sta twister2smca + 1
                stx twister2smcx + 1
                // Switch to and set up re-entrant irq for l/r sprite borders
                lda #<twisters
                sta $fffe
                lda #>twisters
                sta $ffff
                lda #$5c
                sta $d012
                sta twistersi
                // Top border line
                ldx #$04
                    dex
                bne * - 1
                lda #$00
                sta $d020
                lda #$32
                sta $d001
                sta $d003
                lda #$32
                    cmp $d012
                bne * - 3
                ldx #$0a
                    dex
                bne * - 1
                lda #$0f
                sta $d020
twister2smca:   lda #$00
twister2smcx:   ldx #$00
                asl $d019
                rti

twisters:       sta twisterssmca + 1
                stx twisterssmcx + 1
                // Move sprites
                lda twistersi
                sta $d001
                sta $d003
                clc
                adc #$2a
                sta twistersi
                // Reset original irq if necessary
                cmp #$04
                bne !+
                    lda #<twister
                    sta $fffe
                    lda #>twister
                    sta $ffff
                    lda #$00
!:              sta $d012
twisterssmca:   lda #$00
twisterssmcx:   ldx #$00
                asl $d019
                rti

//==================================================================================================================
// Data
                .pc = * "Data"
                // Index table (moves twister l/r)
twisteritab:    .for(var i = 0;i < 256;i++) {
                    .byte sin(i / 256 * 2 * 3.141592 * 3 + 0.8) * 32 + i
                }

                // Delta table (twists harder/softer)
twisterdtab:    .for(var i = 0;i < 256;i++) {
                    .byte [sin(i / 256 * 2 * 3.141592) + cos(i / 256 * 2 * 3.141592 * 2 + 0.3) * 0.5] * 7
                }

                // Twist table (translates a twist index into a char index, and twists a little bit more)
twisterttab:    .for(var i = 0;i < 256;i++) {
                    .byte [i / 256 * 32 * 4] << 3
                }

                .pc = * "Sprite Data"
                // L/r border sprite
twistersprite:  .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000
                .byte %11000000,%00000000,%00000000

                .pc = * "Character Data"
                // Raycaster :) generates twister charset. 32 8x1 half frames in two charsets, giving 32 16x1 full twist frames.
                .function object(p) {
                    .var q = Vector(p.getX(),cos(a) * p.getY() + sin(a) * p.getZ(),cos(a) * p.getZ() - sin(a) * p.getY())
                    //.return max(abs(q.getY()),abs(q.getZ())) - 2
                    //.return sqrt(q.getY() * q.getY() + q.getZ() * q.getZ()) - 2.5 + cos(atan2(q.getZ(),q.getY()) * 4) * 0.6
                    .return sqrt(q.getY() * q.getY() + q.getZ() * q.getZ()) - 2.5 + cos(atan2(q.getZ(),q.getY()) * 8) * 0.2
                }
twisterchars:   .for(var s = 0;s < 2;s++) {
                    .for(var t = 0;t < 32;t++) {
                        .for(var r = 0;r < 8;r++) {
                            .for(var y = 0;y < 8;y++) {
                                .var output = 0
                                .var a = t / 32 * 2 * 3.141592 / 8
                                .var e = Vector(0,0,-7)
                                .var v = Vector(0,-[[s * 64 + r * 8 + y] / 128 - 0.5],1)
                                .eval v = v / sqrt(v.getX() * v.getX() + v.getY() * v.getY() + v.getZ() * v.getZ())
                                .var done = false
                                .for(var i = 0;i < 20;i++) {
                                    .if(!done) {
                                        .var d = object(e)
                                        .if(d <= 0) {
                                            .eval done = true
                                            .var n = Vector(object(e + Vector(0.01,0,0)) - d,object(e + Vector(0,0.01,0)) - d,object(e + Vector(0,0,0.01)) - d)
                                            .eval n = n / sqrt(n.getX() * n.getX() + n.getY() * n.getY() + n.getZ() * n.getZ())
                                            .var l = Vector(0,1,-1)
                                            .eval l = l / sqrt(l.getX() * l.getX() + l.getY() * l.getY() + l.getZ() * l.getZ())
                                            .var ill = max(n * l,0)
                                            .var outputc = ill * 3.04
                                            .var dither = [outputc * 2] & 1
                                            .if(dither == 0) {
                                                .eval output = output | outputc
                                                .eval output = output << 2
                                                .eval output = output | outputc
                                                .eval output = output << 2
                                                .eval output = output | outputc
                                                .eval output = output << 2
                                                .eval output = output | outputc
                                            } else {
                                                .var outputc2 = outputc + 1
                                                .if(outputc2 > 3) .eval outputc2 = 3
                                                .if([y & 1] == 0) {
                                                    .eval output = output | outputc
                                                    .eval output = output << 2
                                                    .eval output = output | outputc2
                                                    .eval output = output << 2
                                                    .eval output = output | outputc
                                                    .eval output = output << 2
                                                    .eval output = output | outputc2
                                                } else {
                                                    .eval output = output | outputc2
                                                    .eval output = output << 2
                                                    .eval output = output | outputc
                                                    .eval output = output << 2
                                                    .eval output = output | outputc2
                                                    .eval output = output << 2
                                                    .eval output = output | outputc
                                                }
                                            }
                                        }
                                        .if(d < 0.001) .eval d = 0.001
                                        .eval e = e + v * d
                                    }
                                }
                                .byte output
                            }
                        }
                    }
                }