[MUD-Dev] Questing (was: Request for ideas)

Vincent Archer archer at frmug.org
Wed Oct 3 15:13:57 New Zealand Daylight Time 2001


According to Eli Stevens:
> ----- Original Message -----
> From: "Vincent Archer" <archer at frmug.org>

>> I've worked on and off on such a system, but it requires far more
>> efforts than I can put in on my not-so-copious spare time. The
>> best model I made was a kind of directed, cyclic graph of "steps"
>> where, at each node (a step that is completed), you'd pick the
>> next arc at random, subject to constraints (is the quest shaping

...

> Would the system pick the next arc, or would the player?  I could

In the model I had, the system picks the next arc. It's mostly a
system that generates in-game stories, with characters serving as
actors under a script from the "director" (the quest system). The
quest is highly linear, with relatively little non-linearities
(introducing subquests, which run their own path before enabling the
next main path, or some choices). In that context, you rarely "fail"
(most failures are in fact pre-scripted failures), because failure
means you can't complete your quest and need to reset (clear the
quest log, and start again).

> see it working either way...  One way would be akin to the choose
> your own adventure model, the other would be like having a choose
> your own adventure book read to you by someone else, without
> knowing about the choices explicitly (just choosing and
> continuing).  Do you have an example?  I am curious to see how the
> randomness would work out in practice.

I had not mapped many possible nodes, but here's an example:

Node: Delivery of diplomatic note to NPC X of Faction Y

Possible next nodes:

  - "See my treasurer for your fee" (most likely, goes to end of
  quest node)

  - "See my treasurer for your fee" (highly unlikely, goes to "we
  are out of fund, please investigate" node)

  - "Please take this reply back with our offer" (semi-unlikely,
  goes to Delivery of diplomatic note to NPC X of Faction Y)

  - "Please take this reply back with our offer" (very unlikely,
  goes to ambush of diplomatic note with weak/defeateable party)

  - "Please take this reply back with out offer" (highly unlikely,
  goes to ambush of diplomatic note with uber/undefeatable party)

  - "Hmmm, the situation isn't developping well, we'll need stong
  allies in the event of war" (very unlikely, goes to recruit PC for
  our cause node) etc...

So what happens when you arrive, meet character X, and deliver the
diplomatic pouch? Most of the time, this marks the end of your quest
(simple FedEx, get some cash). But some of the time (1 times out of
1000, maybe), you will get a message back, and at a random but
suitable place along the way (I assume not TP/instant travel), a
group of ennemies (whose nature may be random, or heavily influenced
by what you fought during the quest already. If you fought a lot of
undead, you might be ambushed by a zombie attack, if not, by bandits
or whatever) calculated to overwhelm you spawns and attacks (group
is severely unbalanced to get you down, ans scaled according to
whomever is in range).

After the attack, you're at ambush, which has two arcs allowed: one
goes back to the letter giver, the other to the letter
recipient. This is one of the rare cases where the player has a
choice: if he meets the message sender, he triggers the 1st node
(which will have various consequences, being sent on a chase to
recover the note, being given a duplicate note, and so on; if he
meets the message recipient, he triggers the 2nd node (which has
different paths unfolding).

>> The trick is to determine all useful nodes and arcs, put the
>> constraints in (never more than three "I sign the letter and you
>> give it to the next guy" steps in a row), and then synthetise a

In the example above, you notice that one arc leads back to the same
node. You need to put constraints so that the character isn't stuck
in the loop ferrying 1000 letters back and forth between the two
NPC.

I had a simple system to avoid that (each time you cross a node,
increment that node "counter" by 100 for the quest, decrement every
other node by 1 and don't take an arc that goes to a node over value
N), but there's enough nodes that looks similar, but are different
underneath to defeat that simple constraint system.

> I like the specialist idea, especially how it ties in with PCs
> online at the time.  I wonder what else could be done with ideas
> like that...

I called these "social nodes". If your world is moderately large, it
gives you an opportunity to meet people you don't know, which can be
fruitful. They're, however, points of possible failure of the quest
(what happens if character X doesn't want to drop his camp to come
with you). There are, however plenty of tricks that you can insert.
If you're directed to hunt bandits, for example, and someone with a
quest arc that involves hunting bandits is on-line and in place, you
might add a dialogue part saying in essence "I hear Mr C is already
on a commission to clear the bandit camp, you might ask him if he
has found anything" (recovering the stolen note).  It's not part of
the quest, it merely directs you to someone who has a similar quest
step to yours, in the hope that you'll join forces and like it.

I was pleasantly surprised yesterday by a step similar to that in
Dark Age of Camelot. As a dwarven seer, I was given a starting
quest, and that one was supposed to teach me combat camaraderie, and
whatnot. So, in my quest journal, I found myself with:

"Step #2: Find another player, recruit him into a group, and come
back."

> Hmm.  Could it be taken out a few levels of scope?  What if we
> made one for the state of an entire guild or kingdom, and did not
> give any starting or ending points?  We just let it run...

As a debug tool, I envisioned putting a flag on the quest entry to
disallow getting to an end node at all. Which meant your quest would
go on forever. Great to debug long-running quests.

Putting it at a higher level than the individual player introduces
an additional layer of complexity: it's usually harder to determine
when you reach a node. Individual-level quests are easier to
qualify: Mob X is slain, NPC Y is met, item Z is delivered.

>> (my own estimation is 6-10 man-months of work at least, which is
>> on the big side for a team student project).
 
> Ouch.  :) It would also make content creation harder, as quest
> writers would have to basically construct choose your own
> adventure books for each one.  Unless you were thinking that each
> of the nodes would be generic, and would could show up in any
> quest?

Yes. On the latter, I mean. One quest would start as an innocent
dipomatic courier, then wander off into "we need recruit", send the
player on a set of quests that involve him getting equipment, then
send him to kill an ennemy of faction X (at which time, the fact
that he started by doing diplomatic courier duty is completely
irrelevant to the system). In theory, each node of the graph would
have a path (more or less complicated) to each other node, barring a
few exceptions maybe (chiefly starting nodes).

The trick isn't making a global book, it's identifying every
"standard" type of event in a quest and finding every "logical"
transition. It's relatively stupid, for example, to ask you to kill
a wolf pelt "because we need a new rug" upon the reception of a
"gift from afar".

> Interesting stuff.  We will probably try and have something along
> these lines in there, but it may have to be stripped down.  :/
> Again, if you have any examples (real or synthetic), I would love
> to see them on the list.  :)

I don't have full, real examples. I think a complete quest graph
will end up probably around 200-250 nodes, with 10 to 20 arcs
leading out of each node; but you can build a quest system with a
lot less nodes; the quests stories won't be as varied however (if
you want diplomatic based stories, you can do it probably with 30-40
nodes).

The original design in my mind was for a 3D MMO style game, with the
additional contraints that at least two-thirds of the arcs should be
douable in 30mn or less (attractive to the casual gamer, who logs,
advance his story, and leaves because baby's feeding time is
approaching).  With 10000 players on the server, and a constraint
that a quest cannot end in less than 5 steps, you'd quickly branch
enough that two player would never ever see exactly the same story.

It's like everything. It's a lot of investment at first, but it has
the potential of generating enough stories (and, if correctly build,
I hope interesting stories) to avoid getting a team of 10 content
designers working on nothing but quests for your game.

--
	Vincent Archer			Email:	archer at frmug.org

All men are mortal.  Socrates was mortal.  Therefore, all men are Socrates.
							(Woody Allen)
_______________________________________________
MUD-Dev mailing list
MUD-Dev at kanga.nu
https://www.kanga.nu/lists/listinfo/mud-dev



More information about the MUD-Dev mailing list