static void set_local_int_value (entity *en, int_types type, int value)
{
fixed_wing
*raw;
#if DEBUG_MODULE
debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_INT_VALUE, en, type, value);
#endif
raw = get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_OPERATIONAL_STATE:
////////////////////////////////////////
{
int
state1,
state2;
state1 = get_local_entity_int_value (en, INT_TYPE_MOBILE_MOVING);
raw->ac.operational_state = value;
state2 = get_local_entity_int_value (en, INT_TYPE_MOBILE_MOVING);
if ((state1 == FALSE) && (state2 == TRUE))
{
//
// wasn't moving, but is now
//
resume_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_ENGINE_LOOPING1);
}
else if ((state1 == TRUE) && (state2 == FALSE))
{
//
// was moving, but isn't anymore
//
pause_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_ENGINE_LOOPING1, 0.5);
pause_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_ENGINE_LOOPING2, 0.5);
}
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
}
static void set_local_raw_int_value (entity *en, int_types type, int value)
{
waypoint
*raw;
#if DEBUG_MODULE
debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_INT_VALUE, en, type, value);
#endif
raw = get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_ENTITY_SUB_TYPE:
////////////////////////////////////////
{
raw->sub_type = value;
break;
}
////////////////////////////////////////
case INT_TYPE_POSITION_TYPE:
////////////////////////////////////////
{
raw->position_type = value;
break;
}
////////////////////////////////////////
case INT_TYPE_ROUTE_NODE:
////////////////////////////////////////
{
raw->route_node = value;
break;
}
////////////////////////////////////////
case INT_TYPE_WAYPOINT_FORMATION:
////////////////////////////////////////
{
ASSERT (value <= get_formation_database_count ());
raw->waypoint_formation = value;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
}
static void set_local_int_value (entity *en, int_types type, int value)
{
site
*raw;
#if DEBUG_MODULE
debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_INT_VALUE, en, type, value);
#endif
raw = (site *) get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_DAMAGE_LEVEL:
////////////////////////////////////////
{
raw->damage_level = value;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
}
static void set_local_int_value (entity *en, int_types type, int value)
{
city
*raw;
#if DEBUG_MODULE
debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_INT_VALUE, en, type, value);
#endif
raw = (city *) get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_APPROXIMATION_OBJECT_3D_SHAPE:
////////////////////////////////////////
{
raw->approximation_object_3d_shape = value;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
}
static int get_local_int_value (entity *en, int_types type)
{
city
*raw;
int
value;
raw = (city *) get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_APPROXIMATION_OBJECT_3D_SHAPE:
////////////////////////////////////////
{
value = raw->approximation_object_3d_shape;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
return (value);
}
static void set_local_int_value (entity *en, int_types type, int value)
{
weapon
*raw;
#if DEBUG_MODULE
debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_INT_VALUE, en, type, value);
#endif
raw = (weapon *) get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_WEAPON_BURST_SIZE:
////////////////////////////////////////
{
raw->burst_size = value;
break;
}
////////////////////////////////////////
case INT_TYPE_WEAPON_KILL_CODE:
////////////////////////////////////////
{
raw->kill_code = value;
break;
}
////////////////////////////////////////
case INT_TYPE_LOCK_ON_AFTER_LAUNCH:
////////////////////////////////////////
{
raw->loal_mode = value;
break;
}
////////////////////////////////////////
case INT_TYPE_WEAPON_MISSILE_PHASE:
////////////////////////////////////////
{
raw->missile_phase = value;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
}
static void set_local_int_value (entity *en, int_types type, int value)
{
bridge
*raw;
#if DEBUG_MODULE
debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_INT_VALUE, en, type, value);
#endif
raw = get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_ALIVE:
////////////////////////////////////////
{
raw->alive = value;
break;
}
////////////////////////////////////////
case INT_TYPE_ENTITY_SUB_TYPE:
////////////////////////////////////////
{
raw->sub_type = value;
break;
}
////////////////////////////////////////
case INT_TYPE_START_NODE:
////////////////////////////////////////
{
raw->start_node = value;
break;
}
////////////////////////////////////////
case INT_TYPE_END_NODE:
////////////////////////////////////////
{
raw->end_node = value;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
}
static int get_local_int_value (entity *en, int_types type)
{
bridge
*raw;
int
value;
raw = get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_ALIVE:
////////////////////////////////////////
{
value = raw->alive;
break;
}
////////////////////////////////////////
case INT_TYPE_ENTITY_SUB_TYPE:
////////////////////////////////////////
{
value = raw->sub_type;
break;
}
////////////////////////////////////////
case INT_TYPE_START_NODE:
////////////////////////////////////////
{
value = raw->start_node;
break;
}
////////////////////////////////////////
case INT_TYPE_END_NODE:
////////////////////////////////////////
{
value = raw->end_node;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
return (value);
}
static void set_local_raw_int_value (entity *en, int_types type, int value)
{
vehicle
*raw;
#if DEBUG_MODULE
debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_INT_VALUE, en, type, value);
#endif
raw = (vehicle *) get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_OPERATIONAL_STATE:
////////////////////////////////////////
{
raw->operational_state = value;
break;
}
////////////////////////////////////////
case INT_TYPE_SELECTED_WEAPON:
////////////////////////////////////////
{
raw->selected_weapon = value;
break;
}
////////////////////////////////////////
case INT_TYPE_WEAPON_CONFIG_TYPE:
////////////////////////////////////////
{
raw->weapon_config_type = (weapon_config_types) value;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
}
static void set_local_int_value (entity *en, int_types type, int value)
{
particle
*raw;
#if DEBUG_MODULE
debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_INT_VALUE, en, type, value);
#endif
raw = get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_OBJECT_3D_SHAPE:
////////////////////////////////////////
{
raw->object_3d_shape = value;
break;
}
////////////////////////////////////////
case INT_TYPE_PARTICLE_COUNT:
////////////////////////////////////////
{
raw->particle_count = value;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
}
static void set_local_int_value (entity *en, int_types type, int value)
{
smoke_list
*raw;
#if DEBUG_MODULE
debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_INT_VALUE, en, type, value);
#endif
raw = get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_INFINITE_GENERATOR:
////////////////////////////////////////
{
raw->infinite_generator = value;
break;
}
////////////////////////////////////////
case INT_TYPE_SMOKE_TYPE:
////////////////////////////////////////
{
raw->smoke_type = value;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
}
static int get_local_int_value (entity *en, int_types type)
{
smoke_list
*raw;
int
value;
raw = get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_INFINITE_GENERATOR:
////////////////////////////////////////
{
value = raw->infinite_generator;
break;
}
////////////////////////////////////////
case INT_TYPE_SMOKE_TYPE:
////////////////////////////////////////
{
value = raw->smoke_type;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
return (value);
}
static int get_local_int_value (entity *en, int_types type)
{
particle
*raw;
int
value;
raw = get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_OBJECT_3D_SHAPE:
////////////////////////////////////////
{
value = raw->object_3d_shape;
break;
}
////////////////////////////////////////
case INT_TYPE_PARTICLE_COUNT:
////////////////////////////////////////
{
value = raw->particle_count;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
return (value);
}
static int get_local_int_value (entity *en, int_types type)
{
site
*raw;
int
value;
raw = (site *) get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_DAMAGE_LEVEL:
////////////////////////////////////////
{
value = raw->damage_level;
break;
}
////////////////////////////////////////
case INT_TYPE_TASK_TARGET_TYPE:
////////////////////////////////////////
{
value = (TASK_TARGET_TYPE_ANY | TASK_TARGET_TYPE_BUILDING);
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
return (value);
}
static int get_local_int_value (entity *en, int_types type)
{
person
*raw;
int
value;
raw = (person *) get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_MOVEMENT_TYPE:
////////////////////////////////////////
{
value = MOVEMENT_TYPE_GROUND;
break;
}
////////////////////////////////////////
case INT_TYPE_TASK_TARGET_TYPE:
////////////////////////////////////////
{
value = (TASK_TARGET_TYPE_ANY | TASK_TARGET_TYPE_MOBILE | TASK_TARGET_TYPE_VEHICLE | TASK_TARGET_TYPE_PEOPLE);
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
return (value);
}
static int get_local_int_value (entity *en, int_types type)
{
weapon
*raw;
int
value;
raw = get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_DEFAULT_3D_SHAPE:
////////////////////////////////////////
{
value = weapon_database[raw->mob.sub_type].default_3d_shape;
break;
}
////////////////////////////////////////
case INT_TYPE_HARD_DAMAGE_CAPABILITY:
////////////////////////////////////////
{
value = weapon_database[raw->mob.sub_type].hard_damage_capability;
break;
}
////////////////////////////////////////
case INT_TYPE_IDENTIFY_WEAPON:
////////////////////////////////////////
{
value = TRUE;
break;
}
////////////////////////////////////////
case INT_TYPE_SOFT_DAMAGE_CAPABILITY:
////////////////////////////////////////
{
value = weapon_database[raw->mob.sub_type].soft_damage_capability;
break;
}
////////////////////////////////////////
case INT_TYPE_THREAT_TYPE:
////////////////////////////////////////
{
value = weapon_database[raw->mob.sub_type].threat_type;
break;
}
////////////////////////////////////////
case INT_TYPE_VIEWABLE_WEAPON:
////////////////////////////////////////
{
value = weapon_database[raw->mob.sub_type].viewable_weapon;
break;
}
////////////////////////////////////////
case INT_TYPE_WEAPON_BURST_SIZE:
////////////////////////////////////////
{
value = raw->burst_size;
break;
}
////////////////////////////////////////
case INT_TYPE_WEAPON_DECOY_TYPE:
////////////////////////////////////////
{
value = weapon_database[raw->mob.sub_type].decoy_type;
break;
}
////////////////////////////////////////
case INT_TYPE_WEAPON_GUIDANCE_TYPE:
////////////////////////////////////////
{
value = weapon_database[raw->mob.sub_type].guidance_type;
break;
}
////////////////////////////////////////
case INT_TYPE_WEAPON_KILL_CODE:
////////////////////////////////////////
{
value = raw->kill_code;
break;
}
////////////////////////////////////////
case INT_TYPE_WEAPON_SMOKE_TRAIL_TYPE:
////////////////////////////////////////
{
value = weapon_database[raw->mob.sub_type].smoke_trail_type;
break;
}
////////////////////////////////////////
case INT_TYPE_WEAPON_WARHEAD_TYPE:
////////////////////////////////////////
{
value = weapon_database[raw->mob.sub_type].warhead_type;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
return (value);
}
static void set_local_int_value (entity *en, int_types type, int value)
{
landing
*raw;
#if DEBUG_MODULE
debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_INT_VALUE, en, type, value);
#endif
raw = (landing *) get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_ENTITY_SUB_TYPE:
////////////////////////////////////////
{
raw->sub_type = value;
break;
}
////////////////////////////////////////
case INT_TYPE_FREE_LANDING_SITES:
////////////////////////////////////////
{
raw->free_landing_sites = value;
break;
}
////////////////////////////////////////
case INT_TYPE_INSIDE_HANGAR:
////////////////////////////////////////
{
raw->inside_hangar = value;
break;
}
////////////////////////////////////////
case INT_TYPE_LANDED_LOCK:
////////////////////////////////////////
{
raw->landed_lock = value;
break;
}
////////////////////////////////////////
case INT_TYPE_LANDING_LOCK:
////////////////////////////////////////
{
raw->landing_lock = value;
break;
}
////////////////////////////////////////
case INT_TYPE_RESERVED_LANDING_SITES:
////////////////////////////////////////
{
raw->reserved_landing_sites = value;
break;
}
////////////////////////////////////////
case INT_TYPE_ROUTE_NODE:
////////////////////////////////////////
{
raw->route_node = value;
break;
}
////////////////////////////////////////
case INT_TYPE_TOTAL_LANDING_SITES:
////////////////////////////////////////
{
raw->total_landing_sites = value;
break;
}
////////////////////////////////////////
case INT_TYPE_TAKEOFF_LOCK:
////////////////////////////////////////
{
raw->takeoff_lock = value;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
}
static int get_local_int_value (entity *en, int_types type)
{
landing
*raw;
int
value;
raw = (landing *) get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_ENTITY_SUB_TYPE:
////////////////////////////////////////
{
value = raw->sub_type;
break;
}
////////////////////////////////////////
case INT_TYPE_FREE_LANDING_SITES:
////////////////////////////////////////
{
value = raw->free_landing_sites;
break;
}
////////////////////////////////////////
case INT_TYPE_INSIDE_HANGAR:
////////////////////////////////////////
{
value = raw->inside_hangar;
break;
}
////////////////////////////////////////
case INT_TYPE_LANDED_LOCK:
////////////////////////////////////////
{
value = raw->landed_lock;
break;
}
////////////////////////////////////////
case INT_TYPE_LANDING_LOCK:
////////////////////////////////////////
{
value = raw->landing_lock;
break;
}
////////////////////////////////////////
case INT_TYPE_RESERVED_LANDING_SITES:
////////////////////////////////////////
{
value = raw->reserved_landing_sites;
break;
}
////////////////////////////////////////
case INT_TYPE_ROUTE_NODE:
////////////////////////////////////////
{
debug_fatal ("ld_int: can't use route node");
value = raw->route_node;
break;
}
////////////////////////////////////////
case INT_TYPE_TOTAL_LANDING_SITES:
////////////////////////////////////////
{
value = raw->total_landing_sites;
break;
}
////////////////////////////////////////
case INT_TYPE_TAKEOFF_LOCK:
////////////////////////////////////////
{
value = raw->takeoff_lock;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
return (value);
}
static void set_local_int_value (entity *en, int_types type, int value)
{
sector
*raw;
#if DEBUG_MODULE
debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_INT_VALUE, en, type, value);
#endif
raw = get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_KEYSITE_COUNT:
////////////////////////////////////////
{
raw->keysite_count = value;
break;
}
////////////////////////////////////////
case INT_TYPE_SIDE:
////////////////////////////////////////
{
raw->side = value;
#ifdef DEBUG
if (value != ENTITY_SIDE_NEUTRAL)
{
ASSERT (get_game_status () == GAME_STATUS_INITIALISING);
}
#endif
break;
}
////////////////////////////////////////
case INT_TYPE_X_SECTOR:
////////////////////////////////////////
{
raw->x_sector = value;
break;
}
////////////////////////////////////////
case INT_TYPE_Z_SECTOR:
////////////////////////////////////////
{
raw->z_sector = value;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
}
static int get_local_int_value (entity *en, int_types type)
{
fixed_wing
*raw;
int
value;
raw = get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_IDENTIFY_FIXED_WING:
////////////////////////////////////////
{
value = 1;
break;
}
////////////////////////////////////////
case INT_TYPE_RADAR_ON:
////////////////////////////////////////
{
//
// fixed wing aircraft must have an airborne radar and a target for the radar to be on
//
value = FALSE;
if (aircraft_database[raw->ac.mob.sub_type].threat_type == THREAT_TYPE_AIRBORNE_RADAR)
{
if (raw->ac.mob.target_link.parent != NULL)
{
value = TRUE;
}
}
break;
}
////////////////////////////////////////
case INT_TYPE_TASK_TARGET_TYPE:
////////////////////////////////////////
{
if (get_local_entity_int_value (en, INT_TYPE_LANDED))
{
value = (TASK_TARGET_TYPE_ANY | TASK_TARGET_TYPE_MOBILE | TASK_TARGET_TYPE_GROUNDED_AIRCRAFT | TASK_TARGET_TYPE_FIXED_WING);
}
else
{
value = (TASK_TARGET_TYPE_ANY | TASK_TARGET_TYPE_MOBILE | TASK_TARGET_TYPE_AIRBORNE_AIRCRAFT | TASK_TARGET_TYPE_FIXED_WING);
}
break;
}
////////////////////////////////////////
case INT_TYPE_WARHEAD_EFFECTIVE_CLASS:
////////////////////////////////////////
{
value = WARHEAD_EFFECTIVE_FIXED_WING;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
return (value);
}
static void set_local_int_value (entity *en, int_types type, int value)
{
vehicle
*raw;
#if DEBUG_MODULE
debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_INT_VALUE, en, type, value);
#endif
raw = (vehicle *) get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_CPG_IDENTIFIED:
////////////////////////////////////////
{
raw->cpg_identified = value;
break;
}
////////////////////////////////////////
case INT_TYPE_DAMAGE_LEVEL:
////////////////////////////////////////
{
raw->damage_level = value;
break;
}
////////////////////////////////////////
case INT_TYPE_FORMATION_POSITION:
////////////////////////////////////////
{
raw->formation_position = value;
break;
}
////////////////////////////////////////
case INT_TYPE_GROUP_MEMBER_NUMBER:
////////////////////////////////////////
{
ASSERT (value >= 0);
ASSERT (value < (1 << NUM_GROUP_MEMBER_NUMBER_BITS));
raw->group_member_number = value;
break;
}
////////////////////////////////////////
case INT_TYPE_GUNSHIP_RADAR_LOS_CLEAR:
////////////////////////////////////////
{
raw->gunship_radar_los_clear = value;
break;
}
////////////////////////////////////////
case INT_TYPE_ID_NUMBER:
////////////////////////////////////////
{
raw->id_number = value;
break;
}
////////////////////////////////////////
case INT_TYPE_ID_NUMBER_SIGNIFICANT_DIGITS:
////////////////////////////////////////
{
raw->id_number_significant_digits = value;
break;
}
////////////////////////////////////////
case INT_TYPE_LIGHTS_ON:
////////////////////////////////////////
{
raw->lights_on = value;
break;
}
////////////////////////////////////////
case INT_TYPE_LOS_TO_TARGET:
////////////////////////////////////////
{
raw->los_to_target = value;
break;
}
////////////////////////////////////////
case INT_TYPE_OBJECT_3D_SHAPE:
////////////////////////////////////////
{
raw->object_3d_shape = value;
break;
}
////////////////////////////////////////
case INT_TYPE_OPERATIONAL_STATE:
////////////////////////////////////////
{
int
state1,
state2;
day_segment_types
day_segment_type;
state1 = get_local_entity_int_value (en, INT_TYPE_MOBILE_MOVING);
raw->operational_state = value;
state2 = get_local_entity_int_value (en, INT_TYPE_MOBILE_MOVING);
if ((state1 == FALSE) && (state2 == TRUE))
{
//
// wasn't moving, but is now
//
// vehicle wakes
set_infinite_smoke_list_generating_state (en, ENTITY_SUB_TYPE_EFFECT_SMOKE_LIST_VEHICLE_WAKE, INFINITE_SMOKE_ON);
// lights
day_segment_type = (day_segment_types) get_local_entity_int_value (get_session_entity (), INT_TYPE_DAY_SEGMENT_TYPE);
if ((day_segment_type == DAY_SEGMENT_TYPE_NIGHT) || (day_segment_type == DAY_SEGMENT_TYPE_DUSK))
{
set_vehicle_headlight_state (en, ON);
}
// weapons
if (get_comms_model () == COMMS_MODEL_SERVER)
{
set_client_server_entity_int_value (en, INT_TYPE_SELECTED_WEAPON, ENTITY_SUB_TYPE_WEAPON_NO_WEAPON);
}
// sound effects
pause_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_ENGINE_LOOPING1, 0.5);
resume_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_ENGINE_LOOPING2);
}
else if ((state1 == TRUE) && (state2 == FALSE))
{
//
// was moving, but isn't anymore
//
set_infinite_smoke_list_generating_state (en, ENTITY_SUB_TYPE_EFFECT_SMOKE_LIST_VEHICLE_WAKE, INFINITE_SMOKE_OFF);
set_vehicle_headlight_state (en, OFF);
pause_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_ENGINE_LOOPING2, 0.5);
resume_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_ENGINE_LOOPING1);
}
break;
}
////////////////////////////////////////
case INT_TYPE_SELECTED_WEAPON:
////////////////////////////////////////
{
//
// stop continuous sound effect
//
if (raw->selected_weapon != value)
{
pause_local_continuous_weapon_sound_effect (en, raw->selected_weapon);
}
raw->selected_weapon = value;
raw->weapon_burst_timer = 0.0;
break;
}
////////////////////////////////////////
case INT_TYPE_SELECTED_WEAPON_SYSTEM_READY:
////////////////////////////////////////
{
raw->selected_weapon_system_ready = value;
break;
}
////////////////////////////////////////
case INT_TYPE_WEAPON_AND_TARGET_VECTORS_VALID:
////////////////////////////////////////
{
raw->weapon_and_target_vectors_valid = value;
break;
}
////////////////////////////////////////
case INT_TYPE_WEAPON_CONFIG_TYPE:
////////////////////////////////////////
{
raw->weapon_config_type = (weapon_config_types) value;
load_local_entity_weapon_config (en);
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
}
static int get_local_int_value (entity *en, int_types type)
{
sector
*raw;
int
value;
raw = get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_KEYSITE_COUNT:
////////////////////////////////////////
{
value = raw->keysite_count;
break;
}
////////////////////////////////////////
case INT_TYPE_SIDE:
////////////////////////////////////////
{
value = raw->side;
break;
}
////////////////////////////////////////
case INT_TYPE_SECTOR_SIDE:
////////////////////////////////////////
{
if (raw->sector_side [ENTITY_SIDE_BLUE_FORCE] > raw->sector_side [ENTITY_SIDE_RED_FORCE])
{
value = ENTITY_SIDE_BLUE_FORCE;
}
else
{
value = ENTITY_SIDE_RED_FORCE;
}
break;
}
////////////////////////////////////////
case INT_TYPE_X_SECTOR:
////////////////////////////////////////
{
value = raw->x_sector;
break;
}
////////////////////////////////////////
case INT_TYPE_Z_SECTOR:
////////////////////////////////////////
{
value = raw->z_sector;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
return (value);
}
static int get_local_int_value (entity *en, int_types type)
{
keysite
*raw;
int
value;
raw = (keysite *) get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_ALIGN_WITH_TERRAIN:
////////////////////////////////////////
{
value = keysite_database [raw->sub_type].align_with_terrain;
break;
}
////////////////////////////////////////
case INT_TYPE_ALIVE:
////////////////////////////////////////
{
value = raw->alive;
break;
}
////////////////////////////////////////
case INT_TYPE_ENTITY_SUB_TYPE:
////////////////////////////////////////
{
value = raw->sub_type;
break;
}
////////////////////////////////////////
case INT_TYPE_HIDDEN_BY_FOG_OF_WAR:
////////////////////////////////////////
{
value = keysite_database [raw->sub_type].hidden_by_fog_of_war;
break;
}
////////////////////////////////////////
case INT_TYPE_IN_USE:
////////////////////////////////////////
{
value = raw->in_use;
break;
}
////////////////////////////////////////
case INT_TYPE_KEYSITE_ID:
////////////////////////////////////////
{
value = raw->keysite_id;
break;
}
////////////////////////////////////////
case INT_TYPE_KEYSITE_USABLE_STATE:
////////////////////////////////////////
{
value = raw->keysite_usable_state;
break;
}
////////////////////////////////////////
case INT_TYPE_LANDING_TYPES:
////////////////////////////////////////
{
value = raw->landing_types;
break;
}
////////////////////////////////////////
case INT_TYPE_MAP_ICON:
////////////////////////////////////////
{
value = keysite_database [raw->sub_type].map_icon;
break;
}
////////////////////////////////////////
case INT_TYPE_OBJECT_INDEX:
////////////////////////////////////////
{
value = raw->object_index;
break;
}
////////////////////////////////////////
case INT_TYPE_POTENTIAL_CAMPAIGN_OBJECTIVE:
////////////////////////////////////////
{
value = keysite_database [raw->sub_type].campaign_objective;
break;
}
////////////////////////////////////////
case INT_TYPE_SIDE:
////////////////////////////////////////
{
value = raw->side;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
return (value);
}
static int get_local_int_value (entity *en, int_types type)
{
waypoint
*raw;
int
value;
raw = get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_CHECK_WAYPOINT_ACTION:
////////////////////////////////////////
{
value = waypoint_database [raw->sub_type].check_waypoint_action;
break;
}
////////////////////////////////////////
case INT_TYPE_ENTITY_SUB_TYPE:
////////////////////////////////////////
{
value = raw->sub_type;
break;
}
////////////////////////////////////////
case INT_TYPE_IDENTIFY_WAYPOINT:
////////////////////////////////////////
{
value = TRUE;
break;
}
////////////////////////////////////////
case INT_TYPE_MAP_ICON:
////////////////////////////////////////
{
value = waypoint_database [raw->sub_type].map_icon;
break;
}
////////////////////////////////////////
case INT_TYPE_MOBILE_FOLLOW_WAYPOINT_OFFSET:
////////////////////////////////////////
{
value = waypoint_database [raw->sub_type].mobile_follow_waypoint_offset;
break;
}
////////////////////////////////////////
case INT_TYPE_PLANNER_MOVEABLE:
////////////////////////////////////////
{
value = waypoint_database [raw->sub_type].planner_moveable;
break;
}
////////////////////////////////////////
case INT_TYPE_POSITION_TYPE:
////////////////////////////////////////
{
value = raw->position_type;
break;
}
////////////////////////////////////////
case INT_TYPE_ROUTE_NODE:
////////////////////////////////////////
{
value = raw->route_node;
break;
}
////////////////////////////////////////
case INT_TYPE_VERBOSE_OPERATIONAL_STATE:
////////////////////////////////////////
{
value = waypoint_database [raw->sub_type].verbose_operational_state;
break;
}
////////////////////////////////////////
case INT_TYPE_WAYPOINT_FORMATION:
////////////////////////////////////////
{
value = raw->waypoint_formation;
break;
}
////////////////////////////////////////
case INT_TYPE_WAYPOINT_GUIDE_TYPE:
////////////////////////////////////////
{
value = waypoint_database [raw->sub_type].guide_sub_type;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
return (value);
}
static int get_local_int_value (entity *en, int_types type)
{
sound_effect
*raw;
int
value;
raw = (sound_effect *) get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_MAXIMUM_VOLUME:
////////////////////////////////////////
{
// possibly store in entity ??
ASSERT (raw->effect_index);
value = application_sound_effects [raw->effect_index [0]].maximum_volume;
break;
}
////////////////////////////////////////
case INT_TYPE_SIDE:
////////////////////////////////////////
{
value = raw->side;
break;
}
////////////////////////////////////////
case INT_TYPE_SOUND_CHANNEL:
////////////////////////////////////////
{
value = raw->sound_channel;
break;
}
////////////////////////////////////////
case INT_TYPE_SOUND_EFFECT_LOOPING:
////////////////////////////////////////
{
value = raw->looping;
break;
}
////////////////////////////////////////
case INT_TYPE_SOUND_EFFECT_PANNING:
////////////////////////////////////////
{
value = raw->panning;
break;
}
////////////////////////////////////////
case INT_TYPE_SOUND_EFFECT_RATE:
////////////////////////////////////////
{
ASSERT (raw->effect_index);
value = application_sound_effects [raw->effect_index [0]].rate;
break;
}
////////////////////////////////////////
case INT_TYPE_SOUND_EFFECT_SEQUENCE_COUNT:
////////////////////////////////////////
{
value = raw->sound_effect_sequence_count;
break;
}
////////////////////////////////////////
case INT_TYPE_SOUND_LOCALITY:
////////////////////////////////////////
{
value = raw->sound_locality;
break;
}
////////////////////////////////////////
case INT_TYPE_VALID_SOUND_EFFECT:
////////////////////////////////////////
{
value = raw->valid_sound_effect;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
return (value);
}
static int get_local_int_value (entity *en, int_types type)
{
vehicle
*raw;
int
value;
raw = (vehicle *) get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_COLLISION_TEST_MOBILE:
////////////////////////////////////////
{
value = TRUE;
break;
}
////////////////////////////////////////
case INT_TYPE_CPG_IDENTIFIED:
////////////////////////////////////////
{
value = raw->cpg_identified;
break;
}
////////////////////////////////////////
case INT_TYPE_DAMAGE_LEVEL:
////////////////////////////////////////
{
value = raw->damage_level;
break;
}
////////////////////////////////////////
case INT_TYPE_DEFAULT_3D_SHAPE:
////////////////////////////////////////
{
value = vehicle_database[raw->mob.sub_type].default_3d_shape;
break;
}
////////////////////////////////////////
case INT_TYPE_DEFAULT_WEAPON_CONFIG_TYPE:
////////////////////////////////////////
{
value = vehicle_database[raw->mob.sub_type].default_weapon_config_type;
break;
}
////////////////////////////////////////
case INT_TYPE_DEFAULT_WEAPON_TYPE:
////////////////////////////////////////
{
value = vehicle_database[raw->mob.sub_type].default_weapon_type;
break;
}
////////////////////////////////////////
case INT_TYPE_DESTROYED_3D_SHAPE:
////////////////////////////////////////
{
value = get_3d_object_destroyed_object_index (raw->object_3d_shape);
break;
}
////////////////////////////////////////
case INT_TYPE_ENGAGE_ENEMY:
////////////////////////////////////////
{
entity
*group;
value = FALSE;
switch (raw->operational_state)
{
case OPERATIONAL_STATE_LANDED:
{
if (get_local_entity_parent (en, LIST_TYPE_TAKEOFF_QUEUE))
{
//
// Don't engage if waiting to takeoff...
//
break;
}
// deliberate fall-through...
}
case OPERATIONAL_STATE_NAVIGATING:
case OPERATIONAL_STATE_STOPPED:
{
group = get_local_entity_parent (en, LIST_TYPE_MEMBER);
if (group)
{
value = get_local_entity_int_value (group, INT_TYPE_ENGAGE_ENEMY);
}
break;
}
}
break;
}
////////////////////////////////////////
case INT_TYPE_EXPLOSIVE_POWER:
////////////////////////////////////////
{
value = vehicle_database[raw->mob.sub_type].explosive_power;
break;
}
////////////////////////////////////////
case INT_TYPE_EXPLOSIVE_QUALITY:
////////////////////////////////////////
{
value = vehicle_database[raw->mob.sub_type].explosive_quality;
break;
}
////////////////////////////////////////
case INT_TYPE_FORCE:
////////////////////////////////////////
{
value = vehicle_database[raw->mob.sub_type].force;
break;
}
////////////////////////////////////////
case INT_TYPE_FORCE_INFO_CATAGORY:
////////////////////////////////////////
{
value = vehicle_database[raw->mob.sub_type].force_info_catagory;
break;
}
////////////////////////////////////////
case INT_TYPE_FORMATION_POSITION:
////////////////////////////////////////
{
value = raw->formation_position;
break;
}
////////////////////////////////////////
case INT_TYPE_GROUP_LEADER:
////////////////////////////////////////
{
if ((get_local_entity_parent (en, LIST_TYPE_MEMBER)) && (get_local_entity_child_pred (en, LIST_TYPE_MEMBER) == NULL))
{
value = TRUE;
}
else
{
value = FALSE;
}
break;
}
////////////////////////////////////////
case INT_TYPE_GROUP_MEMBER_ID:
////////////////////////////////////////
{
value = raw->group_member_number + 1;
break;
}
////////////////////////////////////////
case INT_TYPE_GROUP_MEMBER_NUMBER:
////////////////////////////////////////
{
value = raw->group_member_number;
break;
}
////////////////////////////////////////
case INT_TYPE_GROUP_MEMBER_STATE:
////////////////////////////////////////
{
entity
*task;
//
// Check Task
//
task = get_local_entity_current_task (en);
if (task)
{
if (get_local_entity_int_value (task, INT_TYPE_ENTITY_SUB_TYPE) == ENTITY_SUB_TYPE_TASK_ENGAGE)
{
value = GROUP_MEMBER_STATE_ATTACKING;
}
else
{
value = GROUP_MEMBER_STATE_NAVIGATING;
}
}
else
{
value = GROUP_MEMBER_STATE_IDLE;
}
break;
}
////////////////////////////////////////
case INT_TYPE_GUNSHIP_RADAR_LOS_CLEAR:
////////////////////////////////////////
{
value = raw->gunship_radar_los_clear;
break;
}
////////////////////////////////////////
case INT_TYPE_IDENTIFY_VEHICLE:
////////////////////////////////////////
{
value = TRUE;
break;
}
////////////////////////////////////////
case INT_TYPE_ID_NUMBER:
////////////////////////////////////////
{
value = raw->id_number;
break;
}
////////////////////////////////////////
case INT_TYPE_ID_NUMBER_SIGNIFICANT_DIGITS:
////////////////////////////////////////
{
value = raw->id_number_significant_digits;
break;
}
////////////////////////////////////////
case INT_TYPE_INITIAL_DAMAGE_LEVEL:
////////////////////////////////////////
{
value = vehicle_database[raw->mob.sub_type].initial_damage_level;
break;
}
////////////////////////////////////////
case INT_TYPE_LANDED:
////////////////////////////////////////
{
switch (raw->operational_state)
{
case OPERATIONAL_STATE_LANDED:
//case OPERATIONAL_STATE_REPAIRING:
//case OPERATIONAL_STATE_REARMING:
//case OPERATIONAL_STATE_REFUELING:
{
value = TRUE;
break;
}
case OPERATIONAL_STATE_STOPPED:
case OPERATIONAL_STATE_UNKNOWN:
case OPERATIONAL_STATE_WAITING:
case OPERATIONAL_STATE_ASLEEP:
case OPERATIONAL_STATE_DEAD:
case OPERATIONAL_STATE_DYING:
case OPERATIONAL_STATE_LANDING:
case OPERATIONAL_STATE_LANDING_HOLDING:
case OPERATIONAL_STATE_NAVIGATING:
case OPERATIONAL_STATE_TAKEOFF:
case OPERATIONAL_STATE_TAKEOFF_HOLDING:
case OPERATIONAL_STATE_TAXIING:
{
value = FALSE;
break;
}
default:
{
debug_fatal ("VH_INT: unknown operational state");
}
}
break;
}
////////////////////////////////////////
case INT_TYPE_LIGHTS_ON:
////////////////////////////////////////
{
value = raw->lights_on;
break;
}
////////////////////////////////////////
case INT_TYPE_LOS_TO_TARGET:
////////////////////////////////////////
{
value = raw->los_to_target;
break;
}
////////////////////////////////////////
case INT_TYPE_MAP_ICON:
////////////////////////////////////////
{
value = vehicle_database [raw->mob.sub_type].map_icon;
break;
}
////////////////////////////////////////
case INT_TYPE_MAX_WEAPON_CONFIG_TYPE:
////////////////////////////////////////
{
value = vehicle_database[raw->mob.sub_type].max_weapon_config_type;
break;
}
////////////////////////////////////////
case INT_TYPE_MIN_WEAPON_CONFIG_TYPE:
////////////////////////////////////////
{
value = vehicle_database[raw->mob.sub_type].min_weapon_config_type;
break;
}
////////////////////////////////////////
case INT_TYPE_MOBILE_MOVING:
////////////////////////////////////////
{
switch (raw->operational_state)
{
case OPERATIONAL_STATE_ASLEEP:
case OPERATIONAL_STATE_DEAD:
case OPERATIONAL_STATE_LANDED:
case OPERATIONAL_STATE_STOPPED:
case OPERATIONAL_STATE_UNKNOWN:
case OPERATIONAL_STATE_WAITING:
{
value = FALSE;
break;
}
case OPERATIONAL_STATE_DYING:
case OPERATIONAL_STATE_LANDING:
case OPERATIONAL_STATE_LANDING_HOLDING:
case OPERATIONAL_STATE_NAVIGATING:
case OPERATIONAL_STATE_TAKEOFF:
case OPERATIONAL_STATE_TAKEOFF_HOLDING:
case OPERATIONAL_STATE_TAXIING:
{
value = TRUE;
break;
}
default:
{
debug_fatal ("VH_INT: unknown operational state");
}
}
break;
}
////////////////////////////////////////
case INT_TYPE_OBJECT_3D_SHAPE:
////////////////////////////////////////
{
value = raw->object_3d_shape;
break;
}
////////////////////////////////////////
case INT_TYPE_OFFENSIVE_CAPABILITY:
////////////////////////////////////////
{
value = vehicle_database[raw->mob.sub_type].offensive_capability;
break;
}
////////////////////////////////////////
case INT_TYPE_OPERATIONAL_STATE:
////////////////////////////////////////
{
value = raw->operational_state;
break;
}
////////////////////////////////////////
case INT_TYPE_POINTS_VALUE:
////////////////////////////////////////
{
value = vehicle_database [raw->mob.sub_type].points_value;
break;
}
////////////////////////////////////////
case INT_TYPE_RADAR_ON:
////////////////////////////////////////
{
//
// vehicles must have radar and a target for the radar to be on
//
value = FALSE;
if (vehicle_database[raw->mob.sub_type].threat_type != THREAT_TYPE_INVALID)
{
if (raw->mob.target_link.parent != NULL)
{
value = TRUE;
}
}
break;
}
////////////////////////////////////////
case INT_TYPE_SELECTED_WEAPON:
////////////////////////////////////////
{
value = raw->selected_weapon;
break;
}
////////////////////////////////////////
case INT_TYPE_SELECTED_WEAPON_SYSTEM_READY:
////////////////////////////////////////
{
value = raw->selected_weapon_system_ready;
break;
}
////////////////////////////////////////
case INT_TYPE_TARGET_PRIORITY_TYPE:
////////////////////////////////////////
{
value = vehicle_database[raw->mob.sub_type].target_priority_type;
break;
}
////////////////////////////////////////
case INT_TYPE_TARGET_SYMBOL_TYPE:
////////////////////////////////////////
{
value = vehicle_database[raw->mob.sub_type].target_symbol_type;
break;
}
////////////////////////////////////////
case INT_TYPE_TARGET_TYPE:
////////////////////////////////////////
{
value = vehicle_database[raw->mob.sub_type].target_type;
break;
}
////////////////////////////////////////
case INT_TYPE_TASK_LEADER:
////////////////////////////////////////
{
entity
*guide;
value = FALSE;
guide = get_local_entity_parent (en, LIST_TYPE_FOLLOWER);
if (guide)
{
if (get_local_entity_ptr_value (guide, PTR_TYPE_TASK_LEADER) == en)
{
value = TRUE;
}
}
break;
}
////////////////////////////////////////
case INT_TYPE_TASK_TARGET_TYPE:
////////////////////////////////////////
{
value = (TASK_TARGET_TYPE_ANY | TASK_TARGET_TYPE_MOBILE | TASK_TARGET_TYPE_VEHICLE);
break;
}
////////////////////////////////////////
case INT_TYPE_THREAT_TYPE:
////////////////////////////////////////
{
value = vehicle_database[raw->mob.sub_type].threat_type;
break;
}
////////////////////////////////////////
case INT_TYPE_TRACK_ENTITY_ON_MAP:
////////////////////////////////////////
{
value = TRUE;
break;
}
////////////////////////////////////////
case INT_TYPE_VIEW_CATEGORY:
////////////////////////////////////////
{
value = vehicle_database[raw->mob.sub_type].view_category;
break;
}
////////////////////////////////////////
case INT_TYPE_VIEW_TYPE:
////////////////////////////////////////
{
value = vehicle_database[raw->mob.sub_type].view_type;
break;
}
////////////////////////////////////////
case INT_TYPE_VIEWABLE:
////////////////////////////////////////
{
value = raw->view_link.parent != NULL;
break;
}
////////////////////////////////////////
case INT_TYPE_WARHEAD_EFFECTIVE_CLASS:
////////////////////////////////////////
{
value = vehicle_database[raw->mob.sub_type].warhead_effective_class;
break;
}
////////////////////////////////////////
case INT_TYPE_WEAPON_AND_TARGET_VECTORS_VALID:
////////////////////////////////////////
{
value = raw->weapon_and_target_vectors_valid;
break;
}
////////////////////////////////////////
case INT_TYPE_WEAPON_CONFIG_TYPE:
////////////////////////////////////////
{
value = raw->weapon_config_type;
break;
}
////////////////////////////////////////
case INT_TYPE_WEAPON_SYSTEM_READY:
////////////////////////////////////////
{
////////////////////////////////////////
//
// WARNING! This only returns a valid value for vehicles that have weapon
// systems to be made ready in the current weapons configuration.
//
////////////////////////////////////////
if (get_local_entity_float_value (en, FLOAT_TYPE_WEAPON_SYSTEM_READY_STATE) == VEHICLE_WEAPON_SYSTEM_READY_OPEN_FLOAT_VALUE)
{
value = TRUE;
}
else
{
value = FALSE;
}
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
return (value);
}
static void set_local_int_value (entity *en, int_types type, int value)
{
keysite
*raw;
#if DEBUG_MODULE
debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_INT_VALUE, en, type, value);
#endif
raw = (keysite *) get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_ALIVE:
////////////////////////////////////////
{
raw->alive = value;
break;
}
////////////////////////////////////////
case INT_TYPE_ENTITY_SUB_TYPE:
////////////////////////////////////////
{
raw->sub_type = value;
break;
}
////////////////////////////////////////
case INT_TYPE_IN_USE:
////////////////////////////////////////
{
raw->in_use = value;
break;
}
////////////////////////////////////////
case INT_TYPE_KEYSITE_ID:
////////////////////////////////////////
{
raw->keysite_id = value;
break;
}
////////////////////////////////////////
case INT_TYPE_KEYSITE_USABLE_STATE:
////////////////////////////////////////
{
raw->keysite_usable_state = value;
break;
}
////////////////////////////////////////
case INT_TYPE_LANDING_TYPES:
////////////////////////////////////////
{
raw->landing_types = value;
break;
}
////////////////////////////////////////
case INT_TYPE_OBJECT_INDEX:
////////////////////////////////////////
{
raw->object_index = value;
break;
}
////////////////////////////////////////
case INT_TYPE_SIDE:
////////////////////////////////////////
{
raw->side = value;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
}
static void set_local_int_value (entity *en, int_types type, int value)
{
sound_effect
*raw;
#if DEBUG_MODULE
debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_INT_VALUE, en, type, value);
#endif
raw = (sound_effect *) get_local_entity_data (en);
switch (type)
{
////////////////////////////////////////
case INT_TYPE_SIDE:
////////////////////////////////////////
{
raw->side = value;
break;
}
////////////////////////////////////////
case INT_TYPE_SOUND_CHANNEL:
////////////////////////////////////////
{
raw->sound_channel = value;
break;
}
////////////////////////////////////////
case INT_TYPE_SOUND_EFFECT_LOOPING:
////////////////////////////////////////
{
raw->looping = value;
break;
}
////////////////////////////////////////
case INT_TYPE_SOUND_EFFECT_PANNING:
////////////////////////////////////////
{
raw->panning = value;
break;
}
////////////////////////////////////////
case INT_TYPE_SOUND_EFFECT_SEQUENCE_COUNT:
////////////////////////////////////////
{
raw->sound_effect_sequence_count = value;
break;
}
////////////////////////////////////////
case INT_TYPE_SOUND_LOCALITY:
////////////////////////////////////////
{
raw->sound_locality = value;
break;
}
////////////////////////////////////////
case INT_TYPE_VALID_SOUND_EFFECT:
////////////////////////////////////////
{
raw->valid_sound_effect = value;
break;
}
////////////////////////////////////////
default:
////////////////////////////////////////
{
debug_fatal_invalid_int_type (en, type);
break;
}
}
}
