Article 1409 of rec.games.corewar:
From: wangsawm@prism.CS.ORST.EDU (Wangsawidjaja Mintardjo)
Newsgroups: rec.games.corewar
Subject: Protecting your warrior against IMPire
Message-ID: <1992Oct21.091154.29342@CS.ORST.EDU>
Date: 21 Oct 92 09:11:54 GMT
Sender: usenet@CS.ORST.EDU
Distribution: usa
Organization: Oregon State University, Computer Science Dept.
Lines: 161
Nntp-Posting-Host: prism.cs.orst.edu


Some of you probably have already noticed that two programs I submitted: 
Beholder's Eye & Winter Werewolf suddenly entered KotH and competed with
IMPire programs for the #1 and #2 place. And YES, they are normal vampire
programs that defend themselves against IMPs. By average, they score 
something like 70-15-15 against multi-layered IMPs.

The idea behind their success is quite simple:
- Since multi-layered IMPs advanced slowly, scanners/vampires would have
  sufficient time to finish their own routines before dealing with IMPs.

So to say:
1. Normal routine
2. Core clear
3. IMPs gate

First and two are clear.
Third: IMPs gate. Ok, there might be a better word for this. What I mean
is to stop the IMPs while you are hopeless. And the secret? To use an
instruction which has been looong forgotten: Pre-Decremental DAT.
Does it ring a bell?

So, here we go:

First: Winter Werewolf.

;redcode
;name Winter Werewolf
;author W. Mintardjo
;strategy SPL/JMP bomber with 2 pass core-clear (SPL/DAT) + self-defense
;strategy against IMPs

step    EQU     153
init    EQU     152
n       EQU     (12*8)-2

        DAT     <-4-n, #0
m       MOV     -1, 0-n
        JMP     2
snow    SPL     0, <-3-step-n
main    MOV     hold, @3
        MOV     snow, <2
        ADD     #step, 1
        JMP     main, init      ; Hit here
        MOV     @-4, <n
hold    JMP     -1, 1

        END     m

This originally was my Snowflake 2+. I added the first three instructions and 
modified the SPL to make it works against IMPs. The changes however is not
too robust.

I would like to try to make things clear for everybody. So here I give a rather
lengthy description about what it does.

If everything works fine, Winter Werewolf would have four main routines:

1. Bombing core with mod 8 SPL/JMP.

2. Second routine happened after a bomb landed on line 'JMP main, init'
   So, it transformed into:
           DAT     <-98, #0
		   ...
   main    MOV     hold, @3
           MOV     snow, <2
           ADD     #step, 1
           SPL     0, <-97  ;changed. Main routine goes here
           MOV     @-4, <n  ;n = 94
   hold    JMP     -1, 1
		   ...
   n       SPL     0, <-250
           JMP     -1, 1
   Winter Werewolf now fall into core-clear mode. But it uses SPL 0 instead
   of DAT to stun any replicator process which is still functional. This 
   compromises the large interval of its bombing pattern.

3. When those SPLs reach line labeled n, it changes its pointer
   So then:
   a       DAT     <-98, #0
		   ...
   main    SPL     0, <a    ;a = -97. Line is changed
           MOV     snow, <2
           ADD     #step, 1
           SPL     0, <-97  ;Main routine is still on here
           MOV     @-4, <n  ;n = 94
   hold    JMP     -1, 1
		   ...
   n       SPL     0, <-97
   Once more, it goes into core-clear mode. But this time, it uses a
   Pre-Decremental DAT to kill all stunned processes.

4. At the last, it hits its own code becoming:
   SPL 0, <-97
   DAT <-98, #0

   And you can see then that all what it does is to gate every incoming IMPs.

Now, come the fun part: Beholder's Eye

But before, I would like to mention something about the origin of this
program. Much thanks and credits should go to Matt Hastings. This is because the
code I use came from his 'B-Scanners live in vain'. I borrowed this program
because of its simplicity and changeability in design.


;redcode
;name Beholder's Eye v1.1
;author W. Mintardjo
;strategy Modified B-Scanners Live in Vain with IMPs immunity
;kill Beholder's Eye v1.1

step    EQU 2234
init    EQU -2

main    ADD #step, 3
        JMZ -1, @2
        MOV jump, @1
        MOV snow, <init
        JMN -4, -4
snow    SPL 0, <0
        MOV 2, <-6
jump    JMP -1, 0
        DAT <-92 ,<-2

        END main

To make this program IMPs proof, I might try the similar trick. But if I change
the SPL's B-Field, I wouldn't have mod 2 scanner which decrease this program
performance. It might be better to just leave the B-Field zero and find a way
to make that B-Field changed after scanning. So, here I use a double
Pre-Decremental DAT.

In core clear mode, when a DAT replaced JMP, all processes on this line 
eventually die. In order to die, they have to execute that Pre-Decremental DAT.
I have found that for 8000 processes with coresize 8000, there would be
90 processes remaining on line JMP -1, 0. Then they have to execute that
DAT <?,<? which cause the SPL's B-Field to be decremented 90 times.
The SPL itself has already decremented itself once. So we would have

snow    SPL 0, <-91
        DAT <-92, <-2

The weakness of these programs is that they still lose to dwarf/ring combos.
But then, we go back to our previous philosophy where dwarf beats scanner.
To fight this kind of combinations, I've found that rotld-like program is
good against it.
Also, these programs are also more-likely beaten by fast IMPs or IMPs without 
many layers. But these IMPs won't harm self-splitting bomber much.

Ok. I hope with this, there would be more warrior's variations on KotH.


--- W. Mintardjo


-- 
#include <sys/std/disclaimer.h>
/* Sender: W. Mintardjo (wangsawm@prism.cs.orst.edu) */
main()
{ printf(".sig? what's .sig?\n"); }