Corewars for Dummies
Core Wars for Dummies;
an introduction and tutorial.
This document will attempt to explain Core Wars in general, so that the first time
player may gain an understanding of Corewars and can begin to write Redcode.
My introduction to Core Wars was through Scientific American. Articles there described
a game played in a virtual computer. Competing programs attempted to "kill" each
The programs were written in a language called Redcode. At first glance Redcode
appears hard to decipher, but with a little bit of knowledge the programs yield up
an abundance of information. That knowledge is written here.
Let's take a look at some basic concepts.
The game of Core War is played in a virtual computer (called MARS <1>). While MARS
can be any size, a common size is 8000 instructions. Programs are limited to a specific
starting size, normally 100 instructions. Each program has a finite number of executions (turns, cycles), normally this number is 80,000. These parameters are the
ones currently used by the 94 hill on the Pizza server. There can be any number
of variations on other hills.
There are currently 17 instructions used in Redcode. This number has changed as the
games has evolved. Each instruction has a three letter code (an example would the
MOV for move.) They are listed below in no particular order.
MOD modula (remainder of division)
JMZ jump if zero
JMN jump if not zero
DJN decrement, jump if not zero
SPL split execution
SLT skip if less than
CMP compare (see SEQ)
SEQ skip if equal
SNE skip if not equal
NOP no operation
An in-depth explanation of each instruction (also called Opcodes) appears later.
Suffice it to say that each instruction contains an "A" field and a "B" field. These
fields tell MARS how to execute the instruction.
By example the MOV command simply tells the MARS to copy what is in the "A" field
into the "B" field.
In the previous chapter we learned the meaning of the 17 Opcodes. In this chapter
we take a closer look at four of these instructions. These four are DAT, ADD, MOV,
and JMP. To illustrate we will use a very simple program.
;author John Q. Smith
;strategy bombing core
ADD #10, #-1
MOV 2, @-1
JMP -2, 0
DAT #33, #33
As you may have guessed, the character that indicates the start of a remark on a line
is ";". The first remark (;redcode-94) lets the MARS know that this program is
compliant with the proposed 1994 standard for Core Wars. Just so you know, there
have been two standards before the proposed 94 standard.
The name of this program is Sleepy. Sleepy attempts to destroy it's opponents by
dropping the "DAT #33, #33" instruction in their path of operation. A process which
attempts to execute a "DAT" statement dies.
Now that we know what it does, let's look at how it does it. The MOV command is really
the cornerstone of this program. Without the move command the program has no punch.
Let's see how it works.
MOV 2, @-1
Op A B
First off, notice that the "A" field points to the DAT statement. You can tell this
by counting two from the MOV line. This means that the MOV statement will be coping
the information at this location (the "DAT #33, #33").
The "B" field points to the line with the ADD statement in it. Ordinarily this would
mean that the bomb would be copied on top of this statement, but the "@" symbol makes
this an indirect pointer. In effect the "@" symbol says, use the "B" field I point
to as a new location to point from. In this case the "B" field points to the location
just before the ADD line (this location is not shown).
After the MOV statement is executed, the process goes to the next line. The JMP command
indicates a location for the process to go to. Here the process jumps to the ADD
Now that we have bombed a location of core, we should change pointer to a new location
so that we don't keep bombing the same place over and over. The ADD command changes
the pointer by adding the number "#10" to it. The symbol "#" means that this is
an immediate addressing mode. Put simply, this means deal with what is right here to
complete you task.
ADD #10, #-1
Op A B
The add command adds the "A" field to the "B" field. Here both fields are in immediate
mode, so the operation takes place on one line. After executing this instruction
once, it would look as follows.
ADD #10, #9
Op A B
Now when the MOV command drops a DAT bomb, it will land nine lines below the ADD statement.
0 ADD #10, #9
1-> MOV 2, @-1
2 JMP -2, 0
3 DAT #33, #33
9 DAT #33, #33
Sleepy will continue to drop bombs into the core in ten line increments until the
pointers rap around the core and return. At that point Sleepy begins to bomb over
it's own bombs, doing to until the end of time (80,000 cycles) or until acted upon
by another program.
There are other modifiers to address, but we will explain those in the next chapter.