🚀 go-pugleaf

Well, looks like my prediction about multiple-tactic programs is coming true
with a vengeance.  Both my high-tech bombers, Emerald and ExtraExtra, were
driven off the hill, and Twill also.  More people are writing stone-paper
combinations successfully and venerable Flash Paper is showing definite
signs of age.  The unfortunate side effect of stone-paper combos is they
have driven off their friends the stones, thus allowing scanners to rule
the hill.

I would be curious to know if anyone is using bombers modeled after 
Emerald or ExtraExtra as described in my article 'stone.better.txt' on
soda.berkely.

Much as I hate to encourage scanners, they do seem to be in the limelight, 
and there are three ideas I would like to share.

First Idea:
----------

To make a cmp-scanner that does not use a fixed separation between 
the a- and b-fields, ala Charon and No Mucking About 
(and all the others I've seen).  This would look like:

next    add inc,scan
scan    cmp 0,0
        slt #11, scan
        jmp next
attack  mov bomb,@scan
        mov #scan2-scan,scan2
        sub scan,scan2
        mov bomb, @scan2
        jmp next
scan2   dat #0
inc     dat #1003,#0-1003
bomb    spl 0

If you follow this, you will see that the a and b operands of 'scan' will
always total 8000 (or zero), so subtracting b from zero gives a.  Actually
you subtract b from #scan2-scan to allow for the relative positions of 
scan and scan2.  Unfortunately, Core 1.1 for the Mac does not check for
negative operands with the SUB command (at least not for both operands),
so I can't get this to work reliably.

Second Idea:
------------

A multi-processing scanner, with a large number of syncronized processes.
One requirement for a scanner-replicator combo is that the scanner must
grow processes, or it will effectively cease to function as the replicators
multiply.  Here's part of one that I have:

ptr1     dat #-100
ptr2     dat #-100
bomb     spl 0
start    spl 1,<ptr1
         spl 1,<ptr1
         spl 1,<ptr1
         spl 1,<ptr1
         spl 1,<ptr1
         spl 1,<ptr1
scan     cmp <ptr1,<ptr2
         spl attack,<ptr1
return   jmp scan
attack   mov bomb,<ptr2
         end start

Try it.  It carpet bombs with a spl 0, using 64 processes.  A little slow,
but persistent.

Third Idea:
-----------

The other requirement for a scanner-replicator combo is a scanner that
ignores it's own replicators.  Here's how it might work.  Program scans
until it finds a likely location.  Then if that b-field is less than 
7985 (or some such high number) bomb it.  Now all you have to do is
create a replicator and scanner whose b-fields are all greater than 7985.
I have tested a couple of these, but they're not powerful enough yet.

Unfortunately, merging ideas 2 and 3 has so far defeated me.

--------

just some thoughts

Paul Kline
pk6811s@acad.drake.edu