From news-rocq!univ-lyon1.fr!oleane.net!oleane!news.maxwell.syr.edu!newsfeed.skycache.com!Cidera!portc01.blue.aol.com!audrey04.news.aol.com!not-for-mail Fri Apr 27 13:54:37 2001
Article: 12581 of rec.games.corewar
Path: news-rocq!univ-lyon1.fr!oleane.net!oleane!news.maxwell.syr.edu!newsfeed.skycache.com!Cidera!portc01.blue.aol.com!audrey04.news.aol.com!not-for-mail
Lines: 185
X-Admin: news@aol.com
From: ianoversby@aol.com (IanOversby)
Newsgroups: rec.games.corewar
Date: 26 Apr 2001 20:12:03 GMT
Organization: AOL, http://www.aol.co.uk
Subject: Vain
Message-ID: <20010426161203.09498.00001092@ng-mk1.aol.com>
Xref: news-rocq rec.games.corewar:12581

The idea for Vain was simply to implement an imp-gate in Gigolo which
had been a very successful imp/stone.  Watching the stone systematically
obliterate each square twice while cleverly avoiding itself it seemed
to be quite a difficult problem to slot a gate in.

Gigolo-style (Rosebud) stone:

clr     spl     #0,     <split+step
split	spl	#-step,	<step
stone	mov	>-step,	step+1
	add	split,  stone
	cnt     djn.f	stone,	<split+step
stptr   dat     0,0
	dat     0,0
cc      dat     0,      #stone-4


I thought if I could start the stone half way through its cycle, it would
leave enough gaps to hide a gate in.  The first incarnations of this
idea were very weak.  Removing reduced the length of the bombing and
modifying the start point of the stone gave some gaps to hide my gate
which was of the form jmp #0, <gate.

Unfortunately, to make the gate effective, I had to load it up with very
many processes as otherwise the imp spiral had the most processes and
enemy imps could jump the gate.  Loading the gate with processes was
more effective but this left two more problems.  Firstly, loading the
gate made the stone weaker and secondly often the stone missed the enemy
spl instruction.

I decided to put a d-clear in to solve the problem of missing the spl.
Unfortunately, if I had difficulty making space for a single jmp
instruction, making space for the 3 instructions of a d-clear was a
much greater problem.

I decided to up the step-size to mod-8 and try and hit 5 in every
8 squares.  This meant that if the clear was disabled, I should have
a 5 in 8 chances of taking out an enemy if it was a self-splitting
stone.  I chose a step-size that was high enough to give myself some
choice of position to put the clear so that it was between the
djn-stream and the stone.

I was quite surprised when I submitted it to the hill.  An earlier
test submission of Gigolo went in at 23rd so I wasn't expecting
great things.  Vain went in at 2nd place and beat up my beloved
Newt.  They both survived until the clearing of hill.

All credit to Beppe Bezzi for the Rosebud stone which Gigolo was based
on, Steven Morrell for Rosebud's ancestor - Blue Funk and Bjoern
Guenzel for the ubiqitous d-clear.

This code is a little different to the one that was actually on the
hill with a more modern QScan and B-Imps.  The stone and clear are the
same though.  Son of Vain is a variation on a theme and scores very
nicely indeed :)

Regards,

Ian

;redcode-94nop
;name Vain
;author Ian Oversby
;strategy The Original Vain
;strategy Now with Q^(>2)
;strategy Rosebudish Stone, Impfinity Imps
;strategy and a core-clear
;assert CORESIZE==8000

sdist	equ	(start+3614)
dec	equ	6944
tr	equ	6565
idist	equ	(start+2214)

st	equ	1432
ddist	equ	sdist-1054-2
ist	equ	2667
mx	equ	-7

spin	spl.b	#pump+tr,	>-3000
	sub.f	#-(ist+1),	jump
pump	mov.i	imp,		}spin
jump	jmp.f	tr-2*(ist+1),	<dec
imp	mov.i	#-27,		ist

for 20
	dat.f	0,	0
rof


pGo	spl.b	@0,	spin
	spl.b	dboot,	<-850
for 5
	mov.i	{spos,	{sptr
rof
sptr	spl.b	sdist,	<-700
	div.f	#0,	sptr

	dat.f	0,	0

dboot	mov.i	<spos,	{mptr
	mov.i	<spos,	{mptr
	mov.i	<spos,	{mptr
	spl.b	*mptr,	<-1000
	mov.i	<spos,	@mptr
	mov.ab	#3700,	<mptr
mptr	div.f	#ddist,	#ddist+mx-2
	dat.f	}700,	>800

	spl.b	#0,	<p-st
p	spl.b	#st,	<-st
	mov.i	>0+st,	3-st
	add.f	p,	-1
	djn.f	-2,	<p-st

spos	dat.f	#0,	#dl+1

	dat.f	>1,	#10
	spl.b	#0,	#0
	mov.i	mx,	>mx-1
dl	djn.f	-1,	>mx-2

for 5
	dat.f	0,	0
rof

     qf equ qKil
     qs equ (qd*2)
     qd equ 107
     qi equ 7
     qr equ 11

;    -+)>] 0/1 cycles [(<+-

start
qGo: seq   qd+qf+qs,    qf+qs      ; 1
     jmp   qSki,        {qd+qf+qs+qi
     seq   qd+qf+6*qs,  qf+6*qs    ; B
     jmp   qFas,        {qd+qf+6*qs+qi
     seq   qd+qf+5*qs,  qf+5*qs    ; B-1
     jmp   qFas,        <qBmb
     seq   qd+qf+7*qs,  qf+7*qs    ; B+1
     jmp   qFas,        >qBmb
     seq   qd+qf+9*qs,  qf+9*qs    ; A-1
     djn   qFas,        {qFas
     seq   qd+qf+10*qs, qf+10*qs   ; A
     jmp   qFas,        {qFas

;    -+>)] 2 cycles [(<+-

     seq   qd+qf+3*qs,  qf+3*qs    ; C
     jmp   >qFas,       {qd+qf+3*qs+qi
     seq   qd+qf+2*qs,  qf+2*qs    ; C-1
     jmp   >qFas,       {qSlo
     seq   qd+qf+4*qs,  qf+4*qs    ; C+1
     jmp   >qFas,       }qSlo
     seq   qd+qf+12*qs, qf+12*qs   ; B*C-B
     jmp   qSlo,        {qSlo
     seq   qd+qf+15*qs, qf+15*qs   ; B*C-C
     jmp   qSlo,        <qBmb
     seq   qd+qf+21*qs, qf+21*qs   ; B*C+C
     jmp   qSlo,        >qBmb
     seq   qd+qf+24*qs, qf+24*qs   ; B*C+B
     jmp   qSlo,        }qSlo

     seq   qd+qf+27*qs, qf+27*qs   ; A*C-C
     djn   qSlo,        {qFas
     seq   qd+qf+30*qs, qf+30*qs   ; A*C
     jmp   qSlo,        {qFas

     sne   qd+qf+18*qs, qf+18*qs   ; B*C
     jmz.f pGo,         qd+qf+18*qs-10

qSlo:mul.ab #3,         qKil       ; C=3
qFas:mul.b qBmb,        @qSlo
qSki:sne   >3456,       @qKil
     add   #qd,         qKil
qLoo:mov   qBmb,        @qKil
qKil:mov   qBmb,        *qs
     sub   #qi,         qKil
     djn   qLoo,        #qr
     jmp   pGo,         >10        ; A=10
qBmb:dat   {qi*qr-10,   {6         ; B=6

end start