Vampire Style (Earlier)

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 transferred 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
	      JMP trap
	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.

Vampire Style (Modern)

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
	      JMP -2
	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: Sucker, PitTrap, Twilight Pits, and many others.