| |
Ejner
Registered: Oct 2012
Posts: 43 |
Show Koala Pic
I'm sure noone here has any problems with showing a simple Koala picture, but I came across this piece of code on codebase64.org and wondered why this had to be done so complicated...?
http://codebase64.org/doku.php?id=base:calculate_vic_settings_f..
In TurboAssembler it's pretty simple to calculate the VIC settings, see my example below. Isn't something similar possible with KickAssembler? Just wondering...
Example in TurboAssembler:
;---------------------------------------
; Show Koala
;---------------------------------------
koala = $6000
screen = $5c00
;---------------------------------------
bank = koala/$4000
*= $1000
lda #$3b
sta $d011
lda #koala-($4000*bank)/1024
ora #(screen-($4000*bank))/64
sta $d018
lda #$d8
sta $d016
lda $dd02
ora #%00000011
sta $dd02
lda $dd00
and #%11111100
ora #3-bank
sta $dd00
ldx #0
copy lda koala+$1f40,x
sta screen,x
lda koala+$2040,x
sta screen+$0100,x
lda koala+$2140,x
sta screen+$0200,x
lda koala+$2228,x
sta screen+$02e8,x
lda koala+$2328,x
sta $d800,x
lda koala+$2428,x
sta $d900,x
lda koala+$2528,x
sta $da00,x
lda koala+$2610,x
sta $dae8,x
inx
bne copy
lda koala+$2710
sta $d021
lsr a
lsr a
lsr a
lsr a
sta $d020
lda #0
cmp $0277 ;wait for key
bne *-3
lda $dd02
ora #%00000011
sta $dd02
lda $dd00
and #%11111100
ora #%00000011
sta $dd00
lda #$1b
sta $d011
lda #$15
sta $d018
lda #$c8
sta $d016
jmp $9000
;---------------------------------------
Note: The result of "bank = koala/$4000" is an integer. |
|
| |
Mace
Registered: May 2002
Posts: 1799 |
This shows how it's done in detail.
Of course for your own program, you can change it, but for educational purposes, it's sometimes easier to follow when everything is written in all detail. |
| |
Burglar
Registered: Dec 2004
Posts: 1033 |
.macro set_bank(screenram,bitmap) {
.var cur_dd00 = [ >screenram >> 6 ] ^ %00000011
.eval screenram = screenram & $3fff
.eval bitmap = bitmap & $3fff
.var cur_d018 = [ [ >screenram << 2 ] + [ >bitmap >> 2 ] ]
lda $dd00
and #%1111100
ora #cur_dd00
sta $dd00
lda #cur_d018
sta $d018
}and then you can :set_bank($0400,$2000) |
| |
Ejner
Registered: Oct 2012
Posts: 43 |
Thanks Burglar, thats a neat little snippet of code there :-) |
| |
Burglar
Registered: Dec 2004
Posts: 1033 |
annoying bug in the macro I posted. finally found out that *that* was causing random weirdness in 1 out of 20 runs or so.
lda $dd00
and #%11111100 <-- one more bit added
ora #cur_dd00
sta $dd00
subtle type, I was anding with #$7c instead of #$fc. it will bug your loader possibly. also might add that even this fixed one isnt 100% stable if you use it while loading |
| |
Slammer
Registered: Feb 2004
Posts: 416 |
Burglars way of doing it is pretty handy.. Especially when setting dd00. An alternative way of doing these things are defining functions like:
.function screenToD018(addr) {
.return [[addr&$3fff]/$400]<<4
}
.function charsetToD018(addr) {
.return [[addr&$3fff]/$800]<<1
}
.function toD018(screen, charset) {
.return screenToD018(screen) | charsetToD018(charset)
}
.function toSpritePtr(addr) {
.return [addr&$3fff]/$40
}
etc.
With functions like these you can do:
lda #toD018(logoScreen, logoCharset)
sta $d018 but also make tables if thats what you need:
.byte toD018(screen1,charset), toD018(screen2,charset)
So here you gain a little flexibility but have to type some more |
| |
SIDWAVE
Account closed
Registered: Apr 2002
Posts: 2238 |
as the book says:
selectchar
lda $d018
and #240
ora #0 ;0-2-4-6-8-10-12-14 : 0000-07ff, 0800-0fff, 1000-17ff, 1800-1fff
; 2000-27ff, 2800-2fff, 3000-37ff, 3800-3fff
sta $d018 |
| |
Ejner
Registered: Oct 2012
Posts: 43 |
Hey, I see this thread is still cooking :-)
Thanks for all the examples, they are really helpful and give inspiration for digging a little deeper into all the smooth possibilities with f.i. KickAssembler, it seems like a really handy tool with lots of flexibility once you get the hang of it :-)
I think this thread now provides some nice examples that are all much smoother ways of calculating the VIC settings than the codebase example (no offence)...
Trying to learn a little from the examples above, does this compute in KickAssembler terminology?
koala = $6000
screen = $5c00
*= $1000
lda #[koala & $3fff]/1024
ora #[screen & $3fff]/64
sta $d018
lda $dd00
and #%11111100
ora #3-[>koala >> 6]
sta $dd00
|
| |
SIDWAVE
Account closed
Registered: Apr 2002
Posts: 2238 |
this is unreadable code:
lda #[koala & $3fff]/1024
ora #[screen & $3fff]/64
sta $d018
lda $dd00
and #%11111100
ora #3-[>koala >> 6]
sta $dd00
lda d018
ora xxx
sta d018
can be read!
lda dd00
and xxx
ora 0-1-2-3
sta dd00
can be read
i tried kickasm.. its russian gibberish to me :) |
| |
Ejner
Registered: Oct 2012
Posts: 43 |
koala = $6000
screen = $5c00
*= $1000
lda #[>koala & $3f]/4
ora #[screen & $3fff]/64
sta $d018
lda $dd00
and #%11111100
ora #3-[>koala >> 6]
sta $dd00
Breaking it down...
lda #[koala & $3fff]/1024
...will take the address of the koala, then AND it with $3fff to skip the first two bits which define the VIC bank, and then divide this with 1024, which is actually LSR'ing 10 times to get the remaining bits in the right location for $d018. Treatet as a word, but the result is a byte.
ora #[screen & $3fff]/64
...same, but will LSR only 6 times.
ora #3-[>koala >> 6]
...">koala" will take only the highbyte of the koala address. Then it is LSR'ed 6 times, leaving only the two bits that define the VIC bank. "3-" will invert those two bits.
Hope this helps for better understanding... |
| |
chatGPZ
Registered: Dec 2001
Posts: 11130 |
hooray for using proper constants (and dont listen to rambones, hardcoding values is never better)
just one thing - why doing LDA# followed by ORA#? you can just write it like
Quote:
lda #[[>koala & $3f]/4]|[[screen & $3fff]/64]
also, use bitshifts instead of divides, it makes it easier to see what happens (IMHO) |
... 32 posts hidden. Click here to view all posts....
|
| Previous - 1 | 2 | 3 | 4 | 5 - Next |
