Controlling Players and Characters(41)      摘要: All your hard work is about to pay off with a demonstration of the character and
spell controllers seen in this chapter.

Upon executing the program, you see the scene shown in following snap. 

Controlling Players and Characters(40)      摘要: Things are winding down with the controller at this point. You use the following
functions to equip, use, and drop an item: 

Controlling Players and Characters(39)      摘要: Once characters take enough damage, they die, and when that happens, the following
function is called: 

Controlling Players and Characters(38)      摘要: Coming up is a huge collection of functions you use to retrieve and set the specific
information about a character (related to the artificial intelligence functionality or
actions): 

Controlling Players and Characters(37)      摘要: Whenever a character needs updating, rendering, or what have you, a pointer to
the linked list of characters is needed in order to iterate the list. Either that or
maybe your application needs access to the character data. Either way, the following
functions will help you out:  

Controlling Players and Characters(36)      摘要: Notice that I keep talking about removing characters from the list. What about all
the hard work you’ve put into your PCs—how are you ever going to store their
achievements for later loading? With the following set of saving and loading functions,
of course!  

Controlling Players and Characters(35)      摘要: You're coming to the end of the long haul. You’ve finished the private data and
functions, and the public functions are left:  

Controlling Players and Characters(34)      摘要: Once it is determined what action each character wants to perform, that action
must be validated. Characters moving around can’t walk through other players
(except for PCs, who can walk through other PCs). Also, depending on your levels,
you use a function to determine character-to-map collisions. These two validation
functions are as follows:  

Controlling Players and Characters(33)      摘要: The next two functions to come along work in conjunction with the update functionality
of the class. At every frame that a character needs updating, a specific
function is called to update the character’s actions. This specific function is dependent
on the type of character being updated; for PCs, that specific function is
pc_update (which is overridden by you in order to control your player).  

Controlling Players and Characters(32)      摘要: The brains of the character operation is the cCharController class,
which is probably the biggest non-game core class you’ll work with.

The cCharController class maintains a list of active characters, each character
being stored within a sCharacter structure. For each type of character, there is a
matching entry into an array of sMeshAnim structures (and a matching sCharAnimInfo structure).  

Controlling Players and Characters(31)      摘要: To start, each character needs a definition, which is pulled from the master character
list. You store this definition value in the def variable. To tell similar
characters apart, you assign a unique identification number (ID) to each one.
Think of using identification numbers as you use names. Instead of adding a character
named “George” into the game during play, you refer to that same character
as character 5. 

Controlling Players and Characters(30)      摘要: The character definitions are templates by nature, so you really need to load up the
definitions and work with them on a per-instance basis. This means that you need
to come up with a controller that loads the definitions and tracks each instance of
a character in your game. What you need is a character controller class. 

Controlling Players and Characters(29)      摘要: master character list edit source: 

Controlling Players and Characters(28)      摘要: You create and use a master character list (MCL) much like you use the master
item list (MIL) to define objects in your game. Before using them in your game,
you need to design every character, complete with appearance (3-D mesh) and
functionality (abilities and attributes). This character information is stored in the
sCharDef structure.  

Controlling Players and Characters(27)      摘要: Now, you can put all the neat spells that your game has to offer to good use. You
know how spells work, but you need to know how the spells affect the characters.
Remember that the spell controller tracks only the meshes that create the visual
side of spells; the character controller determines the effects of the spells.  

Controlling Players and Characters(26)      摘要: When a character takes a swing at another character, this action triggers the
process that determines whether the blow hit the target. Determining whether the
attack hit involves an attacking character’s to-hit ability and a defending character’s
agility ability. Remember that the higher the ability values, the better the chance to
hit or dodge the attack.  

Controlling Players and Characters(25)      摘要: After a spell triggers and the effects are processed, what happens? As I’ve previously
mentioned, spells only affect characters, so only the character controller engine
should modify the character’s data. In the section “Creating a Character Controller
Class,” later in this chapter, you find out how to process spells in regard to characters.  

Controlling Players and Characters(24)      摘要: Because the spell controller is needed only for tracking the spell meshes and
animation, the class definition is relatively small  

Controlling Players and Characters(23)      摘要: Controlling spells is a matter of tracking the meshes and animations that represent
the spell and then processing the spell’s effects on their intended targets. Because
the spell’s effects are really related to the characters, it’s best to let the engine that
controls the characters handle the spell effects and leave the spell animation up to
a spell controller class object. 

Controlling Players and Characters(22)      摘要: Creating MSL edit

main window design: 

Controlling Players and Characters(21)      摘要: Defining your game’s spells by manually constructing a bunch of sSpell structures
can quickly become tedious. Instead, you need an editor that is better suited to
quickly change every aspect of your game’s spells. Welcome to the MSL Editor!

Controlling Players and Characters(20)      摘要: Spell effects usually target a single player, but this is not always the case. At times,
the spell is either targeted at the spell caster or all the characters within an area.
Also, not all characters can be affected by a spell. A spell cast by a monster, for
example, should not hurt other monsters, just PCs. In the same vein, spells cast
by PCs should be directed only toward monsters. 

Controlling Players and Characters(19)      摘要: The functional component of a spell does the real work. Once a spell runs through
its animation and reaches its intended target, the damaging or beneficial effects
need to be dealt with. 

Controlling Players and Characters(18)      摘要: Resources are commodities, so characters will want to buy and sell their wares from
and to each other. Only specific characters in a game are open to bartering. These
characters are commonly called “shopkeepers” because they tend to appear only in
stops. You know the drill—enter a shop, approach the counter, and begin dealing.  

Controlling Players and Characters(17)      摘要: Resource management plays a major role in your game. For characters to really get
anywhere or achieve anything, they may need the aid of the items, spells, and other
objects you’ve constructed for your game.  

Controlling Players and Characters(16)      摘要: I’m going to assume that you are comfortable working with action templates and
scripts at this point. The following action template provides an example of using a
derived script class:  

Controlling Players and Characters(15)      摘要: Scripting keeps popping its head up throughout these last few chapters, and true
to form, scripting plays a major role when dealing with characters. Scripts work
with conversations, spells, character movement, and much more. 

Controlling Players and Characters(14)      摘要: To get things rolling, take a look at the following cTextWindow class definition:  

Controlling Players and Characters(13)      摘要: 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.  

Controlling Players and Characters(12)      摘要: Although following another character might seem complicated at first, don’t worry
too much. Remember that keeping it simple is the solution. Following a character
is as easy as walking a route. Because a character already knows its own coordinates
and the coordinates of the character it is following, you can use previously seen
functions to move the character toward another one.  

Controlling Players and Characters(11)      摘要: To determine the distance away from a route point, you can use the standard
Pythagorean Theorem, but in order to speed things up, you can toss the sqrt
operation out the door and use the sum of the squares of the lengths instead.
To see what I mean, take a look at the following two lines of code:  

Controlling Players and Characters(10)      摘要: 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.  

Controlling Players and Characters(9)      摘要: Rotational control allows the player to rotate the character using the left and right
arrow keys and forward and backward using the up and down arrow keys.

Rotational control is better than directional control is some aspects, because the
movement calculations are more basic. Characters need to store a directional value
now, however, that represents the direction they are facing (with 0.0 pointing along
the positive Z-axis, 1.57 pointing along the positive X-axis, 3.14 p  

Controlling Players and Characters(8)      摘要: Your player is the most important character in the game, so you need complete control
of him. Typical games utilize a simple directional control scheme, similar to the
scheme you read about in the section “Player Navigation.” 

Controlling Players and Characters(7)      摘要: Up to this point, only the functionality of a character has been discussed. The reality is that functionality is the only part that really matters, but game players will want some sort of visual representation of their digital alter ego. With the power of a 3-D modeler and the Graphics Core, you’ll have no problem tackling the graphics portion of your characters.  

Controlling Players and Characters(6)      摘要: You contend with NPCs much as you contend with PC controls, except that the
game engine handles all aspects of an NPC’s controls. This difference creates some
tough design and programming situations, and you must develop an artificial intelligence
system that can mimic believable behavior.  

Controlling Players and Characters(5)      摘要: The world revolves around your PC, so most of your game development will go into
controlling him. PCs have the most actions and options available to them. Other
than those character actions previously mentioned, PCs have the option of managing
their game resources, which includes items and magic spells. In addition, character
building is used to build up the strength of the character.  

Controlling Players and Characters(4)      摘要: Characters come in all shapes and sizes—big ones, little ones, even short and furry
ones. The fact is that some characters have different attributes that make them special.

For every different type of character in your game, there is a matching character
class. You can think of character classes as being a way to differentiate the different
species of characters in your game. Going even further, classes can determine a
specific type of character in a species.  

Controlling Players and Characters(3)      摘要: Character’s attributes are much like abilities, except that attributes define a different
aspect of a character. Your physical health is an attribute, for example; it varies
depending on how much injury a character sustains. These injuries can be healed
and, as such, the health of the character is increased.  

Controlling Players and Characters(2)      摘要: Employing characters into your game is one of the most difficult jobs you’ll face.
Even at a basic level, the code needed to control gaming characters can be convoluting.
What’s a lowly programmer to do? Just take it slow, work from the begin-ning, and all will be well.

In this section, I introduce you to some basic concepts common to most roleplaying
games. These concepts include defining a character’s basic abilities (which
include strength, intelligence, agility, and   

Controlling Players and Characters(1)      摘要: A gaming world is nothing without players and monsters running around.
Nevertheless, creating them can be a little daunting at first. But don’t worry.
In this chapter, you can find the basic information you need to create characters
and give them a life of their own in your game—all in an easy-to-follow format.
In this chapter, you learn how to do the following: