The cSpellController Class

Because the spell controller is needed only for tracking the spell meshes and
animation, the class definition is relatively small:

Next comes the MSL, which is contained in the array m_spells. Notice that the
macro NUM_SPELL_DEF defines the size of the MSL array, which means that you
can easily adjust the size for later enhancements.

Following the MSL is the linked list pointer m_spell_tracker, which tracks the spells
that have been cast and are being displayed. Next comes m_num_mesh_anim (which stores
the number of meshes used) and m_mesh_anim (a list of meshes).

Because this example uses 3-D meshes to represent the spells, you need to load textures,
and in order for the spell controller to find those textures, you must store a
directory path that indicates the location of the bitmaps to be used as textures.

Something you haven’t seen up to now is the m_char_controller pointer, which points to the
character controller class object in use. This class pointer triggers the spell effects.

cSpellController contains two private functions: SetAnimData and SpellSound. The
set_animData function sets up the mesh to use as well as the movement of the mesh.
play_spell_sound is called whenever a spell mesh is used; it’s your job to override this function
to play the appropriate sound as specified in the function’s argument list.

With private data and functions covered, you can move on to the class’s public functions
(the Constructor, Destructor, init, shutdown, free, get_spell, add, update, and render):

cSpellController::cSpellController and cSpellController::~sSpellController

Typical in C++ classes, the constructor and destructor clear the class data and free
all used resources, respectively. The destructor relies on a separate function (the
Shutdown function) to clear the data.

cSpellController::init and cSpellController::shutdown

Before using the spell controller class, you must initialize it. When you finish with
the class, you call Shutdown to free up the resources.

cSpellController::free

When you’re done with a spell controller class instance but want to reuse it without
having to shut it down, a call to cSpellController::Free is in order. Free releases the
spell tracking list as well as the mesh list.

cSpellController::get_spell

Outside code might need access to the MSL, and GetSpell fills that need. Providing
the MSL reference number returns a pointer into the array of the loaded MSL.

cSpellController::add

Now the real fun begins! Add is the function you use the most because it initiates a spell.

The private function set_anim_data initializes the three meshes in use by a spell. If one
of the meshes is not used (as specified by the POSITION_NONE value in mesh_pos), the
next mesh in the three is used. After all three meshes are used up, the spell’s
effects are triggered.

Spells need to move, have their timing updated, and have their mesh initiated at
the various steps. Update is responsible for all those functions. To use Update, just pass
the amount of time (in milliseconds) that has elapsed from the last call to Update
(or the amount of time you want the controller to update the spells).

cSpellController::render

The last of the functions, Render, is used to render all spell meshes that are in effect.
Providing the Render function with an optional frustum and viewing distance helps
alter the way the meshes are rendered.