Article 1395 of rec.games.corewar:
From: d91andiv@IDA.LiU.SE (Anders Ivner)
Newsgroups: rec.games.corewar
Subject: The IMProved imp.
Message-ID: <D91ANDIV.92Oct14184118@kol2.IDA.LiU.SE>
Date: 14 Oct 92 17:41:22 GMT
Sender: news@ida.liu.se
Distribution: rec
Organization: CIS Dept, University of Linkoping, Sweden
Lines: 87

As some of you have seen, my program "The IMPire strikes back" now
holds the first place on the KotH list in a firm grip. 170 pts gives
it an 18 pt margin to the 2nd place. (ok, so I needed to boast a bit :-)
And, yes it IS imp-based... I call it 'Cyclic imps'.
The following little example should give you an idea of what I mean:

;redcode
;name trident
;author Anders Ivner
;strategy Three imps are better than one :-)

start	mov	imp,		imp-2667
	spl	imp-2667
	spl	imp+2667
imp	mov	0,		2667
	end	start

(Note that 2667*3 = 8001)
The effect is a program that is only ONE instruction long, like the imp
AND it kills anything it runs into that has less than three processes.

Like this, however, it will only score something like 90-100 pts.
The secret is to put several layers of processes executing the same
instructions. Like this, the different "rings" support each other,
making it close to impossible to stop. It will recover completely
from any decrement hit, it may break loose from spl hits, and the
remaining rings will survive a dat hit undamaged.

The best setup I have found so far is using seven layers with nine
processes in each layer ( 9*889 also equals 8001 ):

;redcode
;name The IMPire strikes back
;author Anders Ivner
;strategy ...and 9*7 imps are even better...

start  spl   1
       spl   1
       spl   1
       spl   1
       spl   1
       mov   -1,  0

jpt    jmp   <jpt,   imp

       jmp   imp+889*8
       jmp   imp+889*7
       jmp   imp+889*6
       jmp   imp+889*5
       jmp   imp+889*4
       jmp   imp+889*3
       jmp   imp+889*2
       jmp   imp+889*1
       jmp   imp+889*0
       jmp   imp+889*8
       jmp   imp+889*7

;[ lots of similar lines deleted ]

       jmp   imp+889*6
       jmp   imp+889*5
       jmp   imp+889*4
       jmp   imp+889*3
       jmp   imp+889*2
       jmp   imp+889*1
       jmp   imp+889*0

imp    mov   0,   889

       end   start

With this many layers the number of losses is reduced to 10%.

Two weak spots can be noted:
-  There is a chance of being hit before the actual imp is started,
   which limits the nr of processes to use.
-  It can (in most cases) only tie replicators and self-splitting bombers,
   since they will pretty soon grow more than 63 processes.

Alright... Now *DON'T* flood the hill with warriors that are merely
permutations of this one! Like using eight layers with seven imps
in each layer, or three layers with 21 imps each.
However, feel free to use it in combination with other strategies.

Anders
(I hope this will encourage more discussions on different techniques
and strategies in this newsgroup...)