🚀 go-pugleaf

In article <70624@hydra.gatech.EDU> gt6525c@prism.gatech.EDU (Damon Gallaty) writes:
>I was just curious about people's ideas on bombing. If you're going to
>bomb someone, why use decrementing, jmp's to slave pits, and such? WHy
>not just bomb a typical DAT and destroy them right there? It seems
>to me that keeping them alive longer just prolongs the battle and
>gives them a slightly better chance to survive. The only use I see
>for using anything but DAT's is perhaps for bombing someone's data
>area with decrements, to try to make them destroy themselves. Perhaps
>I am missing something. Anybody have any helpful insight on this?

I can think of a couple of reasons right off the bat... It is easy 
enough to bomb somebody, and hope they die... but keep in mind, they
are also trying to survive.  What the enemy programs do is split off
a bunch of processes that search for the enemy and also watch each 
other's back.  If one of them gets bomb, patch it up and maybe try
to find out where that bomb came from...  So, what you want to do
as a programmer is to out-smart this strategy.

One way to do it is to bomb using SPL statements instead of DAT's
and then after a period of time of this type of bombing, switch over
to the DAT type bombs.  If the enemy executes the SPL instruction,
then all of their processes, not just that one, will slow down...
This means that the processes can't watch each other's backs as
easily and as fast, and if they do detect a bomb, they can't react
to it as fast.  This will give you time to bomb the rest of the
core and maybe squash all of the slow processes.

Another type of program is the vampire slave bombers.  You would 
bomb with JMP statements in hopes that the enemy will execute it and
jump to one of your home-made bombing routines.  Since the enemy will
probably have lots of processes watching each others back, what would
be the perfect weapon but to have one of its own processes searching 
and destroying its own brethren?  And just as a safe guard, you would
put a SPL 0 or something in the bombing routine to slow the enemy 
program down, the bombing process would pick up more speed as more 
processes get captured, and the other processes would get slower and 
slower, reacting very slowly to any pending attack.

Yet another type of stategy is the decrement type attack.  The basic 
idea here is to merely confuse the enemy program, and all of its 
processes so that it cannot see an oncoming attack, or to throw off
the enemy attacks since you probably changed its bombing step and 
bombing destinations...  You would attempt to modify the enemy program
enough that it would just curl up and die on its own, without much 
work on your side.  Unfortunately, this style of attack doesn't work
very well, since you can confuse the enemy, but you could also by chance
make it easier for the enemy to find you...  Now-a-days, people are
using decrements for other reasons as part of an attack strategy, and 
not as *the* attack strategy.

Well, hope this helps.  There are lots of reasons why a simple DAT type
bombing program will not do the job.  The basic idea is that the enemy
knows you are looking for it.  It may be looking for you, but it will
be watching its own back as well.  You must find a way to stop the 
whole enemy program at one time.  Killing just one process is just like
stirring up a hornets nest.  What would happen if you got them angry...
Stepping on one isn't the answer, but spraying them with Raid might be
in the long run... ;-)

Catch you later!
Scott Adkins
sadkins@ohiou.edu
-- 
Don't forget to have a good day!  Some people never remember this.              -------------------------------------------------------------------------------      Scott W. Adkins                   Internet: sadkins@ohiou.edu             
     ~~~~~~~~~~~~~~~                             ak323@cleveland.freenet.edu     (Flame me, not the net!)                Bitnet: adkins@ouaccvma.bitnet         -------------------------------------------------------------------------------
                           Ohio University of Athens                                                    Home of the Great Hocking River