Automatic
Control of Characters
Ever get the feeling you aren’t
in control? With your role-playing game that just
might seem like the case. However, when scripting comes into play, you want to
control the PCs at times—for example, to advance the story in some way. This
involves automatic control.
Automatic control of a
character means that the game decides which control method to
use and where to move the character. Automatic control takes place in the
artificial
intelligence settings. To temporarily control a PC, you can use the following
steps:
1. Change the PC to an NPC.
2. Change the artificial
intelligence setting of the PC (now an NPC) to follow
a route (or other movement type).
3. Perform movements and continue updating until the last route point is
reached or until you want to stop using automatic control.
4. Switch the character back to
a PC type.
Conversation
among Characters
That’s right, chat it up!
Character interaction is also a major part of a role-playing
game, but have you seriously thought about how to implement conversation into a
game? Thankfully, there are easy ways to make your characters talk to each
other,
and not wanting to stray from the easy path, let me show you some of the basic
character conversation methods.
The Talking
Dummy
The easiest conversation method
to use has got to be the talking dummy. Every roleplaying
game has at least one character (the talking dummy) that says the same
thing again and again; no intelligence is involved. Programming a talking dummy
into your game is as easy as assigning a line of text that is displayed whenever
a
character is spoken to.
The problem is that the talking
dummy can say only one thing at a time, which
isn’t very useful. Also, rather than inserting the code for a character’s
dialogue into
the game engine, you can use an external source for the conversation text, which
takes us to the next topic, how to improve the basic talking dummy design.
Script-Driven
Talking Dummies
You knew this was coming,
didn’t you? Scripting is the heart and soul of computer
role-playing games, so you should try to use it to the fullest degree, including
when
your characters converse with each other. By assigning a script to each
character
in your game, the scripting engine can take the basic talking dummy concept and
expand it.
Adding the ability to use
conditional code in the script enables talking dummies to
decide what to say based on internal flags and variables. Say that you have a
script
that tracks the status of a flag, a flag that states whether you’ve visited a
nearby town.
When it comes to a script-driven talking dummy, your script engine decides which
text to display based on the flag it receives. That character (the dummy) tells
you
to visit the nearby town, or if you’ve been to the town, the dummy might comment
on the town’s population. One such script might look something like this (in a
textual
format):
If flag 0 is TRUE then
Print message “I see you’ve visited GranWell to the south!”
Else
Print message “You should head south to the town GranWell.”
Endif
As you can see in the preceding
script, a flag (flag 0) tracks a TRUE or FALSE value
(the flag is set to TRUE whenever the player visits the town GranWell).
Displaying
Conversational and Other Text
No matter which way you look at
it, you need to display the conversation among
characters in one way or another. You know the routine—whenever your player
talks to another character, a small window pops up and displays text. Every once
in
a while, the character can choose from a list of actions displayed, and the
conversation
goes on.
Using 2-D techniques, you can
display a conversation window (or text window to be
more precise), with the conversation text displayed inside the window. Because
only so many text characters can fit within the window at one time, multiple
windows
are displayed with each page holding a portion of the complete conversation.
A player pushes a button to navigate through each page of text that is displayed
in
the window. When the text finishes, the conversation ends.
To keep things simple, I
developed a system (a text window class called cWindow)
that can render a text window of any size anywhere on the display. This window
can be moved at any time, and may contain any string of text you assign. As a
bonus, the window can act as a text-bubble of sorts, whereas the window has a
pointer to a talking character.Following snap shows the text window class in
action.
Technically, the window is two
rectangles drawn on top of each other, with both
rectangles contained within a vertex buffer. One rectangle is white and is
slightly
larger than the inner colored rectangle. When you draw them in order (from the
larger white rectangle to the smaller colored window), you achieve a bordered
window
look as shown in prior snap.
The window text is drawn on top
of the two windows. Text can be set at any time, but
presetting a string of text gives you the extra ability of calculating a window
size that’s
guaranteed to fit the entire string of text within the window. Once you define a
window’s
size, you can dynamically change the string of text drawn without re-creating
the vertex buffer defining the window.
Realistically, you can use the
text window for anything. Say that you want to open a
window to display an image using a text window class and texture object. It
becomes
a matter of drawing one and then the other.