Vampire warriors, rather than throwing DAT bombs, they throw JMP pointers
into the core. These pointers point to a placed trap. Once any enemy process
steps on one of those pointers, it is immediately transfered to the trap and
forced to do the slave works for vampire warriors.
Earlier incarnation of vampires worked like below:
;name Vampire 1
const EQU 2365
loc MOV ptr, ptr ; throw JMP pointer to core
ADD #const, ptr ; update pointer
SUB #const, loc ; update location
JMP loc ; loop back
ptr JMP @0, trap ; the pointer weapon
trap SPL 1, -100 ; this is where the pointer points to
MOV bomb, <-1 ; core-clear
bomb DAT #0
This warrior throws pointers one for every 5 instructions (modulo 5).
The constant has been chosen to work well with
modulo 5. Note that the next pointer and the
next location are updated by the same constant but reversed in sign.
The trap here simply forces all processes in it to accumulate more processes
and to execute core-clear. The standard
self-splitting is not used here so that
the slavers can execute self-destruct once they finish core-clear.
Modern vampires use more effective procedure:
;name Vampire 2
const EQU 2365
SPL 0 ; self splitting
vamp MOV ptr, @ptr ; throw pointer
ADD data, ptr ; update pointer
DJN vamp, <2339 ; loop back + non-lethal attack
ptr JMP trap, ptr ; pointer to...
trap SPL 1, -100 ; ...here
MOV data, <-1
data DAT #const, #-const
The only changes here are the main component (vampire) and the pointer
structure. Pointer is now updated at once. With this change, it permits
self-splitting mechanism for harder
shell (protection). Another improvement is that the vampire throws pointers
faster than before. The gained speed is approximately 30%.
Samples of vampire warriors are:
Twilight Pits, and many others.