|
Inhalt dieser Seite
Einführung in das Spielprinzip Bei Corewars handelt es sich um ein Simulations- spielzeug. Genauer gesagt geht es darum, ein Kampfprogramm für einen simulierten Computer zu schreiben und dieses dann auf ein Programm eines anderen Spielers zu hetzen. Dieses Programm nennt sich M.A.R.S. ("Memory Array Redcode Simulator"). Die Befehle, die so ein simulierter Computer durchführen kann werden in einer Assembler- sprache Namens "Redcode" geschrieben. Um ein Spiel zu gewinnen, muß es dem eigenen Programm gelingen einen DAT-Befehl in den Code des anderen Programmes zu kopieren. Die Schwierigkeit besteht darin, daß man nie weiß, wo genau im Speicher das gegnerische Programm liegt. So muß man also einen Algorithmus finden, der den Speicher mit DAT-Befehlen übersäht, in der Hoffnung, daß man den anderen zuerst "trifft". Warum gerade DAT ?? Der DAT Befehl dient an sich dazu, wie sein Name schon andeutet, Daten zu speichern. Man kann zu dem Wert in einem DAT hinzuaddieren oder ihn für indirekte Sprünge benutzen. Mehr dazu siehe Adressierungsarten und Opcodes. Man darf den DAT Befehl aber NIEMALS direkt als Anweisung ausführen lassen - das führt per Definitionem zu einem Programmende, was dem Sieg des Gegners gleichkommt. Vielleicht hilft es, sich vorzustellen, daß DAT sowas wie END bedeutet. Beispiel für die richtige Nutzung eines DAT Opcodes: ADD #7, +2
Dieses Programm ist zwar sinnlos, aber der
Wert #1 in dem Dat-Befehl wird alle zwei Taktzyklen um 7 größer.
Multitasking Um einen Kampf zwischen zwei Programmen zu ermöglichen, braucht man Multitasking. Das bedeutet, daß immer Abwechselnd ein Befehl des einen und dann ein Befehl des anderen Programms ausgeführt wird. Für jeden Spieler wird mitgeschrieben, welcher Befehl als nächster ausgeführt werden soll. Diese Werte werden Instruction Pointer genannt, weil sie eine Zahl beinhalten, die auf die nächste auszuführende Zelle im Speicher (Adresse im Core Memory) zeigen. Weiters besteht für jeden Spieler die Möglichkeit, mehrere IP's zu benutzen, jedes Programm kann sich also "aufsplitten", wobei immer genau ein Befehl von Spieler 1 auf einen Befehl von Spieler 2 folgt. Für jeden Spieler existiert eine Tabelle,
die Task Table genannt und für jeden Spieler getrennt verwaltet wird.
Der Kampf gilt dann als gewonnen, wenn die Task Table des Gegners keine
aktiven IP's mehr beinhaltet.
Der Instruction Pointer (IP) und Relativität Jeder Redcode Befehl kann sich nur durch eine Relation auf eine andere Zelle im Core beziehen. Man kann mit dem Befehl JMP +5 festlegen, daß der nächste auszuführende Befehl 5 Zellen weiter hinten im Speicher liegt. Effektiv wird der Wert 5 zum aktuellen IP addiert. Rein theoretisch gäbe es die Möglichkeit einer "absoluten" Adressierung, der Befehl JMP #501 würde das Programm also an der fünfhundertersten Zelle fortsetzen. Es ist aber so definiert, daß das einem Kampfprogramm nicht erlaubt ist. (In meiner Version von M.A.R.S. kann man die Prüfung auf solche illegale Befehle zu Testzwecken abschalten) Sollte ein Befehl ganz am Ende des Speichers
stehen und über dieses Ende hinaus verweisen (Der Core Memory besteht
aus 10.000 Zellen, die jeweils einen kompletten Befehl beinhalten können),
zB: #9987 JMP +100, dann wird von dem Verweis auf die Zelle #10087 auf
#0087 gekürzt. Der Speicher erscheint dem Programm als endlos, jedoch
ist er über 10.000 Zellen periodisch. Das funktioniert genauso, wenn
eine Referenz unter die nullte Zelle verweist. Wie schon erwähnt,
ist jede Adressierung IP-relativ!
Adress Modes Vorweg eine Definition: Jeder Befehl (genauer jede Zelle im Core) hat Platz für den Opcode (welcher Befehl es ist) und zwei Adressen, wobei die erste Adresse als A0 und die zweite als A1 bezeichnet wird: Syntax: OPC A0, A1 oder OPC Source, Target A0 wird meistens zur referenzierung der Quelle (Source) benutzt, wobei A1 meistens auf die Zelle zeigt, die manipuliert werden soll (Ziel = Target). Sollte ein Befehl vorliegen, der nur aus "OPC A0" besteht, dann befindet sich im Speicher der Adresse A1 automatisch ein "#0". Es gibt drei Arten der Relation, wobei die erste keine eigentliche Relation darstellt, sondern eine Absolute Adressierung
Theoretisch würde mit einer Referenz wie #1020 exakt die eintausenzwanzigste Zelle im Core angesprochen. Das ist aber illegal. Dennoch hat dieser Adressierungsmode eine wichtige Funktion: Man kann damit auch konstante (oder "konkrete") Werte speichern. Der Befehl JNE #+5, #+9 (Jump Not Equal) würde die Zahlen 5 und 9 vergleichen und feststellen, daß sie voneinander abweichen. Der Befehl DAT #+990 würde als Variable dienen. Man kann den Inhalt dieser Zelle mit geeigneten Befehlen verändern, abfragen oder indirekt benutzen. Relative Adressierung
Mit Hilfe einer relativen Adresse kann man auf eine Zelle verweisen, die n Positionen vom aktuellen Befehl entfernt ist. (IP + n) Beispiel:
überspringt in der Programmausführung die nächsten vier Anweisungen. Oder: ADD #+10, +22 Addiert den Wert #10 zur Adresse A0 der Zelle, die 22 Positionen weiter hinten im Speicher liegt. Das wird vermutlich ein DAT sein. (Muß aber nicht, es wird nur A0 verändert. MOV kann aber einen Ausnahme bilden.) Indirekt relative Adressierung
Mit Hilfe dieser Adressierungsart kann man die referenzierte Zelle über einen DAT Befehl steuern. Bei der Adresse A0 wäre das nicht unbedingt notwendig, da sie sich zB. durch ADD verändern lassen würde. Auf den Inhalt von A1 hat man aber gar keinen Zugriff über die Befehle. Am Besten erkläre ich es mit einem Beispiel: DAT #+10
Dieser Befehl würde effektiv um 10 Zellen weiter springen. Oder: DAT #-20
Würde den Wert in A0 von der Zelle IP - 20 zu A0 der Zelle IP + 7 addieren. @n bedeutet quasi, daß an der Stelle der indirekten Angabe der Wert A0 von der angegebenen Zelle für eine normale Relation benutzt wird. Im Obigen Beispiel würde der ADD so ausgeführt werden, als stünde dort: ADD -20, +7 ( Addiere [IP - 20].A0 zu [IP + 7].A0 )
Die Opcodes (Befehle) Source kann sein: #n, +n, -n @+n oder @-n Target darf nicht sein: #n Wenn nicht anders angegeben, darf ein Befehl nur so vorkommen, wie er in der folgenden Liste definiert ist. Der Compiler prüft nicht, ob ein Befehl illegal ist, das findet man heraus, wenn sein Programm im M.A.R.S. abstürzt. Mehr Information zu den einzelnen Befehlen findet ihr in der Onlinehilfe. DAT - store DATa
MOV - MOVe (eigentlich "copy") data
JMP - JuMP to cell
SPL - SPLit (create new task) at cell
ADD - ADDition source to target
SUB - SUBtraction source from target
JEQ - Jump +2 if sources EQual
JNE - Jump +2 if sources Not Equal
JMZ - JuMp to cell if source equals Zero
JNZ - Jump to cell if source does Not equal
Zero
DJZ - Decrement source and Jump if now
Zero
DJN - Decrement source and Jump if now
Not zero
Folgende Befehle werden von einer zukünftigen
Version des M.A.R.S. verstanden werden:
Beispiele für Kampfprogramme Sind in der Onlinehilfe zu finden. Ausserdem sind die mitgelieferten Kämpfer mit Kommentaren versehen. Der Redcode-Compiler Man kann Kampfprogramme mit Hilfe des M.A.R.S. direkt in den Core Memory hineinschreiben, oder sie von einer Textdatei mit der Endung .red einlesen (compilieren) lassen. Der Compiler bringt nicht nur den Vorteil, daß man seine Routine nicht jedes Mal mühsam Befehl für Befehl reinklopfen muß, es gibt auch weitere Features: Kommentare
-¯-Anfang
der Datei----------------------------------¯-
JMP 0 ; if
no AdressMode defined it's allways
Labels (Sprungmarken)
zB: Kampfprogramm "Dwarf" Quelltext mit Labels wird übersetzt in loop:
MOV #0, @pointer MOV #+0,
@+3
Wichtig ist es, darauf zu achten, daß
kein Labelname im Namen eines anderen enthalten ist. Im ungünstigsten
Fall muß man die Labels halt durchnumerieren, zB. loop1, loop2 oder
pointerA, pointerB usw.
Was bringt der "Core View"? Wenn man den Quelltext endlich fertig geschrieben hat und der Compiler keine Fehler mehr meldet, dann bedeutet das noch immer nicht unbedingt, daß das Kampfprogramm auch das tut, was es soll. "Logische" Programmfehler kann kein Compiler der Welt erkennen. Man kann nun das eigene Program Schrittweise ausführen und die Ergebnisse eines jeden Befehls im "Monitor" und im "Core View" überprüfen. Der Monitor zeigt den genauen Inhalt einer jeden Core-Speicherzelle an, der Core View dient dazu, einen groben Überblick über die Vorgänge im Speicher zu bieten. Links oben wird die Speicherzelle #0 abgebildet, und die Adressen steigen von links nach rechts, dann zeilenweise. Mit einem Klick auf eine Zelle im Core View erhält man ganz unten in der Statuszeile die Adresse, den Inhalt und die Zellen, die durch den enthaltenen Befehl referenziert werden. Die Bedeutung der Farben im Core View Die Farben zeigen die Art des Vorganges an: Spieler 1 (grün) / Spieler 2 (blau):
Bedeutung
Braun/Türkis: Opcode ausgeführt
oder Zelle manipuliert
Kurzanleitung zu MARS.EXE Wenn man ein Programm direkt in den Speicher schreibt, dann kann man im MONITOR durch Doppelklicken auf eine Zelle in den Editiermodus kommen. (Man kann auch auf Return drücken, wenn der Fokus schon auf der Listbox steht). Wenn man auf WATCH/ADD klickt, dann wird die im Monitor selektierte Zelle dauerhaft im Watchfenster angezeigt. Damit kann man beim Fehlersuchen wichtige DAT-Befehle bequemer beobachten. Um den Einsprungspunkt (Starting Point) für ein gerade erstelltes Programm zu definierten, muß man im DEBUG- Bereich einen der beiden (runden) Radio-Buttons auswählen, um festzulegen, wessen Spielers Programm man gerade meint. Dann klickt man auf "Set Starting Point". Die Adresse der selektierten Zelle wird dann in das Adress- Fenster des Debuggers eingetragen. Man kann die Adresse auch manuell eingeben. Wenn die Adresszeile eines Spielers leer ist, dann heißt das, daß er nicht teilnimmt. So kann man das Programm des Spieler 1 alleine laufen lassen. Wenn Spieler 1 keine Adresse hat, aber Spieler 2, dann wird Spierler 1 die Adresse #0 zugewiesen, also für Einzeltests immer Spieler 1 benutzen oder für Spieler 1 ein Idiot-Programm verwenden (JMP +0) Wenn man links oben auf die längeren Textfelder doppelklickt, dann wird eine Datei-Auswahlbox angezeigt. Man kann hier einen Redcode-Quelltext bestimmen, der dann in das Textfeld eingetragen wird. Man kann die Namen der .red Dateien auch ohne Pfad direkt dorthinein tippen, sofern die Kampfprogramme im selben Verzeichnis liegen wie MARS.EXE. Durch einen Klick auf "Compile" werden die definierten Programme geladen und in den Core Memory Compiliert. Durch Klicken auf "Run" wird der Programmlauf gestartet. Ein Klick auf "STEP" führt nur einen Befehl (aber für beide Spieler) aus. Man kann RUN unterbrechen, indem man auf "BREAK" klickt und mit "CONTINUE" wieder fortsetzen. Den Button "Tournament" sollte man nur mit Kampfprogrammen einsetzen, die schon ausreichend getestet wurden, da man die Ergebnisse des Compilers nicht zu sehen bekommt. Die Geschwindigkeit des Kampfes steigt stark, wenn man die Anzeige des Core View abschaltet. Am schnellsten wird es, wenn man den M.A.R.S. minimiert. Er erscheint dann automatisch wieder, sobald ein Kampf beendet ist. Für Fragen, Anregungen und Wünsche
oder Herausforderungen zu Tournamenten kontaktiert mich bitte über:
http://harald.ist.org.
|