Source RasterPump release Silesia 2017

:BasicUpstart2(main)
//----------------------------------------------------------
// Code for creating the breakpoint file sent to Vice.
//----------------------------------------------------------
.var _useBinFolderForBreakpoints = cmdLineVars.get("usebin") == "true"
.var _createDebugFiles = cmdLineVars.get("afo") == "true"
.print "File creation " + [_createDebugFiles
    ? "enabled (creating breakpoint file)"
    : "disabled (no breakpoint file created)"]
.var brkFile
.if(_createDebugFiles) {
    .if(_useBinFolderForBreakpoints)
        .eval brkFile = createFile("bin/breakpoints.txt")
    else
        .eval brkFile = createFile("breakpoints.txt")
}
.macro break() {
.if(_createDebugFiles) {
    .eval brkFile.writeln("break " + toHexString(*))
    }
}
//------------------------------------------------------

// For C64Debugger v0.54 (2016/09/03)
.macro setbkg(color) {
.if(_createDebugFiles) {
    .eval brkFile.writeln("setbkg " + toHexString(*) + " " + color)
    }
}

//Because Kick Assembler has to be run with the -afo switch to be able to write breakpoints to a file, we can use this to enable "debugger" specific code when build with Shift-F7 or Shift-F5, ie:

.const debug = cmdLineVars.get("afo") == "true"

.if (debug) {
  inc $d020
}

.label border_color = $d020
.label screen_memory = $0400
.label memory_setup_register = $d018

.label screen_control_register1 = $d011
.label vic2_rasterline_register = $d012
.label character_rom = $d000
.const scrollLine = $0400+23*40


* = $af2 "Zmienne"
licznik:
.byte $0
gora:
.byte $0
licznik2:
.byte $1

licznik3:
.byte $1
predkosc:
.byte $0

* = $900 "program"

main:

//  jsr $e544
//:break()

lda #$00
tax
tay
jsr $1000

            lda ' '
            ldx #$0
clear:          sta $0400,x
            sta $0500,x
            sta $0600,x
            sta $0700,x
            inx
            bne clear

        lda #BLACK
        sta $d020
        sta $d021
        sei

        lda #$7f
        sta $dc0d
        sta $dd0d


        lda $dc0d
        lda $dd0d


        lda #$01
        sta $d01a

        lda #$47
        sta $d012

        lda #$1b
        sta $d011


//      lda #$35
    //  sta $01
//:break()

    lda #<irq
    sta $0314
    lda #>irq
    sta $0315


    cli //
//:break()
    //rts   //
    //  cli

        jmp *


 irq:


//:break()

//:break()
        jsr setsprites
                lda #$2f
sta $d012
cmp $d012
bne*-3
lda $1645
cmp #5
bcc skippo
:break()

lda $d020
eor #$02
sta $d020
//:break()

skippo:

         jsr $1003

//:break()

        inc $d019
         linia1:
        lda #$6b    // zaladuj do akku $6b
!loop:

        cmp $d012       // porownaj z rejestrem rastra
        bne !loop-      // Branch Not Equal? to lec do loop i czekaj dalej


//:break()
        bit $00         // ok mamy 6B. Te bit $00 i nop nie robia nic poza docyklowaniem rastra. bit $00 ma 3 cykle
        bit $00
        bit $00
        bit $00
        bit $00
        nop             // nop ma 2 cykle

        ldy #$00        // tu zaczyna sie petla zaladuj do rejestru y = 0
!kolor:
//:break()
        ldx kolor,y         // zaladuj pierwszy bajt z tablicy kolor + y
        stx $d021           // zapisz w rejestrze obrazu (paper). Ta instrukcja wykonuje sie caly czas, az do nastepnego kolory
        ldx tablica,y       // zaladuj pierwszy bajt z tablicy cyklowania (jedna linijka to 63 cykle co 8 linii)
!loop:  dex                 // wartosc Y jest np. 8 - czyli petla ma sie wykonac 8 razy, zeby przelecialo 63 cykle
        bne !loop-          // Y = 0? Nie idz do loop- (czyli pierwsze na gorze)
        iny                 // Tak? Zwieksz Y
        cpy #$24            // Czy Y=$24?
        bne !kolor-         // Nie - idz i wez kolejny kolor z tablicy kolorow jak i z tablicy opoznien
linia2:

        lda #$94                // bylo juz Y=24? to zaladuj $90
        sta $d012               // i zapisz w rejestrze rastra
 !loop:
        cmp $d012               // i znow sprawdz czy jest $90, nie to czekaj tak to
        bne !loop-


        nop
        bit $00
        bit $00
        bit $00
        bit $00
        bit $00
        bit $00
        bit $00
        bit $00
        bit $00
        bit $00
        bit $00
        bit $00
        bit $00
        bit $00
        bit $00
        bit $00

        lda #BLACK
        sta $d021
        sta $d020
        pla                 // te sa niewazne dla Ciebie
        tay
        pla
        tax
        pla

sprajt_gora:
        lda #$80
        sta $07f8

kopia_gora:
//:break()
    lda licznik2
    beq startuj_gora
    jmp czekaj
przesuniecie_gora:
startuj_gora:
    ldy #10
!loop:
    lda gora
    cmp #1
    //beq przesuniecie_dol
    beq sprajt_dol

x1:

copy:       lda kolor,y



        sta kolor-1,y
        iny
        cpy #26
        bne !loop-
        inc licznik
        lda licznik
        cmp #10
        bne wyjscie_irq_gora

        inc gora
        lda gora
        cmp #1
        beq wyjscie_irq_zwykle_gora


sprajt_dol:
        lda #$83
        sta $07f8

przesuniecie_dol:
//:break()
    lda licznik3
    beq startuj_dol
    jmp czekaj3

kopia_dol:


startuj_dol:
    ldy #16
!loop:
    lda gora
    cmp #0
    beq sprajt_gora
//  beq przesuniecie_gora

x2:
        lda kolor-2,y
        sta kolor-1,y
        dey
        cpy #00
        bne !loop-
        inc licznik
        lda licznik
        cmp #10
        bne wyjscie_z_irq_dol

        dec gora
        lda gora
        cmp #0
        beq wyjscie_irq_zwykle_dol


wyjscie_irq_gora:

    dec x1+1
    dec x1+4
    lda predkosc
    sta licznik2
jsr mainProg

    rti

wyjscie_z_irq_dol:
    inc x2+1
    inc x2+4
    lda predkosc
    sta licznik3
    rti

wyjscie_irq_zwykle_dol:
    lda #0
    sta licznik
    lda #$e0
    sta x1+1
    lda #$df
    sta x1+4
    rti

wyjscie_irq_zwykle_gora:
    lda #0
    sta licznik
    lda #$de
    sta x2+1
    lda #$df
    sta x2+4
    rti

czekaj:
        dec licznik2
        rti

czekaj3:
        dec licznik3
        rti

        * = $c000 "Scroll"

mainProg:   {
muza:
//          sei
//          lda #$17
    //      sta $d018
            lda #$1e
            sta $d018


loop1:      lda #$e9
            cmp $d012
            bne loop1
            jsr setScrollD016
//      lda $1645
//      cmp #5
//      bcc x

//white:    lda #WHITE
//      sta $d021


//x:


loop2:      lda #$ff
            cmp $d012
            bne loop2
//:break()

            lda #$c8
            sta $d016

            jsr moveScroll

//          jmp loop1
}
//----------------------------------------------------
//          Scroll
//----------------------------------------------------

setScrollD016:  {
//:break()

value:      lda #0
            and #$07
            ora #$c0
            sta $d016
            rts
}

moveScroll: {
            // Step d016
            dec setScrollD016.value+1
            dec setScrollD016.value+1
            lda setScrollD016.value+1
            and #$07
            cmp #$06
            bne exit
//brreak()

            ldx #0
loop1:      lda scrollLine+1,x
            sta scrollLine,x
            inx
            clc
            adc #64
            sta scrollLine+39,x
            cpx #39
            bne loop1


count:      ldx #0
            lda text,x
            sta scrollLine+39
            inx
//:break()
            txa
            tay
            lda drugie255
            cmp #$ff
            beq drugisc
            cpy #$ff
            bne do255
            sty drugie255
            lda drugie255
            cmp #$ff
            bne do255
            sty drugie255

//:break()
drugisc:    lda text+255,x
            cmp #$ff
            bne over2
            inx
            lda #$01
            sta count+3
over2:
            lda #$ff
            sta count+3
            inx
            stx count+1

            rts

do255:      lda text,x
            cmp #$ff
            bne over1
            sta drugie255
            ldx #0
over1:      stx count+1

exit:       rts
drugie255:
        .byte $0
* = $3000
text:       .text "umiem scrolowac duze fonty! hura! nie smiac sie! ucze sie asm. widzicie, jak ciezko mi przesuwac taki duzy scroll? rasterbar pompka skutecznie pomaga, zeby scroll jakos dojechal do konca :p yugorin of samar dziekuje za pomoc dkt,isildur,slajerek,broneck              e n d"

//"scroll zrobiony na gravity 2017 wsrod krwiozerczych atarowcow. Mechowte (64bites) dlubal gre o zebrach a ja mam 8x16 font scroll.... umiem wyswietlac i skrolowac duze fonty!!! huraaaa... Wiem, wiem, moze to i smieszne, ale jestem na poczatku drogi. Sami widzicie, jak ciezko przesuwac taki scroll, ale ten ruszajacy sie rasterbar (nauczylem sie tego tydzien temu) skutecznie pomaga, zeby scroll jakos dojechal do konca :P :P. Dziekuje za pomoc dkt, isildurowi, slajerkowi i mojemu bratu broneckowi (kurde, broneck.. mlody! moze jakas inna ksywka? ciezko to odmienic :P                           "

}
* = $3350
setsprites:

    lda #%00000001  //;how many sprites on screen - ka?dy bit=jeden sprajt
    sta $d015
    lda #$00
    sta $d010

    lda #0
    sta $d01b
    sta $d01c

    lda #$ff    //;ff= wszystkie du?e, 00=wszystkie ma?e
    sta $d017   //;Y Expand czy powi?skzone w Y
    sta $d01d   //;X Expand czy powi?skzone w X

    //lda #$80  //;gdzie jest sprite = $0900 i pierwsza klatka animacji
    //sta $07f8 //;pierwszy sprite

    //;colors
    lda #$0a
    sta $d027


    lda #$a0    //;pozX sprajta#1 na ekranie
    sta $d000
    lda #$40    //;pozY #1
    sta $d001
    rts

.pc = $3802 "Font 1"
.import c64 "font.c64"
*=$1000 "Muzyka"
.import binary "pompka.sid", $7c+2
*=$2000 "sprajty"
.import binary "pompasprites.bin"



* = $0ce0 "Kolory"
kolor:
        .byte 0,0,0,0,0,0,0,0,0,0,2,10,8,7,1,1,7,8,10,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0


* = $c00 "Tablica cyklowania"
tablica:
        .byte 8,9,9,9,9,9,9,1,8,9,9,9,9,9,9,1,8,9,9,9,9,9,9,1,8,9,9,9,9,9,9,1,8,9,9,9,9,9,9,1,8,9,9,9,9,13,9