FILE *safe_fopen( char *filename, char *mode )
{
	FILE
		*fp;

	ASSERT (filename);

	ASSERT (mode);

	fp = fopen( filename, mode );

	if ( !fp )
	{

		if ( ( *mode == 'r' ) || ( *mode == 'R' ) )
		{

			debug_fatal("Error opening file for reading: %s", filename );
		}
		else if ( ( *mode == 'w' ) || ( *mode == 'W' ) )
		{

			debug_fatal("Error opening file for writing: %s", filename );
		}
		else
		{

			debug_fatal("Error opening file %s", filename );
		}
	}

	return fp;
}

void load_global_options_data (void)
{

	FILE
		*file_ptr;

	int
		size;

	if (!file_exist (global_options_filename))
	{

		return;
	}

	if (!(file_ptr = fopen (global_options_filename, "rb")))
	{

		debug_fatal ("Global: Error loading global options data (file : %s)", global_options_filename);
	}

	//
	// We have to be able to read in previous version of the global options file.
	//

	size = file_size (global_options_filename);

	#ifdef DEBUG

	if (size != sizeof (global_options))
	{
		debug_fatal ("Global: Global options file has changed size (file : %s) - Please delete it", global_options_filename);
	}

	#endif

	if (size > sizeof (global_options))
	{

		debug_fatal ("Global: Global options file is oversized (file : %s) - Please delete it", global_options_filename);
	}

	fread (&global_options, size, 1, file_ptr);

  	fclose (file_ptr);

	//
	// Need to upgrade the version number ( possibly )
	//

	if ( ( get_global_version_number () != application_version_number ) || ( size != sizeof ( global_options ) ) )
	{

		debug_log ( "Upgrading application version number" );

		initialise_global_options_data_version2 ();
	}

	set_global_version_number (application_version_number);
}

int get_regen_sub_type (int type)
{
	int
		regen_type;

	switch (type)
	{
		case ENTITY_TYPE_FIXED_WING:
		{
			regen_type = ENTITY_SUB_TYPE_REGEN_FIXED_WING;

			break;
		}
		
		case ENTITY_TYPE_HELICOPTER:
		{
			regen_type = ENTITY_SUB_TYPE_REGEN_HELICOPTER;

			break;
		}
		
		case ENTITY_TYPE_ROUTED_VEHICLE:
		{
			regen_type = ENTITY_SUB_TYPE_REGEN_GROUND;

			break;
		}
		
		case ENTITY_TYPE_SHIP_VEHICLE:
		{
			regen_type = ENTITY_SUB_TYPE_REGEN_SEA;

			break;
		}
		
		case ENTITY_TYPE_PERSON:
		{
			regen_type = ENTITY_SUB_TYPE_REGEN_PEOPLE;

			break;
		}
		
		case ENTITY_SUB_TYPE_REGEN_NONE:
		{
			debug_fatal ("RG_UPDT: illegal regen sub type: ENTITY_SUB_TYPE_REGEN_NONE");
		}
		
		default:
		{
			debug_fatal ("RG_UPDT: Unknown entity type");
		}
		
	}

	return regen_type;
}

static float get_eo_sensor_fov(eo_params *eo, target_acquisition_systems system)
{
	// TODO: change fov numbers
	float fov = 9.0;

	switch (eo->field_of_view)
	{
		case EO_FOV_MEDIUM:
		{
			if (system == TARGET_ACQUISITION_SYSTEM_FLIR)
				fov = 4.0 * ONE_OVER_SQRT2;
			else  // DTV or DVO
				fov = 2.0 * ONE_OVER_SQRT2;

			break;
		}
		case EO_FOV_WIDE:
		{
			if (system == TARGET_ACQUISITION_SYSTEM_FLIR)
				fov = 15.0 * ONE_OVER_SQRT2;
			else  // DVO
				fov = 9.0 * ONE_OVER_SQRT2;

			break;
		}
		default:
		{
			debug_fatal ("Invalid field of view = %d", eo->field_of_view);

			break;
		}
	}

	return fov;
}

static void *get_local_ptr_value (entity *en, ptr_types type)
{
	waypoint
		*raw;

	void
		*ptr;

	raw = get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case PTR_TYPE_POSITION_ENTITY:
		////////////////////////////////////////
		{
			debug_fatal ("WP_PTR: REMOVE");
			ptr = raw->position_entity;

			break;
		}
		////////////////////////////////////////
		default:
		////////////////////////////////////////
		{
			debug_fatal_invalid_ptr_type (en, type);

			break;
		}
	}

	return (ptr);
}

//.........这里部分代码省略.........
static int number_of_commands = 0;	// number of keymappings in the above array

//**********************************************************************
//
// Function:    check_for_validity
// Date:		21.3.2003
// Author:		Retro
//
// Description:		Should check for duplicate key+modifier combos,
//					and also for typos (?)
//					not yet used
//
//*********************************************************************/
int check_for_validity ( void )
{
	int i = 0;
	int j = 0;
	int numOfDuplicates = 0;

	int tmp_key;
	int tmp_mod;

	for ( i = 0; i < number_of_commands; i++)
	{
		tmp_key = keymaps[i].key;
		tmp_mod = keymaps[i].modifier;

		for ( j = 0; j < number_of_commands; j++)
		{
			if ((keymaps[i].key = tmp_key)&&(keymaps[i].modifier = tmp_mod))
			{
				numOfDuplicates++;
				if (numOfDuplicates > 1)
					debug_fatal ( "Duplicate key+modifier combination (%i) (%i)",tmp_key,tmp_mod );
			}
		}
		numOfDuplicates = 0;
	}

	return 0;
}

//**********************************************************************
//
// Function:    get_DIK_from_string
// Date:		21.3.2003
// Author:		Retro
//
// Description:		returns direct-input-keypress (DIK) on input-string.
//					uses the all_keys array defined above
//
//*********************************************************************/
int get_DIK_from_string ( char* keystring )
{
	int i;
	int retval = 0;

	for ( i = 0; i < NUM_OF_KEYS; i++ )
	{
		if ( strcmp(all_keys[i].key_name,keystring) == 0 )
		{
			retval = all_keys[i].dik_val;
			break;
		}
	}
	if ( retval == 0 )	// kinda crappy way of error checking.. if reval is still 0, obviously no string matched.

void add_default_entity_to_regen_queue (entity_sides side, entity_sub_types group_type)
{
	switch (side)
	{
		case ENTITY_SIDE_BLUE_FORCE:
		{
			add_entity_to_regen_queue (side,
												group_database [group_type].default_entity_type,
												group_database [group_type].default_blue_force_sub_type,
												group_type);

			break;
		}
		case ENTITY_SIDE_RED_FORCE:
		{
			add_entity_to_regen_queue (side,
												group_database [group_type].default_entity_type,
												group_database [group_type].default_red_force_sub_type,
												group_type);

			break;
		}
		default:
		{
			debug_fatal ("RG_UPDT: Invalid Side %d For Default Entity Regen", side);

			break;
		}
	}
}

void set_3d_fogmode ( env_3d *env, fogmodes mode )
{

	ASSERT ( env );

	env->fogmode = mode;

	switch ( mode )
	{

		case FOGMODE_ON_AUTOMATIC:
		case FOGMODE_ON_MANUAL:
		case FOGMODE_OFF:
		{
		
			break;
		}

		default:
		{

			debug_fatal ( "Unknown fogmode in set_3d_fogmode" );

			break;
		}
	}
}

void add_sub_object_index_to_table ( object_3d_sub_object_index_numbers index, object_3d_database_entry *object )
{

	int
		count;

	for ( count = 0; count < number_of_sub_object_table_entries; count++ )
	{

		if ( current_sub_object_table[count].sub_object_index == index )
		{

			int
				offset;

			offset = current_sub_object_table[count].number_of_sub_objects;

			current_sub_object_table[count].sub_objects[offset] = object;

			current_sub_object_table[count].number_of_sub_objects++;

			return;
		}
	}

	debug_fatal ( "Unable to find sub object index in table" );
}

void load_terrain_3d_tree_database ( char *sector_filename, char *data_filename )
{

	FILE
		*fp;

	int
		x_sector,
		z_sector;

	terrain_tree_data
		*tree_data;

	//
	// Memory map the tree data file
	//

	terrain_tree_database = mopen ( data_filename );

	if ( !terrain_tree_database )
	{

		debug_fatal ( "Unable to memory-map %s", data_filename );
	}

	//
	// Open the sector file
	//

	fp = safe_fopen ( sector_filename, "rb" );

	//
	// Go through all the sectors, setting the number of trees and the relevant pointer
	//

	tree_data = terrain_tree_database;

	for ( z_sector = 0; z_sector < terrain_3d_sector_z_max; z_sector++ )
	{

		for ( x_sector = 0; x_sector < terrain_3d_sector_z_max; x_sector++ )
		{

			fread ( &terrain_tree_sectors[z_sector][x_sector].number_of_trees, sizeof ( int ), 1, fp );

			if ( terrain_tree_sectors[z_sector][x_sector].number_of_trees )
			{

				terrain_tree_sectors[z_sector][x_sector].data = tree_data;

				tree_data += terrain_tree_sectors[z_sector][x_sector].number_of_trees;
			}
			else
			{

				terrain_tree_sectors[z_sector][x_sector].data = NULL;
			}
		}
	}
}

void set_3d_lightmode ( env_3d *env, enum LIGHTMODES mode )
{

	ASSERT ( env );

	switch ( mode )
	{

		case LIGHTMODE_NO_LIGHT:
		case LIGHTMODE_AUTOMATIC_LIGHT:
		case LIGHTMODE_MANUAL_LIGHT:
		{

			break;
		}

		default:
		{

			debug_fatal ( "Trying to set an unknown light mode for 3d environment" );

			break;
		}
	}

	env->lightmode = mode;
}

void create_new_pilot_name( entity_sides side, const char **firstname, const char **lastname )
{

	switch( side )
	{
		case ENTITY_SIDE_NEUTRAL:
		case ENTITY_SIDE_BLUE_FORCE:
		{

			*firstname = blue_side_first_name_list[ rand16() % NUM_BLUE_SIDE_FIRST_NAMES ];

			*lastname = blue_side_last_name_list[ rand16() % NUM_BLUE_SIDE_LAST_NAMES ];

			break;
		}
		case ENTITY_SIDE_RED_FORCE:
		{

			*firstname = red_side_first_name_list[ rand16() % NUM_RED_SIDE_FIRST_NAMES ];

			*lastname = red_side_last_name_list[ rand16() % NUM_RED_SIDE_LAST_NAMES ];

			break;
		}
		default:
		{

			debug_fatal( "Trying to create pilot for side %d", side );
		}
	}
}

void set_cloud_3d_scan_radius ( int scan_radius )
{

	if ( ( scan_radius < 1 ) || ( scan_radius > 32 ) )
	{

		debug_fatal ( "Trying to set cloud scan radius to %d", scan_radius );
	}
	else
	{

		cloud_3d_sector_scan_radius = scan_radius;

		//
		// Now set up the blending constants
		//

		cloud_3d_blend_start = CLOUD_MINIMUM_BLEND_DISTANCE;

		cloud_3d_blend_end = CLOUD_MAXIMUM_BLEND_DISTANCE;

		cloud_3d_blend_distance = cloud_3d_blend_end - cloud_3d_blend_start;

		cloud_3d_blend_start_squared = cloud_3d_blend_start * cloud_3d_blend_start;

		cloud_3d_blend_distance_squared = cloud_3d_blend_distance * cloud_3d_blend_distance;

		cloud_3d_blend_constant = cloud_3d_blend_distance_squared - cloud_3d_blend_start_squared;

		cloud_3d_blend_factor = 1.0 / cloud_3d_blend_distance_squared;
	}
}

void decrease_rocket_salvo_size (void)
{
	switch (rocket_salvo_size)
	{
		////////////////////////////////////////
		case 1:
		////////////////////////////////////////
		{
			break;
		}
		////////////////////////////////////////
		case 2:
		////////////////////////////////////////
		{
			rocket_salvo_size = 1;

			break;
		}
		////////////////////////////////////////
		case 4:
		////////////////////////////////////////
		{
			rocket_salvo_size = 2;

			break;
		}
		////////////////////////////////////////
		case 8:
		////////////////////////////////////////
		{
			rocket_salvo_size = 4;

			break;
		}
		////////////////////////////////////////
		case 16:
		////////////////////////////////////////
		{
			rocket_salvo_size = 8;

			break;
		}
		////////////////////////////////////////
		case ROCKET_SALVO_SIZE_ALL:
		////////////////////////////////////////
		{
			rocket_salvo_size = 16;

			break;
		}
		////////////////////////////////////////
		default:
		////////////////////////////////////////
		{
			debug_fatal ("Invalid rocket salvo size = %d", rocket_salvo_size);

			break;
		}
	}
}

void load_3d_terrain_game_data (void)
{

	char
		filename [1024];

	session_list_data_type
		*session;

	//
	// Load 3d terrain
	//

	unload_3d_terrain ();

	session = get_current_game_session ();

	sprintf (filename, "%s\\terrain", session->data_path);

	if (!load_3d_terrain (filename))
	{

		debug_fatal ("ZONE_FN: unable to load terrain");
	}

	//
	// Load 2d map
	//
	
	load_2d_terrain (session->data_path);
}

static void get_local_vec3d (entity *en, vec3d_types type, vec3d *v)
{
	group
		*raw;

	ASSERT (v);

	raw = (group *) get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case VEC3D_TYPE_POSITION:
		////////////////////////////////////////
		{
			#ifdef DEBUG
			
			debug_fatal ("Invalid call to get group position");

			#endif

			break;
		}
		////////////////////////////////////////
		case VEC3D_TYPE_LAST_KNOWN_POSITION:
		////////////////////////////////////////
		{
			#ifdef DEBUG
			
			debug_fatal ("Invalid call to get group last known position. Use ptr not vec3d copy");

			#endif

			break;
		}
		////////////////////////////////////////
		default:
		////////////////////////////////////////
		{
			debug_fatal_invalid_vec3d_type (en, type);

			break;
		}
	}
}

static void set_eo_view_params(target_acquisition_systems system, int x_min, int y_min, int x_max, int y_max, float xfov, float yfov)
{
	display_3d_light_levels
		light_level;

	display_3d_noise_levels
		noise_level;

	vec3d
		*position;

	weathermodes
		weather_mode;

	day_segment_types
		day_segment_type;

	display_3d_tints
		tint;

	position = get_local_entity_vec3d_ptr (get_gunship_entity (), VEC3D_TYPE_POSITION);

	weather_mode = get_simple_session_weather_at_point (position);
	ASSERT ((weather_mode > WEATHERMODE_INVALID) && (weather_mode < WEATHERMODE_LAST));

	day_segment_type = (day_segment_types) get_local_entity_int_value (get_session_entity (), INT_TYPE_DAY_SEGMENT_TYPE);
	ASSERT ((day_segment_type >= 0) && (day_segment_type < NUM_DAY_SEGMENT_TYPES));

	switch (system)
	{
		case TARGET_ACQUISITION_SYSTEM_FLIR:
		{
			light_level = flir_light_levels[weather_mode][day_segment_type];
			noise_level = flir_noise_levels[weather_mode][day_segment_type];
			tint = DISPLAY_3D_TINT_AMBER;

			break;
		}
		case TARGET_ACQUISITION_SYSTEM_LLLTV:
		{
			light_level = llltv_light_levels[weather_mode][day_segment_type];
			noise_level = llltv_noise_levels[weather_mode][day_segment_type];
			tint = DISPLAY_3D_TINT_AMBER_VISUAL;

			break;
		}
		default:
		{
			debug_fatal ("Invalid target acquisition system = %d", system);

			break;
		}
	}

	set_main_3d_params (tint, light_level, noise_level, x_min, y_min, x_max, y_max, xfov, yfov);
}

object_3d_sub_instance* find_sub_object(object_3d_instance* parent_object, unsigned sub_obj_id)
{
	object_3d_sub_object_search_data
		search;

	const char* name = (sub_obj_id < OBJECT_3D_SUB_OBJECT_LAST) ? object_3d_subobject_names[sub_obj_id] : NULL;

	search.search_depth = 0;
	search.search_object = parent_object;
	search.sub_object_index = sub_obj_id;

	if (find_object_3d_sub_object(&search) != SUB_OBJECT_SEARCH_RESULT_OBJECT_FOUND)
		if (name)
			debug_fatal ("Failed to locate sub object: %s", name);
		else
			debug_fatal ("Failed to locate sub object: %d (illegal id)", sub_obj_id);

	return search.result_sub_object;
}

void safe_fread ( void *data, int element_size, int number_of_elements, FILE *fp )
{

	size_t
		size_read;

	size_read = fread ( data, element_size, number_of_elements, fp );

	if ( feof ( fp ) )
	{

		debug_fatal ( "Read past end of file" );
	}

	if ( ferror ( fp ) )
	{

		debug_fatal ( "Error reading file" );
	}
}

static void deselect_viper_target_acquisition_system (target_acquisition_systems system)
{
	switch (system)
	{
		////////////////////////////////////////
		case TARGET_ACQUISITION_SYSTEM_OFF:
		////////////////////////////////////////
		{
			// laser is on in all modes but OFF in automatic mode
			if (!command_line_manual_laser_radar)
				set_laser_is_active(TRUE);
			
			break;
		}
		////////////////////////////////////////
		case TARGET_ACQUISITION_SYSTEM_FLIR:
		////////////////////////////////////////
		{
			deactivate_common_eo ();

			copy_eo_zoom(&viper_flir, &viper_dtv);

			break;
		}
		////////////////////////////////////////
		case TARGET_ACQUISITION_SYSTEM_DTV:
		////////////////////////////////////////
		{
			deactivate_common_eo ();

			copy_eo_zoom(&viper_dtv, &viper_flir);

			break;
		}
		////////////////////////////////////////
		case TARGET_ACQUISITION_SYSTEM_HIDSS:
		////////////////////////////////////////
		{
			deactivate_common_hms ();

			break;
		}
		////////////////////////////////////////
		default:
		////////////////////////////////////////
		{
			debug_fatal ("Invalid target acquisition system = %d", system);

			break;
		}
	}
}