Putting Together a Full Game(9)
The Application init Function
As the starting point of the game, the init function initializes the system (including
the graphics, sound, and input systems), sets up the character and spell controllers,
loads the master item list, pushes the main menu state, and carries out a few miscellaneous
functions. Take a look at the Init function piece by piece to see what’s
going on:
{
create_display(g_hwnd, CLIENT_WIDTH, CLIENT_HEIGHT, 16, true , true );
set_perspective(0.6021124f, 1.3333f, 1.0f, 20000.0f);
ShowCursor(TRUE);
create_font(&m_font, "Consolas", 16, false , false );
m_input.create(g_hwnd, get_window_inst());
m_keyboard.create_keyboard(&m_input);
m_mouse.create_mouse(&m_input, true );
m_sound.init(g_hwnd, 22050, 1, 16, DSSCL_PRIORITY);
m_sound_channel.create(&m_sound, 22050, 1, 16);
m_music_channel.attach(&m_sound);
// load the master item list
FILE* fp = fopen("..\\Data\\Game.mil", "rb");
if (fp == NULL)
return false ;
fread(m_mil, 1, sizeof (m_mil), fp);
fclose(fp);
// initialize the character controller
m_game_chars.init(m_font, "..\\Data\\Game.mcl", m_mil, m_game_spells.get_spell_list(),
array_num(g_char_mesh_files), g_char_mesh_files,
"..\\Data\\", "..\\Data\\",
array_num(g_char_anims), g_char_anims);
m_game_chars.attach_app( this );
// initialize the spell controller
if (! m_game_spells.init("..\\Data\\Game.msl", array_num(g_spell_mesh_files), g_spell_mesh_files, "..\\Data\\"))
return false ;
m_game_spells.attach_app( this );
m_game_chars.attach(&m_game_spells);
m_game_spells.attach(&m_game_chars);
m_game_script.attach_app( this );
if (! load_texture_from_file(&m_charge_bar, "..\\Data\\ChargeBar.bmp", 0, D3DFMT_UNKNOWN))
return false ;
// create the main, header, and stats text windows.
m_text_window.create(m_font);
m_text_header.create(m_font);
m_text_stats.create(m_font);
// position all text windows
m_text_window.move(2, 2, 636, 476, -1, -1, COLOR_DARK_BLUE, COLOR_ARGENTINE);
m_text_header.move(2, 2, 128, 32, -1, -1, COLOR_HALF_RED, COLOR_ARGENTINE);
m_text_stats.move(2, 2, 128, 48, -1, -1, COLOR_DARK_BLUE, COLOR_ARGENTINE);
// push the main menu state, setting menu optios first.
g_menu_options = MENU_LOAD;
m_state_manager.push(menu_frame, this );
return true ;
}
Graphics is the first order of business here—you initialize the graphics system and
set the video mode. You then set the perspective to match that of the 3-D modeler
used to render the backdrops. Finally, you create a font to use throughout the
game and display the mouse cursor.
Next, you initialize the input system and create two device interfaces—one for the
keyboard and the other for the mouse.
Rounding out the Graphics Core initialization code, you initialize the sound system
and create the sound and music channels.
Now, you initialize the game-specific data and interfaces. You load the master item
list and initialize the character controller and spell controllers.
You're about halfway through the init function. At this point, you load a bitmap
that display the player's charge meter, and you create and position the text windows.
Rounding off the Init function, you make a call to the derived script class that tells
the script which application class interface to use. Following that, you push the first
of the game states, the main menu, onto the state stack.
The shutdown Function
What good is the Init function without a matching Shutdown function to shut down
and free used resources in the game? The cApp::shutdown function does just that.
{
m_state_manager.pop_all( this );
free_level();
}
Processing Frames with the frame Function
For every frame that the game is updated, the application class’s frame function is
called. To limit how often the game actually updates, however, a timer is maintained
that limits further frame processing to 30 frames a second. This process of limiting
the updates takes up the first half of the Frame function, as shown here:
{
static DWORD update_timer = timeGetTime();
// limit all frame updates to 30 fps
if (timeGetTime() < update_timer + 33)
return true ;
update_timer = timeGetTime();
m_keyboard.acquire();
m_keyboard.read();
m_mouse.acquire();
m_mouse.read();
return m_state_manager.process_top( this );
}
As I mentioned, the game is updated 30 times a second. Each frame that the game
is updated, the keyboard and mouse’s states are read in, and the current state is
processed.
As states are inserted into the state stack, the uppermost
state executes when cManager::process_top is called, as shown in the frame function.