As promised yesterday during the livestream; I'll do a small write-up as well here and share some of the warriors.
I love reading the tought process you all went through.
== Round 1:
In this round, initially, I focussed on LP/MP warriors. I thought the benchmark wasn't online, glanced over the download button multiple times.
So I started working on my own LP paper and called it "From the Grave", here it is:
;redcode-94nop
;name From the Grave
;author Roy van Rijn
;strategy continuously booted LP paper
;assert 1
pStep equ 1310
bStep1 equ 5295
bOff1 equ 7453
bOff2 equ 6187
bDist equ 2740
bIncr equ 1407
pDjn equ 3972
bDjn equ 4232
pLen equ 8
; LP paper with embedded stone
pTop spl @pStep , >pLen
sub.x pEnd , @3
pBmb mov.i {bOff1 , {bOff2
mov <pTop , {pTop
mov <pTop , {pTop
pLoop add.x #bStep1 , pBmb
jmn.b -4 , @-2
pEnd djn.f pTop , <pDjn
for 10
dat 0,0
rof
; Continuously boot the paper:
bTop add.f #bIncr , *8
wGo mov.i <bBoot , {bBoot
mov.i <bBoot , {bBoot
mov.i <bBoot , {bBoot
mov.i <bBoot , {bBoot
mov.i <bBoot , {bBoot
mov.i <bBoot , {bBoot
bBoot spl bDist , pTop+pLen
mov.i <bBoot , {bBoot
mov.i <bBoot , {bBoot
djn.f bTop , {bDjn
end wGo
Having just a single LP paper looked a bit 'off', so I decided to add a boot. And when I implemented it, I tried looping the boot code to create a continuous boot. This worked pretty well. It makes sure the paper is distributed quickly around the core.
This might be something worth trying with other LP papers as well.
The LP paper I created uses two lines to copy itself in less loops (making it a bit faster) and has a mov/add.x stone inside it. The reset part is pretty nice, it doesn't use the regular mov.ab #len,#0, instead I'm looping back and subtracting the step
and length at the same time. Not sure where I based this on, it might have been brand new, correct me if I'm wrong.
As a second warrior I first wrote a oneshot, but than I found out the benchmark is actually online. So I did a quick search and, like Wayne mentioned above, I found that Eccentric worked pretty well, so I optmized that warrior instead (very last minute).
== Round 2:
The second round... is a bit of an unknown. I never created a lot of nano warriors, so I decided to do something different. I fired up some of my old Java "evolver" code. Haven't used that code in years, left two instances running for about a day and
took the result. It seems to have created two spl/mov-kind of clears, no idea how they'll stack up. No high hopes for this round haha.
== Round 3:
Using numbers -8 to 8.... this sounds like a fun challenge.
The first warrior I created was a paper/stone, because my best warrior yet has been Hullabaloo... Creating one that boots away with good constants using these restrictions sounded like a "fun" challenge.
It was quite hard to be able to create the constants, place them in the correct positions *AND* boot away the resulting paper AND stone. But I managed to create "something". I'm using a lot of DIV.X/SUB.X combinations so quickly generate some numbers
that are big enough to use as stone/paper/boot steps. I sandwiched the constant-creation and boot in between a paper and stone and managed to make it all work.
;redcode-94nop
;name Aight
;author Roy van Rijn
;strategy Just -8 to 8, we can still have a paper/stone.
;assert 1
pGo spl 7 , {3
mov }2 , }-1
bLine mov hBomb , }2
mov 3 , }-3
jmz.f -4 , *-1
hBomb dat }7 , >1
wGo div.x pGo , 1
bDat sub.x #-5 , #-3
pEnd add.a bDat , *-2
add.b bDat , bLine
sub.f bDat , dBoo
mov hBomb , {dBoo
mul.a -5 , @pBoo-1
spl }2 , {bDat
spl 1 , {bDat
spl 0 , {dRec
mov <dGo , {dBoo
dBoo spl 3 , 0
dRec mov <pEnd+3 , <dBoo
spl *dBoo , 4
pBoo jmp @dBoo
dGo spl #0 , {6
mov 5 , @hPtr
hHit add #-8 , hPtr
hPtr mov 3 , }-7
djn.f -3 , {-4
end wGo
I'm hoping a lot of people picked the 'easy' route and made a simple bomber or scanner, which often only requires one or two constants. The paper/stone should do well against both of these.
My other guess was that a lot of warriors are slow, because they have to do a lot of setup/booting. So the second warrior I created for this round is a faster bombing oneshot, based on Myrmidon. You're able to bridge gaps larger than 8 by using some
clever indirection. In this case I ended up with the following warrior:
;redcode-94nop
;name SimpleShot
;author Roy van Rijn
;strategy -8/8 bombing oneshot with SSD
;assert 1
;People might have a lot of 'boot' code, building values
;So maybe speed wins?
; setup values:
mul.x @4 , *iClr ;use indirection to access parts of the warrior
mul.a *iClr , *iClr
scan sub.f *iClr , @2 ;bombing oneshot
mov.i *iClr , }gate
jmz.f -2 , @gate
iClr jmp clear , 0
dat 0,0
dat 0,0
dat 0,0
dat 0,0
dat 0,0
gate dat 8 , 8
dat 1 , 8
clear spl #7 , 7
mov.i *gate+1 , >gate
mov.i *gate+1 , >gate
djn.f -2 , }clear
end scan-2
The oneshot quickly drops some bombs, does some scanning and very early goes into the SSD clear, it was hard to create "good" constants and/or try a lot of them haha.
== Round 4 / Final
Another conundrum, do you focus on high processes (to be safe) or do you focus on the low process side? I've decided to gamble a bit here.
The first warrior I picked is a version (again) of Myrmidon, it is a very versatile warrior that does pretty well in different settings. With a bombing oneshot you can always get lucky.
The second warrior is a bit of a gamble. When we have a lot of processes, a LP paper is useless. If we have very limited processes, a normal paper is useless. But what if we combine the two? This is something we normally don't see, but in this case,
based on the amount of processes available the "best" suited paper takes precedence. With all these papers I've ended up with "Almost a book".
I've decided to focus mainly on the bottom half of the amount of processes, hoping to survive the highest process rounds. I'm hoping that we have a few beginners joining the tournament, that might save me.
The LP paper of this warrior is very similar in design to the one above (From the Grave). Again: not sure where this design comes from, might be new. The second "normal" paper is a Sunset-variant.
I'm creating two processes and booting the LP paper away and using a tiny jump table to launch both papers. After that the processes get increased and it starts the Sunset-style paper for the cases where we have more processes available.
This warrior gets stronger the less processes there are available, so fingers crossed....
;redcode-tiny
;name Almost a Book
;author Roy van Rijn
;strategy Final entry 1
;strategy Multiple papers, LP paper and normal paper
;strategy Needs to survive, optimized for lower processes.
;assert 1
bBoot equ 1792;1385;2193
pStep1 equ 7724;5449
bOff1 equ 2957;7310;1215;1765
bOff2 equ 6024;1434;2637
pDjn equ 4071;6645
pStep2 equ 6853;4911
bOff3 equ 7132;7945;2324
; LP paper with embedded stone
pTop spl @pStep1 , >6
sub.x pEnd , pTop
mov.i {bOff1 , {bOff2
mov <pTop , {pTop
jmn -2 , -4
pEnd djn.f pTop , <pDjn
; Step 1: Boot the LP paper away
; Step 2: Start the LP paper
; Step 3: Start normal paper (for more processes)
dat 1 , pTop+3
start spl 1 , bBoot+2
mov.i <bPtr2 , <bPtr1
mov.i <bPtr2 , <bPtr1
mov.i <bPtr2 , <bPtr1
spl @start-1 , }0
bPtr1 mov.i 1 , #bBoot
bPtr2 spl 1 , pEnd+1
pGo spl pStep2 , {3
mov }2 , }-1
mov.i 3 , <bOff3
mov.i *3 , }-3
jmz.f -4 , *-1
dat }1 , >1
end start
== Conclusion
Awesome to be programming CoreWar again, haven't done this in a while (hence the name 'From the Grave').
Good luck to all, see you in the livestream/chat!
--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)