[MUD-DEV] Dynamic Timelines

[Travis Casey]

Tuesday, November 28, 2000, 6:17:25 PM, Lord Ashon
<ashon at wsunix.wsu.edu> wrote:

> I had an insight today.  A system of Dynamic Timelines or plotlines
> as you wish.  Where the MUD determines new plotlines for a quest.
> One of the things that players talk about all the time are wanting
> more ADMIN or GM run quest.  I was thinking what if I could design a
> system where the MUD could generate these types of quest itself?

> I should note that I am working on an Interactive Simulation, where
> there is little to no involvement from Admins or so called Wizards.
> The Goal is to Automate an evolving virtual world.  Let the players
> and the mud decide what happens.  But back to the post at hand.

> The basics for the system are quite simplistic.  The MUD Randomly
> fills in a formula and has it's quest. (Bracketed Items are
> determined by the MUD)

>   IE: [GROUP/PERSON/THING] does [ACTION] to accomplish [GOAL]

> Now this is fine and dandy.  The AI Engine I have (BBE -> Brainiac
> Behavior Engine) does this on a much simpler system.  But, My
> problem and I guess question comes down to, how does one break the
> quest down to smaller episodes?  And more importantly how does one
> automate that process?

> Take a plot-line like this: Bubba the Evil warrior decides to
> declare war on the City Bane to Capture the princess Buffy and marry
> her.

>   There are certain things that Bubba Has to accomplish:
>   - gather an army
>   - move his army across the world
>   - attack Bane
>   - Find Buffy
>   - Marry Buffy

> Breaking it down like this is above my head, so I turn to you.  =p

> Any one have any ideas or suggestions?

I've been thinking about this a lot over the last few days, so this is
going to be a long post, with a lot of thoughts.

It seems to me that there are a few things that you might want a
plot-generation system to do:

 - Creating "quests" for the players.  (I'm putting "quests" in quotes
   to indicate that these don't have to be set up like typical
   mud-style quests -- ideally, they'd be much more open-ended and
   more integrated into the environment.)

 - Generating background events involving NPCs.  Deaths, marriages,
   births, etc.

 - Making NPCs behave in a consistent way.  This requires the system
   to know things about the NPCs.  E.g., if Bubba has a goal "marry
   Buffy", then if Bubba's first scheme to do that is thwarted, it
   makes sense that he'll try another one later.  If Bubba goes after
   a different princess every few months, things will seem less
   consistent.

The first two can be handled by a simple random event generator like
the one the you've described, and ones that have been described here
before, but personally, I find the last one most interesting.  The
question, then, is what kind of information would we need to keep
about NPCs to make this work, and what do we do with it?

Let's start with the information.  It seems to me that we need at
least two types of information about NPCs:  attitudes and
capabilities.

Attitudes tell how an NPC feels about things.  Some attitudes may
stand alone, while others require an object.  For example, "violent"
can stand on its own, but "desires" needs to have an object for that
desire.  So, Bubba the Evil Warrior might have these attitudes:

 - desires Princess Buffy
 - dislikes Buffy's Father
 - violent
 - dishonorable
 - desires money
 - desires followers
 - hates paladins

You could use a system like that of the paper RPG Pendragon for this.
In it, characters have "passions".  There's a set of passions that all
characters have to have ratings in, and these are arranged in opposed
pairs.  Characters are given numerical ratings in the passions.  When
a passion is tested, a roll is made using it.  On a success, the
character is influenced by that passion.  On a critical success, the
character is strongly influenced by that passion, and cannot hide it.
On a failure, the character may be influenced by the opposite passion
instead; a roll is made with it, and treated the same way.  If neither
passion succeeds, then how the character feels is up to the player or
GM (depending on whether it's a PC or NPC).

(Note that this is an optional rule in Pendragon.  It's meant to
simulate how the characters in Arthurian fantasy sometimes do
things that we moderns might consider to be way overboard.  In this
case, though, I'm only proposing using it to determine NPC behavior.)

Pendragon also has "directed passions", which are like the "desires
with an object" above.  These are optional and do not have opposites.

Capabilities are means that the character has available to affect
things.  These can be inherent abilities, such as being able to use
magic, but could also be external things, like having an army or a
magical item.  They could even be social connections, like being
friends with the local Duke.  Bubba might have a set of capabilities
like:

 - level 10 warrior
 - personal army
 - allied with Boffo the Evil Wizard
 - lots of money

(This system could also be used to describe organizations, kingdoms,
etc.  One could have a set of ideals that it generally subscribes to,
and can have capabilities in the form of significant NPC members,
populations, etc.)
 
Having these things, we can then use them like this:

We decide that an event of a particular type should happen, either
with a random generator, or by a decision by the mud's admins (in
either case, it's picked from a list of "event types").  For
example, let's say that we want a war to happen.

This can be put into the plot generator, possibly with extra details
(e.g., who we want to be the defender in the war).  If we can supply a
set of rules describing why someone might want to fight a war and what
capabilities can make someone capable of fighting a war, then we can
use standard expert system technology to make a system come up with a
list of who might want to start a war that meets our criteria, and the
reasons for which they might want to do so.

If characters are given ratings for the personality traits, as
mentioned above, we can even have the generator make random rolls to
see whether someone will do these things.  For example:

We want a war with the kingdom of Tutiron as the defender.  The
generator has been going through possibilities, and comes to this:

  Bubba the Evil Warrior desires Princess Buffy.
  Princess Buffy does not desire Bubba the Evil Warrior.
  Princess Buffy is an important person in Tutiron.
  Bubba has an army that is large enough to pose a threat to Tutiron.

  These conditions form a possible scenario for a war.  Checking
  personality traits:

    Bubba's desire for Buffy -- succeeds.
    Bubba's dishonorableness -- succeeds.
    Bubba's violence -- succeeds.

  Therefore, Bubba may start a war with Tutiron, with the objective of
  gaining Princess Buffy.

The fun part here is that it allows for characters to sometimes,
although not often, act in a way differently than one might expect.  A
normally honorable knight might try to kidnap Buffy as well -- it
would simply be much less likely.

(One refinement might be to have a threshold for the total of the
rolls.  For example, the system might roll percentile dice against
each personality trait, and have the amount by which the roll was made
be the level of success.  For something like starting a war to get
someone, the total of the three levels of success might have to be
very high -- say, 200 or more.)

There are several possibilities for where to go once you have a set of
possible matches.  One possibility would be to somehow bring it down
to just one.  Another might be to send all or a subset of the possible
matches to an admin (e.g., the top 5 possibilities), for human review
and possible brainstorming (e.g., two or more of them could ally
against the kingdom, each with their own agenda).

Once a particular scenario is chosen, it needs to be implemented.  The
engine might have certain standard scripts to attach to objects in
order to implement the scenario.  Of course, if the scenario is sent
for human review, admins might decide to implement it or parts of it
by hand if they have something special in mind.

That's the overall idea.  Something along those lines would require a
lot of effort to build, but could be very interesting.  Here's some
more random ideas for tweaks and thoughts on the system:

Secrets:  Characters could be have secret desires and personality
traits.  A character will not normally do anything that would betray a
secret, but will still try to fulfill these things, when they can do
so without it being discovered.  (E.g., Bubba might have "desire for
Buffy" as a secret desire.  If so, then there would also have to be a
visible reason for him to attack Tutiron, even though Buffy might be
what he really wants.

Changing traits:  A character's personality traits, especially desires
and hatreds, might change as a result of scenarios being played out.
If a PC plays a major role in foiling Bubba's plan, then Bubba might
be given a hatred for that PC.  If Bubba succeeds in his plan, then
his desire for Princess Buffy might be removed, since it has been
fulfilled.

Capabilities might also change over time, by allowing NPCs to form
and break alliances, gain experience, lose money, gain or lose
followers, etc.

Scenario development:  Ideally, a scenario should not be set up and simply
sit there as a static thing -- it should be dynamic and changing.
This means that, if PCs do not intervene, a scenario will eventually
play out on its own.  A random timing might be used to decide when a
plot will be generated for a countervailing force -- e.g., for an NPC
to try to save Tutiron from Bubba.  That plot could then be treated
like any other -- checked to see if there are NPCs who would want to
do it, and, if there are, one or more of them selected to have
appropriate scripts set up.  This doesn't imply that all scenarios
will "naturally" end up at the starting state, though -- an attempt to
counter might be unsuccessful.  Also, other plots might naturally
branch off from this one -- e.g., if Bubba's attempt to get Buffy is
thwarted, he may go after the thwarters, try another tack to get
Buffy, etc.

Random events:  With a setup like this, random events can be a level
more subtle -- instead of being things that visibly happen, a random
event could be a change in an NPC's personality.  NPCs could fall in
love, fall out of love, reform their ways, conceive a vocation, and do
other such things.

Major and minor characters:  Characters who have many strong
personality traits and the capabilities to do something with them
would be more likely to be have scenarios centered around them than
other characters.  This creates a natural division of NPCS into
major and minor characters.  Allowing for scenarios to change an NPC's
personality traits and/or capabilities can allow the status of an NPC
to change over time.

PC involvement:  Plots could be generated with PCs as objects -- e.g.,
Bubba might put a price on the head of a PC who thwarted his plans,
causing the system to search for NPC mercenaries who might decide to
go after that PC.  I'm not sure how good an idea this would be -- it
allows for "natural" solutions to certain problems (like paladins who
are misbehaving), and can reward PCs who take an active interest in
doing things on the mud by giving them more attention.  On the minus
side, however, it may focus too much attention on those characters.

Well, I think that's enough rambling from me.

--
       |\      _,,,---,,_    Travis S. Casey  <efindel at earthlink.net>
 ZZzz  /,`.-'`'    -.  ;-;;,_   No one agrees with me.  Not even me.
      |,4-  ) )-,_..;\ (  `'-'
     '---''(_/--'  `-'\_)   


_______________________________________________
MUD-Dev mailing list
MUD-Dev at kanga.nu
https://www.kanga.nu/lists/listinfo/mud-dev