open-ended vs. planned...

[apstern@ix.netcom.com]

----- Original Message -----
From: <WFreitag@aol.com>
To: <idrama@flutterby.com>
Sent: Friday, April 13, 2001 6:36 PM
Subject: Re: interactive story issues


> This a response to Andrew's earlier post (not his most recent one). I'm
sorry
> it was so delayed. I didn't mean to ignore Andrew's ideas and questions. I
> wrote lengthy comments last week which were lost when my screen froze,
then
> other distractions arose. Here's a second try.


This is great, this promises to be a very useful discussion.  (at least for
me :-) )


> >If you're interested, another way to frame the discussion is to propose a
> >concrete example of an interactive story to build, so we can start from a
> >common place.  We could talk about issues of conflict, goals, metaphor,
etc.
> >within the context of this concrete idea.  For example, just to pick
> >something, let's say we wanted to make an interactive story set at a
beach
> >town in summer, and you play a character who is a single young person
> >vacationing there.  (I'm thinking of the setting of Eric Rohmer's A
Summer
> >Tale.)  There could be a whole cast of computer-controlled characters
whom
> >you could meet, form relationships with, allowing for a multitude of
> >different stories.
>
> Well, this should be worth a try. I think, though, that we might run into
the
> same problem in another form. Since everyone has their own definitions and
> ideas, then as soon as you start making decisions for a specific work,
will
> people lose interest because they would have decided differently?


Well, let's give it a try, I won't lose interest, hopefully others will be
interested too and jump in


> > What kinds of stories would we theoretically want to happen?  Do we want
> this
> >to be very open ended
> >Or do we want there to already be some sort of conflict from the start,
> >Other questions could be, do we want the story to be dramatic, where
there
> >is an inciting incident, crisis, climax, with a final ending?  Or do we
> >want it to be more meandering, episodic, never-ending?  Should this be
> >replayable?
>
> This seems like a lot of decisions. But they aren't completely free
> decisions, and they're not independent of each other. Some styles are
easier
> to implement than others, and some combinations of elements are not
> compatible. Therefore, in practice, decisions on some elements tend to
also
> decide others. For example, I can be fairly certain that if you choose to
> have a dramatic inciting incident and a crisis-driven conflict, then
unless
> you invent something extremely clever you will also end up with a limited
> number of pre-planned endings.


Exactly; these design decisions affect the nature of an interactive story
fundamentally, and are dependent on one another.  For the sake of
discussion, I find it necessary to make these decisions for our particular
example story, allowing us to focus on how it could be achieved.


> I'm referring again to the idea of current "standard models" for
interactive
> storytelling. These are islands of feasibility where the parts fit
together
> and function reasonably well using current techniques. Even if your
intention
> is to break free of those models, it's important to understand them first.
> The standard models warn you of what aspects of your project are likely to
> require innovative work. If you want to create an interactive story with a
> crisis, goal-oriented story line, and dramatic pre-planned endings, no
> problem. There are lots of games built on this model, using linked plot
> milestone events gated by world state. If you want to create an
interactive
> story with open ended events driven by character interactions with a
> meandering never-ending plot, you can do it. You can do it with a
> character-behavior simulation like the Oz/Zoesis software or Erasmatron.
> (It's much harder than a pre-planned story, but at least the principles
are
> clear.) If you want open ended character interactions with only emergent
> conflict _and_ a big dramatic ending, you're going to have to innovate
more.
> That combination isn't in the standard models. That doesn't mean you
cannot
> or should not do it, but it's going to be far more challenging. It's
> something that hasn't been done well yet by anyone. Trying to do it could
> lead to a breakthrough, or it could wreck your project, your career, and
your
> company.


I agree with this observation that there are islands of feasibility in the
design space of interactive story, and your characterization of them.

A few years ago I got very excited by the potential for interactive story of
the open-ended character-behavior simulation approach you describe, when
working on the Petz and Babyz projects -- similar to the Oz approach.  This
has lead to the desire to build a story manager that operates using authored
behaviors.  More on this later in the email.


> For dialog in the Summer Tale scenario, if the plot is open-ended I'd
choose
> template sentences with pull-down menus to fill in the key nouns. This
gives
> you more mechanisms for open-ended social interaction than an action-based
or
> verb-menu interface with autonomous character speech, and more choices
than
> regular sentence menus, while facilitating automation of the other
> characters' responses and avoiding the incessant "I don't understand you"
> responses you get with text parsers. "Do you want to come with me to
> <settingLocation>?" "I think <character name>'s <phsyical feature> is/are
> really hot." But if the plot were more "dramatic" and event sequence
driven
> I'd use autonomous speech. "Hey, you, stop flirting with my boyfriend."
"Oh
> look, Tiffany's been eaten by a shark! Like, how gross is that!"


Alright, for our discussion let's say that we choose template sentences with
pull-down menus to fill in the key nouns.


> >There seems to be so many ways to go about it, even within one specific
> >story context.  Depending on which kind of story you choose, you may want
to
> >implement these characters as strongly autonomous, independent
goal-directed
> >agents, versus more centrally controlled by a single story-manager (an
issue
> >we're dealing with on our Facade project)...
>
> The crux of the issue isn't central versus local control. In the end,
either
> way, there's some set of mechanisms, and whether those are built as
> individual character behaviors or a big central character control handler
is
> a code architecture issue, not a design issue. (However, you do need a
system
> where authors can at least think of character behavior design in local
terms
> even if it's not implemented that way.)
> The real question is how much of the character's behavior is decided by
rules
> that simulate the character's own goals, desires, reactions, tendencies,
> etc., and how much (if any) is decided by rules that apply global story
> construction principles.


I agree that that is the real question (although I believe the architecture
you choose will have a direct impact on how authoring is done -- my
collaborator Michael has a lot to say about this)


> Once again, the current techniques are all or
> nothing. I've never seen a global "story manager" do anything useful in a
> virtual world of autonomous characters acting according to simulated
behavior
> rules. I've never seen autonomous character behavior rules do anything
useful
> in a virtual world where a planned story existed, other than to control
> low-level behaviors with no effect on the plot, like monsters attacking or
> shopkeepers performing their duties. The idea of taking a world of
autonomous
> characters and superimposing a "story manager" to try to nudge events in
the
> direction of more dramatic stories is a tempting one. It sounds like a
fine
> idea, to me, if it could be done. But I've heard about it (in academia)
for
> over ten years, and haven't seen it done yet.


Well, I tried this a bit with Babyz recently, I wrote about it in my 1999
narrative intelligence paper.  The Babyz were strongly autonomous
characters, but I had a long-term story manager occasionally influence which
behaviors they chose to do, to achieve some loose long term narratives.  For
example, I tried to create "sibling rivalry" stories between babies, where
over the course of a few days, two babies would play pranks on one another,
escalating over time.  These pranks could occur  interspersed among all the
"normal" behaviors they had (eating, sleeping, playing, etc.)  Some users
noticed these rivalries occurring, some didn't.  It was by no means a tight,
efficient story being told; it was more loose, episodic and fragmented.  I
thought it had some promise though.


>  The opposite possibility is
> perhaps less tempting: take a strongly sequenced story and make the
> characters more autonomous. Without the ability to intelligently alter the
> story into something else, it's not clear what the characters' autonomy
would
> add except a distraction. If the story has pre-planned alternate branches,
> open-ended character interactions can be made a factor in determining
which
> branch kicks in. But you have to be careful. If you have a planned plot
that
> depends on the player-character getting a key piece of information from a
> specific character, and due to open-ended character interaction mechanisms
> that character might get killed or develop an irredeemable unwillingness
to
> help the player-character, you have a serious design flaw.
not so much pre-planned, but combinations are finite
>
> Yet again, which I'd choose for Summer Tale depends on whether the general
> approach is open-ended (use autonomous characters) or plot-driven (use a
> story manager).


This is an area where I would like to brainstorm with the minds on this
mailing list -- how could we find a middle ground approach.   For our Summer
Tale discussion, it would be interesting to discuss a variety of approaches.
(Walt, you mentioned something about prose data structures in a previous
post?)

To get the discussion going, I'll describe one approach, which my
collaborator Michael and I are experimenting with for Façade.  I apologize
if this seems a bit long, but there's no easy way to describe it in a few
sentences.

As I was saying earlier, working on behavior-based characters led to the
desire to
build a story manager that operates using authored behaviors.   This kind of
architecture would have the flexibility to "do anything at any time", to
potentially switch to any of the authored story pieces at any time, instead
of being stuck on a fixed railroad track that can only maneuver by following
the current track to the next branch.  The system can be very reactive, able
to respond immediately to user interaction in a variety of ways, to give the
user a high degree of true agency (a characteristic sorely lacking in most
story systems to date).

Of course, along with this kind of flexibility, we want the user to have (as
close as possible) the experience of story happening -- that is, a narrative
that is clearly progressing in an interesting way, where events are
happening at a good pace, characters are changing, ideas and themes are
being explored.

Our plan is to cleverly author the story manager's behaviors such that they
can immediately react to the moment-by-moment user's interactions as they
happen (which are what behaviors are traditionally good at), while
simultaneously are deliberately trying to make events happen and arc story
values over time (ie, progress and perform a story).

By "story manager behaviors" we don't mean character behaviors per se, we
mean behaviors (reactive-plan programs) that are controlling the flow of the
story.  We plan to use the organizing principle of story beats within these
behaviors, referred to in a previous email.  (For detailed description what
behaviors are and how they work, see the CMU Oz group's papers on the
language Hap they designed, there's a link on my webpage to it)

Architecturally, the story manager would be a single agent, not a collection
of independent autonomous agents.  The metaphor of "conversation" between
user and system applies here: the single human user is interacting
one-on-one with the story manager.  The story manager "expresses itself" by
controlling the computer characters.  (Each computer-character could still
be their own agent, but they are regularly given sets of character behaviors
to operate with by the story manager; in this way the characters are weakly
autonomous.  The story manager itself is the only strongly autonomous agent
in the system.)

A big advantage to the approach of using behaviors is that when an author
adds a new behavior to the system, the system automatically starts trying to
use it, anywhere and everywhere it can.  As an author you can slowly build
up the story over time by adding more and more behaviors to the system.  You
could find the system ends up sequencing the behaviors in unexpected ways
(which can be good and bad).

The story manager would respond to the user's interactions in these ways:
- at any moment, the user's interaction would influence the story manager's
decision of which behaviors choose among to perform; the more behaviors that
have been authored, the more possibilities there are.  Each behavior would
have preconditions and effects, to know when it is appropriate to choose
them.
- if we are already in the middle of a behavior, the user's interaction
could influence / modulate HOW the behavior is performed, since a behavior
could have a variety of ways to play itself out
- if the user's interaction demands we switch to another behavior, we could
try a bit of "recovery" where we try to stay in within the current behavior,
before switching away, in an attempt to not thrash all over the place.
- if we need to switch to a new behavior, do so, but by inserting a
transition behavior of some sort, and remember where we had left off in the
previous behavior, in case it is possible to return to it later, in an
attempt to for the story to be efficient.

I think the hard part is:  it is up to the author to design and write these
behaviors so that it will "make sense" to switch among them, that each has
the capability to progress the story, no matter which is running.  If one
behavior requires certain things to have already happened so far, these are
encoded in the behavior's preconditions, which limits when the behavior can
be used.  In this way you can enforce a partial order among all the
behaviors.  The tighter the ordering you author, the closer to "hard wired"
or "pre-planned" you get.

This approach still leaves the author with the burden to generate all of the
events and endings, in the form of story behaviors.  To have a story feel
"open ended" in the sense that it could end in a variety of ways, still
requires the human to author these.  Here, what the AI does do for you is to
_perform_ the story in a variety of flexible and reactive ways.  In
cinema-speak, the AI is more of a director and editor than a writer.

Walt, would you call this a middle ground between the open-ended
character-behavior simulation approach and the "pre-planned" approach you
described?



> What seemed like a long list of independent questions, ultimately, comes
down
> to one question: is the plot open-ended or planned? Like others, I wish
this
> were not so, and I'm working to make it not so, but many projects have
> learned at great cost that at present it _is_ so.

Instead of thinking in terms of "open-ended vs. planned", I like to think
about "authored (planned) with a high degree of flexibility and reactivity
(open-ended)".  That is, as open-ended as possible, but not to point of a
completely open-ended simulation (e.g., Simcity, the Sims), and also
somewhat planned, but as flexible and non-linear as possible.

The burden of the design of the non-lineariness of the story -- that is, the
total number of possible permutations the story can take -- is still on the
human author.   The next step would be to have the AI be even more
generative, to be able to construct its own story events, instead of picking
among human authored ones.  Perhaps this is what people on this list are
wanting to do.  It would be very interesting to brainstorm about ways to
achieve this.


> The state of the art right now is to combine a pre-planned sequence of
major
> plot milestones with open-ended interactions for minor events between
> milestones.
> Between milestones, the player is "working toward" the next milestone by
> systematically altering the world state (making some sort of "progress")
to
> the point where the next milestone can be unlocked.

Right, we need to move beyond that.  Chris' essays where he diagrams the
standard interactive story structures are great for understanding the
limitations of that approach.

> Though I don't take sides in the evolution versus revolution debate
overall,
> I do recommend that anyone trying to create a commercial product with
limited
> time and budget should stick to the evolutionary approach.

I'd like to hear both evolutionary and revolutionary ideas discussed,
although I think I'm in the evolutionary camp.

Andrew