Mit dem Turbo-Assembler direkt am C64 entwickeln

 
Wie meine Umfragen zeigen, wollen viele lieber direkt am C64 arbeiten, statt einen Emulator und / oder eine PC Entwicklungsumgebungen zu nutzen. Daher möchte ich euch hier kurz zeigen, wie dies mit dem Turbo-Assembler geht.

Immerhin haben 23% (Stand 23.02.2020) bei „Welchen C64 Emulator nutzt ihr hauptsächlich?“ mit „KEINEN: Es muss ein ‚echter‘ C64 sein!“ geantwortet, was die zweit häufigste Antwort ist.[poll id=“4″]Bei „Womit erstellt ihr eure C64-Programme?“ haben 17% (Stand 23.02.2020) „direkt am C64“ gewählt, auch dies ist die zweit häufigste Antwort.[poll id=“1″]

Da der C64 über keinen eingebauten Maschinensprachemonitor oder gar Assembler verfügt, muss ein separates Programm, wie der oben erwähnte Turbo-Assembler her. Natürlich gibt es noch viele andere Möglichkeiten (z. B. Profi-Ass 64, Hypra-Ass, Input-Ass, VirtualAssembler16 für die SuperCPU usw.), hier beschränke ich mich aber einzig auf den Turbo-Assembler.

Vor- und Nachteile

Mir fallen zwar viele Punkte ein, die gegen das Arbeiten direkt am C64 sprechen, z. B.

• Man muss noch mehr auf den Speicherbedarf achten. Der Assembler selbst und euer Quellcode benötigen natürlich auch Arbeitsspeicher und dieser ist beim C64 knapp bemessen.
• Die unbequeme C64-Tastatur.
• Ein fieser Absturz kann eure ganze Arbeit vernichten.
• Alte Disketten, die evtl. zum Verlust eurer Arbeit führen können.
• Heutige Standards (Copy & Paste, Undo / Redo, Mausbedienung, Suchen & ersetzen usw.) sind gar nicht vorhanden oder nur sehr simple implementiert und recht hakelig zu nutzen.
• usw.

Aber wie ich selbst beim Schreiben dieses Artikels bemerkt habe, macht es auch durchaus Spass, wieder wie in der guten alten Zeit zu programmieren. Schließlich war es für Hobby-Entwickler in den Achtzigern auch üblich, direkt am C64 zu arbeiten.

Download

Zunächst benötigt ihr natürlich den Turbo-Assembler. Dieser wurde ursprünglich 1985 von Wolfram Römhild entwickelt. Vom Turbo-Assembler gibt es sehr – sehr viele Versionen, da er in der Szene äußerst beliebt war und im Laufe der Jahre immer wieder von verschiedenen Gruppen angepasst wurde. Sei es um Fehler zu beheben oder neue Funktionen einzubauen, wie z. B. die REU-Unterstützung.

Ich habe mich hier für die Version 7.4 von 2001 entschieden. Falls ihr eine andere Fassung nutzt, kann es evtl. zu Abweichungen kommen, aber im Großen und Ganzen, sollte die Bedienung einheitlich sein.

Im Download findet ihr ein D64-Image mit dem Turbo-Assembler:

Das Image müsst ihr dann natürlich noch zum C64 übertragen (z. B. mit einem SD2IEC, dem Turbo Chameleon 64, Kerberos oder wie ihr das sonst auch immer macht), um es dort zu nutzen und / oder auf einer echten Diskette zu speichern.

Den Turbo-Assembler laden & starten

Nun, da ihr den Turbo-Assembler zum C64 übertragen habt (ich gehe davon aus, dass ihr eine Floppy mit der Gerätenummer 8 verwendet) ladet diesen einfach mit LOAD“:*“,8 und startet ihn anschließen mit RUN.

Ihr solltet folgendes sehen:

Beim ersten Start werdet ihr gefragt, ob ihr den Speicher löschen wollt clear memory (y/n)?. Wenn ihr frisch mit der Arbeit beginnt, drückt am besten die Y-Taste, um einen wohldefinierten Zustand zu erhalten.
Falls es mal zu einem Absturz kommt, bevor ihr speichern konntet, schaltet den C64 nicht aus. Ihr könnt den Turbo-Assembler (auch nach einem Reset) neu laden und starten. Drückt dann erstmal auf N, mit Glück ist euer Quellcode noch erhalten und ihr könnt diesen sichern.

Die letzten beiden Bildschirmzeilen des Editors sind übrigens für interne Zwecke reserviert.
In der vorletzten Zeile werden Informationen oder Abfragen (z. B. so wie eben clear memory (y/n)?) angezeigt.

Die unterste Zeile hat folgenden Aufbau:

• Hinter x: findet ihr die aktuelle Spalte in der der Cursor steht, beginnend mit 0.
• Das line: zeigt an, in welcher Zeile sich der Cursor befindet, beginnt ebenfalls bei 0.
• Der Turbo-Assembler speichert euren Quellcode gepackt von $8FEB quasi Rückwärts bis $0801.
  Bei bot: (könnte für Begin Of Turbo-Assembler stehen) seht ihr wo euer Quellcode im Arbeitsspeicher beginnt. Jede neue Eingabe verringert diesen Wert also.
• Hinter insert: seht ihr, welcher Einfügemodus aktuell aktiv ist.
  • Falls dort char steht, wurde der Zeicheneinfügemodus angeschaltet.
  • Steht line dahinter, ist der Zeileneinfügemodus aktiv.

Lasst uns nun mal etwas programmieren…

Einen ersten Quellcode eingeben

Auch wenn ihr jetzt evtl. noch nicht viel mit den Befehlen anfangen könnt, gebt das folgende Programm bitte einfach mal ein und kommt später, sobald ihr das Assembler-Tutorial durchgeht, ggf. nochmal hier her zurück. Ausgangspunkt ist nun folgender Bildschirm:

Ihr könnt euch frei mit den Cursor-Tasten über den Bildschirm bewegen. Probiert das jetzt mal aus. Dabei solltet ihr bemerken, dass sich die Werte hinter x: und line: in der Statuszeile ganz unten ändern. Sobald euer Quellcode mehr als 22 Zeilen umfasst, wird der Bildschirm zeilenweise gescrollt.

Stellt nun den Cursor wieder oben / links in die Ecke und gebt *=$1000 ein. Dies legt fest, wo euer Programm später im Speicher liegen soll. Statt $1000 könnt ihr übrigens auch den dezimalen Wert 4096 eingeben. Sobald ihr die Zeile mit RETURN bestätigt, werdet ihr bemerken, dass der Turbo-Assembler eure Eingabe verschiebt.

Wie ihr gleich noch seht, formatiert der Turbo-Assembler eure Eingaben teilweise um, sobald ihr eine Zeile mit RETURN bestätigt oder um genauer zu sein, eine Zeile verlasst. Beim Verlassen wird eure Eingabe geprüft und ggf. umformatiert (z. B. gibt es feste Positionen für Label, Konstanten, Befehle usw.).
Sollte ein Fehler entdeckt werden, wird die Zeile rot eingefärbt und in der Infozeile erscheint ein Hinweis.

Nach der obigen korrekten Eingabe, sollte der Cursor unter dem * stehen. Gebt dort bitte einfach start ein und drückt wieder RETURN. Bei start handelt es sich übrigens um ein Label, dies wird ganz nach links, in die erste Spalte, verschoben.

Wie ihr seht, steht der Cursor automatisch wieder in der 10. (die Zählung beginnt ja bei 0) Spalte. Gebt nun noch die beiden Zeilen inc $d020 und jmp start ein.

Beachtet, dass ihr beim Turbo-Assembler alle Befehle, Label und Konstanten in Kleinbuchstaben eingeben müsst! Verwendet ihr bei einem Label Großbuchstaben, wird euch ein Fehler angezeigt!

Da unser Programm nun fertig ist, wollt ihr es bestimmt direkt starten. Ihr solltet eure Arbeit aber immer zu erst speichern, sonst besteht die Gefahr, dass ihr durch einen Programmfehler alles verliert.

Den Quellcode speichern und das Programm erstellen

Der Turbo-Assembler wird mit einer ganze Reihe an Tastaturkommandos gesteuert.
Drückt nun die ←-Taste, gefolgt von S, um den Quellcode zu speichern. Es erscheint eine Abfrage für den Dateinamen. Gebt einen passenden Namen ein und bestätigt diesen mit RETURN.

Jetzt, da unsere Arbeit erfolgreich gespeichert wurde, in der Infozeile sollte 00, ok,00,00 stehen, können wir das Programm endlich gefahrlos starten. Drückt dazu wieder die ←-Taste und anschließend 3. Das Programm wird dann erstellt. Es sollten keine Fehler angezeigt werden.

Falls es Probleme beim Erstellen gibt, zeigt euch der Turbo-Assembler die entsprechenden Zeilen, so wie auf dem folgenden Bild, an.

Korrigiert dann die entsprechenden Punkte.
Im obigen Beispiel, fehlt z. B. ein $, es muss inc $d020 lauten. Außerdem heißt unser Label für die Schleife start, daher ist jmp star falsch, es wurde das t am Ende vergessen.

Sobald die Erstellung fehlerfrei durchläuft, könnt ihr zum Schluß die Taste S drücken, um das Programm auszuführen.

Das Programm läuft und der Rahmen blinkt fröhlich vor sich hin 😉 .

Um zurück zum Turbo-Assembler zu kommen, drückt einfach die RESTORE-Taste.

Turbo-Assembler: Liste der Tastaturkommandos

Fast alle Kommandos werden mit der ←-Taste eingeleitet. Es gibt auch Ausnahmen, wie die Funktionstasten F1 bis F8, aber werft einfach einen Blick auf die folgende Liste.
Ich erhebe hier übrigens keinen Anspruch auf Vollständigkeit! Außerdem kann es, durch die unzähligen Turbo-Assembler-Versionen auch zu Unterschieden kommen, aber das Meiste sollte übereinstimmen.

Taste	Funktion
{CRSR LINKS} {CRSR RECHTS} {CRSR RAUF} {CRSR RUNTER}	Wie bereits erwähnt, könnt ihr euch mit den Cursor-Tasten frei über den Bildschirm bewegen.
RETURN	Bewegt den Cursor in die nächste Zeile, an den eingestellten Cursor-Tab. Falls das Zeileneinfügen aktiv ist, wird vorher eine neue leere Zeile unter der aktuellen eingefügt.
SHIFT+RETURN	Unterdrückt das Einfügen einer neuen Zeile, falls dies aktiv ist und verhält sich ansonsten, wie ein einfaches RETURN.
DEL	Zeichen links vom Cursor löschen.
INST	Einfügemodus für einzelne Zeichen umschalten. (Standard = aus) Hiermit schaltet ihr zwischen Überschreiben und Einfügen bei Eingabe der einzelnen Zeichen um. In der Statuszeile ganz unten, könnt ihr an einem char hinter insert: erkennen, dass das Einfügen von Zeichen aktiv ist.
F1	Scrollt 20 Zeilen rauf.
F2	Springt an den Anfang des Quellcodes.
F3 Die Funktionstasten F3 bis F6 können übrigens frei belegt werden (s. ← K)	.text " " an der aktuellen Cursorposition einfügen.
F4	Erstellt das Programm und startet es, sofern die Assemblierung erfolgreich war.
F5	.byte $00 an der aktuellen Cursorposition einfügen.
F6	Die aktuelle Zeile löschen (s. ← DEL)
F7	Scrollt 20 Zeilen runter.
F8	Springt ans Ende des Quellcodes.
Ab hier folgen jetzt Kommandos, die mit ← eingeleitet werden müssen!
← ←	Da viele Kommandos mit ← begonnen werden, muss man erneut ← drücken, um das Zeichen ← zu erhalten.
← DEL	Die aktuelle Zeile komplett löschen, der Quellcode „rutscht“ dabei nach oben, solange es mehr als 22 Zeilen gibt.
← INST	Den Zeilen-Einfügemodus umschalten. (Standard = an) Falls aktiv, wird nach einem RETURN automatisch eine neue leere Zeile eingefügt. In der Statuszeile ganz unten, könnt ihr an einem line hinter insert: erkennen, dass das Einfügen von Zeilen aktiv ist.
← SPACE	Löscht den Inhalt der aktuellen Zeile, indem diese mit lauter Leerzeichen überschrieben wird.
← 1	Den Turbo-Assembler verlassen, um zum BASIC zu wechseln. Gebt SYS 333 oder SYS 36864 ein und bestätigt dies mit RETURN, um den Turbo-Assembler wieder zu starten.
← 2	Die aktuelle Zeile mit einer Trennline füllen ;---------------------- Achtung: Dabei wird alles überschrieben, was bisher in der Zeile stand!
← 3	Erstellt (assembliert) euer Programm im Arbeitsspeicher.
← 4	Exportiert euren assemblierten Quellcode in eine SEQ-Datei. Ihr seht im Listing die Speicheradressen, Bytes und euren Sourcecode. Gebt ihr statt eines Dateinamens ein ? ein, wird das Listing ausgedruckt. Mit einem * erfolgt die Ausgabe auf dem Bildschirm, hier könnt ihr die Ausgabe mit der RUN STOP-Taste abbrechen.
← 5	Erstellt (assembliert) euer Programm, wie bei ← 3, dieses Mal wird es allerdings auf der Diskette gespeichert.
← 6	Fragt einen Speicherbereich ab, der dann ab der aktuellen Cursorposition als .byte-Zeilen in den Quellcode aufgenommen wird.
← 7	Setzt den Cursor-Tab auf die aktuelle Spalte. Nach einem RETURN, erscheint der Cursor dann immer in dieser Spalte.
← 8	Setzt den Quellcode-Tab auf die aktuelle Spalte, solange diese unter 12 liegt. Mnemonics und Pseudo-Op-Codes werden dort automatisch ausgerichtet.
← +	Falls ihr mal schnell zwei hexadezimale 16-Bit Zahlen addieren wollt, könnt ihr dieses Kommando nutzen.
← -	Wie ← +, nur die Subtraktion.
← 	Die aktuelle Zeile in die „Zwischenablage“ kopieren.
← 	Die Zeile aus der „Zwischenablage“ einfügen. Achtung: Dabei wird alles überschrieben, was bisher in der Zeile stand!
← @	Diskettenstatus anzeigen. Wenn keine Probleme vorliegen, sollte 00, ok,00,00 angezeigt werden.
← *	Das Inhaltsverzeichnis der Diskette anzeigen.
← A	Dies aktiviert den PETSCII-Modus. Der Cursor blinkt etwas schneller, solange dieser Modus aktiv ist. In diesem Modus könnt ihr in .text-Zeilen z. B. auch Steuercodes eingeben. Betätigt ←, um den PETSCII-Modus zu beenden.
← E	Hiermit könnt ihr Textbausteine oder ganze Quellcodes, die als SEQ-Datei gespeichert sind, von der Diskette in den Editor laden. Die Zeilen werden an der aktuellen Cursorposition eingefügt. Werft auch einen Blick auf ← W.
← I	Funktioniert wie ← SHIFT+F, nur dass hier automatisch der freie Speicherbereich unter dem vom Turbo-Assembler für den Quellcode verwendetem vorgeschlagen wird.
← Q	Alle Markierung (s. ← M) löschen.
← R	Startet das Suchen und Ersetzen. Es wird erst der zu ersetzende Text und danach der neue Text abgefragt. Anschließend wird der Cursor auf die erste gefundene Position, nach der aktuellen Curorposition, gesetzt. Beachtet auch ← H, ← T und ← Y
← T	Ersetzt beim Suchen und Ersetzen (s. ← R) die aktuell gefundene Stelle.
← U	Speichert eine Liste der von euch verwendeten Labels mit den dazugehörigen Adressen als SEQ-Datei. Beachtet, dass die Infos auf dem letzten Erstellen beruhen. Am besten assembliert ihr euer Programm direkt vor dem Aufruf dieses Kommandos. Gebt ihr statt eines Dateinamens ein ? ein, wird gedruckt. Mit einem * erfolgt die Ausgabe auf dem Bildschirm.
← W	Speichert euren Quellcode im ASCII-Format als SEQ-Datei. Um eine solche Datei wieder zu laden, müsst ihr ← E nutzen.
← Y	Ersetzt beim Suchen und Ersetzen (s. ← R) alle Stellen ab der aktuellen Cursorposition.
← S	Euren Quellcode im Turbo-Assembler-Format speichern. Hinweis: Der Turbo-Assembler verwendet ein binäres Format, ihr könnt euren so gespeicherten Quellcode also nicht direkt „lesen“ oder mit anderen Assemblern nutzen. Es werden übrigens auch Einstellungen, wie die verwendeten Farben, die Tabs, die Belegung der Funktionstasten F3 bis F6, Markierungen und die aktuelle Cursorposition gespeichert.
← D	Es erscheint eine Abfrage, die es euch erlaubt, einen DOS-Befehl an das Diskettenlaufwerk zu senden.
← F	Startet die Suche. Der Cursor wird auf die erste gefundene Stelle, ab der aktuellen Position gesetzt. Beachtet auch ← H.
← H	Weitersuchen, nach ← F oder ← R.
← G	Zu einer Markierung (s. ← M) springen.
← K	Die Funktionstasten F3 bis F6 belegen. Drückt auf die gewünschte Funktionstaste und legt dann fest, was beim Betätigen passieren soll.
← L	Einen Quellcode im Turbo-Assembler-Format laden. Achtung: Dabei wird alles im Editor überschrieben!
← :	Zeigt eine Liste der aktuellen Markierungen (s. ← M) an.
← Z	Alle Änderung in der aktuellen Zeile rückgängig machen. Dieses Undo klappt nur solange, bis ihr die geänderte Zeile verlasst. Außerdem werden sämtliche Änderungen in der Zeile verworfen.
← C	Kaltstart vom Turbo-Assembler. Achtung: TASM wird neu initialisiert und der aktuelle Quellcode komplett gelöscht.
← B	Blockbefehle für den mit ← M markierten Block. W: Speichert den Block als SEQ-Datei auf der Diskette. C: Kopiert den Block an die aktuelle Cursorposition. K: Den Block löschen. Vorsicht: Setzt ihr einen Blockstart in Zeile 0 und nutzt K kann es zum Datenverlust kommen!
← M	Markierungen (Lesezeichen) und Blöcke setzen. Es erscheint eine Abfrage, drückt dort eine Ziffer zwischen 0 und 9, um ein einfaches Lesezeichen zu setzen. Um einen Block (s. ← B) festzulegen, drückt S für Blockstart und E für Blockende. Ein Block wird in einer anderen Farbe dargestellt.
← N	Gebt die gewünschte Zeilennummer ein, um dort hin zu springen.
← =	Zwei Zeilen verbinden. Überschreibt den Inhalt der Zeile über dem Cursor, ab der Spalte, in der der Cursor steht, mit dem Inhalt der aktuellen Zeile ab der Cursorposition. Die aktuelle Zeile wird anschließen gelöscht. (Klingt vertrackt, probiert es einfach mal aus.)
← /	Zeigt euch den Status von $DC00 und $DC01 an. Drückt RESTORE, um die Anzeige zu verlassen.
← F1	Setzt die frei belegbaren Funktionstasten F3 bis F6 wieder auf Standard zurück. Achtung: Es erfolgt keine Sicherheitsabfrage!
← RETURN	Trennt die Zeile, ab der aktuellen Cursorposition auf zwei Zeilen.
← P	EOR-Verschlüsselung (Standard = $00) Der Turbo-Assembler speichert euren Quellcode mit ← S binär. Falls ihr ein unbefugtes Laden unterbinden wollt, könnt ihr mit diesem Kommando eine Art Verschlüsselung aktivieren. Achtung: Ein Quellcode lässt sich nur mit der richtigen EOR-Verschlüsselung wieder laden!
← J	Einen Speicherdump anzeigen, dazu werden die Start- und Endadresse abgefragt.
← SHIFT+F	Überschreibt einen Speicherbereich mit einem bestimmten Wert. Dazu werden die Start-, Endadresse und der Füllwert abgefragt. Vorsicht: Füllt ihr den falschen Bereich, kann es zum Absturz und / oder kompletten Datenverlust kommen!
← SHIFT+L	Lädt eine Datei an die angegebene Speicheradresse. Vorsicht: Überschreibt ihr den falschen Bereich, kann es zum Absturz und / oder kompletten Datenverlust kommen!
← SHIFT+S	Speichert den eingegebenen Adressbereich auf der Diskette.
← V	Aktuelle Speicherbelegung anzeigen. - = frei + = belegt
← O	Die verfügbaren Farbschemen durchschalten.
← SHIFT+K	Tippgeräusche an- / ausschalten. Falls eingeschaltet, wird ein Klickgeräusch abgespielt, sobald ihr eine Taste drückt.

Allgemeine Anmerkungen zur Turbo-Assembler-Bedienung

Hier noch einige Infos, die evtl. nützlich sind. Einige Punkte wurden zwar bereits erwähnt, werden hier aber der Vollständigkeit halber wiederholt.

• In der Regel gelangt ihr mit der RESTORE-Taste zurück zum Turbo-Assembler. Falls dies mal nicht klappt, geht es auch vom BASIC mit der Eingabe von SYS 333 oder SYS 36864.
• Der Turbo-Assembler benötigt natürlich auch Arbeitsspeicher. Er ist ab Speichersstelle $9000 zu finden. Außerdem benötigt euer Quellcode ebenfalls Platz, TASM speichert diesen gepackt von $8feb bis $0801 quasi „rückwärts“.
• Möchtet ihr beim Speichern eine vorhandene Datei überschreiben, dann gebt direkt vor dem Dateinamen @: ein.
• Alles muss in eine Zeile passen, d. h. auch .byte-Zeilen können nicht in der nächsten Zeile fortgesetzt werden. Ihr müsst dort wieder mit .byte beginnen.
• Der Turbo-Assembler verfügt über einen mathematischen Parser. Ihr könnt also im Quellcode Formeln eingeben, die dann bei der Assemblierung berechnet werden.
• Label und Konstanten dürfen maximal 15 Zeichen lang sein.
• Falls ihr einen BASIC-Start in eurem Programm nutzt, solltet ihr nach dem Erstellen nicht auf die S-Taste drücken! Geht stattdessen zurück zum Editor und wechselt mit ← 1 ins BASIC. Dort könnt ihr dann einfach RUN eingeben, um euer Programm zu starten.

Ausdrücke, Operatoren, usw.

Beim Schreiben eurer Programme könnt ihr folgende Ausdrücken und Operatoren verwenden.

Kürzel	Funktion	Beispiel
$	Prefix für hexadezimale Zahlen.	lda #$e2
%	Prefix für binäre Zahlen (max. 8-Bit).	lda #%11000011
!	Prefix für dezimale Zahlen. Das ! ist optional und wird meistens weggelassen.	lda #!123 gleichbedeutend mit lda #123
“x“	Zeichen und Texte	lda #“a“
( )	Klammern für Berechnungen.	lda #(3+5)*2
*	Multiplikation	lda #8*2
/	Division	lda #16/2
+	Addition	lda #3+5
-	Subtraktion	lda #16-8
&	Logisches UND	lda #%10011001&11000011
.	Logisches ODER	lda #%10011001.11000011
:	Exklusives ODER	lda #%10011001:11000011
<	Unteres Byte eines 16-Bit-Wert	lda #<$ffe2
>	Oberes Byte eines 16-Bit-Wert	lda #>$ffe2
*	Aktuelle Speicheradresse	lda #>*
*=	Speicheradresse setzen	*= $1000
;	Alles ab dem Semikolon ist ein Kommentar und wird vom Assembler bei der Programmerstellung ignoriert.	; Mein Kommentar

Unterschiede zum C64 Studio / ACME

Der größte Unterschied liegt in den verfügbaren Pseudo-OP-Codes und deren Schreibweise. Der Turbo-Assembler bietet davon nur vier.

Pseudo-OP-Code	Beschreibung	C64 Studio / ACME
.byte	Einzelne Bytes (z. B. Spritedaten) abbilden. Beispiel .byte $80, $ff, 255, %10010110	!byte
.word	16-Bit-Werte (z. B. Adresslisten) abbilden. Beispiel .word *, $ffe2, 65535	!word
.text	Texte für Bildschirmausgaben. Beispiel .text “Bitte warten...“	!text
.offs	Die nächste Anweisung wird im Arbeitsspeicher an der Position (aktuelle Adresse + Offsetwert) abgelegt. Beispiel .offs 10 Das lässt sich auch über *= *+10 erreichen.	*= *+{Wert}

Wie oben erwähnt, müsst ihr natürlich auf Groß- und Kleinschreibung, sowie die Beschränkung auf 40 Zeichen je Zeile achten.

---

So, das reicht hoffentlich erstmal.
Falls ihr wirklich größere Projekte direkt am C64 entwickelt, bietet sich noch ein Freezer wie das Action Replay, die The Final Cartridge III oder etwas ähnliches an. Damit könnt ihr eure Programm zur Laufzeit untersuchen und so evtl. Fehler leichter aufspüren.

Nun noch viel Spass und Erfolg beim Programmieren, auf dem guten alten C64.

---

(11 Bewertungen | Ø 4,27 von 5 | 85,45%)

Loading...

---