Determining
Victims and Processing Spell Effects
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.
Using the
Spell Controller
At this point, the spell
controller is fully functional, but without the aid of the character
controller, the spell controller won’t work. However, for the moment, hold
that thought and observe the following example, which shows how to use the spell
controller. Begin by instancing the spell controller and declaring an array of
mesh
filenames:
// Graphics =
pre-initialized cGraphics object
// Use two meshes
char *g_SpellMeshNames[]
= {
{ “Fireball.x” },
{ “Explosion.x” }
};
Next, instance and initialize
the spell controller:
cSpellController Controller;
// Initialize
the controller
Controller.Init(&Graphics, “default.msl”,
sizeof(g_SpellMeshNames)/sizeof(char*), g_SpellMeshNames, “..\\”,
NULL);
Now you’re ready for action.
Assuming that you have a single spell in the MSL
(spell 0), you can cast it with the following code:
Controller.Add(0, NULL, CHAR_MONSTER, 0.0f, 0.0f, 0.0f, 100.0f, 0.0f, 100.0f);
The spell will now travel from
the coordinates 0,0,0 to the coordinates
100,0,100 using the settings specified in the MSL Editor. When you finish
with the spell controller, always be sure to call the controller’s Shutdown
function:
Controller.Shutdown();
Combat and
Characters
There are times when characters
just can’t get along. For those special moments,
you need to teach those critters just who the boss is. Handling combat in your
game is a necessity that, fortunately, is easy to carry out.
Although the flashy graphics
and cool special effects are something you want in
combat sequences, you need to start with the basics. Behind every combat action
is
a set of rules (called the combat rules) that determines the outcome of every
swing
of a weapon, every deflected blow, and the result of each magic spell.
Earlier in the chapter, you
learned about character abilities—those abilities that
determine a character’s strength, agility, and so on. The abilities that most
concern
you at this point are those to determine whether an attack hits its mark and how
much damage it does. Following a succinct set of rules, you can use those
character
abilities to determine the outcome of combat.
Using Combat
Rules for Attacking
Your game depends greatly on a
set of underlying rules for handling combat, much
like traditional pen-and-paper role-playing games. Those rules are a set of
mathematical
equations, which, when applied with a little randomness, determine the
outcome of attacks, damage, and defense.
The combat rule set (CRS) of
your game works off the character’s abilities, attributes,
and skills that you’ve already seen in this chapter. Remember how those
abilities,
skills, and attributes are assigned a numerical value? Guess what? Those values
are
used to generate a few values that determine the outcome of combat actions.
For example, a character’s
to-hit attribute is used in a random number calculation
to see whether an attack lands. Then a check against the agility of the
attacker’s
opponent determines whether the attack was dodged. If the opponent was not so
lucky, the attacker’s attack values come into play to determine the damage.
Remember that the character being hit also has a defense ability that helps
reduce
the amount of damage.
Once the decision to attack is
made, a few steps determine the outcome.