Article 1444 of rec.games.

corewar:
From: pk6811s@acad.drake.edu
Newsgroups: rec.games.corewar
Subject: the imp-ring problem
Message-ID: <1992Nov3.083911.1@acad.drake.edu>
Date: 3 Nov 92 14:39:11 GMT
Sender: news@dunix.drake.edu (USENET News System)
Organization: Drake University, Des Moines, Iowa, USA
Lines: 46
Nntp-Posting-Host: acad.drake.edu

I know a lot of people are working on the imp-ring problem, (me too).
Here are some ideas for experimentation.

New bombs:
dat <2666,<-2667
or
sub <2666,<-2667

It is also easy to catch an imp by the tail with some kind of stun bomb,
the problem is killing a complete layer before a new layer is formed.
The points are so far apart that the standard sequential core clear
isn't fast enough to catch them all in time.
Maybe the answer is a clear routine like:
mov bomb,ptr
add #2667,ptr
jmp -2
which will attack all three points (of a 3-point ring) at the same time.

Some people are having success, though they are keeping pretty tight-lipped.
Here is the latest round of scores for Imprimis, my own stone-ring combo.
(%wins for Imprimis/%wins for opponent/%ties)

Medusa's v1 53/34/13
Nazgul 27/38/35
anti-body 42/46/12
Impression v3 1/ 0/99
Pale Shears4 40/44/16
Agony 2.5 37/ 0/63
Winter Werewolf 28/27/45
Sauron 49/28/23
Sender of Eight 0/ 2/98
Atomic Sheep 7/ 1/92
B-scanners l.i.v. 57/21/22
Jehannum 76/18/ 6
PLASMA 18/10/72
Emerald 57/ 5/38
Nimbus 14/ 3/83
Kobold 6b 78/ 6/16

I tried a couple of variations on Imprimis, but could not improve the

score, so put the original back up. It's presently in second or third
place, behind Medusa's v1. I will publish the live version of Imprimis
in time for people to have a shot at it before the tournament.

Paul Kline
pk6811s@acad.drake.edu
Article 1482 of rec.games.corewar:
Newsgroups: rec.games.corewar
Subject: Impression v3
Message-ID: <1992Nov16.064702.10776@wisipc.weizmann.ac.il>
From: fedimit@wisipc.weizmann.ac.il (Dan Nabutovsky)
Date: Mon, 16 Nov 1992 06:47:02 GMT
Organization: Weizmann Institute of Science, Computation Center
Lines: 81

Hi all,
This is my program Impression v3. As you can see, the main
principles of imp-writing are:
- Make spiral not ring
- One Ring is the best architecture
- Dwarf must get most of CPU time.
And, most important:
- Don't send your program to pdk. This schmuck will
make minor changes, send it to Koth under his name,
and then he'll blame you in copycatting.

;redcode
;name Impression v3
;kill P. Kline for plagiate
;author Dan Nabutovsky
;strategy 2 imp spirals + self-splitting dwarf

d EQU 2667
i EQU imp-2000
imp: mov 0,d

start: mov imp, i

spl 32
spl 16
spl 8
spl 4
spl 2
jmp i+d*0
jmp i+d*1
spl 2
jmp i+d*2
jmp i+d*3
spl 4
spl 2
jmp i+d*4
jmp i+d*5
spl 2
jmp i+d*6
jmp i+d*7
spl 8
spl 4
spl 2
jmp i+d*8
jmp i+d*0
spl 2
jmp i+d*1
jmp i+d*2
spl 4
spl 2
jmp i+d*3
jmp i+d*4
spl 2
jmp i+d*5
jmp i+d*6
spl 16
spl 8
spl 4
spl 2
jmp i+d*7
jmp i+d*8
spl 2
spl dwarf
spl dwarf
spl dwarf

DAT #0
DAT #0
DAT #0
DAT #0
DAT #0
DAT #0
DAT #0

inc dat #-2045,#2045

dwarf spl 0,100
stone mov <cnt+102-300,<cnt+100
add inc,stone
cnt djn stone,<-3799

END start

Article 1485 of rec.games.corewar:

Newsgroups: rec.games.corewar
From: pk6811s@acad.drake.edu
Subject: The shmuck responds
Message-ID: <1992Nov17.171301.1@acad.drake.edu>
Lines: 198
Sender: news@dunix.drake.edu (USENET News System)
Nntp-Posting-Host: acad.drake.edu
Organization: Drake University, Des Moines, Iowa, USA
Date: Tue, 17 Nov 1992 23:13:01 GMT

Well, I see after our private conversation, Dan is still unhappy and has
gone public with his complaint.

Let me share two pieces of code that I published BEFORE Impression

appeared on the hill, and before I received a copy:

;redcode
;name Emerald
;author P.Kline
inc dat #-2045,#2045
emerald spl 0,100
stone mov <cnt+102-300,<cnt+100
add inc,stone
cnt djn stone,<-3799
end emerald
Now, I estimate I spent over 40 hours experimenting with different constants
in Emerald to give it an effective (and unique) bombing pattern. I don't have
access to the programs that others use for computing their constants.
Apparently Dan was not able to find alternative constants, so elected
to use Emerald intact in Impression, changing only the word 'emerald' to
'dwarf'.

Also:

;redcode
;name Earnest
;kill Earnest
;author P.Kline
;strategy dwarf/ring combo
spacing equ 1143
start spl 1
spl 1
spl 1
spl a2
a1 spl a1b2
a1b1 spl a1b1c2
a1b1c1 mov imp1,imp1+(spacing*1)
jmp @-1
a1b1c2 mov imp1,imp1+(spacing*2)
jmp @-1
a1b2 spl a1b2c2
a1b2c1 mov imp1,imp1+(spacing*3)
jmp @-1
a1b2c2 mov imp1,imp1+(spacing*4)
jmp @-1
a2 spl a2b2
a2b1 spl a2b1c2
a2b1c1 mov imp1,imp1+(spacing*5)
jmp @-1
a2b1c2 mov imp1,imp1+(spacing*6)
jmp @-1
a2b2 spl a2b2c2
a2b2c1 mov imp1,imp1+(spacing*0)
jmp @-1
a2b2c2 spl 0
mov bomb,<bomb
bomb dat #-50

imp1 mov 0,1143

end start

I believe it was my innovation to use a binary routine to start the imps.

Impire used a completely different startup. Earnest is also a spiral.
It launches 8 processes over a seven-point ring, creating a 1-point overlap.
Dan's contribution was to eliminate the mov imp1,... lines because they
were unnecessary, to use a three-point ring, and to overlay a
second spiral on the first - taken together these are major improvements
and should be called original. Yet they do build on what was
presented in Earnest.

There are differences between Impression and Imprimis. I use reflections

to protect the stone from No Mucking About and Charon (and their derivatives).
I move a dat 0,0 after the stone to protect it from Plasma and somewhat
from Agony. I've seen no one else doing either, so they may be original.
I am using different stone constants. There is a spl 1 prior to
entering the binary routine, which effectively interleaves two spirals
without the overhead of launching them separately. And I launch two
three-point spirals instead of one. While this makes for more targets
for scanners to locate, it makes it impossible for a 'gated' program
(or one that evolves into a gate) to kill the entire program since
each ring will only walk half the length of the core before the timer
elapses - also an original concept.

Finally, here is Imprimis 2. It beats Impression v3 (and other single-ring

programs) from 8 to 20%. You decide whether it looks different,
acts different, and scores different from Impression:

;redcode
;name Imprimis 2
;kill Imprimis
;author P.Kline
;strategy two three-point imp spirals with a stone
;strategy now capable of beating other imps (10%)
d equ 2667
datzero equ inc-5
inc dat #2667,#3039
emerald spl 0
stone mov <cnt-2365-2+1267,cnt+2365-1+10
add inc,stone
cnt djn stone,<5061-1056

datz1 dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
rf34 dat #2667,#3039
spl 0
 mov <6902,<2376
add 7997,7999
djn 7998,<4005
datz2 dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
dat #0
rf49 dat #2667,#3039
spl 0
mov <6902,<2376
add 7997,7999
djn 7998,<4005
datz3 dat #0
dat #0
dat #0
dat #0
dat #0
dat #0

start mov <1000,datz1

mov <1500,datz2
mov <2000,datz3
mov imp,imp+1333
spl 1
spl 16
spl 8
spl 4
spl 2
jmp imp+(d*0)
jmp imp+(d*1)
spl 2
jmp imp+(d*2)
jmp imp+(d*3)
spl 4
spl 2
jmp imp+(d*4)
jmp imp+(d*5)
spl 2
jmp imp+(d*0)+1333
jmp imp+(d*1)+1333

spl 8
spl 4
spl 2
jmp imp+(d*2)+1333
jmp imp+(d*3)+1333
spl 2
jmp imp+(d*4)+1333
jmp imp+(d*5)+1333
spl emerald
spl emerald
spl emerald
jmp emerald
imp mov 0,2667
end start

Paul Kline
pk6811s@acad.drake.edu

Article 1488 of rec.games.corewar:

Newsgroups: rec.games.corewar
From: pk6811s@acad.drake.edu
Subject: Re: Copy cats
Message-ID: <1992Nov18.085805.1@acad.drake.edu>
Lines: 84
Sender: news@dunix.drake.edu (USENET News System)
Nntp-Posting-Host: acad.drake.edu
Organization: Drake University, Des Moines, Iowa, USA
References: <ford.722041041@honte>
Date: Wed, 18 Nov 1992 14:58:05 GMT

More on copycatting:

In reality we all build on what others have done. Even IMPire built
on the old imp strategy. I think most people get stuck trying to
make an existing strategy more efficient - less lines of code, instead
of mixing strategies or trying something new. The originator has probably
tested many variations already, so we're not likely to improve an
existing program, and as the other guy (I forgot who's note I was replying
to) stated, "my variations usually degenerate into the existing Emerald
or Nomuckingabout or whatever".

There are certain redcode irreducibles: an imp, a three-line bomber,

a six-line mouse, stone, etc. These have aged sufficiently to be
considered 'components', which can be incorporated into new, more
complex programs. Some other code-parts are also available: the gate-form
published by Mintardjo which he later stated is not original/unique. I also
don't believe step-sizes should be proprietary. When N. Sieben published
a number of optimum step-sizes, was he not recommending them for use?

Most importantly, we can't claim ownership to idea/strategy/concept.

Once the general idea has been made public, you can't claim it for
yourself. Only the specific implementation in your own code belongs
to you. So everyone is free to write their own bomber/stone, replicator/
paper, scanner, pittrapper, imp-ring, stone-paper combo, or whatever.

I made the statement that in the long run, copycatting is not an effective
strategy. Your program will slowly slide down the hill - along with
the original - as other developers attack your common strategy. I think
this is a true statement. Flash Paper was basically undone by the
appearance of other stone-paper fighters.

I did not intend by that statement to approve knocking off someone

else's code, only to make an observation. The question of where
originality comes in is a hard one to answer in general terms. I suggest
the answer is in forced publication. If all programs on the Hill over
four weeks old were published, the participants could judge whether
someone was unfairly copying others' code. As long as everyone understood
when they submitted their programs that if they become successful,
they will be made public, there should be no problem with publishing
them.

As for Emerald being a clone of Kobold, Emerald beats Kobold something

like 60/30. Here's the latest code for Emerald. Is it different enough
from Kobold/Twill/Stone for me to claim ownership?

(BTW, Matt, I removed the reflections. Since Charon and NMA disappeared,
they were only drawing the attention of other scanners. But I still know
where they are if I need them. :)

;redcode
;name Emerald
;kill Emerald
;author P.Kline
;strategy stone with djn stream
;strategy attempting a gate
spacing equ 2365
hide1 spl 0,<-6
hide2 mov 49,<-20
hide3 dat <-7,<-8
hide dat #inc+1037-130+1020
start mov hide3,inc+1037+48-130+1020
mov hide2,<hide ; create the one-dwarf->gate code
mov hide1,<hide
mov inc+0,inc+1020 ; move stone far away from decoy
hideb mov inc+1,inc+1020+1
mov inc+2,inc+1020+2
mov inc+3,inc+1020+3
mov inc+4,inc+1020+4
spl @hide
spl @hideb
mov #0,-7 ; don't leave any pointers to stone
mov #0,-7
mov #0,-7
mov #0,-7
mov #0,-7
inc dat #0-spacing,#spacing
emerald spl 0
stone mov <cnt-spacing-2,cnt+spacing
add inc,stone
cnt djn stone,<inc-129
end start

Paul Kline
pk6811s@acad.drake.edu

Article 1491 of rec.games.corewar:

Newsgroups: rec.games.corewar
From: maniac@unlv.edu (Eric J. Schwertfeger)
Subject: Sonic Boom 1.30 [X-Hill Source]
Message-ID: <1992Nov18.181110.1047@unlv.edu>
Sender: news@unlv.edu (News User)
Organization: Too many
References: <1992Nov8.195147.29858@cs.kuleuven.ac.be>
<9231710.16573@mulga.cs.mu.OZ.AU>
Date: Wed, 18 Nov 92 18:11:10 GMT

Want to see a very painful death against Corona? watch this :-)
More like suicide, really, but there's not much I can do about it.

;redcode-x
;name Sonic Boom 1.30
;author Eric J. Schwertfeger
;strategy Two SPL bombing carpet bombers going opposite
;strategy Directions, with a monitor that relaunches carpet
;strategy bombers whenever both die.
;strategy v 1.3X Going back to original bombing pattern, hence return
;strategy to 1.XX numbers.
WAIT EQU (568)
FSTEP EQU (16*12)
RSTEP EQU (-16*12)
RCSRC DAT 0,RBDST+(RSTEP)+1
RSTART MOV RCSRC,<(RBDST-RSTEP)
MOV RBDST-RSTEP,<(RBDST-RSTEP)
MOV RBDST-RSTEP,<(RBDST-RSTEP)
MOV RBDST-RSTEP,<(RBDST-RSTEP)
MOV RBDST-RSTEP,<(RBDST-RSTEP)
MOV RBDST-RSTEP,<(RBDST-RSTEP)
MOV RBDST-RSTEP,<(RBDST-RSTEP)
MOV RBDST-RSTEP,<(RBDST-RSTEP)
MOV RCSRC,<(RBDST-RSTEP) ; this pass
MOV RCSRC,<(RBDST-RSTEP)
MOV RCSRC,<(RBDST-RSTEP)
MOV RCSRC,<(RBDST-RSTEP)
RMOVE MOV <(RCSRC-RSTEP),<(RCDST-RSTEP)
RCDST JMP RSTART+RSTEP,RBDST+(RSTEP*2)+1
RBDST SPL 0,#RSTART-240
SHOOT SPL FLAUNCH
SPL RLAUNCH
MOV #(WAIT/3),DELAY
WATCH JMN DIE,RSTART-150
JMN DIE,FBDST+150
DELAY DJN WATCH,#DELAY
JMP SHOOT
FLAUNCH MOV #FCDST+2+FSTEP-FCSRC,FCSRC-FSTEP
MOV #2+(FSTEP*2),FCDST-FSTEP
MOV #FCDST+2+FSTEP-FCSRC,FCSRC
MOV #2+(FSTEP*2),FCDST
MOV #241,FBDST
SPL 1
SPL 1
SPL 1
SPL 1
JMP FMOVE
DIE DAT 0,0
LAUNCH SPL DLAUNCH
DJN 0,#(32*2+4)
MOV DIE,DSTART+(32*DSKIP)
JMP SHOOT
DSKIP EQU (247)
DLAUNCH MOV DSRC,DSRC-DSKIP
MOV DDEST,DDEST-DSKIP
SPL 1
MOV -1,0
JMP DSTART
DSRC DAT DDEST+1+DSKIP
DSTART MOV <DSRC-DSKIP,<DDEST-DSKIP
DDEST JMP DSTART+DSKIP,#1+(DSKIP*2)
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
DAT 0,0
RLAUNCH MOV #RCDST+2+RSTEP-RCSRC,RCSRC-RSTEP
MOV #2+(RSTEP*2),RCDST-RSTEP
MOV #RCDST+2+RSTEP-RCSRC,RCSRC
MOV #2+(RSTEP*2),RCDST
MOV #-254,RBDST
SPL 1
SPL 1
SPL 1
SPL 1
JMP RMOVE
FCSRC DAT 0,FBDST+(FSTEP)+1
FSTART MOV FCSRC,>(FBDST-FSTEP)
MOV FBDST-FSTEP,>(FBDST-FSTEP)
MOV FBDST-FSTEP,>(FBDST-FSTEP)
MOV FBDST-FSTEP,>(FBDST-FSTEP)
MOV FBDST-FSTEP,>(FBDST-FSTEP)
MOV FBDST-FSTEP,>(FBDST-FSTEP)
MOV FBDST-FSTEP,>(FBDST-FSTEP)
MOV FBDST-FSTEP,>(FBDST-FSTEP)
MOV FCSRC,>(FBDST-FSTEP)
MOV FCSRC,>(FBDST-FSTEP)
MOV FCSRC,>(FBDST-FSTEP)
MOV FCSRC,>(FBDST-FSTEP)
FMOVE MOV <(FCSRC-FSTEP),<(FCDST-FSTEP)
FCDST JMP FSTART+FSTEP,FBDST+(FSTEP*2)+1
FBDST SPL 0,#241
END LAUNCH

--
Eric J. Schwertfeger, maniac@cs.unlv.edu

Article 1495 of rec.games.corewar:

From: @prism.cs.orst.edu
Newsgroups: rec.games.corewar
Subject: Copycat and more
Message-ID: <1efceeINN85l@flop.ENGR.ORST.EDU>
Date: 19 Nov 92 06:32:46 GMT
Article-I.D.: flop.1efceeINN85l
Organization: CS Dept, Oregon State University
Lines: 125
NNTP-Posting-Host: prism.cs.orst.edu

I couldn't believe if there is any of us who would rather grab somebody else's
code, rename it without make any reasonable changes, submit it to KotH and
perceive it as his own thereafter. Even though we modify one or two lines,
we still could justify how much contribution we made on the success of
program. I think it is a very nice thing for people to have ways to accredit
the author of program they borrowed.

This copycatting is normal as far as we keep respecting the ethics we all know.
To come to the pure and original concepts is a very rare situation. Even though
it is pure, it also has to be success. We wouldn't have programs such as
Charon, Crimp, No Mucking About and others if the original concept (CMP scanner)
is limited to one. And similarly for other concepts such as B-scanner, paper,
slaver, bomber, IMPs, anti-IMPs etc

Now, imagine a situation when somebody submitted his program into KotH. And
somehow, his program inspired two other people who never know each other.
Both developed the same techniques and submitted the almost similar programs.
Both were success. Then who claimed the original ideas?

This might be the exact situation of the current debate about Impressive and
Imprimis.

And another one: a 'gate'. I called this 'IMPs gate' in my first posting since
there was no other term of using this kind of technique. And then P.Kline
started referring this to my name and made it public without asking me any
permission. Not long after, I think it was Campbell Fraser, described that he
also implemented the very same technique in his No More Mucking About. We never
talked each other. But, Beholder's Eyes (Modified B-scanners live in vain)
and No More Mucking About were the two scanners which occupied the very
high positions at the time after Anders published his IMPire. There was
no Campbell's posting (At least my local system doesn't receive it) and my
posting was distributed locally (My apologize to those who didn't receive it).
We both came to the same idea of using pre-decrement DAT to protect scanner
from IMPs independently. I stated this as non-unique (but original) technique
to avoid this kind of copycatting problem.

Below are three source codes. Two of them are repost of my previous ones to
those who haven't received it.

-----------------------------------------------------------------------------
;redcode
;name Beholder's Eye v1.1
;author W. Mintardjo
;strategy Modified B-Scanners Live in Vain (Matt Hastings) with IMPs immunity
;kill Beholder's Eye v1.1

step EQU 2234

init EQU -2

main ADD #step, 3

 JMZ -1, @2
MOV jump, @1
MOV snow, <init
JMN -4, -4
snow SPL 0, <0
MOV 2, <-6
jump JMP -1, 0
DAT <-92 ,<-2

END main

----------------------------------------------------------------------------
;redcode
;name Winter Werewolf
;author W. Mintardjo
;strategy SPL/JMP bomber with 2 pass core-clear (SPL/DAT) + self-defense
;strategy against IMPs

step EQU 153

init EQU 152
n EQU (12*8)-2

DAT <-4-n, #0
m MOV -1, 0-n
JMP 2
snow SPL 0, <-3-step-n
main MOV hold, @3
MOV snow, <2
ADD #step, 1
JMP main, init ; Hit here
MOV @-4, <n
hold JMP -1, 1

END m

----------------------------------------------------------------------------

;redcode
;name Medusa's v2
;author W. Mintardjo
;strategy Old CMP scanner with anti-IMPs
;strategy Submitted: @date@

CDIST equ 12
IVAL equ 28
FIRST equ scan-OFFSET+IVAL
OFFSET equ 5324

scan sub data,comp

comp cmp FIRST-CDIST,FIRST
slt #data-comp+CDIST+1,comp
djn scan,<FIRST+163
mov #CDIST,count
split mov bomb,<comp
count djn split,#0
add #CDIST,comp
jmz scan,scan-1
bomb spl 0, <0-IVAL+1
incr mov data, <bomb-1
 jmp incr, <0-IVAL-1
data DAT <0-IVAL, <0-IVAL

end comp

Note about this program: The original version of this is due to Stefan Strack's
Agony 2.4b. Ok, so old cmp-scanner was Agony 2.4b. And I decided to redesign
this program to create a more sophisticate cmp-scanner with spl carpet bombing
+ imp defense.
As it can be inspected, the only things unchanged from Agony 2.4b are:
its constants, variable names, and the way it scan which is implemented in most
of cmp-scanner: ADD, CMP, SLT and DJN. I have acknowledged Stefan Strack about
how I derive Medusa's.

--- W. Mintardjo

Article 1498 of rec.games.corewar:

From: te1349@newark.njit.edu (Leafweir)
Newsgroups: rec.games.corewar
Subject: Help
Message-ID: <1992Nov19.190144.21831@njitgw.njit.edu>
Date: 19 Nov 92 19:01:44 GMT
Sender: news@njit.edu
Organization: New Jersey Institute of Technology
Lines: 26
Nntp-Posting-Host: newark-gw.njit.edu

Hiyas,

I found this corewar yesterday playing with ftp. I had heard of it

before but had never seen it. It is rather interesting and I am trying
to learn more about redcode. So far I have tried combining imp and dwarf
I got a program good at surviving but not good at killing. I wanted it
to go forward as a normal imp but also split and throw dat bombs behind
me as I go forward. Please explain to me how to code this stuff. I have
no experience in assembly. What follows is the program that I sort of
put together.

;redcode
;name orc
;author Timothy Echeandia
;strategy Well I am rather new to corewar so I tried combining imp
;and dwarf. You get a more deadly imp an thereby the name orc. I am
;running corewars the X11 version and it survived against xtc. I think
;that this warrior more survives and ties than kills off. Right now
;killing off is giving me problems.

orc mov orc, orc+1

bomb dat #0, #0
bomber add #-4, bomb
mov bomb, @bomb
jmp bomber
end orc

Article 1507 of rec.games.corewar:

Newsgroups: rec.games.corewar
From: pk6811s@acad.drake.edu
Subject: bombs, bombs, and more bombs
Message-ID: <1992Nov25.111019.1@acad.drake.edu>
Lines: 126
Sender: news@dunix.drake.edu (USENET News System)
Nntp-Posting-Host: acad.drake.edu
Organization: Drake University, Des Moines, Iowa, USA
Date: Wed, 25 Nov 1992 17:10:19 GMT

It is HARD to keep a bomber on the Hill. Last summer I

suggested we needed more bombers to reduce the number
of scanners on the Hill, and give replicators some relief.
(I have a marvelous 6-process, self-purging replicator that
gets murdered every time it's submitted). With the appearance
of imps, things have gone from bad to worse. All the old
bombers were wiped out. Well, so were all the old scanners.
But now the scanners are back, bigger and tougher than ever,
so it's time for some bigger and tougher bombers too.

Here's the code for ExtraExtra 2, and Emerald 2. Feel

free to use parts of them as component parts of your own fighters.

;redcode
;name Emerald 2
;kill Emerald
;author P.Kline
;strategy stone with djn stream
;strategy attempting a gate
;strategy new anti-pittrap code
spacing equ 2365
hide1 spl 0,<-6
hide2 mov 49,<-20
hide3 sub @hide2,<hide2 ; hide2 + hide3 kill pit-trappers
hide4 dat <-7,#0 ; hide4 + hide1 will eventually make an imp-gate
hide dat #inc-17+1594+351
start mov hide4,inc-17+1643+350
mov hide3,@hide ; put outrigger in a hole in the bombing pattern
mov hide2,<hide
mov hide1,<hide
mov inc+0,inc+1020
hideb mov inc+1,inc+1020+1 ; move stone away from decoy
mov inc+2,inc+1020+2
mov inc+3,inc+1020+3
mov inc+4,inc+1020+4
spl @hideb
spl @hideb
spl @hide
mov #0,-7 ; erase pointers to stone
mov #0,-7 ; (needs work, I know)
mov #0,-7
mov #0,-7
mov #0,-7
inc dat #0-spacing,#spacing
emerald spl 0
stone mov <cnt-spacing-2,cnt+spacing
add inc,stone
cnt djn stone,<inc-129
end start
;redcode
;name ExtraExtra 2
;kill ExtraExtra
;author P.Kline
;strategy improved stone (2667/2045)
;strategy with anti-imps and anti-pittrap code
copyf1 dat #cnt+1
copyt1 dat #inc+1000
copyt2 dat #inc+1000+3039 ; this is a reflection (still working on it, Matt)
hide1 spl 0,<-6
hide2 mov 403,<-20
hide3 sub @hide2,<hide2 ; hide2 + hide3 kill pittrappers
hide4 jmp -2,1000 ; 1000 protects from the stone
hide5 dat <-7,#0 ; hide5 + hide1 will eventually make an imp-gate
hide dat #inc+3354
start mov hide5,inc+3755 ; put outrigger in a hole in the bombing pattern
mov hide4,@hide
mov hide3,<hide
mov hide2,<hide
mov hide1,<hide
mov <copyf1,<copyt1 ; move stone away from decoy
mov @copyf1,<copyt2 ; to present as small a scan-target as possible
mov <copyf1,<copyt1
mov @copyf1,<copyt2
mov <copyf1,<copyt1
mov @copyf1,<copyt2
mov <copyf1,<copyt1
mov @copyf1,<copyt2
spl @copyt1
mov <copyf1,<copyt1
mov @copyf1,<copyt2
jmp @hide
inc dat #2667,#2045 ; 2667 chases down imp-rings
dwarf mov <100,<cnt+2045
extra spl dwarf,<-100 ; this structure grows cycles very fast
add inc,dwarf ; so even if outrigger is spl-jmp bombed
cnt djn extra,<extra-100; it has small affect (for a while)
dat #(0-cnt)*128
dat #(0-cnt)*128
. . . more of the above to make 100-line decoy
------------------------------------------------------------------------

FYI, here are the (11/24/92) results for ExtraExtra 2 (w/l/t):

RED RAIN 83 / 3 / 14
Sucker 5 66 / 25 / 9
a-test 64 / 29 / 7
jj 64 / 31 / 5
Medusa's v2 58 / 34 / 8
Agony Anti-Imp 58 / 21 / 21
Sauron 57 / 23 / 20
Emerald 2 46 / 31 / 23
Leprechaun 1b 44 / 40 / 16
Griffin 2 41 / 51 / 8
Alt2 40 / 54 / 6
Wrack 33 / 30 / 37
Impression v4 21 / 33 / 46
+0 Stormbringer 20 / 37 / 43
Pale Shears4 25 / 53 / 22
IT 9 / 39 / 52
Imprimis 3 7 / 46 / 47
Paratroops v1.1 11 / 74 / 15
scan8 5 / 74 / 21
Gamma Paper 2.0 14 / 83 / 3

and of course, like a good bomber, it scored almost 50% wins

against itself - free points. The range of results indicates
considerable variety in programs out there.

I wish there was a way to query the Hill for the latest win/loss
table for the current fighters . . .wms? Since no one is publishing
source, ANY information would be helpful.

Paul Kline
pk6811s@acad.drake.edu

Article 1508 of rec.games.corewar:

From: gt7804b@prism.gatech.EDU (Wayne Edward Sheppard)
Newsgroups: rec.games.corewar
Subject: Some Redcode
Message-ID: <76303@hydra.gatech.EDU>
Date: 26 Nov 92 05:52:19 GMT
Organization: Georgia Institute of Technology
Lines: 134

I would like to share some of my code. PLASMA4a is my

first program to reach #1 on the hill. Too bad it didn't stay
up there very long. It can't survive with all of the imps and
scanners out there. I'm sure someone could come up with an
improvement.

Heres an idea of how it works: The main loop scans until

it finds something non-zero( also ignoring -1 ). Then it
bombs up from that location, while a replicator kicks in.

The second program is where I got the inspiration for

PLASMA. Send it in to the Hill and look at the scores.
It does amazingly well against other scanners and bombers.
(65-35-0 on average) But against reps and imps, it loses
99 times out of a hundred.

Maybe some other people could post some code also.

;redcode verbose
;name PLASMA 4a
;author Wayne Sheppard

bomb equ start-1

start add #3039,loc ;mod 1
loc jmz start,-1
cmp #-1,@loc ;don't look at DJN trails
slt #100,loc ;program length
jmp start
spl rep

spl 0
 mov bomb,<loc
jmp -1,<loc

rep spl rep2 ;Replicator from FlashPaper

spl 1 ; by Matt Hastings
spl 1
spl paper4
spl paper3
spl paper2
mov #8,8
paper1 mov <-1,<2
mov <-2,<1
spl @0,-2340
mov <-1,<1020
jmz -5,-5
mov 0,-1
dat #0,#1
dat #0,#1
mov #8,8
paper2 mov <-1,<2
mov <-2,<1
spl @0,5823
mov <-1,<-740
jmz -5,-5
mov 0,-1
dat #0,#1
dat #0,#1
mov #8,8
paper3 mov <-1,<2
mov <-2,<1
spl @0,1000
mov <-1,<-3690
jmz -5,-5
mov 0,-1
dat #0,#1
dat #0,#1
mov #8,8
paper4 mov <-1,<2
mov <-2,<1
spl @0,6109
mov <-1,<1873
jmz -5,-5
mov 0,-1
dat #0,#1
dat #0,#1
mov #8,8
rep2 spl 1
spl 1
spl paper8
spl paper7
spl paper6
paper5 mov <-1,<2
mov <-2,<1
spl @0,3009
mov <-1,<-200
jmz -5,-5
mov 0,-1
dat #0,#1
dat #0,#1
 mov #8,8
paper6 mov <-1,<2
mov <-2,<1
spl @0,4832
mov <-1,<-1830
jmz -5,-5
mov 0,-1
dat #0,#1
dat #0,#1
mov #8,8
paper7 mov <-1,<2
mov <-2,<1
spl @0,1080
mov <-1,<4096
jmz -5,-5
mov 0,-1
dat #0,#1
dat #0,#1
mov #8,8
paper8 mov <-1,<2
mov <-2,<1
spl @0,-3040
mov <-1,<-195
jmz -5,-5
mov 0,-1
dat #0,#1
dat #0,#1

;redcode verbose
;name RED RAIN
;author Wayne Sheppard
;strategy Bscanner
;kill RED RAIN
add #3044,1
jmz -1,-2
mov -3,@-1
jmp -3

--
Wayne Edward Sheppard
Georgia Institute of Technology, Atlanta Georgia, 30332
uucp: ...!{decvax,hplabs,ncar,purdue,rutgers}!gatech!prism!gt7804b
Internet: gt7804b@prism.gatech.edu

Article 1510 of rec.games.corewar:

Newsgroups: rec.games.corewar
From: d91andiv@IDA.LiU.SE (Anders Ivner)
Subject: My programs
Message-ID: <D91ANDIV.92Nov26170506@styr9.IDA.LiU.SE>
Sender: news@ida.liu.se
Organization: CIS Dept, University of Linkoping, Sweden
Distribution: rec
Date: Thu, 26 Nov 1992 16:05:11 GMT
Lines: 175

Here's the code for my programs Griffin 2 and Leprechaun 1b.

Griffin is just a highly optimized cmp-scanner, but Leprechaun
uses a rather interesting technique to bomb and scan at the same
time.

BTW: Does anyone know how to contact Jon Newman? His system seems to be down...

/Anders Ivner

;redcode
;name Griffin 2
;author Anders Ivner
;strategy small spl/jmp bombing cmp-scanner

boot mov <spt, <dpt

mov <spt, <dpt
mov <spt, <dpt
mov <spt, <dpt
mov <spt, <dpt
mov <spt, <dpt
mov <spt, <dpt
mov <spt, <dpt
mov <spt, <dpt
mov flip, 3000+flip-13
mov gate, const+3000-132
spt jmp eyes+3000, const+1
dpt dat #const+3000+1

gate dat <-21, #0

flip jmp @4000, 3999

attack mov flip-13, @eyes

dp mov bomb, <eyes
sub flip-13, @dp

eyes cmp bomb-132, bomb-132+4000

jmn attack, @dp
add const, @dp
djn eyes, #997

bomb spl 0, <-20

const mov -132, <-132

end boot

;redcode
;name Leprechaun 1b
;author Anders Ivner
;strategy Combined Bomber/B-scanner, giving a total speed of 67% of c

offset equ 5016

boot mov <spt, <dpt

mov <spt, <dpt
mov <spt, <dpt
mov <spt, <dpt
mov <spt, <dpt
mov <spt, <dpt
mov <spt, <dpt
mov <spt, <dpt
 mov <spt, <dpt
mov <spt, <dpt
mov bomb2+1, bomb+17+2500
spt jmp start+2500, bomb2+1
dpt dat #bomb2+2501

loop add #offset, eye

start mov bomb, @eye
eye jmz loop, @offset+test+20
test mov eye, eye-20
mov bomb2, @eye-20
mov bomb, <eye-20
pt jmn loop, test
bomb spl 0, <-20
mov 16, <pt
bomb2 jmp -1, 0

dat <-21, #0

dat #1
dat #1
dat #1
dat #0
dat #1
dat #1
dat #1
dat #0

dat #1
dat #1
dat #1
dat #0
dat #1
dat #1
dat #1
dat #0

dat #1
dat #1
dat #1
dat #0
dat #1
dat #1
dat #1
dat #0

dat #1
dat #1
dat #1
dat #0
dat #1
dat #1
dat #1
dat #0

dat #1
dat #1
dat #1
dat #0
 dat #1
dat #1
dat #1
dat #0

dat #1
dat #1
dat #1
dat #0
dat #1
dat #1
dat #1
dat #0

dat #1
dat #1
dat #1
dat #0
dat #1
dat #1
dat #1
dat #0

dat #1
dat #1
dat #1
dat #0
dat #1
dat #1
dat #1
dat #0

dat #1
dat #1
dat #1
dat #0
dat #1
dat #1
dat #1
dat #0

dat #1
dat #1
dat #1
dat #0

end boot

Article 1527 of rec.games.corewar:

From: sah@castle.ed.ac.uk (Juggler)
Newsgroups: rec.games.corewar
Subject: Artagel (code)
Keywords: redcode
Message-ID: <29471@castle.ed.ac.uk>
Date: 11 Dec 92 18:12:45 GMT
Distribution: rec
Organization: Black Star
Lines: 110
In answer to Wayne's imp killing question, here is the code for
Artagel v3, along with some pertinent scores for it. Artagel uses one
of the "magic numbers", 3359, and consequently bombs very effectively
despite its relatively slow speed. The 3059th bomb hits the mov
statement, creating a gate. By this time, the largest distance between
two consecutive bombs is 2. Artagel is useless against paper or fast
bombers. The Crusher, which is currently maintaining a tenuous grip
towards the bottom end of the hill, also uses 3359 as an offset, and a
mod 3359 cmp-scanner is in the offing. What can I say? Untold gratitude
to the person who originally posted the magic numbers!

Cheers,
Si.

;redcode
;name Artagel v3
;author Simon Hovell
;strategy: bomber with gate

Artagel:spl 0, <-20
mov 3,1-3359
add #-3359,-1
jmp -2,<-23
dat <-21,<1 ;1 inserted to slow down djn start,<loc bombers
end Artagel ;a bit

Program "Imprimis 3" (length 100) by "P.Kline"

;strategy modified stone + two 3-point spirals (ala Dan Nabutovsky's
Impression)
;strategy beats single, 3-point spirals 10-20%
;strategy frustrates pittrappers by springing their traps with dat's
;strategy frustrates me by not scoring better
Artagel v3 wins: 39
Imprimis 3 wins: 38
Ties: 23

Program "Gamma Paper 2.0" (length 96) by "W. Mintardjo"

;strategy Stone/Paper, designed to beat some bombers and to tie others
;strategy Version history
;strategy 1.0: Stone/Paper
;strategy 1.2: Better Paper structure
;strategy 1.3: Constant modified
;strategy 2.0: Bomb-train protection
Artagel v3 wins: 22
Gamma Paper 2.0 wins: 78
Ties: 0

Program "It" (length 39) by "nandor sieben"

Artagel v3 wins: 25
It wins: 57
Ties: 18

Program "Sucker 5" (length 100) by "Stefan Strack"

;strategy Self-splitting, pattern-bombing vampire
;strategy 2: with confusion
;strategy 3: much denser, mod-2 bomb-pattern; no spacer
;strategy 3.1: avoids prematurely dropping into clear-mode
;strategy 4: spacer/bootstrap; changed bomb increment; tracer-proof
;strategy 5: imp-defense
;strategy Submitted: Sun Nov 15 19:31:09 CST 1992
Artagel v3 wins: 18
Sucker 5 wins: 45
Ties: 37

Program "Griffin 2" (length 24) by "Anders Ivner"

;strategy small spl/jmp bombing cmp-scanner
Artagel v3 wins: 55
Griffin 2 wins: 40
Ties: 5

Program "Medusa's v2" (length 13) by "Mintardjo & Strack"

;strategy Medusa's is based on Agony 2.4b which is a cmp-scanner with
;strategy SPL carpet bombing.
;strategy Version history:
;strategy Agony 2.4b: The origin of this program
;strategy v1 : Agony 2.4b with Anti-imp
;strategy v1.1 : Better Anti-imp code
;strategy v2 : Bombing structure redesigned
;strategy - Shorter line, shorter bombing and more accuracy
;strategy Submitted : Thu Nov 19 09:07:24 PST 1992
Artagel v3 wins: 70
Medusa's v2 wins: 19
Ties: 11

Program "a-test" (length 14) by "nandor sieben"

Artagel v3 wins: 55
a-test wins: 39
Ties: 6

Program "Impression v4" (length 77) by "Dan Nabutovsky"

;strategy 2 imp spirals + self-splitting dwarf
Artagel v3 wins: 21
Impression v4 wins: 58
Ties: 21

Program "Paratroops v1.1" (length 18) by "W. Mintardjo"

Artagel v3 wins: 12
Paratroops v1.1 wins: 57
Ties: 31

Program "Figment" (length 39) by "c w blue"

Artagel v3 wins: 0
Figment wins: 95
Ties: 5
--
S.A.Hovell,Dept. Electrical Engineering,University of Edinburgh,U.K.
(+31) 650-5655 (Juggler@ed.ac.uk)
----- -----

Article 1568 of rec.games.corewar:

Newsgroups: rec.games.corewar
From: pk6811s@acad.drake.edu
Subject: Imprimis 4
Message-ID: <1993Jan10.175843.1@acad.drake.edu>
Lines: 189
Sender: news@dunix.drake.edu (USENET News System)
Nntp-Posting-Host: acad.drake.edu
Organization: Drake University, Des Moines, Iowa, USA
Date: Sun, 10 Jan 1993 23:58:43 GMT

W. Mintardjo asked me whether Imprimis 3 didn't have a core clear, since it

did not kill his 'Empty' do-nothing program. Indeed, Imprimis 3 did not
have a real core clear. I started thinking about it and decided it would
be worth a few tests. Result - Imprimis 4. Not quite up to Sphinx stature,
but definitely an inprovement. Basically it is a mod-4 stone which gets
most of the early cycles, but kills itself after the mod-4 pattern is
complete. There is also an anti-vampire tracer which is converted to
a core-clear by the stone (before it dies). The core clear finishes just
before it is overrun by the imps, and just before 80,000 cycles elapse.

I do not think the resulting imp-gate does much good, looks like gating
your own imps is harder than gating your opponent's imps - since you
have to interleave the processes - imp/gate/imp/gate/imp/gate...
Maybe someone could suggest a launcing sequence that would do that?

Also, it is clear in my tests that the long startup is a problem,

and Imprimis 4 sometimes gets stunned/vamped before it gets out of
the starting block.

;redcode
;name Imprimis 4
;kill Imprimis
;author P.Kline
;strategy stone like ExtraExtra
;strategy two 3-point spirals like Impression
;strategy anti-vampire code
;strategy core clear -> imp-gate
;strategy sorry - sink wouldn't fit
d equ 2667

stone mov <5630,stone+3044+1

extra spl -1,<inc-129-1100 ; stone soaks up cycles early
add inc,stone ; but kills itself after mod-4 is complete
cnt djn extra,<inc-129-1100
inc dat #2667,#3044
copyf1 dat #0
copyt1 dat #copyf1+1025

hide1 spl 0,<-7 ;

hide2 mov 26,<7887 ; traces vampire snares back to vampire
hide3 sub @hide2,<hide2 ; hide3 will be killed by stone after a while
copyf2 dat #0 ; to make hidex a core clear
copyt2 dat #extra+1254
hide4 dat <-8,#0 ; hide1 + hide4 make an imp-gate very late
copyf3 dat #0
copyt3 dat #extra+1254+25

start mov imp,imp+1000+97+132 ; put imps out there

mov imp,imp+2333+97+132
mov <copyf1,<copyt1 ; put stone out there
mov <copyf1,<copyt1
mov <copyf1,<copyt1
mov <copyf1,<copyt1
 mov <copyf1,<copyt1
add #1,copyt1
mov <copyf2,<copyt2 ; put hidex out there
mov <copyf2,<copyt2
mov <copyf2,<copyt2
mov <copyf3,<copyt3
mov <4000,copyt3
spl stst
spl sttr
spl 1 ; double #processes in the spirals
spl 16 ; binary-launch imp spirals
spl 8 ; each spiral is six instructions wrapped
spl 4 ; around three points, with two
spl 2 ; processes at each instruction
jmp imp+(d*0)+1000+97+132
jmp imp+(d*1)+1000+97+132
spl 2
jmp imp+(d*2)+1000+97+132
jmp imp+(d*3)+1000+97+132
spl 4
spl 2
jmp imp+(d*4)+1000+97+132
jmp imp+(d*5)+1000+97+132
spl 2
jmp imp+(d*0)+2333+97+132
jmp imp+(d*1)+2333+97+132

spl 8
spl 4
spl 2
jmp imp+(d*2)+2333+97+132
jmp imp+(d*3)+2333+97+132
spl 2
jmp imp+(d*4)+2333+97+132
jmp imp+(d*5)+2333+97+132
stst spl 1 ; give the stone some cycles
spl 1
spl 1
spl 1
jmp @copyt1

sttr spl @copyt2 ; give hidex some cycles

spl @copyt2 ; (must be an even number of these)
spl @copyt2
spl @copyt2
spl @copyt2
spl @copyt2
spl @copyt2
spl @copyt2
mov <2000,copyt1 ; don't leave pointers to stone,etc.
mov <3000,copyt2
dat #0
dat #0
imp mov 0,2667
dat #(0-imp)*256 ; this stuff is just decoy
dat #(0-imp)*256
dat #(0-imp)*256
dat #(0-imp)*256
dat #(0-imp)*256
 dat #(0-imp)*256
dat #(0-imp)*256
dat #(0-imp)*256
dat #(0-imp)*256
dat #(0-imp)*256
dat #(0-imp)*256
dat #(0-imp)*256
dat #(0-imp)*256
dat #(0-imp)*256
dat #(0-imp)*256
dat #(0-imp)*256
dat #(0-imp)*256
dat #(0-imp)*256
dat #(0-imp)*256
dat #(0-imp)*256
dat #(0-imp)*256
end start

And here are the results:

Imprimis 4 wins: 14
Sphinx v2.6 wins: 12
Ties: 74
Imprimis 4 wins: 6
It wins: 0
Ties: 94
Imprimis 4 wins: 7
Night wins: 0
Ties: 93
Imprimis 4 wins: 15
Gamma Paper 3.0 wins: 16
Ties: 69
Imprimis 4 wins: 7
+0 Stormbringer wins: 2
Ties: 91
Imprimis 4 wins: 86 <- anti-vamp
Sucker 5 wins: 6
Ties: 8
Imprimis 4 wins: 39
Charon v8.0 wins: 53
Ties: 8
Imprimis 4 wins: 76 <- anti-vamp
Twilight Pits 6 wins: 13
Ties: 11
Imprimis 4 wins: 41
Medusa's v5 wins: 52
Ties: 7
Imprimis 4 wins: 32
a-test wins: 60
Ties: 8
Imprimis 4 wins: 36
Alt2 wins: 47
Ties: 17
Imprimis 4 wins: 87
Emerald 3 wins: 3
Ties: 10
Imprimis 4 wins: 35
Agony Anti-Imp wins: 50
Ties: 15
Imprimis 4 wins: 40
Pale Shears4 wins: 45
Ties: 15
Imprimis 4 wins: 39
Leprechaun 1b wins: 36
Ties: 25
Imprimis 4 wins: 20
test2 wins: 8
Ties: 72
Imprimis 4 wins: 52
Griffin 2 wins: 38
Ties: 10
Imprimis 4 wins: 86 <- anti-vamp
Grimm's Vampyre wins: 12
Ties: 2

Paul Kline
pk6811s@acad.drake.edu

Article 1575 of rec.games.corewar:

From: gt7804b@prism.gatech.EDU (Wayne Edward Sheppard)
Newsgroups: rec.games.corewar
Subject: RedRain-ReDrain
Message-ID: <80395@hydra.gatech.EDU>
Date: 16 Jan 93 16:40:22 GMT
Organization: Georgia Institute of Technology
Lines: 19

;redcode quiet
;name RedRain
;author Wayne Sheppard
add #3039,1
jmz -1,-1
mov 2,@-1
jmp -3

Here is the program that tank beats 99 times. Alot of other programs
beat it 99-100 times. But it beats all of the scanners about 60-70%
I modified the constant so that it scans 3/4 of the core before it
kills itself. This allows it to kill a couple more programs by
giving up some ties.

--
Wayne Edward Sheppard
Georgia Institute of Technology, Atlanta Georgia, 30332
uucp: ...!{decvax,hplabs,ncar,purdue,rutgers}!gatech!prism!gt7804b
Internet: gt7804b@prism.gatech.edu

Article 1576 of rec.games.corewar:

From: gt7804b@prism.gatech.EDU (Wayne Edward Sheppard)
Newsgroups: rec.games.corewar
Subject: A cmp scanner
Message-ID: <80598@hydra.gatech.EDU>
Date: 18 Jan 93 22:29:07 GMT
Organization: Georgia Institute of Technology
Lines: 32
Here is a basic cmp scanner that attempts to defeat imps.
I've been looking for a way to shorten it by one line, but no
such luck.

;redcode quiet
;name Iron Gate
;author Wayne Sheppard
;strategy cmp scanner-SPL/JMP-Gate
;kill Iron Gate

;dist=76 for Sixth Sense

dist equ 98
scan equ dist*2

add off,@x
loc cmp dist-1,-1
slt #14,@x
djn -3,<7000
mov j,@loc
x mov s,<loc
sub new,@x
jmn loc,loc-1
s spl 0,<1-dist
mov 2,<-2
j jmp -1
new dat <0-dist,<0-dist-1
off dat #scan,#scan
--
Wayne Edward Sheppard
Georgia Institute of Technology, Atlanta Georgia, 30332
uucp: ...!{decvax,hplabs,ncar,purdue,rutgers}!gatech!prism!gt7804b
Internet: gt7804b@prism.gatech.edu