Controlling
Non-Player Characters
As you’ve been able to surmise
from the past few sections, controlling the player is
relatively simple. Now comes the tough part—controlling the game’s NPCs. This
section shows you the various methods of navigating your game’s NPCs.
Although games might trick you
into thinking some elaborate scheme is moving
the NPCs around the world, that just isn’t the case.
Do you remember the five
general types of NPC movements that I mentioned earlier—
standing still, wandering around an area, walking along a route, following a
character,
and evading a character? With these in mind, you might want to take a closer
look at
your favorite role-playing games to find out which control schemes they use.
As for your role-playing game,
take a moment to examine the following controls
and how to implement them.
Standing
Still
There’s not much to think about
here—just place a character and he stands still
facing a specific direction. That direction is an angular rotation.
Wandering an
Area
Games such as Ultima Online
allow NPCs to wander around a set area, whether it is
the entire level or a section that you define. To keep things simple, you can
specify
the range in which you want a character to wander, within a specific range of
coordinates
(as illustrated in Figure 16.3).
These coordinates can be stored
in variables such as these:
float
WanderMinX, WanderMinY, WanderMinZ;
float WanderMaxX, WanderMaxY, WanderMaxZ;
Now, assuming that you are
tracking a character’s coordinates in the level in a trio of
variables, you can move them around randomly and check whether a move is valid:
float CharXPos,
CharYPos, CharZPos; // Character coordinates
float XMove, ZMove; // Movement amounts - skip YMove movements
// Distance to move character
float Distance;
// Determine a random direction to move - loop until found
while(1) {
float Direction = 6.28f / 360.0f * (float)(rand() % 360);
XMove = cos(Direction) * Distance;
ZMove = sin(Direction) * Distance;
// Check if move is valid - ignore height for now
if(CharXPos+XMove >= WanderMinX && \
CharXPos+XMove <= WanderMaxX && \
CharZPos+ZMove >= WanderMinZ && \
CharZPos+ZMove <= WanderMaxZ) {
// Movement allowed, update coordinates
CharXPos+=XMove;
CharZPos+=ZMove;
break; // break out of loop
}
}
CAUTION
Don’t randomly move a character around at every frame, or you’ll find yourself
with characters that look
like they’re having a conniption fit. Instead, update a character’s direction
only every few seconds or so.
Walking a
Route
Although NPCs aren’t
intelligent enough to know their way around the level, you
can assign them routes to travel. These routes include coordinates that must be
reached in order to proceed to the next coordinates. Once the last set of
coordinates
is reached, the character returns to the first set of coordinates and starts the
path all over again.
Using Route
Points
Route points are defined as a
set of coordinates, and keeping with the 3-D concept that
you’re accustomed to, you can use the following structure to store those
coordinates:
typedef struct sRoutePoint {
float XPos, ZPos;
} sRoutePoint;
NOTE
Note that there’s no need for a Y-coordinate when using a 3-D engine because the
height is
determined by the height of the ground below the character.
In order to construct a route,
you pick the points you want a character to walk and
construct an array of sRoutePoint structures to store the coordinates. Figure
16.4, for
example, shows a simple map, with five points marked.
Because each point in the route
is marked with coordinates, you can see how to
construct the sRoutePoint structures array:
sRoutePoint
Route[5] = {
{ -200.0f, -100.0f },
{ 100.0f, -300.0f },
{ 300.0f, -200.0f },
{ 200.0f, 100.0f },
{ 0.0f, 400.0f }
};
long NumRoutePoints = 5; // To make it easier to know # points
Walking from
Point to Point
In order to proceed from point
to point, a character walking a route needs to compare
its current coordinates to the point where it’s headed. You use this, combined
with the character’s walking speed, to compute a pair of movement variables that
update the character’s position.
Start by assuming that the
character’s coordinates are kept in the following variables
(along with the character’s walking speed):
float CharXPos, CharZPos; // No Y-coordinate needed
float WalkSpeed; // Walking speed per frame
At this point, assume that
you’ve already retrieved the coordinates you want the
character to walk to and placed them into another pair of variables:
float
RouteXPos, RouteZPos; // Again, no Y-coordinate
Now, to start the character
moving, you calculate the movement variables:
// Calculate
distance from character to route point
float XDiff = (float)fabs(RouteXPos - CharXPos);
float ZDiff = (float)fabs(RouteZPos - CharZPos);
float Length = sqrt(XDiff*XDiff + ZDiff*ZDiff);
// Calculate movement towards point
float MoveX = (RouteXPos - CharXPos) / Length * WalkSpeed;
float MoveZ = (RouteZPos - CharZPos) / Length * WalkSpeed;
Whenever you update the
character per frame from now on, you’ll need to add
MoveX and MoveZ to the character’s coordinates, as in the following:
CharXPos +=
MoveX;
CharZPos += MoveZ;
With that aside, go back and
see just how to track which route point a character is
walking toward. When one route point is reached, the character must walk toward
the next. To determine when a route point is reached, you check the distance
from
the character to the route point; if the distance is within a certain limit, the
character
has reached the point and is allowed to continue on to the next route point.