Example #1
0
static float get_local_float_value (entity *en, float_types type)
{
	pylon
		*raw;

	float
		value;

	raw = get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_AVOIDANCE_RADIUS:
		////////////////////////////////////////
		{
			value = 50.0;

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

			break;
		}
	}

	return (value);
}
Example #2
0
static float get_local_float_value (entity *en, float_types type)
{
	camera
		*raw;

	float
		value;

	raw = (camera *) get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_RADAR_ALTITUDE:
		////////////////////////////////////////
		{
			value = max (raw->position.y - get_3d_terrain_point_data_elevation (&raw->terrain_info), 0.0f);

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

			break;
		}
	}

	return (value);
}
Example #3
0
static void set_local_float_value (entity *en, float_types type, float value)
{
	sector
		*raw;

	#if DEBUG_MODULE

	debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_FLOAT_VALUE, en, type, value);

	#endif

	raw = get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		default:
		////////////////////////////////////////
		{
			debug_fatal_invalid_float_type (en, type);

			break;
		}
	}
}
Example #4
0
static void set_local_float_value (entity *en, float_types type, float value)
{
    person
    *raw;

#if DEBUG_MODULE

    debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_FLOAT_VALUE, en, type, value);

#endif

    raw = (person *) get_local_entity_data (en);

    switch (type)
    {
    ////////////////////////////////////////
    case FLOAT_TYPE_PERSON_ANIMATION_STATE:
        ////////////////////////////////////////
    {
        raw->person_animation_state = value;

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

        break;
    }
    }
}
Example #5
0
static void set_local_float_value (entity *en, float_types type, float value)
{
	fixed
		*raw;

	#if DEBUG_MODULE

	debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_FLOAT_VALUE, en, type, value);

	#endif

	raw = get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_HEADING:
		////////////////////////////////////////
		{
			raw->heading = value;

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

			break;
		}
	}
}
Example #6
0
static float get_local_float_value (entity *en, float_types type)
{
    person
    *raw;

    float
    value;

    raw = (person *) get_local_entity_data (en);

    switch (type)
    {
    ////////////////////////////////////////
    case FLOAT_TYPE_PERSON_ANIMATION_STATE:
        ////////////////////////////////////////
    {
        value = raw->person_animation_state;

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

        break;
    }
    }

    return (value);
}
Example #7
0
static float get_local_float_value (entity *en, float_types type)
{
	sector
		*raw;

	float
		value;

	raw = get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_TALLEST_STRUCTURE_HEIGHT:
		////////////////////////////////////////
		{
			value = raw->tallest_structure_height;

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

			break;
		}
	}

	return (value);
}
Example #8
0
static void set_local_float_value (entity *en, float_types type, float value)
{
	mobile
		*raw;

	#if DEBUG_MODULE

	debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_FLOAT_VALUE, en, type, value);

	#endif

	raw = (mobile *) get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_HEADING:
		////////////////////////////////////////
		{

			matrix3x3
				attitude;

			float
				pitch,
				roll;

			pitch = get_pitch_from_attitude_matrix (raw->attitude);

			roll = get_roll_from_attitude_matrix (raw->attitude);

			get_3d_transformation_matrix (attitude, value, pitch, roll);

			set_local_entity_attitude_matrix (en, attitude);

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_HIGH_VELOCITY:
		case FLOAT_TYPE_LOW_VELOCITY:
		case FLOAT_TYPE_MEDIUM_VELOCITY:
		case FLOAT_TYPE_VELOCITY:
		case FLOAT_TYPE_VERY_HIGH_VELOCITY:
		////////////////////////////////////////
		{
			raw->velocity = value;

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

			break;
		}
	}
}
Example #9
0
static float get_local_float_value (entity *en, float_types type)
{
	mobile
		*raw;

	float
		value;

	raw = (mobile *) get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_ALTITUDE:
		////////////////////////////////////////
		{
			value = raw->position.y;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_HEADING:
		////////////////////////////////////////
		{
			value = get_heading_from_attitude_matrix (raw->attitude);

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_HIGH_VELOCITY:
		case FLOAT_TYPE_LOW_VELOCITY:
		case FLOAT_TYPE_MEDIUM_VELOCITY:
		case FLOAT_TYPE_VELOCITY:
		case FLOAT_TYPE_VERY_HIGH_VELOCITY:
		////////////////////////////////////////
		{
			value = raw->velocity;

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

			break;
		}
	}

	return (value);
}
Example #10
0
static void set_local_float_value (entity *en, float_types type, float value)
{
	site_updatable
		*raw;

	#if DEBUG_MODULE

	debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_FLOAT_VALUE, en, type, value);

	#endif

	raw = get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_LOADING_DOOR_STATE:
		////////////////////////////////////////
		{
			raw->loading_door_state = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_RADAR_ROTATION_STATE:
		////////////////////////////////////////
		{
			raw->radar_rotation_state = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_LOADING_DOOR_TIMER:
		////////////////////////////////////////
		{
			raw->loading_door_timer = value;

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

			break;
		}
	}
}
Example #11
0
static float get_local_float_value (entity *en, float_types type)
{
	bridge
		*raw;

	float
		value;

	raw = (bridge *) get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_PITCH:
		////////////////////////////////////////
		{
			value = raw->pitch;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_RECON_DISTANCE:
		////////////////////////////////////////
		{
			value = 800.0;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_SCALE:
		////////////////////////////////////////
		{
			value = raw->scale;

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

			break;
		}
	}

	return (value);
}
Example #12
0
static float get_local_float_value (entity *en, float_types type)
{
	camera
		*raw;

	float
		value;

	raw = get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_HEADING:
		////////////////////////////////////////
		{
			value = get_heading_from_attitude_matrix (raw->attitude);

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_PITCH:
		////////////////////////////////////////
		{
			value = get_pitch_from_attitude_matrix (raw->attitude);

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_ROLL:
		////////////////////////////////////////
		{
			value = get_roll_from_attitude_matrix (raw->attitude);

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

			break;
		}
	}

	return (value);
}
Example #13
0
static void set_local_float_value (entity *en, float_types type, float value)
{
	bridge
		*raw;

	#if DEBUG_MODULE

	debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_FLOAT_VALUE, en, type, value);

	#endif

	raw = (bridge *) get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_PITCH:
		////////////////////////////////////////
		{
			raw->pitch = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_SCALE:
		////////////////////////////////////////
		{
			raw->scale = value;

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

			break;
		}
	}
}
Example #14
0
static float get_local_float_value (entity *en, float_types type)
{
	task
		*raw;

	float
		value;

	raw = get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_ELAPSED_MISSION_TIME:
		////////////////////////////////////////
		{
			if (raw->task_state == TASK_STATE_ASSIGNED)
			{
				ASSERT (get_session_entity ());

				value = get_local_entity_float_value (get_session_entity (), FLOAT_TYPE_ELAPSED_TIME) - raw->start_time;
			}
			else
			{
				value = 0.0;
			}

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_EXPIRE_TIMER:
		////////////////////////////////////////
		{
			value = raw->expire_timer;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_RATING:
		////////////////////////////////////////
		{
			value = raw->rating;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_START_TIME:
		////////////////////////////////////////
		{
			value = raw->start_time;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_STOP_TIMER:
		////////////////////////////////////////
		{
			value = raw->stop_timer;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_TASK_DEFAULT_PRIORITY:
		////////////////////////////////////////
		{
			value = task_database [raw->sub_type].task_priority;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_TASK_PRIORITY:
		////////////////////////////////////////
		{
			value = raw->task_priority;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_TASK_USER_DATA:
		////////////////////////////////////////
		{
			value = raw->task_user_data;

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

			break;
		}
	}

	return (value);
}
Example #15
0
static float get_local_float_value (entity *en, float_types type)
{
	sprite
		*raw;

	float
		value;

	raw = get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_ANIMATION_FREQUENCY:
		////////////////////////////////////////
		{
			value = raw->animation_frequency;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_EFFECT_LIFETIME:
		////////////////////////////////////////
		{
			value = raw->effect_lifetime;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_END_SCALE:
		////////////////////////////////////////
		{
			value = raw->end_scale;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_SPRITE_LIFETIME:
		////////////////////////////////////////
		{
			value = raw->sprite_lifetime;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_START_SCALE:
		////////////////////////////////////////
		{
			value = raw->start_scale;

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

			break;
		}
	}

	return (value);
}
Example #16
0
static float get_local_float_value (entity *en, float_types type)
{
	site_updatable
		*raw;

	float
		value;

	raw = get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_AVOIDANCE_RADIUS:
		////////////////////////////////////////
		{
			object_3d_bounds
				*bounding_box;

			bounding_box = get_object_3d_bounding_box_without_lines (raw->fix.object_3d_shape);

			value = max (50.0, (2.0 * bounding_box->ymax));

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_LOADING_DOOR_STATE:
		////////////////////////////////////////
		{
			value = raw->loading_door_state;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_RADAR_ROTATION_STATE:
		////////////////////////////////////////
		{
			value = raw->radar_rotation_state;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_LOADING_DOOR_TIMER:
		////////////////////////////////////////
		{
			value = raw->loading_door_timer;

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

			break;
		}
	}

	return (value);
}
Example #17
0
static void set_local_float_value (entity *en, float_types type, float value)
{
	sprite
		*raw;

	#if DEBUG_MODULE

	debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_FLOAT_VALUE, en, type, value);

	#endif

	raw = get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_ANIMATION_FREQUENCY:
		////////////////////////////////////////
		{
			raw->animation_frequency = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_EFFECT_LIFETIME:
		////////////////////////////////////////
		{
			raw->effect_lifetime = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_END_SCALE:
		////////////////////////////////////////
		{
			raw->end_scale = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_SPRITE_LIFETIME:
		////////////////////////////////////////
		{
			raw->sprite_lifetime = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_START_SCALE:
		////////////////////////////////////////
		{
			raw->start_scale = value;

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

			break;
		}
	}
}
Example #18
0
static float get_local_float_value (entity *en, float_types type)
{
	fixed
		*raw;

	float
		value;

	raw = get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_ALTITUDE:
		////////////////////////////////////////
		{
			value = raw->position.y;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_FIXED_OBJECT_IMPORTANCE:
		////////////////////////////////////////
		{
			value = fixed_3d_object_database[raw->object_3d_shape].importance;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_FIXED_STRUCTURE_HEIGHT:
		////////////////////////////////////////
		{
			object_3d_bounds
				*bounding_box;

			if (raw->object_3d_shape != OBJECT_3D_INVALID_OBJECT_INDEX)
			{
				bounding_box = get_object_3d_bounding_box (raw->object_3d_shape);

				value = bounding_box->ymax;
			}

			break;
		}

		////////////////////////////////////////
		case FLOAT_TYPE_HEADING:
		////////////////////////////////////////
		{
			value = raw->heading;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MAX_3D_OBJECT_VISUAL_RANGE:
		////////////////////////////////////////
		{
			value = object_3d_information_database[raw->object_3d_shape].maximum_distance;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_TARGET_PRIORITY_AIR_ATTACK:
		////////////////////////////////////////
		{
			//
			// Target priority is object importance - scaled down so any mobile threats have higher priority
			//
			
			value = get_local_entity_float_value (en, FLOAT_TYPE_FIXED_OBJECT_IMPORTANCE);

			value *= 0.25;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_TARGET_PRIORITY_GROUND_ATTACK:
		////////////////////////////////////////
		{
			//
			// Target priority is object importance - scaled down so any mobile threats have higher priority
			//
			
			value = get_local_entity_float_value (en, FLOAT_TYPE_FIXED_OBJECT_IMPORTANCE);

			value *= 0.25;

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

			break;
		}
	}

	return (value);
}
Example #19
0
static void set_local_float_value (entity *en, float_types type, float value)
{
	smoke_list
		*raw;

	#if DEBUG_MODULE

	debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_FLOAT_VALUE, en, type, value);

	#endif

	raw = (smoke_list *) get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_FREQUENCY:
		////////////////////////////////////////
		{
			raw->frequency = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_GENERATOR_LIFETIME:
		////////////////////////////////////////
		{
			raw->generator_lifetime = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_SMOKE_LIFETIME:
		////////////////////////////////////////
		{
			raw->smoke_lifetime = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_WIDTH_ADJUSTMENT:
		////////////////////////////////////////
		{
			raw->width_adjustment = value;

			break;
		}
		////////////////////////////////////////
		// Xhit: added for downwash effect. (030328)
		case FLOAT_TYPE_SCALE:
		////////////////////////////////////////
		{
			raw->scale = value;

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

			break;
		}
	}
}
Example #20
0
static float get_local_float_value (entity *en, float_types type)
{
	helicopter
		*raw;

	float
		value;

	raw = (helicopter *) get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_FUEL_SUPPLY_LEVEL:
		////////////////////////////////////////
		{
			value = raw->fuel_supply_level;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_INVULNERABLE_TIMER:
		////////////////////////////////////////
		{
			value = raw->invulnerable_timer;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MAIN_ROTOR_BLADE_CONING_ANGLE:
		////////////////////////////////////////
		{
			value = raw->main_rotor_blade_coning_angle;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MAIN_ROTOR_PITCH:
		////////////////////////////////////////
		{
			value = raw->main_rotor_pitch;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MAIN_ROTOR_ROLL:
		////////////////////////////////////////
		{
			value = raw->main_rotor_roll;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MAIN_ROTOR_RPM:
		////////////////////////////////////////
		{
			value = raw->main_rotor_rpm;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MAIN_ROTOR_SPIN_UP_TIMER:
		////////////////////////////////////////
		{
			value = raw->main_rotor_spin_up_timer;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_RADAR_STEALTH_FACTOR:
		////////////////////////////////////////
		{
			value = NO_RADAR_STEALTH_FACTOR;

			if (raw->ac.mob.sub_type == ENTITY_SUB_TYPE_AIRCRAFT_RAH66_COMANCHE)
			{
				if (!get_comanche_stub_wings_attached (en))
				{
					if (get_local_entity_weapon_system_ready_state (en) == WEAPON_SYSTEM_READY_CLOSED)
					{
						value -= NO_RADAR_STEALTH_FACTOR * 0.5;
					}

					if (get_local_entity_undercarriage_state (en) == AIRCRAFT_UNDERCARRIAGE_UP)
					{
						value -= NO_RADAR_STEALTH_FACTOR * 0.35;
					}
				}
			}

			ASSERT (value > 0.0);

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_TAIL_ROTOR_RPM:
		////////////////////////////////////////
		{
			value = raw->tail_rotor_rpm;

			break;
		}
		////////////////////////////////////////
		
		// Jabberwock 050310 MP Cannon bug
		case FLOAT_TYPE_PLAYER_WEAPON_HEADING:
		////////////////////////////////////////
		{
			value = raw->player_weapon_heading;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_PLAYER_WEAPON_PITCH:
		////////////////////////////////////////
		{
			value = raw->player_weapon_pitch;

			break;
		}
		// Jabberwock 050310 ends
		////////////////////////////////////////
		default:
		////////////////////////////////////////
		{
			debug_fatal_invalid_float_type (en, type);

			break;
		}
	}

	return (value);
}
Example #21
0
static void set_local_float_value (entity *en, float_types type, float value)
{
	aircraft
		*raw;

	#if DEBUG_MODULE

	debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_FLOAT_VALUE, en, type, value);

	#endif

	raw = (aircraft *) get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_AIR_RADAR_CONTACT_TIMEOUT:
		////////////////////////////////////////
		{
			raw->air_radar_contact_timeout = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_CARGO_DOOR_STATE:
		////////////////////////////////////////
		{
			raw->cargo_door_state = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_DEATH_TIMER:
		////////////////////////////////////////
		{
			raw->death_timer = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_DISTANCE:
		////////////////////////////////////////
		{
			raw->distance = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_LOADING_DOOR_STATE:
		////////////////////////////////////////
		{
			raw->loading_door_state = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_RUDDER_STATE:
		////////////////////////////////////////
		{
			raw->rudder_state = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_UNDERCARRIAGE_STATE:
		////////////////////////////////////////
		{
			raw->undercarriage_state = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_VIEW_INTEREST_LEVEL:
		////////////////////////////////////////
		{
			raw->view_interest_level = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_WEAPON_BURST_TIMER:
		////////////////////////////////////////
		{
			raw->weapon_burst_timer = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_WEAPON_SYSTEM_READY_STATE:
		////////////////////////////////////////
		{
			raw->weapon_system_ready_state = value;

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

			break;
		}
	}
}
Example #22
0
static float get_local_float_value (entity *en, float_types type)
{
	smoke_list
		*raw;

	float
		value;

	raw = (smoke_list *) get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_FREQUENCY:
		////////////////////////////////////////
		{
			value = raw->frequency;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_GENERATOR_LIFETIME:
		////////////////////////////////////////
		{
			value = raw->generator_lifetime;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_SMOKE_LIFETIME:
		////////////////////////////////////////
		{
			value = raw->smoke_lifetime;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_WIDTH_ADJUSTMENT:
		////////////////////////////////////////
		{
			value = raw->width_adjustment;

			break;
		}
		////////////////////////////////////////
		//Xhit: added for downwash effect. (030328)
		case FLOAT_TYPE_SCALE:
		////////////////////////////////////////
		{
			value = raw->scale;

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

			break;
		}
	}

	return (value);
}
Example #23
0
static void set_local_float_value (entity *en, float_types type, float value)
{
	group
		*raw;

	#if DEBUG_MODULE

	debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_FLOAT_VALUE, en, type, value);

	#endif

	raw = (group *) get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_AMMO_SUPPLY_LEVEL:
		////////////////////////////////////////
		{
			raw->supplies.ammo_supply_level = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_ASSIST_TIMER:
		////////////////////////////////////////
		{
			raw->assist_timer = value;

			if ((value != 0.0) && (!raw->update_link.parent))
			{

				insert_local_entity_into_parents_child_list (en, LIST_TYPE_UPDATE, get_update_entity (), NULL);
			}

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_FUEL_SUPPLY_LEVEL:
		////////////////////////////////////////
		{
			raw->supplies.fuel_supply_level = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_SLEEP:
		////////////////////////////////////////
		{
			raw->sleep = value;

			if ((value != 0.0) && (!raw->update_link.parent))
			{

				insert_local_entity_into_parents_child_list (en, LIST_TYPE_UPDATE, get_update_entity (), NULL);
			}

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_LAST_SEEN_TIME:
		////////////////////////////////////////
		{
			raw->last_seen_time = value;

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

			break;
		}
	}
}
Example #24
0
static float get_local_float_value (entity *en, float_types type)
{
	aircraft
		*raw;

	float
		value;

	raw = (aircraft *) get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_AIR_RADAR_CONTACT_TIMEOUT:
		////////////////////////////////////////
		{
			value = raw->air_radar_contact_timeout;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_AIR_SCAN_RANGE:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].air_scan_range;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_AMMO_ECONOMY:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].ammo_economy;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_ATTACK_ALTITUDE:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].attack_altitude;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_AVOIDANCE_RADIUS:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].avoidance_radius;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_CARGO_DOOR_STATE:
		////////////////////////////////////////
		{
			value = raw->cargo_door_state;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_CENTRE_OF_GRAVITY_TO_GROUND_DISTANCE:
		////////////////////////////////////////
		{
			if (raw->mob.alive)
			{
				value = aircraft_database[raw->mob.sub_type].centre_of_gravity_to_ground_distance;
			}
			else
			{
				value = aircraft_database[raw->mob.sub_type].centre_of_gravity_to_ground_distance_destroyed;
			}

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_CHASE_VIEW_MAX_DISTANCE:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].chase_view_max_distance;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_CHASE_VIEW_MAX_DISTANCE_TEST:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].chase_view_max_distance_test;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_CHASE_VIEW_MIN_DISTANCE:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].chase_view_min_distance;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_CHASE_VIEW_MIN_DISTANCE_TEST:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].chase_view_min_distance_test;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_CRUISE_ALTITUDE:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].cruise_altitude;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_CRUISE_VELOCITY:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].cruise_velocity;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_DEATH_TIMER:
		////////////////////////////////////////
		{
			value = raw->death_timer;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_DISTANCE:
		////////////////////////////////////////
		{
			value = raw->distance;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_FUEL_DEFAULT_WEIGHT:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].fuel_default_weight;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_FUEL_ECONOMY:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].fuel_economy;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_FUSELAGE_ANGLE:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].fuselage_angle;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_LOADING_DOOR_STATE:
		////////////////////////////////////////
		{
			value = raw->loading_door_state;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MAIN_ROTOR_DIRECTION:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].main_rotor_direction;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MAIN_ROTOR_BLADE_DROOP_ANGLE:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].main_rotor_blade_droop_angle;

			break;
		}
		////////////////////////////////////////
		// Xhit: added FLOAT_TYPE_MAIN_ROTOR_RADIUS for downwash effect (030328)
		case FLOAT_TYPE_MAIN_ROTOR_RADIUS:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].main_rotor_radius;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MAIN_ROTOR_SHAFT_ANGLE:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].main_rotor_shaft_angle;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MAX_3D_OBJECT_VISUAL_RANGE:
		////////////////////////////////////////
		{
			value = object_3d_information_database[raw->object_3d_shape].maximum_distance;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MAX_TURN_RATE:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].max_turn_rate;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MAX_ROLL:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].max_roll;

			break;
		}
		// Xhit: added FLOAT_TYPE_NUMBER_OF_MAIN_ROTORS for downwash effect (030328)
		case FLOAT_TYPE_NUMBER_OF_MAIN_ROTORS:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].number_of_main_rotors;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MAX_VERTICAL_TURN_ALLOWANCE:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].max_vertical_turn_allowance;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_POTENTIAL_AIR_THREAT:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].potential_air_to_air_threat;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_POTENTIAL_AIR_TO_AIR_THREAT:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].potential_air_to_air_threat;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_POTENTIAL_AIR_TO_SURFACE_THREAT:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].potential_air_to_surface_threat;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_POTENTIAL_SURFACE_THREAT:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].potential_air_to_surface_threat;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_PROPELLOR_DIRECTION:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].propellor_direction;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_RADAR_ALTITUDE:
		////////////////////////////////////////
		{
			value = max (raw->mob.position.y - get_3d_terrain_point_data_elevation (&raw->terrain_info), 0.0f);

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_RECON_RADIUS:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].recon_radius;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_RUDDER_STATE:
		////////////////////////////////////////
		{
			value = raw->rudder_state;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_SURFACE_SCAN_RANGE:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].surface_scan_range;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_TAIL_ROTOR_DIRECTION:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].tail_rotor_direction;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_TARGET_PRIORITY_AIR_ATTACK:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].potential_air_to_air_threat;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_TARGET_PRIORITY_GROUND_ATTACK:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].potential_air_to_surface_threat;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_TARGET_SCAN_DELAY:
		////////////////////////////////////////
		{
			value = aircraft_database[raw->mob.sub_type].target_scan_delay;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_TARGET_SCAN_TIMER:
		////////////////////////////////////////
		{
			value = raw->target_scan_timer;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_TERRAIN_ELEVATION:
		////////////////////////////////////////
		{
			value = get_3d_terrain_point_data_elevation (&raw->terrain_info);

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_UNDERCARRIAGE_STATE:
		////////////////////////////////////////
		{
			value = raw->undercarriage_state;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_VIEW_INTEREST_LEVEL:
		////////////////////////////////////////
		{
			value = raw->view_interest_level;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_WEAPON_BURST_TIMER:
		////////////////////////////////////////
		{
			value = raw->weapon_burst_timer;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_WEAPON_SYSTEM_READY_STATE:
		////////////////////////////////////////
		{
			value = raw->weapon_system_ready_state;

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

			break;
		}
	}

	return (value);
}
Example #25
0
static float get_local_float_value (entity *en, float_types type)
{
	group
		*raw;

	float
		value;

	raw = (group *) get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_AMMO_SUPPLY_LEVEL:
		////////////////////////////////////////
		{
			value = raw->supplies.ammo_supply_level;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_ASSIST_TIMER:
		////////////////////////////////////////
		{
			value = raw->assist_timer;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_FUEL_SUPPLY_LEVEL:
		////////////////////////////////////////
		{
			value = raw->supplies.fuel_supply_level;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_REARMING_TIME:
		////////////////////////////////////////
		{
			value = group_database [raw->sub_type].rearming_time;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_RECON_DISTANCE:
		////////////////////////////////////////
		{
			value = 100.0;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_SLEEP:
		////////////////////////////////////////
		{
			value = raw->sleep;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_LAST_SEEN_TIME:
		////////////////////////////////////////
		{
			value = raw->last_seen_time;

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

			break;
		}
	}

	return (value);
}
Example #26
0
static void set_local_float_value (entity *en, float_types type, float value)
{
	helicopter
		*raw;

	#if DEBUG_MODULE

	debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_FLOAT_VALUE, en, type, value);

	#endif

	raw = (helicopter *) get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_FUEL_SUPPLY_LEVEL:
		////////////////////////////////////////
		{

			raw->fuel_supply_level = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_INVULNERABLE_TIMER:
		////////////////////////////////////////
		{
			raw->invulnerable_timer = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MAIN_ROTOR_BLADE_CONING_ANGLE:
		////////////////////////////////////////
		{
			raw->main_rotor_blade_coning_angle = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MAIN_ROTOR_PITCH:
		////////////////////////////////////////
		{
			raw->main_rotor_pitch = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MAIN_ROTOR_ROLL:
		////////////////////////////////////////
		{
			raw->main_rotor_roll = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MAIN_ROTOR_RPM:
		////////////////////////////////////////
		{
			raw->main_rotor_rpm = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MAIN_ROTOR_SPIN_UP_TIMER:
		////////////////////////////////////////
		{
			raw->main_rotor_spin_up_timer = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_TAIL_ROTOR_RPM:
		////////////////////////////////////////
		{
			raw->tail_rotor_rpm = value;

			break;
		}
		////////////////////////////////////////
		
		// Jabberwock 050310 MP Cannon bug
		case FLOAT_TYPE_PLAYER_WEAPON_HEADING:
		////////////////////////////////////////
		{
			raw->player_weapon_heading = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_PLAYER_WEAPON_PITCH:
		////////////////////////////////////////
		{
			raw->player_weapon_pitch = value;

			break;
		}
		// Jabberwock 050310 ends
		////////////////////////////////////////
		default:
		////////////////////////////////////////
		{
			debug_fatal_invalid_float_type (en, type);

			break;
		}
	}
}
Example #27
0
static void set_local_float_value (entity *en, float_types type, float value)
{
	task
		*raw;

	#if DEBUG_MODULE

	debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_FLOAT_VALUE, en, type, value);

	#endif

	raw = get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_EXPIRE_TIMER:
		////////////////////////////////////////
		{
			raw->expire_timer = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_RATING:
		////////////////////////////////////////
		{
			raw->rating = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_START_TIME:
		////////////////////////////////////////
		{
			raw->start_time = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_STOP_TIMER:
		////////////////////////////////////////
		{
			raw->stop_timer = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_TASK_PRIORITY:
		////////////////////////////////////////
		{
			raw->task_priority = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_TASK_USER_DATA:
		////////////////////////////////////////
		{
			raw->task_user_data = value;

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

			break;
		}
	}
}
Example #28
0
static float get_local_float_value (entity *en, float_types type)
{
	keysite
		*raw;

	float
		value;

	raw = get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_AMMO_SUPPLY_LEVEL:
		////////////////////////////////////////
		{
			value = raw->supplies.ammo_supply_level;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_ASSIGN_TIMER:
		////////////////////////////////////////
		{
			value = raw->assign_timer;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_ASSIST_TIMER:
		////////////////////////////////////////
		{
			value = raw->assist_timer;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_EFFICIENCY:
		////////////////////////////////////////
		{
			if (raw->keysite_maximum_strength > 0.0)
			{
				ASSERT (raw->keysite_strength <= raw->keysite_maximum_strength);

				value = raw->keysite_strength / raw->keysite_maximum_strength;
			}
			else
			{
				value = 1.0;
			}

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_FUEL_SUPPLY_LEVEL:
		////////////////////////////////////////
		{
			value = raw->supplies.fuel_supply_level;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_MINIMUM_EFFICIENCY:
		////////////////////////////////////////
		{
			value = keysite_database [raw->sub_type].minimum_efficiency;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_KEYSITE_IMPORTANCE:
		////////////////////////////////////////
		{
			value = keysite_database [raw->sub_type].importance;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_KEYSITE_MAXIMUM_STRENGTH:
		////////////////////////////////////////
		{
			value = raw->keysite_maximum_strength;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_KEYSITE_STRENGTH:
		////////////////////////////////////////
		{
			value = raw->keysite_strength;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_RECON_DISTANCE:
		////////////////////////////////////////
		{
			value = keysite_database [raw->sub_type].recon_distance;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_REPAIR_TIMER:
		////////////////////////////////////////
		{
			value = raw->repair_timer;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_SECTOR_SIDE_MAX_VALUE:
		////////////////////////////////////////
		{
			value = keysite_database [raw->sub_type].sector_side_max_value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_SLEEP:
		////////////////////////////////////////
		{
			value = raw->sleep;

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

			break;
		}
	}

	return (value);
}
Example #29
0
static void set_local_float_value (entity *en, float_types type, float value)
{
	keysite
		*raw;

	#if DEBUG_MODULE

	debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_FLOAT_VALUE, en, type, value);

	#endif

	raw = get_local_entity_data (en);

	switch (type)
	{
		////////////////////////////////////////
		case FLOAT_TYPE_AMMO_SUPPLY_LEVEL:
		////////////////////////////////////////
		{
			raw->supplies.ammo_supply_level = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_ASSIGN_TIMER:
		////////////////////////////////////////
		{
			raw->assign_timer = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_ASSIST_TIMER:
		////////////////////////////////////////
		{
			raw->assist_timer = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_FUEL_SUPPLY_LEVEL:
		////////////////////////////////////////
		{
			raw->supplies.fuel_supply_level = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_KEYSITE_MAXIMUM_STRENGTH:
		////////////////////////////////////////
		{
			raw->keysite_maximum_strength = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_KEYSITE_STRENGTH:
		////////////////////////////////////////
		{
			raw->keysite_strength = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_REPAIR_TIMER:
		////////////////////////////////////////
		{
			raw->repair_timer = value;

			break;
		}
		////////////////////////////////////////
		case FLOAT_TYPE_SLEEP:
		////////////////////////////////////////
		{
			raw->sleep = value;

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

			break;
		}
	}
}