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  
   JMP -1  
   DAT #1  

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  
Syntax:  #n  

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  
Syntax: +n oder -n  

Mit Hilfe einer relativen Adresse kann man auf eine Zelle verweisen, die n Positionen vom aktuellen Befehl entfernt ist. (IP + n)  

Beispiel:  
   JMP +5   

ü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  
Syntax: @+n oder @-n  

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  
    JMP @-1    (Der IP zeigt auf den JMP Befehl)  

Dieser Befehl würde effektiv um 10 Zellen weiter springen. Oder:  

    DAT #-20  
    DAT #+7  
    ADD @-1, @-2   <-- IP  

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  
DAT #n  

MOV - MOVe (eigentlich "copy") data  
MOV #n, Target  erzeugt ein DAT #n in der Zelle Target  
MOV Source, Target    kopiert eine komplette Zelle  

JMP - JuMP to cell  
JMP Target  

SPL - SPLit (create new task) at cell  
SPL Target    Wie JMP, nur wird ein neuer Eintrag in  
              der Task Table angelegt.  

ADD - ADDition source to target  
ADD Source, Target  

SUB - SUBtraction source from target  
SUB Source, Target  

JEQ - Jump +2 if sources EQual  
JEQ Source, Source  

JNE - Jump +2 if sources Not Equal  
JNE Source, Source  

JMZ - JuMp to cell if source equals Zero  
JMZ Source, Target  

JNZ - Jump to cell if source does Not equal Zero  
JNZ Source, Target  

DJZ - Decrement source and Jump if now Zero  
DJZ Source, Target  

DJN - Decrement source and Jump if now Not zero  
DJN Source, Target  

Folgende Befehle werden von einer zukünftigen Version des M.A.R.S. verstanden werden:  
IJZ - Increment and Jump if now Zero  
IJN - Increment and Jump if nw Not zero  
JMG - JuMp +2 if A0 Greater than A1  
JNG - Jump +2 if A0 Not greater than A1  

  


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  
Man kann das Ende oder auch eine ganze Zeile mit Kommentartext versehen. Alles ab einem Strichpunkt wird schlichtweg ignoriert:  

-¯-Anfang der Datei----------------------------------¯-  
; Program: IDIOT  
; jumps allways to the same cell  

    JMP 0   ; if no AdressMode defined it's allways  
            ; RELATIVE! JMP 0 = JMP +0  
-­-Ende der Datei------------------------------------­-  

Labels (Sprungmarken)  
Labels werden vom Compiler durch eine relative Adresse ersetzt. Damit kann man das Programm lesbarer machen.  

zB: Kampfprogramm "Dwarf"  

    Quelltext mit Labels            wird übersetzt in  

    loop:    MOV #0, @pointer         MOV #+0, @+3   
             ADD #5, pointer          ADD #+5, +2  
             JMP loop                 JMP -2  
    pointer: DAT #4                   DAT #+4  

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  
Sehr dunkel: Vom Copiler geschrieben  
Dunkel: Diese Zelle wurde durch MOV hierher kopiert  
Hell: Diese Zelle war Source für einen MOV Befehl  

Braun/Türkis: Opcode ausgeführt oder Zelle manipuliert  
Gelb/Violett: Hier ist ein Task "gestorben"   
              (DAT wurde ausgeführt)  

  


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.  
   

Viel Spaß mit Corewars


weiter