Hallo Zusammen,

ich hab schon wieder eine nette kleine Betonwand, vor der ich stehe.

Ich möchte 4 Zeichen im Zeichensatz ersetzen, damit ich sie in Graphics 3 verwenden kann.
Ich will die Zeichen * + , und - ersetzen.
Wenn ich das richtig verstanden habe, dann ist das im Zeichensatz-Definitionsspeicher das 11., 12., 13., und 14. Zeichen.

Nun hab ich mir gedacht, ich tausche im Zeichensatz (dessen Speicher (Highbyte) ich im Byte chbase ($D409) finde) einfach 32 Bytes (4*8) aus. Das scheint aber nicht zu klappen.

kann mir jemand sagen, was ich falsch mache, oder alternativ wie ihr das machen würdet?

1000 Dank
Thomas


SetFont:
lda chbase ;highbyte
sta $D3
lda #80 :lowbyte
sta $D2 ; Zeiger auf das 11. Zeichen im Zeichensatz

lda >Font ;highbyte
sta $D1
lda <Font ;lowbyte
sta $D0 ; Zeiger auf meine eigene Zeichensatzdefinition

ldy #31 ; 4 Zeichen mit je 8 Byte
clc
loop2:
lda ($D0),y ;lese meine definition
sta ($d2),y ; überschreibe original zeichensatz
dey
cpy #0
bne loop2

rts


;------------------------------------------------
; Die Muster für die einzelnen Fonts:
;------------------------------------------------

Font:
.byte $CC, $DE, $FF, $FF, $FF, $FF, $DE, $CC ;COL 11
.byte $8c, $9E, $BF, $BF, $BF, $BF, $9E, $8C ;COL 10
.byte $4C, $5E, $7F, $7F, $7F, $7F, $5E, $4C ;COL 01
.byte $0C, $1E, $3F, $3F, $3F, $3F, $1E, $0C ;COL 00

8bitjunkie hat geschrieben:Nun hab ich mir gedacht, ich tausche im Zeichensatz (dessen Speicher (Highbyte) ich im Byte chbase ($D409) finde) einfach 32 Bytes (4*8) aus. Das scheint aber nicht zu klappen.

Das liegt wohl daran, daß der original Zeichensatz im ROM liegt und sich nicht so einfach überschreiben lassen will :)

Abhilfe: vorher die 1k Zeichensatz Daten ins RAM kopieren (muß an einer 1k Grenze liegen) und dann CHBAS ($2F4) auf die Page im RAM setzen.

so long,

Hias

In Graphics 3?

Eher in einem der beiden Text-Modi Graphics 1 oder 2. Gr.3 ist ein Graphik-Modus (40x24 Pixel bei 4 Farben).

Für Graphics 1+2 reicht es aus, den halben Zeichensatz (also 512 Byte) zu kopieren. Kleinbuchstaben und Grafikzeichen (ATASCII > 64) werden in anderen Farben ausgegeben (genau wie inverse Zeichen).

Vergiss nicht, dass der Zeichensatz bei Zeichen 0 anfängt, somit ist das erste der vier Zeichen das mit der Nummer 10.

In Turbo-BASIC würde das so aussehen:

Code: Alles auswählen

100 MOVE 224*256,152*256,512:.Zeichensatz aus dem ROM ins RAM an die Stellen ab 38912 kopieren
110 MOVE ADR("{32 Byte Zeichensatzdaten als String}"),152*256+10*8,4*8:.die vier Zeichen in der Kopie überschreiben

Äquivalent in Atari-BASIC:

Code: Alles auswählen

100 FOR P=0 TO 1023
101 POKE 152*256+P,PEEK(224*256+P)
102 NEXT P
110 FOR P=0 TO 4*8-1
111 READ WERT
112 POKE 152*256+10*8+P,WERT
113 NEXT WERT
114 DATA {32 Byte Zeichensatzdaten als Zahlen}

@Hias:

Das liegt wohl daran, daß der original Zeichensatz im ROM liegt und sich nicht so einfach überschreiben lassen will

Mhhhhm.
Mist. Das klingt so derart plakativ einleuchtend, dass ich hätte selber drauf kommen können
1000 Dank!


@atarixle:
Du hast natürlich Recht. Ich meinte den Antic-Modus 3 (bzw. inzwischen den 4 oder 5).
Und Danke für das Beispiel, ich probiere das mal aus...

Juhu - es funktioniert. Das Leben kann so schön einfach sein

Dann sieht meine Assembler-Routine so aus:

Code: Alles auswählen

; Definitionen
   chbas   = $2F4  ; Basisadresse des Zeichensatzes (Highbyte)
   quelle  = $d0 ;(ZeroPage-Zeiger in $D0 und §d1)
   ziel      = $d2 ;(Zero-Page-Zeiger in $D2 und $d3)
   
    org $3000 ;Start des Codes

;[Hauptroutine]

; Unterroutinen

Procedure_EigenerZeichensatz:
; Teil 1: Original Zeichensatz vom ROM ins RAM kopieren

   ldx #4  ; 4 Blöcke a 256 Bytes 
   ldy #0   ; jeweils 0-255 = 256 Durchläufe
   
   
   sty quelle ; Lowbyte
   lda #$E0   ; Hier ist der original Atari Zeichensatz im ROM
   sta quelle+1 ; highbyte
      
   sty ziel ; lowbyte
   lda #$98 ; ; Hier soll die Kopie des Zeichensatzes im Speicher liegen
   sta ziel+1 ;highbyte  = 38.912 oder $9800
   
KopiereFontPage:
   lda (quelle),y
   sta (ziel),y
   dey
   bne KopiereFontPage

   dex
   beq FontIstKomplettKopiert
   
   inc quelle+1  ; nächste Page
   inc ziel+1    ; Nächste Page
   jmp KopiereFontPage
   
FontIstKomplettKopiert:

;Teil 2: 4 Zeichen im RAM-Fontbereich mit eigener Definition überschreiben

   lda <MeinFont ; lowbyte
   sta quelle
   lda >MeinFont ; highbyte
   sta quelle+1
   
   lda #$98
   sta ziel+1 ; Highbyte
   lda #10*8  ; ab dem 11. Zeichen die neue Definition setzen
   sta ziel ; lowbyte
   
      
   
   ldy #4*8 ; 4 Zeichen austauschen
UeberschreibeFont:
   lda (quelle),y
   sta (ziel),y
   dey
   bne UeberschreibeFont

   lda #$98
   sta chbas ; Meinen neuen gepatchten Zeichensatz beim OS anmelden.
      
      rts ; Ende Procedure_EigenerZeichensatz


;------------------------------------------------
; Die Muster für die einzelnen Fonts:
;------------------------------------------------

MeinFont:
         .byte $CC, $DE, $FF, $FF, $FF, $FF, $DE, $CC 
         .byte $8c, $9E, $BF, $BF, $BF, $BF, $9E, $8C 
      .byte $4C, $5E, $7F, $7F, $7F, $7F, $5E, $4C 
      .byte $0C, $1E, $3F, $3F, $3F, $3F, $1E, $0C 



Das wäre mein erster Entwurf. Ich eigne mir den 6502 ja grade erst brandneu an.
Frage an die 6502-Profis: Kann man das vielleicht noch eleganter lösen?

Viele Grüße
Thomas

Sieht doch gut aus
So läuft das auch im ROM. Wenn das Programm ins RAM kommt, dann kann man da noch selbstmodifizierenden Code nehmen

Code: Alles auswählen

loop:
s1: lda $e000,x
d1: sta $9800,x
   dex
   bne loop
   inc s1+1
   inc d1+1
...


oder gleich als 1k Block

Code: Alles auswählen

 
loop:
   lda $e000,x
   sta $9800,x
   lda $e100,x
   sta $9900,x
   lda $e200,x
   sta $9A00,x
   lda $e300,x
   sta $9B00,x
   dex
   beq loop
;fertig!


Kann man ganz unterschiedlich machen.
Wenn Du die Speicheraufteilung ordentlich geplant hast klappt das gut.

Wenn es nur kopieren ist, dann nehme ich auch oft einfach ein Macro in MADS, welches eine allgemeine Copymethode aufruft. Wenn das schnell sein muss oder speziell ist (und das ist es ja oft ), dann kommt doch etwas spezielles zum Einsatz.
Ich finde das Beipiel oben mit dem Turbo-Basic MOVE auch total elegant! Blockverarbeitung statt einzelner Bytes macht das sehr übersichtlich.

Hallo 1NG,

mmmh, auch schöne Ideen.
Das mit dem 1 K Block ist so schön einleuchtend, und man spart sich die zweite Schleife