main.c

//main.c
/******************************************************************************
* MAY FIRST - A game inspired by http://en.wikipedia.org/wiki/Juno_First
*******************************************************************************
* The main control loop handles control of frame rate and calls various
* functions that make up the game, like input handling, screen updates, etc.
* Some basic mathematical functions and types are kept here as well.
******************************************************************************/

#include <stdarg.h>
#include <sys/time.h>     // gettimeofday()

#include "main.h"         // Flow control, program state, run modes
#include "draw_frame.h"   // Renders the current game state to screen
#include "game.h"         // Game related settings, game state control
#include "world.h"        // Simulation, advances game state step wise
#include "ui.h"           // Window settings, process_event_queue()


// GLOBAL VARIABLES ///////////////////////////////////////////////////////////

program_state_t program_state = {
	.run_mode        = RM_INIT,
	.window_width    = INITIAL_WINDOW_WIDTH,
	.window_height   = INITIAL_WINDOW_HEIGHT,
	.next_fps_sample = 0,
	.frame_times     = {0},   // See:
	// http://stackoverflow.com/questions/5636070/zero-an-array-in-c-code
	.initial_TAS     = -1,
	.debug           = DEBUG,

#if START_IN_FULLSCREEN
	.screen_flags = SDL_OPENGL | SDL_DOUBLEBUF | SDL_FULLSCREEN,
#else
	.screen_flags = SDL_OPENGL | SDL_DOUBLEBUF | SDL_RESIZABLE,
#endif
};

game_state_t game_state;


// COMMON HELPERS /////////////////////////////////////////////////////////////

void debugf( bool_t do_print, char* format_string, ... )
{
#if DEBUG
	if (do_print) {
		va_list argp;

		va_start( argp, format_string );
		vprintf( format_string, argp );
		va_end(argp);
	}
#endif
}

/* error_quit()
 * When an error occurs, this function is used to terminate the program with
 * a useful error message.
 */
void error_quit( char* error_message )
{
	fprintf( stderr, "Error: %s\n", error_message );
	exit( -1 );
}

/* get_time()
 * Returns time in microseconds.
 */
microtime_t get_time( void )
{
	struct timeval t;
	gettimeofday( &t, NULL );
	return ((microtime_t)t.tv_sec * 1000000) + t.tv_usec;
}


// MATH HELPERS ///////////////////////////////////////////////////////////////

vector_t vector( real_t x, real_t y, real_t z )
{
	vector_t ret;

	ret.x = x;
	ret.y = y;
	ret.z = z;

	return ret;
}

void round_vector( vector_t* v )
{
	v->x = round( v->x );
	v->y = round( v->y );
	v->z = round( v->z );
}

vector_t add_vector( vector_t base, vector_t offset )
{
	vector_t result;

	result.x = base.x + offset.x;
	result.y = base.y + offset.y;
	result.z = base.z + offset.z;

	return result;
}

vector_t subtract_vector( vector_t base, vector_t offset )
{
	vector_t result;

	result.x = base.x - offset.x;
	result.y = base.y - offset.y;
	result.z = base.z - offset.z;

	return result;
}

real_t vector_length( vector_t v )
{
	return sqrt( v.x*v.x + v.y*v.y + v.z*v.z );
}

vector_t multiply_vector_scalar( vector_t v, real_t scalar )
{
	v.x *= scalar;
	v.y *= scalar;
	v.z *= scalar;

	return v;
}

vector_t unity_vector( vector_t v )
{
	real_t length = vector_length(v);

	if (length == 0) {
		fprintf( stderr, "unity_vector(): length == 0\n" );
		return multiply_vector_scalar( v, 0 );
	}
	else {
		return multiply_vector_scalar( v, 1/length );
	}
}

int sgn( int r )
{
	return (r > 0) - (r < 0);
}

real_t fsgn( real_t r )
{
	return (r > 0) - (r < 0);
}

int min( int a, int b )
{
	return (a < b) ? a : b ;
}

int max( int a, int b )
{
	return (a > b) ? a : b ;
}


// MAIN PROGRAM ///////////////////////////////////////////////////////////////

/* save_frame_time()
 * Stores a record of measured frame calculation time into an array used for
 * finding the average frame rate over the last  NR_FPS_SAMPLES  samples.
 */
void save_frame_time( program_state_t* PS )
{
	++PS->next_fps_sample;
	PS->next_fps_sample %= NR_FPS_SAMPLES;
	PS->frame_times[ PS->next_fps_sample ] = PS->frame_time_us;
}

/* calculate_frames_per_second()
 * Returns the average for all  NR_FPS_SAMPLES  samples
 */
real_t average_frame_time( program_state_t* PS )
{
	int i;
	int active_samples = 0;
	microtime_t Tsum = 0;

	for( i = 0 ; i < NR_FPS_SAMPLES ; i++ ) {
		if (PS->frame_times[i] > 0) {
			++active_samples;
			Tsum += PS->frame_times[i];
		}
	}

	return Tsum / (real_t)active_samples;
}

/* main()
 * Program entry point. Initializes everything and runs the main loop.
 * Times are calculated and the frame rate is controlled here.
 */
int main( int argc, char* argv[] )
{
	program_state_t* PS  = &program_state;
	game_state_t*    GS  = &game_state;
	sounds_t*      	 snd = &(GS->sounds);

	PS->program_start_us = get_time();

	init_sdl( PS, GS );     // Create window, load sounds
	init_sound( PS, GS );   // Load music, sounds, set volume
	init_font( PS );        // Load font
	init_opengl( PS );      // Load textures

	play_music( snd->music );

	load_highscore( GS );

	PS->current_time_us    =
	PS->frame_start_us     = get_time();

	// Make the following look nice in debug info
	PS->game_start_us      =
	PS->pause_since_us     = PS->program_start_us - 1;

	PS->tick_fraction_s    = -1;

	PS->highest_frame_time = 0;
	PS->lowest_frame_time  = 99999999;

	PS->run_mode = RM_INTRO;

	while (PS->run_mode != RM_EXIT) {

		PS->current_time_us = get_time();

		// Calculate how much time we need to waste for target FPS
		PS->delay_until_us
			= PS->current_time_us
			+ (1000000 / TARGET_FPS)
		;


		// Keep track of game time (handling pause)
		if ( !(PS->run_mode & (RM_PAUSE | RM_MAIN_MENU)) ) {
			PS->game_time_us
				= PS->current_time_us
				- PS->game_start_us
			;

		}

		// Show intro after main menu idles for a while
		if (PS->run_mode == RM_MAIN_MENU) {
			if (PS->main_menu_since_us
				+ MAIN_MENU_INTRO_SWITCH_TIME < get_time()) {
				PS->run_mode = RM_INTRO;
			}
		}

		// Handle user input
		process_event_queue( PS, GS );

		// Let the universe live for a short moment
		if (PS->run_mode & (RM_RUNNING | RM_AFTER_LIFE)) {
			advance_simulation( PS, GS );
		}

		// Display the current world status as game scene
		draw_frame( PS, GS );

#if LIMIT_FPS
		// Waste time until the next frame needs to be drawn
		while (get_time() < PS->delay_until_us) {
	#if LIMIT_FPS_USING_SDL_DELAY
			SDL_Delay( 1 );
	#endif
		}
#endif
		// Keep track of how many FPS we actually achieved
		PS->frame_time_us   = get_time() - PS->frame_start_us;

		PS->highest_frame_time = max(
			PS->highest_frame_time,
			PS->frame_time_us
		);
		PS->lowest_frame_time = min(
			PS->lowest_frame_time,
			PS->frame_time_us
		);

		PS->frame_start_us  = get_time();
		PS->tick_fraction_s = (real_t)PS->frame_time_us / 1000000.0;

		save_frame_time( PS );   // For average FPS
		PS->average_frame_time = average_frame_time( PS );
	}

	save_highscore( PS, GS );

	glDeleteTextures( 1, &(PS->textures.background) );
	glDeleteTextures( 1, &(PS->textures.digits) );

	Mix_FreeChunk( snd->laser );
	Mix_FreeChunk( snd->hit );
	Mix_FreeChunk( snd->punch );
	Mix_FreeChunk( snd->blast );
	Mix_FreeChunk( snd->denied );
	Mix_FreeChunk( snd->alarm );
	Mix_FreeChunk( snd->blub );

	Mix_FreeChunk( snd->computer_autofire );
	Mix_FreeChunk( snd->computer_doubleshot );
	Mix_FreeChunk( snd->computer_roundshot );
	Mix_FreeChunk( snd->computer_danger );
	Mix_FreeChunk( snd->computer_weaponlost );

	Mix_FreeMusic( snd->music );

	SDL_Quit();   // Will (allegedly) also free  screen .

	return 0;
}


//EOF