Corewars

Search
Votes / Statistics
Rating 
N/A
Hits: 1,495
Downloads: 834
Votes: 0
My Atarimania
Comments (0)

Screenshots - Corewars

Corewars atari screenshot
Corewars atari screenshot
Corewars atari screenshot
Corewars atari screenshot
Corewars atari screenshot

Information - Corewars

GenreMiscellaneousYear1987
Language[unknown]Publisher[no publisher]
ControlsMouseDistributor-
Players1Developer[n/a]
ResolutionMedium / HighLicensed from-
Programmer(s)

Patzel, Martin

CountryGermany
Graphic Artist(s)

Patzel, Martin

SoftwareEnglish
Game design

Patzel, Martin

Box / InstructionsGerman
Musician(s)

[n/a]

LicensePD / Freeware / Shareware
Sound FX

[n/a]

Serial
Cover Artist(s)ST TypeST, STe / 0.5MB
MIDIVersion
Dumpdownload atari Corewars Download / MSANumber of Disks1 / Single Sided
Protection

Instructions - Corewars


        *********************************************************
        *               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
About Us - Contact - Credits - Powered with Webdev - © Atarimania 2003-2024