What's here are all of the warriors I have published - the source of each is available from Planar's page, or follow the source link from each warrior. This list is in the order that the warriors were written, which is not quite the same as the order in which they were published.
My first moderately successful warrior, this one-pass scanner -> spl/dat coreclear was heavily based on the scanner from Core Warrior 2 and sat nicely atop the Beginner's Hill until it died of old age.
Looking back at it now, an a or b-driven spl/spl/dat coreclear as opposed to the stargate clear used here would probably help (see Core Warrior 44 for a descripition of the most commonly used clears), an instruction or two could be shaved off and the scanner could be used to maintain an imp gate.
This is basically a improved version of Syzygy: the scanning speed has been increased to 80%, and it has generally been made more effective. This can be seen by its higher placing on Mount Olympus, Planar's Hill which has every ever published warrior on it, on which it is about 100 places higher than it's older brother.
I always have thought that vampires are a nice idea, and have tried quite a few different ones over the course of my Core War career; this is rather different from most in that it is a scanner rather than a bomber or mixed scanner/bomber, but never actually worked very well - the vamp bomb isn't very effective against silk-type papers, and as a scanner, this tends to get thrashed by stones - I'm just not sure if vampires can really be effective under '94 rules :-( (Having said that, has anyone else noticed how effective myVamp v3.7 is against modern imp/stones?). I do have an improved smaller, faster version of this warrior which is quite a bit better, but still not very effective.
These next 8 warriors (up to Judgement Day) were my entries in Beppe's Direct Elimination Core War Tournament (BDECWT) and contain quite a lot of comments in the source already, but I'll elaborate and expand on those here
In the first round ('94 Redcode), I was pitted against David Moore, who is one of the top '88 Redcode players around, but therefore (I hoped) not very likely to produce a silk, as this requires '94 Redcode, so a simple stone should be safe. Therefore, I simply took Sapphire, one of my warriors which did OK on the beginner's hill, but isn't actually very good, changed it to 3-pt imps and submitted it - it's basically just Blue Funk's stone with a vector-launched imp. Luckily for me, David submitted a vampire and I won fairly easily :-)
The second round was under low process rules (a maximum of 8 processes and a maximum warrior length of 200) and I was against Magnus Paulsson. At this stage, my reasoning went something like this: "You can't do a paper with only 8 processes, so scanners are out (they've got nothing to beat), so stones are the order of the day". Therefore I created a fairly complex stone, which switches into a coreclear as soon as one of its bombs is executed, but this turned out to be a bit of a disaster, as Magnus submitted a stone with an airBag-type check routine which easily thrashed mine once it went into its clear :-(
Having said that papers were out under low process, when I got all the warriors from Beppe's tournament (90kb .ZIP file), the top two warriors in Round 2 were both paper-based. This led to a period on the Low Process Hill in which papers did well, until people developed scanners to beat them.
In round 3 using '88 Redcode, I was pitted against Myer Bremer (apologies for the mis-spelling in the source code) - as you can see from the source code, I wasn't expecting much from this round, having never programmed in '88 before, so I created a very simple vampire, which I hoped would be more effective due to the lack of silks. As it turned out, Myer submitted a one shot bomber/scanner, and I won by a mile (>90% wins!) :-)
Looking at it now, and having run it off against various other warriors, I think the main problem with BftG is that it just cannot kill imps - I didn't know enough '88 Redcode to create a two-pass clear, so BftG just has a dat coreclear; watch out for a new version sometime soon. (maybe)
Round 4 was the multi-warrior round, in which the two submitted warriors fought along with Torch t18 and Tornado 3.0 - both incendiary bombing stones -> coreclear. My opponent was John K Lewis, and a quick bit of testing revealed that the easiest way to score points was to let Torch and Tornado do all the dirty work of actually killing the opponents, and just try and survive. My first idea was to use a Timescape-based paper, as this would also get some wins, but it got easily beaten by Paul Kline's Die Hard, as this can easily survive a standard spl/spl/dat coreclear (but see Paul's article in Core Warrior 52 on killing Die Hards with a standard d-clear). I thought that everybody else would come up with Die Hards as well, and predicted quite a few ties...
In the end, JKL submitted a simple paper which I beat fairly easily :-) and there weren't that many Die Hards around (3), but there were also a lot of papers, and a lot of imps, which both work on the same general 'survival' tactic.
The last round before the knock-out stages was Round 5, in which a warrior had to fight in all four of the previous environments, but with one catch: only 40 lines of code were allowed in total. Being the sneaky gits that we are, everyone thought of ways to 'cheat' and get round the 40 line limit (basically involving creative use of for/rof), but being honourable people really, none of us did. The general reasoning for my warrior went something like: Well, I want Die Hard for the multi-warrior part, so that's in and should get me some points. I'll also use Die Hard for the '94 part (just so I won't lose). Right, that leaves '88 and low process. I still haven't managed to come up with a decent '88 warrior, so I'll write another sort of paper- launched imp so I don't lose (again). In low process, I finally settled on a 60%c stone -> coreclear, which I thought would get me the wins I needed with all those ties in the other rounds.
Well, that was the theory... my opponent, Steven Morrell, submitted a pure stone and let that play in '94, low process and multi-warrior (thus giving me '88 for free :-)). This lost to Die Hard in '94, but not by that much, but as the stone suicides before 80000 cycles, got thrashed in multi-warrior (304-31) as it couldn't kill everything before suiciding. I got 100% wins in '88 (after counting on getting 100% ties), so the fact that I got hammered in low process didn't really matter. So, almost a complete reverse of what I expected, but I won anyway and went through to the semi-finals :-)
The semi-finals, in which I fought Franz, was normal '94 redcode, but we
were both allowed to choose one instruction, one addressing mode and one
modifier to ban. At the time, Franz was the 'paper king', having the only
(non-imp) replicators on the '94 Hill, so to stop him creating any more papers, I choose to ban
spl; for the addressing mode, I chose > (post-increment b-field indirection),
which doesn't really do much, and neither did my choice of modifier, .ab.
Franz, hoping to make a paper, chose to ban seq, $ and .f. Probably the most
interesting one here is $, as this means that all references have to be
through a pointer. After all that lot, we ended up in a one-process, no direct addressing type
game, and we both created stones based on Tornado. However, Franz's was smaller and beats mine
about 53% of the time... but I got lucky in the 200 round fight and won
:-)
The final was played under normal '94 rules, no bans, just pure Redcode. My
opponent was Ian Oversby, who had won every single round he had played, and
was also doing much better on the '94 Hill with his stone/imps (and other things) than I had
ever done... I was pretty worried about his stone/imps, but Ian is also
capable of writing scanners and papers, so I really didn't know what to write.
I tried creating a pspaced paper/scissors/stone, but that was being easily
beaten by most things, so I didn't want to submit that. In the end, I just
submitted another Die Hard variant, but I did stick Probe's qscan on the front of it to try and get some
wins. In the end, Ian submitted another qscan -> Die Hard and we ended up with a
result which looked like: Played 200, Ties 200 :-|
After the slightly silly result of the 'final', Beppe declared a replay,
but this time under low process rules where we couldn't tie nearly so
easily... I still thought that stones where the order of the day under low
process, but these can be easily thrashed by a bomb dodger, so what I
submitted was a pspaced bomb dodger (heavily based on Clisson, which I took
from Gem of the Ocean) and a one-pass scanner -> dclear (in case Ian submitted a
dodger himself). Ian submitted a pair of Torch-based stones, which my dodger beat (quite) easily - the
scanner was obviously dead weight in this case, but I was happier that it was
there. So this means that I won Beppe's tournament :-))) At the time I wrote this, stone/imps, such as Gigolo and Nine Seven Six were dominating
the '94 Hill,
especially with qscans attached. Therefore, rather than trying to beat them, I
decided to join them and write a qscan -> stone/imp. The qscan was taken from
Probe, whilst the
stone was an original design which bombed at 66%c (33% bombs, 33% increments)
and then switched to a 33%c forward core-clear (almost - it transposes
addresses in a linear fashion). This made it onto the Hill, and was at one stage as high as 8th place, but
never did as well as the other stone/imps and fell off fairly quickly, getting
too many losses to survive (around 35%, as opposed to 25% for the other
stone/imps). Having miserably failed to join the stone/imps at the top of the hill, I
decided to beat them instead :-). Trouble was, I didn't have anything
which did this really effectively... eventually, I stumbled across Ian
Sutton's Oblivion,
which contained a one-shot scanner -> stargate clear, which did pretty well
against those stone/imps. I kept the one-shot -> stargate design, but recoded
it, messed about with the constants for a bit, and then submitted it to the
hill. It did, well, OK. Climbed as high as 14th place at one stage, but then
crashed fairly rapidly down and off the hill after about 20 challenges. There
were just too many things which were good against one-shots on the hill
:-( I still liked the one-shot scanner that I had used in One Shot,
but realised it needed some backup if it was going to make it up towards the
top of the hill. Most of the things that were giving One Shot a real hammering
could all be beaten by a simple stone, so some testing went on to find the
best. In the end, I was back with Ian Sutton's Oblivion, but this time
taking the Carbonite component. I made a couple of minor changes, and put
together a p-switcher to bring both components into play. This turned out to be my most successful warrior to date, entering at
second on the '94 Hill, but never reaching first :-( It very rapidly crashed
down to sixth, then slowly down to 13th, but then underwent a revival back up
to 4th at one stage, went into free-fall, bounced around a bit more and then
finally got kicked off at an age of 79. For anyone with a life who doesn't recognise the name, it's the code
number of the Starship Enterprise in Star Trek (to be more precise, NCC-1701-A
was the replacement ship after the first one was destroyed in the third
movie.) A quick bit of discussion on rec.games.corewar
suggested that one-shots could do quite well on the Tiny Hill (core size and max
processes 800), so as One Shot had been moderately successful on
the '94 Hill, I
decided to try my luck on the Tiny Hill. Probably the most distinguishing
thing about this warrior is that it is booted (a luxury in 20 instructions!),
which helped to bump up its wins against other one-shots, such as Brian
Haskin's musket loader v2. This entered the hill in 9th position, but slowly made its way up, and is
currently still near the top of the Hill - not too bad for a warrior that took
about 20 minutes to write, and most of that was trying to get the constants
right, so that it didn't trigger on its own djn stream too early :-) As mentioned in my comments to MI5 above, after BDECWT round 2, I thought that a
paper could do well under low process rules, so when the Low Process Hill started at Pizza, the first warrior onto the hill was
this paper. All it is is a loop to copy the warrior, and some other code to
reset the pointers and start the new copies going. The original features of
this warrior are firstly that it starts with 8 copies ready to go in the code,
giving a very fast start up time (also, the copies have different constants,
which improves the spread of warriors), and that it splits back to itself,
whilst jumping to the new copy, leaving decoy behind to foul scanners. Paper 'LP' has now been kicked off the LP Hill: it's main problem was
that it didn't get enough wins, which is (partially) corrected in its younger brother,
Paper 'LP' II. Having developed Paper 'LP', I discovered I didn't really have
any warriors which could kill it... so I created Inferno 1.8 - it throws
around mov.i step,1 and jmp.a #1,1 bombs using the Tornado engine to stun
things and stop clears before switching to a d-clear to clean up. This was
moderately effective against papers (around one third wins against Paper 'LP'),
and also beats scanners nicely as well. It did pretty well on the
LP Hill
for a while, but then fell off as papers started to dominate the Hill. This is very similar to Paper 'LP', just with a couple of small
changes to make it more difficult for other warriors to 'jump into' the code
and begin executing it - this had the effect of increasing the number of wins
by around 30%, whilst only increasing the losses by a couple of %, thus
sending this one further up the hill. Paper 'LP' II remained at the top of the hill for a good while, and has
hardly been out of the top ten for it's entire stay on the hill (until recently,
when a whole load of scanners/vamps have appeared and killing it quite nicely
:-() After Ian Sutton published Completely Indestructible,
another Low Process paper, I thought I could make it quite a bit better - it
ended up only having the 2 line copying loop the same as the original, but
there goes. Eventually, I trimmed it down to just 5 lines, which (I think) is
the smallest one-process paper written (so long as mov.i 0,1 imps are
excluded)
Unfortunately, this never did as well as either Paper 'LP' or
Paper 'LP' II, and I killed it very quickly after it appeared on
the Hill. At the time I wrote this, papers were beginning to dominate the Low
Process Hill, and I
didn't have anything which could really trash them. So, brute force was
applied: I ran off 100 warriors on my hard disk against Paper 'LP' II under Low Process rules, and eventually found that Iron Gate was very
effective (around 70% wins), so I created a spl-jmp bombing scanner in the
same vein. This was remarkably effective, entering the hill in first place with a 20
point lead over second place, but a couple of papers soon dropped off the
hill, and it lost its lead. After NCC-1701-A was kicked off the Hill, I made a
couple of minor changes (sped up the one shot and improved the stone's boot
routine) and also changed the pswitcher to the P^2 switcher (see
Core
Warrior 58). This made in more effective, but it still didn't last that
long on the Hill. Another pretty unsuccessful pspacer, this is just Big
Brother with an added paper component. Even less effective :-(.Inferno 1.5
The Survivor II
Judgement Day
Stone One
One Shot
NCC-1701-A
One Shot 'T'
Paper 'LP'
Inferno 1.8
Paper 'LP' II
Tribbles
Romulan Warbird
Big Brother
Bigger Brother