Ich benötige Hilfe für eine EasyFlash Anpassung

Stephan Scheuer · 19. Juni 2019

Ich arbeite gerade an "Grand Prix Circuits" für das EasyFlash und habe ein Problem.
Das Spiel ist fast fertig angepasst. Selbst die vom Hersteller gepackten Dateien habe
ich entpackt, für ein noch schnelleres Laden. Einzig die EasyFlash Saveroutine fehlt noch.
Der Code der Saveroutine past problemlos im RAM. Nur dass, was als Spielestand
abgespeichert werden soll nicht. Es sind die Sektoren #00 bis #17 der Spur #01.
Also 18 Blocks. Es wird für jede Saveaktion nur ein Sektor beschrieben, bis dieser
voll ist. Ein Reduzieren der Sektoren durch Umprogramierung möchte ich nicht machen,
weil ich nicht abschätzen kann, ob das zuverlässig funktioniert.
Hat von euch vielleicht jemand eine Idee wie man das Problem lösen kann

PS: Ich möchte das Spiel auch Supercpu kompatibel machen.
Dazu muss ich haufenweise LAXe entfernen. Wahrscheinlich war der Coder ein Angler.

LAX $FF ist z.B.
------------
LDA $FF
TAX

Sehe ich das so richtig?

Stephan Scheuer · 20. Juni 2019

Ich lade mal die zu etwa 97% fertige Version hier hoch. Einfach mal so zum austesten,
wie schnell diese lädt. Ganz im gegensatz zu andern Versionen.

Achja, als Zugabe meine Quellcodes vom Huf-Packer und Huf-Entpacker. Vielleicht kann sie jemand gebrauchen.
Ich hatte eigendlich vor, die Savegames vor dem Flashen zu packen.
Nach einigen Überlegungen/Gedankenspielen hatte ich das dann wieder verworfen.

Ezeyer · 20. Juni 2019

Zitat von Stephan Scheuer

Dazu muss ich haufenweise LAXe entfernen. Wahrscheinlich war der Coder ein Angler.

oder Angelsachse ...

[Externes Medium: https://www.youtube.com/watch?v=4tFxQu2nw68]

Stephan Scheuer · 20. Juni 2019

Ui, Monty Python schaue ich zu gerne. In "das Leben des Brian" die Latein Lehrstunde, unvergesslich.
Achja, ich habe mal eine Idee um die Spielstände zu im EasyFlash zu Speichen, in grob umgesetzt.
Vielleicht funktioniert das ja sogar.

Brainfuck-Quellcode

$0530 ; ---- start easyflash save routine
feststellen, welcher sektor gespeichert werden soll
aufteilung a - sektor 00-08 $2000-$2900
aufteilung b - sektor 09-11 $2000-$2900
x-reg = aktuelle sektornummer
; ---- easyflash einschaten
sei
lda $01
pha
lda #$37
sta $01
lda #$87
sta $de02
; ---- nur für sektor 00-08
txa ; ---- sektornummer laden und (#$00-#$11)
cmp #$09 ; ---- mit festwert #09 vergleichen
bcs sek09 ; ---- ist sektornummer höher als #8, dann hier weiter
clc ; ---- übertrag löschen
adc ast38+2 ; ---- mit savegame highbyte offset addieren
sta ast38+2 ; ---- und festlegen
; ---------
lda #$10 ; ---- wert für bank 10 in den akku laden
sta $de00 ; ---- easyflash bank 10 aktivieren. sektor 00-08
sta buf01 ; ---- aktuelle ef-bank wert puffer
jsr red01 ; ---- aus ef in den c64 laden
; ---------
ldx #$00
ast37 lda $0200,x ; ---- savegame an festgelegter
ast38 sta $2000,x ; ---- adresse im c64 kopieren
inx
bne ast37
jmp weiter ; ---- wenn alles fertig, hier weiter
; ---------
; nur für sektor 00-08
; ---------
sek09 sec ; ---- übertrag setzen
sbc #$09 ; ---- festwert #09 von sektornummer subtrahieren.
sta ast3b+2 ; ---- und als offset festlegen (kleinster wert ist #0
; ---------
lda #$15 ; ---- wert für bank 15 in den akku laden
sta $de00 ; ---- easyflash bank 15 aktivieren. sektor 09-11
sta buf01 ; ---- aktuelle ef-bank wert puffer
jsr red01 ; ---- highscore aus ef in den c64 laden
; ---------
ldx #$00 ; ---- x-reg startwert #0
ast3a lda $0200,x ; ---- savegame an festgelegter
ast3b sta $2000,x ; ---- adresse kopieren
inx
bne ast3a
jmp weiter ; ---- wenn alles fertig, hier weiter
; ---- savegame ins c64 ram schreiben. immer ab $2000-$2900
red01 lda #$00
sta $fc
sta $fe
lda #$80 ; ---- easflash bank, wo die savstates sind
sta $fd
lda #$20 ; ---- c64 ram ab $2000
sta $ff
ldy #$00
ast44 lda ($fc),y
sta ($fe),y
iny
bne ast44
inc $fd
inc $ff
lda $ff
cmp #$29 ; ---- savegame part 1 $2000-$2900
bne ast44
rts
; ---- eapi in den ram dec c64 kopieren
weiter
lda #$00 ; ---- load value to
sta $de00 ; ---- adjust easyflash bank $00
ldx #$00 ; ---- x-reg auf #0 festlegen
b157a lda $b800,x ; ---- eapi von $b800-$b900
sta $3300,x ; ---- nach $3300-$3400 kopieren
lda $b900,x ; ---- eapi von $b900-$ba00
sta $3400,x ; ---- nach $3400-$3500 kopieren
lda $ba00,x ; ---- eapi von $ba00-$bb00
sta $3500,x ; ---- nach $3500-$3600 kopieren
inx
bne b157a
; ---------
jsr $3314 ; ---- eapi init
lda buf01 ; ---- erase flash: low-bank $10 bis $18 (64kb)
ldy #$80 ; ---- low bank $8000 bis $9fff
jsr $df83 ; ---- erease with #$ff
lda buf01 ; ---- get value to
jsr $df86 ; ---- set easyflash to bank #$10
lda #$b0
ldx #$00
ldy #$80 ; ---- low bank
jsr $df8c ; ---- set pointer to $8000 (mode: low-bank)
lda #$20 ; ---- ram-adress were placed the high-score. high byte $0403 to $0803
sta b15b3+2 ; ---- auf startwerte setzten
; ---- write easyflash
ldx #$00 ; ---- y-reg set to #$00
b15b3 lda $2000,x ; ---- von $0403 bis $0803 flashen
jsr $df95 ; ---- eapi: writeflash + increment x-reg
inx ; ---- increment low byte
bne b15b3 ; ---- 256 bytes flashed?
inc b15b3+2 ; ---- incremant high byte
lda b15b3+2 ; ---- compare high byte
cmp #$3 ; ---- with high score endaddress
bne b15b3 ; ---- all bytes flashed?
; ---- flashen beenden
lda #$04 ; ---- get value for
sta ade02 ; ---- easyflash turn off
pla ; ---- get $01 value from stack
sta $01 ; ---- set $01
; ---- swapspace wiederherstellen ----
lda #$02
ldx #<nam01
ldy #>nam01
jsr $ffbd ; ---- restore the swapspace from $1a00 to $1cff
ldx #$00
ldy #$20 ; ---- swapspace ab $2000 laden
jsr $df00 ; ---- to ef-loader. swapspace wiederherstellen
lda #$02
ldx #<nam02
ldy #>nam02
jsr $ffbd ; ---- restore the swapspace from $1a00 to $1cff
ldx #$00
ldy #$20 ; ---- swapspace ab $2000 laden
jmp $df00 ; ---- to ef-loader. swapspace wiederherstellen
nam01 !text "SW1" ; ---- von $2000 bis $2900
nam02 !text "SW2" ; ---- von $3300 bis $3600

Alles anzeigen

reeca · 20. Juni 2019

I've actually stood at that wall at Duone Castle in Scotland ;->

rayden · 20. Juni 2019

Zitat von Stephan Scheuer

Achja, als Zugabe meine Quellcodes vom Huf-Packer und Huf-Entpacker. Vielleicht kann sie jemand gebrauchen.

Just curious: warum "Huf-Packer" und "Huf-Entpacker"?
Ich dachte im ersten Moment an Huffman-Kodierung.

<clevershitting>Der Packer/Depacker ist keine Huffman-Kodierung, sondern ist RLE-kodiert aka Run Length Encoding - gerne auch equal char packer genannt ;)</clevershitting>

Stephan Scheuer · 20. Juni 2019

Den hatte ich für "Accolade Comics" EasyFlash Anpassung gemacht. Der Depacker sollte als Streamdepacker fungieren.
Der Grund ist ganz simpel. Wenn alle Dateien gerippt sind (etwa 1300 Datein) dann überschreitet das Spiel die 1MB Grenze. Immerhin hat
das Game 6 randvolle Diskseiten. Nostalgia machen das mit ihren EasyFlash Anpassungen fast immer.

Bei "Grand Prix Circuits" wollte ich die High Score Packen. Also jeden Sektor separat. Ich schaffe es nicht, das Savegame zwischen zu puffern,
dann zu aktualisieren und in das EasyFlash zurückzuschreiben.

Achja, ein Arbeitskollege hatte mir das mal so gesagt. wenn ein packer z.B. so arbeitet. siehe unten.
nennt man das huffmankodierung. ob es stimmt, keine ahnung. seit dem nenne ich diese Packer aber so.
Die packdichte ist nicht so gut, aber dafür ist der depacker sehr schnell

"aaaaxxxxxeeeeeee kb,04,41 - kb,05,58 - kb,07,45"

KB = kennbyte
04 = 04 mal den 8bit wert
41 = ascii "A"

Hier, alles Handarbeit

Accolade Comics Test/Demoversion

Mac Bacon · 20. Juni 2019

Zitat von Stephan Scheuer

Achja, ein Arbeitskollege hatte mir das mal so gesagt. wenn ein packer z.B. so arbeitet. siehe unten.
nennt man das huffmankodierung. ob es stimmt, keine ahnung. seit dem nenne ich diese Packer aber so.

Nein, das stimmt nicht.
Du kannst die Dinger ja nennen wie Du willst, aber bei der Kommunikation mit anderen solltest Du Dir diese Bezeichnung abgewöhnen.

EDIT: https://de.wikipedia.org/wiki/Huffman-Kodierung

Stephan Scheuer · 20. Juni 2019

Ich wusste es ja schon aber die blöde gewohnheit. Aber Danke!. In Zukunft werde ich das RLE-Packer nennen.

Stephan Scheuer · 20. Juni 2019

Code

; ---- für acme assembler
!to "scpu-depcker.prg",cbm
!cpu 65816
*=$00c000
lzma_zp_base = $80
lzma_lwm = lzma_zp_base
lzma_src_ptr = lzma_lwm+2
lzma_bits = lzma_src_ptr+3
lzma_bitcount = lzma_bits+1
lzma_offs = lzma_bitcount+1
lzma_gamma = lzma_offs+2
lzma_offs2 = lzma_gamma+2
; ---- in:
; ---- a = source bank
; ---- y = source offset
; ---- x = dest offset
; ---- dbr = dest bank
lzma_decrunch
php
rep #$10
sep #$20
!al
sta lzma_src_ptr+2
stz lzma_src_ptr+1
stz lzma_src_ptr
stz lzma_offs+1
stz lzma_lwm+1
lda #$01
sta lzma_bitcount
copy_byte
lda [lzma_src_ptr],y
sta $0000,x
inx
iny
next_sequence_init
stz lzma_lwm
next_sequence
jsr get_bit
bcc copy_byte ; ---- wenn die bit sequence %0..., dann ist kopiere das nächste byte
jsr get_bit
bcc code_pair ; ---- wenn die bit sequence %10..., ist dann ist es ein code-paar
jsr get_bit
stz lzma_offs
stz lzma_offs+1
bcs +
jmp short_match ; ---- wenn die bit sequence %110..., ist, dann ist es eine kurze übereinstimmung
; die sequence ist %111..., die nächsten 4 bits sind der offset (0-15)
jsr get_bit
rol lzma_offs
jsr get_bit
rol lzma_offs
jsr get_bit
rol lzma_offs
jsr get_bit
rol lzma_offs
lda lzma_offs
beq write_byte ; ---- wenn offset = 0, dann 0x00 schreiben
; wenn offset! = 0, dann schreibe das Byte am Ziel - Offset
phx
rep #$20
!al
txa
sec
sbc lzma_offs ; ---- a = ziel - offset
tax
sep #$20
!as
lda $0000,x
plx
write_byte
sta $0000,x
inx
jmp next_sequence_init
; ---- code pair %10...
code_pair
jsr dekodiere_gamma
rep #$20
!al
dec lzma_gamma
dec lzma_gamma
bne normal_code_pair
lda lzma_lwm
bne normal_code_pair
jsr dekodiere_gamma
rep #$20
!al
lda lzma_offs2
sta lzma_offs
jmp copy_code_pair
normal_code_pair
lda lzma_gamma
clc
adc lzma_lwm
dec
sep #$20
!as
sta lzma_offs+1
lda [lzma_src_ptr],y
iny
sta lzma_offs
jsr dekodiere_gamma
rep #$20
!al
lda lzma_offs
cmp #32000
bcc compare_1280
inc lzma_gamma
compare_1280
cmp #1280
bcc compare_128
inc lzma_gamma
jmp continue_short_match
compare_128
cmp #128
bcs continue_short_match
inc lzma_gamma
inc lzma_gamma
jmp continue_short_match
; ein bit laden: bits aus gecrunchten daten laden, das höschstwertige bit als carry flag setzen.
get_bit
sep #$20
!as
dec lzma_bitcount
bne still_bits_left
lda #$08
sta lzma_bitcount
lda [lzma_src_ptr],y
sta lzma_bits
iny
still_bits_left ; ---- es sind immer noch bits übrig
asl lzma_bits
rts
; gamma dekodieren: dekodiert werte aus den komprimierten daten mit gamma-code
dekodiere_gamma
rep #$20
!al
lda #&01
sta lzma_gamma
get_more_gamma
jsr get_bit
rep #$20
!al
lda lzma_gamma
adc lzma_gamma
sta lzma_gamma
jsr get_bit
bcs get_more_gamma
rts
; ---- kurzes übereinstimmung %110...
short_match
rep #$20
!al
lda #$01
sta lzma_gamma
sep #$20
lda [lzma_src_ptr],y ; offset abrufen (offset ist 7 bit + 1 bit, um zu markieren, ob 2 oder 3 bytes kopiert werden)
iny
lsr
beq end_decrunch
rol lzma_gamma
sta lzma_offs
stz lzma_offs+1
rep #$20
!al
continue_short_match
lda lzma_offs
sta lzma_offs2
copy_code_pair
phy
txa
sec
sbc lzma_offs ; -------- dest offset
tay
loop_do_copy
sep #$20
!as
lda $0000,y
sta $0000,x
inx
iny
rep #$20
!al
dec lzma_gamma
bneloop_do_copy
ply
lda #$01
sta lzma_lwm
sep #$20
!as
jmp next_sequence
end_decrunch
plp
rts

Alles anzeigen

Und ein Cruncher der nach deisem Prinzip arbeitet, nennt man Lempel-Ziv-Algorithmus. Ich hoffe, dass das richtig ist.

rayden · 21. Juni 2019

Lempel-Ziv-Markov to be more precise Lempel-Ziv (LZ77 und LZ78) sind im Grunde die Basis für die ganzen LZ-Derivate (Lempel-Ziv-Welch, Lempel-Ziv-Markov, etc.).