RedCode

Like every other redcoder, i also gather great quantities of different projects that are either
a) Not very succesful,
b) Good ideas that just wont work, or
c) stuff that i want to release for other reasons.
I will keep on this spot code that fits on either of category, and maybe even some other useful stuff.

  Monowire's story

As to begin with, i will be releasing the warriors i have sent at beginnerhill on SAL


;redcode
;name Test3
;assert 1
step1 equ 3456
step2 equ 1234
step3 equ 5678


spl 2
spl 1
mov.i <2, {2
mov.i <1, {1
spl paper+4000+6, paper+6

paper:  spl @0, >step1
	mov.i }-1, >-1
	mov.i }-2, >-2
	spl @0, >step2
	mov.i }-1, >-1
	mov.i #step3, }4001

Comment: Test3 is a weak paper/imp, using abnormal imps. It was original part of a experiment, hence the name. Its scores were interesting as it gets beaten easily by any "real" paper, but is capable of beating some scanners. The stepsizes are not the same, as you might guess.


;redcode-94b
;name scizzory
;author Miz
;strategy big scanner
;strategy 124 wilkies 103 wilfiz
;strategy for filling b-hill
;assert 1
step equ 28
gap equ 8


ptr: dat 100, 100+gap
  dat $0, $0
dat >5335, >15
s: spl #step, #step
mov.i -1, >ptr
djn.b -1, lenght

add.f s,  ptr
scan: seq.i *ptr, @ptr
slt.ab #32, ptr
djn.b -3, #4500
lenght: add.ab #12, #0

sub.ab #12, ptr
jmn.b -8, -3
nop >-8, {-9
jmp -11
end scan

C: I am going to regret publishing this little behemot. It originally started as an experiment to copy Recon 2's ability to selfmutate the spl-wiper into a dat-clear at end of the match. I did have a small success, but the mutation went horribly wrong and scizzory lacks the ability to finalize the deadly blow to stunned opponent. Also, than nop/jmp should've been replaced with only one instruction to save space.


;redcode
;name Sugartooth
Assembled code:
ORG	16
SPL.B	#	0,	$	0	 
SPL.B	#	0,	#	0	 
SPL.B	#	0,	#	0	 
SPL.B	#	0,	#	28	 
MOV.I	$	2,	>	-1	 
JMP.B	$	-2,	$	0	 
DAT.F	$	0,	$	0	 
DAT.F	$	0,	$	0	 
DAT.F	$	0,	$	0	 
DAT.F	$	0,	$	0	 
DAT.F	$	0,	$	0	 
DAT.F	$	0,	$	0	 
DAT.F	$	0,	$	0	 
DAT.F	$	0,	$	0	 
DAT.F	$	0,	$	0	 
JMP.B	*	18,	$	0	 
ADD.F	$	3,	$	-1	 
MOV.I	@	0,	@	-2	 
JMN.F	$	-2,	$	15	 
SPL.B	#	2376,	#	-2376	 
MOV.I	$	2,	>	-23	 
DJN.F	$	-1,	>	-24	 
DAT.F	$	0,	$	35	 
DAT.F	$	0,	$	0	 
DAT.F	$	0,	$	0	 
DAT.F	$	0,	$	0	 
DAT.F	$	0,	$	0	 
DAT.F	$	0,	$	0	 
DAT.F	$	0,	$	0	 
DAT.F	$	0,	$	0	 
DAT.F	$	0,	$	0	 
DAT.F	$	0,	$	0	 
DAT.F	$	0,	$	0	 
JMP.B	$	-33,	#	1	 
END

Maybe i should start storing more of my code, i dont have sugar either has non-assembled code.. But to comment, this is a vampire throwing fangs in a mod-8 pattern. It uses indirect fangs to get some resistance against anti-vamp attacks, and once either a) process enters the pit or b) Fang is attacked by anti-vamp attack , the jmp -33 at the bottom is erased and vampire starts a d-clear. Opponent (in theory) is killed at last when the pit has finished its suicidal coreclear. (D-clear doesnt damage the pit). Vampires them selves are hard to make and this one turned out to be another failure at the bottom of the beginner-hill. Oh well, free cannonfodder for other programs.


;redcode
;name Table scan
;assert 1
org scan
warrior: warrior: jmp #0, <-5
 for 50
 $0, $0
 rof

scan: sne.i {table, <table
djn.f -1, -1
jmz.b warrior, @scan
targ: add.f *scan, scan
mov.i fall, }scan
mov.i fall, >scan
djn.b -2, #10
jmp warrior

fall: dat #0, #1
 N for 21
  spl #-100+N*350, #2*N*175
 rof       
table: spl #-100+22*350, #2*22*175

Very generic example of table scan that i did when testing making one. Needs better attack.


;redcode-94b
;assert 1
;name Stoney the second
;author Miz
;strategy Q^3 -> Stone w/ Imps, no boot.

step equ 1459
stone:  spl #0
	mov.i 3, step
	add.ab #step, -1
	djn.f -2, <7000
	dat >-1, }1

for 20
dat $0, $0
rof

istep equ 2667
ilaunch: spl #0, >1
	 mov.i imp, imp
	 add.a #istep+1, 1
	 djn.f imp-istep-1, <3000
	 imp: mov.i #0, istep
for 15
dat $0, $0
rof

start: spl 1, <2000
       spl 1, <4000
       spl 1, <6000
       djn.b stone, #7
       jmp ilaunch, <-3333
for 5
dat $0, $0
rof

qf     equ     qKil
qs     equ     200
qd     equ     4000
qi     equ     7
qr     equ     6
qBmb     dat       {qi*qr-10, {1
qgo      seq       qd+qf+qs, qf+qs
         jmp       qSki, {qd+qf+qs+qi+2
         sne       qd+qf+5*qs, qf+5*qs
         seq       qf+4*qs, {qTab
         jmp       qFas, }qTab
         sne       qd+qf+8*qs, qf+8*qs
         seq       qf+7*qs, {qTab-1
         jmp       qFas, {qFas
         sne       qd+qf+10*qs, qf+10*qs
         seq       qf+9*qs, {qTab+1
         jmp       qFas, }qFas
         seq       qd+qf+2*qs, qf+2*qs
         jmp       qFas, {qTab
         seq       qd+qf+6*qs, qf+6*qs
         djn.a     qFas, {qFas
         seq       qd+qf+3*qs, qf+3*qs
         jmp       qFas, {qd+qf+3*qs+qi+2
         sne       qd+qf+14*qs, qf+14*qs
         seq       qf+13*qs, <qTab
         jmp       qSlo, >qTab
         sne       qd+qf+17*qs, qf+17*qs
         seq       qf+16*qs, <qTab-1
         jmp       qSlo, {qSlo
         seq       qd+qf+11*qs, qf+11*qs
         jmp       qSlo, <qTab
         seq       qd+qf+15*qs, qf+15*qs
         djn.b     qSlo, {qSlo
         sne       qd+qf+12*qs, qf+12*qs
         jmz         start, qd+qf+12*qs-qi   
qSlo     mov.ba    qTab, qTab
qFas     mul.ab    qTab, qKil
qSki     sne     qBmb-1, @qKil
         add        #qd, qKil
qLoo     mov.i     qBmb, @qKil
qKil     mov.i     qBmb, *qs
         sub.ab     #qi, qKil
         djn       qLoo, #qr
         jmp         start, <-4000
         dat       5408, 7217
qTab     dat       4804, 6613
dSrc     dat       5810, qBmb-5
end qgo

Stoney the second is nothing strange - basic fourliner stone that mutates into coreclear, imp-pump that gets damaged after some time, Q^3 in the beginning and no boot. (Would have taken too much time to optimize). Was coded very quickly, and scores nicely, maybe because from lack of Stone/imps on the beginner-hill.