[MUD-Dev] Re: Less numbers, more roleplaying.

[Adam Wiggins]

[Jon Leonard:]
> On Thu, Nov 27, 1997 at 11:28:04AM +0000, Richard Woolcock wrote:
> > Adam Wiggins wrote:
> > > [Richard Woolcock:]
> > > > > of winning.).  A T-Rex just sees 100-200 pound of fresh USDA grade A
> > > > > human.
> > > >
> > > > So called 'Intelligent' mobs should go for the weakest opponent.
> > > 
> > > They should?  I consider myself intelligent, yet I always consider
> > > the most dangerous opponent to be my first target in a combat
> > > situation.
> > 
> > Hmmmm I'm not sure now.  Certainly, you'd be more worried about the
> > most dangerous opponent, but equally, which would you rather have?
> 
> [scenarios deleted]
> 
> I worked out the math behind this a while back, and given some assumptions,
> it doesn't matter what order.
> 
> If you assume that you have several opponents who:
> 
> 1) Fight to the death
> 2) Always do the same amount of damage, while living
> 3) Do damage in proportion to what it takes to kill them
> 
> Then it doesn't matter what order you attack them in.
> 
> 
> To see why, consider a graph of damage done over time:
> 
> (example of 2 1-unit attackers and a 2-unit attacker)
> 
> +---+         +-+           +-+
> |* *|         |*|           |*|
> |   |         +-+---+       +-+-+
> |* *|    vs.  |* * *|  vs.  |* *|
> +---+-+       |     |       +---+---+
> |* * *|       |* * *|       |* * * *|
> +-----+-+     +-----+-+     |       |
> |* * * *|     |* * * *|     |* * * *|
> +-------+     +-------+     +-------+
> 
> time ---->
> 
> Each order has 11 *'s.  This is because no matter what the ordering, opponents
> will always be doing damage in the lower left triangle, and each individual
> will add another triangle in the upper right.  Rearranging the added triangles
> doesn't change the area (total damage).
> 
> If the assumptions don't hold, then strategy emerges.

Heh.  I should think our entire purpose, as game designers, is to make
sure that stuff like the above *never* happens. :)

> If your opponents may not fight to the death, then killing one quickly may
> cause some to run away.  Likewise, if you can flee, killing some before you
> run makes the next fight easier.

If you have semi-sentient opponents (either intelligent beings or AI
programmed to act semi-intelligent), you can also bring in things like
fear (a display of raw carnage of a few members may cause the entire
group to break into panic), surprise (using your secret weapon against
some grunts in the front line is rather a waste; if you've only got
one chance to use a certain advantage, you want to hit them where it's
going to count), and bluff (making them believe that you are more powerful
than you actually are).

> If damage dealt reduces in proportion to heath, then it really doesn't matter
> who you hit when -- there aren't any extra triangles as above.  If slower
> or faster, then you need to kill quickly, or hit everyone, depending.

Here it depends on method of attack.  On your typical mud, smacking
a mage once will knock him out of that devestating spell, while the
same attack on a fighter will just cause her to grunt and keep swinging
at the same rate.  In some cases, though, it may be the other way around -
the fighter's strength goes down in proportion to their wound level, while
the mage can still cast at full strength as long as they are alive.

> If opponents aren't all equally effective in proportion to their health,
> then kill the flimier/more dangerous ones first.

Which is usually the way it works.  Primary example being the wimpy
mage casting spells of mass death, or the thieves with no hitpoints but
a big-ass backstab.  Of course, it's not always quite that straightforward;
in many cases taking out the cleric first thing will mean that the group
disintegrates as there is no healing.  Naturally this is all highly
dependant upon how the different character abilities actually work.
If clerics can't heal until after the battle, taking them out is
virtually pointless.

> For programming less intelligent monsters, I'd recommend having them pick
> an opponent at random, and then try to finish them off.  This makes any
> strategy attacking them risky for an individual.

A silly mud I used to play a while back put in code to have the creature
try to switch to whoever was most wounded (as in, % of hitpoints).
Very simple, but it made many of the creatures harder by an order of
magnitude, as well as making them seem slightly less like lumps of clay.
Amazing what an affect a small change like that can have - imagine some
serious strategy programming.