*********************************************************
* COREWARS - Krieg der Kerne *
* *
* (C) 1987 by Martin Patzel *
* Promenadeweg 15 *
* 7905 Dietenheim *
* *
*********************************************************
* Dieses Programm ist PUBLIC-DOMAIN und darf in keiner *
* Weise verkauft bzw. gewerblich vertrieben werden. *
*********************************************************
Hier ist nun endlich eine stark erweiterte Version von Krieg der Kerne,
wie es sie bereits als Public-Domain Programm gibt.
Besonderheiten:
- eingebauter symbolischer Multipass-Redcode-Assembler
- eingebauter Disassembler
- grafische Anzeige des Spielfelds
- max 26 Programme gleichzeitig
- Single-Step Ausführung von Programmen
- Spielstandsauswertung bei mehrmaliger Programmausführung
- Kampfarena max. 32000 Speicherplätze groß
- Aufruf eines Editors aus dem Programm heraus möglich
Kurzanleitung zum Spiel:
========================
Es gibt eine Kampfarena, in der sich mehrere Programme 'tummeln'.
Jedes dieser Programme versucht nun, so lange wie möglich zu
überleben und andere Programme zum Absturz zu bringen.
Ein Programm stürzt ab, wenn es eine nicht ausfürbare Anweisung
ausführen will. Sieger ist dasjenige Programm, das am Schluß
übrigbleibt.
Die Programme, die sich hier tummeln, werden natürlich von jemandem
geschrieben, z.B. von zwei Spielern: Jeder von den Beiden versucht,
ein möglichst intelligentes und kampfstarkes Programm zu schreiben.
Diese werden dann in die Arena geladen und gestartet.
Derjenige ist dann Sieger, dessen Programm länger überlebt hat.
Wer Genaueres nachlesen will, der schaue in den Originalartikel [1]
bzw lese die Beschreibung von Krieg der Kerne [2].
Nun zu den Einzelheiten:
========================
Die Programme werden in REDCODE geschrieben, einer assemblerähnlichen
Sprache. Diese Programme werden dann mit dem eingebauten Assembler
übersetzt und können dann in die Arena geladen werden.
In REDCODE gibt es im Moment 12 Befehle und 7 Adressierungsarten (s.u.):
DAT n definiert eine Datenfläche mit dem Wert n.
Versucht ein Programm eine solche Anweisung auszuführen,
so 'stürzt' es ab und hat somit verloren.
zuläss. Adressierungsarten: nur relativ (s.u.)
MOV n,m kopiert eine Zahl oder einen Befehl von n nach m
zuläss. Adr.art. für n: rel,#,@,<,>
zuläss. Adr.art. für m: rel,@,<,>
ADD n,m
SUB n,m addiert/subtrahiert n zu/von m
zuläss. Adr.art. für n: rel,#,@,<,>
zuläss. Adr.art. für m: rel,@,<,>
JMP n springt nach n
zuläss. Adr.art. für n: rel,@,<,>
JMZ n,m springt nach n, falls m=0
JMN n,m springt nach n, falls m<>0
JMG n,m springt nach n, falls m>0
zuläss. Adr.art. für n: rel,@,<,>
zuläss. Adr.art. für m: rel,@,<,>
DJN n,m m=m-1, springt, falls dann m<>0
DJZ n,m m=m-1, springt, falls dann m=0
zuläss. Adr.art. für n: rel,@,<,>
zuläss. Adr.art. für m: rel,@,<,>
CMP n,m falls n<>m ist, nächste Anweisung überspringen
zuläss. Adr.art. für n: rel,#,@,<,>
zuläss. Adr.art. für m: rel,@,<,>
SPL n Splittet Programmausführung in zwei Wege auf:
einmal wird nach der SPL-Anweisung weitergemacht,
andererseits an der Adresse n. Beide Programmteile
werden dann natürlich nur noch mit der halben
Geschwindigkeit ausgeführt, da sich die beiden Teile
die zur Verfügung stehende Zeit teilen müssen.
Nun zu den Adressierungsarten:
n falls nur n (ein beliebiger Ausdruck) da steht, wird
relativ adressiert, d.h. die endgültige Adresse
ergibt sich aus der aktuellen Adresse plus n.
(relative Adressierung)
#n Es wird direkt die Zahl n verwendet (z.B. ADD #1,x
addiert 1 zur Variablen x).
@n Zunächst wird zur aktuellen Adresse n addiert. Dann
wird der dort stehende Zahlenwert als relative Adresse
von dort verwendet. (indirekte relative Adressierung)
>n wie @n, nur wird vorher der Zahlenwert in der relativen
Adresse n um 1 erhöht. (indirekte relative Adressierung
mit pre-inkrement)
n, nur wird um 1 erniedrigt. (indirekte relative
Adressierung mit pre-dekrement)
n> wie >n, nur wird nachher (nach der indirekten Adressierung)
erhöht. (indirekte relative Adressierung mit post-inkrement)
n< wie n>, nur wird um 1 erniedrigt. (indirekte relative
Adressierung mit post-dekrement)
Puhh... ist das kompliziert,
... darum nun ein Beispiel:
Nehmen wir an, wir laden nachfolgendes Programm an Adresse 1000, dann
sieht es dort z.B. folgendermaßen aus:
1000 JMP 4
1001 DAT 3
1002 DAT 3
1003 DAT 4
1004 MOV @-3,-1>
1005 ADD #1,-4
1006 DJN -2,-4
1007
Das Programm kopiert sich selbst nach Adresse 1007:
Die Programmausführung beginnt bei 1000. Dort steht ein JMP 4 Befehl,
d.h. es wird die Programmausführung bei Adresse 1000+4=1004 fortgesetzt.
Der MOV-Befehl greift zunächst auf Adresse 1004-3=1001 zu, dort steht
eine 3. Nun holt er sich den Quelloperanden von Adresse 1001+3=1004.
Diesen (also sich selbst) kopiert er nach Adresse 1007 (zuerst 1004-1
berechnen, dort steht eine 4, dann 1003+4=1007 berechnen). Anschliessend
(genaugenommen nach der Berechnung des Wertes 1007, nicht nach dem Kopieren
des Quelloperanden) wird der Inhalt von 1004-1=1003, also die 4 um eins
erhöht.
Dann wird zum Inhalt von 1005-4=1001, also der 3 eine 1 addiert
(ADD-Befehl).
Nun wird der Inhalt von 1006-4=1002, also die 3 um eins vermindert und
auf null überprüft. 2 ist aber ungleich 0, also wird nach 1006-2=1004
gesprungen und mit dem MOV-Befehl fortgefahren.
Nachdem die Befehle und Adressierungsarten nun (hoffentlich) einigermaßen
klar sind, folgt jetzt die Beschreibung des Assemblers.
Der Assembler
=============
Der in diesem Programm eingebaute Assembler ist ein symbolischer
Multipass-Assembler. Symbolisch deshalb, weil Labels (Marken) und
Konstanten verwendet werden können; Multipass, weil er das Quellprogramm
immer wieder liest und verarbeitet, bis alle Labels und Konstanten
festliegen.
Zur Syntax des Assemblers:
Der Assembler erwartet einen Befehl (Mnemonic) mit Argumenten pro Zeile:
[Label[:]] MNEMONIC Argument1 [, Argument2]
Das Label am Anfang der Zeile ist optional, ebenso wie der folgende
Doppelpunkt. Wird das Label aber angegeben, so muß es unbedingt am
Zeilenanfang stehen, da es sonst nicht als solches vom Assembler
erkannt wird! Labels können Groß- und Kleinbuchstaben sowie Ziffern
und den Underscore ('_') enthalten, dürfen jedoch nicht mit einer
Ziffer beginnen. ACHTUNG: Es ist nicht egal ob ein Label groß oder
klein geschrieben wird, d.h. Label und label sind zwei verschiedene
Labels!
Dann folgt ein Mnemonic, bestehend aus den 3 Buchstaben, die den
Befehl identifizieren (DAT, MOV,... s.o.). Hier sind Groß- und
Kleinschrift gleich, d.h. MOV=Mov.
Dann folgen ein oder zwei Argumente, je nach Befehl. Ein Argument
bestehet aus einem Ausdruck und einer Adressierungsart (bzw. keiner
bei relativer Adressierung. Ein Ausdruck wiederum kann aus Labeln,
Konstanten, und Zahlen bestehen, die miteinander addiert, subtrahiert,
multipliziert und dividiert werden können. Dabei darf auch geklammert
werden (normalerweise gilt 'Punkt vor Strich'). Auch dürfen Vorzeichen
verwendet werden.
Die Definition von Konstanten erfolgt so:
Konstante = Ausdruck
wobei für eine Konstante die gleichen Regeln gelten wie für ein Label,
mit einem Unterschied: Die Definition darf nicht am Zeilenanfang
beginnen, da sonst der Konstantennamen als Label aufgefaßt wird und
das nachfolgende '=' zu einer Fehlermeldung führen würde.
Nun noch ein Wort zur Bewertung von Labeln und Konstanten in Ausdrücken:
Konstanten repräsentieren immer den Wert, den sie bei der Definition
erhalten haben.
Labels erhalten immer die Differenz vom aktuellen Programmzähler zu
dem Wert, den der Programmzähler hatte, als das Label definiert wurde.
Ein Beispiel:
Programmzähler (PC)
|
V
....
05 label1:
05 DAT 0
06 const1=99 ; erhält den Wert 99
06 const2=label1 ; erhält -1, da 5-6=-1
06 MOV #1,label2 ; label2 ergibt hier den Wert 2, da 8-6=2
07 ADD #const1-const2,label1 ; label1 hat hier den Wert -2 (5-7=-2)
08 label2:
08 DAT 0
09....
Wie man sieht, erhalten Labels in Ausdrücken immer den Wert, der sich
ergibt aus - .
Kommentare können überall stehen, sie werden durch einen Strichpunkt
begonnen und gehen dann bis zum Zeilenende.
Erscheint eine Fehlermeldung der Art
line nnn: near "xxx": expected '\n' MNEMONIC IDENT,
so trat ein Fehler in Zeile nnn auf, wobei der Assembler anstatt des
Wortes xxx entweder ein Zeilenende ('\n') oder ein Mnemonic oder
einen Ident, also ein Label oder eine Konstante erwartet hätte.
Ist die Symbol-Option eingeschaltet, so werden nach erfolgreicher
Assemblierung alle Labels und Konstanten mit ihren Werten ausgegeben
(Labels enthalten dann die Werte des PC's ihrer Definitionszeilen).
Hier nun noch eine Zusammenfassung der Syntax des Assemblers in
Extended-Backus-Naur-Formalism:
EBNF: [a] Ausdruck a höchstens einmal
{a} Ausdruck a beliebig oft (auch 0 mal)
ab Ausdruck a, dann Ausdruck b
a|b entweder Ausdruck a oder b (bindet schwächer als ab)
'a' Das Zeichen "a"
$ program = {line}.
$ line = [ [LABEL [':']] command |
LABEL ':' |
IDENT '=' expression ] '\n'.
$ command = MNEMONIC arguments.
$ arguments = argument [',' argument].
$ argument = [('@'|'#'|'>'|'<')] expression |
expression ('>'|'<').
$ expression = term [('+'|'-') term].
$ term = factor [('*'|'/') factor].
$ factor = '(' expression ')' |
('+'|'-') factor |
NUMBER |
IDENT.
LABEL : Zeichenkette aus Groß/Kleinbuchstaben/Zahlen/'_', die nicht mit
einer Zahl beginnt. Die Zeichenkette muß am Zeilenanfang
beginnen!
IDENT : Zeichenkette wie LABEL, darf aber nicht am Zeilenanfang stehen!
MNEMONIC: ? {MOV, DAT, ADD, SUB, JMP, JMZ, JMN, JMG, DJN, DJZ, CMP, SPL}
Es können Groß- und Kleinbuchstaben verwendet werden.
NUMBER : Zeichenkette aus den Ziffern 0-9.
Trennende Spaces sind normalerweise nicht notwendig, nur wenn zwei
Zeichenketten unterschieden werden sollen. Es sind folgende Zeilen
möglich:
label1:mov@src,dest>;Comment
add#1,src
djnz label1 , counter
Editor
======
Es ist möglich, einen Editor von COREWARS aus zu starten. Ist die
Option 'PRG' im Pulldown-Menü gesetzt, so wird beim Anklicken von
'Editor' ein Gem-Programm gestartet, das unter dem Namen "EDITOR.PRG"
auf der Diskette vorhanden sein muß. (... sollte sinnvollerweise dann
auch ein Editor sein...) Ist die Option 'PRG' ausgeschaltet, so
wird ein TOS-Editor geladen und gestartet, der unter dem Namen
"EDITOR.TTP" auf der Diskette vorhanden sein muß.
Beendet man den Editor, so kehrt man automatisch in COREWARS zurück.
Der Simulator
=============
Der Simulator ist in der Lage bis zu 26 Redcode-Programme
quasi-gleichzeitig auszuführen.
Der Programmablauf kann jederzeit angehalten werden und der Speicher
(die 'Kampfarena') genau betrachtet werden (z.B. mit dem eingebauten
Disassembler). Der Programmablauf kann auch Schritt für Schritt
erfolgen (Single-Step), bzw. nach einer gewissen Anzahl von Schritten
angehalten werden.
Bildschirmanzeige
-----------------
Jedes Programm im Speicher wird als eine Folge von Großbuchstaben
angezeigt, und zwar wird für jeden Befehl des Programms genau ein
Buchstabe angezeigt.
Das erste Programm, das in den Speicher geladen wird, wird mit den
Buchstaben AAAA angezeigt, das zweite mit BBBB's, usw.
Dort, wo der Speicher leer ist, werden nur kleine Punkte auf dem
Bildschirm angezeigt.
Schreibt ein Programm, z.B. das Programm mit dem Buchstaben B, irgend-
etwas in den Speicher, so erscheint an der beschriebenen Stelle der-
selbe Buchstabe, den das Programm hat, hier also das B.
Add, Sub und < > bei der Adressierung erzeugen Ziffern auf dem Bildschirm.
Dies ist oft sehr nützlich, da man dadurch sieht, wo sich Zähler und
Pointer von Programmen verbergen (denn Zähler werden ja meistens mit
Add und Sub - Befehlen verändert).
Hat nur ein Teil des Spielfelds im Fenster Platz, so kann mit dem Fenster-
schieber am rechten Rand der gewünschte Teil des Spielfelds zur
Anzeige gebracht werden.
Programme laden
---------------
Mit dem Menüpunkt 'load' können fertig assemblierte Redcode-Programme
in den Speicher geladen werden.
Nach dem Anclicken fragt das Programm nach der Ladeadresse, also an
welche Stelle im Speicher es geladen werden soll. Diese Adresse sollte
im Bereich von 0 bis zur Speicherobergrenze liegen (die Speicherober-
grenze ist normalerweise bei 7999, es sind also 8000 Speicherplätze
verfügbar; dieser Wert kann jedoch verändert werden).
Anschließend wird nach dem Dateinamen des übersetzten Redcode-Programms
gefragt.
Das Programm wird nun geladen und am Bildschirm als eine Folge
von Buchstaben angezeigt.
Auf diese Weise können bis zu 26 Programme in den Speicher geladen werden,
die nacheinander die Buchstaben A bis Z als Kennzeichnung erhalten.
Programmausführung
------------------
Unter dem Menüpunkt 'Debug' finden sich die Einträge zur Programmablauf-
steuerung:
Mit 'Start Simulation' wird der Simulator gestartet. Er läuft dann, bis
entweder eine Taste gedrückt wird oder bis alle Programme 'abgestürzt'
sind. Hat man den Programmablauf mit einem Tastendruck unterbrochen,
so kann danach der Simulator wieder gestartet werden. Er macht dann an
der Stelle weiter, an der er unterbrochen wurde.
Mit 'Trace Instruction' bzw 'Trace n Instr...' kann genau ein Befehl
bzw können genau n Befehle abgearbeitet werden. Dann stoppt der
Simulator wieder.
Dump-Fenster
------------
Zwischendurch kann der Speicher mit der Dump-Funktion betrachtet werden:
Durch Ancklicken von 'Dump Arena' öffnet sich ein weiteres Fenster, in
dem ein Teil des Speichers im disassemblierten Format betrachtet werden
kann. Durch Anclicken der Fuller-Box rechts oben am Dump-Fenster kann
auch ein Speicherauszug auf Diskette ausgegeben werden. Das erzeugte
File heißt dann COREWARS.DMP.
Das Dumpfenster kann auch durch einen Doppelclick auf ein Feld im Arena-
Fenster geöffnet werden. Das angeklickte Feld wird dann im Dump-Fenster
ganz oben disassembliert.
Die Zahlen hinter den disassemblierten Befehlen werden hier nicht
mehr relativ ausgegeben, sondern sie bezeichnen direkt die absolute
Adresse in der Arena. Lediglich bei DAT-Befehlen wird hinter der absoluten
Adreßangabe noch der absolute Wert des DAT-Operanden angegeben.
Steht vor einer disassemblierten Zeile ein 'A>', so bedeutet dies,
daß der PC des Programmes A auf dieser Zeile steht und der Befehl
ausgeführt wird, sobald das Programm A mit der Ausführung an die
Reihe kommt.
Steht jedoch ein 'A>>' davor, so wird der Befehl in dieser Zeile
als erster beim nächsten Simulationsschritt ausgeführt.
Das Dumpfenster kann mit der Closer-Box oder mit einem Tastendruck
geschlossen werden.
Mehrfachausführung von Programmen
---------------------------------
Mit Hilfe des Menüpunkts 'Game' kann man Programme (fast) beliebig
oft gegeneinander kämpfen lassen. Anschließend wird eine Statistik
ausgegeben, wie oft welches Programm gewonnen oder verloren hat.
Mit 'Get Sequence' werden die Programme in den Speicher geladen:
Es erscheint eine Dateiauswahlbox, mit der man bestimmt, welches Programm
in den Speicher geladen wird. Diese Box erscheint so oft, bis die
Maximalzahl von 26 Programmen erreicht ist, oder man Abbruch anklickt.
Mit 'Setup' kann man angeben, nach wieviel Simulationsschritten
ein 'Kampf' als unentschieden gewertet werden soll, bzw. wie oft
man die Programme gegeneinander antreten lassen will.
Klickt man nun 'Run Sequence' an, so werden die Programme an zufällige
Plätze in die Kampfarena geladen ('Program x at nnnnn') und ausgeführt.
'Stürzt' ein Programm ab, so wird dies gemeldet ('Program x failed in
cycle nnnn'). Geht nach der voreingestellten Zahl von Simulations-
schritten kein Programm als eindeutiger Sieger hervor (d.h. es ist nur
noch allein in der Kampfarena), so wird die Runde als unentschieden
gewertet ('tie round').
ACHTUNG:
Die Programme können hier auch übereinander geladen werden (d.h. ein
bereits geladenes Programm wird von einem neu geladenen überschrieben).
Um solche Fälle möglichst auszuschließen, sollte die Kampfarena
nicht zu klein gewählt werden, damit die Programme möglichst gut
verteilt werden können.
Optionen
--------
Mit 'Clear Arena' kann die Kampfarena gelöscht werden (alle Programme
und Überreste von Kämpfen werden entfernt) und mit 'Select Arenasize'
kann die Größe der Kampfarena bestimmt werden (1-32000, gleichzeitiges
Löschen der Arena).
Mit 'Display' kann die grafische Spielanzeige abgeschaltet werden,
um eine größere Simulationsgeschwindigkeit zu erreichen.
Bemerkungen
===========
1. Das Scrollen am Bildschirm kann mit einer beliebigen Taste
angehalten werden (funtioniert aber leider nicht immer).
Die Taste 'Esc' bricht bei 'Run Sequence' die Programmausführung ab.
2. Mit einem Simulationsschritt meine ich in diesem Programm die
Ausführung eines Befehls eines Programmes! Hat man also 4 Programme
im Speicher (mit 4 PCs), so bedarf es 4 Simulationsschritten, damit
bei jedem Programm ein Befehl ausgeführt wird.
3. Durch die Darstellungsweise von Adressen und Speicherplätzen
(1 Befehl mit max. zwei Argumenten) kommt es zwangsläufig zu
Problemen mit der Adressierung (meint man jetzt mit der Adresse
den Befehl oder das 1. oder das 2. Argument???).
Ich habe dieses Problem folgendermaßen gelöst:
- Bei einem MOV #... - Befehl wird an der Zieladresse immer ein
DAT-Befehl mit dem entsprechenden Wert erzeugt.
- Bei ADD/SUB-Befehlen werden immer die 2.Argumente der Befehle
addiert/subtrahiert (da auch das Argument des DAT-Befehls intern
als 2.Argument behandelt wird).
Bei ADD/SUB #... wird dann natürlich der Wert nach # zum/vom
2. Argument der Zieladresse addiert/subtrahiert.
- Bei JMZ/JMN/JMG wird der Wert des 2. Arguments getestet und dann
evtl. gesprungen.
- Bei DJZ/DJN wird analog der Wert des 2. Arguments um eins vermin-
dert und dann auf =0 bzw. <>0 getestet.
- Bei CMP #... muß das 2. Argument auf einen DAT-Befehl verweisen
und dessen numerischer Wert muß gleich dem Wert nach dem # sein;
dann erst werden die beiden Argumente des CMP-Befehls als gleich
erkannt.
Bei allen anderen Adressierungen des CMP-Befehls müssen die beiden
Argumente auf zwei total identische Speicherzellen verweisen, damit
der CMP-Befehl Gleichheit erkennt.
- Jeder SPL-Befehl benötigt zusätzlichen Speicherplatz. Geht dieser
zuende, erscheint bei jeder Ausführung des SPL-Befehls ein
'SYSTEM ERROR'.
4. (Fast) jedes Kommando in der Menüleiste kann auch durch einen
einen entsprechenden Buchstaben auf der Tastatur ausgelöst werden.
Dieser Buchstabe ist in der Menüleiste hinter dem Kommando in
eckigen Klammern angegeben.
Literatur:
[1] A.K. Dewdney: Computer-Kurzweil, Spektrum der Wissenschaft,
Aug. 84, Nov. 84, Mai 85, Apr. 87
[2] ST-PD-Service: Disk 57, Krieg der Kerne