These are all the articles I had saved up through June 23. After that, I was enjoying my summer vacation. (School resumed the last part of September.) I had removed the news headers from the files for the articles saved during the first couple of weeks. I sorted them as well as I could using their file-dates. ********************************************************************* Article 1044 of rec.games.corewar: Newsgroups: rec.games.corewar From: stst@vuse.vanderbilt.edu (Stefan Strack) Subject: Sucker 3 Message-ID: <1992Jun5.062117.19851@vuse.vanderbilt.edu> Sender: news@vuse.vanderbilt.edu (News Manager) Nntp-Posting-Host: vuse2 Organization: Vanderbilt University School of Engineering, Nashville, TN, USA Date: Fri, 5 Jun 1992 06:21:17 GMT Lines: 42 Sucker 3 has been floating around the top of the standard hill for a while now, so I guess it's time to post the code. It is a self-splitting vampire with a standard jump to a core-clearing pit that sacrifices speed for robustness to SPL and DAT bombs. Improvements with respect to Sucker 2 are: 1) a much-denser, mod-2 bombing pattern. The JMP bomb will hit the bombing loop only after every other core address has been covered. Interestingly, while the bomb increment of 34 assures a very even spread, it is neither fibonacci a la Andy Pierce, nor remotely optimal by Nandor Sieben's s(a) criterion. 2) no DAT #0,#0 spacer between the bomb loop and the slave pit. Since KotH initializes core with DAT 0,0 since recently (thanks to Andy for finding out), spacers will attract CMP scanners. Enjoy, Stefan (stst@vuse.vanderbilt.edu) ;redcode verbose ;name Sucker 3 ;kill Sucker ;author Stefan Strack ;strategy Self-splitting, pattern-bombing vampire ;strategy 2: with confusion ;strategy 3: merger of Union and Sucker: much denser, mod-2 bomb-pattern ;strategy Submitted: @date@ mark equ start-1-4+10+44+350+44 ;development history mess jump jmp clear-mark,mark start spl 0 loop sub clear,jump ;'jump' will land here after 12,000 cycles mov jump,@jump djn loop,<4003 ;mutagenize core/confuse scanners clear mov 34,<-34 ;entry for captured processes spl clear jmp clear end start Article 1050 of rec.games.corewar: From: ajpierce@med.unc.edu (Andrew Pierce) Newsgroups: rec.games.corewar Subject: Re: The fastest possible scan ? Message-ID: <1992Jun6.160520.2929@samba.oit.unc.edu> Date: 6 Jun 92 16:05:20 GMT References: <3971@wet.UUCP> <60092@cup.portal.com> <1992Jun5.162347.16354@dcs.glasgow.ac.uk> Sender: usenet@samba.oit.unc.edu Organization: UNC-CH School of Medicine Lines: 15 Nntp-Posting-Host: salvo.med.unc.edu In article <1992Jun5.162347.16354@dcs.glasgow.ac.uk> fraserc@dcs.glasgow.ac.uk (Campbell Fraser) writes: >In article <60092@cup.portal.com>, Ordania-DM@cup.portal.com (Charles K Hughes) writes: >> Right now the best scanner can scan 2 locations in 3 cycles. Using >It's possible scan (2x-1) locations in x cycles with the following - As has been posted to the net already (I thought it was by Campbell Fraser but maybe I'm wrong on that) it is possible to scan three locations in three cycles with something like: add offset,1 cmp a,b slt #len,-1 ;self protection jmz -3, Sender: news@vuse.vanderbilt.edu (News Manager) Nntp-Posting-Host: vuse2 Organization: Vanderbilt University School of Engineering, Nashville, TN, USA Date: Tue, 9 Jun 1992 06:14:15 GMT Lines: 151 [This is quite straightforward (you might say trivial), but it hasn't been said before. If you hate lengthy posts, hit 'n' now.] What factors influence warrior performance? Code size, scan/bomb/copy speed and well-chosen constants have been discussed before, but defensive measures have received little attention so far. The following is an attempt at estimating the robustness of stationary programs to single hits by various bomb types. An analysis of robustness could help in program design: adding an instruction that increases robustness should be better than adding one that decreases it. But it can also be used in choosing a bomb type that is most deadly against a certain type of opponent. 1) Warriors: This discussion is limited to stationary programs with a single body of code. While it could be easily extended to multi-partite programs of the QUARTER-type (many dwarfs distributed in core), self-replicators are more difficult to analyze, since their ability to cope with a single hit depends on how much they have replicated. 2) Bombs: For simplicity, only single, overwriting hits are considered here. Of the numerous possible bombs, I will limit myself to 4 "typical" cases: DAT 0,0 SPL 0,0 JMP 0,0 JMP pit,ptr ; jump to slave pit 3) Scenario: The warrior to be analyzed is in the mid-phase of play; any initialization code has been executed, and finishing code (e.g. core clearing) is yet to be executed. The warrior receives a single hit by one of the above bombs. The opposing program is considered to be efficient, i.e. it will be able to finish off the incapacitated warrior at a later stage by, e.g. clearing core. 4) What is analyzed: The bomb impact is scored for each line of code and each additional core address that can influence the program's viability. Excluded from the analysis are spacer instructions. Included are DAT statements that follow an "open loop" beginning with a SPL 0,0 instruction. Robustness scores are added for each of the 4 bombs and for all of the addresses considered, and normalized by dividing by the maximum possible total score. 5) Scoring: I use an arbitrary scale of 0 to 3 to quantify bomb robustness: 3: a hit at this address has little or no impact on the program's performance, i.e. it can still win 2: the program's performance has been compromised, but it can still win (although it probably won't in practice) 1: a win is extremely unlikely, but a tie is still possible 0: the program dies, or is compromised enough not to resist core clearing at a later stage Obviously, these scores are subjective and largely depended on the efficiency of the opponent, game stage, the distance between opponents, etc. Also, assigning scores requires a more than superficial idea of how the code works. 6) Examples: a) generic dwarf DAT 0,0 SPL 0,0 JMP 0,0 JMP pit,trap loop add #3044,1 0 0 0 0 mov bomb,bomb 0 0 0 0 jmp loop 0 0 0 0 bomb dat 0,0 ;(implicit) 3 1 1 3 Being hit by any of the 4 bombs at the first three instructions is certain death. The impact of hitting the bomb address depends on the bomb type. The robustness is calculated by adding up all numbers (8) and dividing by 4*4*3=48, yielding 0.167 b) Crimp (a CMP-scanner) DAT 0,0 SPL 0,0 JMP 0,0 JMP pit,trap ret add offset,start 0 0 0 0 start cmp -284,-1 0 0 0 0 slt #15,start 0 0 0 0 count djn ret,<6223 0 0 0 0 mov bomb1,@start 0 0 0 0 mov bomb2,0.9) at the expense of a larger target size. However, one needs to be careful drawing conclusion when comparing robustness scores between different classes of warriors, since factors like speed and size are also important. -Stefan (stst@vuse.vanderbilt.edu) ********** Here is the defensive program I promised. It was written for '86 standard, 16384 cycles before a draw and a maximum of 512 process but will work for certain other powers of 2. Using <1% of processing time it performs a defence which will prevent it from executing another program's trap. The mechanism will also provide a defence against any bomb with "0" in the B-field. If the defence code gets hit first however then the defence will break down. Note: In '86 standard "spl" put the new process at the front of the queue. The best trapping mechanism was "jmp @0, " The assembler ignored the B-field of instructions which didn't use it e.g. "jmp 0, 10" would load as "jmp 0, 0" ; THE ACME TRAP COMPANY 20:September:1990 WPOS: DAT 0 WDEATH: MOV " inst. AGEN: SPL AONE AONE: SPL ATWO ATWO: SPL ATHREE ATHREE: SPL AGEN AFOUR: JMP AONE ; The last line of the main code NET: JMP @0 ONEA: ADD #3384 -2 ; These 3 lines are part of the main code TWOA: MOV 3 @-3 ; They get moved into "AONE, ATWO, ATHREE" THREEA: SUB -4 @-4 ; respectively. ; TRAP: SPL 1 ; TRAP which the enemy executes SPL -1 ; "spl 1/spl -1 is used to make them execute LOOP: MOV #666 __| /- O O idiot!" Redmond, WA 98052 \X/ | U| \| ********** ; Since I tend to think it's the smallest possible, I'm posting Vent du mont ;Sharr. It's a 3 instructions spl bomber, core mutagenizing, core clearer. It ;is currently mod 4, but I'm working on an odd step version. ;redcode verbose ;name Vent du mont Sharr ;author Pierre Dak Baillargeon ;strategy v1.0: YASB. ;strategy v2.0: Mutagenize memory. ;kill Vent du mont Sharr dist equ -6883 ; mod 4 coma spl coma, <1 ; the poison, the pointer and the core mutagenizer start add #dist, coma+1 ; change location kill mov @kill, sed.cmd sed -f sed.cmd < $1 | mail wms@iwarp.intel.com ********** This is my warrior Precipice which has been as high as two, as low as 12 and seems my best yet. Two programs are created, one a small 2 line core-clear which bombs it's ptr-so this way it doesn't clear itself. The other is a slaver which bombs w/ jumps to a two line trap which just replicates, nothing else. There are 7 processes in the slaver, which also increment the 2-liner's ptr to make it bomb more evenly. Eventually the slaver is hit and the rest of core is cleared. This program has the great advantage that part is real small and also trap is small so hard to hit. In a couple tests it was great to watch slaver get hit by a slaver and still win because of c-c! The major trouble is that if you lose the c-c you will not be able to win. I tried to fix this in Spire, Precipice 2-4, by adding delay (DJN -1 #0 instead of JMP -1) followed by a core-clear which misses both of my programs and then kills itself. Amazingly all of these have done much worse. ;redcode ;name Precipice ;author Matt Hastings start mov lbomber -4056 mov lbomber+1 -4056 mov lbomber+2 -4055 mov lbomber+3 -4055 spl -4060 25 mov trp start-3999 mov trp2 start-3998 arb mov dbomber 1151 mov dbomber+1 1151 mov dbomber+2 1151 mov dbomber+3 1151 mov dbomber+4 1152 spl 1147 spl 1146 spl 1145 spl 1144 spl 1143 spl 1142 3 jmp 1141 17 lbomber mov 3 <4 jmp -1 0 dat 0 -8 dat 0 -29 dbomber jmp 3791 7055 mov @1 <-1 add 3 -2 jmp -2 <2787 dat 948 -947 trp spl 0 0 trp2 jmp -1 0 ;lots of decoys ********** Finally RotLD has been pushed off the hill. This is my most successfull program maybe because of the robustness of a living dead. I've tried to change the code of a the living dead many times, but the result is almost always worse. I would think that dead jmp living , Date: 12 Jun 92 15:49:57 GMT References: <1992Jun10.163438.1969@samba.oit.unc.edu> <1992Jun11.000908.12293@vlsi.polymtl.ca> Organization: Wetware Diversions, San Francisco Lines: 31 In article <1992Jun11.000908.12293@vlsi.polymtl.ca> dak@vlsi.polymtl.ca (Pierre Baillargeon (Hiv91)) writes: >ajpierce@med.unc.edu (Andrew Pierce) writes: >: and then when the imp gets changed to a reverse imp, it will back up and > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >: overwrite an upstream spl 0 engine (if one exists). As an added bonus, >... > Just how do you make an imp execute backward ??? That must be one of those >'master' trick that don't get publicized .... :) The way it works is this: bombsite spl 0 coreloc1 mov -2, <3 coreloc2 mov -3, <2 coreloc3 mov -4, <1 coreloc4 dat #-5 etc. With bombsite being the spl 0 engine and the coreloc cells containing whatever code they used to have. Now, suppose that coreloc3 gets hit with the instruction "mov 0, -1". This gets executed, bombing that word onto coreloc2 and then the process that did that mov dies on the dat in coreloc4. This scenario is repeated until coreloc1 bombs bombsite. When that happens, no more processes are being split off, and the warrior dies on that dat at coreloc4. -- Stephen Beitzel -- sbeitzel@wet.com | "Happy, happy. Joy, joy." "Ownership of the above opinions | depends solely on how offended you are | Relax. Have a homebrew. by them." | Article 1129 of rec.games.corewar: Newsgroups: rec.games.corewar From: wms@iwarp.intel.com (William Shubert) Subject: Spider 2.0 Message-ID: <1992Jun19.153537.23181@iWarp.intel.com> Sender: news@iWarp.intel.com Nntp-Posting-Host: z.iwarp.intel.com Organization: Intel iWarp, Beaverton, Oregon, USA Date: Fri, 19 Jun 1992 15:35:37 GMT Lines: 176 OK, here's Spider 2.0. It's current score is 208; that's 42 points ahead of the #2 program (Brute-Force 1.2, by handicapped programmer Ray Cromwell). Hopefully now that Ray's handicap has been removed he'll write an even better program. Anyway, it's long and complex, but it's really really fun to watch against other x-hill programs if you have an interactive interface. The comments haven't been changed since Spider 1.0, so they're a bit out of date. Oh well, here it is. I hope it encourages people to try new algorithms for the x-hill. -Bill (wms@iwarp.intel.com) PS - Notice that it's exactly 100 instructions long. I'd like to make more improvements, but I'm out of room! Anybody want to expand the maximum program size? ;name Spider 2.0 ;author Bill Shubert ;strategy Sit and wait. When the enemy approaches, strike with a small and ;strategy fast vampire-trap offense. After an enemy is caught, switch to ;strategy a simple memory-clearing routine. ;strategy This is an attempt to demonstrate that an extremely complex and ;strategy long fighter can succeed in the experimental hill. Let's see how ;strategy it goes. ;strategy 1.1 mod: Spider gets bored eventually and goes on the offense. ;strategy 1.2 mod: Faster scan and sturdier clear. ;strategy 2.0 mod: Make chains of fangs so I can attack anywhere I want. ;kill Spider ;This program operates by effectively doubling it's reach by using what I call ; "fangs". A fang is the following pair of instructions: ;fang mov bite,@bite ; jmp fang ;The variable "bite" is located very far away, and is modified by a cooperating ; process which is also very far away. By putting fangs in the path of ; attacking processes, it is possible to have a 2-instruction target size ; but still have a decent amount of intelligence. The main loop is at the ; label "spider". spider loops, looking for opponents arriving from either ; side. When it sees an opponent, it goes to a routine that throws a fang ; in from of the opponent and makes a few bombing passes. After the passes ; are done, hopefully the opponent is trapped and control transfers to a ; piece of code that clears the entire core. coresize equ 7999 wdist equ 250 att_dist equ wdist-2 bspace equ 17 ;How far apart to but the bombs. bpasses equ 5 ;Number of bombing passes before giving up. passlen equ wdist * 2 / bspace ;Number of bombs per bombing pass. lohit1 equ loatt - att_dist-1 ;Position for first low bomb. hihit1 equ hiatt + att_dist-1 empty equ loatt-1 loatt mov @lobptr,@lobloc fang2 jmp loatt,<-5 fang1 mov @lobptr-loatt,@lobloc-loatt fmove dat #att_dist,#att_dist lobptr lo_nxt jmp -att_dist,#fang1 lo_jb jmp trap-lohit1,lohit1-lobloc jbmove dat #att_dist,#-att_dist lobloc dat #loatt-att_dist lokill spl loatt add #att_dist,locmp ;Move lomvlp mov #fang1-lobptr,lobptr add fmove,fang1 ;Move the first fang word. add #1,lobloc mov #fang2-lobptr,lobptr ;Move second fang word. mov #lo_nxt-lobptr,lobptr ;Set up jump to next fang. add #att_dist-1,lobloc ;Move in jump to next fang. add #att_dist,locmp sub #att_dist*2,lobloc ;Point to the next fang position. add jbmove,lo_jb slt locmp,#att_dist+1 jmp lomvlp mov #lobloc-lobptr,lobptr mov lo_jb,lobloc loklp1 add bmov,lobloc loklp2 djn loklp1,#passlen mov #passlen,loklp2 add breset,lobloc djn loklp1,#bpasses mov #jbmove-lobptr,lobptr sub #bpasses*(passlen*bspace-wdist*2)-att_dist-1,lobloc mov #empty-locmp,locmp mov lk1c,spider mov lk2c,s2 mov lk3c,s3 djn spider,kills jmp clear clbptr equ clend+1 clfrom breset dat #wdist*2,#-wdist*2 cljd equ -199 clear mov clbomb,clto-cljd ;Make sure the old "clear" is no good. mov #-cljd+20,cllpc ;Reset the clearing loop counter. mov #clear-clbptr,clbptr ;Reset the bomb location. cllp mov clbomb,hicmp-spider lk2c cmp empty-s2,>hicmp-s2 lk3c cmp empty-s3,>hicmp-s3 hk1c cmp hicmp jmp found s2 cmp hicmp jmp found s3 cmp hicmp jmp found jmp spider hifang1 mov @hibptr-hiatt,@hibloc-hiatt hibptr hi_nxt jmp att_dist,#hifang1 hi_jb jmp trap-hihit1+1,hihit1-hibloc-1 hibloc dat #hiatt+att_dist found cmp @locmp,empty ;Which comparator found the enemy? jmp lokill hikill spl hiatt sub #att_dist,hicmp ;Move himvlp mov #hifang1-hibptr,hibptr sub fmove,hifang1 ;Move the first fang word. add #1,hibloc mov #hifang2-hibptr,hibptr ;Move second fang word. mov #hi_nxt-hibptr,hibptr ;Set up jump to next fang. sub #att_dist+1,hibloc ;Move in jump to next fang. sub #att_dist,hicmp add #att_dist*2,hibloc ;Point to the next fang position. sub jbmove,hi_jb slt #-att_dist-1,hicmp jmp himvlp mov #hibloc-hibptr,hibptr mov hi_jb,hibloc hiklp1 sub bmov,hibloc hiklp2 djn hiklp1,#passlen mov #passlen,hiklp2 sub breset,hibloc djn hiklp1,#bpasses mov #jbmove-hibptr,hibptr add #bpasses*(passlen*bspace-wdist*2)-att_dist+2,hibloc mov hk1c,spider mov hk2c,s2 mov hk3c,s3 djn spider,kills jmp clear hiatt mov @hibptr,@hibloc hifang2 jmp hiatt end spider Article 1132 of rec.games.corewar: From: maniac@t-bone.cs.unlv.edu (Eric J. Schwertfeger) Newsgroups: rec.games.corewar Subject: BackFire 1.3 (warrior source) Message-ID: <1992Jun21.214637.24632@unlv.edu> Date: 21 Jun 92 21:46:37 GMT Sender: news@unlv.edu (News User) Organization: UNLV Lines: 71 Well, as promised, BackFire 1.3C missed the hill by about 2 points, so I'm retiring it until a better idea comes along. So, Mr Cisek can breath easier, knowing that the PitTrap Killer is retired :-) BTW, I did notice PitTrap 3.1f was getting higher again before my final BackFire attempt. I really wish BackFire had done better, since I wrote it on my birthday, which also happened to be the first redcode program I wrote (someone had a demented idea for a birthday present :-) Hope I'm not a flash-in-the-pan, and this isn't the only program I ever write that survives more than 15 challenges. (Probe 6 is doing nicely, but it doesn't count). ;redcode ;name BackFire 1.3c ;author Eric J. Schwertfeger ;strategy B-Field scanner that ;strategy bombs location and @location ;strategy v1.1 tried larger jump, putzed out ;strategy v1.2 Seems like I fixed more bugs ;strategy than I have instructions!!! ;strategy v1.2b Test File, trying different bomb ;strategy v1.3 added a decoy ;strategy v1.3a moved farther from decoy (was 200, now 3000) ;strategy v1.3bc changed increment (was 13, then 39, then 411) ;strategy If this doesn't make the hill, I give up ;strategy (on BackFire, that is). ;stragety Submitted: @date@ BACK EQU 3000 WHERE EQU (LOOP-3) BOMB EQU (WHERE+2) START MOV Date: 22 Jun 92 01:30:50 GMT References: <1992Jun21.214637.24632@unlv.edu> Sender: news@vuse.vanderbilt.edu (News Manager) Organization: Vanderbilt University School of Engineering, Nashville, TN, USA Lines: 21 Nntp-Posting-Host: vuse2 On the subject of vampire killers, here's another one. "garlic" is a special purpose warrior that kills any bombing slaver 9/10 times, but is no threat to anything else. Nonetheless it achieved 81 points on the hill. Due to its small size and the linear scan, it has a good chance of finding a vampire fang before being hit. If someone wants to improve on it and make "garlic" more effective against non-vampires, go ahead. I'm not gonna do it, because I want to keep "Sucker 4" alive :-) Enjoy, Stefan (stst@vuse.vanderbilt.edu) ;redcode ;name garlic ;kill garlic ;author Stefan Strack ;strategy vampires are afraid of it ;strategy Submitted: @date@ scan jmz scan, Sender: news@unlv.edu (News User) Organization: UNLV Date: Tue, 23 Jun 92 02:51:23 GMT Lines: 39 This is the original Chaingang, that still had the BackFire code in it. It actually did a little better than later versions, but I'll post them also for simplicity ;redcode ;name ChainGang 1.1 ;author Eric J. Schwertfeger ;strategy Vampire & Vampire Hunter that ;strategy is Immune to it's own hunt ;strategy Much improved bombing thanks to ;strategy Julius Andrew Cisek (PitTrap) ;stragety Submitted: @date@ BOMB EQU (WHERE-2) WHERE JMP PIT,0 ;by adding a value x,-x, we maintain ; a proper distance such that if the instruction is moved to ; where the b field points to, the a field points back to PIT BLANK DAT #-3,#-3 LOOP ADD INC,WHERE ; JMZ so we don't leave fingerprints that JMZ LOOP,@WHERE ; BackFire or garlic will find SLT #TAIL+1,WHERE ; SLT so we don't shoot ourself JMP LOOP MOV WHERE,BOMB ; here we compute the address to blast SUB @WHERE,BOMB ; see BackFire for better explanation MOV BOMB-1, Date: 23 Jun 92 03:12:34 GMT Sender: news@unlv.edu (News User) Organization: UNLV Lines: 37 Here's Stealth Hunter 1.0 (there seems to be a problem with the constants used in 1.1). It's the only non-b-field scanner I've written, and the one serious program that doesn't go 98-2 against the programs at the top of the hill, but it also seldom beats the snot out of other programs like BackFire does, so it doesn't score high on the hill. ;redcode ;name StealthHunter 1.0 ;author Eric J. Schwertfeger ;strategy Simple, Fast Vampire ;strategy My first Non-B-Field Scanner ;strategy Again, thanks go to J. Cisek (PitTrap) ;strategy Submitted: @date@ BLANK DAT #-4,#-4 LOOP ADD INC,SRC ADD INC,DEST CMP @SRC,@DEST JMP BOMBIT JMP LOOP BOMBIT SLT #(BLANK-SRC-1),SRC ; only bomb if it's not us! MOV SRC,@SRC BLANKS SLT #(BLANK-DEST-1),DEST ; only bomb if it's not us! MOV DEST,@DEST JMP LOOP INC DAT #26,#-26 PLOOP2 MOV SRC+2, Date: 23 Jun 92 04:11:23 GMT Organization: The Voice of Fate Lines: 20 Nntp-Posting-Host: lachesis.acm.rpi.edu Here is a short, _real_ short bomber. This was the projectile in a program series named Appleseed and another named Fast Bomb. Seeing as my 3b2 doesn't yet have any sort of CW running on it, I can't tell if it ever gets to the imp, but just the first two lines works well enough. ;redcode ;name Burp ;author Jack Twilley ;strategy Simple looper start mov empty,