download source
and solution
Demonstrating
Characters with the Chars Demo
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.
In the Chars demo, you take
control of the PC, using the arrow keys to turn and
move him. The controls are straightforward—use the space bar to interact with
the
closest character (either to speak to an NPC or to attack a monster). Pressing
the
number keys 1 through 3 casts a few spells at the closest monster.
Each character in the game
demonstrates a single artificial intelligence. Speaking
to another character conveys which artificial intelligence a particular
character uses
(except for monsters, which either stand still or follow the player character).
It’s
best to quickly dispatch the monsters before they take your player character
out.
Everything in the Chars demo
has been explained in this chapter. A script class
determines which characters to place in the map during startup (as detailed in
the
startup script) and what each character does or says when spoken to.
The demo’s action template,
default.mla, contains a number of script actions that
directly modify a character’s type, artificial intelligence, position, and
direction.
Adding characters to the world is as easy as using an add character script
action,
and from there, you modify the character’s attributes accordingly.
As for the main application,
the system core’s cApp class is being used to
control the flow of the demo; each frame update is regulated to 33-millisecond
lapses, giving a 30-frames-per-second update rate. At each and every frame,
keyboard
input is read in and stored, waiting to be used during the PC update function.
A fixed camera renders out the action, with each character fully animated
inside a single level (both characters and the level represented by meshes).
The code to the demo is well
commented, so enjoy exploring it, and find out how
quickly you can create characters running around in your game project. Be sure
to
check out the scripts and script action template using the Mad Lib Script
editor, as
well as the items and character definitions using the MIL and MCL Editors.
Main Routine
Source:
WinMain.h:
#ifndef WIMMAIN_H
#define WINMAIN_H
#include "core_framework.h"
#include "core_input.h"
#include "text_window.h"
#include "char_ics.h"
#include "char.h"
#include "script.h"
#include "spell.h"
class cApp;
/*************************************************************************************************/
class cGameCharController : public cCharController
{
private:
cApp* m_app;
private:
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);
public:
void set_data(cApp* app)
{
m_app = app;
}
};
/*************************************************************************************************/
class cGameScript : public cScript
{
friend cApp;
private:
BOOL m_flags[256];
cApp* m_app;
cInputDevice* m_keyboard;
cGameCharController* m_gc_controller;
long m_num_route_points;
sRoutePoint* m_route;
cTextWindow m_text_window;
ID3DXFont* m_font;
//////////////////////////////////////////////////////////////////////////////////
public:
cGameScript()
{
m_app = NULL;
m_keyboard = NULL;
m_gc_controller = NULL;
m_route = NULL;
m_font = NULL;
ZeroMemory(m_flags, sizeof(m_flags));
}
~cGameScript()
{
delete[] m_route;
}
void set_data(cApp* app, cInputDevice* keyboard, cGameCharController* gc_controller, ID3DXFont* font)
{
m_app = app;
m_keyboard = keyboard;
m_gc_controller = gc_controller;
m_font = font;
m_text_window.create(m_font);
}
//////////////////////////////////////////////////////////////////////////////////
private:
virtual void release()
{
delete[] m_route;
m_route = NULL;
m_num_route_points = 0;
}
virtual sScriptInfo* process(sScriptInfo* info)
{
switch(info->action_index)
{
case 0: return script_end(info);
case 1: return script_if_flag_then(info);
case 2: return script_else(info);
case 3: return script_endif(info);
case 4: return script_set_flag(info);
case 5: return script_show_msg(info);
case 6: return script_add_char(info);
case 7: return script_remove_char(info);
case 8: return script_show_char_msg(info);
case 9: return script_set_char_type(info);
case 10: return script_set_char_ai(info);
case 11: return script_set_char_distance(info);
case 12: return script_set_char_bound(info);
case 13: return script_set_target_char(info);
case 14: return script_set_no_target(info);
case 15: return script_create_route(info);
case 16: return script_add_point(info);
case 17: return script_assign_route(info);
case 18: return script_move_char(info);
case 19: return script_set_char_script(info);
}
return NULL; // error executing
}
//////////////////////////////////////////////////////////////////////////////////
private:
sScriptInfo* script_end(sScriptInfo* info)
{
return NULL; // force end of processing
}
sScriptInfo* script_else(sScriptInfo* info)
{
return info->next;
}
sScriptInfo* script_endif(sScriptInfo* info)
{
return info->next;
}
sScriptInfo* script_set_flag(sScriptInfo* info)
{
m_flags[info->entries[0].long_value % 256] = info->entries[1].bool_value;
return info->next;
}
sScriptInfo* script_add_char(sScriptInfo* info)
{
m_gc_controller->add_char(info->entries[0].long_value,
info->entries[1].long_value,
info->entries[2].selection,
info->entries[3].selection,
info->entries[4].float_value,
info->entries[5].float_value,
info->entries[6].float_value,
info->entries[7].float_value);
return info->next;
}
sScriptInfo* script_remove_char(sScriptInfo* info)
{
m_gc_controller->remove(info->entries[0].long_value);
return info->next;
}
sScriptInfo* script_set_char_type(sScriptInfo* info)
{
m_gc_controller->set_char_type(info->entries[0].long_value, info->entries[1].selection);
return info->next;
}
sScriptInfo* script_set_char_ai(sScriptInfo* info)
{
m_gc_controller->set_char_ai(info->entries[0].long_value, info->entries[1].selection);
return info->next;
}
sScriptInfo* script_set_char_distance(sScriptInfo* info)
{
m_gc_controller->set_char_distance(info->entries[0].long_value, info->entries[1].float_value);
return info->next;
}
sScriptInfo* script_set_char_bound(sScriptInfo* info)
{
m_gc_controller->set_char_bound(info->entries[0].long_value,
info->entries[1].float_value,
info->entries[2].float_value,
info->entries[3].float_value,
info->entries[4].float_value,
info->entries[5].float_value,
info->entries[6].float_value);
return info->next;
}
sScriptInfo* script_set_target_char(sScriptInfo* info)
{
m_gc_controller->set_target_char(info->entries[0].long_value, info->entries[1].long_value);
return info->next;
}
sScriptInfo* script_set_no_target(sScriptInfo* info)
{
m_gc_controller->set_target_char(info->entries[0].long_value, -1);
return info->next;
}
sScriptInfo* script_create_route(sScriptInfo* info)
{
delete[] m_route;
m_route = NULL;
m_num_route_points = 0;
m_num_route_points = info->entries[0].long_value;
m_route = new sRoutePoint[m_num_route_points];
return info->next;
}
sScriptInfo* script_add_point(sScriptInfo* info)
{
long route_index = info->entries[0].long_value;
m_route[route_index].pos_x = info->entries[1].float_value;
m_route[route_index].pos_y = info->entries[2].float_value;
m_route[route_index].pos_z = info->entries[3].float_value;
return info->next;
}
sScriptInfo* script_assign_route(sScriptInfo* info)
{
m_gc_controller->set_char_route(info->entries[0].long_value, m_num_route_points, m_route);
return info->next;
}
sScriptInfo* script_move_char(sScriptInfo* info)
{
m_gc_controller->move_char(info->entries[0].long_value,
info->entries[1].float_value,
info->entries[2].float_value,
info->entries[3].float_value);
return info->next;
}
sScriptInfo* script_set_char_script(sScriptInfo* info)
{
m_gc_controller->set_char_script(info->entries[0].long_value, info->entries[1].text);
return info->next;
}
//////////////////////////////////////////////////////////////////////////////////
private:
sScriptInfo* script_if_flag_then(sScriptInfo* info);
sScriptInfo* script_show_msg(sScriptInfo* info);
sScriptInfo* script_show_char_msg(sScriptInfo* info);
void render_scene_and_msg();
};
/*************************************************************************************************/
class cApp : public cFramework
{
friend class cGameScript;
friend class cGameCharController;
private:
cCamera m_camera;
cInput m_input;
cInputDevice m_keyboard;
cInputDevice m_mouse;
cMesh m_terrain_mesh;
cObject m_terrain_object;
cGameCharController m_gc_controller;
cSpellController m_spell_controller;
cGameScript m_game_script;
sItem m_mil[1024];
ID3DXFont* m_font;
public:
bool init();
bool frame();
long get_input();
bool check_intersect(float x_start, float y_start, float z_start,
float x_end, float y_end, float z_end);
};
#endif
WinMain.cpp:
#include "core_common.h"
#include "core_graphics.h"
#include "char.h"
#include "script.h"
#include "text_window.h"
#include "tool.h"
#include "WinMain.h"
#define PRESS_UP 1
#define PRESS_RIGHT 2
#define PRESS_DOWN 4
#define PRESS_LEFT 8
#define PRESS_SPACE 16
#define PRESS_1 32
#define PRESS_2 64
#define PRESS_3 128
#define CLIENT_WIDTH 800
#define CLIENT_HEIGHT 600
cApp g_app;
// Global names of character meshes
PCSTR g_char_mesh_names[] = {
"..\\Data\\Warrior.x", // Mesh # 0
"..\\Data\\Yodan.x" // Mesh # 1
};
sCharAnimInfo g_char_anim_infos[] = {
{ "Idle", true },
{ "Walk", true },
{ "Swing", false },
{ "Spell", false },
{ "Swing", false },
{ "Hurt", false },
{ "Die", false },
{ "Idle", true }
};
PCSTR g_spell_mesh_names[] = {
"..\\Data\\Fireball.x",
"..\\Data\\Explosion.x",
"..\\Data\\Groundball.x",
"..\\Data\\ice.x",
"..\\Data\\bomb.x",
};
int WINAPI WinMain(HINSTANCE inst, HINSTANCE, LPSTR cmd_line, int cmd_show)
{
DWORD pos_x = (get_screen_width() - CLIENT_WIDTH) / 2;
DWORD pos_y = (get_screen_height() - CLIENT_HEIGHT) / 4;
build_window(inst, "CharClass", "Characters Demo",
WS_BORDER | WS_CAPTION | WS_MINIMIZEBOX | WS_SYSMENU,
pos_x, pos_y, CLIENT_WIDTH, CLIENT_HEIGHT);
g_app.run();
return 0;
}
/*************************************************************************************************/
void cGameCharController::pc_update(sCharacter* character, long elapsed,
float* x_move, float* y_move, float* z_move)
{
if(character->id != CHAR_PC)
return;
float speed = elapsed/1000.0f * get_speed(character);
// rotate character
long action = m_app->get_input();
if(action & PRESS_RIGHT)
{
character->direction += (elapsed/1000.0f * 8);
character->action = CHAR_MOVE;
}
if(action & PRESS_LEFT)
{
character->direction -= (elapsed/1000.0f * 8);
character->action = CHAR_MOVE;
}
// walk forward
if(action & PRESS_UP)
{
*x_move = sin(character->direction) * speed;
*z_move = cos(character->direction) * speed;
character->action = CHAR_MOVE;
}
sCharacter* char_ptr;
float x_diff, y_diff, z_diff, dist;
// attack a nearby monster or process NPC script
if(action & PRESS_SPACE)
{
for(char_ptr = get_root_char(); char_ptr != NULL; char_ptr = char_ptr->next)
{
// only check other characters
if(char_ptr->id == character->id)
continue;
x_diff = fabs(char_ptr->pos_x - character->pos_x);
y_diff = fabs(char_ptr->pos_y - character->pos_y);
z_diff = fabs(char_ptr->pos_z - character->pos_z);
dist = x_diff * x_diff + y_diff * y_diff + z_diff * z_diff;
// only check characters within 1000.0 units distance
if(dist > 10000.0f)
continue;
if(char_ptr->script_filename[0])
m_app->m_game_script.execute(char_ptr->script_filename);
else
{
// turn toward victim
x_diff = char_ptr->pos_x - character->pos_x;
z_diff = char_ptr->pos_z - character->pos_z;
character->direction = atan2(x_diff, z_diff);
character->victim = char_ptr;
char_ptr->attacker = character;
m_app->m_gc_controller.set_char_action(character, CHAR_ATTACK, 0);
}
break;
}
}
long spell_index = 0;
// cast spells
if(action & PRESS_1 || action & PRESS_2 || action & PRESS_3)
{
// get spell index to cast
if(action & PRESS_1) spell_index = 0;
if(action & PRESS_2) spell_index = 1;
if(action & PRESS_3) spell_index = 2;
float spell_max_dist = m_app->m_spell_controller.get_spell(spell_index)->max_dist;
// search for closest monster
for(char_ptr = get_root_char(); char_ptr != NULL; char_ptr = char_ptr->next)
{
if(char_ptr->type == CHAR_MONSTER)
{
x_diff = fabs(char_ptr->pos_x - character->pos_x);
y_diff = fabs(char_ptr->pos_y - character->pos_y);
z_diff = fabs(char_ptr->pos_z - character->pos_z);
dist = x_diff * x_diff + y_diff * y_diff + z_diff * z_diff;
if(dist <= (spell_max_dist * spell_max_dist))
{
character->spell_index = spell_index;
character->target_type = CHAR_MONSTER;
character->target_x = char_ptr->pos_x;
character->target_y = char_ptr->pos_y;
character->target_z = char_ptr->pos_z;
// turn toward victim
x_diff = char_ptr->pos_x - character->pos_x;
z_diff = char_ptr->pos_z - character->pos_z;
character->direction = atan2(x_diff, z_diff);
m_app->m_gc_controller.set_char_action(character, CHAR_SPELL, 0);
break;
}
}
}
}
}
///////////////////////////////////////////////////////////////////////////////////
bool cGameCharController::validate_move(sCharacter* character,
float* x_move, float* y_move, float* z_move)
{
// check against terrain mesh for collision
return ! m_app->check_intersect(character->pos_x, character->pos_y + 2.0f, character->pos_z,
*x_move + character->pos_x, *y_move + character->pos_y + 2.0f, *z_move + character->pos_z);
}
/*************************************************************************************************/
void cGameScript::render_scene_and_msg()
{
clear_display(0, 1.0);
if(begin_display_scene())
{
enable_zbuffer();
g_app.m_terrain_object.render();
g_app.m_gc_controller.render(-1, NULL, 0);
g_app.m_spell_controller.render(NULL, 0);
m_text_window.render(NULL, 0);
end_display_scene();
}
present_display();
}
///////////////////////////////////////////////////////////////////////////////////
sScriptInfo* cGameScript::script_if_flag_then(sScriptInfo* info)
{
bool skip;
// see if a flag matches second entry
if(m_flags[info->entries[0].long_value % 256] == info->entries[1].bool_value)
skip = false;
else
skip = true;
// At this point, Skip states if the script actions need to be skipped due to a conditional
// if..then statement.
//
// Actions are further processed if skip = false, looking for an else to flip the skip mode,
// or an endif to end the conditional block.
info = info->next;
while(info)
{
if(info->action_index == 2) // if else, flip skip mode.
skip = !skip;
else if(info->action_index == 3) // break on end if
return info->next;
// Process script function in conditional block, making sure to skip actions when condition not met.
if(skip)
info = info->next;
else
{
if((info = process(info)) == NULL)
return NULL;
}
}
return NULL; // end of script reached
}
///////////////////////////////////////////////////////////////////////////////////
sScriptInfo* cGameScript::script_show_msg(sScriptInfo* info)
{
m_text_window.set_text(info->entries[0].text, COLOR_WHITE);
m_text_window.move(10, 10, CLIENT_WIDTH-20, 0, -1, -1, COLOR_BLACK, COLOR_ARGENTINE);
render_scene_and_msg();
// wait for a key press
m_keyboard->acquire();
m_keyboard->m_locks[KEY_SPACE] = true;
m_keyboard->set_key_state(KEY_SPACE, false);
while(1)
{
m_keyboard->read();
if(m_keyboard->get_key_state(KEY_SPACE))
break;
}
m_keyboard->m_locks[KEY_SPACE] = true;
m_keyboard->set_key_state(KEY_SPACE, false);
return info->next;
}
///////////////////////////////////////////////////////////////////////////////////
sScriptInfo* cGameScript::script_show_char_msg(sScriptInfo* info)
{
D3DXMATRIX mat_world, mat_view, mat_proj;
D3DXMatrixIdentity(&mat_world);
get_display_view_matrix(&mat_view);
get_display_proj_matrix(&mat_proj);
D3DVIEWPORT9 viewport;
get_display_viewport(&viewport);
// get the character's coordinates
float max_y;
sCharacter* character = m_gc_controller->get_char(info->entries[1].long_value);
character->object.get_bounds(NULL, NULL, NULL, NULL, &max_y, NULL, NULL);
// project the 3D coordinates in 2D coordinates
D3DXVECTOR3 target_vec;
D3DXVECTOR3 source_vec(character->pos_x, character->pos_y + max_y, character->pos_z);
D3DXVec3Project(&target_vec, &source_vec, &viewport, &mat_proj, &mat_view, &mat_world);
m_text_window.set_text(info->entries[0].text, D3DCOLOR_RGBA(255, 255, 0, 255));
m_text_window.move(10, 10, CLIENT_WIDTH-20, 0, target_vec.x, target_vec.y,
D3DCOLOR_RGBA(0, 30, 60, 255), COLOR_ARGENTINE);
// display the window while waiting for a keypress
m_keyboard->acquire();
m_keyboard->m_locks[KEY_SPACE] = true;
m_keyboard->set_key_state(KEY_SPACE, false);
while(1)
{
m_keyboard->read();
if(m_keyboard->get_key_state(KEY_SPACE))
break;
render_scene_and_msg();
}
m_keyboard->m_locks[KEY_SPACE] = true;
m_keyboard->set_key_state(KEY_SPACE, false);
return info->next;
}
/*************************************************************************************************/
bool cApp::init()
{
create_display(g_hwnd, CLIENT_WIDTH, CLIENT_HEIGHT, 16, true, true);
set_perspective(D3DX_PI/4, 1.3333f, 1.0f, 10000.0f);
create_font(&m_font, "Arial", 16, true, false);
m_input.create(g_hwnd, get_window_inst());
m_keyboard.create_keyboard(&m_input);
m_mouse.create_mouse(&m_input, true);
m_terrain_mesh.load("..\\Data\\World.x", "..\\Data\\");
m_terrain_object.create(&m_terrain_mesh);
// load the master item list
ZeroMemory(m_mil, sizeof(m_mil));
FILE* fp;
if((fp = fopen("..\\Data\\Default.mil", "rb")) == NULL)
return false;
fread(m_mil, 1, sizeof(m_mil), fp);
fclose(fp);
m_spell_controller.init("..\\Data\\Default.msl",
array_num(g_spell_mesh_names), g_spell_mesh_names,
"..\\Data\\");
m_gc_controller.init(m_font, "..\\Data\\Default.mcl",
m_mil, m_spell_controller.get_spell_list(),
array_num(g_char_mesh_names), g_char_mesh_names,
"..\\Data\\", "..\\Data\\",
array_num(g_char_anim_infos), g_char_anim_infos);
m_spell_controller.attach(&m_gc_controller);
m_gc_controller.attach(&m_spell_controller);
m_gc_controller.set_data(this);
// add the character player
m_gc_controller.add_char(0, 0, CHAR_PC, CHAR_STAND, 0.0f, 0.0f, 0.0f, 3.14f);
// process the startup script
m_game_script.set_data(this, &m_keyboard, &m_gc_controller, m_font);
m_game_script.execute("..\\Data\\Startup.mls");
return true;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
bool cApp::frame()
{
static DWORD update_counter = timeGetTime();
// lock to 30fps
if(timeGetTime() < update_counter + 33)
return true;
update_counter = timeGetTime();
m_keyboard.acquire();
m_keyboard.read();
// exit if ESC pressed
if(m_keyboard.get_key_state(KEY_ESC))
return false;
m_gc_controller.update(33);
m_spell_controller.update(33);
m_camera.point(0.0f, 700.0f, -700.0f, 0.0f, 0.0f, 0.0f);
set_display_camera(&m_camera);
clear_display(0, 1.0f);
if(begin_display_scene())
{
enable_zbuffer();
m_terrain_object.render();
m_gc_controller.render(-1, NULL, 0);
m_spell_controller.render(NULL, 0);
static sCharacter* character = m_gc_controller.get_char(0);
char stats[128];
sprintf(stats, "HP: %ld / %ld\r\nMP: %ld / %ld",
character->health_points, character->char_def.health_points,
character->mana_points, character->char_def.mana_points);
draw_font(m_font, stats, 2, 2, 0, 0, COLOR_WHITE, DT_LEFT);
end_display_scene();
}
present_display();
return true;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
long cApp::get_input()
{
long action = 0;
if(m_keyboard.get_key_state(KEY_UP) || m_keyboard.get_key_state(KEY_W))
action |= PRESS_UP;
if(m_keyboard.get_key_state(KEY_RIGHT) || m_keyboard.get_key_state(KEY_D))
action |= PRESS_RIGHT;
if(m_keyboard.get_key_state(KEY_DOWN) || m_keyboard.get_key_state(KEY_S))
action |= PRESS_DOWN;
if(m_keyboard.get_key_state(KEY_LEFT) || m_keyboard.get_key_state(KEY_A))
action |= PRESS_LEFT;
if(m_keyboard.get_key_state(KEY_SPACE))
{
action |= PRESS_SPACE;
m_keyboard.m_locks[KEY_SPACE] = true;
m_keyboard.set_key_state(KEY_SPACE, false);
}
if(m_keyboard.get_key_state(KEY_1))
{
action |= PRESS_1;
m_keyboard.m_locks[KEY_1] = true;
m_keyboard.set_key_state(KEY_1, false);
}
if(m_keyboard.get_key_state(KEY_2))
{
action |= PRESS_2;
m_keyboard.m_locks[KEY_2] = true;
m_keyboard.set_key_state(KEY_2, false);
}
if(m_keyboard.get_key_state(KEY_3))
{
action |= PRESS_3;
m_keyboard.m_locks[KEY_3] = true;
m_keyboard.set_key_state(KEY_3, false);
}
return action;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
bool cApp::check_intersect(float x_start, float y_start, float z_start,
float x_end, float y_end, float z_end)
{
for(sMeshInfo* mesh_info = m_terrain_mesh.get_root_mesh(); mesh_info != NULL; mesh_info = mesh_info->m_next)
{
if(is_ray_intersect_mesh(mesh_info->m_d3d_mesh, x_start, y_start, z_start, x_end, y_end, z_end, NULL))
return true;
}
return false;
}