🚀 go-pugleaf

In <136140001@hpcupt1.cup.hp.com> wang@hpcupt1.cup.hp.com writes:

> Why are people still playing CoreWars?  I stopped playing a few years ago
> when I determined Vampire type fighters have too much advantages over other
> types of fighters; one hit and the game is over.
> 
> I can describe my last CoreWars fighter as 2 parallel running vampires that
> periodically check if the twin is dead or not.  If so, the survivor will turn
> itself into multiplying rabits.  It's insurance against lucky shots.
> 
> How do the latest champions work?  If things have changed, please correct
> my theory about vampires.
> 

Things have changed all right.  Any and all of the current champions could
knock the socks off any and all of the contestants in the previous yearly
tournaments.  One of the main reasons is the use of large numbers of processes
running together, usually created by executing a SPL 0 instruction.  Of course,
this means you need to have code that can be executed by multiple processes
without damaging itself, but this isn't too hard, and the resulting toughness
is really worth it.

Intelligence, such as the self-checking program you described, isn't that
important anymore (unfortunately, IMHO).  However, there are a few tricks
available that make programs smarter than the usual bomb-bomb-bomb versions,
such as the use of CMP to scan 2 locations every 3 cycles.  Here's the classic
example of such a program:

;redcode verbose
;name Crimp 2
;author Andy Pierce
;strategy  cmp scanner with decoy
;strategy  v2:  smaller, faster core clear, original constants

ret     add offset,start
start   cmp -50,-1
        slt #11,start
count   djn ret,<6024
        mov bomb1,@start
        mov bomb2,<start
        add next,start
        jmn start,ret
bomb2   spl 0,2
next    mov @-49,<-48
bomb1   jmp -1,0
offset  dat #-98,#-98

The "redcode verbose", "name", "author", and "strategy" lines are for the
ongoing tournament King of the Hill, which is addressed in the FAQ.

Programs such as Crimp 2 ruled the hill for months last spring, before more
innovations came out and gradually pushed them off.  This program looks at
2 addresses using the CMP, checking to see if they are equal.  Chances are,
if they aren't, you've found a section of a program, so the SLT checks to
see if it's your own code.  If it's not, bomb one of the two locations,
exchange the A- and B-fields of the CMP, bomb the other location, then go
back to scanning.  The DJN mutates core, and when the mutation finally
overwrites the program, it drops into the core-clear at the end - starting
with a SPL 0 so unlucky bombs from an enemy can't kill the program.

When CMP-scanners seemed to be entrenched so firmly on the hill that they
would never be pushed off, many people said that innovation in Redcode had
come to an end.  However, just a few weeks ago, the first imp-ring appeared
on the hill, and this strategy has since been accepted as a very powerful
one - one of the few strategies that actually do well in tooth-and-nail
competitions, where "smart" programs - self-checkers and the like - generally
get smashed.  Moral: never give up on CoreWar.

Kent Peterson

Well, Sucker 4 nearly made it to 1000, and Sucker 5
looks like a good bet to do even better.  There's just
one problem.  Pit-trappers are EASY to beat, because they
drop pointers to themselves all over core.  Try running
this three-line program against Sucker 4:

trace    mov 10,<-10
         sub @trace,<trace
         jmp trace

Then figure out how you can incorporate the first two lines
into a loop in your own fighter.  Or create a three-line 
'outrigger' running somewhere outside your program - 
that's what I do in Imprimis 3.  It doesn't need many 
cycles, it can be a slow but sure killer.

Testing against imp-rings also gives some interesting results -
such as tracing an imp-line back to it's source.  Not fatal,
but sometimes kills the stone.

Peace.

Paul Kline
pk6811s@acad.drake.edu