Controlling Characters
The characters are the heart
and soul of your game.
You derive the character
controller in order to
control the player of the game and to collision-check a character's movements
against the maps. For The Tower, you can use a derived character controller,
to manage all your game's characters. The first step to
using the character controller in a game is to derive your own class from
cCharController:
class cGameChars : public cCharController
{
private:
cApp* m_app;
////////////////////////////////////////////////////////////////////////////////
public:
void attach_app(cApp* app)
{
m_app = app;
}
private:
virtual void drop_money(float x_pos, float y_pos, float z_pos, long quantity);
virtual bool gain_exp(sCharacter* character, long amount);
virtual bool pc_teleport(sCharacter* character, const sSpell* spell);
virtual void pc_update(sCharacter* character, long elapsed,
float* x_move, float* y_move, float* z_move);
virtual bool validate_move(sCharacter* character, float* x_move, float* y_move, float* z_move);
virtual void play_action_sound(const sCharacter* character);
};
The cGameChars class comes with
only one public function, attach_app.
You use the cGameChars
function to set the application class pointer in the cGameChars class instance.
In addition,
the cGameChars class overrides only the functions used to move the player and to
validate
all character movements. The remaining functions come into play when the player
gains experience points from combat or teleports the character with a spell,
when
the character controller plays a sound, when a monster drops some money, or
when a monster drops an item after being killed.
Because the derived character
controller class requires access to the application
class, you must precede all calls to the cGameChars class with a call to the
attach_app function.
The attach_app function takes one
argument—the pointer to the application class.
The other functions, such as
gain_exp, drop_money, tell the game
engine
that a monster was killed and that the game needs to reward the player with
experience,
money from a dying monster. These rewards are pushed
aside until combat ends, at which point, the application class's end_of_combat
function
processes them.
void cGameChars::drop_money(float x_pos, float y_pos, float z_pos, long quantity)
{
m_app->m_combat_money += quantity;
}
bool cGameChars::gain_exp(sCharacter* character, long amount)
{
m_app->m_combat_exp += amount;
return false; // do not display message
}
bool cGameChars::pc_teleport(sCharacter* character, const sSpell* spell)
{
// teleport player to town
m_app->teleport_player(1, 100.0f, 0.0f, -170.0f);
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
bool cGameChars::validate_move(sCharacter* character, float* x_move, float* y_move, float* z_move)
{
float pos_x = character->pos_x;
float pos_y = character->pos_y;
float pos_z = character->pos_z;
// check against terrain mesh for collision
if(m_app->check_intersect(pos_x, pos_y + 8.0f, pos_z,
pos_x + *x_move, pos_y + 8.0f + *y_move, pos_z + *z_move,
NULL))
return false;
// get new height
float height = m_app->get_height_below(pos_x + *x_move, pos_y + 32.0f, pos_z + *z_move);
*y_move = height - pos_y;
// check against barriers and clear movement if any
if(m_app->m_barrier.get_barrier(pos_x + *x_move, pos_y + *y_move, pos_z + *z_move))
(*x_move) = (*y_move) = (*z_move) = 0.0f;
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void cGameChars::play_action_sound(const sCharacter* character)
{
long sound = 0;
// play sound based on character type and action
switch(character->action)
{
case CHAR_ATTACK:
m_app->play_sound(character->id == ID_PLAYER ? SOUND_CHAR_ATTACK : SOUND_MONSTER_ATTACK);
break;
case CHAR_SPELL:
if(character->spell_index == SPELL_FIREBALL)
sound = SOUND_FIREBALL;
else if(character->spell_index == SPELL_ICE)
sound = SOUND_ICE;
else if(character->spell_index == SPELL_HEAL)
sound = SOUND_HEAL;
else if(character->spell_index == SPELL_TELEPORT)
sound = SOUND_TELEPORT;
else if(character->spell_index == SPELL_GROUNDBALL)
sound = SOUND_GROUNDBALL;
else if(character->spell_index == SPELL_CONCUSSION)
sound = SOUND_CONCUSSION;
else if(character->spell_index == SPELL_EVIL_FORCE)
sound = SOUND_EVIL_FORCE;
m_app->play_sound(sound);
break;
case CHAR_HURT:
m_app->play_sound(character->id == ID_PLAYER ? SOUND_CHAR_HURT : SOUND_MONSTER_HURT);
break;
case CHAR_DIE:
m_app->play_sound(character->id == ID_PLAYER ? SOUND_CHAR_DIE : SOUND_MONSTER_DIE);
break;
}
}
The pc_update is the main function of interest here. It determines which keys the
player is pressing and what mouse button is being pressed. Now, take this
function
apart to see what makes it tick:
void cGameChars::pc_update(sCharacter* character, long elapsed,
float* x_move, float* y_move, float* z_move)
{
if(elapsed == 0) // do not update if no elapsed time
return;
// rotate character
if(m_app->m_keyboard.get_key_state(KEY_LEFT) || m_app->m_keyboard.get_key_state(KEY_A))
{
character->direction -= elapsed / 1000.0f * 4.0f;
character->action = CHAR_MOVE;
}
if(m_app->m_keyboard.get_key_state(KEY_RIGHT) || m_app->m_keyboard.get_key_state(KEY_D))
{
character->direction += elapsed / 1000.0f * 4.0f;
character->action = CHAR_MOVE;
}
// calculate move length along x,z axis
if(m_app->m_keyboard.get_key_state(KEY_UP) || m_app->m_keyboard.get_key_state(KEY_W))
{
float speed = elapsed / 1000.0f * m_app->m_game_chars.get_speed(character);
*x_move = sin(character->direction) * speed;
*z_move = cos(character->direction) * speed;
character->action = CHAR_MOVE;
}
// process attack or talk action
if(m_app->m_mouse.get_button_state(MOUSE_LBUTTON))
{
// see which character is being pointed at and make sure if it is a monster.
sCharacter* target = m_app->get_char_at(m_app->m_mouse.get_x_pos(), m_app->m_mouse.get_y_pos());
if(target != NULL)
{
if(target->type == CHAR_NPC) // handle talking to npcs
{
// no distance checks, just process their script.
char filename[MAX_PATH];
sprintf(filename, "..\\Data\\Char%lu.mls", target->id);
m_app->m_game_script.execute(filename);
return; // do not process anymore
}
else if(target->type == CHAR_MONSTER) // handle attacking monsters
{
// get distance to target
float x_diff = fabs(target->pos_x - character->pos_x);
float y_diff = fabs(target->pos_y - character->pos_y);
float z_diff = fabs(target->pos_z - character->pos_z);
float dist = x_diff * x_diff + y_diff * y_diff + z_diff * z_diff;
// offset dist by target's radius
float monster_radius = get_xz_radius(target);
dist -= (monster_radius * monster_radius);
float attack_range = get_xz_radius(character) + character->char_def.attack_range;
// only perform attack if target in range
if(dist <= (attack_range * attack_range))
{
target->attacker = character;
character->victim = target;
// face victim
x_diff = target->pos_x - character->pos_x;
z_diff = target->pos_z - character->pos_z;
character->direction = atan2(x_diff, z_diff);
m_app->m_game_chars.set_char_action(character, CHAR_ATTACK, 0);
}
}
}
}
long spell_index = -1;
// cast magic spll based on NUM key pressed
if(m_app->m_keyboard.get_key_state(KEY_1))
{
m_app->m_keyboard.m_locks[KEY_1] = true;
spell_index = SPELL_FIREBALL;
}
else if(m_app->m_keyboard.get_key_state(KEY_2))
{
m_app->m_keyboard.m_locks[KEY_2] = true;
spell_index = SPELL_ICE;
}
else if(m_app->m_keyboard.get_key_state(KEY_3))
{
m_app->m_keyboard.m_locks[KEY_3] = true;
spell_index = SPELL_HEAL;
}
else if(m_app->m_keyboard.get_key_state(KEY_4))
{
m_app->m_keyboard.m_locks[KEY_4] = true;
spell_index = SPELL_TELEPORT;
}
else if(m_app->m_keyboard.get_key_state(KEY_5))
{
m_app->m_keyboard.m_locks[KEY_5] = true;
spell_index = SPELL_GROUNDBALL;
}
// cast spell if commanded
if(spell_index != -1)
{
sSpell* spell = m_app->m_game_spells.get_spell(spell_index);
// only cast if spell known and has enough mana points
if(char_can_spell(character, spell, spell_index))
{
// see which character is being pointed
sCharacter* target = m_app->get_char_at(m_app->m_mouse.get_x_pos(), m_app->m_mouse.get_y_pos());
if(target && target->type == CHAR_MONSTER)
{
// get distance to target
float x_diff = fabs(target->pos_x - character->pos_x);
float y_diff = fabs(target->pos_y - character->pos_y);
float z_diff = fabs(target->pos_z - character->pos_z);
float dist = x_diff * x_diff + y_diff * y_diff + z_diff * z_diff;
// offset dist by target's radius
float target_radius = get_xz_radius(target);
dist -= (target_radius * target_radius);
float spell_range = get_xz_radius(character) + spell->max_dist;
// only perform spell if target in range
if(dist <= (spell_range * spell_range))
{
character->spell_index = spell_index;
character->target_type = CHAR_MONSTER;
character->target_x = target->pos_x;
character->target_y = target->pos_y;
character->target_z = target->pos_z;
*x_move = *y_move = *z_move = 0.0f; // clear movement
// face victim
x_diff = target->pos_x - character->pos_x;
z_diff = target->pos_z - character->pos_z;
character->direction = atan2(x_diff, z_diff);
set_char_action(character, CHAR_SPELL, 0);
}
}
else if(target == character)
{
if((spell_index == SPELL_HEAL && character->health_points < character->char_def.health_points) ||
(spell_index == SPELL_TELEPORT))
{
character->spell_index = spell_index;
character->target_type = CHAR_PC;
character->target_x = target->pos_x;
character->target_y = target->pos_y;
character->target_z = target->pos_z;
*x_move = *y_move = *z_move = 0.0f; // clear movement
set_char_action(character, CHAR_SPELL, 0);
}
}
}
}
// enter status frame if right mouse buttom pressed
if(m_app->m_mouse.get_button_state(MOUSE_RBUTTON))
{
m_app->m_mouse.m_locks[MOUSE_RBUTTON] = true;
m_app->m_state_manager.push(status_frame, m_app);
}
}
pc_update starts by first
determining whether an update is in order (based on
whether any time has elapsed) and continues by determining which keys (if any)
are pressed on the keyboard. If the up arrow key is pressed, the character moves
forward, whereas if the left or right arrow keys are pressed, the character’s
direction
is modified.
For each
movement that the player performs, such as walking forward or turning
left and right, you need to assign the CHAR_MOVE action to the player's
character.
Notice that even though pressing left or right immediately rotates the player’s
character,
the code does not immediately modify the character’s coordinates. Instead,
you store the direction of travel in the x_move and z_move variables.
You then determine whether the
player has clicked the left mouse button. Remember
from the design of the sample game that clicking the left mouse button on a
nearby
character either attacks the character (if the character is a monster) or speaks
to the
character (if the character is an NPC).
The portion of code just shown
calls upon the get_char_at function, which scans
for the character that is positioned under the mouse cursor. If a character is
found,
you determine which type of character it is; if it is an NPC, you execute the
appropriate
character's script.
On the other hand, if the
character clicked is a monster and that monster is within
attack range, you initiate an attack action.
Coming up to the end of the
pc_update function, the controller needs to determine
whether a spell has been cast at a nearby character. In the game, positioning
the
mouse cursor over a character and pressing one of the number keys (from 1
through
5) casts a spell.
If a spell was cast, the
controller determines whether the player knows the spell and
has enough mana to cast the spell and whether the target character is in range.
At this point, the controller
has determined that the spell can be cast. You need
to store the coordinates of the target, the number of the spell being cast, and
the
player's action in the structure pointed to by the Character pointer.
To finish up the player
character update, the controller determines whether the
player clicked the right mouse button, which opens the character’s status window
(by pushing the character-status state onto the state stack).