Article 3162 of rec.games.corewar:
Path: news.cs.utah.edu!cs.utexas.edu!howland.reston.ans.net!vixen.cso.uiuc.edu!newsrelay.iastate.edu!dunix.drake.edu!acad.drake.edu!pk6811s
From: pk6811s@acad.drake.edu
Newsgroups: rec.games.corewar
Subject: Bunker - self repair attempt
Date: 30 Aug 94 09:09:04 CST
Organization: Drake University, Des Moines, Iowa
Lines: 84
Message-ID: <1994Aug30.090904@acad.drake.edu>
NNTP-Posting-Host: acad.drake.edu

With all the new features in experimental-94 I thought be possible to write
a successful self-repair program.  I wrote the first Bunker using post-
increment and it stayed on the Big Hill for a while, but never was much
of a contender.  Now with a-field-indirect addressing Bunker is one
line shorter and takes one less instruction to repair, but is still
a wimp.

There are two basic problems here.  The first is that too much time is spent
monitoring code and too little crunching opponents.  This seems to be
an inherent weakness in self-repair programs.  If you don't monitor
code and are spl-bombed, you get slowed down so much you can't repair
yourself.

The second problem happens when both components are attacked at the same
time.  Or when one or both are under attack by slow-moving opponents,
such as slow-moving imps, or many-copied paper, such that one component
is nearly always in a bad state.  Eventually the other component is 
attacked and that's the end.

The basic idea with Bunker is to use parallel processes to monitor and
repair code - sort of the way paper uses parallel processes to replicate.
Bunker runs as two partners.  Each partner's code is monitored by summing
his b-operands - they should total zero.  If not he is dat-wiped, reloaded
and restarted.  It really works - even Agony's spl-carpets are overcome
a few times.  But it's not quite fast enough or small enough to prevent
both partners being crippled eventually.

I've stared at this long enough that I'm not coming up with any new ideas,
so here it is - maybe someone else can give Bunker the zing it needs.

;redcode-94
;name Bunker t3
;kill Bunker
;author P.Kline
;strategy self-repair pair
space    equ 4000
step     equ 13

copyf    dat    #fin
copyt    dat    #fin+space

start    mov <copyf,<copyt
	 mov <copyf,<copyt
	 mov <copyf,<copyt
	 mov <copyf,<copyt
	 mov <copyf,<copyt
	 mov <copyf,<copyt
	 mov <copyf,<copyt
	 mov <copyf,<copyt
	 mov <copyf,<copyt
	 mov <copyf,<copyt
	 mov <copyf,<copyt
	 
	 spl 1               ; create 11 processes
	 mov -1,0
	 spl 1
	 mov -1,0
	 spl chk
	 jmp chk+space

     for 20
	 dat 0,0
     rof

rset     sub.a  #0,#space                ; reset counter after fix

chk      sub.ba }fix,rset                ; sum partner's b-operands
	 jmn.a  kill,rset                ; they should total to zero
clr      mov    d3,>-20                  ; slow core-clear
loop     jmp    chk,{fix                 ; go again, reset pointer

kill     mov    d4,{fix                  ; zap partner's code
	 spl    rset,1000                ; reset self while partner dies
fix      mov    <rset+space,{rset+space  ; repair partner's code
offset   jmp    rset+space,#2964         ; restart partner
d3       dat    <2667,#50                ; core-clear bomb
d4       dat    #fin-rset,#fin-rset+space; repair pointers

fin      dat 0,0

	 end    start

Paul Kline
pk6811s@acad.drake.edu