!text Großß'/Kleinschrift in ACME

Hallo,

zwischen Groß- und Kleinschrift sowohl im CharROM als auch bei vielen anderen Zeichensätzen sind Groß- und Kleinbuchstaben um 64 Zeichen versetzt, d.h. wenn man auf einen Zeichencode 64 Zeichen aufschlägt, landet man beim selben Zeichen in groß, bzw. klein, je nach Aufbau der Zeichen.

Mit der !text Direktive in ACME werden (nach meinem Verständnis) Textzeichen in Offset-Zahlen umgewandelt. So ist der Buchstabe "d" für den Assembler später eine 4. Es macht ja schließlich keinen Spaß, seine Texte als Zahlen in den Sourcecode schreiben zu müssen.

Ich will jetzt an die Großbuchstaben eines Charsets dran, die ab dem 512. Byte beginnen. Ich kann den Zeichensatz mit entsprechendem Offset einladen, dann klappt der !text. Was dann aber nicht mehr klappt, sind Nummern und Interpunktionszeichen aus dem Charset.

Gibt es, ohne dass ich die Bitmap-Struktur des Charsets umbauen muss, einen Weg, der !text-Direktive zu sagen, es soll für bestimmte Bereiche ein Offset benutzt werden? Oder muss ich umsteigen und Byte-Wüsten in meinen Quellcode eintippen, also .byte 4 anstatt !text "d"?

Edit:
Bzw. sind die Regeln, nach denen !text die Buchstaben in Zahlen umsetzt, zugänglich und editierbar?

Edit2:
Die Datei AllPOs.txt in den ACME Docs scheint Infos zu enthalten was man hier tun kann.
Ich lese mich da ein und poste, wenn ich es herausgefunden habe.

Danke sehr!

So, diese Stelle in der Doku ist es:

Zitat von Marco Baye

Examples: !convtab raw
!text "Test" ; outputs $54 $65 $73 $74
!ct pet
!tx "Test" ; outputs $d4 $45 $53 $54
!ct scr {
!tx "Test" ; outputs $54 $05 $13 $14
!ct "my_own_table_file"
!tx "abcdefg" ; whatever...
}
!tx "Test" ; outputs $d4 $45 $53 $54 again
Hint: If you don't want to fiddle with a hex editor to create a
conversion table file, try using ACME:
!to "asc2pet.ct", plain ; no load address
* = 0; pc = table index
; first create "as-is" table
!for i, 0, 255 {!byte i}
; now exchange upper and lower case characters
* = 65, overlay
!for i, 1, 26 {!byte * + 128}
* = 97, overlay
!for i, 1, 26 {!byte * - 32}
The resulting file can be used as a conversion table to convert to
PetSCII (which is useless, because ACME can do so anyway. But you get
the idea).

Alles anzeigen

Ich war aber intellektuell zu überfordert, das umzusetzen (und bequem).
Es ging am Ende schneller, im Hex Editor das Charset zu öffnen, die Bytes abzuzählen und copy paste zu machen (ich brauche nur Großbuchstaben, Zahlen und Interpunktion).

@ Mac Bacon

Das angehängte Bild zeigt den Aufbau meines Zeichensatzes, mit dem ich arbeiten will.
!scr hatte ich schon drin, das klappt auch, nur nimmt er dann die Kleinbuchstaben am Anfang des Charsets. Ich will aber an die Großbuchstaben weiter unten ran, die ab Byte 512 beginnen.

Ich kann jetzt die Großbuchstaben einfach bei der vorgesehenen Charset-Position per Offset anfangen lassen:

*=Adresse-512-2
charset:

!bin "charset.bin"

aber mit !scr und !pet findet er mir dann die Zahlen und Punkte, Kommas, Ausrufezeichen nicht mehr.

Also habe ich einfach die Bytes von 512 bis 512+32*8) im Hex Editor kopiert (die dritte Zeile von oben im Charset-Bild) und ganz am Anfang eingefügt, bzw. die Kleinbuchstaben mit den Großbuchstaben überschrieben und als neue Charset-Bin-Datei abgespeichert. !scr ist weiterhin gesetzt, Interpunktion und Buchstaben klappen jetzt, weil die gleich geblieben sind.

Wenn ich abstrakte Syntax-Beschreibungen in Dokus sehe ist das für mich fast so schlimm wie mathematische Formeln. Die Rettung sind für mich immer die Beispiele, anhand derer ich das Muster sehe und imitieren kann. Die ACME Doku ist sehr gut, ich hätte nur eben viel länger gebraucht, den relevanten Teil der Doku zu verstehen und umzusetzen statt schnell ein bisschen zu zählen und im Hex Editor hin und her zu kopieren.

Es klappt auch mit Großbuchstaben im Source nicht.

Ich kopiere Charset-Bitmap-Stücke in Sprites und nutze !scr als Offset-Hilfe, damit ich !scr "d" statt .byte 4 scheiben kann.

Der C64 weiß nichts von der Charset-Bitmap. Wenn man im Direktmodus etwas tippen könnte, käme in meinem Programm immer noch CharROM.

Wenn ich sage "Nimm aus dem !scr String das nächste Zeichen (=die nächste Offset-Zahl) und wende sie als Offset auf die Char-Bitmap ab Adresse XYZ an und schneide das Zeichen heraus was Du brauchst und kopiere es in ein Sprite", dann erhalte ich immer das gleiche Ergebnis im Sprite, nämlich Kleinschrift, egal ob im !scr String große oder kleine Buchstaben drin stehen.

Würde ich dem C64 sagen was er als Charset zu nehmen hat und ins Screen RAM poken, dann hätte ich vermutlich Groß- und Kleinschreibung so wie es im !scr String definiert ist. Das ScreenRAM interessiert mich aber hier gar nicht als Ort der Textdarstellung.

Edit:
Gelöst habe ich das Problem also nur über einen krummen Umweg, nämlich durch Manipulation der Char-Bitmap.

Edit2:
Oder ich hätte über eine Conv-Tabelle dem ACME-Programm gesagt, "wenn Du das "d" in Großschrift siehst, mach da keine 4 draus, sondern eine 68. Und das war mir zu schwer.

Lda infotext,x

getChar
sta ZP_HELPADR. ; Ort des Chars den wir suchen soll hier stehen
lda #$30
sta ZP_HELPADR+1

asl ZP_HELPADR. ;mal 8
asl ZP_HELPADR
asl ZP_HELPADR

bcc cont
inc ZP_HELPADR+1 ;hi Byte der Adresse wird erst ab 512x8 auf 2 erhöht, kein rol in weiteres hilfs hi Byte nach asl Aktion nötig

Cont
;lokalisieren des gewünschten Chars in der Bitmap via indirekter y adressierung und ins Sprite kopieren

Infotext
!scr "d"

-----------------

Ich benutze asl und will aus Faulheit und für schnellen Code kein rol nach jedem asl in ein weiteres hilfs hi Byte machen, das ich dann auf das Adress High Byte der Charset Adresse auf addieren muss.

Wahrscheinlich verschlucke ich mit meinem asl einen Teil der Ziel Adresse.

Danke MJ!

Ja dann werde ich mal sehen. Aktuell funktioniert der gesamte Sprite Scroller mit Punkt, komma, zahlen und Großbuchstaben mit frisierter, 2x256 Byte großen charmap. Ich brauche nur das Adress High Byte maximal auf 1.

Ich optimiere ggf. Später. Jetzt als nächstes muss ich den Sprite scroller in die untere geöffnete border unterbringen und dann ein restliches Intro in den Bereich der sichtbaren Bitmap hinein bauen.

Wenn das alles erstmal geht ändere ich bestimmte Routinen ab, um sie flexibler und wiederverwendbarer zu machen.

Da gehört die korrekte Char Indizierung dann auf jeden Fall dazu.

Super! Nehm ich! Ich will mit dem Sprite scroller möglichst wenig Raster Zeit zubringen weil ich im Intro viel Zeit verbraten werde mit Linien ziehen.

Danke. Dieses Forum ist einfach elite!