Article 690 of rec.games.corewar:
From: Scott_-_Nelson@cup.portal.com
Newsgroups: rec.games.corewar
Subject: warriors
Message-ID: <56723@cup.portal.com>
Date: Wed,  1 Apr 92 01:28:32 PST
Organization: The Portal System (TM)
Lines: 34

    Yet another warrior from my collection, Scissors 88.
Scissors 88 is the first slaver-type program I wrote which uses 
the 'double add' strategy (which only became possible under the '88 
standards)  Scissors 88 made it to the top of the hill, but was quickly 
pushed off.
----- cut -----
;redcode
;name scissors88
;author Scott Nelson
;strategy  capture the enemy and put him to work.
 
;
;main code loop
;
loop	add	s,	ptr	;double add makes ptr both jump and point
	mov	ptr,	@ptr	;move the jmp to the right place
	jmp	loop		;Tiny, isn't it?
ptr	jmp	pit
s	dat	#5084,	#-5084
;
;Slave pit
; 
wptr	dat	#loop
p	dat	#1
	jmp	pit
pit	mov	p,	<wptr	;enemy falls in here
	spl	pit		;SPL's to slow him down
	mov	p,	<wptr	;eventually this will kill itself
	jmp	pit		;Gee, the pit is bigger than the main code!
;
	end	loop
----- end cut -----
   It is worth examining the main code carefully, since the same basic
structure is used in scissors 2, and scissors 3.1


Article 691 of rec.games.corewar:
From: Scott_-_Nelson@cup.portal.com
Newsgroups: rec.games.corewar
Subject: warriors
Message-ID: <56724@cup.portal.com>
Date: Wed,  1 Apr 92 01:30:36 PST
Organization: The Portal System (TM)
Lines: 42

    Yet another warrior from my collection, Scissors 3.1
Scissors 3.0 is the first program I wrote which used the SLT instruction,
(which also only became possible under the '88 standards)
Scissors 3.1 made it to the top of the hill many times, and livce to a 
ripe old age of 91 before being bumped off.
----- cut -----
;redcode
;name scissors3.1
;author Scott Nelson
;strategy  capture the enemy and put him to work.
;strategy  only 5 code lines, scans every location.
;strategy 
;strategy  3.1 - fewer DAT statements
 
start	add	addval,	jp	;scan for non-zero B-field (double add)
	jmz	start,	@jp	;
 
	slt	#-16,	jp	;O.K. if it's me skip the next instruction
	mov	jp,	@jp	; not me! bombs away
	jmp	start		;go find another one.
 
;
; slave pit
;
pit	spl	1		;enemy comes in here
	spl	1
addval	mov	11,	<-11	;this is multi-purpose, it will
				;elimate other enemies, kill the pit
				;after clearing core, and I use it as
				;an ADD value in the main code.
	jmp	pit
;
jp	jmp	pit		;jp at end so SLT will work right
 
	end	start
----- end cut -----
Notes on scissors 3.1:
    The step size of 11 is one of the nicest features of this warrior,
because it eventually hits EVERY location in core.  This is also one of
the few warriors which functions as well in a weird coresize (i.e. 11307)
as it does in a standard one.  (Molerat is another.)
 


Article 692 of rec.games.corewar:
From: Scott_-_Nelson@cup.portal.com
Newsgroups: rec.games.corewar
Subject: warriors
Message-ID: <56722@cup.portal.com>
Date: Wed,  1 Apr 92 01:27:31 PST
Organization: The Portal System (TM)
References:  <92091.105224ASMQK@ASUACAD.BITNET>
Lines: 19

    O.K. here is another warrior from my collection, Rock.
Rock has been on the hill but has not made it to the top yet.
----- cut -----
;redcode
;author Scott Nelson
;name Rock
;strategy sort of Dwarf with bigger steps.
 
rock	add	s,	p
p	mov	<1,	2
	jmp	rock
	dat		#0
s	dat	#5084,	#-5084
	end	rock
----- end cut -----
Rock is basically just dwarf with a step size of 5084.  The larger step 
size and extra decrement makes Rock perform slightly better than Dwarf 
against most warriors.
 


Article 693 of rec.games.corewar:
From: Scott_-_Nelson@cup.portal.com
Newsgroups: rec.games.corewar
Subject: warriors
Message-ID: <56725@cup.portal.com>
Date: Wed,  1 Apr 92 01:31:40 PST
Organization: The Portal System (TM)
Lines: 110

    One more warrior from my collection, Molerat.
Molerat is a variant on Lemmings (see TCWN, spring 1988, page 11)
It won the 1990 ICWS tourney and took second in the Grand finally
held just afterward.
 
  It is not easy to follow the code, so I will outline the basic
flow.  
    Start 5 processes running inline (all 5 executing the same instructions)
    split to one of two "types", add or sub (more on this later)
 
    type add ;
      adds 5 locations to another location
      makes a copy of itself,
      splits to the beginning and repeats -and/or-
      bombs the location pointed to by the adds (perhaps a slave pit?)
      jumps to the copy.
 
    type sub ;
      subtracts 5 locations from another location
      makes a copy of itself,
      splits to the beginning and repeats -and/or-
      bombs the location pointed to by the subtracts (perhaps a slave pit?)
      jumps to the copy.
 
----- cut -----
;redcode
;name Molrat A.K.A paper
;author Scott Nelson
;strategy - Replicate -
 
start
; start up five inline process
	spl	1
	mov	-1,	0
	mov	-1,	0
	spl	paper4		;type add
	spl	paper3		;type sub
	spl	paper2		;type add
	jmp	paper1		;type sub
count	dat		#5
 
src1	mov	#10,	10	;initialize src for copy
	sub	<203,	204	;subtract for pit-bombing 
paper1	mov	<src1,	<dest1	;copy five locations
	mov	<src1,	<dest1	;copy five more
	spl	back1		;if we can, make more copies
	mov	bomb1,	<200	;bomb the pit (we hope)
dest1	jmz	@dest1,	6101	;if copy worked, jump there
back1	jmz	src1,	src1	;if copy worked, split back
	mov	0,	-1	;hmm . . . something went wrong, try to die.
bomb1	dat		#-10	;die
;
	dat		#1	
	dat		#1
	dat		#1
;
src2	mov	#10,	10
	add	<203,	204
paper2	mov	<src2,	<dest2
	mov	<src2,	<dest2
	spl	back2
	mov	bomb2,	<200
 
dest2	jmz	@dest2,	6301
back2	jmz	src2,	src2
	mov	0,	-1
bomb2	dat		#-10
	dat		#1
	dat		#1
	dat		#1
 
	mov	#10,	10
	sub	<203,	204
paper3	mov	<-2,	<4
	mov	<-3,	<3
	spl	3
	mov	4,	<200
	jmz	@0,	6501
	jmz	-7,	-7
	mov	0,	-1
	dat		#-10
	dat		#1
	dat		#1
	dat		#1
 
	mov	#10,	10
	add	<203,	204
paper4	mov	<-2,	<4
	mov	<-3,	<3
	spl	3
	mov	4,	<200
	jmz	@0,	6701
	jmz	-7,	-7
	mov	0,	-1
	dat		#-10
	end	start 
----- end cut ----- 
 
    Notes:  Molerat's major strength lies in the total lack of loops.  It
can (and does) spend 50% of its time modifying memory.  It is also
very good at dying when modified. (Alas, it is not perfect at it.) 
At first this might seem like a bad thing, but if a copy dies
(instead of being trapped in slave pit) then another (presumably
unmodified) Molerat can be born.  It also avoids the problem of the
enemy becoming a Molerat, since exactly five processes would have to
be executing inline in order to become a Molerat.  It also handles
SPL 0 bombs fairly well, since it consumes processes five times
faster than most mice-like programs.
    It is worth noting that Molerat performs better with a larger
coresize.  In fact in a large enough core, Molerat will beat XTC.


Article 695 of rec.games.corewar:
Newsgroups: rec.games.corewar
Subject: Re: Neophyte questions.
Message-ID: <56661@cup.portal.com>
From: Scott_-_Nelson@cup.portal.com
Date: 31 Mar 92 09:39:47 GMT
References: <STEPHEN.92Mar31002540@estragon.uchicago.edu>
Organization: The Portal System (TM)
Lines: 37

. . .
> Apparently important things I couldn't find out by reading what seem
> to be the Standard Texts:
> 
>         (1) there seems to be no FIXED limit on process count at
. . .
>         (2) if there IS a limit on process count, *what happens on
> spawn failure*? Do you drop through, or do you branch, under the newer
> redcode standard?
> 
>         (3) am I stupid, or is there no way of transferring a value
> from the b operand to the a operand other than a huge comparison tree?
. . .
 
1.) The limit is up to the group in charge of the tourney, who should
    post it along with all other arbitrary numbers.  For KotH it is 8000.
    but it could be 64 (the ICWS tourney standard in '90) or even 125000
    (effectively no limit)
 
2.) Spawn failure results in drop through.
 
3.) You are not stupid, but there are other (equally unsatisfactory) ways 
    to move the B-field to the A-field.
    here is the smallest one I can think of:
 
         ADD  inc, loc
         djn  -1, loc
    inc	 dat  #1, #0
    loc  dat  #0, #10
 
    several million others are possible, but none are fast.
 
    This sounds like a good idea for a puzzle:
    What's the fastest way to move the B-field of a location to the A-field 
    in 100 words or less.  (assume the A-field is initialized to zero as in
    the above example.)  Post your best time!
 


Article 699 of rec.games.corewar:
From: kwhyte@math.uchicago.edu (Kevin Whyte)
Newsgroups: rec.games.corewar
Subject: Re: modified '90 warrior, (was Re: Help! Need fighter!)
Message-ID: <1992Apr2.201952.16523@midway.uchicago.edu>
Date: 2 Apr 92 20:19:52 GMT
References: <1992Mar29.025522.19023@usenet.ins.cwru.edu> <1992Mar31.171647.17062@rlgvax.Reston.ICL.COM> <1992Apr2.055403.25498@samba.oit.unc.edu>
Sender: news@uchinews.uchicago.edu (News System)
Organization: Dept. of Mathematics, Univ. of Chicago
Lines: 78


  I'm sure I posted this before, but Andy's reference to Sargent
brought it to mind.  Sargent was a decent idea, but wastes much
time having the opponent imp stomp (of all things) if caught.  Kinch
is the next developement (although I never really got it past the
crude stage), and is a better warrior than Sargent.  The large
#'s of dat #0,#0 are only to space the diffent segments of code.
These really should be changed to dat 0,0 to make empty core.

;name Kinch
;author Kevin (kwhyte@math.uchicago.edu)

bomb jmp pit,0
offset dat #436,#-436
     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
start  add offset,bomb
       jmz start,@bomb
       add #7,bomb
loop   mov #13,loop
get    mov bomb,<bomb
       djn get,loop
       add #6,bomb
change jmp start,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
new    mov #-10,0
       mov -2,-3
       mov -4,<-4
       djn -1,-3
       jmp -3,0
thing  jmp new-start,start
       jmp 13,0
       jmp 12,0
       jmp 11,0
       jmp 10,0
       jmp 9,0
       jmp 8,0
pit     jmp 7,0
       jmp 6,0
       jmp 5,0
       jmp 4,0
       jmp 3,0
       jmp 2,0
       jmp 1,0
       mov thing,@thing
       spl 0,0
       jmp -1,0
       end start

Kevin
kwhyte@math.uchicago.edu


Article 704 of rec.games.corewar:
From: JJJ101@psuvm.psu.edu
Newsgroups: rec.games.corewar
Subject: Acid Rain 1.0
Message-ID: <92094.122752JJJ101@psuvm.psu.edu>
Date: 3 Apr 92 17:27:52 GMT
Organization: Penn State University
Lines: 80

Here's my program Acid Rain. It's been floating around the x-hill
for a few days around 8th,9th,or 10th.

James

;redcode-x verbose
;name Acid Rain 1.0
;author James Jesensky

start mov i1, <where1
      mov i2, <where1
      mov i3, <where1
      mov i4, <where1
      mov i5, <where1
      mov i6, <where1
      mov i1, <where2
      mov i2, <where2
      mov i3, <where2
      mov i4, <where2
      mov i5, <where2
      mov i6, <where2
      mov i1, <where3
      mov i2, <where3
      mov i3, <where3
      mov i4, <where3
      mov i5, <where3
      mov i6, <where3
      mov i1, <where4
      mov i2, <where4
      mov i3, <where4
      mov i4, <where4
      mov i5, <where4
      mov i6, <where4
      mov i1, <where5
      mov i2, <where5
      mov i3, <where5
      mov i4, <where5
      mov i5, <where5
      mov i6, <where5
      mov i1, <where6
      mov i2, <where6
      mov i3, <where6
      mov i4, <where6
      mov i5, <where6
      mov i6, <where6
      mov i1, <where7
      mov i2, <where7
      mov i3, <where7
      mov i4, <where7
      mov i5, <where7
      mov i6, <where7
      mov i1, <where8
      mov i2, <where8
      mov i3, <where8
      mov i4, <where8
      mov i5, <where8
      mov i6, <where8
      spl @where1
      spl @where2
      spl @where3
      spl @where4
      spl @where5
      spl @where6
      spl @where7
      spl @where8
      dat #0, #0
where1  dat #500, #500
where2  dat #1501, #1501
where3  dat #2502, #2502
where4  dat #3503, #3503
where5  dat #4504, #4504
where6  dat #5505, #5505
where7  dat #6506, #6506
where8  dat #7507, #7507
i1   mov 0, 1
i2   jmp -1
i3   spl 2
i4   djn -1, -3
i5   mov <-2, <-2
i6   mov #900, -1


Article 714 of rec.games.corewar:
From: ajpierce@med.unc.edu (Andrew Pierce)
Newsgroups: rec.games.corewar
Subject: Small 4
Message-ID: <1992Apr8.131527.7093@samba.oit.unc.edu>
Date: 8 Apr 92 13:15:27 GMT
Sender: usenet@samba.oit.unc.edu
Organization: UNC-CH School of Medicine
Lines: 26
Nntp-Posting-Host: salvo.med.unc.edu


   Small 4 has survived 10 successful challenges on KotH.  Here is the
code.  Basically this is the same as Small 2 which was posted to the net,
except the bombs have been made visible to B-field scanners (I think it
takes some of the elegance out of it, but it does do better), the bombing
address is held within the the executable code, and the bombing sequence
begins away from the executing code.
     -Andy
ajpierce@med.unc.edu

;redcode verbose
;name Small 4
;author Andy Pierce  (ajpierce@med.unc.edu)
;strategy small bomber/clearer
;strategy v2:  fix kill routine
;strategy v3:  marginally more robust
;strategy v4:  give bombs non-zero B-fields, start bombs away from self

start	add #15,1
	mov hit,751
	jmp start,0
hit	spl 0,-1
	mov 4,<-1
	jmp -1,0

	end start


Article 715 of rec.games.corewar:
From: ajpierce@med.unc.edu (Andrew Pierce)
Newsgroups: rec.games.corewar
Subject: Synch 4
Message-ID: <1992Apr8.133256.7898@samba.oit.unc.edu>
Date: 8 Apr 92 13:32:56 GMT
References: <1992Apr8.131527.7093@samba.oit.unc.edu>
Sender: usenet@samba.oit.unc.edu
Organization: UNC-CH School of Medicine
Lines: 63
Nntp-Posting-Host: salvo.med.unc.edu


   Synch 4 has survived more than 10 successful challenges on KotH.  Here
is the code.  I really like this one.  When it first appeared on KotH, the
Synch series went immediately to #1 and stayed there for about a week.
The highest score I saw reported was 978 or so, by Synch 3.  Synch 4 is
strategically almost identical to Synch 3, yet scored lower -- I take this
to be due to random statistical influences on battles on the hill.
   Synch 4 is an off-axis cmp scanner -- it compares locations to see if
they have been changed, but these locations are not coresize/2 apart so
that programs cannot use the "mirror defence" of having two identical
copies coresize/2 away from each other.
   Once an altered location has been found, Synch makes a decision:
Case 1:  the preceding instruction to the altered one has also been
altered:  In this case Synch 4 assumes it has found executing code and
bombs with spl 0, following with a clear routine.
Case 2:  the preceding instruction to the altered one has not been
altered:  In this case Synch 4 uses the same strategy which my program
"Stoopify" used and which I have learned the program "Hideout" also uses.
This is based on the idea that "lightning never strikes twice in the same
place".  When building a pattern bomber, it is not very efficient to
rebomb a location you have already hit (assuming non-motile programs) so
Synch 4 transfers a small bombing routine on top of one of the bombs it
has found.
   In some ways then, Synch 4 is somewhat parasitic:  it beats the
efficient pattern bombers but loses to "poorly designed" pattern bombers.
The hill though has lots of efficient bombers on it, such as Small 4,
which keep the programs that Synch 4 tends to lose to off the hill.
     -Andy
ajpierce@med.unc.edu

;redcode verbose
;name Synch 4
;author Andy Pierce  (ajpierce@med.unc.edu)
;strategy  cmp scan, spl bomb, clear core
;strategy  v2:  reduce footprint, convert losses to ties, better tactics
;strategy  v2a: convert ties to wins, marginally better strategy
;strategy  v3:  reduce footprint again, more extensive smear routine
;strategy  v4:  move scan off axis, minor tactics fix

start	cmp 2939,6988
	jmp hit,0
back	sub offset,start
	jmp start,0
hit	cmp @start,start-1
	jmp 2,0
	add flip,start
	slt #30,start
	jmp back,0
	mov bomb,@start
	cmp <start,start-1
	jmp smear,0
trans	add #5,start
	mov @push,<start
	djn -1,push
	jmp @start,0
smear	add #100,start
	mov bomb,<start
push	jmn -1,5
bomb	spl 0,0
	mov 2,<-1
	jmp -1,0
flip	dat #3951,#3951
offset	dat #49,#49


Article 748 of rec.games.corewar:
From: ScottNelson@cup.portal.com (Scott - Nelson)
Newsgroups: rec.games.corewar
Subject: Re: Binary Subdivision bombing
Message-ID: <57559@cup.portal.com>
Date: Fri, 17 Apr 92 23:27:43 PDT
Organization: The Portal System (TM)
References:  <1992Apr12.233751.8607@mintaka.lcs.mit.edu>
Lines: 86

    First let me point out that if you want post-increment, you can always
do it in two instructions (MOV @stack,b   ADD #1,stack).
 
Here is a single-process bomber that bombs with a "binary subdivision".
---- cut -----
;
;name Binary bomber
;
; basic bomber
loop	mov	bomb,	@offsets
l2	add	@i1,	@loop
	djn	loop,	@i2
; now change the parameters
	add	#1,	loop
	add	#1,	i1
	add	#1,	i2
	jmp	loop
;
i1	dat	addvals
i2	dat	counts
 
 
;the table of add values
addvals	dat		#0
	dat		#4096
	dat		#2048
	dat		#1024
	dat		#512
	dat		#256
	dat		#128
	dat		#64
	dat		#32
	dat		#16
	dat		#8
	dat		#4
	dat		#2
;the table of counts
counts	dat		#1
	dat		#2
	dat		#4
	dat		#8
	dat		#16
	dat		#32-1
	dat		#64-2
	dat		#128-4
	dat		#256-8
	dat		#512-15
	dat		#1024-30
	dat		#2048-60
	dat		#4096-120
 
;the table of offsets
offsets	
	dat		#bomb+4096
	dat		#bomb+2048
	dat		#bomb+1024
	dat		#bomb+512
	dat		#bomb+256
	dat		#bomb+128
	dat		#bomb+64
	dat		#bomb+32
	dat		#bomb+16
	dat		#bomb+8
	dat		#bomb+4
	dat		#bomb+2
	dat		#bomb+1
;
bomb	dat	#0
---- end cut -----
 
Subdividing core in this manor can also be accomplished by having
one dwarf for each step size.  This is not as bad as it sounds,
eleven dwarves, and three mov's accomplish the whole task.  (It is
actually shorter than "Binary bomber")
 
I suspect that even a perfect binary subdivision program would not
perform very well, because of the large tables needed.  Until some
sort of division instruction exists, I think binary subdividers will
take a back seat to the "optima" style of bombing.
|+--------------------------------------------------------------+|
Half a bee, philosophically, must ipso facto, half not be.
 
 
 
 
  <<<ScottNelson@cup.portal.com>>>


Article 749 of rec.games.corewar:
Newsgroups: rec.games.corewar
From: rjc@hal.gnu.ai.mit.edu (Ray)
Subject: Re: Binary Subdivision bombing
Message-ID: <1992Apr18.082557.824@mintaka.lcs.mit.edu>
Sender: news@mintaka.lcs.mit.edu
Organization: /etc/organization
References: <1992Apr12.233751.8607@mintaka.lcs.mit.edu> <57559@cup.portal.com>
Date: Sat, 18 Apr 1992 08:25:57 GMT
Lines: 121

    Well I did a single process bomber about 3 days ago and it lost
miserably on the hill. It's just too big a target (although
much smaller than yours) compared to dwarf optima and their ilk.

-----------------------------------
;redcode verbose
;name Binrary Tree 2.0 (beta)
;author Ray Cromwell
;strategy Greatly enhanced version of my Binary Tree program
;strategy thousands of times faster!

bomb	spl	0,#42
offset	dat	#0,#0
temp	dat	#0,#0
	dat	#0,#0
num	dat	#16,#16
start	mov	<ptr,dest	;fetch next vlaue from offset table
	jmn	ploop,ptr	;if 0, turn into a dwarf bombing with dats
	mov	bomb-1,<bomb-1
	jmp	-1,<bomb-1
ploop	mov	dest,offset	;dest is the destination which is offsetted
	add	offset,offset   ;offset is the value added to dest each loop
				;which is 2*dest
				;this gets rid of the "bomb some loc twice"
				;by making each bombing run out of phase
				;by 1/2 the dist between two previous bombs
	slt	#62,num		;check to prevent us from bombing ourselve
	jmp	2,0		
	sub	#2,num
	mov	num,temp	;temp=number of bombs to lay out
	add	temp,num	;num=num*2, for next iteration
bloop	mov	bomb,@dest
	add	offset,dest
	djn	bloop,temp	;bomb code

	jmp	start,<4000	;impstomp/decoy jump back to begining
	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           ;move the table away from the main code
	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
	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
ptr	dat	#tbl+1,#tbl+1
	dat	#2,#2
	dat	#4,#4
	dat	#8,#8
	dat	#16,#16
	dat	#31,#31
	dat	#62,#62
	dat	#125,#125
tbl	dat	#250,#250
dest	dat	#0,#0
	end	start

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

  On the first iteration, it lays out 16 bombs spaced 500 apart starting
at 250. On the next iteration it lays out 32 bombs spaced 250 apart
starting at 125. Then 64 bombs(actually 62) spaced 124 apart starting
at 62 (it bombs 62 instead of 64 because it would to bomb itself)
On the last loop it bombs 1924 locations spaced 4 apart starting at an offset
of 2.

  So it ends up bombing almost every other location in the core (except
a small area nar the program itself, and a single column)

  It still loses badly. I think because the table footprint is too big.
I thought of starting the table at dat #125,#125. That way it would bomb
with an offset of 250 between bombs starting out. I could also
stop the table at dat #4,#4 but this only shaves 2 words off the program
size.

  Clearly it does better against larger programs. It won't hit programs of
size 4-8 until the 7th iteration.

   I could make the bombing more uniform by making the table values larger
divisions of the core. (for instance, bomb 16 locations spaced 1500 apart
instead of 500. )



Article 784 of rec.games.corewar:
Organization: Penn State University
Date: Tuesday, 28 Apr 1992 14:17:09 EDT
From: Jeff Raven <JAR129@psuvm.psu.edu>
Message-ID: <92119.141709JAR129@psuvm.psu.edu>
Newsgroups: rec.games.corewar
Subject: Nevermore 3.2
Lines: 45

For those of you out there who could use another warrior to test against,
here's Nevermore 3.2. It's a fairly simple B-field scanner, but it does
OK against most competition (although it gets massacred by dwarves). The
only thing distinctive about it is the bombing mechanism, which alternates
between DAT and SPL bombs. I'm not sure that the alternating is particulary
useful, but without it the original algorithm looked entirely too much like
XTC. (Incidentally, if anyone's got any recommendations for improvements,
I'd like to hear them ;)

------CUT HERE------

;redcode verbose
;name Nevermore 3.2
;author Jeff Raven
;
;strategy - Version 3.2
;strategy - Scans the core, looking for a non-zero B-field, and then
;strategy - proceeds to bomb the memory around the suspicious address.
;strategy - As for how it bombs .......... the algorithm has finally
;strategy - been fixed, and hopefully it should tie a lot less now.
;

basis   EQU 4                   ; Basic step size for the search
step    EQU 3044                ; Step size for the search
delta   EQU (point - alpha)     ; Constant used in the bomb exchange
double  EQU (2 * delta)         ; Constant used in the bomb exchange
offset  EQU basis               ; Distance ahead of target to start bombing
correct EQU (basis - 1)         ; Corrective value used after bombing
times   EQU (2 * basis - 1)     ; Number of bombs to place

start   ADD #step, target
target  JMZ start, counter
        ADD @point, point
        SUB #delta, point
        ADD #offset, target
counter MOV #times, counter
kill    MOV @point, <target
        DJN kill, counter
        ADD #correct, target
        JMP start

alpha   SPL alpha, double
point   DAT #alpha

        END start


Article 785 of rec.games.corewar:
Newsgroups: rec.games.corewar
From: stst@vuse.vanderbilt.edu (Stefan Strack)
Subject: More code: Agony 2.1
Message-ID: <1992Apr29.002402.29361@vuse.vanderbilt.edu>
Sender: news@vuse.vanderbilt.edu (News Manager)
Nntp-Posting-Host: vuse2
Organization: Vanderbilt University School of Engineering, Nashville, TN, USA
References: <92119.141709JAR129@psuvm.psu.edu>
Date: Wed, 29 Apr 1992 00:24:02 GMT
Lines: 40

In article <92119.141709JAR129@psuvm.psu.edu> JAR129@psuvm.psu.edu (Jeff Raven) writes:
>For those of you out there who could use another warrior to test against,
>here's Nevermore 3.2.  [..]
Keep it up, Jeff! 

Another Core Warrior for your collection: Agony 2.1 is a scanner that bombs
with a SPL-carpet, just like XTC or Jeff's Nevermore. For thoroughness and
greater speed (2 scans/3 instruction loop) it uses a CMP-scan engine.
Agony doesn't switch bombs to kill, but clears the core when scanning is
complete. It was briefly #1 and is now somewhere in the middle of the hill.

Enjoy, Stefan (stst@vuse.vanderbilt.edu)

;redcode verbose
;name Agony 2.1
;author Stefan Strack
;strategy Small-interval CMP scanner that bombs with a SPL 0 carpet.
;strategy 2.0: smaller
;strategy 2.1: larger, but should tie less; changed scan constants
;strategy Submitted: @date@

CDIST   EQU     23                 ; distance between addresses CoMPared
IVAL    EQU     994                ; scan increment (mod-2 pattern)

scan    ADD     incr,   comp                            ; CMP scan loop:
comp    CMP     0,      CDIST                           ;
        SLT     #incr-comp+CDIST+(bptr-comp)+1,comp     ; don't bomb self
        JMP     scan                                    ;

        MOV     #CDIST+(bptr-comp)+1,count    ; init bomb-loop w/ # of bombs
        MOV     comp,    bptr                 ; use "comp" as bomb-pointer
bptr    DAT     #0                            ; this will be "comp" when exec
split   MOV     bomb,   <bptr                 ; bomb away
count   DJN     split,  #0
        JMN     scan,   scan                  ; fall thru when self-obliterated
bomb    SPL     0                             ; and clear the core
        MOV     2,<-1
incr    DAT     #IVAL,  #IVAL

        END     scan


Article 787 of rec.games.corewar:
From: vli@mpr.ca (Vincent Li)
Newsgroups: rec.games.corewar
Subject: Multidwarf
Message-ID: <1992Apr30.061947.12692@mprgate.mpr.ca>
Date: 30 Apr 92 06:19:47 GMT
Sender: news@mprgate.mpr.ca
Organization: MPR Teltech Ltd., Burnaby, B.C., Canada
Lines: 30


Hi there,
  Here's another fellow you can try out against. I've submitted it twice
to the hill and it made it on there only briefly. It's like dwarf optima
except where the bomb would've gone is a dwarf that sweeps the core.
Seems to be effective against single process bombers, but because
it's multi-process, quite vulnerable to trappers, which seems to be a
dominant force on the hill!

-- Vince

---------------------------------------
vli@mprgate.mpr.ca        |-) It works well under pressure: Another thing
                          |-] you can say about your pillow. -- Mr Boffo
--------------------------------------------------------------------------------
;redcode verbose
;name multidwarf
;author Vincent Li (vli@atom.mpr.ca)
;strategy many dwarfs working together
;strategy credits to Nandor Sieban for insights
;
start   mov     ptr,<dst
        mov     bomber,<dst
dst     spl     @dst,#3044
        add     #3044, dst
        jmp     start,0
bomber  mov     bomb, <ptr
ptr     jmp     bomber,#-2
bomb    dat     #0
        end     start


Article 790 of rec.games.corewar:
Newsgroups: rec.games.corewar
From: t-jcisek@microsoft.com (Julius Cisek)
Subject: Down with PitTrap - ICWS'88 too simple?
Message-ID: <1992Apr30.190647.21754@microsoft.com>
Date: 30 Apr 92 19:06:47 GMT
Organization: Microsoft Corp.
Lines: 72


As some of you may know, I removed PitTrap v2.3a from the King of the
Hill tournament.  I do this because I found that PitTrap was almost
identical to scissors88, a warrior written by Scott Nelson long before
I even knew about corewar.  I didn't write PitTrap using Scott's code;
it was a completely original program, but this is the problem with
ICWS'88.  There is just not enough variety to facilitate truly original
programs.  Just the fact the step values can play such a crucial role
in the success of a program (Dwarf-12b, also by Scott Nelson survived
for over 100 successful challenges before parting) shows you that we
need a new standard.  The only TRULY original program I've seen since
I started playing KotH is Synch by Andy Pierce (a really brilliant
idea) and there have been hybrids (not nearly as successful) since.

For now, my suggestion is to follow Andy's, Scott's, and Stefan's
suit and start posting the source to your programs.

Here is PitTrap v2.3a (with "decoys" removed for sake of length):
;redcode verbose
;name PitTrap v2.3a
;author J.Cisek
;strategy creation date 4/6/92
;strategy steal processes into slave pit
;strategy slave pit is a simple bomber that kills itself
;strategy  v1.1  4/7/92 doesn't trap itself...
;strategy  v2.0  4/8/92 smaller code/quicker search
;strategy  v2.1  4/13/92 better slave pit
;strategy  v2.2a 4/22/92 better step value
;strategy  v2.3  4/24/92 decoys [v2.3a optimal step]

INSTALL	equ 3000
STEP	equ 3044

init	mov trap, INSTALL
	mov intval, INSTALL
	mov bomb, INSTALL

here	mov search, INSTALL+1
	mov search+1, INSTALL+1
	mov search+2, INSTALL+1

	mov pit, INSTALL+2
	mov pit+1, INSTALL+2
	mov pit+2, INSTALL+2

	jmp INSTALL+here+1

trap	jmp pit+1, #-1
intval	dat #STEP, #-STEP
bomb	dat #trap

	dat #42

search	add intval, trap
	mov trap, @trap
	jmp search, #0

	dat #42

pit	mov bomb, <bomb
	spl pit, #0
	jmp pit, #0

	dat #42				; decoys
;fill the space after this point with as many dat #42's (or whatever)
;as you can fit.  It'll play havoc with scanning programs.

	end init

;kill PitTrap
-- 
Julius Andrew Cisek                ,_,
t-jcisek@microsoft.com   "Joy!"   /oo \  _.-.   "Quiet, you bloated
One Microsoft Way     //          <>__| /- O O       idiot!"
Redmond, WA 98052   \X/           |  U|    \|


Article 791 of rec.games.corewar:
Newsgroups: rec.games.corewar
From: t-jcisek@microsoft.com (Julius Cisek)
Subject: Tiny and Gnats
Message-ID: <1992Apr30.195809.23677@microsoft.com>
Date: 30 Apr 92 19:58:09 GMT
Organization: Microsoft Corp.
Lines: 57


ProtonDance-X prompted the development of Tiny and Gnats which were
short time visitors on the hill.  Tiny is like Andy Pierce's Small,
in a demented kind of way.  Tiny v1.2 made it to the hill, hit a
high of 19th, and was knocked off at the age of 4.  Gnats made it
as high as 5th once (yes really) and had a total age (versions Gnasty
and Gnastier included) of 20.  Lets knock off gnats first.  Here's
what a Gnat looks like:
;redcode verbose
;author J.Cisek
;date 4/16/92
gnat	mov -1, <-2
	jmp gnat, <-3

Of course, this isn't good enough, so the versions I submitted spread
8-32 of these things through the core.  Not very exciting, but they did
pretty well against some programs.

Finally, here's Tiny v1.2 (with decoys removed).  His biggest advantage
is that he doesn't have any piece of code that's longer than a dwarf.
Also, the pieces are strewn 60 places away.  What this does is assures
that if a program that scans by either mod 3, mod 4, or mod 5 misses
one piece, it'll miss 'em all (Tiny needs time to do his work...)
;redcode verbose
;name Tiny v1.2
;author J.Cisek
;strategy creation date 4/19/92
;strategy very small spl 0 bomber/clearer with decoys
;strategy  v1.1 4/20/92 better location
;strategy  v1.2 4/21/92 bombs with spl -1

start   mov trap, 3000
        mov slow-1, 3119
        mov slow, 3119
        mov slow+1, 3119
        spl 3117, #42
        mov clear, 3055
        mov clear+1, 3055
        dat #42

trap    spl -1, #42

clear   mov -2, <-2
        jmp clear, #0

        jmp -60, #0
slow    mov -121, <-122		; gets hit here with a SPL -1
        jmp slow, <-123

        dat #42
;Here's where your decoys go.  Go crazy!

        end start

;kill Tiny
-- 
Julius Andrew Cisek                ,_,
t-jcisek@microsoft.com   "Joy!"   /oo \  _.-.   "Quiet, you bloated
One Microsoft Way     //          <>__| /- O O       idiot!"
Redmond, WA 98052   \X/           |  U|    \|


Article 792 of rec.games.corewar:
Newsgroups: rec.games.corewar
From: t-jcisek@microsoft.com (Julius Cisek)
Subject: ProtonDance
Message-ID: <1992Apr30.194501.23261@microsoft.com>
Date: 30 Apr 92 19:45:01 GMT
Organization: Microsoft Corp.
Lines: 29



Here's a really nifty little program, ProtonDance-X (the X is NOT
for the experimental hill, I didn't know about it when I named this
program...).  It uses a really nifty trick (also used by my Tiny and
Gnats programs) of decrementing a value using the B-operand of an
instruction that doesn't even use the B-operand.  Since operands
are evaluated the same way no matter what the instruction, this:
JMP label, <value works.  Anyways, ProtonDance-X was on the hill
just when KotH went to version 2.2.  It made it to 15th place once
and was knocked off at the age of 11.  High score was 139.  I have
a feeling, by the way, that Andy Pierce and nandor sieben have also
come across this trick (what were Shuffle and mixer guys? :)
;redcode verbose
;name ProtonDance-X
;author J.Cisek
;date 4/13/92
;strategy  Tiny disruptor.  Messes up programs.

dance	mov <-1, <-1		; do the proton dance
	jmp dance, <-2		; b-field pre-decrement is the key here

	end dance

; This does work under ICWS'88 and KotH.  Try and find me!

;kill ProtonDance
-- 
Julius Andrew Cisek                ,_,
t-jcisek@microsoft.com   "Joy!"   /oo \  _.-.   "Quiet, you bloated
One Microsoft Way     //          <>__| /- O O       idiot!"
Redmond, WA 98052   \X/           |  U|    \|


Article 793 of rec.games.corewar:
Newsgroups: rec.games.corewar
From: t-jcisek@microsoft.com (Julius Cisek)
Subject: Charon v2.0
Message-ID: <1992Apr30.192529.22277@microsoft.com>
Date: 30 Apr 92 19:25:29 GMT
Organization: Microsoft Corp.
Lines: 54


By the way, PitTrap survived 129 successful challenges through its
many versions.

Here is Charon v2.0 which has been in the top 10 of the Hill for
several days, even reaching 1st a couple of times.  Charon scans
with a distance of 1/2 core (this doesn't work against programs
that mirror themselves, but there doesn't seem to be too many of
those).  When it finds code, it bombs it with a SPL 0, JMP -1
combination which effectively shuts the enemy down.  He counts
down during his search and starts a clear core routine when the
counter is down to zero:
;redcode verbose
;name Charon v2.0
;author J.Cisek
;strategy creation date 4/11/92
;strategy cmp scan, spl trap, clear core, etc.
;strategy  v1.1 4/14/92 improved trap [reversed in v1.3]
;strategy  v1.2 4/16/92 improved clear core routine
;strategy  v1.3 4/21/92 original trap, optimal step, smaller code
;strategy  v2.0 4/22/92 total code overhaul
;strategy   mod 3 cmp scan with optimal step, new deadly trap

START	equ 1581
STEP	equ 1581
HALF	equ 4000
COUNT	equ 1333

target	cmp START, START+HALF		;this must be first for SLT to work
counter	jmp gotem, #COUNT		;also used as counter
search	add steps, target		;start new search here
	djn target, counter		;countdown to clear

clear	mov bomb, <bomb			;your typical clear core
	jmp clear, #0			; routine
bomb	dat #clear			;visible bomb

gotem	slt #trap+3-target, target	;don't hit self
	jmp search, #0			;skip over self
	mov trap+1, @target		;move trap in place
	mov trap, <target
	add switch, target		;swap a and b operands
	jmp target, #0			;cmp again (same location)

steps	dat #STEP, #STEP		;our step value
switch	dat #HALF, #HALF+1		;the swap value
trap	spl 0, #0			;the trap
	jmp trap, #0

	end target

;kill Charon
-- 
Julius Andrew Cisek                ,_,
t-jcisek@microsoft.com   "Joy!"   /oo \  _.-.   "Quiet, you bloated
One Microsoft Way     //          <>__| /- O O       idiot!"
Redmond, WA 98052   \X/           |  U|    \|


Article 794 of rec.games.corewar:
Newsgroups: rec.games.corewar
From: t-jcisek@microsoft.com (Julius Cisek)
Subject: Crimson v1.1 - KotH-x
Message-ID: <1992Apr30.193210.22517@microsoft.com>
Date: 30 Apr 92 19:32:10 GMT
Organization: Microsoft Corp.
Lines: 60



Here is my first program specifically designed for the current KotH
experimental hill.  It's a very simple but quite effective program
which borrows the trap from my Charon v2.0 program on the regular
hill.  It copies itself backwards in core after bombing backwards
with SPL 0, JMP -1.  As it moves it counts down and eventually
turns it's own trap into a DAT statement.  From now on when it moves,
it kills.  Crimson v1.1 hovers between 3rd and 5th (if hovers is
the right word for KotH-x with its myriad of submissions... :)
;redcode-x verbose
;name Crimson v1.1
;author J.Cisek
;strategy creation date 4/26/92
;strategy This is my first program designed specifically
;strategy  for the KotH experimental hill.
;strategy  Bombs the local area, then jumps to the next area.
;strategy  Traps the first time through core, clears the second.
;strategy  v1.1 4/29/92 Doesn't leave back uncovered anymore.

STEP	equ -150			; new copy offset
TRAPS	equ 1				; space between traps
NTRAPS	equ 64				; number of traps [STEP+50 / (TRAPS+2)]
JUMPS	equ 50				; number of times we trap

length	dat #0, #0			; program data
split	spl 0, #0
jump	jmp split, #0

start	mov #NTRAPS, jump		; use jump to store this counter

attack	mov jump, <length		; 2nd piece of trap
	mov split, <length		; 1st piece of trap
	sub #TRAPS, length		; point to new trap
	djn attack, jump		; attack NTRAPS times

	djn normal, done		; after we jump through the core
	mov length, split		;  JUMPS times, start killing

normal	mov #done-length+1, length	; set up copy source
	mov #STEP, split		; set up copy destination
copy	mov <length, <split		; copy 
	jmn copy, length

	add #3, split			; point to new start point
done	jmp @split, #JUMPS		; transfer control there

	end start

; This warrior is designed for the KotH experimental hill which has the
;  following settings: Post-increment is allowed, warriors can only change
;  memory locations within 250 of the current instruction.

; While it does work under ICWS'88, don't bother running this warrior in a
;  regular tournament, or under any rules which allow writing to a greater
;  address range

;kill Crimson
-- 
Julius Andrew Cisek                ,_,
t-jcisek@microsoft.com   "Joy!"   /oo \  _.-.   "Quiet, you bloated
One Microsoft Way     //          <>__| /- O O       idiot!"
Redmond, WA 98052   \X/           |  U|    \|


